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