← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/usb/wusbcore/devconnect.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
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/slab.h>
 
92
#include <linux/workqueue.h>
 
93
#include <linux/export.h>
 
94
#include "wusbhc.h"
 
95
 
 
96
static void wusbhc_devconnect_acked_work(struct work_struct *work);
 
97
 
 
98
static 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
 
 
107
static 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;
 
138
err:
 
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
 */
 
154
static 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
 */
 
184
static 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
 */
 
243
static 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 */
 
252
static
 
253
void 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
 
 
262
static 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
 */
 
301
static
 
302
void 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
         */
 
361
error_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
 */
 
382
static 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
 */
 
430
static 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
 */
 
476
static 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
 */
 
496
static 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
 */
 
527
static 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
 */
 
547
static 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
 */
 
585
static 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
 */
 
610
void 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
}
 
652
EXPORT_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
 */
 
673
void __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
 */
 
722
static 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;
 
775
error_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
 */
 
793
static 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
 
 
837
error_bad_bos:
 
838
error_get_descriptor:
 
839
        kfree(bos);
 
840
        wusb_dev->wusb_cap_descr = NULL;
 
841
        return result;
 
842
}
 
843
 
 
844
static 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
 
 
850
static 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
 */
 
885
static 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;
 
923
out:
 
924
        wusb_dev_put(wusb_dev);
 
925
        wusbhc_put(wusbhc);
 
926
error_nodev:
 
927
        return;
 
928
 
 
929
        wusb_dev_sysfs_rm(wusb_dev);
 
930
error_add_sysfs:
 
931
        wusb_dev_bos_rm(wusb_dev);
 
932
error_bos_add:
 
933
        wusb_dev_sec_rm(wusb_dev);
 
934
error_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
 */
 
946
static 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
 */
 
970
int 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
 */
 
996
struct 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
}
 
1009
EXPORT_SYMBOL_GPL(__wusb_dev_get_by_usb_dev);
 
1010
 
 
1011
void 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
}
 
1018
EXPORT_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
 */
 
1026
int 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
 */
 
1042
void 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
 */
 
1056
int 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
 
 
1082
error_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
 */
 
1094
void 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
 */
 
1117
int 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
}