Linux Audio

Check our new training course

Loading...
Note: File does not exist in v6.8.
   1/*
   2 * WUSB Wire Adapter: Control/Data Streaming Interface (WUSB[8])
   3 * Device Connect handling
   4 *
   5 * Copyright (C) 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 * FIXME: docs
  24 * FIXME: this file needs to be broken up, it's grown too big
  25 *
  26 *
  27 * WUSB1.0[7.1, 7.5.1, ]
  28 *
  29 * WUSB device connection is kind of messy. Some background:
  30 *
  31 *     When a device wants to connect it scans the UWB radio channels
  32 *     looking for a WUSB Channel; a WUSB channel is defined by MMCs
  33 *     (Micro Managed Commands or something like that) [see
  34 *     Design-overview for more on this] .
  35 *
  36 * So, device scans the radio, finds MMCs and thus a host and checks
  37 * when the next DNTS is. It sends a Device Notification Connect
  38 * (DN_Connect); the host picks it up (through nep.c and notif.c, ends
  39 * up in wusb_devconnect_ack(), which creates a wusb_dev structure in
  40 * wusbhc->port[port_number].wusb_dev), assigns an unauth address
  41 * to the device (this means from 0x80 to 0xfe) and sends, in the MMC
  42 * a Connect Ack Information Element (ConnAck IE).
  43 *
  44 * So now the device now has a WUSB address. From now on, we use
  45 * that to talk to it in the RPipes.
  46 *
  47 * ASSUMPTIONS:
  48 *
  49 *  - We use the the as device address the port number where it is
  50 *    connected (port 0 doesn't exist). For unauth, it is 128 + that.
  51 *
  52 * ROADMAP:
  53 *
  54 *   This file contains the logic for doing that--entry points:
  55 *
  56 *   wusb_devconnect_ack()      Ack a device until _acked() called.
  57 *                              Called by notif.c:wusb_handle_dn_connect()
  58 *                              when a DN_Connect is received.
  59 *
  60 *     wusb_devconnect_acked()  Ack done, release resources.
  61 *
  62 *   wusb_handle_dn_alive()     Called by notif.c:wusb_handle_dn()
  63 *                              for processing a DN_Alive pong from a device.
  64 *
  65 *   wusb_handle_dn_disconnect()Called by notif.c:wusb_handle_dn() to
  66 *                              process a disconenct request from a
  67 *                              device.
  68 *
  69 *   __wusb_dev_disable()       Called by rh.c:wusbhc_rh_clear_port_feat() when
  70 *                              disabling a port.
  71 *
  72 *   wusb_devconnect_create()   Called when creating the host by
  73 *                              lc.c:wusbhc_create().
  74 *
  75 *   wusb_devconnect_destroy()  Cleanup called removing the host. Called
  76 *                              by lc.c:wusbhc_destroy().
  77 *
  78 *   Each Wireless USB host maintains a list of DN_Connect requests
  79 *   (actually we maintain a list of pending Connect Acks, the
  80 *   wusbhc->ca_list).
  81 *
  82 * LIFE CYCLE OF port->wusb_dev
  83 *
  84 *   Before the @wusbhc structure put()s the reference it owns for
  85 *   port->wusb_dev [and clean the wusb_dev pointer], it needs to
  86 *   lock @wusbhc->mutex.
  87 */
  88
  89#include <linux/jiffies.h>
  90#include <linux/ctype.h>
  91#include <linux/slab.h>
  92#include <linux/workqueue.h>
  93#include <linux/export.h>
  94#include "wusbhc.h"
  95
  96static void wusbhc_devconnect_acked_work(struct work_struct *work);
  97
  98static void wusb_dev_free(struct wusb_dev *wusb_dev)
  99{
 100	if (wusb_dev) {
 101		kfree(wusb_dev->set_gtk_req);
 102		usb_free_urb(wusb_dev->set_gtk_urb);
 103		kfree(wusb_dev);
 104	}
 105}
 106
 107static struct wusb_dev *wusb_dev_alloc(struct wusbhc *wusbhc)
 108{
 109	struct wusb_dev *wusb_dev;
 110	struct urb *urb;
 111	struct usb_ctrlrequest *req;
 112
 113	wusb_dev = kzalloc(sizeof(*wusb_dev), GFP_KERNEL);
 114	if (wusb_dev == NULL)
 115		goto err;
 116
 117	wusb_dev->wusbhc = wusbhc;
 118
 119	INIT_WORK(&wusb_dev->devconnect_acked_work, wusbhc_devconnect_acked_work);
 120
 121	urb = usb_alloc_urb(0, GFP_KERNEL);
 122	if (urb == NULL)
 123		goto err;
 124	wusb_dev->set_gtk_urb = urb;
 125
 126	req = kmalloc(sizeof(*req), GFP_KERNEL);
 127	if (req == NULL)
 128		goto err;
 129	wusb_dev->set_gtk_req = req;
 130
 131	req->bRequestType = USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE;
 132	req->bRequest = USB_REQ_SET_DESCRIPTOR;
 133	req->wValue = cpu_to_le16(USB_DT_KEY << 8 | wusbhc->gtk_index);
 134	req->wIndex = 0;
 135	req->wLength = cpu_to_le16(wusbhc->gtk.descr.bLength);
 136
 137	return wusb_dev;
 138err:
 139	wusb_dev_free(wusb_dev);
 140	return NULL;
 141}
 142
 143
 144/*
 145 * Using the Connect-Ack list, fill out the @wusbhc Connect-Ack WUSB IE
 146 * properly so that it can be added to the MMC.
 147 *
 148 * We just get the @wusbhc->ca_list and fill out the first four ones or
 149 * less (per-spec WUSB1.0[7.5, before T7-38). If the ConnectAck WUSB
 150 * IE is not allocated, we alloc it.
 151 *
 152 * @wusbhc->mutex must be taken
 153 */
 154static void wusbhc_fill_cack_ie(struct wusbhc *wusbhc)
 155{
 156	unsigned cnt;
 157	struct wusb_dev *dev_itr;
 158	struct wuie_connect_ack *cack_ie;
 159
 160	cack_ie = &wusbhc->cack_ie;
 161	cnt = 0;
 162	list_for_each_entry(dev_itr, &wusbhc->cack_list, cack_node) {
 163		cack_ie->blk[cnt].CDID = dev_itr->cdid;
 164		cack_ie->blk[cnt].bDeviceAddress = dev_itr->addr;
 165		if (++cnt >= WUIE_ELT_MAX)
 166			break;
 167	}
 168	cack_ie->hdr.bLength = sizeof(cack_ie->hdr)
 169		+ cnt * sizeof(cack_ie->blk[0]);
 170}
 171
 172/*
 173 * Register a new device that wants to connect
 174 *
 175 * A new device wants to connect, so we add it to the Connect-Ack
 176 * list. We give it an address in the unauthorized range (bit 8 set);
 177 * user space will have to drive authorization further on.
 178 *
 179 * @dev_addr: address to use for the device (which is also the port
 180 *            number).
 181 *
 182 * @wusbhc->mutex must be taken
 183 */
 184static struct wusb_dev *wusbhc_cack_add(struct wusbhc *wusbhc,
 185					struct wusb_dn_connect *dnc,
 186					const char *pr_cdid, u8 port_idx)
 187{
 188	struct device *dev = wusbhc->dev;
 189	struct wusb_dev *wusb_dev;
 190	int new_connection = wusb_dn_connect_new_connection(dnc);
 191	u8 dev_addr;
 192	int result;
 193
 194	/* Is it registered already? */
 195	list_for_each_entry(wusb_dev, &wusbhc->cack_list, cack_node)
 196		if (!memcmp(&wusb_dev->cdid, &dnc->CDID,
 197			    sizeof(wusb_dev->cdid)))
 198			return wusb_dev;
 199	/* We don't have it, create an entry, register it */
 200	wusb_dev = wusb_dev_alloc(wusbhc);
 201	if (wusb_dev == NULL)
 202		return NULL;
 203	wusb_dev_init(wusb_dev);
 204	wusb_dev->cdid = dnc->CDID;
 205	wusb_dev->port_idx = port_idx;
 206
 207	/*
 208	 * Devices are always available within the cluster reservation
 209	 * and since the hardware will take the intersection of the
 210	 * per-device availability and the cluster reservation, the
 211	 * per-device availability can simply be set to always
 212	 * available.
 213	 */
 214	bitmap_fill(wusb_dev->availability.bm, UWB_NUM_MAS);
 215
 216	/* FIXME: handle reconnects instead of assuming connects are
 217	   always new. */
 218	if (1 && new_connection == 0)
 219		new_connection = 1;
 220	if (new_connection) {
 221		dev_addr = (port_idx + 2) | WUSB_DEV_ADDR_UNAUTH;
 222
 223		dev_info(dev, "Connecting new WUSB device to address %u, "
 224			"port %u\n", dev_addr, port_idx);
 225
 226		result = wusb_set_dev_addr(wusbhc, wusb_dev, dev_addr);
 227		if (result < 0)
 228			return NULL;
 229	}
 230	wusb_dev->entry_ts = jiffies;
 231	list_add_tail(&wusb_dev->cack_node, &wusbhc->cack_list);
 232	wusbhc->cack_count++;
 233	wusbhc_fill_cack_ie(wusbhc);
 234
 235	return wusb_dev;
 236}
 237
 238/*
 239 * Remove a Connect-Ack context entry from the HCs view
 240 *
 241 * @wusbhc->mutex must be taken
 242 */
 243static void wusbhc_cack_rm(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
 244{
 245	list_del_init(&wusb_dev->cack_node);
 246	wusbhc->cack_count--;
 247	wusbhc_fill_cack_ie(wusbhc);
 248}
 249
 250/*
 251 * @wusbhc->mutex must be taken */
 252static
 253void wusbhc_devconnect_acked(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
 254{
 255	wusbhc_cack_rm(wusbhc, wusb_dev);
 256	if (wusbhc->cack_count)
 257		wusbhc_mmcie_set(wusbhc, 0, 0, &wusbhc->cack_ie.hdr);
 258	else
 259		wusbhc_mmcie_rm(wusbhc, &wusbhc->cack_ie.hdr);
 260}
 261
 262static void wusbhc_devconnect_acked_work(struct work_struct *work)
 263{
 264	struct wusb_dev *wusb_dev = container_of(work, struct wusb_dev,
 265						 devconnect_acked_work);
 266	struct wusbhc *wusbhc = wusb_dev->wusbhc;
 267
 268	mutex_lock(&wusbhc->mutex);
 269	wusbhc_devconnect_acked(wusbhc, wusb_dev);
 270	mutex_unlock(&wusbhc->mutex);
 271
 272	wusb_dev_put(wusb_dev);
 273}
 274
 275/*
 276 * Ack a device for connection
 277 *
 278 * FIXME: docs
 279 *
 280 * @pr_cdid:	Printable CDID...hex Use @dnc->cdid for the real deal.
 281 *
 282 * So we get the connect ack IE (may have been allocated already),
 283 * find an empty connect block, an empty virtual port, create an
 284 * address with it (see below), make it an unauth addr [bit 7 set] and
 285 * set the MMC.
 286 *
 287 * Addresses: because WUSB hosts have no downstream hubs, we can do a
 288 *            1:1 mapping between 'port number' and device
 289 *            address. This simplifies many things, as during this
 290 *            initial connect phase the USB stack has no knoledge of
 291 *            the device and hasn't assigned an address yet--we know
 292 *            USB's choose_address() will use the same euristics we
 293 *            use here, so we can assume which address will be assigned.
 294 *
 295 *            USB stack always assigns address 1 to the root hub, so
 296 *            to the port number we add 2 (thus virtual port #0 is
 297 *            addr #2).
 298 *
 299 * @wusbhc shall be referenced
 300 */
 301static
 302void wusbhc_devconnect_ack(struct wusbhc *wusbhc, struct wusb_dn_connect *dnc,
 303			   const char *pr_cdid)
 304{
 305	int result;
 306	struct device *dev = wusbhc->dev;
 307	struct wusb_dev *wusb_dev;
 308	struct wusb_port *port;
 309	unsigned idx, devnum;
 310
 311	mutex_lock(&wusbhc->mutex);
 312
 313	/* Check we are not handling it already */
 314	for (idx = 0; idx < wusbhc->ports_max; idx++) {
 315		port = wusb_port_by_idx(wusbhc, idx);
 316		if (port->wusb_dev
 317		    && memcmp(&dnc->CDID, &port->wusb_dev->cdid, sizeof(dnc->CDID)) == 0)
 318			goto error_unlock;
 319	}
 320	/* Look up those fake ports we have for a free one */
 321	for (idx = 0; idx < wusbhc->ports_max; idx++) {
 322		port = wusb_port_by_idx(wusbhc, idx);
 323		if ((port->status & USB_PORT_STAT_POWER)
 324		    && !(port->status & USB_PORT_STAT_CONNECTION))
 325			break;
 326	}
 327	if (idx >= wusbhc->ports_max) {
 328		dev_err(dev, "Host controller can't connect more devices "
 329			"(%u already connected); device %s rejected\n",
 330			wusbhc->ports_max, pr_cdid);
 331		/* NOTE: we could send a WUIE_Disconnect here, but we haven't
 332		 *       event acked, so the device will eventually timeout the
 333		 *       connection, right? */
 334		goto error_unlock;
 335	}
 336
 337	devnum = idx + 2;
 338
 339	/* Make sure we are using no crypto on that "virtual port" */
 340	wusbhc->set_ptk(wusbhc, idx, 0, NULL, 0);
 341
 342	/* Grab a filled in Connect-Ack context, fill out the
 343	 * Connect-Ack Wireless USB IE, set the MMC */
 344	wusb_dev = wusbhc_cack_add(wusbhc, dnc, pr_cdid, idx);
 345	if (wusb_dev == NULL)
 346		goto error_unlock;
 347	result = wusbhc_mmcie_set(wusbhc, 0, 0, &wusbhc->cack_ie.hdr);
 348	if (result < 0)
 349		goto error_unlock;
 350	/* Give the device at least 2ms (WUSB1.0[7.5.1p3]), let's do
 351	 * three for a good measure */
 352	msleep(3);
 353	port->wusb_dev = wusb_dev;
 354	port->status |= USB_PORT_STAT_CONNECTION;
 355	port->change |= USB_PORT_STAT_C_CONNECTION;
 356	/* Now the port status changed to connected; khubd will
 357	 * pick the change up and try to reset the port to bring it to
 358	 * the enabled state--so this process returns up to the stack
 359	 * and it calls back into wusbhc_rh_port_reset().
 360	 */
 361error_unlock:
 362	mutex_unlock(&wusbhc->mutex);
 363	return;
 364
 365}
 366
 367/*
 368 * Disconnect a Wireless USB device from its fake port
 369 *
 370 * Marks the port as disconnected so that khubd can pick up the change
 371 * and drops our knowledge about the device.
 372 *
 373 * Assumes there is a device connected
 374 *
 375 * @port_index: zero based port number
 376 *
 377 * NOTE: @wusbhc->mutex is locked
 378 *
 379 * WARNING: From here it is not very safe to access anything hanging off
 380 *	    wusb_dev
 381 */
 382static void __wusbhc_dev_disconnect(struct wusbhc *wusbhc,
 383				    struct wusb_port *port)
 384{
 385	struct wusb_dev *wusb_dev = port->wusb_dev;
 386
 387	port->status &= ~(USB_PORT_STAT_CONNECTION | USB_PORT_STAT_ENABLE
 388			  | USB_PORT_STAT_SUSPEND | USB_PORT_STAT_RESET
 389			  | USB_PORT_STAT_LOW_SPEED | USB_PORT_STAT_HIGH_SPEED);
 390	port->change |= USB_PORT_STAT_C_CONNECTION | USB_PORT_STAT_C_ENABLE;
 391	if (wusb_dev) {
 392		dev_dbg(wusbhc->dev, "disconnecting device from port %d\n", wusb_dev->port_idx);
 393		if (!list_empty(&wusb_dev->cack_node))
 394			list_del_init(&wusb_dev->cack_node);
 395		/* For the one in cack_add() */
 396		wusb_dev_put(wusb_dev);
 397	}
 398	port->wusb_dev = NULL;
 399
 400	/* After a device disconnects, change the GTK (see [WUSB]
 401	 * section 6.2.11.2). */
 402	if (wusbhc->active)
 403		wusbhc_gtk_rekey(wusbhc);
 404
 405	/* The Wireless USB part has forgotten about the device already; now
 406	 * khubd's timer will pick up the disconnection and remove the USB
 407	 * device from the system
 408	 */
 409}
 410
 411/*
 412 * Refresh the list of keep alives to emit in the MMC
 413 *
 414 * Some devices don't respond to keep alives unless they've been
 415 * authenticated, so skip unauthenticated devices.
 416 *
 417 * We only publish the first four devices that have a coming timeout
 418 * condition. Then when we are done processing those, we go for the
 419 * next ones. We ignore the ones that have timed out already (they'll
 420 * be purged).
 421 *
 422 * This might cause the first devices to timeout the last devices in
 423 * the port array...FIXME: come up with a better algorithm?
 424 *
 425 * Note we can't do much about MMC's ops errors; we hope next refresh
 426 * will kind of handle it.
 427 *
 428 * NOTE: @wusbhc->mutex is locked
 429 */
 430static void __wusbhc_keep_alive(struct wusbhc *wusbhc)
 431{
 432	struct device *dev = wusbhc->dev;
 433	unsigned cnt;
 434	struct wusb_dev *wusb_dev;
 435	struct wusb_port *wusb_port;
 436	struct wuie_keep_alive *ie = &wusbhc->keep_alive_ie;
 437	unsigned keep_alives, old_keep_alives;
 438
 439	old_keep_alives = ie->hdr.bLength - sizeof(ie->hdr);
 440	keep_alives = 0;
 441	for (cnt = 0;
 442	     keep_alives < WUIE_ELT_MAX && cnt < wusbhc->ports_max;
 443	     cnt++) {
 444		unsigned tt = msecs_to_jiffies(wusbhc->trust_timeout);
 445
 446		wusb_port = wusb_port_by_idx(wusbhc, cnt);
 447		wusb_dev = wusb_port->wusb_dev;
 448
 449		if (wusb_dev == NULL)
 450			continue;
 451		if (wusb_dev->usb_dev == NULL || !wusb_dev->usb_dev->authenticated)
 452			continue;
 453
 454		if (time_after(jiffies, wusb_dev->entry_ts + tt)) {
 455			dev_err(dev, "KEEPALIVE: device %u timed out\n",
 456				wusb_dev->addr);
 457			__wusbhc_dev_disconnect(wusbhc, wusb_port);
 458		} else if (time_after(jiffies, wusb_dev->entry_ts + tt/2)) {
 459			/* Approaching timeout cut out, need to refresh */
 460			ie->bDeviceAddress[keep_alives++] = wusb_dev->addr;
 461		}
 462	}
 463	if (keep_alives & 0x1)	/* pad to even number ([WUSB] section 7.5.9) */
 464		ie->bDeviceAddress[keep_alives++] = 0x7f;
 465	ie->hdr.bLength = sizeof(ie->hdr) +
 466		keep_alives*sizeof(ie->bDeviceAddress[0]);
 467	if (keep_alives > 0)
 468		wusbhc_mmcie_set(wusbhc, 10, 5, &ie->hdr);
 469	else if (old_keep_alives != 0)
 470		wusbhc_mmcie_rm(wusbhc, &ie->hdr);
 471}
 472
 473/*
 474 * Do a run through all devices checking for timeouts
 475 */
 476static void wusbhc_keep_alive_run(struct work_struct *ws)
 477{
 478	struct delayed_work *dw = to_delayed_work(ws);
 479	struct wusbhc *wusbhc =	container_of(dw, struct wusbhc, keep_alive_timer);
 480
 481	mutex_lock(&wusbhc->mutex);
 482	__wusbhc_keep_alive(wusbhc);
 483	mutex_unlock(&wusbhc->mutex);
 484
 485	queue_delayed_work(wusbd, &wusbhc->keep_alive_timer,
 486			   msecs_to_jiffies(wusbhc->trust_timeout / 2));
 487}
 488
 489/*
 490 * Find the wusb_dev from its device address.
 491 *
 492 * The device can be found directly from the address (see
 493 * wusb_cack_add() for where the device address is set to port_idx
 494 * +2), except when the address is zero.
 495 */
 496static struct wusb_dev *wusbhc_find_dev_by_addr(struct wusbhc *wusbhc, u8 addr)
 497{
 498	int p;
 499
 500	if (addr == 0xff) /* unconnected */
 501		return NULL;
 502
 503	if (addr > 0) {
 504		int port = (addr & ~0x80) - 2;
 505		if (port < 0 || port >= wusbhc->ports_max)
 506			return NULL;
 507		return wusb_port_by_idx(wusbhc, port)->wusb_dev;
 508	}
 509
 510	/* Look for the device with address 0. */
 511	for (p = 0; p < wusbhc->ports_max; p++) {
 512		struct wusb_dev *wusb_dev = wusb_port_by_idx(wusbhc, p)->wusb_dev;
 513		if (wusb_dev && wusb_dev->addr == addr)
 514			return wusb_dev;
 515	}
 516	return NULL;
 517}
 518
 519/*
 520 * Handle a DN_Alive notification (WUSB1.0[7.6.1])
 521 *
 522 * This just updates the device activity timestamp and then refreshes
 523 * the keep alive IE.
 524 *
 525 * @wusbhc shall be referenced and unlocked
 526 */
 527static void wusbhc_handle_dn_alive(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
 528{
 529	mutex_lock(&wusbhc->mutex);
 530	wusb_dev->entry_ts = jiffies;
 531	__wusbhc_keep_alive(wusbhc);
 532	mutex_unlock(&wusbhc->mutex);
 533}
 534
 535/*
 536 * Handle a DN_Connect notification (WUSB1.0[7.6.1])
 537 *
 538 * @wusbhc
 539 * @pkt_hdr
 540 * @size:    Size of the buffer where the notification resides; if the
 541 *           notification data suggests there should be more data than
 542 *           available, an error will be signaled and the whole buffer
 543 *           consumed.
 544 *
 545 * @wusbhc->mutex shall be held
 546 */
 547static void wusbhc_handle_dn_connect(struct wusbhc *wusbhc,
 548				     struct wusb_dn_hdr *dn_hdr,
 549				     size_t size)
 550{
 551	struct device *dev = wusbhc->dev;
 552	struct wusb_dn_connect *dnc;
 553	char pr_cdid[WUSB_CKHDID_STRSIZE];
 554	static const char *beacon_behaviour[] = {
 555		"reserved",
 556		"self-beacon",
 557		"directed-beacon",
 558		"no-beacon"
 559	};
 560
 561	if (size < sizeof(*dnc)) {
 562		dev_err(dev, "DN CONNECT: short notification (%zu < %zu)\n",
 563			size, sizeof(*dnc));
 564		return;
 565	}
 566
 567	dnc = container_of(dn_hdr, struct wusb_dn_connect, hdr);
 568	ckhdid_printf(pr_cdid, sizeof(pr_cdid), &dnc->CDID);
 569	dev_info(dev, "DN CONNECT: device %s @ %x (%s) wants to %s\n",
 570		 pr_cdid,
 571		 wusb_dn_connect_prev_dev_addr(dnc),
 572		 beacon_behaviour[wusb_dn_connect_beacon_behavior(dnc)],
 573		 wusb_dn_connect_new_connection(dnc) ? "connect" : "reconnect");
 574	/* ACK the connect */
 575	wusbhc_devconnect_ack(wusbhc, dnc, pr_cdid);
 576}
 577
 578/*
 579 * Handle a DN_Disconnect notification (WUSB1.0[7.6.1])
 580 *
 581 * Device is going down -- do the disconnect.
 582 *
 583 * @wusbhc shall be referenced and unlocked
 584 */
 585static void wusbhc_handle_dn_disconnect(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
 586{
 587	struct device *dev = wusbhc->dev;
 588
 589	dev_info(dev, "DN DISCONNECT: device 0x%02x going down\n", wusb_dev->addr);
 590
 591	mutex_lock(&wusbhc->mutex);
 592	__wusbhc_dev_disconnect(wusbhc, wusb_port_by_idx(wusbhc, wusb_dev->port_idx));
 593	mutex_unlock(&wusbhc->mutex);
 594}
 595
 596/*
 597 * Handle a Device Notification coming a host
 598 *
 599 * The Device Notification comes from a host (HWA, DWA or WHCI)
 600 * wrapped in a set of headers. Somebody else has peeled off those
 601 * headers for us and we just get one Device Notifications.
 602 *
 603 * Invalid DNs (e.g., too short) are discarded.
 604 *
 605 * @wusbhc shall be referenced
 606 *
 607 * FIXMES:
 608 *  - implement priorities as in WUSB1.0[Table 7-55]?
 609 */
 610void wusbhc_handle_dn(struct wusbhc *wusbhc, u8 srcaddr,
 611		      struct wusb_dn_hdr *dn_hdr, size_t size)
 612{
 613	struct device *dev = wusbhc->dev;
 614	struct wusb_dev *wusb_dev;
 615
 616	if (size < sizeof(struct wusb_dn_hdr)) {
 617		dev_err(dev, "DN data shorter than DN header (%d < %d)\n",
 618			(int)size, (int)sizeof(struct wusb_dn_hdr));
 619		return;
 620	}
 621
 622	wusb_dev = wusbhc_find_dev_by_addr(wusbhc, srcaddr);
 623	if (wusb_dev == NULL && dn_hdr->bType != WUSB_DN_CONNECT) {
 624		dev_dbg(dev, "ignoring DN %d from unconnected device %02x\n",
 625			dn_hdr->bType, srcaddr);
 626		return;
 627	}
 628
 629	switch (dn_hdr->bType) {
 630	case WUSB_DN_CONNECT:
 631		wusbhc_handle_dn_connect(wusbhc, dn_hdr, size);
 632		break;
 633	case WUSB_DN_ALIVE:
 634		wusbhc_handle_dn_alive(wusbhc, wusb_dev);
 635		break;
 636	case WUSB_DN_DISCONNECT:
 637		wusbhc_handle_dn_disconnect(wusbhc, wusb_dev);
 638		break;
 639	case WUSB_DN_MASAVAILCHANGED:
 640	case WUSB_DN_RWAKE:
 641	case WUSB_DN_SLEEP:
 642		/* FIXME: handle these DNs. */
 643		break;
 644	case WUSB_DN_EPRDY:
 645		/* The hardware handles these. */
 646		break;
 647	default:
 648		dev_warn(dev, "unknown DN %u (%d octets) from %u\n",
 649			 dn_hdr->bType, (int)size, srcaddr);
 650	}
 651}
 652EXPORT_SYMBOL_GPL(wusbhc_handle_dn);
 653
 654/*
 655 * Disconnect a WUSB device from a the cluster
 656 *
 657 * @wusbhc
 658 * @port     Fake port where the device is (wusbhc index, not USB port number).
 659 *
 660 * In Wireless USB, a disconnect is basically telling the device he is
 661 * being disconnected and forgetting about him.
 662 *
 663 * We send the device a Device Disconnect IE (WUSB1.0[7.5.11]) for 100
 664 * ms and then keep going.
 665 *
 666 * We don't do much in case of error; we always pretend we disabled
 667 * the port and disconnected the device. If physically the request
 668 * didn't get there (many things can fail in the way there), the stack
 669 * will reject the device's communication attempts.
 670 *
 671 * @wusbhc should be refcounted and locked
 672 */
 673void __wusbhc_dev_disable(struct wusbhc *wusbhc, u8 port_idx)
 674{
 675	int result;
 676	struct device *dev = wusbhc->dev;
 677	struct wusb_dev *wusb_dev;
 678	struct wuie_disconnect *ie;
 679
 680	wusb_dev = wusb_port_by_idx(wusbhc, port_idx)->wusb_dev;
 681	if (wusb_dev == NULL) {
 682		/* reset no device? ignore */
 683		dev_dbg(dev, "DISCONNECT: no device at port %u, ignoring\n",
 684			port_idx);
 685		return;
 686	}
 687	__wusbhc_dev_disconnect(wusbhc, wusb_port_by_idx(wusbhc, port_idx));
 688
 689	ie = kzalloc(sizeof(*ie), GFP_KERNEL);
 690	if (ie == NULL)
 691		return;
 692	ie->hdr.bLength = sizeof(*ie);
 693	ie->hdr.bIEIdentifier = WUIE_ID_DEVICE_DISCONNECT;
 694	ie->bDeviceAddress = wusb_dev->addr;
 695	result = wusbhc_mmcie_set(wusbhc, 0, 0, &ie->hdr);
 696	if (result < 0)
 697		dev_err(dev, "DISCONNECT: can't set MMC: %d\n", result);
 698	else {
 699		/* At least 6 MMCs, assuming at least 1 MMC per zone. */
 700		msleep(7*4);
 701		wusbhc_mmcie_rm(wusbhc, &ie->hdr);
 702	}
 703	kfree(ie);
 704}
 705
 706/*
 707 * Walk over the BOS descriptor, verify and grok it
 708 *
 709 * @usb_dev: referenced
 710 * @wusb_dev: referenced and unlocked
 711 *
 712 * The BOS descriptor is defined at WUSB1.0[7.4.1], and it defines a
 713 * "flexible" way to wrap all kinds of descriptors inside an standard
 714 * descriptor (wonder why they didn't use normal descriptors,
 715 * btw). Not like they lack code.
 716 *
 717 * At the end we go to look for the WUSB Device Capabilities
 718 * (WUSB1.0[7.4.1.1]) that is wrapped in a device capability descriptor
 719 * that is part of the BOS descriptor set. That tells us what does the
 720 * device support (dual role, beacon type, UWB PHY rates).
 721 */
 722static int wusb_dev_bos_grok(struct usb_device *usb_dev,
 723			     struct wusb_dev *wusb_dev,
 724			     struct usb_bos_descriptor *bos, size_t desc_size)
 725{
 726	ssize_t result;
 727	struct device *dev = &usb_dev->dev;
 728	void *itr, *top;
 729
 730	/* Walk over BOS capabilities, verify them */
 731	itr = (void *)bos + sizeof(*bos);
 732	top = itr + desc_size - sizeof(*bos);
 733	while (itr < top) {
 734		struct usb_dev_cap_header *cap_hdr = itr;
 735		size_t cap_size;
 736		u8 cap_type;
 737		if (top - itr < sizeof(*cap_hdr)) {
 738			dev_err(dev, "Device BUG? premature end of BOS header "
 739				"data [offset 0x%02x]: only %zu bytes left\n",
 740				(int)(itr - (void *)bos), top - itr);
 741			result = -ENOSPC;
 742			goto error_bad_cap;
 743		}
 744		cap_size = cap_hdr->bLength;
 745		cap_type = cap_hdr->bDevCapabilityType;
 746		if (cap_size == 0)
 747			break;
 748		if (cap_size > top - itr) {
 749			dev_err(dev, "Device BUG? premature end of BOS data "
 750				"[offset 0x%02x cap %02x %zu bytes]: "
 751				"only %zu bytes left\n",
 752				(int)(itr - (void *)bos),
 753				cap_type, cap_size, top - itr);
 754			result = -EBADF;
 755			goto error_bad_cap;
 756		}
 757		switch (cap_type) {
 758		case USB_CAP_TYPE_WIRELESS_USB:
 759			if (cap_size != sizeof(*wusb_dev->wusb_cap_descr))
 760				dev_err(dev, "Device BUG? WUSB Capability "
 761					"descriptor is %zu bytes vs %zu "
 762					"needed\n", cap_size,
 763					sizeof(*wusb_dev->wusb_cap_descr));
 764			else
 765				wusb_dev->wusb_cap_descr = itr;
 766			break;
 767		default:
 768			dev_err(dev, "BUG? Unknown BOS capability 0x%02x "
 769				"(%zu bytes) at offset 0x%02x\n", cap_type,
 770				cap_size, (int)(itr - (void *)bos));
 771		}
 772		itr += cap_size;
 773	}
 774	result = 0;
 775error_bad_cap:
 776	return result;
 777}
 778
 779/*
 780 * Add information from the BOS descriptors to the device
 781 *
 782 * @usb_dev: referenced
 783 * @wusb_dev: referenced and unlocked
 784 *
 785 * So what we do is we alloc a space for the BOS descriptor of 64
 786 * bytes; read the first four bytes which include the wTotalLength
 787 * field (WUSB1.0[T7-26]) and if it fits in those 64 bytes, read the
 788 * whole thing. If not we realloc to that size.
 789 *
 790 * Then we call the groking function, that will fill up
 791 * wusb_dev->wusb_cap_descr, which is what we'll need later on.
 792 */
 793static int wusb_dev_bos_add(struct usb_device *usb_dev,
 794			    struct wusb_dev *wusb_dev)
 795{
 796	ssize_t result;
 797	struct device *dev = &usb_dev->dev;
 798	struct usb_bos_descriptor *bos;
 799	size_t alloc_size = 32, desc_size = 4;
 800
 801	bos = kmalloc(alloc_size, GFP_KERNEL);
 802	if (bos == NULL)
 803		return -ENOMEM;
 804	result = usb_get_descriptor(usb_dev, USB_DT_BOS, 0, bos, desc_size);
 805	if (result < 4) {
 806		dev_err(dev, "Can't get BOS descriptor or too short: %zd\n",
 807			result);
 808		goto error_get_descriptor;
 809	}
 810	desc_size = le16_to_cpu(bos->wTotalLength);
 811	if (desc_size >= alloc_size) {
 812		kfree(bos);
 813		alloc_size = desc_size;
 814		bos = kmalloc(alloc_size, GFP_KERNEL);
 815		if (bos == NULL)
 816			return -ENOMEM;
 817	}
 818	result = usb_get_descriptor(usb_dev, USB_DT_BOS, 0, bos, desc_size);
 819	if (result < 0 || result != desc_size) {
 820		dev_err(dev, "Can't get  BOS descriptor or too short (need "
 821			"%zu bytes): %zd\n", desc_size, result);
 822		goto error_get_descriptor;
 823	}
 824	if (result < sizeof(*bos)
 825	    || le16_to_cpu(bos->wTotalLength) != desc_size) {
 826		dev_err(dev, "Can't get  BOS descriptor or too short (need "
 827			"%zu bytes): %zd\n", desc_size, result);
 828		goto error_get_descriptor;
 829	}
 830
 831	result = wusb_dev_bos_grok(usb_dev, wusb_dev, bos, result);
 832	if (result < 0)
 833		goto error_bad_bos;
 834	wusb_dev->bos = bos;
 835	return 0;
 836
 837error_bad_bos:
 838error_get_descriptor:
 839	kfree(bos);
 840	wusb_dev->wusb_cap_descr = NULL;
 841	return result;
 842}
 843
 844static void wusb_dev_bos_rm(struct wusb_dev *wusb_dev)
 845{
 846	kfree(wusb_dev->bos);
 847	wusb_dev->wusb_cap_descr = NULL;
 848};
 849
 850static struct usb_wireless_cap_descriptor wusb_cap_descr_default = {
 851	.bLength = sizeof(wusb_cap_descr_default),
 852	.bDescriptorType = USB_DT_DEVICE_CAPABILITY,
 853	.bDevCapabilityType = USB_CAP_TYPE_WIRELESS_USB,
 854
 855	.bmAttributes = USB_WIRELESS_BEACON_NONE,
 856	.wPHYRates = cpu_to_le16(USB_WIRELESS_PHY_53),
 857	.bmTFITXPowerInfo = 0,
 858	.bmFFITXPowerInfo = 0,
 859	.bmBandGroup = cpu_to_le16(0x0001),	/* WUSB1.0[7.4.1] bottom */
 860	.bReserved = 0
 861};
 862
 863/*
 864 * USB stack's device addition Notifier Callback
 865 *
 866 * Called from drivers/usb/core/hub.c when a new device is added; we
 867 * use this hook to perform certain WUSB specific setup work on the
 868 * new device. As well, it is the first time we can connect the
 869 * wusb_dev and the usb_dev. So we note it down in wusb_dev and take a
 870 * reference that we'll drop.
 871 *
 872 * First we need to determine if the device is a WUSB device (else we
 873 * ignore it). For that we use the speed setting (USB_SPEED_WIRELESS)
 874 * [FIXME: maybe we'd need something more definitive]. If so, we track
 875 * it's usb_busd and from there, the WUSB HC.
 876 *
 877 * Because all WUSB HCs are contained in a 'struct wusbhc', voila, we
 878 * get the wusbhc for the device.
 879 *
 880 * We have a reference on @usb_dev (as we are called at the end of its
 881 * enumeration).
 882 *
 883 * NOTE: @usb_dev locked
 884 */
 885static void wusb_dev_add_ncb(struct usb_device *usb_dev)
 886{
 887	int result = 0;
 888	struct wusb_dev *wusb_dev;
 889	struct wusbhc *wusbhc;
 890	struct device *dev = &usb_dev->dev;
 891	u8 port_idx;
 892
 893	if (usb_dev->wusb == 0 || usb_dev->devnum == 1)
 894		return;		/* skip non wusb and wusb RHs */
 895
 896	usb_set_device_state(usb_dev, USB_STATE_UNAUTHENTICATED);
 897
 898	wusbhc = wusbhc_get_by_usb_dev(usb_dev);
 899	if (wusbhc == NULL)
 900		goto error_nodev;
 901	mutex_lock(&wusbhc->mutex);
 902	wusb_dev = __wusb_dev_get_by_usb_dev(wusbhc, usb_dev);
 903	port_idx = wusb_port_no_to_idx(usb_dev->portnum);
 904	mutex_unlock(&wusbhc->mutex);
 905	if (wusb_dev == NULL)
 906		goto error_nodev;
 907	wusb_dev->usb_dev = usb_get_dev(usb_dev);
 908	usb_dev->wusb_dev = wusb_dev_get(wusb_dev);
 909	result = wusb_dev_sec_add(wusbhc, usb_dev, wusb_dev);
 910	if (result < 0) {
 911		dev_err(dev, "Cannot enable security: %d\n", result);
 912		goto error_sec_add;
 913	}
 914	/* Now query the device for it's BOS and attach it to wusb_dev */
 915	result = wusb_dev_bos_add(usb_dev, wusb_dev);
 916	if (result < 0) {
 917		dev_err(dev, "Cannot get BOS descriptors: %d\n", result);
 918		goto error_bos_add;
 919	}
 920	result = wusb_dev_sysfs_add(wusbhc, usb_dev, wusb_dev);
 921	if (result < 0)
 922		goto error_add_sysfs;
 923out:
 924	wusb_dev_put(wusb_dev);
 925	wusbhc_put(wusbhc);
 926error_nodev:
 927	return;
 928
 929	wusb_dev_sysfs_rm(wusb_dev);
 930error_add_sysfs:
 931	wusb_dev_bos_rm(wusb_dev);
 932error_bos_add:
 933	wusb_dev_sec_rm(wusb_dev);
 934error_sec_add:
 935	mutex_lock(&wusbhc->mutex);
 936	__wusbhc_dev_disconnect(wusbhc, wusb_port_by_idx(wusbhc, port_idx));
 937	mutex_unlock(&wusbhc->mutex);
 938	goto out;
 939}
 940
 941/*
 942 * Undo all the steps done at connection by the notifier callback
 943 *
 944 * NOTE: @usb_dev locked
 945 */
 946static void wusb_dev_rm_ncb(struct usb_device *usb_dev)
 947{
 948	struct wusb_dev *wusb_dev = usb_dev->wusb_dev;
 949
 950	if (usb_dev->wusb == 0 || usb_dev->devnum == 1)
 951		return;		/* skip non wusb and wusb RHs */
 952
 953	wusb_dev_sysfs_rm(wusb_dev);
 954	wusb_dev_bos_rm(wusb_dev);
 955	wusb_dev_sec_rm(wusb_dev);
 956	wusb_dev->usb_dev = NULL;
 957	usb_dev->wusb_dev = NULL;
 958	wusb_dev_put(wusb_dev);
 959	usb_put_dev(usb_dev);
 960}
 961
 962/*
 963 * Handle notifications from the USB stack (notifier call back)
 964 *
 965 * This is called when the USB stack does a
 966 * usb_{bus,device}_{add,remove}() so we can do WUSB specific
 967 * handling. It is called with [for the case of
 968 * USB_DEVICE_{ADD,REMOVE} with the usb_dev locked.
 969 */
 970int wusb_usb_ncb(struct notifier_block *nb, unsigned long val,
 971		 void *priv)
 972{
 973	int result = NOTIFY_OK;
 974
 975	switch (val) {
 976	case USB_DEVICE_ADD:
 977		wusb_dev_add_ncb(priv);
 978		break;
 979	case USB_DEVICE_REMOVE:
 980		wusb_dev_rm_ncb(priv);
 981		break;
 982	case USB_BUS_ADD:
 983		/* ignore (for now) */
 984	case USB_BUS_REMOVE:
 985		break;
 986	default:
 987		WARN_ON(1);
 988		result = NOTIFY_BAD;
 989	};
 990	return result;
 991}
 992
 993/*
 994 * Return a referenced wusb_dev given a @wusbhc and @usb_dev
 995 */
 996struct wusb_dev *__wusb_dev_get_by_usb_dev(struct wusbhc *wusbhc,
 997					   struct usb_device *usb_dev)
 998{
 999	struct wusb_dev *wusb_dev;
1000	u8 port_idx;
1001
1002	port_idx = wusb_port_no_to_idx(usb_dev->portnum);
1003	BUG_ON(port_idx > wusbhc->ports_max);
1004	wusb_dev = wusb_port_by_idx(wusbhc, port_idx)->wusb_dev;
1005	if (wusb_dev != NULL)		/* ops, device is gone */
1006		wusb_dev_get(wusb_dev);
1007	return wusb_dev;
1008}
1009EXPORT_SYMBOL_GPL(__wusb_dev_get_by_usb_dev);
1010
1011void wusb_dev_destroy(struct kref *_wusb_dev)
1012{
1013	struct wusb_dev *wusb_dev = container_of(_wusb_dev, struct wusb_dev, refcnt);
1014
1015	list_del_init(&wusb_dev->cack_node);
1016	wusb_dev_free(wusb_dev);
1017}
1018EXPORT_SYMBOL_GPL(wusb_dev_destroy);
1019
1020/*
1021 * Create all the device connect handling infrastructure
1022 *
1023 * This is basically the device info array, Connect Acknowledgement
1024 * (cack) lists, keep-alive timers (and delayed work thread).
1025 */
1026int wusbhc_devconnect_create(struct wusbhc *wusbhc)
1027{
1028	wusbhc->keep_alive_ie.hdr.bIEIdentifier = WUIE_ID_KEEP_ALIVE;
1029	wusbhc->keep_alive_ie.hdr.bLength = sizeof(wusbhc->keep_alive_ie.hdr);
1030	INIT_DELAYED_WORK(&wusbhc->keep_alive_timer, wusbhc_keep_alive_run);
1031
1032	wusbhc->cack_ie.hdr.bIEIdentifier = WUIE_ID_CONNECTACK;
1033	wusbhc->cack_ie.hdr.bLength = sizeof(wusbhc->cack_ie.hdr);
1034	INIT_LIST_HEAD(&wusbhc->cack_list);
1035
1036	return 0;
1037}
1038
1039/*
1040 * Release all resources taken by the devconnect stuff
1041 */
1042void wusbhc_devconnect_destroy(struct wusbhc *wusbhc)
1043{
1044	/* no op */
1045}
1046
1047/*
1048 * wusbhc_devconnect_start - start accepting device connections
1049 * @wusbhc: the WUSB HC
1050 *
1051 * Sets the Host Info IE to accept all new connections.
1052 *
1053 * FIXME: This also enables the keep alives but this is not necessary
1054 * until there are connected and authenticated devices.
1055 */
1056int wusbhc_devconnect_start(struct wusbhc *wusbhc)
1057{
1058	struct device *dev = wusbhc->dev;
1059	struct wuie_host_info *hi;
1060	int result;
1061
1062	hi = kzalloc(sizeof(*hi), GFP_KERNEL);
1063	if (hi == NULL)
1064		return -ENOMEM;
1065
1066	hi->hdr.bLength       = sizeof(*hi);
1067	hi->hdr.bIEIdentifier = WUIE_ID_HOST_INFO;
1068	hi->attributes        = cpu_to_le16((wusbhc->rsv->stream << 3) | WUIE_HI_CAP_ALL);
1069	hi->CHID              = wusbhc->chid;
1070	result = wusbhc_mmcie_set(wusbhc, 0, 0, &hi->hdr);
1071	if (result < 0) {
1072		dev_err(dev, "Cannot add Host Info MMCIE: %d\n", result);
1073		goto error_mmcie_set;
1074	}
1075	wusbhc->wuie_host_info = hi;
1076
1077	queue_delayed_work(wusbd, &wusbhc->keep_alive_timer,
1078			   (wusbhc->trust_timeout*CONFIG_HZ)/1000/2);
1079
1080	return 0;
1081
1082error_mmcie_set:
1083	kfree(hi);
1084	return result;
1085}
1086
1087/*
1088 * wusbhc_devconnect_stop - stop managing connected devices
1089 * @wusbhc: the WUSB HC
1090 *
1091 * Disconnects any devices still connected, stops the keep alives and
1092 * removes the Host Info IE.
1093 */
1094void wusbhc_devconnect_stop(struct wusbhc *wusbhc)
1095{
1096	int i;
1097
1098	mutex_lock(&wusbhc->mutex);
1099	for (i = 0; i < wusbhc->ports_max; i++) {
1100		if (wusbhc->port[i].wusb_dev)
1101			__wusbhc_dev_disconnect(wusbhc, &wusbhc->port[i]);
1102	}
1103	mutex_unlock(&wusbhc->mutex);
1104
1105	cancel_delayed_work_sync(&wusbhc->keep_alive_timer);
1106	wusbhc_mmcie_rm(wusbhc, &wusbhc->wuie_host_info->hdr);
1107	kfree(wusbhc->wuie_host_info);
1108	wusbhc->wuie_host_info = NULL;
1109}
1110
1111/*
1112 * wusb_set_dev_addr - set the WUSB device address used by the host
1113 * @wusbhc: the WUSB HC the device is connect to
1114 * @wusb_dev: the WUSB device
1115 * @addr: new device address
1116 */
1117int wusb_set_dev_addr(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev, u8 addr)
1118{
1119	int result;
1120
1121	wusb_dev->addr = addr;
1122	result = wusbhc->dev_info_set(wusbhc, wusb_dev);
1123	if (result < 0)
1124		dev_err(wusbhc->dev, "device %d: failed to set device "
1125			"address\n", wusb_dev->port_idx);
1126	else
1127		dev_info(wusbhc->dev, "device %d: %s addr %u\n",
1128			 wusb_dev->port_idx,
1129			 (addr & WUSB_DEV_ADDR_UNAUTH) ? "unauth" : "auth",
1130			 wusb_dev->addr);
1131
1132	return result;
1133}