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