Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/trivial
[linux-2.6.git] / drivers / usb / gadget / rndis.c
1 /*
2  * RNDIS MSG parser
3  *
4  * Authors:     Benedikt Spranger, Pengutronix
5  *              Robert Schwebel, Pengutronix
6  *
7  *              This program is free software; you can redistribute it and/or
8  *              modify it under the terms of the GNU General Public License
9  *              version 2, as published by the Free Software Foundation.
10  *
11  *              This software was originally developed in conformance with
12  *              Microsoft's Remote NDIS Specification License Agreement.
13  *
14  * 03/12/2004 Kai-Uwe Bloem <linux-development@auerswald.de>
15  *              Fixed message length bug in init_response
16  *
17  * 03/25/2004 Kai-Uwe Bloem <linux-development@auerswald.de>
18  *              Fixed rndis_rm_hdr length bug.
19  *
20  * Copyright (C) 2004 by David Brownell
21  *              updates to merge with Linux 2.6, better match RNDIS spec
22  */
23
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/kernel.h>
27 #include <linux/errno.h>
28 #include <linux/init.h>
29 #include <linux/list.h>
30 #include <linux/proc_fs.h>
31 #include <linux/slab.h>
32 #include <linux/seq_file.h>
33 #include <linux/netdevice.h>
34
35 #include <asm/io.h>
36 #include <asm/byteorder.h>
37 #include <asm/system.h>
38 #include <asm/unaligned.h>
39
40
41 #undef  VERBOSE_DEBUG
42
43 #include "rndis.h"
44
45
46 /* The driver for your USB chip needs to support ep0 OUT to work with
47  * RNDIS, plus all three CDC Ethernet endpoints (interrupt not optional).
48  *
49  * Windows hosts need an INF file like Documentation/usb/linux.inf
50  * and will be happier if you provide the host_addr module parameter.
51  */
52
53 #if 0
54 static int rndis_debug = 0;
55 module_param (rndis_debug, int, 0);
56 MODULE_PARM_DESC (rndis_debug, "enable debugging");
57 #else
58 #define rndis_debug             0
59 #endif
60
61 #define RNDIS_MAX_CONFIGS       1
62
63
64 static rndis_params rndis_per_dev_params[RNDIS_MAX_CONFIGS];
65
66 /* Driver Version */
67 static const __le32 rndis_driver_version = cpu_to_le32(1);
68
69 /* Function Prototypes */
70 static rndis_resp_t *rndis_add_response(int configNr, u32 length);
71
72
73 /* supported OIDs */
74 static const u32 oid_supported_list[] =
75 {
76         /* the general stuff */
77         OID_GEN_SUPPORTED_LIST,
78         OID_GEN_HARDWARE_STATUS,
79         OID_GEN_MEDIA_SUPPORTED,
80         OID_GEN_MEDIA_IN_USE,
81         OID_GEN_MAXIMUM_FRAME_SIZE,
82         OID_GEN_LINK_SPEED,
83         OID_GEN_TRANSMIT_BLOCK_SIZE,
84         OID_GEN_RECEIVE_BLOCK_SIZE,
85         OID_GEN_VENDOR_ID,
86         OID_GEN_VENDOR_DESCRIPTION,
87         OID_GEN_VENDOR_DRIVER_VERSION,
88         OID_GEN_CURRENT_PACKET_FILTER,
89         OID_GEN_MAXIMUM_TOTAL_SIZE,
90         OID_GEN_MEDIA_CONNECT_STATUS,
91         OID_GEN_PHYSICAL_MEDIUM,
92
93         /* the statistical stuff */
94         OID_GEN_XMIT_OK,
95         OID_GEN_RCV_OK,
96         OID_GEN_XMIT_ERROR,
97         OID_GEN_RCV_ERROR,
98         OID_GEN_RCV_NO_BUFFER,
99 #ifdef  RNDIS_OPTIONAL_STATS
100         OID_GEN_DIRECTED_BYTES_XMIT,
101         OID_GEN_DIRECTED_FRAMES_XMIT,
102         OID_GEN_MULTICAST_BYTES_XMIT,
103         OID_GEN_MULTICAST_FRAMES_XMIT,
104         OID_GEN_BROADCAST_BYTES_XMIT,
105         OID_GEN_BROADCAST_FRAMES_XMIT,
106         OID_GEN_DIRECTED_BYTES_RCV,
107         OID_GEN_DIRECTED_FRAMES_RCV,
108         OID_GEN_MULTICAST_BYTES_RCV,
109         OID_GEN_MULTICAST_FRAMES_RCV,
110         OID_GEN_BROADCAST_BYTES_RCV,
111         OID_GEN_BROADCAST_FRAMES_RCV,
112         OID_GEN_RCV_CRC_ERROR,
113         OID_GEN_TRANSMIT_QUEUE_LENGTH,
114 #endif  /* RNDIS_OPTIONAL_STATS */
115
116         /* mandatory 802.3 */
117         /* the general stuff */
118         OID_802_3_PERMANENT_ADDRESS,
119         OID_802_3_CURRENT_ADDRESS,
120         OID_802_3_MULTICAST_LIST,
121         OID_802_3_MAC_OPTIONS,
122         OID_802_3_MAXIMUM_LIST_SIZE,
123
124         /* the statistical stuff */
125         OID_802_3_RCV_ERROR_ALIGNMENT,
126         OID_802_3_XMIT_ONE_COLLISION,
127         OID_802_3_XMIT_MORE_COLLISIONS,
128 #ifdef  RNDIS_OPTIONAL_STATS
129         OID_802_3_XMIT_DEFERRED,
130         OID_802_3_XMIT_MAX_COLLISIONS,
131         OID_802_3_RCV_OVERRUN,
132         OID_802_3_XMIT_UNDERRUN,
133         OID_802_3_XMIT_HEARTBEAT_FAILURE,
134         OID_802_3_XMIT_TIMES_CRS_LOST,
135         OID_802_3_XMIT_LATE_COLLISIONS,
136 #endif  /* RNDIS_OPTIONAL_STATS */
137
138 #ifdef  RNDIS_PM
139         /* PM and wakeup are "mandatory" for USB, but the RNDIS specs
140          * don't say what they mean ... and the NDIS specs are often
141          * confusing and/or ambiguous in this context.  (That is, more
142          * so than their specs for the other OIDs.)
143          *
144          * FIXME someone who knows what these should do, please
145          * implement them!
146          */
147
148         /* power management */
149         OID_PNP_CAPABILITIES,
150         OID_PNP_QUERY_POWER,
151         OID_PNP_SET_POWER,
152
153 #ifdef  RNDIS_WAKEUP
154         /* wake up host */
155         OID_PNP_ENABLE_WAKE_UP,
156         OID_PNP_ADD_WAKE_UP_PATTERN,
157         OID_PNP_REMOVE_WAKE_UP_PATTERN,
158 #endif  /* RNDIS_WAKEUP */
159 #endif  /* RNDIS_PM */
160 };
161
162
163 /* NDIS Functions */
164 static int gen_ndis_query_resp(int configNr, u32 OID, u8 *buf,
165                                unsigned buf_len, rndis_resp_t *r)
166 {
167         int retval = -ENOTSUPP;
168         u32 length = 4; /* usually */
169         __le32 *outbuf;
170         int i, count;
171         rndis_query_cmplt_type *resp;
172         struct net_device *net;
173         struct rtnl_link_stats64 temp;
174         const struct rtnl_link_stats64 *stats;
175
176         if (!r) return -ENOMEM;
177         resp = (rndis_query_cmplt_type *)r->buf;
178
179         if (!resp) return -ENOMEM;
180
181         if (buf_len && rndis_debug > 1) {
182                 pr_debug("query OID %08x value, len %d:\n", OID, buf_len);
183                 for (i = 0; i < buf_len; i += 16) {
184                         pr_debug("%03d: %08x %08x %08x %08x\n", i,
185                                 get_unaligned_le32(&buf[i]),
186                                 get_unaligned_le32(&buf[i + 4]),
187                                 get_unaligned_le32(&buf[i + 8]),
188                                 get_unaligned_le32(&buf[i + 12]));
189                 }
190         }
191
192         /* response goes here, right after the header */
193         outbuf = (__le32 *)&resp[1];
194         resp->InformationBufferOffset = cpu_to_le32(16);
195
196         net = rndis_per_dev_params[configNr].dev;
197         stats = dev_get_stats(net, &temp);
198
199         switch (OID) {
200
201         /* general oids (table 4-1) */
202
203         /* mandatory */
204         case OID_GEN_SUPPORTED_LIST:
205                 pr_debug("%s: OID_GEN_SUPPORTED_LIST\n", __func__);
206                 length = sizeof(oid_supported_list);
207                 count  = length / sizeof(u32);
208                 for (i = 0; i < count; i++)
209                         outbuf[i] = cpu_to_le32(oid_supported_list[i]);
210                 retval = 0;
211                 break;
212
213         /* mandatory */
214         case OID_GEN_HARDWARE_STATUS:
215                 pr_debug("%s: OID_GEN_HARDWARE_STATUS\n", __func__);
216                 /* Bogus question!
217                  * Hardware must be ready to receive high level protocols.
218                  * BTW:
219                  * reddite ergo quae sunt Caesaris Caesari
220                  * et quae sunt Dei Deo!
221                  */
222                 *outbuf = cpu_to_le32(0);
223                 retval = 0;
224                 break;
225
226         /* mandatory */
227         case OID_GEN_MEDIA_SUPPORTED:
228                 pr_debug("%s: OID_GEN_MEDIA_SUPPORTED\n", __func__);
229                 *outbuf = cpu_to_le32(rndis_per_dev_params[configNr].medium);
230                 retval = 0;
231                 break;
232
233         /* mandatory */
234         case OID_GEN_MEDIA_IN_USE:
235                 pr_debug("%s: OID_GEN_MEDIA_IN_USE\n", __func__);
236                 /* one medium, one transport... (maybe you do it better) */
237                 *outbuf = cpu_to_le32(rndis_per_dev_params[configNr].medium);
238                 retval = 0;
239                 break;
240
241         /* mandatory */
242         case OID_GEN_MAXIMUM_FRAME_SIZE:
243                 pr_debug("%s: OID_GEN_MAXIMUM_FRAME_SIZE\n", __func__);
244                 if (rndis_per_dev_params[configNr].dev) {
245                         *outbuf = cpu_to_le32(
246                                 rndis_per_dev_params[configNr].dev->mtu);
247                         retval = 0;
248                 }
249                 break;
250
251         /* mandatory */
252         case OID_GEN_LINK_SPEED:
253                 if (rndis_debug > 1)
254                         pr_debug("%s: OID_GEN_LINK_SPEED\n", __func__);
255                 if (rndis_per_dev_params[configNr].media_state
256                                 == NDIS_MEDIA_STATE_DISCONNECTED)
257                         *outbuf = cpu_to_le32(0);
258                 else
259                         *outbuf = cpu_to_le32(
260                                 rndis_per_dev_params[configNr].speed);
261                 retval = 0;
262                 break;
263
264         /* mandatory */
265         case OID_GEN_TRANSMIT_BLOCK_SIZE:
266                 pr_debug("%s: OID_GEN_TRANSMIT_BLOCK_SIZE\n", __func__);
267                 if (rndis_per_dev_params[configNr].dev) {
268                         *outbuf = cpu_to_le32(
269                                 rndis_per_dev_params[configNr].dev->mtu);
270                         retval = 0;
271                 }
272                 break;
273
274         /* mandatory */
275         case OID_GEN_RECEIVE_BLOCK_SIZE:
276                 pr_debug("%s: OID_GEN_RECEIVE_BLOCK_SIZE\n", __func__);
277                 if (rndis_per_dev_params[configNr].dev) {
278                         *outbuf = cpu_to_le32(
279                                 rndis_per_dev_params[configNr].dev->mtu);
280                         retval = 0;
281                 }
282                 break;
283
284         /* mandatory */
285         case OID_GEN_VENDOR_ID:
286                 pr_debug("%s: OID_GEN_VENDOR_ID\n", __func__);
287                 *outbuf = cpu_to_le32(
288                         rndis_per_dev_params[configNr].vendorID);
289                 retval = 0;
290                 break;
291
292         /* mandatory */
293         case OID_GEN_VENDOR_DESCRIPTION:
294                 pr_debug("%s: OID_GEN_VENDOR_DESCRIPTION\n", __func__);
295                 if (rndis_per_dev_params[configNr].vendorDescr) {
296                         length = strlen(rndis_per_dev_params[configNr].
297                                         vendorDescr);
298                         memcpy(outbuf,
299                                 rndis_per_dev_params[configNr].vendorDescr,
300                                 length);
301                 } else {
302                         outbuf[0] = 0;
303                 }
304                 retval = 0;
305                 break;
306
307         case OID_GEN_VENDOR_DRIVER_VERSION:
308                 pr_debug("%s: OID_GEN_VENDOR_DRIVER_VERSION\n", __func__);
309                 /* Created as LE */
310                 *outbuf = rndis_driver_version;
311                 retval = 0;
312                 break;
313
314         /* mandatory */
315         case OID_GEN_CURRENT_PACKET_FILTER:
316                 pr_debug("%s: OID_GEN_CURRENT_PACKET_FILTER\n", __func__);
317                 *outbuf = cpu_to_le32(*rndis_per_dev_params[configNr].filter);
318                 retval = 0;
319                 break;
320
321         /* mandatory */
322         case OID_GEN_MAXIMUM_TOTAL_SIZE:
323                 pr_debug("%s: OID_GEN_MAXIMUM_TOTAL_SIZE\n", __func__);
324                 *outbuf = cpu_to_le32(RNDIS_MAX_TOTAL_SIZE);
325                 retval = 0;
326                 break;
327
328         /* mandatory */
329         case OID_GEN_MEDIA_CONNECT_STATUS:
330                 if (rndis_debug > 1)
331                         pr_debug("%s: OID_GEN_MEDIA_CONNECT_STATUS\n", __func__);
332                 *outbuf = cpu_to_le32(rndis_per_dev_params[configNr]
333                                                 .media_state);
334                 retval = 0;
335                 break;
336
337         case OID_GEN_PHYSICAL_MEDIUM:
338                 pr_debug("%s: OID_GEN_PHYSICAL_MEDIUM\n", __func__);
339                 *outbuf = cpu_to_le32(0);
340                 retval = 0;
341                 break;
342
343         /* The RNDIS specification is incomplete/wrong.   Some versions
344          * of MS-Windows expect OIDs that aren't specified there.  Other
345          * versions emit undefined RNDIS messages. DOCUMENT ALL THESE!
346          */
347         case OID_GEN_MAC_OPTIONS:               /* from WinME */
348                 pr_debug("%s: OID_GEN_MAC_OPTIONS\n", __func__);
349                 *outbuf = cpu_to_le32(
350                           NDIS_MAC_OPTION_RECEIVE_SERIALIZED
351                         | NDIS_MAC_OPTION_FULL_DUPLEX);
352                 retval = 0;
353                 break;
354
355         /* statistics OIDs (table 4-2) */
356
357         /* mandatory */
358         case OID_GEN_XMIT_OK:
359                 if (rndis_debug > 1)
360                         pr_debug("%s: OID_GEN_XMIT_OK\n", __func__);
361                 if (stats) {
362                         *outbuf = cpu_to_le32(stats->tx_packets
363                                 - stats->tx_errors - stats->tx_dropped);
364                         retval = 0;
365                 }
366                 break;
367
368         /* mandatory */
369         case OID_GEN_RCV_OK:
370                 if (rndis_debug > 1)
371                         pr_debug("%s: OID_GEN_RCV_OK\n", __func__);
372                 if (stats) {
373                         *outbuf = cpu_to_le32(stats->rx_packets
374                                 - stats->rx_errors - stats->rx_dropped);
375                         retval = 0;
376                 }
377                 break;
378
379         /* mandatory */
380         case OID_GEN_XMIT_ERROR:
381                 if (rndis_debug > 1)
382                         pr_debug("%s: OID_GEN_XMIT_ERROR\n", __func__);
383                 if (stats) {
384                         *outbuf = cpu_to_le32(stats->tx_errors);
385                         retval = 0;
386                 }
387                 break;
388
389         /* mandatory */
390         case OID_GEN_RCV_ERROR:
391                 if (rndis_debug > 1)
392                         pr_debug("%s: OID_GEN_RCV_ERROR\n", __func__);
393                 if (stats) {
394                         *outbuf = cpu_to_le32(stats->rx_errors);
395                         retval = 0;
396                 }
397                 break;
398
399         /* mandatory */
400         case OID_GEN_RCV_NO_BUFFER:
401                 pr_debug("%s: OID_GEN_RCV_NO_BUFFER\n", __func__);
402                 if (stats) {
403                         *outbuf = cpu_to_le32(stats->rx_dropped);
404                         retval = 0;
405                 }
406                 break;
407
408         /* ieee802.3 OIDs (table 4-3) */
409
410         /* mandatory */
411         case OID_802_3_PERMANENT_ADDRESS:
412                 pr_debug("%s: OID_802_3_PERMANENT_ADDRESS\n", __func__);
413                 if (rndis_per_dev_params[configNr].dev) {
414                         length = ETH_ALEN;
415                         memcpy(outbuf,
416                                 rndis_per_dev_params[configNr].host_mac,
417                                 length);
418                         retval = 0;
419                 }
420                 break;
421
422         /* mandatory */
423         case OID_802_3_CURRENT_ADDRESS:
424                 pr_debug("%s: OID_802_3_CURRENT_ADDRESS\n", __func__);
425                 if (rndis_per_dev_params[configNr].dev) {
426                         length = ETH_ALEN;
427                         memcpy(outbuf,
428                                 rndis_per_dev_params [configNr].host_mac,
429                                 length);
430                         retval = 0;
431                 }
432                 break;
433
434         /* mandatory */
435         case OID_802_3_MULTICAST_LIST:
436                 pr_debug("%s: OID_802_3_MULTICAST_LIST\n", __func__);
437                 /* Multicast base address only */
438                 *outbuf = cpu_to_le32(0xE0000000);
439                 retval = 0;
440                 break;
441
442         /* mandatory */
443         case OID_802_3_MAXIMUM_LIST_SIZE:
444                 pr_debug("%s: OID_802_3_MAXIMUM_LIST_SIZE\n", __func__);
445                 /* Multicast base address only */
446                 *outbuf = cpu_to_le32(1);
447                 retval = 0;
448                 break;
449
450         case OID_802_3_MAC_OPTIONS:
451                 pr_debug("%s: OID_802_3_MAC_OPTIONS\n", __func__);
452                 *outbuf = cpu_to_le32(0);
453                 retval = 0;
454                 break;
455
456         /* ieee802.3 statistics OIDs (table 4-4) */
457
458         /* mandatory */
459         case OID_802_3_RCV_ERROR_ALIGNMENT:
460                 pr_debug("%s: OID_802_3_RCV_ERROR_ALIGNMENT\n", __func__);
461                 if (stats) {
462                         *outbuf = cpu_to_le32(stats->rx_frame_errors);
463                         retval = 0;
464                 }
465                 break;
466
467         /* mandatory */
468         case OID_802_3_XMIT_ONE_COLLISION:
469                 pr_debug("%s: OID_802_3_XMIT_ONE_COLLISION\n", __func__);
470                 *outbuf = cpu_to_le32(0);
471                 retval = 0;
472                 break;
473
474         /* mandatory */
475         case OID_802_3_XMIT_MORE_COLLISIONS:
476                 pr_debug("%s: OID_802_3_XMIT_MORE_COLLISIONS\n", __func__);
477                 *outbuf = cpu_to_le32(0);
478                 retval = 0;
479                 break;
480
481         default:
482                 pr_warning("%s: query unknown OID 0x%08X\n",
483                          __func__, OID);
484         }
485         if (retval < 0)
486                 length = 0;
487
488         resp->InformationBufferLength = cpu_to_le32(length);
489         r->length = length + sizeof(*resp);
490         resp->MessageLength = cpu_to_le32(r->length);
491         return retval;
492 }
493
494 static int gen_ndis_set_resp(u8 configNr, u32 OID, u8 *buf, u32 buf_len,
495                              rndis_resp_t *r)
496 {
497         rndis_set_cmplt_type *resp;
498         int i, retval = -ENOTSUPP;
499         struct rndis_params *params;
500
501         if (!r)
502                 return -ENOMEM;
503         resp = (rndis_set_cmplt_type *)r->buf;
504         if (!resp)
505                 return -ENOMEM;
506
507         if (buf_len && rndis_debug > 1) {
508                 pr_debug("set OID %08x value, len %d:\n", OID, buf_len);
509                 for (i = 0; i < buf_len; i += 16) {
510                         pr_debug("%03d: %08x %08x %08x %08x\n", i,
511                                 get_unaligned_le32(&buf[i]),
512                                 get_unaligned_le32(&buf[i + 4]),
513                                 get_unaligned_le32(&buf[i + 8]),
514                                 get_unaligned_le32(&buf[i + 12]));
515                 }
516         }
517
518         params = &rndis_per_dev_params[configNr];
519         switch (OID) {
520         case OID_GEN_CURRENT_PACKET_FILTER:
521
522                 /* these NDIS_PACKET_TYPE_* bitflags are shared with
523                  * cdc_filter; it's not RNDIS-specific
524                  * NDIS_PACKET_TYPE_x == USB_CDC_PACKET_TYPE_x for x in:
525                  *      PROMISCUOUS, DIRECTED,
526                  *      MULTICAST, ALL_MULTICAST, BROADCAST
527                  */
528                 *params->filter = (u16)get_unaligned_le32(buf);
529                 pr_debug("%s: OID_GEN_CURRENT_PACKET_FILTER %08x\n",
530                         __func__, *params->filter);
531
532                 /* this call has a significant side effect:  it's
533                  * what makes the packet flow start and stop, like
534                  * activating the CDC Ethernet altsetting.
535                  */
536                 retval = 0;
537                 if (*params->filter) {
538                         params->state = RNDIS_DATA_INITIALIZED;
539                         netif_carrier_on(params->dev);
540                         if (netif_running(params->dev))
541                                 netif_wake_queue(params->dev);
542                 } else {
543                         params->state = RNDIS_INITIALIZED;
544                         netif_carrier_off(params->dev);
545                         netif_stop_queue(params->dev);
546                 }
547                 break;
548
549         case OID_802_3_MULTICAST_LIST:
550                 /* I think we can ignore this */
551                 pr_debug("%s: OID_802_3_MULTICAST_LIST\n", __func__);
552                 retval = 0;
553                 break;
554
555         default:
556                 pr_warning("%s: set unknown OID 0x%08X, size %d\n",
557                          __func__, OID, buf_len);
558         }
559
560         return retval;
561 }
562
563 /*
564  * Response Functions
565  */
566
567 static int rndis_init_response(int configNr, rndis_init_msg_type *buf)
568 {
569         rndis_init_cmplt_type *resp;
570         rndis_resp_t *r;
571         struct rndis_params *params = rndis_per_dev_params + configNr;
572
573         if (!params->dev)
574                 return -ENOTSUPP;
575
576         r = rndis_add_response(configNr, sizeof(rndis_init_cmplt_type));
577         if (!r)
578                 return -ENOMEM;
579         resp = (rndis_init_cmplt_type *)r->buf;
580
581         resp->MessageType = cpu_to_le32(REMOTE_NDIS_INITIALIZE_CMPLT);
582         resp->MessageLength = cpu_to_le32(52);
583         resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
584         resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);
585         resp->MajorVersion = cpu_to_le32(RNDIS_MAJOR_VERSION);
586         resp->MinorVersion = cpu_to_le32(RNDIS_MINOR_VERSION);
587         resp->DeviceFlags = cpu_to_le32(RNDIS_DF_CONNECTIONLESS);
588         resp->Medium = cpu_to_le32(RNDIS_MEDIUM_802_3);
589         resp->MaxPacketsPerTransfer = cpu_to_le32(1);
590         resp->MaxTransferSize = cpu_to_le32(
591                   params->dev->mtu
592                 + sizeof(struct ethhdr)
593                 + sizeof(struct rndis_packet_msg_type)
594                 + 22);
595         resp->PacketAlignmentFactor = cpu_to_le32(0);
596         resp->AFListOffset = cpu_to_le32(0);
597         resp->AFListSize = cpu_to_le32(0);
598
599         params->resp_avail(params->v);
600         return 0;
601 }
602
603 static int rndis_query_response(int configNr, rndis_query_msg_type *buf)
604 {
605         rndis_query_cmplt_type *resp;
606         rndis_resp_t *r;
607         struct rndis_params *params = rndis_per_dev_params + configNr;
608
609         /* pr_debug("%s: OID = %08X\n", __func__, cpu_to_le32(buf->OID)); */
610         if (!params->dev)
611                 return -ENOTSUPP;
612
613         /*
614          * we need more memory:
615          * gen_ndis_query_resp expects enough space for
616          * rndis_query_cmplt_type followed by data.
617          * oid_supported_list is the largest data reply
618          */
619         r = rndis_add_response(configNr,
620                 sizeof(oid_supported_list) + sizeof(rndis_query_cmplt_type));
621         if (!r)
622                 return -ENOMEM;
623         resp = (rndis_query_cmplt_type *)r->buf;
624
625         resp->MessageType = cpu_to_le32(REMOTE_NDIS_QUERY_CMPLT);
626         resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
627
628         if (gen_ndis_query_resp(configNr, le32_to_cpu(buf->OID),
629                         le32_to_cpu(buf->InformationBufferOffset)
630                                         + 8 + (u8 *)buf,
631                         le32_to_cpu(buf->InformationBufferLength),
632                         r)) {
633                 /* OID not supported */
634                 resp->Status = cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED);
635                 resp->MessageLength = cpu_to_le32(sizeof *resp);
636                 resp->InformationBufferLength = cpu_to_le32(0);
637                 resp->InformationBufferOffset = cpu_to_le32(0);
638         } else
639                 resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);
640
641         params->resp_avail(params->v);
642         return 0;
643 }
644
645 static int rndis_set_response(int configNr, rndis_set_msg_type *buf)
646 {
647         u32 BufLength, BufOffset;
648         rndis_set_cmplt_type *resp;
649         rndis_resp_t *r;
650         struct rndis_params *params = rndis_per_dev_params + configNr;
651
652         r = rndis_add_response(configNr, sizeof(rndis_set_cmplt_type));
653         if (!r)
654                 return -ENOMEM;
655         resp = (rndis_set_cmplt_type *)r->buf;
656
657         BufLength = le32_to_cpu(buf->InformationBufferLength);
658         BufOffset = le32_to_cpu(buf->InformationBufferOffset);
659
660 #ifdef  VERBOSE_DEBUG
661         pr_debug("%s: Length: %d\n", __func__, BufLength);
662         pr_debug("%s: Offset: %d\n", __func__, BufOffset);
663         pr_debug("%s: InfoBuffer: ", __func__);
664
665         for (i = 0; i < BufLength; i++) {
666                 pr_debug("%02x ", *(((u8 *) buf) + i + 8 + BufOffset));
667         }
668
669         pr_debug("\n");
670 #endif
671
672         resp->MessageType = cpu_to_le32(REMOTE_NDIS_SET_CMPLT);
673         resp->MessageLength = cpu_to_le32(16);
674         resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
675         if (gen_ndis_set_resp(configNr, le32_to_cpu(buf->OID),
676                         ((u8 *)buf) + 8 + BufOffset, BufLength, r))
677                 resp->Status = cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED);
678         else
679                 resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);
680
681         params->resp_avail(params->v);
682         return 0;
683 }
684
685 static int rndis_reset_response(int configNr, rndis_reset_msg_type *buf)
686 {
687         rndis_reset_cmplt_type *resp;
688         rndis_resp_t *r;
689         struct rndis_params *params = rndis_per_dev_params + configNr;
690
691         r = rndis_add_response(configNr, sizeof(rndis_reset_cmplt_type));
692         if (!r)
693                 return -ENOMEM;
694         resp = (rndis_reset_cmplt_type *)r->buf;
695
696         resp->MessageType = cpu_to_le32(REMOTE_NDIS_RESET_CMPLT);
697         resp->MessageLength = cpu_to_le32(16);
698         resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);
699         /* resent information */
700         resp->AddressingReset = cpu_to_le32(1);
701
702         params->resp_avail(params->v);
703         return 0;
704 }
705
706 static int rndis_keepalive_response(int configNr,
707                                     rndis_keepalive_msg_type *buf)
708 {
709         rndis_keepalive_cmplt_type *resp;
710         rndis_resp_t *r;
711         struct rndis_params *params = rndis_per_dev_params + configNr;
712
713         /* host "should" check only in RNDIS_DATA_INITIALIZED state */
714
715         r = rndis_add_response(configNr, sizeof(rndis_keepalive_cmplt_type));
716         if (!r)
717                 return -ENOMEM;
718         resp = (rndis_keepalive_cmplt_type *)r->buf;
719
720         resp->MessageType = cpu_to_le32(
721                         REMOTE_NDIS_KEEPALIVE_CMPLT);
722         resp->MessageLength = cpu_to_le32(16);
723         resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
724         resp->Status = cpu_to_le32(RNDIS_STATUS_SUCCESS);
725
726         params->resp_avail(params->v);
727         return 0;
728 }
729
730
731 /*
732  * Device to Host Comunication
733  */
734 static int rndis_indicate_status_msg(int configNr, u32 status)
735 {
736         rndis_indicate_status_msg_type *resp;
737         rndis_resp_t *r;
738         struct rndis_params *params = rndis_per_dev_params + configNr;
739
740         if (params->state == RNDIS_UNINITIALIZED)
741                 return -ENOTSUPP;
742
743         r = rndis_add_response(configNr,
744                                 sizeof(rndis_indicate_status_msg_type));
745         if (!r)
746                 return -ENOMEM;
747         resp = (rndis_indicate_status_msg_type *)r->buf;
748
749         resp->MessageType = cpu_to_le32(REMOTE_NDIS_INDICATE_STATUS_MSG);
750         resp->MessageLength = cpu_to_le32(20);
751         resp->Status = cpu_to_le32(status);
752         resp->StatusBufferLength = cpu_to_le32(0);
753         resp->StatusBufferOffset = cpu_to_le32(0);
754
755         params->resp_avail(params->v);
756         return 0;
757 }
758
759 int rndis_signal_connect(int configNr)
760 {
761         rndis_per_dev_params[configNr].media_state
762                         = NDIS_MEDIA_STATE_CONNECTED;
763         return rndis_indicate_status_msg(configNr,
764                                           RNDIS_STATUS_MEDIA_CONNECT);
765 }
766
767 int rndis_signal_disconnect(int configNr)
768 {
769         rndis_per_dev_params[configNr].media_state
770                         = NDIS_MEDIA_STATE_DISCONNECTED;
771         return rndis_indicate_status_msg(configNr,
772                                           RNDIS_STATUS_MEDIA_DISCONNECT);
773 }
774
775 void rndis_uninit(int configNr)
776 {
777         u8 *buf;
778         u32 length;
779
780         if (configNr >= RNDIS_MAX_CONFIGS)
781                 return;
782         rndis_per_dev_params[configNr].state = RNDIS_UNINITIALIZED;
783
784         /* drain the response queue */
785         while ((buf = rndis_get_next_response(configNr, &length)))
786                 rndis_free_response(configNr, buf);
787 }
788
789 void rndis_set_host_mac(int configNr, const u8 *addr)
790 {
791         rndis_per_dev_params[configNr].host_mac = addr;
792 }
793
794 /*
795  * Message Parser
796  */
797 int rndis_msg_parser(u8 configNr, u8 *buf)
798 {
799         u32 MsgType, MsgLength;
800         __le32 *tmp;
801         struct rndis_params *params;
802
803         if (!buf)
804                 return -ENOMEM;
805
806         tmp = (__le32 *)buf;
807         MsgType   = get_unaligned_le32(tmp++);
808         MsgLength = get_unaligned_le32(tmp++);
809
810         if (configNr >= RNDIS_MAX_CONFIGS)
811                 return -ENOTSUPP;
812         params = &rndis_per_dev_params[configNr];
813
814         /* NOTE: RNDIS is *EXTREMELY* chatty ... Windows constantly polls for
815          * rx/tx statistics and link status, in addition to KEEPALIVE traffic
816          * and normal HC level polling to see if there's any IN traffic.
817          */
818
819         /* For USB: responses may take up to 10 seconds */
820         switch (MsgType) {
821         case REMOTE_NDIS_INITIALIZE_MSG:
822                 pr_debug("%s: REMOTE_NDIS_INITIALIZE_MSG\n",
823                         __func__);
824                 params->state = RNDIS_INITIALIZED;
825                 return rndis_init_response(configNr,
826                                         (rndis_init_msg_type *)buf);
827
828         case REMOTE_NDIS_HALT_MSG:
829                 pr_debug("%s: REMOTE_NDIS_HALT_MSG\n",
830                         __func__);
831                 params->state = RNDIS_UNINITIALIZED;
832                 if (params->dev) {
833                         netif_carrier_off(params->dev);
834                         netif_stop_queue(params->dev);
835                 }
836                 return 0;
837
838         case REMOTE_NDIS_QUERY_MSG:
839                 return rndis_query_response(configNr,
840                                         (rndis_query_msg_type *)buf);
841
842         case REMOTE_NDIS_SET_MSG:
843                 return rndis_set_response(configNr,
844                                         (rndis_set_msg_type *)buf);
845
846         case REMOTE_NDIS_RESET_MSG:
847                 pr_debug("%s: REMOTE_NDIS_RESET_MSG\n",
848                         __func__);
849                 return rndis_reset_response(configNr,
850                                         (rndis_reset_msg_type *)buf);
851
852         case REMOTE_NDIS_KEEPALIVE_MSG:
853                 /* For USB: host does this every 5 seconds */
854                 if (rndis_debug > 1)
855                         pr_debug("%s: REMOTE_NDIS_KEEPALIVE_MSG\n",
856                                 __func__);
857                 return rndis_keepalive_response(configNr,
858                                                  (rndis_keepalive_msg_type *)
859                                                  buf);
860
861         default:
862                 /* At least Windows XP emits some undefined RNDIS messages.
863                  * In one case those messages seemed to relate to the host
864                  * suspending itself.
865                  */
866                 pr_warning("%s: unknown RNDIS message 0x%08X len %d\n",
867                         __func__, MsgType, MsgLength);
868                 {
869                         unsigned i;
870                         for (i = 0; i < MsgLength; i += 16) {
871                                 pr_debug("%03d: "
872                                         " %02x %02x %02x %02x"
873                                         " %02x %02x %02x %02x"
874                                         " %02x %02x %02x %02x"
875                                         " %02x %02x %02x %02x"
876                                         "\n",
877                                         i,
878                                         buf[i], buf [i+1],
879                                                 buf[i+2], buf[i+3],
880                                         buf[i+4], buf [i+5],
881                                                 buf[i+6], buf[i+7],
882                                         buf[i+8], buf [i+9],
883                                                 buf[i+10], buf[i+11],
884                                         buf[i+12], buf [i+13],
885                                                 buf[i+14], buf[i+15]);
886                         }
887                 }
888                 break;
889         }
890
891         return -ENOTSUPP;
892 }
893
894 int rndis_register(void (*resp_avail)(void *v), void *v)
895 {
896         u8 i;
897
898         if (!resp_avail)
899                 return -EINVAL;
900
901         for (i = 0; i < RNDIS_MAX_CONFIGS; i++) {
902                 if (!rndis_per_dev_params[i].used) {
903                         rndis_per_dev_params[i].used = 1;
904                         rndis_per_dev_params[i].resp_avail = resp_avail;
905                         rndis_per_dev_params[i].v = v;
906                         pr_debug("%s: configNr = %d\n", __func__, i);
907                         return i;
908                 }
909         }
910         pr_debug("failed\n");
911
912         return -ENODEV;
913 }
914
915 void rndis_deregister(int configNr)
916 {
917         pr_debug("%s:\n", __func__);
918
919         if (configNr >= RNDIS_MAX_CONFIGS) return;
920         rndis_per_dev_params[configNr].used = 0;
921 }
922
923 int rndis_set_param_dev(u8 configNr, struct net_device *dev, u16 *cdc_filter)
924 {
925         pr_debug("%s:\n", __func__);
926         if (!dev)
927                 return -EINVAL;
928         if (configNr >= RNDIS_MAX_CONFIGS) return -1;
929
930         rndis_per_dev_params[configNr].dev = dev;
931         rndis_per_dev_params[configNr].filter = cdc_filter;
932
933         return 0;
934 }
935
936 int rndis_set_param_vendor(u8 configNr, u32 vendorID, const char *vendorDescr)
937 {
938         pr_debug("%s:\n", __func__);
939         if (!vendorDescr) return -1;
940         if (configNr >= RNDIS_MAX_CONFIGS) return -1;
941
942         rndis_per_dev_params[configNr].vendorID = vendorID;
943         rndis_per_dev_params[configNr].vendorDescr = vendorDescr;
944
945         return 0;
946 }
947
948 int rndis_set_param_medium(u8 configNr, u32 medium, u32 speed)
949 {
950         pr_debug("%s: %u %u\n", __func__, medium, speed);
951         if (configNr >= RNDIS_MAX_CONFIGS) return -1;
952
953         rndis_per_dev_params[configNr].medium = medium;
954         rndis_per_dev_params[configNr].speed = speed;
955
956         return 0;
957 }
958
959 void rndis_add_hdr(struct sk_buff *skb)
960 {
961         struct rndis_packet_msg_type *header;
962
963         if (!skb)
964                 return;
965         header = (void *)skb_push(skb, sizeof(*header));
966         memset(header, 0, sizeof *header);
967         header->MessageType = cpu_to_le32(REMOTE_NDIS_PACKET_MSG);
968         header->MessageLength = cpu_to_le32(skb->len);
969         header->DataOffset = cpu_to_le32(36);
970         header->DataLength = cpu_to_le32(skb->len - sizeof(*header));
971 }
972
973 void rndis_free_response(int configNr, u8 *buf)
974 {
975         rndis_resp_t *r;
976         struct list_head *act, *tmp;
977
978         list_for_each_safe(act, tmp,
979                         &(rndis_per_dev_params[configNr].resp_queue))
980         {
981                 r = list_entry(act, rndis_resp_t, list);
982                 if (r && r->buf == buf) {
983                         list_del(&r->list);
984                         kfree(r);
985                 }
986         }
987 }
988
989 u8 *rndis_get_next_response(int configNr, u32 *length)
990 {
991         rndis_resp_t *r;
992         struct list_head *act, *tmp;
993
994         if (!length) return NULL;
995
996         list_for_each_safe(act, tmp,
997                         &(rndis_per_dev_params[configNr].resp_queue))
998         {
999                 r = list_entry(act, rndis_resp_t, list);
1000                 if (!r->send) {
1001                         r->send = 1;
1002                         *length = r->length;
1003                         return r->buf;
1004                 }
1005         }
1006
1007         return NULL;
1008 }
1009
1010 static rndis_resp_t *rndis_add_response(int configNr, u32 length)
1011 {
1012         rndis_resp_t *r;
1013
1014         /* NOTE: this gets copied into ether.c USB_BUFSIZ bytes ... */
1015         r = kmalloc(sizeof(rndis_resp_t) + length, GFP_ATOMIC);
1016         if (!r) return NULL;
1017
1018         r->buf = (u8 *)(r + 1);
1019         r->length = length;
1020         r->send = 0;
1021
1022         list_add_tail(&r->list,
1023                 &(rndis_per_dev_params[configNr].resp_queue));
1024         return r;
1025 }
1026
1027 int rndis_rm_hdr(struct gether *port,
1028                         struct sk_buff *skb,
1029                         struct sk_buff_head *list)
1030 {
1031         /* tmp points to a struct rndis_packet_msg_type */
1032         __le32 *tmp = (void *)skb->data;
1033
1034         /* MessageType, MessageLength */
1035         if (cpu_to_le32(REMOTE_NDIS_PACKET_MSG)
1036                         != get_unaligned(tmp++)) {
1037                 dev_kfree_skb_any(skb);
1038                 return -EINVAL;
1039         }
1040         tmp++;
1041
1042         /* DataOffset, DataLength */
1043         if (!skb_pull(skb, get_unaligned_le32(tmp++) + 8)) {
1044                 dev_kfree_skb_any(skb);
1045                 return -EOVERFLOW;
1046         }
1047         skb_trim(skb, get_unaligned_le32(tmp++));
1048
1049         skb_queue_tail(list, skb);
1050         return 0;
1051 }
1052
1053 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
1054
1055 static int rndis_proc_show(struct seq_file *m, void *v)
1056 {
1057         rndis_params *param = m->private;
1058
1059         seq_printf(m,
1060                          "Config Nr. %d\n"
1061                          "used      : %s\n"
1062                          "state     : %s\n"
1063                          "medium    : 0x%08X\n"
1064                          "speed     : %d\n"
1065                          "cable     : %s\n"
1066                          "vendor ID : 0x%08X\n"
1067                          "vendor    : %s\n",
1068                          param->confignr, (param->used) ? "y" : "n",
1069                          ({ char *s = "?";
1070                          switch (param->state) {
1071                          case RNDIS_UNINITIALIZED:
1072                                 s = "RNDIS_UNINITIALIZED"; break;
1073                          case RNDIS_INITIALIZED:
1074                                 s = "RNDIS_INITIALIZED"; break;
1075                          case RNDIS_DATA_INITIALIZED:
1076                                 s = "RNDIS_DATA_INITIALIZED"; break;
1077                         }; s; }),
1078                          param->medium,
1079                          (param->media_state) ? 0 : param->speed*100,
1080                          (param->media_state) ? "disconnected" : "connected",
1081                          param->vendorID, param->vendorDescr);
1082         return 0;
1083 }
1084
1085 static ssize_t rndis_proc_write(struct file *file, const char __user *buffer,
1086                                 size_t count, loff_t *ppos)
1087 {
1088         rndis_params *p = PDE(file->f_path.dentry->d_inode)->data;
1089         u32 speed = 0;
1090         int i, fl_speed = 0;
1091
1092         for (i = 0; i < count; i++) {
1093                 char c;
1094                 if (get_user(c, buffer))
1095                         return -EFAULT;
1096                 switch (c) {
1097                 case '0':
1098                 case '1':
1099                 case '2':
1100                 case '3':
1101                 case '4':
1102                 case '5':
1103                 case '6':
1104                 case '7':
1105                 case '8':
1106                 case '9':
1107                         fl_speed = 1;
1108                         speed = speed * 10 + c - '0';
1109                         break;
1110                 case 'C':
1111                 case 'c':
1112                         rndis_signal_connect(p->confignr);
1113                         break;
1114                 case 'D':
1115                 case 'd':
1116                         rndis_signal_disconnect(p->confignr);
1117                         break;
1118                 default:
1119                         if (fl_speed) p->speed = speed;
1120                         else pr_debug("%c is not valid\n", c);
1121                         break;
1122                 }
1123
1124                 buffer++;
1125         }
1126
1127         return count;
1128 }
1129
1130 static int rndis_proc_open(struct inode *inode, struct file *file)
1131 {
1132         return single_open(file, rndis_proc_show, PDE(inode)->data);
1133 }
1134
1135 static const struct file_operations rndis_proc_fops = {
1136         .owner          = THIS_MODULE,
1137         .open           = rndis_proc_open,
1138         .read           = seq_read,
1139         .llseek         = seq_lseek,
1140         .release        = single_release,
1141         .write          = rndis_proc_write,
1142 };
1143
1144 #define NAME_TEMPLATE "driver/rndis-%03d"
1145
1146 static struct proc_dir_entry *rndis_connect_state [RNDIS_MAX_CONFIGS];
1147
1148 #endif /* CONFIG_USB_GADGET_DEBUG_FILES */
1149
1150
1151 int rndis_init(void)
1152 {
1153         u8 i;
1154
1155         for (i = 0; i < RNDIS_MAX_CONFIGS; i++) {
1156 #ifdef  CONFIG_USB_GADGET_DEBUG_FILES
1157                 char name [20];
1158
1159                 sprintf(name, NAME_TEMPLATE, i);
1160                 rndis_connect_state[i] = proc_create_data(name, 0660, NULL,
1161                                         &rndis_proc_fops,
1162                                         (void *)(rndis_per_dev_params + i));
1163                 if (!rndis_connect_state[i]) {
1164                         pr_debug("%s: remove entries", __func__);
1165                         while (i) {
1166                                 sprintf(name, NAME_TEMPLATE, --i);
1167                                 remove_proc_entry(name, NULL);
1168                         }
1169                         pr_debug("\n");
1170                         return -EIO;
1171                 }
1172 #endif
1173                 rndis_per_dev_params[i].confignr = i;
1174                 rndis_per_dev_params[i].used = 0;
1175                 rndis_per_dev_params[i].state = RNDIS_UNINITIALIZED;
1176                 rndis_per_dev_params[i].media_state
1177                                 = NDIS_MEDIA_STATE_DISCONNECTED;
1178                 INIT_LIST_HEAD(&(rndis_per_dev_params[i].resp_queue));
1179         }
1180
1181         return 0;
1182 }
1183
1184 void rndis_exit(void)
1185 {
1186 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
1187         u8 i;
1188         char name[20];
1189
1190         for (i = 0; i < RNDIS_MAX_CONFIGS; i++) {
1191                 sprintf(name, NAME_TEMPLATE, i);
1192                 remove_proc_entry(name, NULL);
1193         }
1194 #endif
1195 }