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