1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Wireless Host Controller (WHC) asynchronous schedule management.
4 *
5 * Copyright (C) 2007 Cambridge Silicon Radio Ltd.
6 */
7 #include <linux/kernel.h>
8 #include <linux/gfp.h>
9 #include <linux/dma-mapping.h>
10 #include <linux/usb.h>
11
12 #include "../../../uwb/include/umc.h"
13 #include "../../wusbhc.h"
14
15 #include "whcd.h"
16
qset_get_next_prev(struct whc * whc,struct whc_qset * qset,struct whc_qset ** next,struct whc_qset ** prev)17 static void qset_get_next_prev(struct whc *whc, struct whc_qset *qset,
18 struct whc_qset **next, struct whc_qset **prev)
19 {
20 struct list_head *n, *p;
21
22 BUG_ON(list_empty(&whc->async_list));
23
24 n = qset->list_node.next;
25 if (n == &whc->async_list)
26 n = n->next;
27 p = qset->list_node.prev;
28 if (p == &whc->async_list)
29 p = p->prev;
30
31 *next = container_of(n, struct whc_qset, list_node);
32 *prev = container_of(p, struct whc_qset, list_node);
33
34 }
35
asl_qset_insert_begin(struct whc * whc,struct whc_qset * qset)36 static void asl_qset_insert_begin(struct whc *whc, struct whc_qset *qset)
37 {
38 list_move(&qset->list_node, &whc->async_list);
39 qset->in_sw_list = true;
40 }
41
asl_qset_insert(struct whc * whc,struct whc_qset * qset)42 static void asl_qset_insert(struct whc *whc, struct whc_qset *qset)
43 {
44 struct whc_qset *next, *prev;
45
46 qset_clear(whc, qset);
47
48 /* Link into ASL. */
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;
53 }
54
asl_qset_remove(struct whc * whc,struct whc_qset * qset)55 static void asl_qset_remove(struct whc *whc, struct whc_qset *qset)
56 {
57 struct whc_qset *prev, *next;
58
59 qset_get_next_prev(whc, qset, &next, &prev);
60
61 list_move(&qset->list_node, &whc->async_removed_list);
62 qset->in_sw_list = false;
63
64 /*
65 * No more qsets in the ASL? The caller must stop the ASL as
66 * it's no longer valid.
67 */
68 if (list_empty(&whc->async_list))
69 return;
70
71 /* Remove from ASL. */
72 whc_qset_set_link_ptr(&prev->qh.link, next->qset_dma);
73 qset->in_hw_list = false;
74 }
75
76 /**
77 * process_qset - process any recently inactivated or halted qTDs in a
78 * qset.
79 *
80 * After inactive qTDs are removed, new qTDs can be added if the
81 * urb queue still contains URBs.
82 *
83 * Returns any additional WUSBCMD bits for the ASL sync command (i.e.,
84 * WUSBCMD_ASYNC_QSET_RM if a halted qset was removed).
85 */
process_qset(struct whc * whc,struct whc_qset * qset)86 static uint32_t process_qset(struct whc *whc, struct whc_qset *qset)
87 {
88 enum whc_update update = 0;
89 uint32_t status = 0;
90
91 while (qset->ntds) {
92 struct whc_qtd *td;
93
94 td = &qset->qtd[qset->td_start];
95 status = le32_to_cpu(td->status);
96
97 /*
98 * Nothing to do with a still active qTD.
99 */
100 if (status & QTD_STS_ACTIVE)
101 break;
102
103 if (status & QTD_STS_HALTED) {
104 /* Ug, an error. */
105 process_halted_qtd(whc, qset, td);
106 /* A halted qTD always triggers an update
107 because the qset was either removed or
108 reactivated. */
109 update |= WHC_UPDATE_UPDATED;
110 goto done;
111 }
112
113 /* Mmm, a completed qTD. */
114 process_inactive_qtd(whc, qset, td);
115 }
116
117 if (!qset->remove)
118 update |= qset_add_qtds(whc, qset);
119
120 done:
121 /*
122 * Remove this qset from the ASL if requested, but only if has
123 * no qTDs.
124 */
125 if (qset->remove && qset->ntds == 0) {
126 asl_qset_remove(whc, qset);
127 update |= WHC_UPDATE_REMOVED;
128 }
129 return update;
130 }
131
asl_start(struct whc * whc)132 void asl_start(struct whc *whc)
133 {
134 struct whc_qset *qset;
135
136 qset = list_first_entry(&whc->async_list, struct whc_qset, list_node);
137
138 le_writeq(qset->qset_dma | QH_LINK_NTDS(8), whc->base + WUSBASYNCLISTADDR);
139
140 whc_write_wusbcmd(whc, WUSBCMD_ASYNC_EN, WUSBCMD_ASYNC_EN);
141 whci_wait_for(&whc->umc->dev, whc->base + WUSBSTS,
142 WUSBSTS_ASYNC_SCHED, WUSBSTS_ASYNC_SCHED,
143 1000, "start ASL");
144 }
145
asl_stop(struct whc * whc)146 void asl_stop(struct whc *whc)
147 {
148 whc_write_wusbcmd(whc, WUSBCMD_ASYNC_EN, 0);
149 whci_wait_for(&whc->umc->dev, whc->base + WUSBSTS,
150 WUSBSTS_ASYNC_SCHED, 0,
151 1000, "stop ASL");
152 }
153
154 /**
155 * asl_update - request an ASL update and wait for the hardware to be synced
156 * @whc: the WHCI HC
157 * @wusbcmd: WUSBCMD value to start the update.
158 *
159 * If the WUSB HC is inactive (i.e., the ASL is stopped) then the
160 * update must be skipped as the hardware may not respond to update
161 * requests.
162 */
asl_update(struct whc * whc,uint32_t wusbcmd)163 void asl_update(struct whc *whc, uint32_t wusbcmd)
164 {
165 struct wusbhc *wusbhc = &whc->wusbhc;
166 long t;
167
168 mutex_lock(&wusbhc->mutex);
169 if (wusbhc->active) {
170 whc_write_wusbcmd(whc, wusbcmd, wusbcmd);
171 t = wait_event_timeout(
172 whc->async_list_wq,
173 (le_readl(whc->base + WUSBCMD) & WUSBCMD_ASYNC_UPDATED) == 0,
174 msecs_to_jiffies(1000));
175 if (t == 0)
176 whc_hw_error(whc, "ASL update timeout");
177 }
178 mutex_unlock(&wusbhc->mutex);
179 }
180
181 /**
182 * scan_async_work - scan the ASL for qsets to process.
183 *
184 * Process each qset in the ASL in turn and then signal the WHC that
185 * the ASL has been updated.
186 *
187 * Then start, stop or update the asynchronous schedule as required.
188 */
scan_async_work(struct work_struct * work)189 void scan_async_work(struct work_struct *work)
190 {
191 struct whc *whc = container_of(work, struct whc, async_work);
192 struct whc_qset *qset, *t;
193 enum whc_update update = 0;
194
195 spin_lock_irq(&whc->lock);
196
197 /*
198 * Transerve the software list backwards so new qsets can be
199 * safely inserted into the ASL without making it non-circular.
200 */
201 list_for_each_entry_safe_reverse(qset, t, &whc->async_list, list_node) {
202 if (!qset->in_hw_list) {
203 asl_qset_insert(whc, qset);
204 update |= WHC_UPDATE_ADDED;
205 }
206
207 update |= process_qset(whc, qset);
208 }
209
210 spin_unlock_irq(&whc->lock);
211
212 if (update) {
213 uint32_t wusbcmd = WUSBCMD_ASYNC_UPDATED | WUSBCMD_ASYNC_SYNCED_DB;
214 if (update & WHC_UPDATE_REMOVED)
215 wusbcmd |= WUSBCMD_ASYNC_QSET_RM;
216 asl_update(whc, wusbcmd);
217 }
218
219 /*
220 * Now that the ASL is updated, complete the removal of any
221 * removed qsets.
222 *
223 * If the qset was to be reset, do so and reinsert it into the
224 * ASL if it has pending transfers.
225 */
226 spin_lock_irq(&whc->lock);
227
228 list_for_each_entry_safe(qset, t, &whc->async_removed_list, list_node) {
229 qset_remove_complete(whc, qset);
230 if (qset->reset) {
231 qset_reset(whc, qset);
232 if (!list_empty(&qset->stds)) {
233 asl_qset_insert_begin(whc, qset);
234 queue_work(whc->workqueue, &whc->async_work);
235 }
236 }
237 }
238
239 spin_unlock_irq(&whc->lock);
240 }
241
242 /**
243 * asl_urb_enqueue - queue an URB onto the asynchronous list (ASL).
244 * @whc: the WHCI host controller
245 * @urb: the URB to enqueue
246 * @mem_flags: flags for any memory allocations
247 *
248 * The qset for the endpoint is obtained and the urb queued on to it.
249 *
250 * Work is scheduled to update the hardware's view of the ASL.
251 */
asl_urb_enqueue(struct whc * whc,struct urb * urb,gfp_t mem_flags)252 int asl_urb_enqueue(struct whc *whc, struct urb *urb, gfp_t mem_flags)
253 {
254 struct whc_qset *qset;
255 int err;
256 unsigned long flags;
257
258 spin_lock_irqsave(&whc->lock, flags);
259
260 err = usb_hcd_link_urb_to_ep(&whc->wusbhc.usb_hcd, urb);
261 if (err < 0) {
262 spin_unlock_irqrestore(&whc->lock, flags);
263 return err;
264 }
265
266 qset = get_qset(whc, urb, GFP_ATOMIC);
267 if (qset == NULL)
268 err = -ENOMEM;
269 else
270 err = qset_add_urb(whc, qset, urb, GFP_ATOMIC);
271 if (!err) {
272 if (!qset->in_sw_list && !qset->remove)
273 asl_qset_insert_begin(whc, qset);
274 } else
275 usb_hcd_unlink_urb_from_ep(&whc->wusbhc.usb_hcd, urb);
276
277 spin_unlock_irqrestore(&whc->lock, flags);
278
279 if (!err)
280 queue_work(whc->workqueue, &whc->async_work);
281
282 return err;
283 }
284
285 /**
286 * asl_urb_dequeue - remove an URB (qset) from the async list.
287 * @whc: the WHCI host controller
288 * @urb: the URB to dequeue
289 * @status: the current status of the URB
290 *
291 * URBs that do yet have qTDs can simply be removed from the software
292 * queue, otherwise the qset must be removed from the ASL so the qTDs
293 * can be removed.
294 */
asl_urb_dequeue(struct whc * whc,struct urb * urb,int status)295 int asl_urb_dequeue(struct whc *whc, struct urb *urb, int status)
296 {
297 struct whc_urb *wurb = urb->hcpriv;
298 struct whc_qset *qset = wurb->qset;
299 struct whc_std *std, *t;
300 bool has_qtd = false;
301 int ret;
302 unsigned long flags;
303
304 spin_lock_irqsave(&whc->lock, flags);
305
306 ret = usb_hcd_check_unlink_urb(&whc->wusbhc.usb_hcd, urb, status);
307 if (ret < 0)
308 goto out;
309
310 list_for_each_entry_safe(std, t, &qset->stds, list_node) {
311 if (std->urb == urb) {
312 if (std->qtd)
313 has_qtd = true;
314 qset_free_std(whc, std);
315 } else
316 std->qtd = NULL; /* so this std is re-added when the qset is */
317 }
318
319 if (has_qtd) {
320 asl_qset_remove(whc, qset);
321 wurb->status = status;
322 wurb->is_async = true;
323 queue_work(whc->workqueue, &wurb->dequeue_work);
324 } else
325 qset_remove_urb(whc, qset, urb, status);
326 out:
327 spin_unlock_irqrestore(&whc->lock, flags);
328
329 return ret;
330 }
331
332 /**
333 * asl_qset_delete - delete a qset from the ASL
334 */
asl_qset_delete(struct whc * whc,struct whc_qset * qset)335 void asl_qset_delete(struct whc *whc, struct whc_qset *qset)
336 {
337 qset->remove = 1;
338 queue_work(whc->workqueue, &whc->async_work);
339 qset_delete(whc, qset);
340 }
341
342 /**
343 * asl_init - initialize the asynchronous schedule list
344 *
345 * A dummy qset with no qTDs is added to the ASL to simplify removing
346 * qsets (no need to stop the ASL when the last qset is removed).
347 */
asl_init(struct whc * whc)348 int asl_init(struct whc *whc)
349 {
350 struct whc_qset *qset;
351
352 qset = qset_alloc(whc, GFP_KERNEL);
353 if (qset == NULL)
354 return -ENOMEM;
355
356 asl_qset_insert_begin(whc, qset);
357 asl_qset_insert(whc, qset);
358
359 return 0;
360 }
361
362 /**
363 * asl_clean_up - free ASL resources
364 *
365 * The ASL is stopped and empty except for the dummy qset.
366 */
asl_clean_up(struct whc * whc)367 void asl_clean_up(struct whc *whc)
368 {
369 struct whc_qset *qset;
370
371 if (!list_empty(&whc->async_list)) {
372 qset = list_first_entry(&whc->async_list, struct whc_qset, list_node);
373 list_del(&qset->list_node);
374 qset_free(whc, qset);
375 }
376 }
377