drivers/usb/host/whci/qset.c

   1 /*
   2  * Wireless Host Controller (WHC) qset management.
   3  *
   4  * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License version
   8  * 2 as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 #include <linux/kernel.h>
  19 #include <linux/dma-mapping.h>
  20 #include <linux/uwb/umc.h>
  21 #include <linux/usb.h>
  22
  23 #include "../../wusbcore/wusbhc.h"
  24
  25 #include "whcd.h"
  26
  27 struct whc_qset *qset_alloc(struct whc *whc, gfp_t mem_flags)
  28 {
  29         struct whc_qset *qset;
  30         dma_addr_t dma;
  31
  32         qset = dma_pool_alloc(whc->qset_pool, mem_flags, &dma);
  33         if (qset == NULL)
  34                 return NULL;
  35         memset(qset, 0, sizeof(struct whc_qset));
  36
  37         qset->qset_dma = dma;
  38         qset->whc = whc;
  39
  40         INIT_LIST_HEAD(&qset->list_node);
  41         INIT_LIST_HEAD(&qset->stds);
  42
  43         return qset;
  44 }
  45
  46 /**
  47  * qset_fill_qh - fill the static endpoint state in a qset's QHead
  48  * @qset: the qset whose QH needs initializing with static endpoint
  49  *        state
  50  * @urb:  an urb for a transfer to this endpoint
  51  */
  52 static void qset_fill_qh(struct whc_qset *qset, struct urb *urb)
  53 {
  54         struct usb_device *usb_dev = urb->dev;
  55         struct usb_wireless_ep_comp_descriptor *epcd;
  56         bool is_out;
  57
  58         is_out = usb_pipeout(urb->pipe);
  59
  60         epcd = (struct usb_wireless_ep_comp_descriptor *)qset->ep->extra;
  61
  62         if (epcd) {
  63                 qset->max_seq = epcd->bMaxSequence;
  64                 qset->max_burst = epcd->bMaxBurst;
  65         } else {
  66                 qset->max_seq = 2;
  67                 qset->max_burst = 1;
  68         }
  69
  70         qset->qh.info1 = cpu_to_le32(
  71                 QH_INFO1_EP(usb_pipeendpoint(urb->pipe))
  72                 | (is_out ? QH_INFO1_DIR_OUT : QH_INFO1_DIR_IN)
  73                 | usb_pipe_to_qh_type(urb->pipe)
  74                 | QH_INFO1_DEV_INFO_IDX(wusb_port_no_to_idx(usb_dev->portnum))
  75                 | QH_INFO1_MAX_PKT_LEN(usb_maxpacket(urb->dev, urb->pipe, is_out))
  76                 );
  77         qset->qh.info2 = cpu_to_le32(
  78                 QH_INFO2_BURST(qset->max_burst)
  79                 | QH_INFO2_DBP(0)
  80                 | QH_INFO2_MAX_COUNT(3)
  81                 | QH_INFO2_MAX_RETRY(3)
  82                 | QH_INFO2_MAX_SEQ(qset->max_seq - 1)
  83                 );
  84         /* FIXME: where can we obtain these Tx parameters from?  Why
  85          * doesn't the chip know what Tx power to use? It knows the Rx
  86          * strength and can presumably guess the Tx power required
  87          * from that? */
  88         qset->qh.info3 = cpu_to_le32(
  89                 QH_INFO3_TX_RATE_53_3
  90                 | QH_INFO3_TX_PWR(0) /* 0 == max power */
  91                 );
  92
  93         qset->qh.cur_window = cpu_to_le32((1 << qset->max_burst) - 1);
  94 }
  95
  96 /**
  97  * qset_clear - clear fields in a qset so it may be reinserted into a
  98  * schedule.
  99  *
 100  * The sequence number and current window are not cleared (see
 101  * qset_reset()).
 102  */
 103 void qset_clear(struct whc *whc, struct whc_qset *qset)
 104 {
 105         qset->td_start = qset->td_end = qset->ntds = 0;
 106         qset->remove = 0;
 107
 108         qset->qh.link = cpu_to_le32(QH_LINK_NTDS(8) | QH_LINK_T);
 109         qset->qh.status = qset->qh.status & QH_STATUS_SEQ_MASK;
 110         qset->qh.err_count = 0;
 111         qset->qh.scratch[0] = 0;
 112         qset->qh.scratch[1] = 0;
 113         qset->qh.scratch[2] = 0;
 114
 115         memset(&qset->qh.overlay, 0, sizeof(qset->qh.overlay));
 116
 117         init_completion(&qset->remove_complete);
 118 }
 119
 120 /**
 121  * qset_reset - reset endpoint state in a qset.
 122  *
 123  * Clears the sequence number and current window.  This qset must not
 124  * be in the ASL or PZL.
 125  */
 126 void qset_reset(struct whc *whc, struct whc_qset *qset)
 127 {
 128         wait_for_completion(&qset->remove_complete);
 129
 130         qset->qh.status &= ~QH_STATUS_SEQ_MASK;
 131         qset->qh.cur_window = cpu_to_le32((1 << qset->max_burst) - 1);
 132 }
 133
 134 /**
 135  * get_qset - get the qset for an async endpoint
 136  *
 137  * A new qset is created if one does not already exist.
 138  */
 139 struct whc_qset *get_qset(struct whc *whc, struct urb *urb,
 140                                  gfp_t mem_flags)
 141 {
 142         struct whc_qset *qset;
 143
 144         qset = urb->ep->hcpriv;
 145         if (qset == NULL) {
 146                 qset = qset_alloc(whc, mem_flags);
 147                 if (qset == NULL)
 148                         return NULL;
 149
 150                 qset->ep = urb->ep;
 151                 urb->ep->hcpriv = qset;
 152                 qset_fill_qh(qset, urb);
 153         }
 154         return qset;
 155 }
 156
 157 void qset_remove_complete(struct whc *whc, struct whc_qset *qset)
 158 {
 159         list_del_init(&qset->list_node);
 160         complete(&qset->remove_complete);
 161 }
 162
 163 /**
 164  * qset_add_qtds - add qTDs for an URB to a qset
 165  *
 166  * Returns true if the list (ASL/PZL) must be updated because (for a
 167  * WHCI 0.95 controller) an activated qTD was pointed to be iCur.
 168  */
 169 enum whc_update qset_add_qtds(struct whc *whc, struct whc_qset *qset)
 170 {
 171         struct whc_std *std;
 172         enum whc_update update = 0;
 173
 174         list_for_each_entry(std, &qset->stds, list_node) {
 175                 struct whc_qtd *qtd;
 176                 uint32_t status;
 177
 178                 if (qset->ntds >= WHCI_QSET_TD_MAX
 179                     || (qset->pause_after_urb && std->urb != qset->pause_after_urb))
 180                         break;
 181
 182                 if (std->qtd)
 183                         continue; /* already has a qTD */
 184
 185                 qtd = std->qtd = &qset->qtd[qset->td_end];
 186
 187                 /* Fill in setup bytes for control transfers. */
 188                 if (usb_pipecontrol(std->urb->pipe))
 189                         memcpy(qtd->setup, std->urb->setup_packet, 8);
 190
 191                 status = QTD_STS_ACTIVE | QTD_STS_LEN(std->len);
 192
 193                 if (whc_std_last(std) && usb_pipeout(std->urb->pipe))
 194                         status |= QTD_STS_LAST_PKT;
 195
 196                 /*
 197                  * For an IN transfer the iAlt field should be set so
 198                  * the h/w will automatically advance to the next
 199                  * transfer. However, if there are 8 or more TDs
 200                  * remaining in this transfer then iAlt cannot be set
 201                  * as it could point to somewhere in this transfer.
 202                  */
 203                 if (std->ntds_remaining < WHCI_QSET_TD_MAX) {
 204                         int ialt;
 205                         ialt = (qset->td_end + std->ntds_remaining) % WHCI_QSET_TD_MAX;
 206                         status |= QTD_STS_IALT(ialt);
 207                 } else if (usb_pipein(std->urb->pipe))
 208                         qset->pause_after_urb = std->urb;
 209
 210                 if (std->num_pointers)
 211                         qtd->options = cpu_to_le32(QTD_OPT_IOC);
 212                 else
 213                         qtd->options = cpu_to_le32(QTD_OPT_IOC | QTD_OPT_SMALL);
 214                 qtd->page_list_ptr = cpu_to_le64(std->dma_addr);
 215
 216                 qtd->status = cpu_to_le32(status);
 217
 218                 if (QH_STATUS_TO_ICUR(qset->qh.status) == qset->td_end)
 219                         update = WHC_UPDATE_UPDATED;
 220
 221                 if (++qset->td_end >= WHCI_QSET_TD_MAX)
 222                         qset->td_end = 0;
 223                 qset->ntds++;
 224         }
 225
 226         return update;
 227 }
 228
 229 /**
 230  * qset_remove_qtd - remove the first qTD from a qset.
 231  *
 232  * The qTD might be still active (if it's part of a IN URB that
 233  * resulted in a short read) so ensure it's deactivated.
 234  */
 235 static void qset_remove_qtd(struct whc *whc, struct whc_qset *qset)
 236 {
 237         qset->qtd[qset->td_start].status = 0;
 238
 239         if (++qset->td_start >= WHCI_QSET_TD_MAX)
 240                 qset->td_start = 0;
 241         qset->ntds--;
 242 }
 243
 244 /**
 245  * qset_free_std - remove an sTD and free it.
 246  * @whc: the WHCI host controller
 247  * @std: the sTD to remove and free.
 248  */
 249 void qset_free_std(struct whc *whc, struct whc_std *std)
 250 {
 251         list_del(&std->list_node);
 252         if (std->num_pointers) {
 253                 dma_unmap_single(whc->wusbhc.dev, std->dma_addr,
 254                                  std->num_pointers * sizeof(struct whc_page_list_entry),
 255                                  DMA_TO_DEVICE);
 256                 kfree(std->pl_virt);
 257         }
 258
 259         kfree(std);
 260 }
 261
 262 /**
 263  * qset_remove_qtds - remove an URB's qTDs (and sTDs).
 264  */
 265 static void qset_remove_qtds(struct whc *whc, struct whc_qset *qset,
 266                              struct urb *urb)
 267 {
 268         struct whc_std *std, *t;
 269
 270         list_for_each_entry_safe(std, t, &qset->stds, list_node) {
 271                 if (std->urb != urb)
 272                         break;
 273                 if (std->qtd != NULL)
 274                         qset_remove_qtd(whc, qset);
 275                 qset_free_std(whc, std);
 276         }
 277 }
 278
 279 /**
 280  * qset_free_stds - free any remaining sTDs for an URB.
 281  */
 282 static void qset_free_stds(struct whc_qset *qset, struct urb *urb)
 283 {
 284         struct whc_std *std, *t;
 285
 286         list_for_each_entry_safe(std, t, &qset->stds, list_node) {
 287                 if (std->urb == urb)
 288                         qset_free_std(qset->whc, std);
 289         }
 290 }
 291
 292 static int qset_fill_page_list(struct whc *whc, struct whc_std *std, gfp_t mem_flags)
 293 {
 294         dma_addr_t dma_addr = std->dma_addr;
 295         dma_addr_t sp, ep;
 296         size_t std_len = std->len;
 297         size_t pl_len;
 298         int p;
 299
 300         sp = ALIGN(dma_addr, WHCI_PAGE_SIZE);
 301         ep = dma_addr + std_len;
 302         std->num_pointers = DIV_ROUND_UP(ep - sp, WHCI_PAGE_SIZE);
 303
 304         pl_len = std->num_pointers * sizeof(struct whc_page_list_entry);
 305         std->pl_virt = kmalloc(pl_len, mem_flags);
 306         if (std->pl_virt == NULL)
 307                 return -ENOMEM;
 308         std->dma_addr = dma_map_single(whc->wusbhc.dev, std->pl_virt, pl_len, DMA_TO_DEVICE);
 309
 310         for (p = 0; p < std->num_pointers; p++) {
 311                 std->pl_virt[p].buf_ptr = cpu_to_le64(dma_addr);
 312                 dma_addr = ALIGN(dma_addr + WHCI_PAGE_SIZE, WHCI_PAGE_SIZE);
 313         }
 314
 315         return 0;
 316 }
 317
 318 /**
 319  * urb_dequeue_work - executes asl/pzl update and gives back the urb to the system.
 320  */
 321 static void urb_dequeue_work(struct work_struct *work)
 322 {
 323         struct whc_urb *wurb = container_of(work, struct whc_urb, dequeue_work);
 324         struct whc_qset *qset = wurb->qset;
 325         struct whc *whc = qset->whc;
 326         unsigned long flags;
 327
 328         if (wurb->is_async == true)
 329                 asl_update(whc, WUSBCMD_ASYNC_UPDATED
 330                            | WUSBCMD_ASYNC_SYNCED_DB
 331                            | WUSBCMD_ASYNC_QSET_RM);
 332         else
 333                 pzl_update(whc, WUSBCMD_PERIODIC_UPDATED
 334                            | WUSBCMD_PERIODIC_SYNCED_DB
 335                            | WUSBCMD_PERIODIC_QSET_RM);
 336
 337         spin_lock_irqsave(&whc->lock, flags);
 338         qset_remove_urb(whc, qset, wurb->urb, wurb->status);
 339         spin_unlock_irqrestore(&whc->lock, flags);
 340 }
 341
 342 /**
 343  * qset_add_urb - add an urb to the qset's queue.
 344  *
 345  * The URB is chopped into sTDs, one for each qTD that will required.
 346  * At least one qTD (and sTD) is required even if the transfer has no
 347  * data (e.g., for some control transfers).
 348  */
 349 int qset_add_urb(struct whc *whc, struct whc_qset *qset, struct urb *urb,
 350         gfp_t mem_flags)
 351 {
 352         struct whc_urb *wurb;
 353         int remaining = urb->transfer_buffer_length;
 354         u64 transfer_dma = urb->transfer_dma;
 355         int ntds_remaining;
 356
 357         ntds_remaining = DIV_ROUND_UP(remaining, QTD_MAX_XFER_SIZE);
 358         if (ntds_remaining == 0)
 359                 ntds_remaining = 1;
 360
 361         wurb = kzalloc(sizeof(struct whc_urb), mem_flags);
 362         if (wurb == NULL)
 363                 goto err_no_mem;
 364         urb->hcpriv = wurb;
 365         wurb->qset = qset;
 366         wurb->urb = urb;
 367         INIT_WORK(&wurb->dequeue_work, urb_dequeue_work);
 368
 369         while (ntds_remaining) {
 370                 struct whc_std *std;
 371                 size_t std_len;
 372
 373                 std = kmalloc(sizeof(struct whc_std), mem_flags);
 374                 if (std == NULL)
 375                         goto err_no_mem;
 376
 377                 std_len = remaining;
 378                 if (std_len > QTD_MAX_XFER_SIZE)
 379                         std_len = QTD_MAX_XFER_SIZE;
 380
 381                 std->urb = urb;
 382                 std->dma_addr = transfer_dma;
 383                 std->len = std_len;
 384                 std->ntds_remaining = ntds_remaining;
 385                 std->qtd = NULL;
 386
 387                 INIT_LIST_HEAD(&std->list_node);
 388                 list_add_tail(&std->list_node, &qset->stds);
 389
 390                 if (std_len > WHCI_PAGE_SIZE) {
 391                         if (qset_fill_page_list(whc, std, mem_flags) < 0)
 392                                 goto err_no_mem;
 393                 } else
 394                         std->num_pointers = 0;
 395
 396                 ntds_remaining--;
 397                 remaining -= std_len;
 398                 transfer_dma += std_len;
 399         }
 400
 401         return 0;
 402
 403 err_no_mem:
 404         qset_free_stds(qset, urb);
 405         return -ENOMEM;
 406 }
 407
 408 /**
 409  * qset_remove_urb - remove an URB from the urb queue.
 410  *
 411  * The URB is returned to the USB subsystem.
 412  */
 413 void qset_remove_urb(struct whc *whc, struct whc_qset *qset,
 414                             struct urb *urb, int status)
 415 {
 416         struct wusbhc *wusbhc = &whc->wusbhc;
 417         struct whc_urb *wurb = urb->hcpriv;
 418
 419         usb_hcd_unlink_urb_from_ep(&wusbhc->usb_hcd, urb);
 420         /* Drop the lock as urb->complete() may enqueue another urb. */
 421         spin_unlock(&whc->lock);
 422         wusbhc_giveback_urb(wusbhc, urb, status);
 423         spin_lock(&whc->lock);
 424
 425         kfree(wurb);
 426 }
 427
 428 /**
 429  * get_urb_status_from_qtd - get the completed urb status from qTD status
 430  * @urb:    completed urb
 431  * @status: qTD status
 432  */
 433 static int get_urb_status_from_qtd(struct urb *urb, u32 status)
 434 {
 435         if (status & QTD_STS_HALTED) {
 436                 if (status & QTD_STS_DBE)
 437                         return usb_pipein(urb->pipe) ? -ENOSR : -ECOMM;
 438                 else if (status & QTD_STS_BABBLE)
 439                         return -EOVERFLOW;
 440                 else if (status & QTD_STS_RCE)
 441                         return -ETIME;
 442                 return -EPIPE;
 443         }
 444         if (usb_pipein(urb->pipe)
 445             && (urb->transfer_flags & URB_SHORT_NOT_OK)
 446             && urb->actual_length < urb->transfer_buffer_length)
 447                 return -EREMOTEIO;
 448         return 0;
 449 }
 450
 451 /**
 452  * process_inactive_qtd - process an inactive (but not halted) qTD.
 453  *
 454  * Update the urb with the transfer bytes from the qTD, if the urb is
 455  * completely transfered or (in the case of an IN only) the LPF is
 456  * set, then the transfer is complete and the urb should be returned
 457  * to the system.
 458  */
 459 void process_inactive_qtd(struct whc *whc, struct whc_qset *qset,
 460                                  struct whc_qtd *qtd)
 461 {
 462         struct whc_std *std = list_first_entry(&qset->stds, struct whc_std, list_node);
 463         struct urb *urb = std->urb;
 464         uint32_t status;
 465         bool complete;
 466
 467         status = le32_to_cpu(qtd->status);
 468
 469         urb->actual_length += std->len - QTD_STS_TO_LEN(status);
 470
 471         if (usb_pipein(urb->pipe) && (status & QTD_STS_LAST_PKT))
 472                 complete = true;
 473         else
 474                 complete = whc_std_last(std);
 475
 476         qset_remove_qtd(whc, qset);
 477         qset_free_std(whc, std);
 478
 479         /*
 480          * Transfers for this URB are complete?  Then return it to the
 481          * USB subsystem.
 482          */
 483         if (complete) {
 484                 qset_remove_qtds(whc, qset, urb);
 485                 qset_remove_urb(whc, qset, urb, get_urb_status_from_qtd(urb, status));
 486
 487                 /*
 488                  * If iAlt isn't valid then the hardware didn't
 489                  * advance iCur. Adjust the start and end pointers to
 490                  * match iCur.
 491                  */
 492                 if (!(status & QTD_STS_IALT_VALID))
 493                         qset->td_start = qset->td_end
 494                                 = QH_STATUS_TO_ICUR(le16_to_cpu(qset->qh.status));
 495                 qset->pause_after_urb = NULL;
 496         }
 497 }
 498
 499 /**
 500  * process_halted_qtd - process a qset with a halted qtd
 501  *
 502  * Remove all the qTDs for the failed URB and return the failed URB to
 503  * the USB subsystem.  Then remove all other qTDs so the qset can be
 504  * removed.
 505  *
 506  * FIXME: this is the point where rate adaptation can be done.  If a
 507  * transfer failed because it exceeded the maximum number of retries
 508  * then it could be reactivated with a slower rate without having to
 509  * remove the qset.
 510  */
 511 void process_halted_qtd(struct whc *whc, struct whc_qset *qset,
 512                                struct whc_qtd *qtd)
 513 {
 514         struct whc_std *std = list_first_entry(&qset->stds, struct whc_std, list_node);
 515         struct urb *urb = std->urb;
 516         int urb_status;
 517
 518         urb_status = get_urb_status_from_qtd(urb, le32_to_cpu(qtd->status));
 519
 520         qset_remove_qtds(whc, qset, urb);
 521         qset_remove_urb(whc, qset, urb, urb_status);
 522
 523         list_for_each_entry(std, &qset->stds, list_node) {
 524                 if (qset->ntds == 0)
 525                         break;
 526                 qset_remove_qtd(whc, qset);
 527                 std->qtd = NULL;
 528         }
 529
 530         qset->remove = 1;
 531 }
 532
 533 void qset_free(struct whc *whc, struct whc_qset *qset)
 534 {
 535         dma_pool_free(whc->qset_pool, qset, qset->qset_dma);
 536 }
 537
 538 /**
 539  * qset_delete - wait for a qset to be unused, then free it.
 540  */
 541 void qset_delete(struct whc *whc, struct whc_qset *qset)
 542 {
 543         wait_for_completion(&qset->remove_complete);
 544         qset_free(whc, qset);
 545 }