blob: f56dec6119c3fcadb97740dd1d2d0cad33fef487 [file] [log] [blame]
David Brownell64e04912005-08-31 09:54:36 -07001/*
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 */
David Brownell64e04912005-08-31 09:54:36 -070019#include <linux/module.h>
David Brownell64e04912005-08-31 09:54:36 -070020#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/mii.h>
26#include <linux/usb.h>
David Brownella8c28f22006-06-13 09:57:47 -070027#include <linux/usb/cdc.h>
Jussi Kivilinna3692e942008-01-26 00:51:45 +020028#include <linux/usb/usbnet.h>
29#include <linux/usb/rndis_host.h>
David Brownell64e04912005-08-31 09:54:36 -070030
31
32/*
33 * RNDIS is NDIS remoted over USB. It's a MSFT variant of CDC ACM ... of
34 * course ACM was intended for modems, not Ethernet links! USB's standard
35 * for Ethernet links is "CDC Ethernet", which is significantly simpler.
David Brownell51400f12006-04-02 10:19:08 -080036 *
37 * NOTE that Microsoft's "RNDIS 1.0" specification is incomplete. Issues
38 * include:
39 * - Power management in particular relies on information that's scattered
40 * through other documentation, and which is incomplete or incorrect even
41 * there.
42 * - There are various undocumented protocol requirements, such as the
43 * need to send unused garbage in control-OUT messages.
44 * - In some cases, MS-Windows will emit undocumented requests; this
45 * matters more to peripheral implementations than host ones.
46 *
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -080047 * Moreover there's a no-open-specs variant of RNDIS called "ActiveSync".
48 *
David Brownell51400f12006-04-02 10:19:08 -080049 * For these reasons and others, ** USE OF RNDIS IS STRONGLY DISCOURAGED ** in
50 * favor of such non-proprietary alternatives as CDC Ethernet or the newer (and
51 * currently rare) "Ethernet Emulation Model" (EEM).
David Brownell64e04912005-08-31 09:54:36 -070052 */
53
54/*
David Brownell64e04912005-08-31 09:54:36 -070055 * RNDIS notifications from device: command completion; "reverse"
56 * keepalives; etc
57 */
Jussi Kivilinna56659982008-01-26 00:51:17 +020058void rndis_status(struct usbnet *dev, struct urb *urb)
David Brownell64e04912005-08-31 09:54:36 -070059{
60 devdbg(dev, "rndis status urb, len %d stat %d",
61 urb->actual_length, urb->status);
62 // FIXME for keepalives, respond immediately (asynchronously)
63 // if not an RNDIS status, do like cdc_status(dev,urb) does
64}
Jussi Kivilinna56659982008-01-26 00:51:17 +020065EXPORT_SYMBOL_GPL(rndis_status);
David Brownell64e04912005-08-31 09:54:36 -070066
67/*
Jussi Kivilinna2a4901b2009-07-30 19:41:52 +030068 * RNDIS indicate messages.
69 */
70static void rndis_msg_indicate(struct usbnet *dev, struct rndis_indicate *msg,
71 int buflen)
72{
73 struct cdc_state *info = (void *)&dev->data;
74 struct device *udev = &info->control->dev;
75
76 if (dev->driver_info->indication) {
77 dev->driver_info->indication(dev, msg, buflen);
78 } else {
79 switch (msg->status) {
80 case RNDIS_STATUS_MEDIA_CONNECT:
81 dev_info(udev, "rndis media connect\n");
82 break;
83 case RNDIS_STATUS_MEDIA_DISCONNECT:
84 dev_info(udev, "rndis media disconnect\n");
85 break;
86 default:
87 dev_info(udev, "rndis indication: 0x%08x\n",
88 le32_to_cpu(msg->status));
89 }
90 }
91}
92
93/*
David Brownell64e04912005-08-31 09:54:36 -070094 * RPC done RNDIS-style. Caller guarantees:
95 * - message is properly byteswapped
96 * - there's no other request pending
97 * - buf can hold up to 1KB response (required by RNDIS spec)
98 * On return, the first few entries are already byteswapped.
99 *
100 * Call context is likely probe(), before interface name is known,
101 * which is why we won't try to use it in the diagnostics.
102 */
Jussi Kivilinna818727b2008-06-18 15:40:12 +0300103int rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf, int buflen)
David Brownell64e04912005-08-31 09:54:36 -0700104{
105 struct cdc_state *info = (void *) &dev->data;
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800106 int master_ifnum;
David Brownell64e04912005-08-31 09:54:36 -0700107 int retval;
108 unsigned count;
109 __le32 rsp;
110 u32 xid = 0, msg_len, request_id;
111
112 /* REVISIT when this gets called from contexts other than probe() or
113 * disconnect(): either serialize, or dispatch responses on xid
114 */
115
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800116 /* Issue the request; xid is unique, don't bother byteswapping it */
David Brownell64e04912005-08-31 09:54:36 -0700117 if (likely(buf->msg_type != RNDIS_MSG_HALT
118 && buf->msg_type != RNDIS_MSG_RESET)) {
119 xid = dev->xid++;
120 if (!xid)
121 xid = dev->xid++;
122 buf->request_id = (__force __le32) xid;
123 }
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800124 master_ifnum = info->control->cur_altsetting->desc.bInterfaceNumber;
David Brownell64e04912005-08-31 09:54:36 -0700125 retval = usb_control_msg(dev->udev,
126 usb_sndctrlpipe(dev->udev, 0),
127 USB_CDC_SEND_ENCAPSULATED_COMMAND,
128 USB_TYPE_CLASS | USB_RECIP_INTERFACE,
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800129 0, master_ifnum,
David Brownell64e04912005-08-31 09:54:36 -0700130 buf, le32_to_cpu(buf->msg_len),
131 RNDIS_CONTROL_TIMEOUT_MS);
132 if (unlikely(retval < 0 || xid == 0))
133 return retval;
134
135 // FIXME Seems like some devices discard responses when
136 // we time out and cancel our "get response" requests...
137 // so, this is fragile. Probably need to poll for status.
138
139 /* ignore status endpoint, just poll the control channel;
140 * the request probably completed immediately
141 */
142 rsp = buf->msg_type | RNDIS_MSG_COMPLETION;
143 for (count = 0; count < 10; count++) {
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800144 memset(buf, 0, CONTROL_BUFFER_SIZE);
David Brownell64e04912005-08-31 09:54:36 -0700145 retval = usb_control_msg(dev->udev,
146 usb_rcvctrlpipe(dev->udev, 0),
147 USB_CDC_GET_ENCAPSULATED_RESPONSE,
148 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800149 0, master_ifnum,
Jussi Kivilinna818727b2008-06-18 15:40:12 +0300150 buf, buflen,
David Brownell64e04912005-08-31 09:54:36 -0700151 RNDIS_CONTROL_TIMEOUT_MS);
152 if (likely(retval >= 8)) {
153 msg_len = le32_to_cpu(buf->msg_len);
154 request_id = (__force u32) buf->request_id;
155 if (likely(buf->msg_type == rsp)) {
156 if (likely(request_id == xid)) {
157 if (unlikely(rsp == RNDIS_MSG_RESET_C))
158 return 0;
159 if (likely(RNDIS_STATUS_SUCCESS
160 == buf->status))
161 return 0;
162 dev_dbg(&info->control->dev,
163 "rndis reply status %08x\n",
164 le32_to_cpu(buf->status));
165 return -EL3RST;
166 }
167 dev_dbg(&info->control->dev,
168 "rndis reply id %d expected %d\n",
169 request_id, xid);
170 /* then likely retry */
171 } else switch (buf->msg_type) {
Jussi Kivilinna2a4901b2009-07-30 19:41:52 +0300172 case RNDIS_MSG_INDICATE: /* fault/event */
173 rndis_msg_indicate(dev, (void *)buf, buflen);
Jussi Kivilinna5d6ecf62008-01-26 00:51:34 +0200174
David Brownell64e04912005-08-31 09:54:36 -0700175 break;
176 case RNDIS_MSG_KEEPALIVE: { /* ping */
177 struct rndis_keepalive_c *msg = (void *)buf;
178
179 msg->msg_type = RNDIS_MSG_KEEPALIVE_C;
Harvey Harrison35c26c22009-02-14 22:56:56 -0800180 msg->msg_len = cpu_to_le32(sizeof *msg);
David Brownell64e04912005-08-31 09:54:36 -0700181 msg->status = RNDIS_STATUS_SUCCESS;
182 retval = usb_control_msg(dev->udev,
183 usb_sndctrlpipe(dev->udev, 0),
184 USB_CDC_SEND_ENCAPSULATED_COMMAND,
185 USB_TYPE_CLASS | USB_RECIP_INTERFACE,
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800186 0, master_ifnum,
David Brownell64e04912005-08-31 09:54:36 -0700187 msg, sizeof *msg,
188 RNDIS_CONTROL_TIMEOUT_MS);
189 if (unlikely(retval < 0))
190 dev_dbg(&info->control->dev,
191 "rndis keepalive err %d\n",
192 retval);
193 }
194 break;
195 default:
196 dev_dbg(&info->control->dev,
197 "unexpected rndis msg %08x len %d\n",
198 le32_to_cpu(buf->msg_type), msg_len);
199 }
200 } else {
201 /* device probably issued a protocol stall; ignore */
202 dev_dbg(&info->control->dev,
203 "rndis response error, code %d\n", retval);
204 }
Pierre Ynard74ef5c52008-05-14 16:20:16 -0700205 msleep(20);
David Brownell64e04912005-08-31 09:54:36 -0700206 }
207 dev_dbg(&info->control->dev, "rndis response timeout\n");
208 return -ETIMEDOUT;
209}
Jussi Kivilinna56659982008-01-26 00:51:17 +0200210EXPORT_SYMBOL_GPL(rndis_command);
David Brownell64e04912005-08-31 09:54:36 -0700211
David Brownellddda0862007-04-17 17:53:20 -0700212/*
213 * rndis_query:
214 *
215 * Performs a query for @oid along with 0 or more bytes of payload as
216 * specified by @in_len. If @reply_len is not set to -1 then the reply
217 * length is checked against this value, resulting in an error if it
218 * doesn't match.
219 *
220 * NOTE: Adding a payload exactly or greater than the size of the expected
221 * response payload is an evident requirement MSFT added for ActiveSync.
222 *
223 * The only exception is for OIDs that return a variably sized response,
224 * in which case no payload should be added. This undocumented (and
225 * nonsensical!) issue was found by sniffing protocol requests from the
226 * ActiveSync 4.1 Windows driver.
227 */
228static int rndis_query(struct usbnet *dev, struct usb_interface *intf,
Al Viroeca1ad82008-03-16 22:21:54 +0000229 void *buf, __le32 oid, u32 in_len,
David Brownellddda0862007-04-17 17:53:20 -0700230 void **reply, int *reply_len)
231{
232 int retval;
233 union {
234 void *buf;
235 struct rndis_msg_hdr *header;
236 struct rndis_query *get;
237 struct rndis_query_c *get_c;
238 } u;
239 u32 off, len;
240
241 u.buf = buf;
242
243 memset(u.get, 0, sizeof *u.get + in_len);
244 u.get->msg_type = RNDIS_MSG_QUERY;
245 u.get->msg_len = cpu_to_le32(sizeof *u.get + in_len);
246 u.get->oid = oid;
247 u.get->len = cpu_to_le32(in_len);
Harvey Harrison35c26c22009-02-14 22:56:56 -0800248 u.get->offset = cpu_to_le32(20);
David Brownellddda0862007-04-17 17:53:20 -0700249
Jussi Kivilinna818727b2008-06-18 15:40:12 +0300250 retval = rndis_command(dev, u.header, CONTROL_BUFFER_SIZE);
David Brownellddda0862007-04-17 17:53:20 -0700251 if (unlikely(retval < 0)) {
252 dev_err(&intf->dev, "RNDIS_MSG_QUERY(0x%08x) failed, %d\n",
253 oid, retval);
254 return retval;
255 }
256
257 off = le32_to_cpu(u.get_c->offset);
258 len = le32_to_cpu(u.get_c->len);
259 if (unlikely((8 + off + len) > CONTROL_BUFFER_SIZE))
260 goto response_error;
261
262 if (*reply_len != -1 && len != *reply_len)
263 goto response_error;
264
265 *reply = (unsigned char *) &u.get_c->request_id + off;
266 *reply_len = len;
267
268 return retval;
269
270response_error:
271 dev_err(&intf->dev, "RNDIS_MSG_QUERY(0x%08x) "
272 "invalid response - off %d len %d\n",
273 oid, off, len);
274 return -EDOM;
275}
276
Stephen Hemminger0f2166d2009-03-20 19:36:00 +0000277/* same as usbnet_netdev_ops but MTU change not allowed */
278static const struct net_device_ops rndis_netdev_ops = {
279 .ndo_open = usbnet_open,
280 .ndo_stop = usbnet_stop,
281 .ndo_start_xmit = usbnet_start_xmit,
282 .ndo_tx_timeout = usbnet_tx_timeout,
283 .ndo_set_mac_address = eth_mac_addr,
284 .ndo_validate_addr = eth_validate_addr,
285};
286
Jussi Kivilinna039ee172008-01-27 23:34:33 +0200287int
288generic_rndis_bind(struct usbnet *dev, struct usb_interface *intf, int flags)
David Brownell64e04912005-08-31 09:54:36 -0700289{
290 int retval;
291 struct net_device *net = dev->net;
Daniel Gollubdeb31f12007-01-16 11:03:01 +0100292 struct cdc_state *info = (void *) &dev->data;
David Brownell64e04912005-08-31 09:54:36 -0700293 union {
294 void *buf;
295 struct rndis_msg_hdr *header;
296 struct rndis_init *init;
297 struct rndis_init_c *init_c;
298 struct rndis_query *get;
299 struct rndis_query_c *get_c;
300 struct rndis_set *set;
301 struct rndis_set_c *set_c;
Jussi Kivilinna9ff55872008-01-26 00:50:55 +0200302 struct rndis_halt *halt;
David Brownell64e04912005-08-31 09:54:36 -0700303 } u;
Al Virod63ddce2008-05-21 01:34:30 +0100304 u32 tmp;
305 __le32 phym_unspec, *phym;
David Brownellddda0862007-04-17 17:53:20 -0700306 int reply_len;
307 unsigned char *bp;
David Brownell64e04912005-08-31 09:54:36 -0700308
309 /* we can't rely on i/o from stack working, or stack allocation */
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800310 u.buf = kmalloc(CONTROL_BUFFER_SIZE, GFP_KERNEL);
David Brownell64e04912005-08-31 09:54:36 -0700311 if (!u.buf)
312 return -ENOMEM;
313 retval = usbnet_generic_cdc_bind(dev, intf);
314 if (retval < 0)
Daniel Gollubdeb31f12007-01-16 11:03:01 +0100315 goto fail;
David Brownell64e04912005-08-31 09:54:36 -0700316
David Brownell64e04912005-08-31 09:54:36 -0700317 u.init->msg_type = RNDIS_MSG_INIT;
Harvey Harrison35c26c22009-02-14 22:56:56 -0800318 u.init->msg_len = cpu_to_le32(sizeof *u.init);
319 u.init->major_version = cpu_to_le32(1);
320 u.init->minor_version = cpu_to_le32(0);
David Brownell64e04912005-08-31 09:54:36 -0700321
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800322 /* max transfer (in spec) is 0x4000 at full speed, but for
323 * TX we'll stick to one Ethernet packet plus RNDIS framing.
324 * For RX we handle drivers that zero-pad to end-of-packet.
325 * Don't let userspace change these settings.
David Brownellddda0862007-04-17 17:53:20 -0700326 *
327 * NOTE: there still seems to be wierdness here, as if we need
328 * to do some more things to make sure WinCE targets accept this.
329 * They default to jumbograms of 8KB or 16KB, which is absurd
330 * for such low data rates and which is also more than Linux
331 * can usually expect to allocate for SKB data...
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800332 */
333 net->hard_header_len += sizeof (struct rndis_data_hdr);
334 dev->hard_mtu = net->mtu + net->hard_header_len;
335
Jean-Christophe Dubois10d0f272008-03-13 14:56:36 -0800336 dev->maxpacket = usb_maxpacket(dev->udev, dev->out, 1);
337 if (dev->maxpacket == 0) {
338 if (netif_msg_probe(dev))
339 dev_dbg(&intf->dev, "dev->maxpacket can't be 0\n");
340 retval = -EINVAL;
341 goto fail_and_release;
342 }
343
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800344 dev->rx_urb_size = dev->hard_mtu + (dev->maxpacket + 1);
345 dev->rx_urb_size &= ~(dev->maxpacket - 1);
346 u.init->max_transfer_size = cpu_to_le32(dev->rx_urb_size);
347
Stephen Hemminger0f2166d2009-03-20 19:36:00 +0000348 net->netdev_ops = &rndis_netdev_ops;
349
Jussi Kivilinna818727b2008-06-18 15:40:12 +0300350 retval = rndis_command(dev, u.header, CONTROL_BUFFER_SIZE);
David Brownell64e04912005-08-31 09:54:36 -0700351 if (unlikely(retval < 0)) {
352 /* it might not even be an RNDIS device!! */
353 dev_err(&intf->dev, "RNDIS init failed, %d\n", retval);
David Brownellddda0862007-04-17 17:53:20 -0700354 goto fail_and_release;
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800355 }
356 tmp = le32_to_cpu(u.init_c->max_transfer_size);
357 if (tmp < dev->hard_mtu) {
Thomas Sailer500d2c22007-10-24 00:47:19 +0200358 if (tmp <= net->hard_header_len) {
359 dev_err(&intf->dev,
360 "dev can't take %u byte packets (max %u)\n",
361 dev->hard_mtu, tmp);
362 retval = -EINVAL;
Jussi Kivilinna9ff55872008-01-26 00:50:55 +0200363 goto halt_fail_and_release;
Thomas Sailer500d2c22007-10-24 00:47:19 +0200364 }
Thomas Sailer500d2c22007-10-24 00:47:19 +0200365 dev_warn(&intf->dev,
366 "dev can't take %u byte packets (max %u), "
367 "adjusting MTU to %u\n",
George Nassar40ac7b62009-10-14 18:27:41 -0500368 dev->hard_mtu, tmp, tmp - net->hard_header_len);
369 dev->hard_mtu = tmp;
370 net->mtu = dev->hard_mtu - net->hard_header_len;
David Brownell64e04912005-08-31 09:54:36 -0700371 }
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800372
David Brownell64e04912005-08-31 09:54:36 -0700373 /* REVISIT: peripheral "alignment" request is ignored ... */
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800374 dev_dbg(&intf->dev,
375 "hard mtu %u (%u from dev), rx buflen %Zu, align %d\n",
376 dev->hard_mtu, tmp, dev->rx_urb_size,
David Brownell64e04912005-08-31 09:54:36 -0700377 1 << le32_to_cpu(u.init_c->packet_alignment));
378
Jussi Kivilinna7c39e032008-01-26 00:51:28 +0200379 /* module has some device initialization code needs to be done right
380 * after RNDIS_INIT */
381 if (dev->driver_info->early_init &&
382 dev->driver_info->early_init(dev) != 0)
383 goto halt_fail_and_release;
384
Jussi Kivilinna039ee172008-01-27 23:34:33 +0200385 /* Check physical medium */
Jussi Kivilinna9f5e60d2008-03-23 12:45:44 +0200386 phym = NULL;
Jussi Kivilinna039ee172008-01-27 23:34:33 +0200387 reply_len = sizeof *phym;
388 retval = rndis_query(dev, intf, u.buf, OID_GEN_PHYSICAL_MEDIUM,
389 0, (void **) &phym, &reply_len);
Jussi Kivilinna9f5e60d2008-03-23 12:45:44 +0200390 if (retval != 0 || !phym) {
Jussi Kivilinna039ee172008-01-27 23:34:33 +0200391 /* OID is optional so don't fail here. */
Jussi Kivilinna9f5e60d2008-03-23 12:45:44 +0200392 phym_unspec = RNDIS_PHYSICAL_MEDIUM_UNSPECIFIED;
393 phym = &phym_unspec;
394 }
Jussi Kivilinna039ee172008-01-27 23:34:33 +0200395 if ((flags & FLAG_RNDIS_PHYM_WIRELESS) &&
396 *phym != RNDIS_PHYSICAL_MEDIUM_WIRELESS_LAN) {
397 if (netif_msg_probe(dev))
398 dev_dbg(&intf->dev, "driver requires wireless "
399 "physical medium, but device is not.\n");
400 retval = -ENODEV;
401 goto halt_fail_and_release;
402 }
403 if ((flags & FLAG_RNDIS_PHYM_NOT_WIRELESS) &&
404 *phym == RNDIS_PHYSICAL_MEDIUM_WIRELESS_LAN) {
405 if (netif_msg_probe(dev))
406 dev_dbg(&intf->dev, "driver requires non-wireless "
407 "physical medium, but device is wireless.\n");
408 retval = -ENODEV;
409 goto halt_fail_and_release;
410 }
411
David Brownellddda0862007-04-17 17:53:20 -0700412 /* Get designated host ethernet address */
413 reply_len = ETH_ALEN;
414 retval = rndis_query(dev, intf, u.buf, OID_802_3_PERMANENT_ADDRESS,
415 48, (void **) &bp, &reply_len);
416 if (unlikely(retval< 0)) {
David Brownell64e04912005-08-31 09:54:36 -0700417 dev_err(&intf->dev, "rndis get ethaddr, %d\n", retval);
Jussi Kivilinna9ff55872008-01-26 00:50:55 +0200418 goto halt_fail_and_release;
David Brownell64e04912005-08-31 09:54:36 -0700419 }
David Brownellddda0862007-04-17 17:53:20 -0700420 memcpy(net->dev_addr, bp, ETH_ALEN);
John W. Linville083925d2009-10-06 11:05:42 +0000421 memcpy(net->perm_addr, bp, ETH_ALEN);
David Brownell64e04912005-08-31 09:54:36 -0700422
423 /* set a nonzero filter to enable data transfers */
424 memset(u.set, 0, sizeof *u.set);
425 u.set->msg_type = RNDIS_MSG_SET;
Harvey Harrison35c26c22009-02-14 22:56:56 -0800426 u.set->msg_len = cpu_to_le32(4 + sizeof *u.set);
David Brownell64e04912005-08-31 09:54:36 -0700427 u.set->oid = OID_GEN_CURRENT_PACKET_FILTER;
Harvey Harrison35c26c22009-02-14 22:56:56 -0800428 u.set->len = cpu_to_le32(4);
429 u.set->offset = cpu_to_le32((sizeof *u.set) - 8);
Jussi Kivilinnaa842eda2008-01-26 00:51:01 +0200430 *(__le32 *)(u.buf + sizeof *u.set) = RNDIS_DEFAULT_FILTER;
David Brownell64e04912005-08-31 09:54:36 -0700431
Jussi Kivilinna818727b2008-06-18 15:40:12 +0300432 retval = rndis_command(dev, u.header, CONTROL_BUFFER_SIZE);
David Brownell64e04912005-08-31 09:54:36 -0700433 if (unlikely(retval < 0)) {
434 dev_err(&intf->dev, "rndis set packet filter, %d\n", retval);
Jussi Kivilinna9ff55872008-01-26 00:50:55 +0200435 goto halt_fail_and_release;
David Brownell64e04912005-08-31 09:54:36 -0700436 }
437
438 retval = 0;
Daniel Gollubdeb31f12007-01-16 11:03:01 +0100439
440 kfree(u.buf);
441 return retval;
442
Jussi Kivilinna9ff55872008-01-26 00:50:55 +0200443halt_fail_and_release:
444 memset(u.halt, 0, sizeof *u.halt);
445 u.halt->msg_type = RNDIS_MSG_HALT;
Harvey Harrison35c26c22009-02-14 22:56:56 -0800446 u.halt->msg_len = cpu_to_le32(sizeof *u.halt);
Jussi Kivilinna818727b2008-06-18 15:40:12 +0300447 (void) rndis_command(dev, (void *)u.halt, CONTROL_BUFFER_SIZE);
Daniel Gollubdeb31f12007-01-16 11:03:01 +0100448fail_and_release:
449 usb_set_intfdata(info->data, NULL);
450 usb_driver_release_interface(driver_of(intf), info->data);
David Brownellddda0862007-04-17 17:53:20 -0700451 info->data = NULL;
Daniel Gollubdeb31f12007-01-16 11:03:01 +0100452fail:
David Brownell64e04912005-08-31 09:54:36 -0700453 kfree(u.buf);
454 return retval;
455}
Jussi Kivilinna56659982008-01-26 00:51:17 +0200456EXPORT_SYMBOL_GPL(generic_rndis_bind);
David Brownell64e04912005-08-31 09:54:36 -0700457
Jussi Kivilinna039ee172008-01-27 23:34:33 +0200458static int rndis_bind(struct usbnet *dev, struct usb_interface *intf)
459{
460 return generic_rndis_bind(dev, intf, FLAG_RNDIS_PHYM_NOT_WIRELESS);
461}
462
Jussi Kivilinna56659982008-01-26 00:51:17 +0200463void rndis_unbind(struct usbnet *dev, struct usb_interface *intf)
David Brownell64e04912005-08-31 09:54:36 -0700464{
465 struct rndis_halt *halt;
466
467 /* try to clear any rndis state/activity (no i/o from stack!) */
Jussi Kivilinna04c3c012008-01-26 00:50:49 +0200468 halt = kzalloc(CONTROL_BUFFER_SIZE, GFP_KERNEL);
David Brownell64e04912005-08-31 09:54:36 -0700469 if (halt) {
470 halt->msg_type = RNDIS_MSG_HALT;
Harvey Harrison35c26c22009-02-14 22:56:56 -0800471 halt->msg_len = cpu_to_le32(sizeof *halt);
Jussi Kivilinna818727b2008-06-18 15:40:12 +0300472 (void) rndis_command(dev, (void *)halt, CONTROL_BUFFER_SIZE);
David Brownell64e04912005-08-31 09:54:36 -0700473 kfree(halt);
474 }
475
Bjorge Dijkstra2bfa2e12008-01-26 00:50:38 +0200476 usbnet_cdc_unbind(dev, intf);
David Brownell64e04912005-08-31 09:54:36 -0700477}
Jussi Kivilinna56659982008-01-26 00:51:17 +0200478EXPORT_SYMBOL_GPL(rndis_unbind);
David Brownell64e04912005-08-31 09:54:36 -0700479
480/*
481 * DATA -- host must not write zlps
482 */
Jussi Kivilinna56659982008-01-26 00:51:17 +0200483int rndis_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
David Brownell64e04912005-08-31 09:54:36 -0700484{
485 /* peripheral may have batched packets to us... */
486 while (likely(skb->len)) {
487 struct rndis_data_hdr *hdr = (void *)skb->data;
488 struct sk_buff *skb2;
489 u32 msg_len, data_offset, data_len;
490
491 msg_len = le32_to_cpu(hdr->msg_len);
492 data_offset = le32_to_cpu(hdr->data_offset);
493 data_len = le32_to_cpu(hdr->data_len);
494
495 /* don't choke if we see oob, per-packet data, etc */
496 if (unlikely(hdr->msg_type != RNDIS_MSG_PACKET
497 || skb->len < msg_len
498 || (data_offset + data_len + 8) > msg_len)) {
Herbert Xu58e2e7d2009-06-29 16:52:26 +0000499 dev->net->stats.rx_frame_errors++;
David Brownell64e04912005-08-31 09:54:36 -0700500 devdbg(dev, "bad rndis message %d/%d/%d/%d, len %d",
501 le32_to_cpu(hdr->msg_type),
502 msg_len, data_offset, data_len, skb->len);
503 return 0;
504 }
505 skb_pull(skb, 8 + data_offset);
506
507 /* at most one packet left? */
508 if (likely((data_len - skb->len) <= sizeof *hdr)) {
509 skb_trim(skb, data_len);
510 break;
511 }
512
513 /* try to return all the packets in the batch */
514 skb2 = skb_clone(skb, GFP_ATOMIC);
515 if (unlikely(!skb2))
516 break;
517 skb_pull(skb, msg_len - sizeof *hdr);
518 skb_trim(skb2, data_len);
519 usbnet_skb_return(dev, skb2);
520 }
521
522 /* caller will usbnet_skb_return the remaining packet */
523 return 1;
524}
Jussi Kivilinna56659982008-01-26 00:51:17 +0200525EXPORT_SYMBOL_GPL(rndis_rx_fixup);
David Brownell64e04912005-08-31 09:54:36 -0700526
Jussi Kivilinna56659982008-01-26 00:51:17 +0200527struct sk_buff *
Al Viro55016f12005-10-21 03:21:58 -0400528rndis_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags)
David Brownell64e04912005-08-31 09:54:36 -0700529{
530 struct rndis_data_hdr *hdr;
531 struct sk_buff *skb2;
532 unsigned len = skb->len;
533
534 if (likely(!skb_cloned(skb))) {
535 int room = skb_headroom(skb);
536
537 /* enough head room as-is? */
538 if (unlikely((sizeof *hdr) <= room))
539 goto fill;
540
541 /* enough room, but needs to be readjusted? */
542 room += skb_tailroom(skb);
543 if (likely((sizeof *hdr) <= room)) {
544 skb->data = memmove(skb->head + sizeof *hdr,
545 skb->data, len);
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700546 skb_set_tail_pointer(skb, len);
David Brownell64e04912005-08-31 09:54:36 -0700547 goto fill;
548 }
549 }
550
551 /* create a new skb, with the correct size (and tailpad) */
552 skb2 = skb_copy_expand(skb, sizeof *hdr, 1, flags);
553 dev_kfree_skb_any(skb);
554 if (unlikely(!skb2))
555 return skb2;
556 skb = skb2;
557
558 /* fill out the RNDIS header. we won't bother trying to batch
559 * packets; Linux minimizes wasted bandwidth through tx queues.
560 */
561fill:
562 hdr = (void *) __skb_push(skb, sizeof *hdr);
563 memset(hdr, 0, sizeof *hdr);
564 hdr->msg_type = RNDIS_MSG_PACKET;
565 hdr->msg_len = cpu_to_le32(skb->len);
Harvey Harrison35c26c22009-02-14 22:56:56 -0800566 hdr->data_offset = cpu_to_le32(sizeof(*hdr) - 8);
David Brownell64e04912005-08-31 09:54:36 -0700567 hdr->data_len = cpu_to_le32(len);
568
569 /* FIXME make the last packet always be short ... */
570 return skb;
571}
Jussi Kivilinna56659982008-01-26 00:51:17 +0200572EXPORT_SYMBOL_GPL(rndis_tx_fixup);
David Brownell64e04912005-08-31 09:54:36 -0700573
574
575static const struct driver_info rndis_info = {
576 .description = "RNDIS device",
David Brownellddda0862007-04-17 17:53:20 -0700577 .flags = FLAG_ETHER | FLAG_FRAMING_RN | FLAG_NO_SETINT,
Jussi Kivilinna039ee172008-01-27 23:34:33 +0200578 .bind = rndis_bind,
David Brownell64e04912005-08-31 09:54:36 -0700579 .unbind = rndis_unbind,
580 .status = rndis_status,
581 .rx_fixup = rndis_rx_fixup,
582 .tx_fixup = rndis_tx_fixup,
583};
584
David Brownell64e04912005-08-31 09:54:36 -0700585/*-------------------------------------------------------------------------*/
586
587static const struct usb_device_id products [] = {
588{
589 /* RNDIS is MSFT's un-official variant of CDC ACM */
590 USB_INTERFACE_INFO(USB_CLASS_COMM, 2 /* ACM */, 0x0ff),
591 .driver_info = (unsigned long) &rndis_info,
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800592}, {
593 /* "ActiveSync" is an undocumented variant of RNDIS, used in WM5 */
594 USB_INTERFACE_INFO(USB_CLASS_MISC, 1, 1),
595 .driver_info = (unsigned long) &rndis_info,
Thomas Backlund7e99eed2008-07-22 13:55:58 -0700596}, {
597 /* RNDIS for tethering */
598 USB_INTERFACE_INFO(USB_CLASS_WIRELESS_CONTROLLER, 1, 3),
599 .driver_info = (unsigned long) &rndis_info,
David Brownell64e04912005-08-31 09:54:36 -0700600},
601 { }, // END
602};
603MODULE_DEVICE_TABLE(usb, products);
604
605static struct usb_driver rndis_driver = {
David Brownell64e04912005-08-31 09:54:36 -0700606 .name = "rndis_host",
607 .id_table = products,
608 .probe = usbnet_probe,
609 .disconnect = usbnet_disconnect,
610 .suspend = usbnet_suspend,
611 .resume = usbnet_resume,
612};
613
614static int __init rndis_init(void)
615{
David Brownell51400f12006-04-02 10:19:08 -0800616 return usb_register(&rndis_driver);
David Brownell64e04912005-08-31 09:54:36 -0700617}
618module_init(rndis_init);
619
620static void __exit rndis_exit(void)
621{
David Brownell51400f12006-04-02 10:19:08 -0800622 usb_deregister(&rndis_driver);
David Brownell64e04912005-08-31 09:54:36 -0700623}
624module_exit(rndis_exit);
625
626MODULE_AUTHOR("David Brownell");
627MODULE_DESCRIPTION("USB Host side RNDIS driver");
628MODULE_LICENSE("GPL");