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