2 * Wireless Host Controller (WHC) qset management.
4 * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
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.
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.
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/>.
18 #include <linux/kernel.h>
19 #include <linux/dma-mapping.h>
20 #include <linux/uwb/umc.h>
21 #include <linux/usb.h>
23 #include "../../wusbcore/wusbhc.h"
27 void dump_qset(struct whc_qset *qset, struct device *dev)
30 struct urb *urb = NULL;
33 dev_dbg(dev, "qset %08x\n", (u32)qset->qset_dma);
34 dev_dbg(dev, " -> %08x\n", (u32)qset->qh.link);
35 dev_dbg(dev, " info: %08x %08x %08x\n",
36 qset->qh.info1, qset->qh.info2, qset->qh.info3);
37 dev_dbg(dev, " sts: %04x errs: %d\n", qset->qh.status, qset->qh.err_count);
38 dev_dbg(dev, " TD: sts: %08x opts: %08x\n",
39 qset->qh.overlay.qtd.status, qset->qh.overlay.qtd.options);
41 for (i = 0; i < WHCI_QSET_TD_MAX; i++) {
42 dev_dbg(dev, " %c%c TD[%d]: sts: %08x opts: %08x ptr: %08x\n",
43 i == qset->td_start ? 'S' : ' ',
44 i == qset->td_end ? 'E' : ' ',
45 i, qset->qtd[i].status, qset->qtd[i].options,
46 (u32)qset->qtd[i].page_list_ptr);
48 dev_dbg(dev, " ntds: %d\n", qset->ntds);
49 list_for_each_entry(std, &qset->stds, list_node) {
50 if (urb != std->urb) {
52 dev_dbg(dev, " urb %p transferred: %d bytes\n", urb,
56 dev_dbg(dev, " sTD[%td]: %zu bytes @ %08x\n",
57 std->qtd - &qset->qtd[0],
58 std->len, std->num_pointers ?
59 (u32)(std->pl_virt[0].buf_ptr) : (u32)std->dma_addr);
61 dev_dbg(dev, " sTD[-]: %zd bytes @ %08x\n",
62 std->len, std->num_pointers ?
63 (u32)(std->pl_virt[0].buf_ptr) : (u32)std->dma_addr);
67 struct whc_qset *qset_alloc(struct whc *whc, gfp_t mem_flags)
69 struct whc_qset *qset;
72 qset = dma_pool_alloc(whc->qset_pool, mem_flags, &dma);
75 memset(qset, 0, sizeof(struct whc_qset));
80 INIT_LIST_HEAD(&qset->list_node);
81 INIT_LIST_HEAD(&qset->stds);
87 * qset_fill_qh - fill the static endpoint state in a qset's QHead
88 * @qset: the qset whose QH needs initializing with static endpoint
90 * @urb: an urb for a transfer to this endpoint
92 static void qset_fill_qh(struct whc_qset *qset, struct urb *urb)
94 struct usb_device *usb_dev = urb->dev;
95 struct usb_wireless_ep_comp_descriptor *epcd;
98 is_out = usb_pipeout(urb->pipe);
100 epcd = (struct usb_wireless_ep_comp_descriptor *)qset->ep->extra;
103 qset->max_seq = epcd->bMaxSequence;
104 qset->max_burst = epcd->bMaxBurst;
110 qset->qh.info1 = cpu_to_le32(
111 QH_INFO1_EP(usb_pipeendpoint(urb->pipe))
112 | (is_out ? QH_INFO1_DIR_OUT : QH_INFO1_DIR_IN)
113 | usb_pipe_to_qh_type(urb->pipe)
114 | QH_INFO1_DEV_INFO_IDX(wusb_port_no_to_idx(usb_dev->portnum))
115 | QH_INFO1_MAX_PKT_LEN(usb_maxpacket(urb->dev, urb->pipe, is_out))
117 qset->qh.info2 = cpu_to_le32(
118 QH_INFO2_BURST(qset->max_burst)
120 | QH_INFO2_MAX_COUNT(3)
121 | QH_INFO2_MAX_RETRY(3)
122 | QH_INFO2_MAX_SEQ(qset->max_seq - 1)
124 /* FIXME: where can we obtain these Tx parameters from? Why
125 * doesn't the chip know what Tx power to use? It knows the Rx
126 * strength and can presumably guess the Tx power required
128 qset->qh.info3 = cpu_to_le32(
129 QH_INFO3_TX_RATE_53_3
130 | QH_INFO3_TX_PWR(0) /* 0 == max power */
135 * qset_clear - clear fields in a qset so it may be reinserted into a
138 void qset_clear(struct whc *whc, struct whc_qset *qset)
140 qset->td_start = qset->td_end = qset->ntds = 0;
143 qset->qh.link = cpu_to_le32(QH_LINK_NTDS(8) | QH_LINK_T);
144 qset->qh.status = cpu_to_le16(QH_STATUS_ICUR(qset->td_start));
145 qset->qh.err_count = 0;
146 qset->qh.cur_window = cpu_to_le32((1 << qset->max_burst) - 1);
147 qset->qh.scratch[0] = 0;
148 qset->qh.scratch[1] = 0;
149 qset->qh.scratch[2] = 0;
151 memset(&qset->qh.overlay, 0, sizeof(qset->qh.overlay));
153 init_completion(&qset->remove_complete);
157 * get_qset - get the qset for an async endpoint
159 * A new qset is created if one does not already exist.
161 struct whc_qset *get_qset(struct whc *whc, struct urb *urb,
164 struct whc_qset *qset;
166 qset = urb->ep->hcpriv;
168 qset = qset_alloc(whc, mem_flags);
173 urb->ep->hcpriv = qset;
174 qset_fill_qh(qset, urb);
179 void qset_remove_complete(struct whc *whc, struct whc_qset *qset)
181 list_del_init(&qset->list_node);
182 complete(&qset->remove_complete);
186 * qset_add_qtds - add qTDs for an URB to a qset
188 * Returns true if the list (ASL/PZL) must be updated because (for a
189 * WHCI 0.95 controller) an activated qTD was pointed to be iCur.
191 enum whc_update qset_add_qtds(struct whc *whc, struct whc_qset *qset)
194 enum whc_update update = 0;
196 list_for_each_entry(std, &qset->stds, list_node) {
200 if (qset->ntds >= WHCI_QSET_TD_MAX
201 || (qset->pause_after_urb && std->urb != qset->pause_after_urb))
205 continue; /* already has a qTD */
207 qtd = std->qtd = &qset->qtd[qset->td_end];
209 /* Fill in setup bytes for control transfers. */
210 if (usb_pipecontrol(std->urb->pipe))
211 memcpy(qtd->setup, std->urb->setup_packet, 8);
213 status = QTD_STS_ACTIVE | QTD_STS_LEN(std->len);
215 if (whc_std_last(std) && usb_pipeout(std->urb->pipe))
216 status |= QTD_STS_LAST_PKT;
219 * For an IN transfer the iAlt field should be set so
220 * the h/w will automatically advance to the next
221 * transfer. However, if there are 8 or more TDs
222 * remaining in this transfer then iAlt cannot be set
223 * as it could point to somewhere in this transfer.
225 if (std->ntds_remaining < WHCI_QSET_TD_MAX) {
227 ialt = (qset->td_end + std->ntds_remaining) % WHCI_QSET_TD_MAX;
228 status |= QTD_STS_IALT(ialt);
229 } else if (usb_pipein(std->urb->pipe))
230 qset->pause_after_urb = std->urb;
232 if (std->num_pointers)
233 qtd->options = cpu_to_le32(QTD_OPT_IOC);
235 qtd->options = cpu_to_le32(QTD_OPT_IOC | QTD_OPT_SMALL);
236 qtd->page_list_ptr = cpu_to_le64(std->dma_addr);
238 qtd->status = cpu_to_le32(status);
240 if (QH_STATUS_TO_ICUR(qset->qh.status) == qset->td_end)
241 update = WHC_UPDATE_UPDATED;
243 if (++qset->td_end >= WHCI_QSET_TD_MAX)
252 * qset_remove_qtd - remove the first qTD from a qset.
254 * The qTD might be still active (if it's part of a IN URB that
255 * resulted in a short read) so ensure it's deactivated.
257 static void qset_remove_qtd(struct whc *whc, struct whc_qset *qset)
259 qset->qtd[qset->td_start].status = 0;
261 if (++qset->td_start >= WHCI_QSET_TD_MAX)
267 * qset_free_std - remove an sTD and free it.
268 * @whc: the WHCI host controller
269 * @std: the sTD to remove and free.
271 void qset_free_std(struct whc *whc, struct whc_std *std)
273 list_del(&std->list_node);
274 if (std->num_pointers) {
275 dma_unmap_single(whc->wusbhc.dev, std->dma_addr,
276 std->num_pointers * sizeof(struct whc_page_list_entry),
285 * qset_remove_qtds - remove an URB's qTDs (and sTDs).
287 static void qset_remove_qtds(struct whc *whc, struct whc_qset *qset,
290 struct whc_std *std, *t;
292 list_for_each_entry_safe(std, t, &qset->stds, list_node) {
295 if (std->qtd != NULL)
296 qset_remove_qtd(whc, qset);
297 qset_free_std(whc, std);
302 * qset_free_stds - free any remaining sTDs for an URB.
304 static void qset_free_stds(struct whc_qset *qset, struct urb *urb)
306 struct whc_std *std, *t;
308 list_for_each_entry_safe(std, t, &qset->stds, list_node) {
310 qset_free_std(qset->whc, std);
314 static int qset_fill_page_list(struct whc *whc, struct whc_std *std, gfp_t mem_flags)
316 dma_addr_t dma_addr = std->dma_addr;
318 size_t std_len = std->len;
322 sp = ALIGN(dma_addr, WHCI_PAGE_SIZE);
323 ep = dma_addr + std_len;
324 std->num_pointers = DIV_ROUND_UP(ep - sp, WHCI_PAGE_SIZE);
326 pl_len = std->num_pointers * sizeof(struct whc_page_list_entry);
327 std->pl_virt = kmalloc(pl_len, mem_flags);
328 if (std->pl_virt == NULL)
330 std->dma_addr = dma_map_single(whc->wusbhc.dev, std->pl_virt, pl_len, DMA_TO_DEVICE);
332 for (p = 0; p < std->num_pointers; p++) {
333 std->pl_virt[p].buf_ptr = cpu_to_le64(dma_addr);
334 dma_addr = ALIGN(dma_addr + WHCI_PAGE_SIZE, WHCI_PAGE_SIZE);
341 * urb_dequeue_work - executes asl/pzl update and gives back the urb to the system.
343 static void urb_dequeue_work(struct work_struct *work)
345 struct whc_urb *wurb = container_of(work, struct whc_urb, dequeue_work);
346 struct whc_qset *qset = wurb->qset;
347 struct whc *whc = qset->whc;
350 if (wurb->is_async == true)
351 asl_update(whc, WUSBCMD_ASYNC_UPDATED
352 | WUSBCMD_ASYNC_SYNCED_DB
353 | WUSBCMD_ASYNC_QSET_RM);
355 pzl_update(whc, WUSBCMD_PERIODIC_UPDATED
356 | WUSBCMD_PERIODIC_SYNCED_DB
357 | WUSBCMD_PERIODIC_QSET_RM);
359 spin_lock_irqsave(&whc->lock, flags);
360 qset_remove_urb(whc, qset, wurb->urb, wurb->status);
361 spin_unlock_irqrestore(&whc->lock, flags);
365 * qset_add_urb - add an urb to the qset's queue.
367 * The URB is chopped into sTDs, one for each qTD that will required.
368 * At least one qTD (and sTD) is required even if the transfer has no
369 * data (e.g., for some control transfers).
371 int qset_add_urb(struct whc *whc, struct whc_qset *qset, struct urb *urb,
374 struct whc_urb *wurb;
375 int remaining = urb->transfer_buffer_length;
376 u64 transfer_dma = urb->transfer_dma;
379 ntds_remaining = DIV_ROUND_UP(remaining, QTD_MAX_XFER_SIZE);
380 if (ntds_remaining == 0)
383 wurb = kzalloc(sizeof(struct whc_urb), mem_flags);
389 INIT_WORK(&wurb->dequeue_work, urb_dequeue_work);
391 while (ntds_remaining) {
395 std = kmalloc(sizeof(struct whc_std), mem_flags);
400 if (std_len > QTD_MAX_XFER_SIZE)
401 std_len = QTD_MAX_XFER_SIZE;
404 std->dma_addr = transfer_dma;
406 std->ntds_remaining = ntds_remaining;
409 INIT_LIST_HEAD(&std->list_node);
410 list_add_tail(&std->list_node, &qset->stds);
412 if (std_len > WHCI_PAGE_SIZE) {
413 if (qset_fill_page_list(whc, std, mem_flags) < 0)
416 std->num_pointers = 0;
419 remaining -= std_len;
420 transfer_dma += std_len;
426 qset_free_stds(qset, urb);
431 * qset_remove_urb - remove an URB from the urb queue.
433 * The URB is returned to the USB subsystem.
435 void qset_remove_urb(struct whc *whc, struct whc_qset *qset,
436 struct urb *urb, int status)
438 struct wusbhc *wusbhc = &whc->wusbhc;
439 struct whc_urb *wurb = urb->hcpriv;
441 usb_hcd_unlink_urb_from_ep(&wusbhc->usb_hcd, urb);
442 /* Drop the lock as urb->complete() may enqueue another urb. */
443 spin_unlock(&whc->lock);
444 wusbhc_giveback_urb(wusbhc, urb, status);
445 spin_lock(&whc->lock);
451 * get_urb_status_from_qtd - get the completed urb status from qTD status
452 * @urb: completed urb
453 * @status: qTD status
455 static int get_urb_status_from_qtd(struct urb *urb, u32 status)
457 if (status & QTD_STS_HALTED) {
458 if (status & QTD_STS_DBE)
459 return usb_pipein(urb->pipe) ? -ENOSR : -ECOMM;
460 else if (status & QTD_STS_BABBLE)
462 else if (status & QTD_STS_RCE)
466 if (usb_pipein(urb->pipe)
467 && (urb->transfer_flags & URB_SHORT_NOT_OK)
468 && urb->actual_length < urb->transfer_buffer_length)
474 * process_inactive_qtd - process an inactive (but not halted) qTD.
476 * Update the urb with the transfer bytes from the qTD, if the urb is
477 * completely transfered or (in the case of an IN only) the LPF is
478 * set, then the transfer is complete and the urb should be returned
481 void process_inactive_qtd(struct whc *whc, struct whc_qset *qset,
484 struct whc_std *std = list_first_entry(&qset->stds, struct whc_std, list_node);
485 struct urb *urb = std->urb;
489 status = le32_to_cpu(qtd->status);
491 urb->actual_length += std->len - QTD_STS_TO_LEN(status);
493 if (usb_pipein(urb->pipe) && (status & QTD_STS_LAST_PKT))
496 complete = whc_std_last(std);
498 qset_remove_qtd(whc, qset);
499 qset_free_std(whc, std);
502 * Transfers for this URB are complete? Then return it to the
506 qset_remove_qtds(whc, qset, urb);
507 qset_remove_urb(whc, qset, urb, get_urb_status_from_qtd(urb, status));
510 * If iAlt isn't valid then the hardware didn't
511 * advance iCur. Adjust the start and end pointers to
514 if (!(status & QTD_STS_IALT_VALID))
515 qset->td_start = qset->td_end
516 = QH_STATUS_TO_ICUR(le16_to_cpu(qset->qh.status));
517 qset->pause_after_urb = NULL;
522 * process_halted_qtd - process a qset with a halted qtd
524 * Remove all the qTDs for the failed URB and return the failed URB to
525 * the USB subsystem. Then remove all other qTDs so the qset can be
528 * FIXME: this is the point where rate adaptation can be done. If a
529 * transfer failed because it exceeded the maximum number of retries
530 * then it could be reactivated with a slower rate without having to
533 void process_halted_qtd(struct whc *whc, struct whc_qset *qset,
536 struct whc_std *std = list_first_entry(&qset->stds, struct whc_std, list_node);
537 struct urb *urb = std->urb;
540 urb_status = get_urb_status_from_qtd(urb, le32_to_cpu(qtd->status));
542 qset_remove_qtds(whc, qset, urb);
543 qset_remove_urb(whc, qset, urb, urb_status);
545 list_for_each_entry(std, &qset->stds, list_node) {
548 qset_remove_qtd(whc, qset);
555 void qset_free(struct whc *whc, struct whc_qset *qset)
557 dma_pool_free(whc->qset_pool, qset, qset->qset_dma);
561 * qset_delete - wait for a qset to be unused, then free it.
563 void qset_delete(struct whc *whc, struct whc_qset *qset)
565 wait_for_completion(&qset->remove_complete);
566 qset_free(whc, qset);