2 * Wireless Host Controller (WHC) asynchronous schedule 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 static void qset_get_next_prev(struct whc
*whc
, struct whc_qset
*qset
,
28 struct whc_qset
**next
, struct whc_qset
**prev
)
30 struct list_head
*n
, *p
;
32 BUG_ON(list_empty(&whc
->async_list
));
34 n
= qset
->list_node
.next
;
35 if (n
== &whc
->async_list
)
37 p
= qset
->list_node
.prev
;
38 if (p
== &whc
->async_list
)
41 *next
= container_of(n
, struct whc_qset
, list_node
);
42 *prev
= container_of(p
, struct whc_qset
, list_node
);
46 static void asl_qset_insert_begin(struct whc
*whc
, struct whc_qset
*qset
)
48 list_move(&qset
->list_node
, &whc
->async_list
);
49 qset
->in_sw_list
= true;
52 static void asl_qset_insert(struct whc
*whc
, struct whc_qset
*qset
)
54 struct whc_qset
*next
, *prev
;
56 qset_clear(whc
, qset
);
59 qset_get_next_prev(whc
, qset
, &next
, &prev
);
60 whc_qset_set_link_ptr(&qset
->qh
.link
, next
->qset_dma
);
61 whc_qset_set_link_ptr(&prev
->qh
.link
, qset
->qset_dma
);
62 qset
->in_hw_list
= true;
65 static void asl_qset_remove(struct whc
*whc
, struct whc_qset
*qset
)
67 struct whc_qset
*prev
, *next
;
69 qset_get_next_prev(whc
, qset
, &next
, &prev
);
71 list_move(&qset
->list_node
, &whc
->async_removed_list
);
72 qset
->in_sw_list
= false;
75 * No more qsets in the ASL? The caller must stop the ASL as
76 * it's no longer valid.
78 if (list_empty(&whc
->async_list
))
81 /* Remove from ASL. */
82 whc_qset_set_link_ptr(&prev
->qh
.link
, next
->qset_dma
);
83 qset
->in_hw_list
= false;
87 * process_qset - process any recently inactivated or halted qTDs in a
90 * After inactive qTDs are removed, new qTDs can be added if the
91 * urb queue still contains URBs.
93 * Returns any additional WUSBCMD bits for the ASL sync command (i.e.,
94 * WUSBCMD_ASYNC_QSET_RM if a halted qset was removed).
96 static uint32_t process_qset(struct whc
*whc
, struct whc_qset
*qset
)
98 enum whc_update update
= 0;
106 td
= &qset
->qtd
[qset
->td_start
];
107 status
= le32_to_cpu(td
->status
);
110 * Nothing to do with a still active qTD.
112 if (status
& QTD_STS_ACTIVE
)
115 if (status
& QTD_STS_HALTED
) {
117 process_halted_qtd(whc
, qset
, td
);
118 /* A halted qTD always triggers an update
119 because the qset was either removed or
121 update
|= WHC_UPDATE_UPDATED
;
125 /* Mmm, a completed qTD. */
126 process_inactive_qtd(whc
, qset
, td
);
130 update
|= qset_add_qtds(whc
, qset
);
134 * Remove this qset from the ASL if requested, but only if has
137 if (qset
->remove
&& qset
->ntds
== 0) {
138 asl_qset_remove(whc
, qset
);
139 update
|= WHC_UPDATE_REMOVED
;
144 void asl_start(struct whc
*whc
)
146 struct whc_qset
*qset
;
148 qset
= list_first_entry(&whc
->async_list
, struct whc_qset
, list_node
);
150 le_writeq(qset
->qset_dma
| QH_LINK_NTDS(8), whc
->base
+ WUSBASYNCLISTADDR
);
152 whc_write_wusbcmd(whc
, WUSBCMD_ASYNC_EN
, WUSBCMD_ASYNC_EN
);
153 whci_wait_for(&whc
->umc
->dev
, whc
->base
+ WUSBSTS
,
154 WUSBSTS_ASYNC_SCHED
, WUSBSTS_ASYNC_SCHED
,
158 void asl_stop(struct whc
*whc
)
160 whc_write_wusbcmd(whc
, WUSBCMD_ASYNC_EN
, 0);
161 whci_wait_for(&whc
->umc
->dev
, whc
->base
+ WUSBSTS
,
162 WUSBSTS_ASYNC_SCHED
, 0,
167 * asl_update - request an ASL update and wait for the hardware to be synced
169 * @wusbcmd: WUSBCMD value to start the update.
171 * If the WUSB HC is inactive (i.e., the ASL is stopped) then the
172 * update must be skipped as the hardware may not respond to update
175 void asl_update(struct whc
*whc
, uint32_t wusbcmd
)
177 struct wusbhc
*wusbhc
= &whc
->wusbhc
;
180 mutex_lock(&wusbhc
->mutex
);
181 if (wusbhc
->active
) {
182 whc_write_wusbcmd(whc
, wusbcmd
, wusbcmd
);
183 t
= wait_event_timeout(
185 (le_readl(whc
->base
+ WUSBCMD
) & WUSBCMD_ASYNC_UPDATED
) == 0,
186 msecs_to_jiffies(1000));
188 whc_hw_error(whc
, "ASL update timeout");
190 mutex_unlock(&wusbhc
->mutex
);
194 * scan_async_work - scan the ASL for qsets to process.
196 * Process each qset in the ASL in turn and then signal the WHC that
197 * the ASL has been updated.
199 * Then start, stop or update the asynchronous schedule as required.
201 void scan_async_work(struct work_struct
*work
)
203 struct whc
*whc
= container_of(work
, struct whc
, async_work
);
204 struct whc_qset
*qset
, *t
;
205 enum whc_update update
= 0;
207 spin_lock_irq(&whc
->lock
);
210 * Transerve the software list backwards so new qsets can be
211 * safely inserted into the ASL without making it non-circular.
213 list_for_each_entry_safe_reverse(qset
, t
, &whc
->async_list
, list_node
) {
214 if (!qset
->in_hw_list
) {
215 asl_qset_insert(whc
, qset
);
216 update
|= WHC_UPDATE_ADDED
;
219 update
|= process_qset(whc
, qset
);
222 spin_unlock_irq(&whc
->lock
);
225 uint32_t wusbcmd
= WUSBCMD_ASYNC_UPDATED
| WUSBCMD_ASYNC_SYNCED_DB
;
226 if (update
& WHC_UPDATE_REMOVED
)
227 wusbcmd
|= WUSBCMD_ASYNC_QSET_RM
;
228 asl_update(whc
, wusbcmd
);
232 * Now that the ASL is updated, complete the removal of any
235 * If the qset was to be reset, do so and reinsert it into the
236 * ASL if it has pending transfers.
238 spin_lock_irq(&whc
->lock
);
240 list_for_each_entry_safe(qset
, t
, &whc
->async_removed_list
, list_node
) {
241 qset_remove_complete(whc
, qset
);
243 qset_reset(whc
, qset
);
244 if (!list_empty(&qset
->stds
)) {
245 asl_qset_insert_begin(whc
, qset
);
246 queue_work(whc
->workqueue
, &whc
->async_work
);
251 spin_unlock_irq(&whc
->lock
);
255 * asl_urb_enqueue - queue an URB onto the asynchronous list (ASL).
256 * @whc: the WHCI host controller
257 * @urb: the URB to enqueue
258 * @mem_flags: flags for any memory allocations
260 * The qset for the endpoint is obtained and the urb queued on to it.
262 * Work is scheduled to update the hardware's view of the ASL.
264 int asl_urb_enqueue(struct whc
*whc
, struct urb
*urb
, gfp_t mem_flags
)
266 struct whc_qset
*qset
;
270 spin_lock_irqsave(&whc
->lock
, flags
);
272 err
= usb_hcd_link_urb_to_ep(&whc
->wusbhc
.usb_hcd
, urb
);
274 spin_unlock_irqrestore(&whc
->lock
, flags
);
278 qset
= get_qset(whc
, urb
, GFP_ATOMIC
);
282 err
= qset_add_urb(whc
, qset
, urb
, GFP_ATOMIC
);
284 if (!qset
->in_sw_list
&& !qset
->remove
)
285 asl_qset_insert_begin(whc
, qset
);
287 usb_hcd_unlink_urb_from_ep(&whc
->wusbhc
.usb_hcd
, urb
);
289 spin_unlock_irqrestore(&whc
->lock
, flags
);
292 queue_work(whc
->workqueue
, &whc
->async_work
);
298 * asl_urb_dequeue - remove an URB (qset) from the async list.
299 * @whc: the WHCI host controller
300 * @urb: the URB to dequeue
301 * @status: the current status of the URB
303 * URBs that do yet have qTDs can simply be removed from the software
304 * queue, otherwise the qset must be removed from the ASL so the qTDs
307 int asl_urb_dequeue(struct whc
*whc
, struct urb
*urb
, int status
)
309 struct whc_urb
*wurb
= urb
->hcpriv
;
310 struct whc_qset
*qset
= wurb
->qset
;
311 struct whc_std
*std
, *t
;
312 bool has_qtd
= false;
316 spin_lock_irqsave(&whc
->lock
, flags
);
318 ret
= usb_hcd_check_unlink_urb(&whc
->wusbhc
.usb_hcd
, urb
, status
);
322 list_for_each_entry_safe(std
, t
, &qset
->stds
, list_node
) {
323 if (std
->urb
== urb
) {
326 qset_free_std(whc
, std
);
328 std
->qtd
= NULL
; /* so this std is re-added when the qset is */
332 asl_qset_remove(whc
, qset
);
333 wurb
->status
= status
;
334 wurb
->is_async
= true;
335 queue_work(whc
->workqueue
, &wurb
->dequeue_work
);
337 qset_remove_urb(whc
, qset
, urb
, status
);
339 spin_unlock_irqrestore(&whc
->lock
, flags
);
345 * asl_qset_delete - delete a qset from the ASL
347 void asl_qset_delete(struct whc
*whc
, struct whc_qset
*qset
)
350 queue_work(whc
->workqueue
, &whc
->async_work
);
351 qset_delete(whc
, qset
);
355 * asl_init - initialize the asynchronous schedule list
357 * A dummy qset with no qTDs is added to the ASL to simplify removing
358 * qsets (no need to stop the ASL when the last qset is removed).
360 int asl_init(struct whc
*whc
)
362 struct whc_qset
*qset
;
364 qset
= qset_alloc(whc
, GFP_KERNEL
);
368 asl_qset_insert_begin(whc
, qset
);
369 asl_qset_insert(whc
, qset
);
375 * asl_clean_up - free ASL resources
377 * The ASL is stopped and empty except for the dummy qset.
379 void asl_clean_up(struct whc
*whc
)
381 struct whc_qset
*qset
;
383 if (!list_empty(&whc
->async_list
)) {
384 qset
= list_first_entry(&whc
->async_list
, struct whc_qset
, list_node
);
385 list_del(&qset
->list_node
);
386 qset_free(whc
, qset
);