git.oblomov.eu Git - linux-2.6/blob - 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
  94 /**
  95  * qset_clear - clear fields in a qset so it may be reinserted into a
  96  * schedule
  97  */
  98 void qset_clear(struct whc *whc, struct whc_qset *qset)
  99 {
 100         qset->td_start = qset->td_end = qset->ntds = 0;
 101         qset->remove = 0;
 102
 103         qset->qh.link = cpu_to_le32(QH_LINK_NTDS(8) | QH_LINK_T);
 104         qset->qh.status = cpu_to_le16(QH_STATUS_ICUR(qset->td_start));
 105         qset->qh.err_count = 0;
 106         qset->qh.cur_window = cpu_to_le32((1 << qset->max_burst) - 1);
 107         qset->qh.scratch[0] = 0;
 108         qset->qh.scratch[1] = 0;
 109         qset->qh.scratch[2] = 0;
 110
 111         memset(&qset->qh.overlay, 0, sizeof(qset->qh.overlay));
 112
 113         init_completion(&qset->remove_complete);
 114 }
 115
 116 /**
 117  * get_qset - get the qset for an async endpoint
 118  *
 119  * A new qset is created if one does not already exist.
 120  */
 121 struct whc_qset *get_qset(struct whc *whc, struct urb *urb,
 122                                  gfp_t mem_flags)
 123 {
 124         struct whc_qset *qset;
 125
 126         qset = urb->ep->hcpriv;
 127         if (qset == NULL) {
 128                 qset = qset_alloc(whc, mem_flags);
 129                 if (qset == NULL)
 130                         return NULL;
 131
 132                 qset->ep = urb->ep;
 133                 urb->ep->hcpriv = qset;
 134                 qset_fill_qh(qset, urb);
 135         }
 136         return qset;
 137 }
 138
 139 void qset_remove_complete(struct whc *whc, struct whc_qset *qset)
 140 {
 141         list_del_init(&qset->list_node);
 142         complete(&qset->remove_complete);
 143 }
 144
 145 /**
 146  * qset_add_qtds - add qTDs for an URB to a qset
 147  *
 148  * Returns true if the list (ASL/PZL) must be updated because (for a
 149  * WHCI 0.95 controller) an activated qTD was pointed to be iCur.
 150  */
 151 enum whc_update qset_add_qtds(struct whc *whc, struct whc_qset *qset)
 152 {
 153         struct whc_std *std;
 154         enum whc_update update = 0;
 155
 156         list_for_each_entry(std, &qset->stds, list_node) {
 157                 struct whc_qtd *qtd;
 158                 uint32_t status;
 159
 160                 if (qset->ntds >= WHCI_QSET_TD_MAX
 161                     || (qset->pause_after_urb && std->urb != qset->pause_after_urb))
 162                         break;
 163
 164                 if (std->qtd)
 165                         continue; /* already has a qTD */
 166
 167                 qtd = std->qtd = &qset->qtd[qset->td_end];
 168
 169                 /* Fill in setup bytes for control transfers. */
 170                 if (usb_pipecontrol(std->urb->pipe))
 171                         memcpy(qtd->setup, std->urb->setup_packet, 8);
 172
 173                 status = QTD_STS_ACTIVE | QTD_STS_LEN(std->len);
 174
 175                 if (whc_std_last(std) && usb_pipeout(std->urb->pipe))
 176                         status |= QTD_STS_LAST_PKT;
 177
 178                 /*
 179                  * For an IN transfer the iAlt field should be set so
 180                  * the h/w will automatically advance to the next
 181                  * transfer. However, if there are 8 or more TDs
 182                  * remaining in this transfer then iAlt cannot be set
 183                  * as it could point to somewhere in this transfer.
 184                  */
 185                 if (std->ntds_remaining < WHCI_QSET_TD_MAX) {
 186                         int ialt;
 187                         ialt = (qset->td_end + std->ntds_remaining) % WHCI_QSET_TD_MAX;
 188                         status |= QTD_STS_IALT(ialt);
 189                 } else if (usb_pipein(std->urb->pipe))
 190                         qset->pause_after_urb = std->urb;
 191
 192                 if (std->num_pointers)
 193                         qtd->options = cpu_to_le32(QTD_OPT_IOC);
 194                 else
 195                         qtd->options = cpu_to_le32(QTD_OPT_IOC | QTD_OPT_SMALL);
 196                 qtd->page_list_ptr = cpu_to_le64(std->dma_addr);
 197
 198                 qtd->status = cpu_to_le32(status);
 199
 200                 if (QH_STATUS_TO_ICUR(qset->qh.status) == qset->td_end)
 201                         update = WHC_UPDATE_UPDATED;
 202
 203                 if (++qset->td_end >= WHCI_QSET_TD_MAX)
 204                         qset->td_end = 0;
 205                 qset->ntds++;
 206         }
 207
 208         return update;
 209 }
 210
 211 /**
 212  * qset_remove_qtd - remove the first qTD from a qset.
 213  *
 214  * The qTD might be still active (if it's part of a IN URB that
 215  * resulted in a short read) so ensure it's deactivated.
 216  */
 217 static void qset_remove_qtd(struct whc *whc, struct whc_qset *qset)
 218 {
 219         qset->qtd[qset->td_start].status = 0;
 220
 221         if (++qset->td_start >= WHCI_QSET_TD_MAX)
 222                 qset->td_start = 0;
 223         qset->ntds--;
 224 }
 225
 226 /**
 227  * qset_free_std - remove an sTD and free it.
 228  * @whc: the WHCI host controller
 229  * @std: the sTD to remove and free.
 230  */
 231 void qset_free_std(struct whc *whc, struct whc_std *std)
 232 {
 233         list_del(&std->list_node);
 234         if (std->num_pointers) {
 235                 dma_unmap_single(whc->wusbhc.dev, std->dma_addr,
 236                                  std->num_pointers * sizeof(struct whc_page_list_entry),
 237                                  DMA_TO_DEVICE);
 238                 kfree(std->pl_virt);
 239         }
 240
 241         kfree(std);
 242 }
 243
 244 /**
 245  * qset_remove_qtds - remove an URB's qTDs (and sTDs).
 246  */
 247 static void qset_remove_qtds(struct whc *whc, struct whc_qset *qset,
 248                              struct urb *urb)
 249 {
 250         struct whc_std *std, *t;
 251
 252         list_for_each_entry_safe(std, t, &qset->stds, list_node) {
 253                 if (std->urb != urb)
 254                         break;
 255                 if (std->qtd != NULL)
 256                         qset_remove_qtd(whc, qset);
 257                 qset_free_std(whc, std);
 258         }
 259 }
 260
 261 /**
 262  * qset_free_stds - free any remaining sTDs for an URB.
 263  */
 264 static void qset_free_stds(struct whc_qset *qset, struct urb *urb)
 265 {
 266         struct whc_std *std, *t;
 267
 268         list_for_each_entry_safe(std, t, &qset->stds, list_node) {
 269                 if (std->urb == urb)
 270                         qset_free_std(qset->whc, std);
 271         }
 272 }
 273
 274 static int qset_fill_page_list(struct whc *whc, struct whc_std *std, gfp_t mem_flags)
 275 {
 276         dma_addr_t dma_addr = std->dma_addr;
 277         dma_addr_t sp, ep;
 278         size_t std_len = std->len;
 279         size_t pl_len;
 280         int p;
 281
 282         sp = ALIGN(dma_addr, WHCI_PAGE_SIZE);
 283         ep = dma_addr + std_len;
 284         std->num_pointers = DIV_ROUND_UP(ep - sp, WHCI_PAGE_SIZE);
 285
 286         pl_len = std->num_pointers * sizeof(struct whc_page_list_entry);
 287         std->pl_virt = kmalloc(pl_len, mem_flags);
 288         if (std->pl_virt == NULL)
 289                 return -ENOMEM;
 290         std->dma_addr = dma_map_single(whc->wusbhc.dev, std->pl_virt, pl_len, DMA_TO_DEVICE);
 291
 292         for (p = 0; p < std->num_pointers; p++) {
 293                 std->pl_virt[p].buf_ptr = cpu_to_le64(dma_addr);
 294                 dma_addr = ALIGN(dma_addr + WHCI_PAGE_SIZE, WHCI_PAGE_SIZE);
 295         }
 296
 297         return 0;
 298 }
 299
 300 /**
 301  * urb_dequeue_work - executes asl/pzl update and gives back the urb to the system.
 302  */
 303 static void urb_dequeue_work(struct work_struct *work)
 304 {
 305         struct whc_urb *wurb = container_of(work, struct whc_urb, dequeue_work);
 306         struct whc_qset *qset = wurb->qset;
 307         struct whc *whc = qset->whc;
 308         unsigned long flags;
 309
 310         if (wurb->is_async == true)
 311                 asl_update(whc, WUSBCMD_ASYNC_UPDATED
 312                            | WUSBCMD_ASYNC_SYNCED_DB
 313                            | WUSBCMD_ASYNC_QSET_RM);
 314         else
 315                 pzl_update(whc, WUSBCMD_PERIODIC_UPDATED
 316                            | WUSBCMD_PERIODIC_SYNCED_DB
 317                            | WUSBCMD_PERIODIC_QSET_RM);
 318
 319         spin_lock_irqsave(&whc->lock, flags);
 320         qset_remove_urb(whc, qset, wurb->urb, wurb->status);
 321         spin_unlock_irqrestore(&whc->lock, flags);
 322 }
 323
 324 /**
 325  * qset_add_urb - add an urb to the qset's queue.
 326  *
 327  * The URB is chopped into sTDs, one for each qTD that will required.
 328  * At least one qTD (and sTD) is required even if the transfer has no
 329  * data (e.g., for some control transfers).
 330  */
 331 int qset_add_urb(struct whc *whc, struct whc_qset *qset, struct urb *urb,
 332         gfp_t mem_flags)
 333 {
 334         struct whc_urb *wurb;
 335         int remaining = urb->transfer_buffer_length;
 336         u64 transfer_dma = urb->transfer_dma;
 337         int ntds_remaining;
 338
 339         ntds_remaining = DIV_ROUND_UP(remaining, QTD_MAX_XFER_SIZE);
 340         if (ntds_remaining == 0)
 341                 ntds_remaining = 1;
 342
 343         wurb = kzalloc(sizeof(struct whc_urb), mem_flags);
 344         if (wurb == NULL)
 345                 goto err_no_mem;
 346         urb->hcpriv = wurb;
 347         wurb->qset = qset;
 348         wurb->urb = urb;
 349         INIT_WORK(&wurb->dequeue_work, urb_dequeue_work);
 350
 351         while (ntds_remaining) {
 352                 struct whc_std *std;
 353                 size_t std_len;
 354
 355                 std = kmalloc(sizeof(struct whc_std), mem_flags);
 356                 if (std == NULL)
 357                         goto err_no_mem;
 358
 359                 std_len = remaining;
 360                 if (std_len > QTD_MAX_XFER_SIZE)
 361                         std_len = QTD_MAX_XFER_SIZE;
 362
 363                 std->urb = urb;
 364                 std->dma_addr = transfer_dma;
 365                 std->len = std_len;
 366                 std->ntds_remaining = ntds_remaining;
 367                 std->qtd = NULL;
 368
 369                 INIT_LIST_HEAD(&std->list_node);
 370                 list_add_tail(&std->list_node, &qset->stds);
 371
 372                 if (std_len > WHCI_PAGE_SIZE) {
 373                         if (qset_fill_page_list(whc, std, mem_flags) < 0)
 374                                 goto err_no_mem;
 375                 } else
 376                         std->num_pointers = 0;
 377
 378                 ntds_remaining--;
 379                 remaining -= std_len;
 380                 transfer_dma += std_len;
 381         }
 382
 383         return 0;
 384
 385 err_no_mem:
 386         qset_free_stds(qset, urb);
 387         return -ENOMEM;
 388 }
 389
 390 /**
 391  * qset_remove_urb - remove an URB from the urb queue.
 392  *
 393  * The URB is returned to the USB subsystem.
 394  */
 395 void qset_remove_urb(struct whc *whc, struct whc_qset *qset,
 396                             struct urb *urb, int status)
 397 {
 398         struct wusbhc *wusbhc = &whc->wusbhc;
 399         struct whc_urb *wurb = urb->hcpriv;
 400
 401         usb_hcd_unlink_urb_from_ep(&wusbhc->usb_hcd, urb);
 402         /* Drop the lock as urb->complete() may enqueue another urb. */
 403         spin_unlock(&whc->lock);
 404         wusbhc_giveback_urb(wusbhc, urb, status);
 405         spin_lock(&whc->lock);
 406
 407         kfree(wurb);
 408 }
 409
 410 /**
 411  * get_urb_status_from_qtd - get the completed urb status from qTD status
 412  * @urb:    completed urb
 413  * @status: qTD status
 414  */
 415 static int get_urb_status_from_qtd(struct urb *urb, u32 status)
 416 {
 417         if (status & QTD_STS_HALTED) {
 418                 if (status & QTD_STS_DBE)
 419                         return usb_pipein(urb->pipe) ? -ENOSR : -ECOMM;
 420                 else if (status & QTD_STS_BABBLE)
 421                         return -EOVERFLOW;
 422                 else if (status & QTD_STS_RCE)
 423                         return -ETIME;
 424                 return -EPIPE;
 425         }
 426         if (usb_pipein(urb->pipe)
 427             && (urb->transfer_flags & URB_SHORT_NOT_OK)
 428             && urb->actual_length < urb->transfer_buffer_length)
 429                 return -EREMOTEIO;
 430         return 0;
 431 }
 432
 433 /**
 434  * process_inactive_qtd - process an inactive (but not halted) qTD.
 435  *
 436  * Update the urb with the transfer bytes from the qTD, if the urb is
 437  * completely transfered or (in the case of an IN only) the LPF is
 438  * set, then the transfer is complete and the urb should be returned
 439  * to the system.
 440  */
 441 void process_inactive_qtd(struct whc *whc, struct whc_qset *qset,
 442                                  struct whc_qtd *qtd)
 443 {
 444         struct whc_std *std = list_first_entry(&qset->stds, struct whc_std, list_node);
 445         struct urb *urb = std->urb;
 446         uint32_t status;
 447         bool complete;
 448
 449         status = le32_to_cpu(qtd->status);
 450
 451         urb->actual_length += std->len - QTD_STS_TO_LEN(status);
 452
 453         if (usb_pipein(urb->pipe) && (status & QTD_STS_LAST_PKT))
 454                 complete = true;
 455         else
 456                 complete = whc_std_last(std);
 457
 458         qset_remove_qtd(whc, qset);
 459         qset_free_std(whc, std);
 460
 461         /*
 462          * Transfers for this URB are complete?  Then return it to the
 463          * USB subsystem.
 464          */
 465         if (complete) {
 466                 qset_remove_qtds(whc, qset, urb);
 467                 qset_remove_urb(whc, qset, urb, get_urb_status_from_qtd(urb, status));
 468
 469                 /*
 470                  * If iAlt isn't valid then the hardware didn't
 471                  * advance iCur. Adjust the start and end pointers to
 472                  * match iCur.
 473                  */
 474                 if (!(status & QTD_STS_IALT_VALID))
 475                         qset->td_start = qset->td_end
 476                                 = QH_STATUS_TO_ICUR(le16_to_cpu(qset->qh.status));
 477                 qset->pause_after_urb = NULL;
 478         }
 479 }
 480
 481 /**
 482  * process_halted_qtd - process a qset with a halted qtd
 483  *
 484  * Remove all the qTDs for the failed URB and return the failed URB to
 485  * the USB subsystem.  Then remove all other qTDs so the qset can be
 486  * removed.
 487  *
 488  * FIXME: this is the point where rate adaptation can be done.  If a
 489  * transfer failed because it exceeded the maximum number of retries
 490  * then it could be reactivated with a slower rate without having to
 491  * remove the qset.
 492  */
 493 void process_halted_qtd(struct whc *whc, struct whc_qset *qset,
 494                                struct whc_qtd *qtd)
 495 {
 496         struct whc_std *std = list_first_entry(&qset->stds, struct whc_std, list_node);
 497         struct urb *urb = std->urb;
 498         int urb_status;
 499
 500         urb_status = get_urb_status_from_qtd(urb, le32_to_cpu(qtd->status));
 501
 502         qset_remove_qtds(whc, qset, urb);
 503         qset_remove_urb(whc, qset, urb, urb_status);
 504
 505         list_for_each_entry(std, &qset->stds, list_node) {
 506                 if (qset->ntds == 0)
 507                         break;
 508                 qset_remove_qtd(whc, qset);
 509                 std->qtd = NULL;
 510         }
 511
 512         qset->remove = 1;
 513 }
 514
 515 void qset_free(struct whc *whc, struct whc_qset *qset)
 516 {
 517         dma_pool_free(whc->qset_pool, qset, qset->qset_dma);
 518 }
 519
 520 /**
 521  * qset_delete - wait for a qset to be unused, then free it.
 522  */
 523 void qset_delete(struct whc *whc, struct whc_qset *qset)
 524 {
 525         wait_for_completion(&qset->remove_complete);
 526         qset_free(whc, qset);
 527 }