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/slab.h>
21 #include <linux/uwb/umc.h>
22 #include <linux/usb.h>
24 #include "../../wusbcore/wusbhc.h"
28 struct whc_qset
*qset_alloc(struct whc
*whc
, gfp_t mem_flags
)
30 struct whc_qset
*qset
;
33 qset
= dma_pool_alloc(whc
->qset_pool
, mem_flags
, &dma
);
36 memset(qset
, 0, sizeof(struct whc_qset
));
41 INIT_LIST_HEAD(&qset
->list_node
);
42 INIT_LIST_HEAD(&qset
->stds
);
48 * qset_fill_qh - fill the static endpoint state in a qset's QHead
49 * @qset: the qset whose QH needs initializing with static endpoint
51 * @urb: an urb for a transfer to this endpoint
53 static void qset_fill_qh(struct whc
*whc
, struct whc_qset
*qset
, struct urb
*urb
)
55 struct usb_device
*usb_dev
= urb
->dev
;
56 struct wusb_dev
*wusb_dev
= usb_dev
->wusb_dev
;
57 struct usb_wireless_ep_comp_descriptor
*epcd
;
61 is_out
= usb_pipeout(urb
->pipe
);
63 qset
->max_packet
= le16_to_cpu(urb
->ep
->desc
.wMaxPacketSize
);
65 epcd
= (struct usb_wireless_ep_comp_descriptor
*)qset
->ep
->extra
;
67 qset
->max_seq
= epcd
->bMaxSequence
;
68 qset
->max_burst
= epcd
->bMaxBurst
;
75 * Initial PHY rate is 53.3 Mbit/s for control endpoints or
76 * the maximum supported by the device for other endpoints
77 * (unless limited by the user).
79 if (usb_pipecontrol(urb
->pipe
))
80 phy_rate
= UWB_PHY_RATE_53
;
84 phy_rates
= le16_to_cpu(wusb_dev
->wusb_cap_descr
->wPHYRates
);
85 phy_rate
= fls(phy_rates
) - 1;
86 if (phy_rate
> whc
->wusbhc
.phy_rate
)
87 phy_rate
= whc
->wusbhc
.phy_rate
;
90 qset
->qh
.info1
= cpu_to_le32(
91 QH_INFO1_EP(usb_pipeendpoint(urb
->pipe
))
92 | (is_out
? QH_INFO1_DIR_OUT
: QH_INFO1_DIR_IN
)
93 | usb_pipe_to_qh_type(urb
->pipe
)
94 | QH_INFO1_DEV_INFO_IDX(wusb_port_no_to_idx(usb_dev
->portnum
))
95 | QH_INFO1_MAX_PKT_LEN(qset
->max_packet
)
97 qset
->qh
.info2
= cpu_to_le32(
98 QH_INFO2_BURST(qset
->max_burst
)
100 | QH_INFO2_MAX_COUNT(3)
101 | QH_INFO2_MAX_RETRY(3)
102 | QH_INFO2_MAX_SEQ(qset
->max_seq
- 1)
104 /* FIXME: where can we obtain these Tx parameters from? Why
105 * doesn't the chip know what Tx power to use? It knows the Rx
106 * strength and can presumably guess the Tx power required
108 qset
->qh
.info3
= cpu_to_le32(
109 QH_INFO3_TX_RATE(phy_rate
)
110 | QH_INFO3_TX_PWR(0) /* 0 == max power */
113 qset
->qh
.cur_window
= cpu_to_le32((1 << qset
->max_burst
) - 1);
117 * qset_clear - clear fields in a qset so it may be reinserted into a
120 * The sequence number and current window are not cleared (see
123 void qset_clear(struct whc
*whc
, struct whc_qset
*qset
)
125 qset
->td_start
= qset
->td_end
= qset
->ntds
= 0;
127 qset
->qh
.link
= cpu_to_le64(QH_LINK_NTDS(8) | QH_LINK_T
);
128 qset
->qh
.status
= qset
->qh
.status
& QH_STATUS_SEQ_MASK
;
129 qset
->qh
.err_count
= 0;
130 qset
->qh
.scratch
[0] = 0;
131 qset
->qh
.scratch
[1] = 0;
132 qset
->qh
.scratch
[2] = 0;
134 memset(&qset
->qh
.overlay
, 0, sizeof(qset
->qh
.overlay
));
136 init_completion(&qset
->remove_complete
);
140 * qset_reset - reset endpoint state in a qset.
142 * Clears the sequence number and current window. This qset must not
143 * be in the ASL or PZL.
145 void qset_reset(struct whc
*whc
, struct whc_qset
*qset
)
149 qset
->qh
.status
&= ~QH_STATUS_SEQ_MASK
;
150 qset
->qh
.cur_window
= cpu_to_le32((1 << qset
->max_burst
) - 1);
154 * get_qset - get the qset for an async endpoint
156 * A new qset is created if one does not already exist.
158 struct whc_qset
*get_qset(struct whc
*whc
, struct urb
*urb
,
161 struct whc_qset
*qset
;
163 qset
= urb
->ep
->hcpriv
;
165 qset
= qset_alloc(whc
, mem_flags
);
170 urb
->ep
->hcpriv
= qset
;
171 qset_fill_qh(whc
, qset
, urb
);
176 void qset_remove_complete(struct whc
*whc
, struct whc_qset
*qset
)
179 list_del_init(&qset
->list_node
);
180 complete(&qset
->remove_complete
);
184 * qset_add_qtds - add qTDs for an URB to a qset
186 * Returns true if the list (ASL/PZL) must be updated because (for a
187 * WHCI 0.95 controller) an activated qTD was pointed to be iCur.
189 enum whc_update
qset_add_qtds(struct whc
*whc
, struct whc_qset
*qset
)
192 enum whc_update update
= 0;
194 list_for_each_entry(std
, &qset
->stds
, list_node
) {
198 if (qset
->ntds
>= WHCI_QSET_TD_MAX
199 || (qset
->pause_after_urb
&& std
->urb
!= qset
->pause_after_urb
))
203 continue; /* already has a qTD */
205 qtd
= std
->qtd
= &qset
->qtd
[qset
->td_end
];
207 /* Fill in setup bytes for control transfers. */
208 if (usb_pipecontrol(std
->urb
->pipe
))
209 memcpy(qtd
->setup
, std
->urb
->setup_packet
, 8);
211 status
= QTD_STS_ACTIVE
| QTD_STS_LEN(std
->len
);
213 if (whc_std_last(std
) && usb_pipeout(std
->urb
->pipe
))
214 status
|= QTD_STS_LAST_PKT
;
217 * For an IN transfer the iAlt field should be set so
218 * the h/w will automatically advance to the next
219 * transfer. However, if there are 8 or more TDs
220 * remaining in this transfer then iAlt cannot be set
221 * as it could point to somewhere in this transfer.
223 if (std
->ntds_remaining
< WHCI_QSET_TD_MAX
) {
225 ialt
= (qset
->td_end
+ std
->ntds_remaining
) % WHCI_QSET_TD_MAX
;
226 status
|= QTD_STS_IALT(ialt
);
227 } else if (usb_pipein(std
->urb
->pipe
))
228 qset
->pause_after_urb
= std
->urb
;
230 if (std
->num_pointers
)
231 qtd
->options
= cpu_to_le32(QTD_OPT_IOC
);
233 qtd
->options
= cpu_to_le32(QTD_OPT_IOC
| QTD_OPT_SMALL
);
234 qtd
->page_list_ptr
= cpu_to_le64(std
->dma_addr
);
236 qtd
->status
= cpu_to_le32(status
);
238 if (QH_STATUS_TO_ICUR(qset
->qh
.status
) == qset
->td_end
)
239 update
= WHC_UPDATE_UPDATED
;
241 if (++qset
->td_end
>= WHCI_QSET_TD_MAX
)
250 * qset_remove_qtd - remove the first qTD from a qset.
252 * The qTD might be still active (if it's part of a IN URB that
253 * resulted in a short read) so ensure it's deactivated.
255 static void qset_remove_qtd(struct whc
*whc
, struct whc_qset
*qset
)
257 qset
->qtd
[qset
->td_start
].status
= 0;
259 if (++qset
->td_start
>= WHCI_QSET_TD_MAX
)
264 static void qset_copy_bounce_to_sg(struct whc
*whc
, struct whc_std
*std
)
266 struct scatterlist
*sg
;
268 size_t remaining
, offset
;
270 bounce
= std
->bounce_buf
;
271 remaining
= std
->len
;
274 offset
= std
->bounce_offset
;
279 len
= min(sg
->length
- offset
, remaining
);
280 memcpy(sg_virt(sg
) + offset
, bounce
, len
);
286 if (offset
>= sg
->length
) {
295 * qset_free_std - remove an sTD and free it.
296 * @whc: the WHCI host controller
297 * @std: the sTD to remove and free.
299 void qset_free_std(struct whc
*whc
, struct whc_std
*std
)
301 list_del(&std
->list_node
);
302 if (std
->bounce_buf
) {
303 bool is_out
= usb_pipeout(std
->urb
->pipe
);
306 if (std
->num_pointers
)
307 dma_addr
= le64_to_cpu(std
->pl_virt
[0].buf_ptr
);
309 dma_addr
= std
->dma_addr
;
311 dma_unmap_single(whc
->wusbhc
.dev
, dma_addr
,
312 std
->len
, is_out
? DMA_TO_DEVICE
: DMA_FROM_DEVICE
);
314 qset_copy_bounce_to_sg(whc
, std
);
315 kfree(std
->bounce_buf
);
319 dma_unmap_single(whc
->wusbhc
.dev
, std
->dma_addr
,
320 std
->num_pointers
* sizeof(struct whc_page_list_entry
),
329 * qset_remove_qtds - remove an URB's qTDs (and sTDs).
331 static void qset_remove_qtds(struct whc
*whc
, struct whc_qset
*qset
,
334 struct whc_std
*std
, *t
;
336 list_for_each_entry_safe(std
, t
, &qset
->stds
, list_node
) {
339 if (std
->qtd
!= NULL
)
340 qset_remove_qtd(whc
, qset
);
341 qset_free_std(whc
, std
);
346 * qset_free_stds - free any remaining sTDs for an URB.
348 static void qset_free_stds(struct whc_qset
*qset
, struct urb
*urb
)
350 struct whc_std
*std
, *t
;
352 list_for_each_entry_safe(std
, t
, &qset
->stds
, list_node
) {
354 qset_free_std(qset
->whc
, std
);
358 static int qset_fill_page_list(struct whc
*whc
, struct whc_std
*std
, gfp_t mem_flags
)
360 dma_addr_t dma_addr
= std
->dma_addr
;
365 /* Short buffers don't need a page list. */
366 if (std
->len
<= WHCI_PAGE_SIZE
) {
367 std
->num_pointers
= 0;
371 sp
= dma_addr
& ~(WHCI_PAGE_SIZE
-1);
372 ep
= dma_addr
+ std
->len
;
373 std
->num_pointers
= DIV_ROUND_UP(ep
- sp
, WHCI_PAGE_SIZE
);
375 pl_len
= std
->num_pointers
* sizeof(struct whc_page_list_entry
);
376 std
->pl_virt
= kmalloc(pl_len
, mem_flags
);
377 if (std
->pl_virt
== NULL
)
379 std
->dma_addr
= dma_map_single(whc
->wusbhc
.dev
, std
->pl_virt
, pl_len
, DMA_TO_DEVICE
);
381 for (p
= 0; p
< std
->num_pointers
; p
++) {
382 std
->pl_virt
[p
].buf_ptr
= cpu_to_le64(dma_addr
);
383 dma_addr
= (dma_addr
+ WHCI_PAGE_SIZE
) & ~(WHCI_PAGE_SIZE
-1);
390 * urb_dequeue_work - executes asl/pzl update and gives back the urb to the system.
392 static void urb_dequeue_work(struct work_struct
*work
)
394 struct whc_urb
*wurb
= container_of(work
, struct whc_urb
, dequeue_work
);
395 struct whc_qset
*qset
= wurb
->qset
;
396 struct whc
*whc
= qset
->whc
;
399 if (wurb
->is_async
== true)
400 asl_update(whc
, WUSBCMD_ASYNC_UPDATED
401 | WUSBCMD_ASYNC_SYNCED_DB
402 | WUSBCMD_ASYNC_QSET_RM
);
404 pzl_update(whc
, WUSBCMD_PERIODIC_UPDATED
405 | WUSBCMD_PERIODIC_SYNCED_DB
406 | WUSBCMD_PERIODIC_QSET_RM
);
408 spin_lock_irqsave(&whc
->lock
, flags
);
409 qset_remove_urb(whc
, qset
, wurb
->urb
, wurb
->status
);
410 spin_unlock_irqrestore(&whc
->lock
, flags
);
413 static struct whc_std
*qset_new_std(struct whc
*whc
, struct whc_qset
*qset
,
414 struct urb
*urb
, gfp_t mem_flags
)
418 std
= kzalloc(sizeof(struct whc_std
), mem_flags
);
425 INIT_LIST_HEAD(&std
->list_node
);
426 list_add_tail(&std
->list_node
, &qset
->stds
);
431 static int qset_add_urb_sg(struct whc
*whc
, struct whc_qset
*qset
, struct urb
*urb
,
435 struct scatterlist
*sg
;
438 struct whc_std
*std
= NULL
;
439 struct whc_page_list_entry
*entry
;
440 dma_addr_t prev_end
= 0;
444 remaining
= urb
->transfer_buffer_length
;
446 for_each_sg(urb
->sg
, sg
, urb
->num_mapped_sgs
, i
) {
448 size_t dma_remaining
;
452 if (remaining
== 0) {
456 dma_addr
= sg_dma_address(sg
);
457 dma_remaining
= min_t(size_t, sg_dma_len(sg
), remaining
);
459 while (dma_remaining
) {
463 * We can use the previous std (if it exists) provided that:
464 * - the previous one ended on a page boundary.
465 * - the current one begins on a page boundary.
466 * - the previous one isn't full.
468 * If a new std is needed but the previous one
469 * was not a whole number of packets then this
470 * sg list cannot be mapped onto multiple
471 * qTDs. Return an error and let the caller
475 || (prev_end
& (WHCI_PAGE_SIZE
-1))
476 || (dma_addr
& (WHCI_PAGE_SIZE
-1))
477 || std
->len
+ WHCI_PAGE_SIZE
> QTD_MAX_XFER_SIZE
) {
478 if (std
&& std
->len
% qset
->max_packet
!= 0)
480 std
= qset_new_std(whc
, qset
, urb
, mem_flags
);
488 dma_len
= dma_remaining
;
491 * If the remainder of this element doesn't
492 * fit in a single qTD, limit the qTD to a
493 * whole number of packets. This allows the
494 * remainder to go into the next qTD.
496 if (std
->len
+ dma_len
> QTD_MAX_XFER_SIZE
) {
497 dma_len
= (QTD_MAX_XFER_SIZE
/ qset
->max_packet
)
498 * qset
->max_packet
- std
->len
;
502 std
->ntds_remaining
= -1; /* filled in later */
504 sp
= dma_addr
& ~(WHCI_PAGE_SIZE
-1);
505 ep
= dma_addr
+ dma_len
;
506 num_pointers
= DIV_ROUND_UP(ep
- sp
, WHCI_PAGE_SIZE
);
507 std
->num_pointers
+= num_pointers
;
509 pl_len
= std
->num_pointers
* sizeof(struct whc_page_list_entry
);
511 std
->pl_virt
= krealloc(std
->pl_virt
, pl_len
, mem_flags
);
512 if (std
->pl_virt
== NULL
) {
516 for (;p
< std
->num_pointers
; p
++, entry
++) {
517 std
->pl_virt
[p
].buf_ptr
= cpu_to_le64(dma_addr
);
518 dma_addr
= (dma_addr
+ WHCI_PAGE_SIZE
) & ~(WHCI_PAGE_SIZE
-1);
521 prev_end
= dma_addr
= ep
;
522 dma_remaining
-= dma_len
;
523 remaining
-= dma_len
;
527 /* Now the number of stds is know, go back and fill in
528 std->ntds_remaining. */
529 list_for_each_entry(std
, &qset
->stds
, list_node
) {
530 if (std
->ntds_remaining
== -1) {
531 pl_len
= std
->num_pointers
* sizeof(struct whc_page_list_entry
);
532 std
->ntds_remaining
= ntds
--;
533 std
->dma_addr
= dma_map_single(whc
->wusbhc
.dev
, std
->pl_virt
,
534 pl_len
, DMA_TO_DEVICE
);
541 * qset_add_urb_sg_linearize - add an urb with sg list, copying the data
543 * If the URB contains an sg list whose elements cannot be directly
544 * mapped to qTDs then the data must be transferred via bounce
547 static int qset_add_urb_sg_linearize(struct whc
*whc
, struct whc_qset
*qset
,
548 struct urb
*urb
, gfp_t mem_flags
)
550 bool is_out
= usb_pipeout(urb
->pipe
);
554 struct whc_std
*std
= NULL
;
556 struct scatterlist
*sg
;
559 /* limit maximum bounce buffer to 16 * 3.5 KiB ~= 28 k */
560 max_std_len
= qset
->max_burst
* qset
->max_packet
;
562 remaining
= urb
->transfer_buffer_length
;
564 for_each_sg(urb
->sg
, sg
, urb
->num_mapped_sgs
, i
) {
569 if (remaining
== 0) {
573 sg_remaining
= min_t(size_t, remaining
, sg
->length
);
576 while (sg_remaining
) {
577 if (!std
|| std
->len
== max_std_len
) {
578 std
= qset_new_std(whc
, qset
, urb
, mem_flags
);
581 std
->bounce_buf
= kmalloc(max_std_len
, mem_flags
);
582 if (std
->bounce_buf
== NULL
)
585 std
->bounce_offset
= orig
- sg_virt(sg
);
586 bounce
= std
->bounce_buf
;
590 len
= min(sg_remaining
, max_std_len
- std
->len
);
593 memcpy(bounce
, orig
, len
);
596 std
->ntds_remaining
= -1; /* filled in later */
606 * For each of the new sTDs, map the bounce buffers, create
607 * page lists (if necessary), and fill in std->ntds_remaining.
609 list_for_each_entry(std
, &qset
->stds
, list_node
) {
610 if (std
->ntds_remaining
!= -1)
613 std
->dma_addr
= dma_map_single(&whc
->umc
->dev
, std
->bounce_buf
, std
->len
,
614 is_out
? DMA_TO_DEVICE
: DMA_FROM_DEVICE
);
616 if (qset_fill_page_list(whc
, std
, mem_flags
) < 0)
619 std
->ntds_remaining
= ntds
--;
626 * qset_add_urb - add an urb to the qset's queue.
628 * The URB is chopped into sTDs, one for each qTD that will required.
629 * At least one qTD (and sTD) is required even if the transfer has no
630 * data (e.g., for some control transfers).
632 int qset_add_urb(struct whc
*whc
, struct whc_qset
*qset
, struct urb
*urb
,
635 struct whc_urb
*wurb
;
636 int remaining
= urb
->transfer_buffer_length
;
637 u64 transfer_dma
= urb
->transfer_dma
;
641 wurb
= kzalloc(sizeof(struct whc_urb
), mem_flags
);
647 INIT_WORK(&wurb
->dequeue_work
, urb_dequeue_work
);
650 ret
= qset_add_urb_sg(whc
, qset
, urb
, mem_flags
);
651 if (ret
== -EINVAL
) {
652 qset_free_stds(qset
, urb
);
653 ret
= qset_add_urb_sg_linearize(whc
, qset
, urb
, mem_flags
);
660 ntds_remaining
= DIV_ROUND_UP(remaining
, QTD_MAX_XFER_SIZE
);
661 if (ntds_remaining
== 0)
664 while (ntds_remaining
) {
669 if (std_len
> QTD_MAX_XFER_SIZE
)
670 std_len
= QTD_MAX_XFER_SIZE
;
672 std
= qset_new_std(whc
, qset
, urb
, mem_flags
);
676 std
->dma_addr
= transfer_dma
;
678 std
->ntds_remaining
= ntds_remaining
;
680 if (qset_fill_page_list(whc
, std
, mem_flags
) < 0)
684 remaining
-= std_len
;
685 transfer_dma
+= std_len
;
691 qset_free_stds(qset
, urb
);
696 * qset_remove_urb - remove an URB from the urb queue.
698 * The URB is returned to the USB subsystem.
700 void qset_remove_urb(struct whc
*whc
, struct whc_qset
*qset
,
701 struct urb
*urb
, int status
)
703 struct wusbhc
*wusbhc
= &whc
->wusbhc
;
704 struct whc_urb
*wurb
= urb
->hcpriv
;
706 usb_hcd_unlink_urb_from_ep(&wusbhc
->usb_hcd
, urb
);
707 /* Drop the lock as urb->complete() may enqueue another urb. */
708 spin_unlock(&whc
->lock
);
709 wusbhc_giveback_urb(wusbhc
, urb
, status
);
710 spin_lock(&whc
->lock
);
716 * get_urb_status_from_qtd - get the completed urb status from qTD status
717 * @urb: completed urb
718 * @status: qTD status
720 static int get_urb_status_from_qtd(struct urb
*urb
, u32 status
)
722 if (status
& QTD_STS_HALTED
) {
723 if (status
& QTD_STS_DBE
)
724 return usb_pipein(urb
->pipe
) ? -ENOSR
: -ECOMM
;
725 else if (status
& QTD_STS_BABBLE
)
727 else if (status
& QTD_STS_RCE
)
731 if (usb_pipein(urb
->pipe
)
732 && (urb
->transfer_flags
& URB_SHORT_NOT_OK
)
733 && urb
->actual_length
< urb
->transfer_buffer_length
)
739 * process_inactive_qtd - process an inactive (but not halted) qTD.
741 * Update the urb with the transfer bytes from the qTD, if the urb is
742 * completely transferred or (in the case of an IN only) the LPF is
743 * set, then the transfer is complete and the urb should be returned
746 void process_inactive_qtd(struct whc
*whc
, struct whc_qset
*qset
,
749 struct whc_std
*std
= list_first_entry(&qset
->stds
, struct whc_std
, list_node
);
750 struct urb
*urb
= std
->urb
;
754 status
= le32_to_cpu(qtd
->status
);
756 urb
->actual_length
+= std
->len
- QTD_STS_TO_LEN(status
);
758 if (usb_pipein(urb
->pipe
) && (status
& QTD_STS_LAST_PKT
))
761 complete
= whc_std_last(std
);
763 qset_remove_qtd(whc
, qset
);
764 qset_free_std(whc
, std
);
767 * Transfers for this URB are complete? Then return it to the
771 qset_remove_qtds(whc
, qset
, urb
);
772 qset_remove_urb(whc
, qset
, urb
, get_urb_status_from_qtd(urb
, status
));
775 * If iAlt isn't valid then the hardware didn't
776 * advance iCur. Adjust the start and end pointers to
779 if (!(status
& QTD_STS_IALT_VALID
))
780 qset
->td_start
= qset
->td_end
781 = QH_STATUS_TO_ICUR(le16_to_cpu(qset
->qh
.status
));
782 qset
->pause_after_urb
= NULL
;
787 * process_halted_qtd - process a qset with a halted qtd
789 * Remove all the qTDs for the failed URB and return the failed URB to
790 * the USB subsystem. Then remove all other qTDs so the qset can be
793 * FIXME: this is the point where rate adaptation can be done. If a
794 * transfer failed because it exceeded the maximum number of retries
795 * then it could be reactivated with a slower rate without having to
798 void process_halted_qtd(struct whc
*whc
, struct whc_qset
*qset
,
801 struct whc_std
*std
= list_first_entry(&qset
->stds
, struct whc_std
, list_node
);
802 struct urb
*urb
= std
->urb
;
805 urb_status
= get_urb_status_from_qtd(urb
, le32_to_cpu(qtd
->status
));
807 qset_remove_qtds(whc
, qset
, urb
);
808 qset_remove_urb(whc
, qset
, urb
, urb_status
);
810 list_for_each_entry(std
, &qset
->stds
, list_node
) {
813 qset_remove_qtd(whc
, qset
);
820 void qset_free(struct whc
*whc
, struct whc_qset
*qset
)
822 dma_pool_free(whc
->qset_pool
, qset
, qset
->qset_dma
);
826 * qset_delete - wait for a qset to be unused, then free it.
828 void qset_delete(struct whc
*whc
, struct whc_qset
*qset
)
830 wait_for_completion(&qset
->remove_complete
);
831 qset_free(whc
, qset
);