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