← Back to branch summary

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

« back to all changes in this revision

Viewing changes to drivers/net/usb/rndis_host.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/net/usb/rndis_host.c
 
1
/*
 
2
 * Host Side support for RNDIS Networking Links
 
3
 * Copyright (C) 2005 by David Brownell
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or modify
 
6
 * it under the terms of the GNU General Public License as published by
 
7
 * the Free Software Foundation; either version 2 of the License, or
 
8
 * (at your option) any later version.
 
9
 *
 
10
 * This program is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 * GNU General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU General Public License
 
16
 * along with this program; if not, write to the Free Software
 
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
18
 */
 
19
#include <linux/module.h>
 
20
#include <linux/init.h>
 
21
#include <linux/netdevice.h>
 
22
#include <linux/etherdevice.h>
 
23
#include <linux/ethtool.h>
 
24
#include <linux/workqueue.h>
 
25
#include <linux/slab.h>
 
26
#include <linux/mii.h>
 
27
#include <linux/usb.h>
 
28
#include <linux/usb/cdc.h>
 
29
#include <linux/usb/usbnet.h>
 
30
#include <linux/usb/rndis_host.h>
 
31
 
 
32
 
 
33
/*
 
34
 * RNDIS is NDIS remoted over USB.  It's a MSFT variant of CDC ACM ... of
 
35
 * course ACM was intended for modems, not Ethernet links!  USB's standard
 
36
 * for Ethernet links is "CDC Ethernet", which is significantly simpler.
 
37
 *
 
38
 * NOTE that Microsoft's "RNDIS 1.0" specification is incomplete.  Issues
 
39
 * include:
 
40
 *    - Power management in particular relies on information that's scattered
 
41
 *      through other documentation, and which is incomplete or incorrect even
 
42
 *      there.
 
43
 *    - There are various undocumented protocol requirements, such as the
 
44
 *      need to send unused garbage in control-OUT messages.
 
45
 *    - In some cases, MS-Windows will emit undocumented requests; this
 
46
 *      matters more to peripheral implementations than host ones.
 
47
 *
 
48
 * Moreover there's a no-open-specs variant of RNDIS called "ActiveSync".
 
49
 *
 
50
 * For these reasons and others, ** USE OF RNDIS IS STRONGLY DISCOURAGED ** in
 
51
 * favor of such non-proprietary alternatives as CDC Ethernet or the newer (and
 
52
 * currently rare) "Ethernet Emulation Model" (EEM).
 
53
 */
 
54
 
 
55
/*
 
56
 * RNDIS notifications from device: command completion; "reverse"
 
57
 * keepalives; etc
 
58
 */
 
59
void rndis_status(struct usbnet *dev, struct urb *urb)
 
60
{
 
61
        netdev_dbg(dev->net, "rndis status urb, len %d stat %d\n",
 
62
                   urb->actual_length, urb->status);
 
63
        // FIXME for keepalives, respond immediately (asynchronously)
 
64
        // if not an RNDIS status, do like cdc_status(dev,urb) does
 
65
}
 
66
EXPORT_SYMBOL_GPL(rndis_status);
 
67
 
 
68
/*
 
69
 * RNDIS indicate messages.
 
70
 */
 
71
static void rndis_msg_indicate(struct usbnet *dev, struct rndis_indicate *msg,
 
72
                                int buflen)
 
73
{
 
74
        struct cdc_state *info = (void *)&dev->data;
 
75
        struct device *udev = &info->control->dev;
 
76
 
 
77
        if (dev->driver_info->indication) {
 
78
                dev->driver_info->indication(dev, msg, buflen);
 
79
        } else {
 
80
                switch (msg->status) {
 
81
                case RNDIS_STATUS_MEDIA_CONNECT:
 
82
                        dev_info(udev, "rndis media connect\n");
 
83
                        break;
 
84
                case RNDIS_STATUS_MEDIA_DISCONNECT:
 
85
                        dev_info(udev, "rndis media disconnect\n");
 
86
                        break;
 
87
                default:
 
88
                        dev_info(udev, "rndis indication: 0x%08x\n",
 
89
                                        le32_to_cpu(msg->status));
 
90
                }
 
91
        }
 
92
}
 
93
 
 
94
/*
 
95
 * RPC done RNDIS-style.  Caller guarantees:
 
96
 * - message is properly byteswapped
 
97
 * - there's no other request pending
 
98
 * - buf can hold up to 1KB response (required by RNDIS spec)
 
99
 * On return, the first few entries are already byteswapped.
 
100
 *
 
101
 * Call context is likely probe(), before interface name is known,
 
102
 * which is why we won't try to use it in the diagnostics.
 
103
 */
 
104
int rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf, int buflen)
 
105
{
 
106
        struct cdc_state        *info = (void *) &dev->data;
 
107
        struct usb_cdc_notification notification;
 
108
        int                     master_ifnum;
 
109
        int                     retval;
 
110
        int                     partial;
 
111
        unsigned                count;
 
112
        __le32                  rsp;
 
113
        u32                     xid = 0, msg_len, request_id;
 
114
 
 
115
        /* REVISIT when this gets called from contexts other than probe() or
 
116
         * disconnect(): either serialize, or dispatch responses on xid
 
117
         */
 
118
 
 
119
        /* Issue the request; xid is unique, don't bother byteswapping it */
 
120
        if (likely(buf->msg_type != RNDIS_MSG_HALT &&
 
121
                   buf->msg_type != RNDIS_MSG_RESET)) {
 
122
                xid = dev->xid++;
 
123
                if (!xid)
 
124
                        xid = dev->xid++;
 
125
                buf->request_id = (__force __le32) xid;
 
126
        }
 
127
        master_ifnum = info->control->cur_altsetting->desc.bInterfaceNumber;
 
128
        retval = usb_control_msg(dev->udev,
 
129
                usb_sndctrlpipe(dev->udev, 0),
 
130
                USB_CDC_SEND_ENCAPSULATED_COMMAND,
 
131
                USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 
132
                0, master_ifnum,
 
133
                buf, le32_to_cpu(buf->msg_len),
 
134
                RNDIS_CONTROL_TIMEOUT_MS);
 
135
        if (unlikely(retval < 0 || xid == 0))
 
136
                return retval;
 
137
 
 
138
        /* Some devices don't respond on the control channel until
 
139
         * polled on the status channel, so do that first. */
 
140
        if (dev->driver_info->data & RNDIS_DRIVER_DATA_POLL_STATUS) {
 
141
                retval = usb_interrupt_msg(
 
142
                        dev->udev,
 
143
                        usb_rcvintpipe(dev->udev,
 
144
                                       dev->status->desc.bEndpointAddress),
 
145
                        &notification, sizeof(notification), &partial,
 
146
                        RNDIS_CONTROL_TIMEOUT_MS);
 
147
                if (unlikely(retval < 0))
 
148
                        return retval;
 
149
        }
 
150
 
 
151
        /* Poll the control channel; the request probably completed immediately */
 
152
        rsp = buf->msg_type | RNDIS_MSG_COMPLETION;
 
153
        for (count = 0; count < 10; count++) {
 
154
                memset(buf, 0, CONTROL_BUFFER_SIZE);
 
155
                retval = usb_control_msg(dev->udev,
 
156
                        usb_rcvctrlpipe(dev->udev, 0),
 
157
                        USB_CDC_GET_ENCAPSULATED_RESPONSE,
 
158
                        USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 
159
                        0, master_ifnum,
 
160
                        buf, buflen,
 
161
                        RNDIS_CONTROL_TIMEOUT_MS);
 
162
                if (likely(retval >= 8)) {
 
163
                        msg_len = le32_to_cpu(buf->msg_len);
 
164
                        request_id = (__force u32) buf->request_id;
 
165
                        if (likely(buf->msg_type == rsp)) {
 
166
                                if (likely(request_id == xid)) {
 
167
                                        if (unlikely(rsp == RNDIS_MSG_RESET_C))
 
168
                                                return 0;
 
169
                                        if (likely(RNDIS_STATUS_SUCCESS
 
170
                                                        == buf->status))
 
171
                                                return 0;
 
172
                                        dev_dbg(&info->control->dev,
 
173
                                                "rndis reply status %08x\n",
 
174
                                                le32_to_cpu(buf->status));
 
175
                                        return -EL3RST;
 
176
                                }
 
177
                                dev_dbg(&info->control->dev,
 
178
                                        "rndis reply id %d expected %d\n",
 
179
                                        request_id, xid);
 
180
                                /* then likely retry */
 
181
                        } else switch (buf->msg_type) {
 
182
                        case RNDIS_MSG_INDICATE:        /* fault/event */
 
183
                                rndis_msg_indicate(dev, (void *)buf, buflen);
 
184
 
 
185
                                break;
 
186
                        case RNDIS_MSG_KEEPALIVE: {     /* ping */
 
187
                                struct rndis_keepalive_c *msg = (void *)buf;
 
188
 
 
189
                                msg->msg_type = RNDIS_MSG_KEEPALIVE_C;
 
190
                                msg->msg_len = cpu_to_le32(sizeof *msg);
 
191
                                msg->status = RNDIS_STATUS_SUCCESS;
 
192
                                retval = usb_control_msg(dev->udev,
 
193
                                        usb_sndctrlpipe(dev->udev, 0),
 
194
                                        USB_CDC_SEND_ENCAPSULATED_COMMAND,
 
195
                                        USB_TYPE_CLASS | USB_RECIP_INTERFACE,
 
196
                                        0, master_ifnum,
 
197
                                        msg, sizeof *msg,
 
198
                                        RNDIS_CONTROL_TIMEOUT_MS);
 
199
                                if (unlikely(retval < 0))
 
200
                                        dev_dbg(&info->control->dev,
 
201
                                                "rndis keepalive err %d\n",
 
202
                                                retval);
 
203
                                }
 
204
                                break;
 
205
                        default:
 
206
                                dev_dbg(&info->control->dev,
 
207
                                        "unexpected rndis msg %08x len %d\n",
 
208
                                        le32_to_cpu(buf->msg_type), msg_len);
 
209
                        }
 
210
                } else {
 
211
                        /* device probably issued a protocol stall; ignore */
 
212
                        dev_dbg(&info->control->dev,
 
213
                                "rndis response error, code %d\n", retval);
 
214
                }
 
215
                msleep(20);
 
216
        }
 
217
        dev_dbg(&info->control->dev, "rndis response timeout\n");
 
218
        return -ETIMEDOUT;
 
219
}
 
220
EXPORT_SYMBOL_GPL(rndis_command);
 
221
 
 
222
/*
 
223
 * rndis_query:
 
224
 *
 
225
 * Performs a query for @oid along with 0 or more bytes of payload as
 
226
 * specified by @in_len. If @reply_len is not set to -1 then the reply
 
227
 * length is checked against this value, resulting in an error if it
 
228
 * doesn't match.
 
229
 *
 
230
 * NOTE: Adding a payload exactly or greater than the size of the expected
 
231
 * response payload is an evident requirement MSFT added for ActiveSync.
 
232
 *
 
233
 * The only exception is for OIDs that return a variably sized response,
 
234
 * in which case no payload should be added.  This undocumented (and
 
235
 * nonsensical!) issue was found by sniffing protocol requests from the
 
236
 * ActiveSync 4.1 Windows driver.
 
237
 */
 
238
static int rndis_query(struct usbnet *dev, struct usb_interface *intf,
 
239
                void *buf, __le32 oid, u32 in_len,
 
240
                void **reply, int *reply_len)
 
241
{
 
242
        int retval;
 
243
        union {
 
244
                void                    *buf;
 
245
                struct rndis_msg_hdr    *header;
 
246
                struct rndis_query      *get;
 
247
                struct rndis_query_c    *get_c;
 
248
        } u;
 
249
        u32 off, len;
 
250
 
 
251
        u.buf = buf;
 
252
 
 
253
        memset(u.get, 0, sizeof *u.get + in_len);
 
254
        u.get->msg_type = RNDIS_MSG_QUERY;
 
255
        u.get->msg_len = cpu_to_le32(sizeof *u.get + in_len);
 
256
        u.get->oid = oid;
 
257
        u.get->len = cpu_to_le32(in_len);
 
258
        u.get->offset = cpu_to_le32(20);
 
259
 
 
260
        retval = rndis_command(dev, u.header, CONTROL_BUFFER_SIZE);
 
261
        if (unlikely(retval < 0)) {
 
262
                dev_err(&intf->dev, "RNDIS_MSG_QUERY(0x%08x) failed, %d\n",
 
263
                                oid, retval);
 
264
                return retval;
 
265
        }
 
266
 
 
267
        off = le32_to_cpu(u.get_c->offset);
 
268
        len = le32_to_cpu(u.get_c->len);
 
269
        if (unlikely((8 + off + len) > CONTROL_BUFFER_SIZE))
 
270
                goto response_error;
 
271
 
 
272
        if (*reply_len != -1 && len != *reply_len)
 
273
                goto response_error;
 
274
 
 
275
        *reply = (unsigned char *) &u.get_c->request_id + off;
 
276
        *reply_len = len;
 
277
 
 
278
        return retval;
 
279
 
 
280
response_error:
 
281
        dev_err(&intf->dev, "RNDIS_MSG_QUERY(0x%08x) "
 
282
                        "invalid response - off %d len %d\n",
 
283
                oid, off, len);
 
284
        return -EDOM;
 
285
}
 
286
 
 
287
/* same as usbnet_netdev_ops but MTU change not allowed */
 
288
static const struct net_device_ops rndis_netdev_ops = {
 
289
        .ndo_open               = usbnet_open,
 
290
        .ndo_stop               = usbnet_stop,
 
291
        .ndo_start_xmit         = usbnet_start_xmit,
 
292
        .ndo_tx_timeout         = usbnet_tx_timeout,
 
293
        .ndo_set_mac_address    = eth_mac_addr,
 
294
        .ndo_validate_addr      = eth_validate_addr,
 
295
};
 
296
 
 
297
int
 
298
generic_rndis_bind(struct usbnet *dev, struct usb_interface *intf, int flags)
 
299
{
 
300
        int                     retval;
 
301
        struct net_device       *net = dev->net;
 
302
        struct cdc_state        *info = (void *) &dev->data;
 
303
        union {
 
304
                void                    *buf;
 
305
                struct rndis_msg_hdr    *header;
 
306
                struct rndis_init       *init;
 
307
                struct rndis_init_c     *init_c;
 
308
                struct rndis_query      *get;
 
309
                struct rndis_query_c    *get_c;
 
310
                struct rndis_set        *set;
 
311
                struct rndis_set_c      *set_c;
 
312
                struct rndis_halt       *halt;
 
313
        } u;
 
314
        u32                     tmp;
 
315
        __le32                  phym_unspec, *phym;
 
316
        int                     reply_len;
 
317
        unsigned char           *bp;
 
318
 
 
319
        /* we can't rely on i/o from stack working, or stack allocation */
 
320
        u.buf = kmalloc(CONTROL_BUFFER_SIZE, GFP_KERNEL);
 
321
        if (!u.buf)
 
322
                return -ENOMEM;
 
323
        retval = usbnet_generic_cdc_bind(dev, intf);
 
324
        if (retval < 0)
 
325
                goto fail;
 
326
 
 
327
        u.init->msg_type = RNDIS_MSG_INIT;
 
328
        u.init->msg_len = cpu_to_le32(sizeof *u.init);
 
329
        u.init->major_version = cpu_to_le32(1);
 
330
        u.init->minor_version = cpu_to_le32(0);
 
331
 
 
332
        /* max transfer (in spec) is 0x4000 at full speed, but for
 
333
         * TX we'll stick to one Ethernet packet plus RNDIS framing.
 
334
         * For RX we handle drivers that zero-pad to end-of-packet.
 
335
         * Don't let userspace change these settings.
 
336
         *
 
337
         * NOTE: there still seems to be wierdness here, as if we need
 
338
         * to do some more things to make sure WinCE targets accept this.
 
339
         * They default to jumbograms of 8KB or 16KB, which is absurd
 
340
         * for such low data rates and which is also more than Linux
 
341
         * can usually expect to allocate for SKB data...
 
342
         */
 
343
        net->hard_header_len += sizeof (struct rndis_data_hdr);
 
344
        dev->hard_mtu = net->mtu + net->hard_header_len;
 
345
 
 
346
        dev->maxpacket = usb_maxpacket(dev->udev, dev->out, 1);
 
347
        if (dev->maxpacket == 0) {
 
348
                netif_dbg(dev, probe, dev->net,
 
349
                          "dev->maxpacket can't be 0\n");
 
350
                retval = -EINVAL;
 
351
                goto fail_and_release;
 
352
        }
 
353
 
 
354
        dev->rx_urb_size = dev->hard_mtu + (dev->maxpacket + 1);
 
355
        dev->rx_urb_size &= ~(dev->maxpacket - 1);
 
356
        u.init->max_transfer_size = cpu_to_le32(dev->rx_urb_size);
 
357
 
 
358
        net->netdev_ops = &rndis_netdev_ops;
 
359
 
 
360
        retval = rndis_command(dev, u.header, CONTROL_BUFFER_SIZE);
 
361
        if (unlikely(retval < 0)) {
 
362
                /* it might not even be an RNDIS device!! */
 
363
                dev_err(&intf->dev, "RNDIS init failed, %d\n", retval);
 
364
                goto fail_and_release;
 
365
        }
 
366
        tmp = le32_to_cpu(u.init_c->max_transfer_size);
 
367
        if (tmp < dev->hard_mtu) {
 
368
                if (tmp <= net->hard_header_len) {
 
369
                        dev_err(&intf->dev,
 
370
                                "dev can't take %u byte packets (max %u)\n",
 
371
                                dev->hard_mtu, tmp);
 
372
                        retval = -EINVAL;
 
373
                        goto halt_fail_and_release;
 
374
                }
 
375
                dev_warn(&intf->dev,
 
376
                         "dev can't take %u byte packets (max %u), "
 
377
                         "adjusting MTU to %u\n",
 
378
                         dev->hard_mtu, tmp, tmp - net->hard_header_len);
 
379
                dev->hard_mtu = tmp;
 
380
                net->mtu = dev->hard_mtu - net->hard_header_len;
 
381
        }
 
382
 
 
383
        /* REVISIT:  peripheral "alignment" request is ignored ... */
 
384
        dev_dbg(&intf->dev,
 
385
                "hard mtu %u (%u from dev), rx buflen %Zu, align %d\n",
 
386
                dev->hard_mtu, tmp, dev->rx_urb_size,
 
387
                1 << le32_to_cpu(u.init_c->packet_alignment));
 
388
 
 
389
        /* module has some device initialization code needs to be done right
 
390
         * after RNDIS_INIT */
 
391
        if (dev->driver_info->early_init &&
 
392
                        dev->driver_info->early_init(dev) != 0)
 
393
                goto halt_fail_and_release;
 
394
 
 
395
        /* Check physical medium */
 
396
        phym = NULL;
 
397
        reply_len = sizeof *phym;
 
398
        retval = rndis_query(dev, intf, u.buf, OID_GEN_PHYSICAL_MEDIUM,
 
399
                        0, (void **) &phym, &reply_len);
 
400
        if (retval != 0 || !phym) {
 
401
                /* OID is optional so don't fail here. */
 
402
                phym_unspec = RNDIS_PHYSICAL_MEDIUM_UNSPECIFIED;
 
403
                phym = &phym_unspec;
 
404
        }
 
405
        if ((flags & FLAG_RNDIS_PHYM_WIRELESS) &&
 
406
                        *phym != RNDIS_PHYSICAL_MEDIUM_WIRELESS_LAN) {
 
407
                netif_dbg(dev, probe, dev->net,
 
408
                          "driver requires wireless physical medium, but device is not\n");
 
409
                retval = -ENODEV;
 
410
                goto halt_fail_and_release;
 
411
        }
 
412
        if ((flags & FLAG_RNDIS_PHYM_NOT_WIRELESS) &&
 
413
                        *phym == RNDIS_PHYSICAL_MEDIUM_WIRELESS_LAN) {
 
414
                netif_dbg(dev, probe, dev->net,
 
415
                          "driver requires non-wireless physical medium, but device is wireless.\n");
 
416
                retval = -ENODEV;
 
417
                goto halt_fail_and_release;
 
418
        }
 
419
 
 
420
        /* Get designated host ethernet address */
 
421
        reply_len = ETH_ALEN;
 
422
        retval = rndis_query(dev, intf, u.buf, OID_802_3_PERMANENT_ADDRESS,
 
423
                        48, (void **) &bp, &reply_len);
 
424
        if (unlikely(retval< 0)) {
 
425
                dev_err(&intf->dev, "rndis get ethaddr, %d\n", retval);
 
426
                goto halt_fail_and_release;
 
427
        }
 
428
        memcpy(net->dev_addr, bp, ETH_ALEN);
 
429
        memcpy(net->perm_addr, bp, ETH_ALEN);
 
430
 
 
431
        /* set a nonzero filter to enable data transfers */
 
432
        memset(u.set, 0, sizeof *u.set);
 
433
        u.set->msg_type = RNDIS_MSG_SET;
 
434
        u.set->msg_len = cpu_to_le32(4 + sizeof *u.set);
 
435
        u.set->oid = OID_GEN_CURRENT_PACKET_FILTER;
 
436
        u.set->len = cpu_to_le32(4);
 
437
        u.set->offset = cpu_to_le32((sizeof *u.set) - 8);
 
438
        *(__le32 *)(u.buf + sizeof *u.set) = RNDIS_DEFAULT_FILTER;
 
439
 
 
440
        retval = rndis_command(dev, u.header, CONTROL_BUFFER_SIZE);
 
441
        if (unlikely(retval < 0)) {
 
442
                dev_err(&intf->dev, "rndis set packet filter, %d\n", retval);
 
443
                goto halt_fail_and_release;
 
444
        }
 
445
 
 
446
        retval = 0;
 
447
 
 
448
        kfree(u.buf);
 
449
        return retval;
 
450
 
 
451
halt_fail_and_release:
 
452
        memset(u.halt, 0, sizeof *u.halt);
 
453
        u.halt->msg_type = RNDIS_MSG_HALT;
 
454
        u.halt->msg_len = cpu_to_le32(sizeof *u.halt);
 
455
        (void) rndis_command(dev, (void *)u.halt, CONTROL_BUFFER_SIZE);
 
456
fail_and_release:
 
457
        usb_set_intfdata(info->data, NULL);
 
458
        usb_driver_release_interface(driver_of(intf), info->data);
 
459
        info->data = NULL;
 
460
fail:
 
461
        kfree(u.buf);
 
462
        return retval;
 
463
}
 
464
EXPORT_SYMBOL_GPL(generic_rndis_bind);
 
465
 
 
466
static int rndis_bind(struct usbnet *dev, struct usb_interface *intf)
 
467
{
 
468
        return generic_rndis_bind(dev, intf, FLAG_RNDIS_PHYM_NOT_WIRELESS);
 
469
}
 
470
 
 
471
void rndis_unbind(struct usbnet *dev, struct usb_interface *intf)
 
472
{
 
473
        struct rndis_halt       *halt;
 
474
 
 
475
        /* try to clear any rndis state/activity (no i/o from stack!) */
 
476
        halt = kzalloc(CONTROL_BUFFER_SIZE, GFP_KERNEL);
 
477
        if (halt) {
 
478
                halt->msg_type = RNDIS_MSG_HALT;
 
479
                halt->msg_len = cpu_to_le32(sizeof *halt);
 
480
                (void) rndis_command(dev, (void *)halt, CONTROL_BUFFER_SIZE);
 
481
                kfree(halt);
 
482
        }
 
483
 
 
484
        usbnet_cdc_unbind(dev, intf);
 
485
}
 
486
EXPORT_SYMBOL_GPL(rndis_unbind);
 
487
 
 
488
/*
 
489
 * DATA -- host must not write zlps
 
490
 */
 
491
int rndis_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
 
492
{
 
493
        /* peripheral may have batched packets to us... */
 
494
        while (likely(skb->len)) {
 
495
                struct rndis_data_hdr   *hdr = (void *)skb->data;
 
496
                struct sk_buff          *skb2;
 
497
                u32                     msg_len, data_offset, data_len;
 
498
 
 
499
                msg_len = le32_to_cpu(hdr->msg_len);
 
500
                data_offset = le32_to_cpu(hdr->data_offset);
 
501
                data_len = le32_to_cpu(hdr->data_len);
 
502
 
 
503
                /* don't choke if we see oob, per-packet data, etc */
 
504
                if (unlikely(hdr->msg_type != RNDIS_MSG_PACKET ||
 
505
                             skb->len < msg_len ||
 
506
                             (data_offset + data_len + 8) > msg_len)) {
 
507
                        dev->net->stats.rx_frame_errors++;
 
508
                        netdev_dbg(dev->net, "bad rndis message %d/%d/%d/%d, len %d\n",
 
509
                                   le32_to_cpu(hdr->msg_type),
 
510
                                   msg_len, data_offset, data_len, skb->len);
 
511
                        return 0;
 
512
                }
 
513
                skb_pull(skb, 8 + data_offset);
 
514
 
 
515
                /* at most one packet left? */
 
516
                if (likely((data_len - skb->len) <= sizeof *hdr)) {
 
517
                        skb_trim(skb, data_len);
 
518
                        break;
 
519
                }
 
520
 
 
521
                /* try to return all the packets in the batch */
 
522
                skb2 = skb_clone(skb, GFP_ATOMIC);
 
523
                if (unlikely(!skb2))
 
524
                        break;
 
525
                skb_pull(skb, msg_len - sizeof *hdr);
 
526
                skb_trim(skb2, data_len);
 
527
                usbnet_skb_return(dev, skb2);
 
528
        }
 
529
 
 
530
        /* caller will usbnet_skb_return the remaining packet */
 
531
        return 1;
 
532
}
 
533
EXPORT_SYMBOL_GPL(rndis_rx_fixup);
 
534
 
 
535
struct sk_buff *
 
536
rndis_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags)
 
537
{
 
538
        struct rndis_data_hdr   *hdr;
 
539
        struct sk_buff          *skb2;
 
540
        unsigned                len = skb->len;
 
541
 
 
542
        if (likely(!skb_cloned(skb))) {
 
543
                int     room = skb_headroom(skb);
 
544
 
 
545
                /* enough head room as-is? */
 
546
                if (unlikely((sizeof *hdr) <= room))
 
547
                        goto fill;
 
548
 
 
549
                /* enough room, but needs to be readjusted? */
 
550
                room += skb_tailroom(skb);
 
551
                if (likely((sizeof *hdr) <= room)) {
 
552
                        skb->data = memmove(skb->head + sizeof *hdr,
 
553
                                            skb->data, len);
 
554
                        skb_set_tail_pointer(skb, len);
 
555
                        goto fill;
 
556
                }
 
557
        }
 
558
 
 
559
        /* create a new skb, with the correct size (and tailpad) */
 
560
        skb2 = skb_copy_expand(skb, sizeof *hdr, 1, flags);
 
561
        dev_kfree_skb_any(skb);
 
562
        if (unlikely(!skb2))
 
563
                return skb2;
 
564
        skb = skb2;
 
565
 
 
566
        /* fill out the RNDIS header.  we won't bother trying to batch
 
567
         * packets; Linux minimizes wasted bandwidth through tx queues.
 
568
         */
 
569
fill:
 
570
        hdr = (void *) __skb_push(skb, sizeof *hdr);
 
571
        memset(hdr, 0, sizeof *hdr);
 
572
        hdr->msg_type = RNDIS_MSG_PACKET;
 
573
        hdr->msg_len = cpu_to_le32(skb->len);
 
574
        hdr->data_offset = cpu_to_le32(sizeof(*hdr) - 8);
 
575
        hdr->data_len = cpu_to_le32(len);
 
576
 
 
577
        /* FIXME make the last packet always be short ... */
 
578
        return skb;
 
579
}
 
580
EXPORT_SYMBOL_GPL(rndis_tx_fixup);
 
581
 
 
582
 
 
583
static const struct driver_info rndis_info = {
 
584
        .description =  "RNDIS device",
 
585
        .flags =        FLAG_ETHER | FLAG_POINTTOPOINT | FLAG_FRAMING_RN | FLAG_NO_SETINT,
 
586
        .bind =         rndis_bind,
 
587
        .unbind =       rndis_unbind,
 
588
        .status =       rndis_status,
 
589
        .rx_fixup =     rndis_rx_fixup,
 
590
        .tx_fixup =     rndis_tx_fixup,
 
591
};
 
592
 
 
593
static const struct driver_info rndis_poll_status_info = {
 
594
        .description =  "RNDIS device (poll status before control)",
 
595
        .flags =        FLAG_ETHER | FLAG_POINTTOPOINT | FLAG_FRAMING_RN | FLAG_NO_SETINT,
 
596
        .data =         RNDIS_DRIVER_DATA_POLL_STATUS,
 
597
        .bind =         rndis_bind,
 
598
        .unbind =       rndis_unbind,
 
599
        .status =       rndis_status,
 
600
        .rx_fixup =     rndis_rx_fixup,
 
601
        .tx_fixup =     rndis_tx_fixup,
 
602
};
 
603
 
 
604
/*-------------------------------------------------------------------------*/
 
605
 
 
606
static const struct usb_device_id       products [] = {
 
607
{
 
608
        /* 2Wire HomePortal 1000SW */
 
609
        USB_DEVICE_AND_INTERFACE_INFO(0x1630, 0x0042,
 
610
                                      USB_CLASS_COMM, 2 /* ACM */, 0x0ff),
 
611
        .driver_info = (unsigned long) &rndis_poll_status_info,
 
612
}, {
 
613
        /* RNDIS is MSFT's un-official variant of CDC ACM */
 
614
        USB_INTERFACE_INFO(USB_CLASS_COMM, 2 /* ACM */, 0x0ff),
 
615
        .driver_info = (unsigned long) &rndis_info,
 
616
}, {
 
617
        /* "ActiveSync" is an undocumented variant of RNDIS, used in WM5 */
 
618
        USB_INTERFACE_INFO(USB_CLASS_MISC, 1, 1),
 
619
        .driver_info = (unsigned long) &rndis_poll_status_info,
 
620
}, {
 
621
        /* RNDIS for tethering */
 
622
        USB_INTERFACE_INFO(USB_CLASS_WIRELESS_CONTROLLER, 1, 3),
 
623
        .driver_info = (unsigned long) &rndis_info,
 
624
},
 
625
        { },            // END
 
626
};
 
627
MODULE_DEVICE_TABLE(usb, products);
 
628
 
 
629
static struct usb_driver rndis_driver = {
 
630
        .name =         "rndis_host",
 
631
        .id_table =     products,
 
632
        .probe =        usbnet_probe,
 
633
        .disconnect =   usbnet_disconnect,
 
634
        .suspend =      usbnet_suspend,
 
635
        .resume =       usbnet_resume,
 
636
};
 
637
 
 
638
static int __init rndis_init(void)
 
639
{
 
640
        return usb_register(&rndis_driver);
 
641
}
 
642
module_init(rndis_init);
 
643
 
 
644
static void __exit rndis_exit(void)
 
645
{
 
646
        usb_deregister(&rndis_driver);
 
647
}
 
648
module_exit(rndis_exit);
 
649
 
 
650
MODULE_AUTHOR("David Brownell");
 
651
MODULE_DESCRIPTION("USB Host side RNDIS driver");
 
652
MODULE_LICENSE("GPL");