blob: 4a4335833c36760548c67373ef71f17d05bba23c [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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090025#include <linux/slab.h>
David Brownell64e04912005-08-31 09:54:36 -070026#include <linux/mii.h>
27#include <linux/usb.h>
David Brownella8c28f22006-06-13 09:57:47 -070028#include <linux/usb/cdc.h>
Jussi Kivilinna3692e942008-01-26 00:51:45 +020029#include <linux/usb/usbnet.h>
30#include <linux/usb/rndis_host.h>
David Brownell64e04912005-08-31 09:54:36 -070031
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.
David Brownell51400f12006-04-02 10:19:08 -080037 *
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 *
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -080048 * Moreover there's a no-open-specs variant of RNDIS called "ActiveSync".
49 *
David Brownell51400f12006-04-02 10:19:08 -080050 * 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).
David Brownell64e04912005-08-31 09:54:36 -070053 */
54
55/*
David Brownell64e04912005-08-31 09:54:36 -070056 * RNDIS notifications from device: command completion; "reverse"
57 * keepalives; etc
58 */
Jussi Kivilinna56659982008-01-26 00:51:17 +020059void rndis_status(struct usbnet *dev, struct urb *urb)
David Brownell64e04912005-08-31 09:54:36 -070060{
Joe Perches60b86752010-02-17 10:30:23 +000061 netdev_dbg(dev->net, "rndis status urb, len %d stat %d\n",
62 urb->actual_length, urb->status);
David Brownell64e04912005-08-31 09:54:36 -070063 // FIXME for keepalives, respond immediately (asynchronously)
64 // if not an RNDIS status, do like cdc_status(dev,urb) does
65}
Jussi Kivilinna56659982008-01-26 00:51:17 +020066EXPORT_SYMBOL_GPL(rndis_status);
David Brownell64e04912005-08-31 09:54:36 -070067
68/*
Jussi Kivilinna2a4901b2009-07-30 19:41:52 +030069 * RNDIS indicate messages.
70 */
71static 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 {
Jussi Kivilinna3eef3662012-05-11 22:17:34 +000080 u32 status = le32_to_cpu(msg->status);
81
82 switch (status) {
83 case RNDIS_STATUS_MEDIA_CONNECT:
Jussi Kivilinna2a4901b2009-07-30 19:41:52 +030084 dev_info(udev, "rndis media connect\n");
85 break;
Jussi Kivilinna3eef3662012-05-11 22:17:34 +000086 case RNDIS_STATUS_MEDIA_DISCONNECT:
Jussi Kivilinna2a4901b2009-07-30 19:41:52 +030087 dev_info(udev, "rndis media disconnect\n");
88 break;
89 default:
Jussi Kivilinna3eef3662012-05-11 22:17:34 +000090 dev_info(udev, "rndis indication: 0x%08x\n", status);
Jussi Kivilinna2a4901b2009-07-30 19:41:52 +030091 }
92 }
93}
94
95/*
David Brownell64e04912005-08-31 09:54:36 -070096 * RPC done RNDIS-style. Caller guarantees:
97 * - message is properly byteswapped
98 * - there's no other request pending
99 * - buf can hold up to 1KB response (required by RNDIS spec)
100 * On return, the first few entries are already byteswapped.
101 *
102 * Call context is likely probe(), before interface name is known,
103 * which is why we won't try to use it in the diagnostics.
104 */
Jussi Kivilinna818727b2008-06-18 15:40:12 +0300105int rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf, int buflen)
David Brownell64e04912005-08-31 09:54:36 -0700106{
107 struct cdc_state *info = (void *) &dev->data;
Ben Hutchings4d42d412011-04-13 14:48:55 -0700108 struct usb_cdc_notification notification;
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800109 int master_ifnum;
David Brownell64e04912005-08-31 09:54:36 -0700110 int retval;
Ben Hutchings4d42d412011-04-13 14:48:55 -0700111 int partial;
David Brownell64e04912005-08-31 09:54:36 -0700112 unsigned count;
Jussi Kivilinna3eef3662012-05-11 22:17:34 +0000113 u32 xid = 0, msg_len, request_id, msg_type, rsp,
114 status;
David Brownell64e04912005-08-31 09:54:36 -0700115
116 /* REVISIT when this gets called from contexts other than probe() or
117 * disconnect(): either serialize, or dispatch responses on xid
118 */
119
Jussi Kivilinna3eef3662012-05-11 22:17:34 +0000120 msg_type = le32_to_cpu(buf->msg_type);
121
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800122 /* Issue the request; xid is unique, don't bother byteswapping it */
Jussi Kivilinna3eef3662012-05-11 22:17:34 +0000123 if (likely(msg_type != RNDIS_MSG_HALT && msg_type != RNDIS_MSG_RESET)) {
David Brownell64e04912005-08-31 09:54:36 -0700124 xid = dev->xid++;
125 if (!xid)
126 xid = dev->xid++;
127 buf->request_id = (__force __le32) xid;
128 }
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800129 master_ifnum = info->control->cur_altsetting->desc.bInterfaceNumber;
David Brownell64e04912005-08-31 09:54:36 -0700130 retval = usb_control_msg(dev->udev,
131 usb_sndctrlpipe(dev->udev, 0),
132 USB_CDC_SEND_ENCAPSULATED_COMMAND,
133 USB_TYPE_CLASS | USB_RECIP_INTERFACE,
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800134 0, master_ifnum,
David Brownell64e04912005-08-31 09:54:36 -0700135 buf, le32_to_cpu(buf->msg_len),
136 RNDIS_CONTROL_TIMEOUT_MS);
137 if (unlikely(retval < 0 || xid == 0))
138 return retval;
139
Ben Hutchings4d42d412011-04-13 14:48:55 -0700140 /* Some devices don't respond on the control channel until
141 * polled on the status channel, so do that first. */
142 if (dev->driver_info->data & RNDIS_DRIVER_DATA_POLL_STATUS) {
143 retval = usb_interrupt_msg(
144 dev->udev,
145 usb_rcvintpipe(dev->udev,
146 dev->status->desc.bEndpointAddress),
147 &notification, sizeof(notification), &partial,
148 RNDIS_CONTROL_TIMEOUT_MS);
149 if (unlikely(retval < 0))
150 return retval;
151 }
David Brownell64e04912005-08-31 09:54:36 -0700152
Ben Hutchings4d42d412011-04-13 14:48:55 -0700153 /* Poll the control channel; the request probably completed immediately */
Jussi Kivilinna3eef3662012-05-11 22:17:34 +0000154 rsp = le32_to_cpu(buf->msg_type) | RNDIS_MSG_COMPLETION;
David Brownell64e04912005-08-31 09:54:36 -0700155 for (count = 0; count < 10; count++) {
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800156 memset(buf, 0, CONTROL_BUFFER_SIZE);
David Brownell64e04912005-08-31 09:54:36 -0700157 retval = usb_control_msg(dev->udev,
158 usb_rcvctrlpipe(dev->udev, 0),
159 USB_CDC_GET_ENCAPSULATED_RESPONSE,
160 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800161 0, master_ifnum,
Jussi Kivilinna818727b2008-06-18 15:40:12 +0300162 buf, buflen,
David Brownell64e04912005-08-31 09:54:36 -0700163 RNDIS_CONTROL_TIMEOUT_MS);
164 if (likely(retval >= 8)) {
Jussi Kivilinna3eef3662012-05-11 22:17:34 +0000165 msg_type = le32_to_cpu(buf->msg_type);
David Brownell64e04912005-08-31 09:54:36 -0700166 msg_len = le32_to_cpu(buf->msg_len);
Jussi Kivilinna3eef3662012-05-11 22:17:34 +0000167 status = le32_to_cpu(buf->status);
David Brownell64e04912005-08-31 09:54:36 -0700168 request_id = (__force u32) buf->request_id;
Jussi Kivilinna3eef3662012-05-11 22:17:34 +0000169 if (likely(msg_type == rsp)) {
David Brownell64e04912005-08-31 09:54:36 -0700170 if (likely(request_id == xid)) {
Jussi Kivilinna3eef3662012-05-11 22:17:34 +0000171 if (unlikely(rsp == RNDIS_MSG_RESET_C))
David Brownell64e04912005-08-31 09:54:36 -0700172 return 0;
Jussi Kivilinna3eef3662012-05-11 22:17:34 +0000173 if (likely(RNDIS_STATUS_SUCCESS ==
174 status))
David Brownell64e04912005-08-31 09:54:36 -0700175 return 0;
176 dev_dbg(&info->control->dev,
177 "rndis reply status %08x\n",
Jussi Kivilinna3eef3662012-05-11 22:17:34 +0000178 status);
David Brownell64e04912005-08-31 09:54:36 -0700179 return -EL3RST;
180 }
181 dev_dbg(&info->control->dev,
182 "rndis reply id %d expected %d\n",
183 request_id, xid);
184 /* then likely retry */
Jussi Kivilinna3eef3662012-05-11 22:17:34 +0000185 } else switch (msg_type) {
186 case RNDIS_MSG_INDICATE: /* fault/event */
Jussi Kivilinna2a4901b2009-07-30 19:41:52 +0300187 rndis_msg_indicate(dev, (void *)buf, buflen);
David Brownell64e04912005-08-31 09:54:36 -0700188 break;
Jussi Kivilinna3eef3662012-05-11 22:17:34 +0000189 case RNDIS_MSG_KEEPALIVE: { /* ping */
David Brownell64e04912005-08-31 09:54:36 -0700190 struct rndis_keepalive_c *msg = (void *)buf;
191
Linus Walleij7390e8b2012-05-11 22:15:39 +0000192 msg->msg_type = cpu_to_le32(RNDIS_MSG_KEEPALIVE_C);
Harvey Harrison35c26c22009-02-14 22:56:56 -0800193 msg->msg_len = cpu_to_le32(sizeof *msg);
Linus Walleij7390e8b2012-05-11 22:15:39 +0000194 msg->status = cpu_to_le32(RNDIS_STATUS_SUCCESS);
David Brownell64e04912005-08-31 09:54:36 -0700195 retval = usb_control_msg(dev->udev,
196 usb_sndctrlpipe(dev->udev, 0),
197 USB_CDC_SEND_ENCAPSULATED_COMMAND,
198 USB_TYPE_CLASS | USB_RECIP_INTERFACE,
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800199 0, master_ifnum,
David Brownell64e04912005-08-31 09:54:36 -0700200 msg, sizeof *msg,
201 RNDIS_CONTROL_TIMEOUT_MS);
202 if (unlikely(retval < 0))
203 dev_dbg(&info->control->dev,
204 "rndis keepalive err %d\n",
205 retval);
206 }
207 break;
208 default:
209 dev_dbg(&info->control->dev,
210 "unexpected rndis msg %08x len %d\n",
211 le32_to_cpu(buf->msg_type), msg_len);
212 }
213 } else {
214 /* device probably issued a protocol stall; ignore */
215 dev_dbg(&info->control->dev,
216 "rndis response error, code %d\n", retval);
217 }
Pierre Ynard74ef5c52008-05-14 16:20:16 -0700218 msleep(20);
David Brownell64e04912005-08-31 09:54:36 -0700219 }
220 dev_dbg(&info->control->dev, "rndis response timeout\n");
221 return -ETIMEDOUT;
222}
Jussi Kivilinna56659982008-01-26 00:51:17 +0200223EXPORT_SYMBOL_GPL(rndis_command);
David Brownell64e04912005-08-31 09:54:36 -0700224
David Brownellddda0862007-04-17 17:53:20 -0700225/*
226 * rndis_query:
227 *
228 * Performs a query for @oid along with 0 or more bytes of payload as
229 * specified by @in_len. If @reply_len is not set to -1 then the reply
230 * length is checked against this value, resulting in an error if it
231 * doesn't match.
232 *
233 * NOTE: Adding a payload exactly or greater than the size of the expected
234 * response payload is an evident requirement MSFT added for ActiveSync.
235 *
236 * The only exception is for OIDs that return a variably sized response,
237 * in which case no payload should be added. This undocumented (and
238 * nonsensical!) issue was found by sniffing protocol requests from the
239 * ActiveSync 4.1 Windows driver.
240 */
241static int rndis_query(struct usbnet *dev, struct usb_interface *intf,
Jussi Kivilinna5432bdc2012-05-11 22:17:50 +0000242 void *buf, u32 oid, u32 in_len,
David Brownellddda0862007-04-17 17:53:20 -0700243 void **reply, int *reply_len)
244{
245 int retval;
246 union {
247 void *buf;
248 struct rndis_msg_hdr *header;
249 struct rndis_query *get;
250 struct rndis_query_c *get_c;
251 } u;
252 u32 off, len;
253
254 u.buf = buf;
255
256 memset(u.get, 0, sizeof *u.get + in_len);
Linus Walleij7390e8b2012-05-11 22:15:39 +0000257 u.get->msg_type = cpu_to_le32(RNDIS_MSG_QUERY);
David Brownellddda0862007-04-17 17:53:20 -0700258 u.get->msg_len = cpu_to_le32(sizeof *u.get + in_len);
Jussi Kivilinna5432bdc2012-05-11 22:17:50 +0000259 u.get->oid = cpu_to_le32(oid);
David Brownellddda0862007-04-17 17:53:20 -0700260 u.get->len = cpu_to_le32(in_len);
Harvey Harrison35c26c22009-02-14 22:56:56 -0800261 u.get->offset = cpu_to_le32(20);
David Brownellddda0862007-04-17 17:53:20 -0700262
Jussi Kivilinna818727b2008-06-18 15:40:12 +0300263 retval = rndis_command(dev, u.header, CONTROL_BUFFER_SIZE);
David Brownellddda0862007-04-17 17:53:20 -0700264 if (unlikely(retval < 0)) {
265 dev_err(&intf->dev, "RNDIS_MSG_QUERY(0x%08x) failed, %d\n",
266 oid, retval);
267 return retval;
268 }
269
270 off = le32_to_cpu(u.get_c->offset);
271 len = le32_to_cpu(u.get_c->len);
272 if (unlikely((8 + off + len) > CONTROL_BUFFER_SIZE))
273 goto response_error;
274
275 if (*reply_len != -1 && len != *reply_len)
276 goto response_error;
277
278 *reply = (unsigned char *) &u.get_c->request_id + off;
279 *reply_len = len;
280
281 return retval;
282
283response_error:
284 dev_err(&intf->dev, "RNDIS_MSG_QUERY(0x%08x) "
285 "invalid response - off %d len %d\n",
286 oid, off, len);
287 return -EDOM;
288}
289
Stephen Hemminger0f2166d2009-03-20 19:36:00 +0000290/* same as usbnet_netdev_ops but MTU change not allowed */
291static const struct net_device_ops rndis_netdev_ops = {
292 .ndo_open = usbnet_open,
293 .ndo_stop = usbnet_stop,
294 .ndo_start_xmit = usbnet_start_xmit,
295 .ndo_tx_timeout = usbnet_tx_timeout,
296 .ndo_set_mac_address = eth_mac_addr,
297 .ndo_validate_addr = eth_validate_addr,
298};
299
Jussi Kivilinna039ee172008-01-27 23:34:33 +0200300int
301generic_rndis_bind(struct usbnet *dev, struct usb_interface *intf, int flags)
David Brownell64e04912005-08-31 09:54:36 -0700302{
303 int retval;
304 struct net_device *net = dev->net;
Daniel Gollubdeb31f12007-01-16 11:03:01 +0100305 struct cdc_state *info = (void *) &dev->data;
David Brownell64e04912005-08-31 09:54:36 -0700306 union {
307 void *buf;
308 struct rndis_msg_hdr *header;
309 struct rndis_init *init;
310 struct rndis_init_c *init_c;
311 struct rndis_query *get;
312 struct rndis_query_c *get_c;
313 struct rndis_set *set;
314 struct rndis_set_c *set_c;
Jussi Kivilinna9ff55872008-01-26 00:50:55 +0200315 struct rndis_halt *halt;
David Brownell64e04912005-08-31 09:54:36 -0700316 } u;
Al Virod63ddce2008-05-21 01:34:30 +0100317 u32 tmp;
318 __le32 phym_unspec, *phym;
David Brownellddda0862007-04-17 17:53:20 -0700319 int reply_len;
320 unsigned char *bp;
David Brownell64e04912005-08-31 09:54:36 -0700321
322 /* we can't rely on i/o from stack working, or stack allocation */
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800323 u.buf = kmalloc(CONTROL_BUFFER_SIZE, GFP_KERNEL);
David Brownell64e04912005-08-31 09:54:36 -0700324 if (!u.buf)
325 return -ENOMEM;
326 retval = usbnet_generic_cdc_bind(dev, intf);
327 if (retval < 0)
Daniel Gollubdeb31f12007-01-16 11:03:01 +0100328 goto fail;
David Brownell64e04912005-08-31 09:54:36 -0700329
Linus Walleij7390e8b2012-05-11 22:15:39 +0000330 u.init->msg_type = cpu_to_le32(RNDIS_MSG_INIT);
Harvey Harrison35c26c22009-02-14 22:56:56 -0800331 u.init->msg_len = cpu_to_le32(sizeof *u.init);
332 u.init->major_version = cpu_to_le32(1);
333 u.init->minor_version = cpu_to_le32(0);
David Brownell64e04912005-08-31 09:54:36 -0700334
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800335 /* max transfer (in spec) is 0x4000 at full speed, but for
336 * TX we'll stick to one Ethernet packet plus RNDIS framing.
337 * For RX we handle drivers that zero-pad to end-of-packet.
338 * Don't let userspace change these settings.
David Brownellddda0862007-04-17 17:53:20 -0700339 *
340 * NOTE: there still seems to be wierdness here, as if we need
341 * to do some more things to make sure WinCE targets accept this.
342 * They default to jumbograms of 8KB or 16KB, which is absurd
343 * for such low data rates and which is also more than Linux
344 * can usually expect to allocate for SKB data...
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800345 */
346 net->hard_header_len += sizeof (struct rndis_data_hdr);
347 dev->hard_mtu = net->mtu + net->hard_header_len;
348
Jean-Christophe Dubois10d0f272008-03-13 14:56:36 -0800349 dev->maxpacket = usb_maxpacket(dev->udev, dev->out, 1);
350 if (dev->maxpacket == 0) {
Joe Perchesa475f602010-02-17 10:30:24 +0000351 netif_dbg(dev, probe, dev->net,
352 "dev->maxpacket can't be 0\n");
Jean-Christophe Dubois10d0f272008-03-13 14:56:36 -0800353 retval = -EINVAL;
354 goto fail_and_release;
355 }
356
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800357 dev->rx_urb_size = dev->hard_mtu + (dev->maxpacket + 1);
358 dev->rx_urb_size &= ~(dev->maxpacket - 1);
359 u.init->max_transfer_size = cpu_to_le32(dev->rx_urb_size);
360
Stephen Hemminger0f2166d2009-03-20 19:36:00 +0000361 net->netdev_ops = &rndis_netdev_ops;
362
Jussi Kivilinna818727b2008-06-18 15:40:12 +0300363 retval = rndis_command(dev, u.header, CONTROL_BUFFER_SIZE);
David Brownell64e04912005-08-31 09:54:36 -0700364 if (unlikely(retval < 0)) {
365 /* it might not even be an RNDIS device!! */
366 dev_err(&intf->dev, "RNDIS init failed, %d\n", retval);
David Brownellddda0862007-04-17 17:53:20 -0700367 goto fail_and_release;
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800368 }
369 tmp = le32_to_cpu(u.init_c->max_transfer_size);
370 if (tmp < dev->hard_mtu) {
Thomas Sailer500d2c22007-10-24 00:47:19 +0200371 if (tmp <= net->hard_header_len) {
372 dev_err(&intf->dev,
373 "dev can't take %u byte packets (max %u)\n",
374 dev->hard_mtu, tmp);
375 retval = -EINVAL;
Jussi Kivilinna9ff55872008-01-26 00:50:55 +0200376 goto halt_fail_and_release;
Thomas Sailer500d2c22007-10-24 00:47:19 +0200377 }
Thomas Sailer500d2c22007-10-24 00:47:19 +0200378 dev_warn(&intf->dev,
379 "dev can't take %u byte packets (max %u), "
380 "adjusting MTU to %u\n",
George Nassar40ac7b62009-10-14 18:27:41 -0500381 dev->hard_mtu, tmp, tmp - net->hard_header_len);
382 dev->hard_mtu = tmp;
383 net->mtu = dev->hard_mtu - net->hard_header_len;
David Brownell64e04912005-08-31 09:54:36 -0700384 }
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800385
David Brownell64e04912005-08-31 09:54:36 -0700386 /* REVISIT: peripheral "alignment" request is ignored ... */
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800387 dev_dbg(&intf->dev,
388 "hard mtu %u (%u from dev), rx buflen %Zu, align %d\n",
389 dev->hard_mtu, tmp, dev->rx_urb_size,
David Brownell64e04912005-08-31 09:54:36 -0700390 1 << le32_to_cpu(u.init_c->packet_alignment));
391
Jussi Kivilinna7c39e032008-01-26 00:51:28 +0200392 /* module has some device initialization code needs to be done right
393 * after RNDIS_INIT */
394 if (dev->driver_info->early_init &&
395 dev->driver_info->early_init(dev) != 0)
396 goto halt_fail_and_release;
397
Jussi Kivilinna039ee172008-01-27 23:34:33 +0200398 /* Check physical medium */
Jussi Kivilinna9f5e60d2008-03-23 12:45:44 +0200399 phym = NULL;
Jussi Kivilinna039ee172008-01-27 23:34:33 +0200400 reply_len = sizeof *phym;
Linus Walleij7390e8b2012-05-11 22:15:39 +0000401 retval = rndis_query(dev, intf, u.buf,
Jussi Kivilinna5432bdc2012-05-11 22:17:50 +0000402 RNDIS_OID_GEN_PHYSICAL_MEDIUM,
403 0, (void **) &phym, &reply_len);
Jussi Kivilinna9f5e60d2008-03-23 12:45:44 +0200404 if (retval != 0 || !phym) {
Jussi Kivilinna039ee172008-01-27 23:34:33 +0200405 /* OID is optional so don't fail here. */
Linus Walleij7390e8b2012-05-11 22:15:39 +0000406 phym_unspec = cpu_to_le32(RNDIS_PHYSICAL_MEDIUM_UNSPECIFIED);
Jussi Kivilinna9f5e60d2008-03-23 12:45:44 +0200407 phym = &phym_unspec;
408 }
Jussi Kivilinna039ee172008-01-27 23:34:33 +0200409 if ((flags & FLAG_RNDIS_PHYM_WIRELESS) &&
Jussi Kivilinna3eef3662012-05-11 22:17:34 +0000410 le32_to_cpup(phym) != RNDIS_PHYSICAL_MEDIUM_WIRELESS_LAN) {
Joe Perchesa475f602010-02-17 10:30:24 +0000411 netif_dbg(dev, probe, dev->net,
412 "driver requires wireless physical medium, but device is not\n");
Jussi Kivilinna039ee172008-01-27 23:34:33 +0200413 retval = -ENODEV;
414 goto halt_fail_and_release;
415 }
416 if ((flags & FLAG_RNDIS_PHYM_NOT_WIRELESS) &&
Jussi Kivilinna3eef3662012-05-11 22:17:34 +0000417 le32_to_cpup(phym) == RNDIS_PHYSICAL_MEDIUM_WIRELESS_LAN) {
Joe Perchesa475f602010-02-17 10:30:24 +0000418 netif_dbg(dev, probe, dev->net,
419 "driver requires non-wireless physical medium, but device is wireless.\n");
Jussi Kivilinna039ee172008-01-27 23:34:33 +0200420 retval = -ENODEV;
421 goto halt_fail_and_release;
422 }
423
David Brownellddda0862007-04-17 17:53:20 -0700424 /* Get designated host ethernet address */
425 reply_len = ETH_ALEN;
Linus Walleij7390e8b2012-05-11 22:15:39 +0000426 retval = rndis_query(dev, intf, u.buf,
Jussi Kivilinna5432bdc2012-05-11 22:17:50 +0000427 RNDIS_OID_802_3_PERMANENT_ADDRESS,
428 48, (void **) &bp, &reply_len);
David Brownellddda0862007-04-17 17:53:20 -0700429 if (unlikely(retval< 0)) {
David Brownell64e04912005-08-31 09:54:36 -0700430 dev_err(&intf->dev, "rndis get ethaddr, %d\n", retval);
Jussi Kivilinna9ff55872008-01-26 00:50:55 +0200431 goto halt_fail_and_release;
David Brownell64e04912005-08-31 09:54:36 -0700432 }
David Brownellddda0862007-04-17 17:53:20 -0700433 memcpy(net->dev_addr, bp, ETH_ALEN);
John W. Linville083925d2009-10-06 11:05:42 +0000434 memcpy(net->perm_addr, bp, ETH_ALEN);
David Brownell64e04912005-08-31 09:54:36 -0700435
436 /* set a nonzero filter to enable data transfers */
437 memset(u.set, 0, sizeof *u.set);
Linus Walleij7390e8b2012-05-11 22:15:39 +0000438 u.set->msg_type = cpu_to_le32(RNDIS_MSG_SET);
Harvey Harrison35c26c22009-02-14 22:56:56 -0800439 u.set->msg_len = cpu_to_le32(4 + sizeof *u.set);
Linus Walleij8cdddc32012-05-11 22:16:08 +0000440 u.set->oid = cpu_to_le32(RNDIS_OID_GEN_CURRENT_PACKET_FILTER);
Harvey Harrison35c26c22009-02-14 22:56:56 -0800441 u.set->len = cpu_to_le32(4);
442 u.set->offset = cpu_to_le32((sizeof *u.set) - 8);
Linus Walleij7390e8b2012-05-11 22:15:39 +0000443 *(__le32 *)(u.buf + sizeof *u.set) = cpu_to_le32(RNDIS_DEFAULT_FILTER);
David Brownell64e04912005-08-31 09:54:36 -0700444
Jussi Kivilinna818727b2008-06-18 15:40:12 +0300445 retval = rndis_command(dev, u.header, CONTROL_BUFFER_SIZE);
David Brownell64e04912005-08-31 09:54:36 -0700446 if (unlikely(retval < 0)) {
447 dev_err(&intf->dev, "rndis set packet filter, %d\n", retval);
Jussi Kivilinna9ff55872008-01-26 00:50:55 +0200448 goto halt_fail_and_release;
David Brownell64e04912005-08-31 09:54:36 -0700449 }
450
451 retval = 0;
Daniel Gollubdeb31f12007-01-16 11:03:01 +0100452
453 kfree(u.buf);
454 return retval;
455
Jussi Kivilinna9ff55872008-01-26 00:50:55 +0200456halt_fail_and_release:
457 memset(u.halt, 0, sizeof *u.halt);
Linus Walleij7390e8b2012-05-11 22:15:39 +0000458 u.halt->msg_type = cpu_to_le32(RNDIS_MSG_HALT);
Harvey Harrison35c26c22009-02-14 22:56:56 -0800459 u.halt->msg_len = cpu_to_le32(sizeof *u.halt);
Jussi Kivilinna818727b2008-06-18 15:40:12 +0300460 (void) rndis_command(dev, (void *)u.halt, CONTROL_BUFFER_SIZE);
Daniel Gollubdeb31f12007-01-16 11:03:01 +0100461fail_and_release:
462 usb_set_intfdata(info->data, NULL);
463 usb_driver_release_interface(driver_of(intf), info->data);
David Brownellddda0862007-04-17 17:53:20 -0700464 info->data = NULL;
Daniel Gollubdeb31f12007-01-16 11:03:01 +0100465fail:
David Brownell64e04912005-08-31 09:54:36 -0700466 kfree(u.buf);
467 return retval;
468}
Jussi Kivilinna56659982008-01-26 00:51:17 +0200469EXPORT_SYMBOL_GPL(generic_rndis_bind);
David Brownell64e04912005-08-31 09:54:36 -0700470
Jussi Kivilinna039ee172008-01-27 23:34:33 +0200471static int rndis_bind(struct usbnet *dev, struct usb_interface *intf)
472{
473 return generic_rndis_bind(dev, intf, FLAG_RNDIS_PHYM_NOT_WIRELESS);
474}
475
Jussi Kivilinna56659982008-01-26 00:51:17 +0200476void rndis_unbind(struct usbnet *dev, struct usb_interface *intf)
David Brownell64e04912005-08-31 09:54:36 -0700477{
478 struct rndis_halt *halt;
479
480 /* try to clear any rndis state/activity (no i/o from stack!) */
Jussi Kivilinna04c3c012008-01-26 00:50:49 +0200481 halt = kzalloc(CONTROL_BUFFER_SIZE, GFP_KERNEL);
David Brownell64e04912005-08-31 09:54:36 -0700482 if (halt) {
Linus Walleij7390e8b2012-05-11 22:15:39 +0000483 halt->msg_type = cpu_to_le32(RNDIS_MSG_HALT);
Harvey Harrison35c26c22009-02-14 22:56:56 -0800484 halt->msg_len = cpu_to_le32(sizeof *halt);
Jussi Kivilinna818727b2008-06-18 15:40:12 +0300485 (void) rndis_command(dev, (void *)halt, CONTROL_BUFFER_SIZE);
David Brownell64e04912005-08-31 09:54:36 -0700486 kfree(halt);
487 }
488
Bjorge Dijkstra2bfa2e12008-01-26 00:50:38 +0200489 usbnet_cdc_unbind(dev, intf);
David Brownell64e04912005-08-31 09:54:36 -0700490}
Jussi Kivilinna56659982008-01-26 00:51:17 +0200491EXPORT_SYMBOL_GPL(rndis_unbind);
David Brownell64e04912005-08-31 09:54:36 -0700492
493/*
494 * DATA -- host must not write zlps
495 */
Jussi Kivilinna56659982008-01-26 00:51:17 +0200496int rndis_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
David Brownell64e04912005-08-31 09:54:36 -0700497{
498 /* peripheral may have batched packets to us... */
499 while (likely(skb->len)) {
500 struct rndis_data_hdr *hdr = (void *)skb->data;
501 struct sk_buff *skb2;
Jussi Kivilinna3eef3662012-05-11 22:17:34 +0000502 u32 msg_type, msg_len, data_offset, data_len;
David Brownell64e04912005-08-31 09:54:36 -0700503
Jussi Kivilinna3eef3662012-05-11 22:17:34 +0000504 msg_type = le32_to_cpu(hdr->msg_type);
David Brownell64e04912005-08-31 09:54:36 -0700505 msg_len = le32_to_cpu(hdr->msg_len);
506 data_offset = le32_to_cpu(hdr->data_offset);
507 data_len = le32_to_cpu(hdr->data_len);
508
509 /* don't choke if we see oob, per-packet data, etc */
Jussi Kivilinna3eef3662012-05-11 22:17:34 +0000510 if (unlikely(msg_type != RNDIS_MSG_PACKET || skb->len < msg_len
511 || (data_offset + data_len + 8) > msg_len)) {
Herbert Xu58e2e7d2009-06-29 16:52:26 +0000512 dev->net->stats.rx_frame_errors++;
Joe Perches60b86752010-02-17 10:30:23 +0000513 netdev_dbg(dev->net, "bad rndis message %d/%d/%d/%d, len %d\n",
514 le32_to_cpu(hdr->msg_type),
515 msg_len, data_offset, data_len, skb->len);
David Brownell64e04912005-08-31 09:54:36 -0700516 return 0;
517 }
518 skb_pull(skb, 8 + data_offset);
519
520 /* at most one packet left? */
521 if (likely((data_len - skb->len) <= sizeof *hdr)) {
522 skb_trim(skb, data_len);
523 break;
524 }
525
526 /* try to return all the packets in the batch */
527 skb2 = skb_clone(skb, GFP_ATOMIC);
528 if (unlikely(!skb2))
529 break;
530 skb_pull(skb, msg_len - sizeof *hdr);
531 skb_trim(skb2, data_len);
532 usbnet_skb_return(dev, skb2);
533 }
534
535 /* caller will usbnet_skb_return the remaining packet */
536 return 1;
537}
Jussi Kivilinna56659982008-01-26 00:51:17 +0200538EXPORT_SYMBOL_GPL(rndis_rx_fixup);
David Brownell64e04912005-08-31 09:54:36 -0700539
Jussi Kivilinna56659982008-01-26 00:51:17 +0200540struct sk_buff *
Al Viro55016f12005-10-21 03:21:58 -0400541rndis_tx_fixup(struct usbnet *dev, struct sk_buff *skb, gfp_t flags)
David Brownell64e04912005-08-31 09:54:36 -0700542{
543 struct rndis_data_hdr *hdr;
544 struct sk_buff *skb2;
545 unsigned len = skb->len;
546
547 if (likely(!skb_cloned(skb))) {
548 int room = skb_headroom(skb);
549
550 /* enough head room as-is? */
551 if (unlikely((sizeof *hdr) <= room))
552 goto fill;
553
554 /* enough room, but needs to be readjusted? */
555 room += skb_tailroom(skb);
556 if (likely((sizeof *hdr) <= room)) {
557 skb->data = memmove(skb->head + sizeof *hdr,
558 skb->data, len);
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700559 skb_set_tail_pointer(skb, len);
David Brownell64e04912005-08-31 09:54:36 -0700560 goto fill;
561 }
562 }
563
564 /* create a new skb, with the correct size (and tailpad) */
565 skb2 = skb_copy_expand(skb, sizeof *hdr, 1, flags);
566 dev_kfree_skb_any(skb);
567 if (unlikely(!skb2))
568 return skb2;
569 skb = skb2;
570
571 /* fill out the RNDIS header. we won't bother trying to batch
572 * packets; Linux minimizes wasted bandwidth through tx queues.
573 */
574fill:
575 hdr = (void *) __skb_push(skb, sizeof *hdr);
576 memset(hdr, 0, sizeof *hdr);
Linus Walleij7390e8b2012-05-11 22:15:39 +0000577 hdr->msg_type = cpu_to_le32(RNDIS_MSG_PACKET);
David Brownell64e04912005-08-31 09:54:36 -0700578 hdr->msg_len = cpu_to_le32(skb->len);
Harvey Harrison35c26c22009-02-14 22:56:56 -0800579 hdr->data_offset = cpu_to_le32(sizeof(*hdr) - 8);
David Brownell64e04912005-08-31 09:54:36 -0700580 hdr->data_len = cpu_to_le32(len);
581
582 /* FIXME make the last packet always be short ... */
583 return skb;
584}
Jussi Kivilinna56659982008-01-26 00:51:17 +0200585EXPORT_SYMBOL_GPL(rndis_tx_fixup);
David Brownell64e04912005-08-31 09:54:36 -0700586
587
588static const struct driver_info rndis_info = {
589 .description = "RNDIS device",
Arnd Bergmannc2613442011-04-01 20:12:02 -0700590 .flags = FLAG_ETHER | FLAG_POINTTOPOINT | FLAG_FRAMING_RN | FLAG_NO_SETINT,
Jussi Kivilinna039ee172008-01-27 23:34:33 +0200591 .bind = rndis_bind,
David Brownell64e04912005-08-31 09:54:36 -0700592 .unbind = rndis_unbind,
593 .status = rndis_status,
594 .rx_fixup = rndis_rx_fixup,
595 .tx_fixup = rndis_tx_fixup,
596};
597
Ben Hutchings4d42d412011-04-13 14:48:55 -0700598static const struct driver_info rndis_poll_status_info = {
599 .description = "RNDIS device (poll status before control)",
Ben Hutchingseb8aa722011-04-14 23:23:45 -0700600 .flags = FLAG_ETHER | FLAG_POINTTOPOINT | FLAG_FRAMING_RN | FLAG_NO_SETINT,
Ben Hutchings4d42d412011-04-13 14:48:55 -0700601 .data = RNDIS_DRIVER_DATA_POLL_STATUS,
602 .bind = rndis_bind,
603 .unbind = rndis_unbind,
604 .status = rndis_status,
605 .rx_fixup = rndis_rx_fixup,
606 .tx_fixup = rndis_tx_fixup,
607};
608
David Brownell64e04912005-08-31 09:54:36 -0700609/*-------------------------------------------------------------------------*/
610
611static const struct usb_device_id products [] = {
612{
Ben Hutchings4d42d412011-04-13 14:48:55 -0700613 /* 2Wire HomePortal 1000SW */
614 USB_DEVICE_AND_INTERFACE_INFO(0x1630, 0x0042,
615 USB_CLASS_COMM, 2 /* ACM */, 0x0ff),
616 .driver_info = (unsigned long) &rndis_poll_status_info,
617}, {
David Brownell64e04912005-08-31 09:54:36 -0700618 /* RNDIS is MSFT's un-official variant of CDC ACM */
619 USB_INTERFACE_INFO(USB_CLASS_COMM, 2 /* ACM */, 0x0ff),
620 .driver_info = (unsigned long) &rndis_info,
Ole Andre Vadla Ravnasad55d712006-12-14 16:01:28 -0800621}, {
622 /* "ActiveSync" is an undocumented variant of RNDIS, used in WM5 */
623 USB_INTERFACE_INFO(USB_CLASS_MISC, 1, 1),
Ben Hutchings4d42d412011-04-13 14:48:55 -0700624 .driver_info = (unsigned long) &rndis_poll_status_info,
Thomas Backlund7e99eed2008-07-22 13:55:58 -0700625}, {
626 /* RNDIS for tethering */
627 USB_INTERFACE_INFO(USB_CLASS_WIRELESS_CONTROLLER, 1, 3),
628 .driver_info = (unsigned long) &rndis_info,
David Brownell64e04912005-08-31 09:54:36 -0700629},
630 { }, // END
631};
632MODULE_DEVICE_TABLE(usb, products);
633
634static struct usb_driver rndis_driver = {
David Brownell64e04912005-08-31 09:54:36 -0700635 .name = "rndis_host",
636 .id_table = products,
637 .probe = usbnet_probe,
638 .disconnect = usbnet_disconnect,
639 .suspend = usbnet_suspend,
640 .resume = usbnet_resume,
Sarah Sharpe1f12eb2012-04-23 10:08:51 -0700641 .disable_hub_initiated_lpm = 1,
David Brownell64e04912005-08-31 09:54:36 -0700642};
643
Greg Kroah-Hartmand632eb12011-11-18 09:44:20 -0800644module_usb_driver(rndis_driver);
David Brownell64e04912005-08-31 09:54:36 -0700645
646MODULE_AUTHOR("David Brownell");
647MODULE_DESCRIPTION("USB Host side RNDIS driver");
648MODULE_LICENSE("GPL");