]>
git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/usb/host/whci/asl.c
1 // SPDX-License-Identifier: GPL-2.0
3 * Wireless Host Controller (WHC) asynchronous schedule management.
5 * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
7 #include <linux/kernel.h>
9 #include <linux/dma-mapping.h>
10 #include <linux/uwb/umc.h>
11 #include <linux/usb.h>
13 #include "../../wusbcore/wusbhc.h"
17 static void qset_get_next_prev(struct whc
*whc
, struct whc_qset
*qset
,
18 struct whc_qset
**next
, struct whc_qset
**prev
)
20 struct list_head
*n
, *p
;
22 BUG_ON(list_empty(&whc
->async_list
));
24 n
= qset
->list_node
.next
;
25 if (n
== &whc
->async_list
)
27 p
= qset
->list_node
.prev
;
28 if (p
== &whc
->async_list
)
31 *next
= container_of(n
, struct whc_qset
, list_node
);
32 *prev
= container_of(p
, struct whc_qset
, list_node
);
36 static void asl_qset_insert_begin(struct whc
*whc
, struct whc_qset
*qset
)
38 list_move(&qset
->list_node
, &whc
->async_list
);
39 qset
->in_sw_list
= true;
42 static void asl_qset_insert(struct whc
*whc
, struct whc_qset
*qset
)
44 struct whc_qset
*next
, *prev
;
46 qset_clear(whc
, qset
);
49 qset_get_next_prev(whc
, qset
, &next
, &prev
);
50 whc_qset_set_link_ptr(&qset
->qh
.link
, next
->qset_dma
);
51 whc_qset_set_link_ptr(&prev
->qh
.link
, qset
->qset_dma
);
52 qset
->in_hw_list
= true;
55 static void asl_qset_remove(struct whc
*whc
, struct whc_qset
*qset
)
57 struct whc_qset
*prev
, *next
;
59 qset_get_next_prev(whc
, qset
, &next
, &prev
);
61 list_move(&qset
->list_node
, &whc
->async_removed_list
);
62 qset
->in_sw_list
= false;
65 * No more qsets in the ASL? The caller must stop the ASL as
66 * it's no longer valid.
68 if (list_empty(&whc
->async_list
))
71 /* Remove from ASL. */
72 whc_qset_set_link_ptr(&prev
->qh
.link
, next
->qset_dma
);
73 qset
->in_hw_list
= false;
77 * process_qset - process any recently inactivated or halted qTDs in a
80 * After inactive qTDs are removed, new qTDs can be added if the
81 * urb queue still contains URBs.
83 * Returns any additional WUSBCMD bits for the ASL sync command (i.e.,
84 * WUSBCMD_ASYNC_QSET_RM if a halted qset was removed).
86 static uint32_t process_qset(struct whc
*whc
, struct whc_qset
*qset
)
88 enum whc_update update
= 0;
96 td
= &qset
->qtd
[qset
->td_start
];
97 status
= le32_to_cpu(td
->status
);
100 * Nothing to do with a still active qTD.
102 if (status
& QTD_STS_ACTIVE
)
105 if (status
& QTD_STS_HALTED
) {
107 process_halted_qtd(whc
, qset
, td
);
108 /* A halted qTD always triggers an update
109 because the qset was either removed or
111 update
|= WHC_UPDATE_UPDATED
;
115 /* Mmm, a completed qTD. */
116 process_inactive_qtd(whc
, qset
, td
);
120 update
|= qset_add_qtds(whc
, qset
);
124 * Remove this qset from the ASL if requested, but only if has
127 if (qset
->remove
&& qset
->ntds
== 0) {
128 asl_qset_remove(whc
, qset
);
129 update
|= WHC_UPDATE_REMOVED
;
134 void asl_start(struct whc
*whc
)
136 struct whc_qset
*qset
;
138 qset
= list_first_entry(&whc
->async_list
, struct whc_qset
, list_node
);
140 le_writeq(qset
->qset_dma
| QH_LINK_NTDS(8), whc
->base
+ WUSBASYNCLISTADDR
);
142 whc_write_wusbcmd(whc
, WUSBCMD_ASYNC_EN
, WUSBCMD_ASYNC_EN
);
143 whci_wait_for(&whc
->umc
->dev
, whc
->base
+ WUSBSTS
,
144 WUSBSTS_ASYNC_SCHED
, WUSBSTS_ASYNC_SCHED
,
148 void asl_stop(struct whc
*whc
)
150 whc_write_wusbcmd(whc
, WUSBCMD_ASYNC_EN
, 0);
151 whci_wait_for(&whc
->umc
->dev
, whc
->base
+ WUSBSTS
,
152 WUSBSTS_ASYNC_SCHED
, 0,
157 * asl_update - request an ASL update and wait for the hardware to be synced
159 * @wusbcmd: WUSBCMD value to start the update.
161 * If the WUSB HC is inactive (i.e., the ASL is stopped) then the
162 * update must be skipped as the hardware may not respond to update
165 void asl_update(struct whc
*whc
, uint32_t wusbcmd
)
167 struct wusbhc
*wusbhc
= &whc
->wusbhc
;
170 mutex_lock(&wusbhc
->mutex
);
171 if (wusbhc
->active
) {
172 whc_write_wusbcmd(whc
, wusbcmd
, wusbcmd
);
173 t
= wait_event_timeout(
175 (le_readl(whc
->base
+ WUSBCMD
) & WUSBCMD_ASYNC_UPDATED
) == 0,
176 msecs_to_jiffies(1000));
178 whc_hw_error(whc
, "ASL update timeout");
180 mutex_unlock(&wusbhc
->mutex
);
184 * scan_async_work - scan the ASL for qsets to process.
186 * Process each qset in the ASL in turn and then signal the WHC that
187 * the ASL has been updated.
189 * Then start, stop or update the asynchronous schedule as required.
191 void scan_async_work(struct work_struct
*work
)
193 struct whc
*whc
= container_of(work
, struct whc
, async_work
);
194 struct whc_qset
*qset
, *t
;
195 enum whc_update update
= 0;
197 spin_lock_irq(&whc
->lock
);
200 * Transerve the software list backwards so new qsets can be
201 * safely inserted into the ASL without making it non-circular.
203 list_for_each_entry_safe_reverse(qset
, t
, &whc
->async_list
, list_node
) {
204 if (!qset
->in_hw_list
) {
205 asl_qset_insert(whc
, qset
);
206 update
|= WHC_UPDATE_ADDED
;
209 update
|= process_qset(whc
, qset
);
212 spin_unlock_irq(&whc
->lock
);
215 uint32_t wusbcmd
= WUSBCMD_ASYNC_UPDATED
| WUSBCMD_ASYNC_SYNCED_DB
;
216 if (update
& WHC_UPDATE_REMOVED
)
217 wusbcmd
|= WUSBCMD_ASYNC_QSET_RM
;
218 asl_update(whc
, wusbcmd
);
222 * Now that the ASL is updated, complete the removal of any
225 * If the qset was to be reset, do so and reinsert it into the
226 * ASL if it has pending transfers.
228 spin_lock_irq(&whc
->lock
);
230 list_for_each_entry_safe(qset
, t
, &whc
->async_removed_list
, list_node
) {
231 qset_remove_complete(whc
, qset
);
233 qset_reset(whc
, qset
);
234 if (!list_empty(&qset
->stds
)) {
235 asl_qset_insert_begin(whc
, qset
);
236 queue_work(whc
->workqueue
, &whc
->async_work
);
241 spin_unlock_irq(&whc
->lock
);
245 * asl_urb_enqueue - queue an URB onto the asynchronous list (ASL).
246 * @whc: the WHCI host controller
247 * @urb: the URB to enqueue
248 * @mem_flags: flags for any memory allocations
250 * The qset for the endpoint is obtained and the urb queued on to it.
252 * Work is scheduled to update the hardware's view of the ASL.
254 int asl_urb_enqueue(struct whc
*whc
, struct urb
*urb
, gfp_t mem_flags
)
256 struct whc_qset
*qset
;
260 spin_lock_irqsave(&whc
->lock
, flags
);
262 err
= usb_hcd_link_urb_to_ep(&whc
->wusbhc
.usb_hcd
, urb
);
264 spin_unlock_irqrestore(&whc
->lock
, flags
);
268 qset
= get_qset(whc
, urb
, GFP_ATOMIC
);
272 err
= qset_add_urb(whc
, qset
, urb
, GFP_ATOMIC
);
274 if (!qset
->in_sw_list
&& !qset
->remove
)
275 asl_qset_insert_begin(whc
, qset
);
277 usb_hcd_unlink_urb_from_ep(&whc
->wusbhc
.usb_hcd
, urb
);
279 spin_unlock_irqrestore(&whc
->lock
, flags
);
282 queue_work(whc
->workqueue
, &whc
->async_work
);
288 * asl_urb_dequeue - remove an URB (qset) from the async list.
289 * @whc: the WHCI host controller
290 * @urb: the URB to dequeue
291 * @status: the current status of the URB
293 * URBs that do yet have qTDs can simply be removed from the software
294 * queue, otherwise the qset must be removed from the ASL so the qTDs
297 int asl_urb_dequeue(struct whc
*whc
, struct urb
*urb
, int status
)
299 struct whc_urb
*wurb
= urb
->hcpriv
;
300 struct whc_qset
*qset
= wurb
->qset
;
301 struct whc_std
*std
, *t
;
302 bool has_qtd
= false;
306 spin_lock_irqsave(&whc
->lock
, flags
);
308 ret
= usb_hcd_check_unlink_urb(&whc
->wusbhc
.usb_hcd
, urb
, status
);
312 list_for_each_entry_safe(std
, t
, &qset
->stds
, list_node
) {
313 if (std
->urb
== urb
) {
316 qset_free_std(whc
, std
);
318 std
->qtd
= NULL
; /* so this std is re-added when the qset is */
322 asl_qset_remove(whc
, qset
);
323 wurb
->status
= status
;
324 wurb
->is_async
= true;
325 queue_work(whc
->workqueue
, &wurb
->dequeue_work
);
327 qset_remove_urb(whc
, qset
, urb
, status
);
329 spin_unlock_irqrestore(&whc
->lock
, flags
);
335 * asl_qset_delete - delete a qset from the ASL
337 void asl_qset_delete(struct whc
*whc
, struct whc_qset
*qset
)
340 queue_work(whc
->workqueue
, &whc
->async_work
);
341 qset_delete(whc
, qset
);
345 * asl_init - initialize the asynchronous schedule list
347 * A dummy qset with no qTDs is added to the ASL to simplify removing
348 * qsets (no need to stop the ASL when the last qset is removed).
350 int asl_init(struct whc
*whc
)
352 struct whc_qset
*qset
;
354 qset
= qset_alloc(whc
, GFP_KERNEL
);
358 asl_qset_insert_begin(whc
, qset
);
359 asl_qset_insert(whc
, qset
);
365 * asl_clean_up - free ASL resources
367 * The ASL is stopped and empty except for the dummy qset.
369 void asl_clean_up(struct whc
*whc
)
371 struct whc_qset
*qset
;
373 if (!list_empty(&whc
->async_list
)) {
374 qset
= list_first_entry(&whc
->async_list
, struct whc_qset
, list_node
);
375 list_del(&qset
->list_node
);
376 qset_free(whc
, qset
);