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