Commit | Line | Data |
---|---|---|
d09318b8 IPG |
1 | /* |
2 | * Host Wire Adapter: | |
3 | * Driver glue, HWA-specific functions, bridges to WAHC and WUSBHC | |
4 | * | |
5 | * Copyright (C) 2005-2006 Intel Corporation | |
6 | * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU General Public License version | |
10 | * 2 as published by the Free Software Foundation. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | * GNU General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License | |
18 | * along with this program; if not, write to the Free Software | |
19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
20 | * 02110-1301, USA. | |
21 | * | |
22 | * | |
23 | * The HWA driver is a simple layer that forwards requests to the WAHC | |
24 | * (Wire Adater Host Controller) or WUSBHC (Wireless USB Host | |
25 | * Controller) layers. | |
26 | * | |
27 | * Host Wire Adapter is the 'WUSB 1.0 standard' name for Wireless-USB | |
28 | * Host Controller that is connected to your system via USB (a USB | |
29 | * dongle that implements a USB host...). There is also a Device Wired | |
30 | * Adaptor, DWA (Wireless USB hub) that uses the same mechanism for | |
31 | * transferring data (it is after all a USB host connected via | |
32 | * Wireless USB), we have a common layer called Wire Adapter Host | |
33 | * Controller that does all the hard work. The WUSBHC (Wireless USB | |
34 | * Host Controller) is the part common to WUSB Host Controllers, the | |
35 | * HWA and the PCI-based one, that is implemented following the WHCI | |
36 | * spec. All these layers are implemented in ../wusbcore. | |
37 | * | |
38 | * The main functions are hwahc_op_urb_{en,de}queue(), that pass the | |
39 | * job of converting a URB to a Wire Adapter | |
40 | * | |
41 | * Entry points: | |
42 | * | |
43 | * hwahc_driver_*() Driver initialization, registration and | |
44 | * teardown. | |
45 | * | |
46 | * hwahc_probe() New device came up, create an instance for | |
47 | * it [from device enumeration]. | |
48 | * | |
49 | * hwahc_disconnect() Remove device instance [from device | |
50 | * enumeration]. | |
51 | * | |
52 | * [__]hwahc_op_*() Host-Wire-Adaptor specific functions for | |
53 | * starting/stopping/etc (some might be made also | |
54 | * DWA). | |
55 | */ | |
56 | #include <linux/kernel.h> | |
5a0e3ad6 | 57 | #include <linux/slab.h> |
d09318b8 IPG |
58 | #include <linux/module.h> |
59 | #include <linux/workqueue.h> | |
60 | #include <linux/wait.h> | |
61 | #include <linux/completion.h> | |
62 | #include "../wusbcore/wa-hc.h" | |
63 | #include "../wusbcore/wusbhc.h" | |
64 | ||
d09318b8 IPG |
65 | struct hwahc { |
66 | struct wusbhc wusbhc; /* has to be 1st */ | |
67 | struct wahc wa; | |
d09318b8 IPG |
68 | }; |
69 | ||
bce83697 | 70 | /* |
d09318b8 IPG |
71 | * FIXME should be wusbhc |
72 | * | |
73 | * NOTE: we need to cache the Cluster ID because later...there is no | |
74 | * way to get it :) | |
75 | */ | |
76 | static int __hwahc_set_cluster_id(struct hwahc *hwahc, u8 cluster_id) | |
77 | { | |
78 | int result; | |
79 | struct wusbhc *wusbhc = &hwahc->wusbhc; | |
80 | struct wahc *wa = &hwahc->wa; | |
81 | struct device *dev = &wa->usb_iface->dev; | |
82 | ||
83 | result = usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0), | |
84 | WUSB_REQ_SET_CLUSTER_ID, | |
85 | USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, | |
86 | cluster_id, | |
87 | wa->usb_iface->cur_altsetting->desc.bInterfaceNumber, | |
7b3e3740 | 88 | NULL, 0, USB_CTRL_SET_TIMEOUT); |
d09318b8 IPG |
89 | if (result < 0) |
90 | dev_err(dev, "Cannot set WUSB Cluster ID to 0x%02x: %d\n", | |
91 | cluster_id, result); | |
92 | else | |
93 | wusbhc->cluster_id = cluster_id; | |
94 | dev_info(dev, "Wireless USB Cluster ID set to 0x%02x\n", cluster_id); | |
95 | return result; | |
96 | } | |
97 | ||
98 | static int __hwahc_op_set_num_dnts(struct wusbhc *wusbhc, u8 interval, u8 slots) | |
99 | { | |
100 | struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); | |
101 | struct wahc *wa = &hwahc->wa; | |
102 | ||
103 | return usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0), | |
104 | WUSB_REQ_SET_NUM_DNTS, | |
105 | USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, | |
106 | interval << 8 | slots, | |
107 | wa->usb_iface->cur_altsetting->desc.bInterfaceNumber, | |
7b3e3740 | 108 | NULL, 0, USB_CTRL_SET_TIMEOUT); |
d09318b8 IPG |
109 | } |
110 | ||
111 | /* | |
112 | * Reset a WUSB host controller and wait for it to complete doing it. | |
113 | * | |
114 | * @usb_hcd: Pointer to WUSB Host Controller instance. | |
115 | * | |
116 | */ | |
117 | static int hwahc_op_reset(struct usb_hcd *usb_hcd) | |
118 | { | |
119 | int result; | |
120 | struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); | |
121 | struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); | |
122 | struct device *dev = &hwahc->wa.usb_iface->dev; | |
123 | ||
d09318b8 IPG |
124 | mutex_lock(&wusbhc->mutex); |
125 | wa_nep_disarm(&hwahc->wa); | |
126 | result = __wa_set_feature(&hwahc->wa, WA_RESET); | |
127 | if (result < 0) { | |
128 | dev_err(dev, "error commanding HC to reset: %d\n", result); | |
129 | goto error_unlock; | |
130 | } | |
d09318b8 IPG |
131 | result = __wa_wait_status(&hwahc->wa, WA_STATUS_RESETTING, 0); |
132 | if (result < 0) { | |
133 | dev_err(dev, "error waiting for HC to reset: %d\n", result); | |
134 | goto error_unlock; | |
135 | } | |
136 | error_unlock: | |
137 | mutex_unlock(&wusbhc->mutex); | |
d09318b8 IPG |
138 | return result; |
139 | } | |
140 | ||
141 | /* | |
142 | * FIXME: break this function up | |
143 | */ | |
144 | static int hwahc_op_start(struct usb_hcd *usb_hcd) | |
145 | { | |
146 | u8 addr; | |
147 | int result; | |
148 | struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); | |
149 | struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); | |
d09318b8 | 150 | |
d09318b8 IPG |
151 | result = -ENOSPC; |
152 | mutex_lock(&wusbhc->mutex); | |
d09318b8 IPG |
153 | addr = wusb_cluster_id_get(); |
154 | if (addr == 0) | |
155 | goto error_cluster_id_get; | |
156 | result = __hwahc_set_cluster_id(hwahc, addr); | |
157 | if (result < 0) | |
158 | goto error_set_cluster_id; | |
159 | ||
d09318b8 | 160 | usb_hcd->uses_new_polling = 1; |
541c7d43 | 161 | set_bit(HCD_FLAG_POLL_RH, &usb_hcd->flags); |
d09318b8 | 162 | usb_hcd->state = HC_STATE_RUNNING; |
644f6a12 TP |
163 | |
164 | /* | |
165 | * prevent USB core from suspending the root hub since | |
166 | * bus_suspend and bus_resume are not yet supported. | |
167 | */ | |
168 | pm_runtime_get_noresume(&usb_hcd->self.root_hub->dev); | |
169 | ||
d09318b8 IPG |
170 | result = 0; |
171 | out: | |
172 | mutex_unlock(&wusbhc->mutex); | |
d09318b8 IPG |
173 | return result; |
174 | ||
d09318b8 IPG |
175 | error_set_cluster_id: |
176 | wusb_cluster_id_put(wusbhc->cluster_id); | |
177 | error_cluster_id_get: | |
178 | goto out; | |
179 | ||
180 | } | |
181 | ||
d09318b8 IPG |
182 | /* |
183 | * No need to abort pipes, as when this is called, all the children | |
184 | * has been disconnected and that has done it [through | |
185 | * usb_disable_interface() -> usb_disable_endpoint() -> | |
186 | * hwahc_op_ep_disable() - >rpipe_ep_disable()]. | |
187 | */ | |
188 | static void hwahc_op_stop(struct usb_hcd *usb_hcd) | |
189 | { | |
d09318b8 | 190 | struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); |
d09318b8 | 191 | |
d09318b8 | 192 | mutex_lock(&wusbhc->mutex); |
d09318b8 IPG |
193 | wusb_cluster_id_put(wusbhc->cluster_id); |
194 | mutex_unlock(&wusbhc->mutex); | |
d09318b8 IPG |
195 | } |
196 | ||
197 | static int hwahc_op_get_frame_number(struct usb_hcd *usb_hcd) | |
198 | { | |
199 | struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); | |
200 | struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); | |
7e176dcb | 201 | struct wahc *wa = &hwahc->wa; |
d09318b8 | 202 | |
7e176dcb TP |
203 | /* |
204 | * We cannot query the HWA for the WUSB time since that requires sending | |
205 | * a synchronous URB and this function can be called in_interrupt. | |
206 | * Instead, query the USB frame number for our parent and use that. | |
207 | */ | |
208 | return usb_get_current_frame_number(wa->usb_dev); | |
d09318b8 IPG |
209 | } |
210 | ||
211 | static int hwahc_op_urb_enqueue(struct usb_hcd *usb_hcd, struct urb *urb, | |
212 | gfp_t gfp) | |
213 | { | |
214 | struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); | |
215 | struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); | |
216 | ||
217 | return wa_urb_enqueue(&hwahc->wa, urb->ep, urb, gfp); | |
218 | } | |
219 | ||
220 | static int hwahc_op_urb_dequeue(struct usb_hcd *usb_hcd, struct urb *urb, | |
221 | int status) | |
222 | { | |
223 | struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); | |
224 | struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); | |
225 | ||
b374487e | 226 | return wa_urb_dequeue(&hwahc->wa, urb, status); |
d09318b8 IPG |
227 | } |
228 | ||
229 | /* | |
230 | * Release resources allocated for an endpoint | |
231 | * | |
232 | * If there is an associated rpipe to this endpoint, go ahead and put it. | |
233 | */ | |
234 | static void hwahc_op_endpoint_disable(struct usb_hcd *usb_hcd, | |
235 | struct usb_host_endpoint *ep) | |
236 | { | |
237 | struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); | |
238 | struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); | |
239 | ||
240 | rpipe_ep_disable(&hwahc->wa, ep); | |
241 | } | |
242 | ||
4d2bea4c DV |
243 | static int __hwahc_op_wusbhc_start(struct wusbhc *wusbhc) |
244 | { | |
245 | int result; | |
246 | struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); | |
247 | struct device *dev = &hwahc->wa.usb_iface->dev; | |
248 | ||
249 | result = __wa_set_feature(&hwahc->wa, WA_ENABLE); | |
250 | if (result < 0) { | |
251 | dev_err(dev, "error commanding HC to start: %d\n", result); | |
252 | goto error_stop; | |
253 | } | |
254 | result = __wa_wait_status(&hwahc->wa, WA_ENABLE, WA_ENABLE); | |
255 | if (result < 0) { | |
256 | dev_err(dev, "error waiting for HC to start: %d\n", result); | |
257 | goto error_stop; | |
258 | } | |
259 | result = wa_nep_arm(&hwahc->wa, GFP_KERNEL); | |
260 | if (result < 0) { | |
261 | dev_err(dev, "cannot listen to notifications: %d\n", result); | |
262 | goto error_stop; | |
263 | } | |
86e2864d TP |
264 | /* |
265 | * If WUSB_QUIRK_ALEREON_HWA_DISABLE_XFER_NOTIFICATIONS is set, | |
266 | * disable transfer notifications. | |
267 | */ | |
268 | if (hwahc->wa.quirks & | |
269 | WUSB_QUIRK_ALEREON_HWA_DISABLE_XFER_NOTIFICATIONS) { | |
270 | struct usb_host_interface *cur_altsetting = | |
271 | hwahc->wa.usb_iface->cur_altsetting; | |
272 | ||
273 | result = usb_control_msg(hwahc->wa.usb_dev, | |
274 | usb_sndctrlpipe(hwahc->wa.usb_dev, 0), | |
275 | WA_REQ_ALEREON_DISABLE_XFER_NOTIFICATIONS, | |
276 | USB_DIR_OUT | USB_TYPE_VENDOR | | |
277 | USB_RECIP_INTERFACE, | |
278 | WA_REQ_ALEREON_FEATURE_SET, | |
279 | cur_altsetting->desc.bInterfaceNumber, | |
280 | NULL, 0, | |
281 | USB_CTRL_SET_TIMEOUT); | |
282 | /* | |
283 | * If we successfully sent the control message, start DTI here | |
284 | * because no transfer notifications will be received which is | |
285 | * where DTI is normally started. | |
286 | */ | |
287 | if (result == 0) | |
288 | result = wa_dti_start(&hwahc->wa); | |
289 | else | |
290 | result = 0; /* OK. Continue normally. */ | |
291 | ||
292 | if (result < 0) { | |
293 | dev_err(dev, "cannot start DTI: %d\n", result); | |
294 | goto error_dti_start; | |
295 | } | |
296 | } | |
297 | ||
4d2bea4c DV |
298 | return result; |
299 | ||
86e2864d TP |
300 | error_dti_start: |
301 | wa_nep_disarm(&hwahc->wa); | |
4d2bea4c DV |
302 | error_stop: |
303 | __wa_clear_feature(&hwahc->wa, WA_ENABLE); | |
304 | return result; | |
305 | } | |
306 | ||
307 | static void __hwahc_op_wusbhc_stop(struct wusbhc *wusbhc, int delay) | |
308 | { | |
309 | struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); | |
310 | struct wahc *wa = &hwahc->wa; | |
311 | u8 iface_no = wa->usb_iface->cur_altsetting->desc.bInterfaceNumber; | |
312 | int ret; | |
313 | ||
314 | ret = usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0), | |
315 | WUSB_REQ_CHAN_STOP, | |
316 | USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, | |
317 | delay * 1000, | |
318 | iface_no, | |
7b3e3740 | 319 | NULL, 0, USB_CTRL_SET_TIMEOUT); |
4d2bea4c DV |
320 | if (ret == 0) |
321 | msleep(delay); | |
322 | ||
323 | wa_nep_disarm(&hwahc->wa); | |
324 | __wa_stop(&hwahc->wa); | |
325 | } | |
326 | ||
d09318b8 IPG |
327 | /* |
328 | * Set the UWB MAS allocation for the WUSB cluster | |
329 | * | |
330 | * @stream_index: stream to use (-1 for cancelling the allocation) | |
331 | * @mas: mas bitmap to use | |
332 | */ | |
333 | static int __hwahc_op_bwa_set(struct wusbhc *wusbhc, s8 stream_index, | |
334 | const struct uwb_mas_bm *mas) | |
335 | { | |
336 | int result; | |
337 | struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); | |
338 | struct wahc *wa = &hwahc->wa; | |
339 | struct device *dev = &wa->usb_iface->dev; | |
340 | u8 mas_le[UWB_NUM_MAS/8]; | |
341 | ||
342 | /* Set the stream index */ | |
343 | result = usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0), | |
344 | WUSB_REQ_SET_STREAM_IDX, | |
345 | USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, | |
346 | stream_index, | |
347 | wa->usb_iface->cur_altsetting->desc.bInterfaceNumber, | |
7b3e3740 | 348 | NULL, 0, USB_CTRL_SET_TIMEOUT); |
d09318b8 IPG |
349 | if (result < 0) { |
350 | dev_err(dev, "Cannot set WUSB stream index: %d\n", result); | |
351 | goto out; | |
352 | } | |
353 | uwb_mas_bm_copy_le(mas_le, mas); | |
354 | /* Set the MAS allocation */ | |
355 | result = usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0), | |
356 | WUSB_REQ_SET_WUSB_MAS, | |
357 | USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, | |
358 | 0, wa->usb_iface->cur_altsetting->desc.bInterfaceNumber, | |
7b3e3740 | 359 | mas_le, 32, USB_CTRL_SET_TIMEOUT); |
d09318b8 IPG |
360 | if (result < 0) |
361 | dev_err(dev, "Cannot set WUSB MAS allocation: %d\n", result); | |
362 | out: | |
363 | return result; | |
364 | } | |
365 | ||
366 | /* | |
367 | * Add an IE to the host's MMC | |
368 | * | |
369 | * @interval: See WUSB1.0[8.5.3.1] | |
370 | * @repeat_cnt: See WUSB1.0[8.5.3.1] | |
371 | * @handle: See WUSB1.0[8.5.3.1] | |
372 | * @wuie: Pointer to the header of the WUSB IE data to add. | |
373 | * MUST BE allocated in a kmalloc buffer (no stack or | |
374 | * vmalloc). | |
375 | * | |
376 | * NOTE: the format of the WUSB IEs for MMCs are different to the | |
377 | * normal MBOA MAC IEs (IE Id + Length in MBOA MAC vs. Length + | |
378 | * Id in WUSB IEs). Standards...you gotta love'em. | |
379 | */ | |
380 | static int __hwahc_op_mmcie_add(struct wusbhc *wusbhc, u8 interval, | |
381 | u8 repeat_cnt, u8 handle, | |
382 | struct wuie_hdr *wuie) | |
383 | { | |
384 | struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); | |
385 | struct wahc *wa = &hwahc->wa; | |
386 | u8 iface_no = wa->usb_iface->cur_altsetting->desc.bInterfaceNumber; | |
387 | ||
388 | return usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0), | |
389 | WUSB_REQ_ADD_MMC_IE, | |
390 | USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, | |
391 | interval << 8 | repeat_cnt, | |
392 | handle << 8 | iface_no, | |
7b3e3740 | 393 | wuie, wuie->bLength, USB_CTRL_SET_TIMEOUT); |
d09318b8 IPG |
394 | } |
395 | ||
396 | /* | |
397 | * Remove an IE to the host's MMC | |
398 | * | |
399 | * @handle: See WUSB1.0[8.5.3.1] | |
400 | */ | |
401 | static int __hwahc_op_mmcie_rm(struct wusbhc *wusbhc, u8 handle) | |
402 | { | |
403 | struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); | |
404 | struct wahc *wa = &hwahc->wa; | |
405 | u8 iface_no = wa->usb_iface->cur_altsetting->desc.bInterfaceNumber; | |
406 | return usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0), | |
407 | WUSB_REQ_REMOVE_MMC_IE, | |
408 | USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, | |
409 | 0, handle << 8 | iface_no, | |
7b3e3740 | 410 | NULL, 0, USB_CTRL_SET_TIMEOUT); |
d09318b8 IPG |
411 | } |
412 | ||
413 | /* | |
414 | * Update device information for a given fake port | |
415 | * | |
416 | * @port_idx: Fake port to which device is connected (wusbhc index, not | |
417 | * USB port number). | |
418 | */ | |
419 | static int __hwahc_op_dev_info_set(struct wusbhc *wusbhc, | |
420 | struct wusb_dev *wusb_dev) | |
421 | { | |
422 | struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); | |
423 | struct wahc *wa = &hwahc->wa; | |
424 | u8 iface_no = wa->usb_iface->cur_altsetting->desc.bInterfaceNumber; | |
425 | struct hwa_dev_info *dev_info; | |
426 | int ret; | |
427 | ||
428 | /* fill out the Device Info buffer and send it */ | |
429 | dev_info = kzalloc(sizeof(struct hwa_dev_info), GFP_KERNEL); | |
430 | if (!dev_info) | |
431 | return -ENOMEM; | |
432 | uwb_mas_bm_copy_le(dev_info->bmDeviceAvailability, | |
433 | &wusb_dev->availability); | |
434 | dev_info->bDeviceAddress = wusb_dev->addr; | |
435 | ||
436 | /* | |
437 | * If the descriptors haven't been read yet, use a default PHY | |
438 | * rate of 53.3 Mbit/s only. The correct value will be used | |
439 | * when this will be called again as part of the | |
440 | * authentication process (which occurs after the descriptors | |
441 | * have been read). | |
442 | */ | |
443 | if (wusb_dev->wusb_cap_descr) | |
444 | dev_info->wPHYRates = wusb_dev->wusb_cap_descr->wPHYRates; | |
445 | else | |
446 | dev_info->wPHYRates = cpu_to_le16(USB_WIRELESS_PHY_53); | |
447 | ||
448 | ret = usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0), | |
449 | WUSB_REQ_SET_DEV_INFO, | |
450 | USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, | |
451 | 0, wusb_dev->port_idx << 8 | iface_no, | |
452 | dev_info, sizeof(struct hwa_dev_info), | |
7b3e3740 | 453 | USB_CTRL_SET_TIMEOUT); |
d09318b8 IPG |
454 | kfree(dev_info); |
455 | return ret; | |
456 | } | |
457 | ||
458 | /* | |
459 | * Set host's idea of which encryption (and key) method to use when | |
460 | * talking to ad evice on a given port. | |
461 | * | |
462 | * If key is NULL, it means disable encryption for that "virtual port" | |
463 | * (used when we disconnect). | |
464 | */ | |
465 | static int __hwahc_dev_set_key(struct wusbhc *wusbhc, u8 port_idx, u32 tkid, | |
466 | const void *key, size_t key_size, | |
467 | u8 key_idx) | |
468 | { | |
469 | int result = -ENOMEM; | |
470 | struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); | |
471 | struct wahc *wa = &hwahc->wa; | |
472 | u8 iface_no = wa->usb_iface->cur_altsetting->desc.bInterfaceNumber; | |
473 | struct usb_key_descriptor *keyd; | |
474 | size_t keyd_len; | |
475 | ||
476 | keyd_len = sizeof(*keyd) + key_size; | |
477 | keyd = kzalloc(keyd_len, GFP_KERNEL); | |
478 | if (keyd == NULL) | |
479 | return -ENOMEM; | |
480 | ||
481 | keyd->bLength = keyd_len; | |
482 | keyd->bDescriptorType = USB_DT_KEY; | |
483 | keyd->tTKID[0] = (tkid >> 0) & 0xff; | |
484 | keyd->tTKID[1] = (tkid >> 8) & 0xff; | |
485 | keyd->tTKID[2] = (tkid >> 16) & 0xff; | |
486 | memcpy(keyd->bKeyData, key, key_size); | |
487 | ||
488 | result = usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0), | |
489 | USB_REQ_SET_DESCRIPTOR, | |
490 | USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, | |
491 | USB_DT_KEY << 8 | key_idx, | |
492 | port_idx << 8 | iface_no, | |
7b3e3740 | 493 | keyd, keyd_len, USB_CTRL_SET_TIMEOUT); |
d09318b8 | 494 | |
31dbb803 | 495 | kzfree(keyd); /* clear keys etc. */ |
d09318b8 IPG |
496 | return result; |
497 | } | |
498 | ||
499 | /* | |
500 | * Set host's idea of which encryption (and key) method to use when | |
501 | * talking to ad evice on a given port. | |
502 | * | |
503 | * If key is NULL, it means disable encryption for that "virtual port" | |
504 | * (used when we disconnect). | |
505 | */ | |
506 | static int __hwahc_op_set_ptk(struct wusbhc *wusbhc, u8 port_idx, u32 tkid, | |
507 | const void *key, size_t key_size) | |
508 | { | |
509 | int result = -ENOMEM; | |
510 | struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc); | |
511 | struct wahc *wa = &hwahc->wa; | |
512 | u8 iface_no = wa->usb_iface->cur_altsetting->desc.bInterfaceNumber; | |
513 | u8 encryption_value; | |
514 | ||
515 | /* Tell the host which key to use to talk to the device */ | |
516 | if (key) { | |
517 | u8 key_idx = wusb_key_index(0, WUSB_KEY_INDEX_TYPE_PTK, | |
518 | WUSB_KEY_INDEX_ORIGINATOR_HOST); | |
519 | ||
520 | result = __hwahc_dev_set_key(wusbhc, port_idx, tkid, | |
521 | key, key_size, key_idx); | |
522 | if (result < 0) | |
523 | goto error_set_key; | |
524 | encryption_value = wusbhc->ccm1_etd->bEncryptionValue; | |
525 | } else { | |
526 | /* FIXME: this should come from wusbhc->etd[UNSECURE].value */ | |
527 | encryption_value = 0; | |
528 | } | |
529 | ||
42b2aa86 | 530 | /* Set the encryption type for communicating with the device */ |
d09318b8 IPG |
531 | result = usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0), |
532 | USB_REQ_SET_ENCRYPTION, | |
533 | USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE, | |
534 | encryption_value, port_idx << 8 | iface_no, | |
7b3e3740 | 535 | NULL, 0, USB_CTRL_SET_TIMEOUT); |
d09318b8 IPG |
536 | if (result < 0) |
537 | dev_err(wusbhc->dev, "Can't set host's WUSB encryption for " | |
538 | "port index %u to %s (value %d): %d\n", port_idx, | |
539 | wusb_et_name(wusbhc->ccm1_etd->bEncryptionType), | |
540 | wusbhc->ccm1_etd->bEncryptionValue, result); | |
541 | error_set_key: | |
542 | return result; | |
543 | } | |
544 | ||
545 | /* | |
546 | * Set host's GTK key | |
547 | */ | |
548 | static int __hwahc_op_set_gtk(struct wusbhc *wusbhc, u32 tkid, | |
549 | const void *key, size_t key_size) | |
550 | { | |
551 | u8 key_idx = wusb_key_index(0, WUSB_KEY_INDEX_TYPE_GTK, | |
552 | WUSB_KEY_INDEX_ORIGINATOR_HOST); | |
553 | ||
554 | return __hwahc_dev_set_key(wusbhc, 0, tkid, key, key_size, key_idx); | |
555 | } | |
556 | ||
557 | /* | |
558 | * Get the Wire Adapter class-specific descriptor | |
559 | * | |
560 | * NOTE: this descriptor comes with the big bundled configuration | |
561 | * descriptor that includes the interfaces' and endpoints', so | |
562 | * we just look for it in the cached copy kept by the USB stack. | |
563 | * | |
564 | * NOTE2: We convert LE fields to CPU order. | |
565 | */ | |
566 | static int wa_fill_descr(struct wahc *wa) | |
567 | { | |
568 | int result; | |
569 | struct device *dev = &wa->usb_iface->dev; | |
570 | char *itr; | |
571 | struct usb_device *usb_dev = wa->usb_dev; | |
572 | struct usb_descriptor_header *hdr; | |
573 | struct usb_wa_descriptor *wa_descr; | |
574 | size_t itr_size, actconfig_idx; | |
575 | ||
576 | actconfig_idx = (usb_dev->actconfig - usb_dev->config) / | |
577 | sizeof(usb_dev->config[0]); | |
578 | itr = usb_dev->rawdescriptors[actconfig_idx]; | |
579 | itr_size = le16_to_cpu(usb_dev->actconfig->desc.wTotalLength); | |
580 | while (itr_size >= sizeof(*hdr)) { | |
581 | hdr = (struct usb_descriptor_header *) itr; | |
bce83697 DV |
582 | dev_dbg(dev, "Extra device descriptor: " |
583 | "type %02x/%u bytes @ %zu (%zu left)\n", | |
584 | hdr->bDescriptorType, hdr->bLength, | |
585 | (itr - usb_dev->rawdescriptors[actconfig_idx]), | |
586 | itr_size); | |
d09318b8 IPG |
587 | if (hdr->bDescriptorType == USB_DT_WIRE_ADAPTER) |
588 | goto found; | |
589 | itr += hdr->bLength; | |
590 | itr_size -= hdr->bLength; | |
591 | } | |
592 | dev_err(dev, "cannot find Wire Adapter Class descriptor\n"); | |
593 | return -ENODEV; | |
594 | ||
595 | found: | |
596 | result = -EINVAL; | |
597 | if (hdr->bLength > itr_size) { /* is it available? */ | |
598 | dev_err(dev, "incomplete Wire Adapter Class descriptor " | |
599 | "(%zu bytes left, %u needed)\n", | |
600 | itr_size, hdr->bLength); | |
601 | goto error; | |
602 | } | |
603 | if (hdr->bLength < sizeof(*wa->wa_descr)) { | |
604 | dev_err(dev, "short Wire Adapter Class descriptor\n"); | |
605 | goto error; | |
606 | } | |
607 | wa->wa_descr = wa_descr = (struct usb_wa_descriptor *) hdr; | |
1653d2f8 | 608 | if (le16_to_cpu(wa_descr->bcdWAVersion) > 0x0100) |
d09318b8 | 609 | dev_warn(dev, "Wire Adapter v%d.%d newer than groked v1.0\n", |
cee2448e | 610 | (le16_to_cpu(wa_descr->bcdWAVersion) & 0xff00) >> 8, |
1653d2f8 | 611 | le16_to_cpu(wa_descr->bcdWAVersion) & 0x00ff); |
d09318b8 IPG |
612 | result = 0; |
613 | error: | |
614 | return result; | |
615 | } | |
616 | ||
617 | static struct hc_driver hwahc_hc_driver = { | |
618 | .description = "hwa-hcd", | |
619 | .product_desc = "Wireless USB HWA host controller", | |
620 | .hcd_priv_size = sizeof(struct hwahc) - sizeof(struct usb_hcd), | |
621 | .irq = NULL, /* FIXME */ | |
1a81f881 | 622 | .flags = HCD_USB25, |
d09318b8 IPG |
623 | .reset = hwahc_op_reset, |
624 | .start = hwahc_op_start, | |
d09318b8 IPG |
625 | .stop = hwahc_op_stop, |
626 | .get_frame_number = hwahc_op_get_frame_number, | |
627 | .urb_enqueue = hwahc_op_urb_enqueue, | |
628 | .urb_dequeue = hwahc_op_urb_dequeue, | |
629 | .endpoint_disable = hwahc_op_endpoint_disable, | |
630 | ||
631 | .hub_status_data = wusbhc_rh_status_data, | |
632 | .hub_control = wusbhc_rh_control, | |
d09318b8 IPG |
633 | .start_port_reset = wusbhc_rh_start_port_reset, |
634 | }; | |
635 | ||
636 | static int hwahc_security_create(struct hwahc *hwahc) | |
637 | { | |
638 | int result; | |
639 | struct wusbhc *wusbhc = &hwahc->wusbhc; | |
640 | struct usb_device *usb_dev = hwahc->wa.usb_dev; | |
641 | struct device *dev = &usb_dev->dev; | |
642 | struct usb_security_descriptor *secd; | |
643 | struct usb_encryption_descriptor *etd; | |
644 | void *itr, *top; | |
645 | size_t itr_size, needed, bytes; | |
646 | u8 index; | |
647 | char buf[64]; | |
648 | ||
649 | /* Find the host's security descriptors in the config descr bundle */ | |
650 | index = (usb_dev->actconfig - usb_dev->config) / | |
651 | sizeof(usb_dev->config[0]); | |
652 | itr = usb_dev->rawdescriptors[index]; | |
653 | itr_size = le16_to_cpu(usb_dev->actconfig->desc.wTotalLength); | |
654 | top = itr + itr_size; | |
655 | result = __usb_get_extra_descriptor(usb_dev->rawdescriptors[index], | |
656 | le16_to_cpu(usb_dev->actconfig->desc.wTotalLength), | |
657 | USB_DT_SECURITY, (void **) &secd); | |
658 | if (result == -1) { | |
659 | dev_warn(dev, "BUG? WUSB host has no security descriptors\n"); | |
660 | return 0; | |
661 | } | |
662 | needed = sizeof(*secd); | |
663 | if (top - (void *)secd < needed) { | |
664 | dev_err(dev, "BUG? Not enough data to process security " | |
665 | "descriptor header (%zu bytes left vs %zu needed)\n", | |
666 | top - (void *) secd, needed); | |
667 | return 0; | |
668 | } | |
669 | needed = le16_to_cpu(secd->wTotalLength); | |
670 | if (top - (void *)secd < needed) { | |
671 | dev_err(dev, "BUG? Not enough data to process security " | |
672 | "descriptors (%zu bytes left vs %zu needed)\n", | |
673 | top - (void *) secd, needed); | |
674 | return 0; | |
675 | } | |
676 | /* Walk over the sec descriptors and store CCM1's on wusbhc */ | |
677 | itr = (void *) secd + sizeof(*secd); | |
678 | top = (void *) secd + le16_to_cpu(secd->wTotalLength); | |
679 | index = 0; | |
680 | bytes = 0; | |
681 | while (itr < top) { | |
682 | etd = itr; | |
683 | if (top - itr < sizeof(*etd)) { | |
684 | dev_err(dev, "BUG: bad host security descriptor; " | |
685 | "not enough data (%zu vs %zu left)\n", | |
686 | top - itr, sizeof(*etd)); | |
687 | break; | |
688 | } | |
689 | if (etd->bLength < sizeof(*etd)) { | |
690 | dev_err(dev, "BUG: bad host encryption descriptor; " | |
691 | "descriptor is too short " | |
692 | "(%zu vs %zu needed)\n", | |
693 | (size_t)etd->bLength, sizeof(*etd)); | |
694 | break; | |
695 | } | |
696 | itr += etd->bLength; | |
697 | bytes += snprintf(buf + bytes, sizeof(buf) - bytes, | |
698 | "%s (0x%02x) ", | |
699 | wusb_et_name(etd->bEncryptionType), | |
700 | etd->bEncryptionValue); | |
701 | wusbhc->ccm1_etd = etd; | |
702 | } | |
703 | dev_info(dev, "supported encryption types: %s\n", buf); | |
704 | if (wusbhc->ccm1_etd == NULL) { | |
705 | dev_err(dev, "E: host doesn't support CCM-1 crypto\n"); | |
706 | return 0; | |
707 | } | |
708 | /* Pretty print what we support */ | |
709 | return 0; | |
710 | } | |
711 | ||
712 | static void hwahc_security_release(struct hwahc *hwahc) | |
713 | { | |
714 | /* nothing to do here so far... */ | |
715 | } | |
716 | ||
f07ddb9e TP |
717 | static int hwahc_create(struct hwahc *hwahc, struct usb_interface *iface, |
718 | kernel_ulong_t quirks) | |
d09318b8 IPG |
719 | { |
720 | int result; | |
721 | struct device *dev = &iface->dev; | |
722 | struct wusbhc *wusbhc = &hwahc->wusbhc; | |
723 | struct wahc *wa = &hwahc->wa; | |
724 | struct usb_device *usb_dev = interface_to_usbdev(iface); | |
725 | ||
726 | wa->usb_dev = usb_get_dev(usb_dev); /* bind the USB device */ | |
727 | wa->usb_iface = usb_get_intf(iface); | |
728 | wusbhc->dev = dev; | |
a8995751 TP |
729 | /* defer getting the uwb_rc handle until it is needed since it |
730 | * may not have been registered by the hwa_rc driver yet. */ | |
731 | wusbhc->uwb_rc = NULL; | |
d09318b8 IPG |
732 | result = wa_fill_descr(wa); /* Get the device descriptor */ |
733 | if (result < 0) | |
734 | goto error_fill_descriptor; | |
735 | if (wa->wa_descr->bNumPorts > USB_MAXCHILDREN) { | |
736 | dev_err(dev, "FIXME: USB_MAXCHILDREN too low for WUSB " | |
737 | "adapter (%u ports)\n", wa->wa_descr->bNumPorts); | |
738 | wusbhc->ports_max = USB_MAXCHILDREN; | |
739 | } else { | |
740 | wusbhc->ports_max = wa->wa_descr->bNumPorts; | |
741 | } | |
742 | wusbhc->mmcies_max = wa->wa_descr->bNumMMCIEs; | |
743 | wusbhc->start = __hwahc_op_wusbhc_start; | |
744 | wusbhc->stop = __hwahc_op_wusbhc_stop; | |
745 | wusbhc->mmcie_add = __hwahc_op_mmcie_add; | |
746 | wusbhc->mmcie_rm = __hwahc_op_mmcie_rm; | |
747 | wusbhc->dev_info_set = __hwahc_op_dev_info_set; | |
748 | wusbhc->bwa_set = __hwahc_op_bwa_set; | |
749 | wusbhc->set_num_dnts = __hwahc_op_set_num_dnts; | |
750 | wusbhc->set_ptk = __hwahc_op_set_ptk; | |
751 | wusbhc->set_gtk = __hwahc_op_set_gtk; | |
752 | result = hwahc_security_create(hwahc); | |
753 | if (result < 0) { | |
754 | dev_err(dev, "Can't initialize security: %d\n", result); | |
755 | goto error_security_create; | |
756 | } | |
757 | wa->wusb = wusbhc; /* FIXME: ugly, need to fix */ | |
758 | result = wusbhc_create(&hwahc->wusbhc); | |
759 | if (result < 0) { | |
760 | dev_err(dev, "Can't create WUSB HC structures: %d\n", result); | |
761 | goto error_wusbhc_create; | |
762 | } | |
f07ddb9e | 763 | result = wa_create(&hwahc->wa, iface, quirks); |
d09318b8 IPG |
764 | if (result < 0) |
765 | goto error_wa_create; | |
766 | return 0; | |
767 | ||
768 | error_wa_create: | |
769 | wusbhc_destroy(&hwahc->wusbhc); | |
770 | error_wusbhc_create: | |
771 | /* WA Descr fill allocs no resources */ | |
772 | error_security_create: | |
773 | error_fill_descriptor: | |
d09318b8 IPG |
774 | usb_put_intf(iface); |
775 | usb_put_dev(usb_dev); | |
776 | return result; | |
777 | } | |
778 | ||
779 | static void hwahc_destroy(struct hwahc *hwahc) | |
780 | { | |
781 | struct wusbhc *wusbhc = &hwahc->wusbhc; | |
782 | ||
d09318b8 IPG |
783 | mutex_lock(&wusbhc->mutex); |
784 | __wa_destroy(&hwahc->wa); | |
785 | wusbhc_destroy(&hwahc->wusbhc); | |
786 | hwahc_security_release(hwahc); | |
787 | hwahc->wusbhc.dev = NULL; | |
788 | uwb_rc_put(wusbhc->uwb_rc); | |
789 | usb_put_intf(hwahc->wa.usb_iface); | |
790 | usb_put_dev(hwahc->wa.usb_dev); | |
791 | mutex_unlock(&wusbhc->mutex); | |
d09318b8 IPG |
792 | } |
793 | ||
794 | static void hwahc_init(struct hwahc *hwahc) | |
795 | { | |
796 | wa_init(&hwahc->wa); | |
797 | } | |
798 | ||
799 | static int hwahc_probe(struct usb_interface *usb_iface, | |
800 | const struct usb_device_id *id) | |
801 | { | |
802 | int result; | |
803 | struct usb_hcd *usb_hcd; | |
804 | struct wusbhc *wusbhc; | |
805 | struct hwahc *hwahc; | |
806 | struct device *dev = &usb_iface->dev; | |
807 | ||
d09318b8 IPG |
808 | result = -ENOMEM; |
809 | usb_hcd = usb_create_hcd(&hwahc_hc_driver, &usb_iface->dev, "wusb-hwa"); | |
810 | if (usb_hcd == NULL) { | |
811 | dev_err(dev, "unable to allocate instance\n"); | |
812 | goto error_alloc; | |
813 | } | |
814 | usb_hcd->wireless = 1; | |
2b81c083 | 815 | usb_hcd->self.sg_tablesize = ~0; |
d09318b8 IPG |
816 | wusbhc = usb_hcd_to_wusbhc(usb_hcd); |
817 | hwahc = container_of(wusbhc, struct hwahc, wusbhc); | |
818 | hwahc_init(hwahc); | |
f07ddb9e | 819 | result = hwahc_create(hwahc, usb_iface, id->driver_info); |
d09318b8 IPG |
820 | if (result < 0) { |
821 | dev_err(dev, "Cannot initialize internals: %d\n", result); | |
822 | goto error_hwahc_create; | |
823 | } | |
824 | result = usb_add_hcd(usb_hcd, 0, 0); | |
825 | if (result < 0) { | |
826 | dev_err(dev, "Cannot add HCD: %d\n", result); | |
827 | goto error_add_hcd; | |
828 | } | |
3c9740a1 | 829 | device_wakeup_enable(usb_hcd->self.controller); |
d09318b8 IPG |
830 | result = wusbhc_b_create(&hwahc->wusbhc); |
831 | if (result < 0) { | |
832 | dev_err(dev, "Cannot setup phase B of WUSBHC: %d\n", result); | |
833 | goto error_wusbhc_b_create; | |
834 | } | |
d09318b8 IPG |
835 | return 0; |
836 | ||
837 | error_wusbhc_b_create: | |
838 | usb_remove_hcd(usb_hcd); | |
839 | error_add_hcd: | |
840 | hwahc_destroy(hwahc); | |
841 | error_hwahc_create: | |
842 | usb_put_hcd(usb_hcd); | |
843 | error_alloc: | |
d09318b8 IPG |
844 | return result; |
845 | } | |
846 | ||
847 | static void hwahc_disconnect(struct usb_interface *usb_iface) | |
848 | { | |
849 | struct usb_hcd *usb_hcd; | |
850 | struct wusbhc *wusbhc; | |
851 | struct hwahc *hwahc; | |
852 | ||
853 | usb_hcd = usb_get_intfdata(usb_iface); | |
854 | wusbhc = usb_hcd_to_wusbhc(usb_hcd); | |
855 | hwahc = container_of(wusbhc, struct hwahc, wusbhc); | |
856 | ||
d09318b8 IPG |
857 | wusbhc_b_destroy(&hwahc->wusbhc); |
858 | usb_remove_hcd(usb_hcd); | |
859 | hwahc_destroy(hwahc); | |
860 | usb_put_hcd(usb_hcd); | |
d09318b8 IPG |
861 | } |
862 | ||
d09318b8 | 863 | static struct usb_device_id hwahc_id_table[] = { |
f07ddb9e TP |
864 | /* Alereon 5310 */ |
865 | { USB_DEVICE_AND_INTERFACE_INFO(0x13dc, 0x5310, 0xe0, 0x02, 0x01), | |
86e2864d TP |
866 | .driver_info = WUSB_QUIRK_ALEREON_HWA_CONCAT_ISOC | |
867 | WUSB_QUIRK_ALEREON_HWA_DISABLE_XFER_NOTIFICATIONS }, | |
f07ddb9e TP |
868 | /* Alereon 5611 */ |
869 | { USB_DEVICE_AND_INTERFACE_INFO(0x13dc, 0x5611, 0xe0, 0x02, 0x01), | |
86e2864d TP |
870 | .driver_info = WUSB_QUIRK_ALEREON_HWA_CONCAT_ISOC | |
871 | WUSB_QUIRK_ALEREON_HWA_DISABLE_XFER_NOTIFICATIONS }, | |
d09318b8 IPG |
872 | /* FIXME: use class labels for this */ |
873 | { USB_INTERFACE_INFO(0xe0, 0x02, 0x01), }, | |
874 | {}, | |
875 | }; | |
876 | MODULE_DEVICE_TABLE(usb, hwahc_id_table); | |
877 | ||
878 | static struct usb_driver hwahc_driver = { | |
879 | .name = "hwa-hc", | |
880 | .probe = hwahc_probe, | |
881 | .disconnect = hwahc_disconnect, | |
882 | .id_table = hwahc_id_table, | |
883 | }; | |
884 | ||
65db4305 | 885 | module_usb_driver(hwahc_driver); |
d09318b8 IPG |
886 | |
887 | MODULE_AUTHOR("Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>"); | |
888 | MODULE_DESCRIPTION("Host Wired Adapter USB Host Control Driver"); | |
889 | MODULE_LICENSE("GPL"); |