]>
Commit | Line | Data |
---|---|---|
7e6133aa DV |
1 | /* |
2 | * Wireless Host Controller (WHC) driver. | |
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 | */ | |
7e6133aa DV |
18 | #include <linux/kernel.h> |
19 | #include <linux/init.h> | |
20 | #include <linux/uwb/umc.h> | |
21 | ||
22 | #include "../../wusbcore/wusbhc.h" | |
23 | ||
24 | #include "whcd.h" | |
25 | ||
26 | /* | |
27 | * One time initialization. | |
28 | * | |
29 | * Nothing to do here. | |
30 | */ | |
31 | static int whc_reset(struct usb_hcd *usb_hcd) | |
32 | { | |
33 | return 0; | |
34 | } | |
35 | ||
36 | /* | |
37 | * Start the wireless host controller. | |
38 | * | |
39 | * Start device notification. | |
40 | * | |
41 | * Put hc into run state, set DNTS parameters. | |
42 | */ | |
43 | static int whc_start(struct usb_hcd *usb_hcd) | |
44 | { | |
45 | struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); | |
46 | struct whc *whc = wusbhc_to_whc(wusbhc); | |
47 | u8 bcid; | |
48 | int ret; | |
49 | ||
50 | mutex_lock(&wusbhc->mutex); | |
51 | ||
52 | le_writel(WUSBINTR_GEN_CMD_DONE | |
53 | | WUSBINTR_HOST_ERR | |
54 | | WUSBINTR_ASYNC_SCHED_SYNCED | |
55 | | WUSBINTR_DNTS_INT | |
56 | | WUSBINTR_ERR_INT | |
57 | | WUSBINTR_INT, | |
58 | whc->base + WUSBINTR); | |
59 | ||
60 | /* set cluster ID */ | |
61 | bcid = wusb_cluster_id_get(); | |
62 | ret = whc_set_cluster_id(whc, bcid); | |
63 | if (ret < 0) | |
64 | goto out; | |
65 | wusbhc->cluster_id = bcid; | |
66 | ||
67 | /* start HC */ | |
68 | whc_write_wusbcmd(whc, WUSBCMD_RUN, WUSBCMD_RUN); | |
69 | ||
70 | usb_hcd->uses_new_polling = 1; | |
71 | usb_hcd->poll_rh = 1; | |
72 | usb_hcd->state = HC_STATE_RUNNING; | |
73 | ||
74 | out: | |
75 | mutex_unlock(&wusbhc->mutex); | |
76 | return ret; | |
77 | } | |
78 | ||
79 | ||
80 | /* | |
81 | * Stop the wireless host controller. | |
82 | * | |
83 | * Stop device notification. | |
84 | * | |
85 | * Wait for pending transfer to stop? Put hc into stop state? | |
86 | */ | |
87 | static void whc_stop(struct usb_hcd *usb_hcd) | |
88 | { | |
89 | struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); | |
90 | struct whc *whc = wusbhc_to_whc(wusbhc); | |
91 | ||
92 | mutex_lock(&wusbhc->mutex); | |
93 | ||
7e6133aa DV |
94 | /* stop HC */ |
95 | le_writel(0, whc->base + WUSBINTR); | |
96 | whc_write_wusbcmd(whc, WUSBCMD_RUN, 0); | |
97 | whci_wait_for(&whc->umc->dev, whc->base + WUSBSTS, | |
98 | WUSBSTS_HCHALTED, WUSBSTS_HCHALTED, | |
99 | 100, "HC to halt"); | |
100 | ||
101 | wusb_cluster_id_put(wusbhc->cluster_id); | |
102 | ||
103 | mutex_unlock(&wusbhc->mutex); | |
104 | } | |
105 | ||
106 | static int whc_get_frame_number(struct usb_hcd *usb_hcd) | |
107 | { | |
108 | /* Frame numbers are not applicable to WUSB. */ | |
109 | return -ENOSYS; | |
110 | } | |
111 | ||
112 | ||
113 | /* | |
114 | * Queue an URB to the ASL or PZL | |
115 | */ | |
116 | static int whc_urb_enqueue(struct usb_hcd *usb_hcd, struct urb *urb, | |
117 | gfp_t mem_flags) | |
118 | { | |
119 | struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); | |
120 | struct whc *whc = wusbhc_to_whc(wusbhc); | |
121 | int ret; | |
122 | ||
123 | switch (usb_pipetype(urb->pipe)) { | |
124 | case PIPE_INTERRUPT: | |
125 | ret = pzl_urb_enqueue(whc, urb, mem_flags); | |
126 | break; | |
127 | case PIPE_ISOCHRONOUS: | |
128 | dev_err(&whc->umc->dev, "isochronous transfers unsupported\n"); | |
129 | ret = -ENOTSUPP; | |
130 | break; | |
131 | case PIPE_CONTROL: | |
132 | case PIPE_BULK: | |
133 | default: | |
134 | ret = asl_urb_enqueue(whc, urb, mem_flags); | |
135 | break; | |
136 | }; | |
137 | ||
138 | return ret; | |
139 | } | |
140 | ||
141 | /* | |
142 | * Remove a queued URB from the ASL or PZL. | |
143 | */ | |
144 | static int whc_urb_dequeue(struct usb_hcd *usb_hcd, struct urb *urb, int status) | |
145 | { | |
146 | struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); | |
147 | struct whc *whc = wusbhc_to_whc(wusbhc); | |
148 | int ret; | |
149 | ||
150 | switch (usb_pipetype(urb->pipe)) { | |
151 | case PIPE_INTERRUPT: | |
152 | ret = pzl_urb_dequeue(whc, urb, status); | |
153 | break; | |
154 | case PIPE_ISOCHRONOUS: | |
155 | ret = -ENOTSUPP; | |
156 | break; | |
157 | case PIPE_CONTROL: | |
158 | case PIPE_BULK: | |
159 | default: | |
160 | ret = asl_urb_dequeue(whc, urb, status); | |
161 | break; | |
162 | }; | |
163 | ||
164 | return ret; | |
165 | } | |
166 | ||
167 | /* | |
168 | * Wait for all URBs to the endpoint to be completed, then delete the | |
169 | * qset. | |
170 | */ | |
171 | static void whc_endpoint_disable(struct usb_hcd *usb_hcd, | |
172 | struct usb_host_endpoint *ep) | |
173 | { | |
174 | struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); | |
175 | struct whc *whc = wusbhc_to_whc(wusbhc); | |
176 | struct whc_qset *qset; | |
177 | ||
178 | qset = ep->hcpriv; | |
179 | if (qset) { | |
180 | ep->hcpriv = NULL; | |
181 | if (usb_endpoint_xfer_bulk(&ep->desc) | |
182 | || usb_endpoint_xfer_control(&ep->desc)) | |
183 | asl_qset_delete(whc, qset); | |
184 | else | |
185 | pzl_qset_delete(whc, qset); | |
186 | } | |
187 | } | |
188 | ||
7f0406db DV |
189 | static void whc_endpoint_reset(struct usb_hcd *usb_hcd, |
190 | struct usb_host_endpoint *ep) | |
191 | { | |
192 | struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); | |
193 | struct whc *whc = wusbhc_to_whc(wusbhc); | |
194 | struct whc_qset *qset; | |
831baa49 DV |
195 | unsigned long flags; |
196 | ||
197 | spin_lock_irqsave(&whc->lock, flags); | |
7f0406db DV |
198 | |
199 | qset = ep->hcpriv; | |
200 | if (qset) { | |
201 | qset->remove = 1; | |
831baa49 | 202 | qset->reset = 1; |
7f0406db DV |
203 | |
204 | if (usb_endpoint_xfer_bulk(&ep->desc) | |
205 | || usb_endpoint_xfer_control(&ep->desc)) | |
206 | queue_work(whc->workqueue, &whc->async_work); | |
207 | else | |
208 | queue_work(whc->workqueue, &whc->periodic_work); | |
7f0406db | 209 | } |
831baa49 DV |
210 | |
211 | spin_unlock_irqrestore(&whc->lock, flags); | |
7f0406db DV |
212 | } |
213 | ||
214 | ||
7e6133aa DV |
215 | static struct hc_driver whc_hc_driver = { |
216 | .description = "whci-hcd", | |
217 | .product_desc = "Wireless host controller", | |
218 | .hcd_priv_size = sizeof(struct whc) - sizeof(struct usb_hcd), | |
219 | .irq = whc_int_handler, | |
220 | .flags = HCD_USB2, | |
221 | ||
222 | .reset = whc_reset, | |
223 | .start = whc_start, | |
224 | .stop = whc_stop, | |
225 | .get_frame_number = whc_get_frame_number, | |
226 | .urb_enqueue = whc_urb_enqueue, | |
227 | .urb_dequeue = whc_urb_dequeue, | |
228 | .endpoint_disable = whc_endpoint_disable, | |
7f0406db | 229 | .endpoint_reset = whc_endpoint_reset, |
7e6133aa DV |
230 | |
231 | .hub_status_data = wusbhc_rh_status_data, | |
232 | .hub_control = wusbhc_rh_control, | |
233 | .bus_suspend = wusbhc_rh_suspend, | |
234 | .bus_resume = wusbhc_rh_resume, | |
235 | .start_port_reset = wusbhc_rh_start_port_reset, | |
236 | }; | |
237 | ||
238 | static int whc_probe(struct umc_dev *umc) | |
239 | { | |
240 | int ret = -ENOMEM; | |
241 | struct usb_hcd *usb_hcd; | |
242 | struct wusbhc *wusbhc = NULL; | |
243 | struct whc *whc = NULL; | |
244 | struct device *dev = &umc->dev; | |
245 | ||
246 | usb_hcd = usb_create_hcd(&whc_hc_driver, dev, "whci"); | |
247 | if (usb_hcd == NULL) { | |
248 | dev_err(dev, "unable to create hcd\n"); | |
249 | goto error; | |
250 | } | |
251 | ||
252 | usb_hcd->wireless = 1; | |
253 | ||
254 | wusbhc = usb_hcd_to_wusbhc(usb_hcd); | |
255 | whc = wusbhc_to_whc(wusbhc); | |
256 | whc->umc = umc; | |
257 | ||
258 | ret = whc_init(whc); | |
259 | if (ret) | |
260 | goto error; | |
261 | ||
262 | wusbhc->dev = dev; | |
263 | wusbhc->uwb_rc = uwb_rc_get_by_grandpa(umc->dev.parent); | |
264 | if (!wusbhc->uwb_rc) { | |
265 | ret = -ENODEV; | |
266 | dev_err(dev, "cannot get radio controller\n"); | |
267 | goto error; | |
268 | } | |
269 | ||
270 | if (whc->n_devices > USB_MAXCHILDREN) { | |
271 | dev_warn(dev, "USB_MAXCHILDREN too low for WUSB adapter (%u ports)\n", | |
272 | whc->n_devices); | |
273 | wusbhc->ports_max = USB_MAXCHILDREN; | |
274 | } else | |
275 | wusbhc->ports_max = whc->n_devices; | |
276 | wusbhc->mmcies_max = whc->n_mmc_ies; | |
277 | wusbhc->start = whc_wusbhc_start; | |
278 | wusbhc->stop = whc_wusbhc_stop; | |
279 | wusbhc->mmcie_add = whc_mmcie_add; | |
280 | wusbhc->mmcie_rm = whc_mmcie_rm; | |
281 | wusbhc->dev_info_set = whc_dev_info_set; | |
282 | wusbhc->bwa_set = whc_bwa_set; | |
283 | wusbhc->set_num_dnts = whc_set_num_dnts; | |
284 | wusbhc->set_ptk = whc_set_ptk; | |
285 | wusbhc->set_gtk = whc_set_gtk; | |
286 | ||
287 | ret = wusbhc_create(wusbhc); | |
288 | if (ret) | |
289 | goto error_wusbhc_create; | |
290 | ||
291 | ret = usb_add_hcd(usb_hcd, whc->umc->irq, IRQF_SHARED); | |
292 | if (ret) { | |
293 | dev_err(dev, "cannot add HCD: %d\n", ret); | |
294 | goto error_usb_add_hcd; | |
295 | } | |
296 | ||
297 | ret = wusbhc_b_create(wusbhc); | |
298 | if (ret) { | |
299 | dev_err(dev, "WUSBHC phase B setup failed: %d\n", ret); | |
300 | goto error_wusbhc_b_create; | |
301 | } | |
302 | ||
dcc7461e DV |
303 | whc_dbg_init(whc); |
304 | ||
7e6133aa DV |
305 | return 0; |
306 | ||
307 | error_wusbhc_b_create: | |
308 | usb_remove_hcd(usb_hcd); | |
309 | error_usb_add_hcd: | |
310 | wusbhc_destroy(wusbhc); | |
311 | error_wusbhc_create: | |
312 | uwb_rc_put(wusbhc->uwb_rc); | |
313 | error: | |
314 | whc_clean_up(whc); | |
315 | if (usb_hcd) | |
316 | usb_put_hcd(usb_hcd); | |
317 | return ret; | |
318 | } | |
319 | ||
320 | ||
321 | static void whc_remove(struct umc_dev *umc) | |
322 | { | |
323 | struct usb_hcd *usb_hcd = dev_get_drvdata(&umc->dev); | |
324 | struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); | |
325 | struct whc *whc = wusbhc_to_whc(wusbhc); | |
326 | ||
327 | if (usb_hcd) { | |
dcc7461e | 328 | whc_dbg_clean_up(whc); |
7e6133aa DV |
329 | wusbhc_b_destroy(wusbhc); |
330 | usb_remove_hcd(usb_hcd); | |
331 | wusbhc_destroy(wusbhc); | |
332 | uwb_rc_put(wusbhc->uwb_rc); | |
333 | whc_clean_up(whc); | |
334 | usb_put_hcd(usb_hcd); | |
335 | } | |
336 | } | |
337 | ||
338 | static struct umc_driver whci_hc_driver = { | |
339 | .name = "whci-hcd", | |
340 | .cap_id = UMC_CAP_ID_WHCI_WUSB_HC, | |
341 | .probe = whc_probe, | |
342 | .remove = whc_remove, | |
343 | }; | |
344 | ||
345 | static int __init whci_hc_driver_init(void) | |
346 | { | |
347 | return umc_driver_register(&whci_hc_driver); | |
348 | } | |
349 | module_init(whci_hc_driver_init); | |
350 | ||
351 | static void __exit whci_hc_driver_exit(void) | |
352 | { | |
353 | umc_driver_unregister(&whci_hc_driver); | |
354 | } | |
355 | module_exit(whci_hc_driver_exit); | |
356 | ||
357 | /* PCI device ID's that we handle (so it gets loaded) */ | |
358 | static struct pci_device_id whci_hcd_id_table[] = { | |
359 | { PCI_DEVICE_CLASS(PCI_CLASS_WIRELESS_WHCI, ~0) }, | |
360 | { /* empty last entry */ } | |
361 | }; | |
362 | MODULE_DEVICE_TABLE(pci, whci_hcd_id_table); | |
363 | ||
364 | MODULE_DESCRIPTION("WHCI Wireless USB host controller driver"); | |
365 | MODULE_AUTHOR("Cambridge Silicon Radio Ltd."); | |
366 | MODULE_LICENSE("GPL"); |