← Back to branch summary

~ubuntu-branches/ubuntu/saucy/linux-n900/saucy

« back to all changes in this revision

Viewing changes to drivers/usb/wusbcore/wa-hc.h

  • Committer: Bazaar Package Importer
  • Author(s): Mathieu Poirier
  • Date: 2011-02-18 09:43:31 UTC
  • Revision ID: james.westby@ubuntu.com-20110218094331-eyubsja4f9k0yhmq
Tags: 2.6.35-1.1
Initial release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/usb/wusbcore/wa-hc.h
 
1
/*
 
2
 * HWA Host Controller Driver
 
3
 * Wire Adapter Control/Data Streaming Iface (WUSB1.0[8])
 
4
 *
 
5
 * Copyright (C) 2005-2006 Intel Corporation
 
6
 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
 
7
 *
 
8
 * This program is free software; you can redistribute it and/or
 
9
 * modify it under the terms of the GNU General Public License version
 
10
 * 2 as published by the Free Software Foundation.
 
11
 *
 
12
 * This program is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 * GNU General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU General Public License
 
18
 * along with this program; if not, write to the Free Software
 
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 
20
 * 02110-1301, USA.
 
21
 *
 
22
 *
 
23
 * This driver implements a USB Host Controller (struct usb_hcd) for a
 
24
 * Wireless USB Host Controller based on the Wireless USB 1.0
 
25
 * Host-Wire-Adapter specification (in layman terms, a USB-dongle that
 
26
 * implements a Wireless USB host).
 
27
 *
 
28
 * Check out the Design-overview.txt file in the source documentation
 
29
 * for other details on the implementation.
 
30
 *
 
31
 * Main blocks:
 
32
 *
 
33
 *  driver     glue with the driver API, workqueue daemon
 
34
 *
 
35
 *  lc         RC instance life cycle management (create, destroy...)
 
36
 *
 
37
 *  hcd        glue with the USB API Host Controller Interface API.
 
38
 *
 
39
 *  nep        Notification EndPoint managent: collect notifications
 
40
 *             and queue them with the workqueue daemon.
 
41
 *
 
42
 *             Handle notifications as coming from the NEP. Sends them
 
43
 *             off others to their respective modules (eg: connect,
 
44
 *             disconnect and reset go to devconnect).
 
45
 *
 
46
 *  rpipe      Remote Pipe management; rpipe is what we use to write
 
47
 *             to an endpoint on a WUSB device that is connected to a
 
48
 *             HWA RC.
 
49
 *
 
50
 *  xfer       Transfer management -- this is all the code that gets a
 
51
 *             buffer and pushes it to a device (or viceversa). *
 
52
 *
 
53
 * Some day a lot of this code will be shared between this driver and
 
54
 * the drivers for DWA (xfer, rpipe).
 
55
 *
 
56
 * All starts at driver.c:hwahc_probe(), when one of this guys is
 
57
 * connected. hwahc_disconnect() stops it.
 
58
 *
 
59
 * During operation, the main driver is devices connecting or
 
60
 * disconnecting. They cause the HWA RC to send notifications into
 
61
 * nep.c:hwahc_nep_cb() that will dispatch them to
 
62
 * notif.c:wa_notif_dispatch(). From there they will fan to cause
 
63
 * device connects, disconnects, etc.
 
64
 *
 
65
 * Note much of the activity is difficult to follow. For example a
 
66
 * device connect goes to devconnect, which will cause the "fake" root
 
67
 * hub port to show a connect and stop there. Then khubd will notice
 
68
 * and call into the rh.c:hwahc_rc_port_reset() code to authenticate
 
69
 * the device (and this might require user intervention) and enable
 
70
 * the port.
 
71
 *
 
72
 * We also have a timer workqueue going from devconnect.c that
 
73
 * schedules in hwahc_devconnect_create().
 
74
 *
 
75
 * The rest of the traffic is in the usual entry points of a USB HCD,
 
76
 * which are hooked up in driver.c:hwahc_rc_driver, and defined in
 
77
 * hcd.c.
 
78
 */
 
79
 
 
80
#ifndef __HWAHC_INTERNAL_H__
 
81
#define __HWAHC_INTERNAL_H__
 
82
 
 
83
#include <linux/completion.h>
 
84
#include <linux/usb.h>
 
85
#include <linux/mutex.h>
 
86
#include <linux/spinlock.h>
 
87
#include <linux/uwb.h>
 
88
#include <linux/usb/wusb.h>
 
89
#include <linux/usb/wusb-wa.h>
 
90
 
 
91
struct wusbhc;
 
92
struct wahc;
 
93
extern void wa_urb_enqueue_run(struct work_struct *ws);
 
94
 
 
95
/**
 
96
 * RPipe instance
 
97
 *
 
98
 * @descr's fields are kept in LE, as we need to send it back and
 
99
 * forth.
 
100
 *
 
101
 * @wa is referenced when set
 
102
 *
 
103
 * @segs_available is the number of requests segments that still can
 
104
 *                 be submitted to the controller without overloading
 
105
 *                 it. It is initialized to descr->wRequests when
 
106
 *                 aiming.
 
107
 *
 
108
 * A rpipe supports a max of descr->wRequests at the same time; before
 
109
 * submitting seg_lock has to be taken. If segs_avail > 0, then we can
 
110
 * submit; if not, we have to queue them.
 
111
 */
 
112
struct wa_rpipe {
 
113
        struct kref refcnt;
 
114
        struct usb_rpipe_descriptor descr;
 
115
        struct usb_host_endpoint *ep;
 
116
        struct wahc *wa;
 
117
        spinlock_t seg_lock;
 
118
        struct list_head seg_list;
 
119
        atomic_t segs_available;
 
120
        u8 buffer[1];   /* For reads/writes on USB */
 
121
};
 
122
 
 
123
 
 
124
/**
 
125
 * Instance of a HWA Host Controller
 
126
 *
 
127
 * Except where a more specific lock/mutex applies or atomic, all
 
128
 * fields protected by @mutex.
 
129
 *
 
130
 * @wa_descr  Can be accessed without locking because it is in
 
131
 *            the same area where the device descriptors were
 
132
 *            read, so it is guaranteed to exist umodified while
 
133
 *            the device exists.
 
134
 *
 
135
 *            Endianess has been converted to CPU's.
 
136
 *
 
137
 * @nep_* can be accessed without locking as its processing is
 
138
 *        serialized; we submit a NEP URB and it comes to
 
139
 *        hwahc_nep_cb(), which won't issue another URB until it is
 
140
 *        done processing it.
 
141
 *
 
142
 * @xfer_list:
 
143
 *
 
144
 *   List of active transfers to verify existence from a xfer id
 
145
 *   gotten from the xfer result message. Can't use urb->list because
 
146
 *   it goes by endpoint, and we don't know the endpoint at the time
 
147
 *   when we get the xfer result message. We can't really rely on the
 
148
 *   pointer (will have to change for 64 bits) as the xfer id is 32 bits.
 
149
 *
 
150
 * @xfer_delayed_list:   List of transfers that need to be started
 
151
 *                       (with a workqueue, because they were
 
152
 *                       submitted from an atomic context).
 
153
 *
 
154
 * FIXME: this needs to be layered up: a wusbhc layer (for sharing
 
155
 *        comonalities with WHCI), a wa layer (for sharing
 
156
 *        comonalities with DWA-RC).
 
157
 */
 
158
struct wahc {
 
159
        struct usb_device *usb_dev;
 
160
        struct usb_interface *usb_iface;
 
161
 
 
162
        /* HC to deliver notifications */
 
163
        union {
 
164
                struct wusbhc *wusb;
 
165
                struct dwahc *dwa;
 
166
        };
 
167
 
 
168
        const struct usb_endpoint_descriptor *dto_epd, *dti_epd;
 
169
        const struct usb_wa_descriptor *wa_descr;
 
170
 
 
171
        struct urb *nep_urb;            /* Notification EndPoint [lockless] */
 
172
        struct edc nep_edc;
 
173
        void *nep_buffer;
 
174
        size_t nep_buffer_size;
 
175
 
 
176
        atomic_t notifs_queued;
 
177
 
 
178
        u16 rpipes;
 
179
        unsigned long *rpipe_bm;        /* rpipe usage bitmap */
 
180
        spinlock_t rpipe_bm_lock;       /* protect rpipe_bm */
 
181
        struct mutex rpipe_mutex;       /* assigning resources to endpoints */
 
182
 
 
183
        struct urb *dti_urb;            /* URB for reading xfer results */
 
184
        struct urb *buf_in_urb;         /* URB for reading data in */
 
185
        struct edc dti_edc;             /* DTI error density counter */
 
186
        struct wa_xfer_result *xfer_result; /* real size = dti_ep maxpktsize */
 
187
        size_t xfer_result_size;
 
188
 
 
189
        s32 status;                     /* For reading status */
 
190
 
 
191
        struct list_head xfer_list;
 
192
        struct list_head xfer_delayed_list;
 
193
        spinlock_t xfer_list_lock;
 
194
        struct work_struct xfer_work;
 
195
        atomic_t xfer_id_count;
 
196
};
 
197
 
 
198
 
 
199
extern int wa_create(struct wahc *wa, struct usb_interface *iface);
 
200
extern void __wa_destroy(struct wahc *wa);
 
201
void wa_reset_all(struct wahc *wa);
 
202
 
 
203
 
 
204
/* Miscellaneous constants */
 
205
enum {
 
206
        /** Max number of EPROTO errors we tolerate on the NEP in a
 
207
         * period of time */
 
208
        HWAHC_EPROTO_MAX = 16,
 
209
        /** Period of time for EPROTO errors (in jiffies) */
 
210
        HWAHC_EPROTO_PERIOD = 4 * HZ,
 
211
};
 
212
 
 
213
 
 
214
/* Notification endpoint handling */
 
215
extern int wa_nep_create(struct wahc *, struct usb_interface *);
 
216
extern void wa_nep_destroy(struct wahc *);
 
217
 
 
218
static inline int wa_nep_arm(struct wahc *wa, gfp_t gfp_mask)
 
219
{
 
220
        struct urb *urb = wa->nep_urb;
 
221
        urb->transfer_buffer = wa->nep_buffer;
 
222
        urb->transfer_buffer_length = wa->nep_buffer_size;
 
223
        return usb_submit_urb(urb, gfp_mask);
 
224
}
 
225
 
 
226
static inline void wa_nep_disarm(struct wahc *wa)
 
227
{
 
228
        usb_kill_urb(wa->nep_urb);
 
229
}
 
230
 
 
231
 
 
232
/* RPipes */
 
233
static inline void wa_rpipe_init(struct wahc *wa)
 
234
{
 
235
        spin_lock_init(&wa->rpipe_bm_lock);
 
236
        mutex_init(&wa->rpipe_mutex);
 
237
}
 
238
 
 
239
static inline void wa_init(struct wahc *wa)
 
240
{
 
241
        edc_init(&wa->nep_edc);
 
242
        atomic_set(&wa->notifs_queued, 0);
 
243
        wa_rpipe_init(wa);
 
244
        edc_init(&wa->dti_edc);
 
245
        INIT_LIST_HEAD(&wa->xfer_list);
 
246
        INIT_LIST_HEAD(&wa->xfer_delayed_list);
 
247
        spin_lock_init(&wa->xfer_list_lock);
 
248
        INIT_WORK(&wa->xfer_work, wa_urb_enqueue_run);
 
249
        atomic_set(&wa->xfer_id_count, 1);
 
250
}
 
251
 
 
252
/**
 
253
 * Destroy a pipe (when refcount drops to zero)
 
254
 *
 
255
 * Assumes it has been moved to the "QUIESCING" state.
 
256
 */
 
257
struct wa_xfer;
 
258
extern void rpipe_destroy(struct kref *_rpipe);
 
259
static inline
 
260
void __rpipe_get(struct wa_rpipe *rpipe)
 
261
{
 
262
        kref_get(&rpipe->refcnt);
 
263
}
 
264
extern int rpipe_get_by_ep(struct wahc *, struct usb_host_endpoint *,
 
265
                           struct urb *, gfp_t);
 
266
static inline void rpipe_put(struct wa_rpipe *rpipe)
 
267
{
 
268
        kref_put(&rpipe->refcnt, rpipe_destroy);
 
269
 
 
270
}
 
271
extern void rpipe_ep_disable(struct wahc *, struct usb_host_endpoint *);
 
272
extern int wa_rpipes_create(struct wahc *);
 
273
extern void wa_rpipes_destroy(struct wahc *);
 
274
static inline void rpipe_avail_dec(struct wa_rpipe *rpipe)
 
275
{
 
276
        atomic_dec(&rpipe->segs_available);
 
277
}
 
278
 
 
279
/**
 
280
 * Returns true if the rpipe is ready to submit more segments.
 
281
 */
 
282
static inline int rpipe_avail_inc(struct wa_rpipe *rpipe)
 
283
{
 
284
        return atomic_inc_return(&rpipe->segs_available) > 0
 
285
                && !list_empty(&rpipe->seg_list);
 
286
}
 
287
 
 
288
 
 
289
/* Transferring data */
 
290
extern int wa_urb_enqueue(struct wahc *, struct usb_host_endpoint *,
 
291
                          struct urb *, gfp_t);
 
292
extern int wa_urb_dequeue(struct wahc *, struct urb *);
 
293
extern void wa_handle_notif_xfer(struct wahc *, struct wa_notif_hdr *);
 
294
 
 
295
 
 
296
/* Misc
 
297
 *
 
298
 * FIXME: Refcounting for the actual @hwahc object is not correct; I
 
299
 *        mean, this should be refcounting on the HCD underneath, but
 
300
 *        it is not. In any case, the semantics for HCD refcounting
 
301
 *        are *weird*...on refcount reaching zero it just frees
 
302
 *        it...no RC specific function is called...unless I miss
 
303
 *        something.
 
304
 *
 
305
 * FIXME: has to go away in favour of an 'struct' hcd based sollution
 
306
 */
 
307
static inline struct wahc *wa_get(struct wahc *wa)
 
308
{
 
309
        usb_get_intf(wa->usb_iface);
 
310
        return wa;
 
311
}
 
312
 
 
313
static inline void wa_put(struct wahc *wa)
 
314
{
 
315
        usb_put_intf(wa->usb_iface);
 
316
}
 
317
 
 
318
 
 
319
static inline int __wa_feature(struct wahc *wa, unsigned op, u16 feature)
 
320
{
 
321
        return usb_control_msg(wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
 
322
                        op ? USB_REQ_SET_FEATURE : USB_REQ_CLEAR_FEATURE,
 
323
                        USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 
324
                        feature,
 
325
                        wa->usb_iface->cur_altsetting->desc.bInterfaceNumber,
 
326
                        NULL, 0, 1000 /* FIXME: arbitrary */);
 
327
}
 
328
 
 
329
 
 
330
static inline int __wa_set_feature(struct wahc *wa, u16 feature)
 
331
{
 
332
        return  __wa_feature(wa, 1, feature);
 
333
}
 
334
 
 
335
 
 
336
static inline int __wa_clear_feature(struct wahc *wa, u16 feature)
 
337
{
 
338
        return __wa_feature(wa, 0, feature);
 
339
}
 
340
 
 
341
 
 
342
/**
 
343
 * Return the status of a Wire Adapter
 
344
 *
 
345
 * @wa:         Wire Adapter instance
 
346
 * @returns     < 0 errno code on error, or status bitmap as described
 
347
 *              in WUSB1.0[8.3.1.6].
 
348
 *
 
349
 * NOTE: need malloc, some arches don't take USB from the stack
 
350
 */
 
351
static inline
 
352
s32 __wa_get_status(struct wahc *wa)
 
353
{
 
354
        s32 result;
 
355
        result = usb_control_msg(
 
356
                wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
 
357
                USB_REQ_GET_STATUS,
 
358
                USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 
359
                0, wa->usb_iface->cur_altsetting->desc.bInterfaceNumber,
 
360
                &wa->status, sizeof(wa->status),
 
361
                1000 /* FIXME: arbitrary */);
 
362
        if (result >= 0)
 
363
                result = wa->status;
 
364
        return result;
 
365
}
 
366
 
 
367
 
 
368
/**
 
369
 * Waits until the Wire Adapter's status matches @mask/@value
 
370
 *
 
371
 * @wa:         Wire Adapter instance.
 
372
 * @returns     < 0 errno code on error, otherwise status.
 
373
 *
 
374
 * Loop until the WAs status matches the mask and value (status & mask
 
375
 * == value). Timeout if it doesn't happen.
 
376
 *
 
377
 * FIXME: is there an official specification on how long status
 
378
 *        changes can take?
 
379
 */
 
380
static inline s32 __wa_wait_status(struct wahc *wa, u32 mask, u32 value)
 
381
{
 
382
        s32 result;
 
383
        unsigned loops = 10;
 
384
        do {
 
385
                msleep(50);
 
386
                result = __wa_get_status(wa);
 
387
                if ((result & mask) == value)
 
388
                        break;
 
389
                if (loops-- == 0) {
 
390
                        result = -ETIMEDOUT;
 
391
                        break;
 
392
                }
 
393
        } while (result >= 0);
 
394
        return result;
 
395
}
 
396
 
 
397
 
 
398
/** Command @hwahc to stop, @returns 0 if ok, < 0 errno code on error */
 
399
static inline int __wa_stop(struct wahc *wa)
 
400
{
 
401
        int result;
 
402
        struct device *dev = &wa->usb_iface->dev;
 
403
 
 
404
        result = __wa_clear_feature(wa, WA_ENABLE);
 
405
        if (result < 0 && result != -ENODEV) {
 
406
                dev_err(dev, "error commanding HC to stop: %d\n", result);
 
407
                goto out;
 
408
        }
 
409
        result = __wa_wait_status(wa, WA_ENABLE, 0);
 
410
        if (result < 0 && result != -ENODEV)
 
411
                dev_err(dev, "error waiting for HC to stop: %d\n", result);
 
412
out:
 
413
        return 0;
 
414
}
 
415
 
 
416
 
 
417
#endif /* #ifndef __HWAHC_INTERNAL_H__ */