1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/kernel.h>
19#include <linux/gfp.h>
20#include <linux/dma-mapping.h>
21#include <linux/uwb/umc.h>
22#include <linux/usb.h>
23
24#include "../../wusbcore/wusbhc.h"
25
26#include "whcd.h"
27
28static void qset_get_next_prev(struct whc *whc, struct whc_qset *qset,
29 struct whc_qset **next, struct whc_qset **prev)
30{
31 struct list_head *n, *p;
32
33 BUG_ON(list_empty(&whc->async_list));
34
35 n = qset->list_node.next;
36 if (n == &whc->async_list)
37 n = n->next;
38 p = qset->list_node.prev;
39 if (p == &whc->async_list)
40 p = p->prev;
41
42 *next = container_of(n, struct whc_qset, list_node);
43 *prev = container_of(p, struct whc_qset, list_node);
44
45}
46
47static void asl_qset_insert_begin(struct whc *whc, struct whc_qset *qset)
48{
49 list_move(&qset->list_node, &whc->async_list);
50 qset->in_sw_list = true;
51}
52
53static void asl_qset_insert(struct whc *whc, struct whc_qset *qset)
54{
55 struct whc_qset *next, *prev;
56
57 qset_clear(whc, qset);
58
59
60 qset_get_next_prev(whc, qset, &next, &prev);
61 whc_qset_set_link_ptr(&qset->qh.link, next->qset_dma);
62 whc_qset_set_link_ptr(&prev->qh.link, qset->qset_dma);
63 qset->in_hw_list = true;
64}
65
66static void asl_qset_remove(struct whc *whc, struct whc_qset *qset)
67{
68 struct whc_qset *prev, *next;
69
70 qset_get_next_prev(whc, qset, &next, &prev);
71
72 list_move(&qset->list_node, &whc->async_removed_list);
73 qset->in_sw_list = false;
74
75
76
77
78
79 if (list_empty(&whc->async_list))
80 return;
81
82
83 whc_qset_set_link_ptr(&prev->qh.link, next->qset_dma);
84 qset->in_hw_list = false;
85}
86
87
88
89
90
91
92
93
94
95
96
97static uint32_t process_qset(struct whc *whc, struct whc_qset *qset)
98{
99 enum whc_update update = 0;
100 uint32_t status = 0;
101
102 while (qset->ntds) {
103 struct whc_qtd *td;
104 int t;
105
106 t = qset->td_start;
107 td = &qset->qtd[qset->td_start];
108 status = le32_to_cpu(td->status);
109
110
111
112
113 if (status & QTD_STS_ACTIVE)
114 break;
115
116 if (status & QTD_STS_HALTED) {
117
118 process_halted_qtd(whc, qset, td);
119
120
121
122 update |= WHC_UPDATE_UPDATED;
123 goto done;
124 }
125
126
127 process_inactive_qtd(whc, qset, td);
128 }
129
130 if (!qset->remove)
131 update |= qset_add_qtds(whc, qset);
132
133done:
134
135
136
137
138 if (qset->remove && qset->ntds == 0) {
139 asl_qset_remove(whc, qset);
140 update |= WHC_UPDATE_REMOVED;
141 }
142 return update;
143}
144
145void asl_start(struct whc *whc)
146{
147 struct whc_qset *qset;
148
149 qset = list_first_entry(&whc->async_list, struct whc_qset, list_node);
150
151 le_writeq(qset->qset_dma | QH_LINK_NTDS(8), whc->base + WUSBASYNCLISTADDR);
152
153 whc_write_wusbcmd(whc, WUSBCMD_ASYNC_EN, WUSBCMD_ASYNC_EN);
154 whci_wait_for(&whc->umc->dev, whc->base + WUSBSTS,
155 WUSBSTS_ASYNC_SCHED, WUSBSTS_ASYNC_SCHED,
156 1000, "start ASL");
157}
158
159void asl_stop(struct whc *whc)
160{
161 whc_write_wusbcmd(whc, WUSBCMD_ASYNC_EN, 0);
162 whci_wait_for(&whc->umc->dev, whc->base + WUSBSTS,
163 WUSBSTS_ASYNC_SCHED, 0,
164 1000, "stop ASL");
165}
166
167
168
169
170
171
172
173
174
175
176void asl_update(struct whc *whc, uint32_t wusbcmd)
177{
178 struct wusbhc *wusbhc = &whc->wusbhc;
179 long t;
180
181 mutex_lock(&wusbhc->mutex);
182 if (wusbhc->active) {
183 whc_write_wusbcmd(whc, wusbcmd, wusbcmd);
184 t = wait_event_timeout(
185 whc->async_list_wq,
186 (le_readl(whc->base + WUSBCMD) & WUSBCMD_ASYNC_UPDATED) == 0,
187 msecs_to_jiffies(1000));
188 if (t == 0)
189 whc_hw_error(whc, "ASL update timeout");
190 }
191 mutex_unlock(&wusbhc->mutex);
192}
193
194
195
196
197
198
199
200
201
202void scan_async_work(struct work_struct *work)
203{
204 struct whc *whc = container_of(work, struct whc, async_work);
205 struct whc_qset *qset, *t;
206 enum whc_update update = 0;
207
208 spin_lock_irq(&whc->lock);
209
210
211
212
213
214 list_for_each_entry_safe_reverse(qset, t, &whc->async_list, list_node) {
215 if (!qset->in_hw_list) {
216 asl_qset_insert(whc, qset);
217 update |= WHC_UPDATE_ADDED;
218 }
219
220 update |= process_qset(whc, qset);
221 }
222
223 spin_unlock_irq(&whc->lock);
224
225 if (update) {
226 uint32_t wusbcmd = WUSBCMD_ASYNC_UPDATED | WUSBCMD_ASYNC_SYNCED_DB;
227 if (update & WHC_UPDATE_REMOVED)
228 wusbcmd |= WUSBCMD_ASYNC_QSET_RM;
229 asl_update(whc, wusbcmd);
230 }
231
232
233
234
235
236
237
238
239 spin_lock_irq(&whc->lock);
240
241 list_for_each_entry_safe(qset, t, &whc->async_removed_list, list_node) {
242 qset_remove_complete(whc, qset);
243 if (qset->reset) {
244 qset_reset(whc, qset);
245 if (!list_empty(&qset->stds)) {
246 asl_qset_insert_begin(whc, qset);
247 queue_work(whc->workqueue, &whc->async_work);
248 }
249 }
250 }
251
252 spin_unlock_irq(&whc->lock);
253}
254
255
256
257
258
259
260
261
262
263
264
265int asl_urb_enqueue(struct whc *whc, struct urb *urb, gfp_t mem_flags)
266{
267 struct whc_qset *qset;
268 int err;
269 unsigned long flags;
270
271 spin_lock_irqsave(&whc->lock, flags);
272
273 err = usb_hcd_link_urb_to_ep(&whc->wusbhc.usb_hcd, urb);
274 if (err < 0) {
275 spin_unlock_irqrestore(&whc->lock, flags);
276 return err;
277 }
278
279 qset = get_qset(whc, urb, GFP_ATOMIC);
280 if (qset == NULL)
281 err = -ENOMEM;
282 else
283 err = qset_add_urb(whc, qset, urb, GFP_ATOMIC);
284 if (!err) {
285 if (!qset->in_sw_list && !qset->remove)
286 asl_qset_insert_begin(whc, qset);
287 } else
288 usb_hcd_unlink_urb_from_ep(&whc->wusbhc.usb_hcd, urb);
289
290 spin_unlock_irqrestore(&whc->lock, flags);
291
292 if (!err)
293 queue_work(whc->workqueue, &whc->async_work);
294
295 return err;
296}
297
298
299
300
301
302
303
304
305
306
307
308int asl_urb_dequeue(struct whc *whc, struct urb *urb, int status)
309{
310 struct whc_urb *wurb = urb->hcpriv;
311 struct whc_qset *qset = wurb->qset;
312 struct whc_std *std, *t;
313 bool has_qtd = false;
314 int ret;
315 unsigned long flags;
316
317 spin_lock_irqsave(&whc->lock, flags);
318
319 ret = usb_hcd_check_unlink_urb(&whc->wusbhc.usb_hcd, urb, status);
320 if (ret < 0)
321 goto out;
322
323 list_for_each_entry_safe(std, t, &qset->stds, list_node) {
324 if (std->urb == urb) {
325 if (std->qtd)
326 has_qtd = true;
327 qset_free_std(whc, std);
328 } else
329 std->qtd = NULL;
330 }
331
332 if (has_qtd) {
333 asl_qset_remove(whc, qset);
334 wurb->status = status;
335 wurb->is_async = true;
336 queue_work(whc->workqueue, &wurb->dequeue_work);
337 } else
338 qset_remove_urb(whc, qset, urb, status);
339out:
340 spin_unlock_irqrestore(&whc->lock, flags);
341
342 return ret;
343}
344
345
346
347
348void asl_qset_delete(struct whc *whc, struct whc_qset *qset)
349{
350 qset->remove = 1;
351 queue_work(whc->workqueue, &whc->async_work);
352 qset_delete(whc, qset);
353}
354
355
356
357
358
359
360
361int asl_init(struct whc *whc)
362{
363 struct whc_qset *qset;
364
365 qset = qset_alloc(whc, GFP_KERNEL);
366 if (qset == NULL)
367 return -ENOMEM;
368
369 asl_qset_insert_begin(whc, qset);
370 asl_qset_insert(whc, qset);
371
372 return 0;
373}
374
375
376
377
378
379
380void asl_clean_up(struct whc *whc)
381{
382 struct whc_qset *qset;
383
384 if (!list_empty(&whc->async_list)) {
385 qset = list_first_entry(&whc->async_list, struct whc_qset, list_node);
386 list_del(&qset->list_node);
387 qset_free(whc, qset);
388 }
389}
390