projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[GitHub/mt8127/android_kernel_alcatel_ttab.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
165 gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
166 rndis_resp_t *r)
167 {
168 int retval = -ENOTSUPP;
169 u32 length = 4; /* usually */
170 __le32 *outbuf;
171 int i, count;
172 rndis_query_cmplt_type *resp;
173 struct net_device *net;
174 const struct net_device_stats *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);
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 length = strlen (rndis_per_dev_params [configNr].vendorDescr);
296 memcpy (outbuf,
297 rndis_per_dev_params [configNr].vendorDescr, length);
298 retval = 0;
299 break;
300
301 case OID_GEN_VENDOR_DRIVER_VERSION:
302 pr_debug("%s: OID_GEN_VENDOR_DRIVER_VERSION\n", __func__);
303 /* Created as LE */
304 *outbuf = rndis_driver_version;
305 retval = 0;
306 break;
307
308 /* mandatory */
309 case OID_GEN_CURRENT_PACKET_FILTER:
310 pr_debug("%s: OID_GEN_CURRENT_PACKET_FILTER\n", __func__);
311 *outbuf = cpu_to_le32 (*rndis_per_dev_params[configNr].filter);
312 retval = 0;
313 break;
314
315 /* mandatory */
316 case OID_GEN_MAXIMUM_TOTAL_SIZE:
317 pr_debug("%s: OID_GEN_MAXIMUM_TOTAL_SIZE\n", __func__);
318 *outbuf = cpu_to_le32(RNDIS_MAX_TOTAL_SIZE);
319 retval = 0;
320 break;
321
322 /* mandatory */
323 case OID_GEN_MEDIA_CONNECT_STATUS:
324 if (rndis_debug > 1)
325 pr_debug("%s: OID_GEN_MEDIA_CONNECT_STATUS\n", __func__);
326 *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
327 .media_state);
328 retval = 0;
329 break;
330
331 case OID_GEN_PHYSICAL_MEDIUM:
332 pr_debug("%s: OID_GEN_PHYSICAL_MEDIUM\n", __func__);
333 *outbuf = cpu_to_le32 (0);
334 retval = 0;
335 break;
336
337 /* The RNDIS specification is incomplete/wrong. Some versions
338 * of MS-Windows expect OIDs that aren't specified there. Other
339 * versions emit undefined RNDIS messages. DOCUMENT ALL THESE!
340 */
341 case OID_GEN_MAC_OPTIONS: /* from WinME */
342 pr_debug("%s: OID_GEN_MAC_OPTIONS\n", __func__);
343 *outbuf = cpu_to_le32(
344 NDIS_MAC_OPTION_RECEIVE_SERIALIZED
345 | NDIS_MAC_OPTION_FULL_DUPLEX);
346 retval = 0;
347 break;
348
349 /* statistics OIDs (table 4-2) */
350
351 /* mandatory */
352 case OID_GEN_XMIT_OK:
353 if (rndis_debug > 1)
354 pr_debug("%s: OID_GEN_XMIT_OK\n", __func__);
355 if (stats) {
356 *outbuf = cpu_to_le32(stats->tx_packets
357 - stats->tx_errors - stats->tx_dropped);
358 retval = 0;
359 }
360 break;
361
362 /* mandatory */
363 case OID_GEN_RCV_OK:
364 if (rndis_debug > 1)
365 pr_debug("%s: OID_GEN_RCV_OK\n", __func__);
366 if (stats) {
367 *outbuf = cpu_to_le32(stats->rx_packets
368 - stats->rx_errors - stats->rx_dropped);
369 retval = 0;
370 }
371 break;
372
373 /* mandatory */
374 case OID_GEN_XMIT_ERROR:
375 if (rndis_debug > 1)
376 pr_debug("%s: OID_GEN_XMIT_ERROR\n", __func__);
377 if (stats) {
378 *outbuf = cpu_to_le32(stats->tx_errors);
379 retval = 0;
380 }
381 break;
382
383 /* mandatory */
384 case OID_GEN_RCV_ERROR:
385 if (rndis_debug > 1)
386 pr_debug("%s: OID_GEN_RCV_ERROR\n", __func__);
387 if (stats) {
388 *outbuf = cpu_to_le32(stats->rx_errors);
389 retval = 0;
390 }
391 break;
392
393 /* mandatory */
394 case OID_GEN_RCV_NO_BUFFER:
395 pr_debug("%s: OID_GEN_RCV_NO_BUFFER\n", __func__);
396 if (stats) {
397 *outbuf = cpu_to_le32(stats->rx_dropped);
398 retval = 0;
399 }
400 break;
401
402 /* ieee802.3 OIDs (table 4-3) */
403
404 /* mandatory */
405 case OID_802_3_PERMANENT_ADDRESS:
406 pr_debug("%s: OID_802_3_PERMANENT_ADDRESS\n", __func__);
407 if (rndis_per_dev_params [configNr].dev) {
408 length = ETH_ALEN;
409 memcpy (outbuf,
410 rndis_per_dev_params [configNr].host_mac,
411 length);
412 retval = 0;
413 }
414 break;
415
416 /* mandatory */
417 case OID_802_3_CURRENT_ADDRESS:
418 pr_debug("%s: OID_802_3_CURRENT_ADDRESS\n", __func__);
419 if (rndis_per_dev_params [configNr].dev) {
420 length = ETH_ALEN;
421 memcpy (outbuf,
422 rndis_per_dev_params [configNr].host_mac,
423 length);
424 retval = 0;
425 }
426 break;
427
428 /* mandatory */
429 case OID_802_3_MULTICAST_LIST:
430 pr_debug("%s: OID_802_3_MULTICAST_LIST\n", __func__);
431 /* Multicast base address only */
432 *outbuf = cpu_to_le32 (0xE0000000);
433 retval = 0;
434 break;
435
436 /* mandatory */
437 case OID_802_3_MAXIMUM_LIST_SIZE:
438 pr_debug("%s: OID_802_3_MAXIMUM_LIST_SIZE\n", __func__);
439 /* Multicast base address only */
440 *outbuf = cpu_to_le32 (1);
441 retval = 0;
442 break;
443
444 case OID_802_3_MAC_OPTIONS:
445 pr_debug("%s: OID_802_3_MAC_OPTIONS\n", __func__);
446 *outbuf = cpu_to_le32(0);
447 retval = 0;
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 = 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 = 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 = cpu_to_le32 (
576 REMOTE_NDIS_INITIALIZE_CMPLT);
577 resp->MessageLength = cpu_to_le32 (52);
578 resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
579 resp->Status = cpu_to_le32 (RNDIS_STATUS_SUCCESS);
580 resp->MajorVersion = cpu_to_le32 (RNDIS_MAJOR_VERSION);
581 resp->MinorVersion = cpu_to_le32 (RNDIS_MINOR_VERSION);
582 resp->DeviceFlags = cpu_to_le32 (RNDIS_DF_CONNECTIONLESS);
583 resp->Medium = cpu_to_le32 (RNDIS_MEDIUM_802_3);
584 resp->MaxPacketsPerTransfer = 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 = cpu_to_le32 (0);
591 resp->AFListOffset = cpu_to_le32 (0);
592 resp->AFListSize = 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 = 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 = cpu_to_le32 (
630 RNDIS_STATUS_NOT_SUPPORTED);
631 resp->MessageLength = cpu_to_le32 (sizeof *resp);
632 resp->InformationBufferLength = cpu_to_le32 (0);
633 resp->InformationBufferOffset = cpu_to_le32 (0);
634 } else
635 resp->Status = 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 = cpu_to_le32 (REMOTE_NDIS_SET_CMPLT);
669 resp->MessageLength = 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 = cpu_to_le32 (RNDIS_STATUS_NOT_SUPPORTED);
674 else
675 resp->Status = 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 = cpu_to_le32 (REMOTE_NDIS_RESET_CMPLT);
693 resp->MessageLength = cpu_to_le32 (16);
694 resp->Status = cpu_to_le32 (RNDIS_STATUS_SUCCESS);
695 /* resent information */
696 resp->AddressingReset = 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 = cpu_to_le32 (
717 REMOTE_NDIS_KEEPALIVE_CMPLT);
718 resp->MessageLength = cpu_to_le32 (16);
719 resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
720 resp->Status = 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 = cpu_to_le32 (
746 REMOTE_NDIS_INDICATE_STATUS_MSG);
747 resp->MessageLength = cpu_to_le32 (20);
748 resp->Status = cpu_to_le32 (status);
749 resp->StatusBufferLength = cpu_to_le32 (0);
750 resp->StatusBufferOffset = 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 = cpu_to_le32(REMOTE_NDIS_PACKET_MSG);
967 header->MessageLength = cpu_to_le32(skb->len);
968 header->DataOffset = 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 gether *port,
1027 struct sk_buff *skb,
1028 struct sk_buff_head *list)
1029 {
1030 /* tmp points to a struct rndis_packet_msg_type */
1031 __le32 *tmp = (void *) skb->data;
1032
1033 /* MessageType, MessageLength */
1034 if (cpu_to_le32(REMOTE_NDIS_PACKET_MSG)
1035 != get_unaligned(tmp++)) {
1036 dev_kfree_skb_any(skb);
1037 return -EINVAL;
1038 }
1039 tmp++;
1040
1041 /* DataOffset, DataLength */
1042 if (!skb_pull(skb, get_unaligned_le32(tmp++) + 8)) {
1043 dev_kfree_skb_any(skb);
1044 return -EOVERFLOW;
1045 }
1046 skb_trim(skb, get_unaligned_le32(tmp++));
1047
1048 skb_queue_tail(list, skb);
1049 return 0;
1050 }
1051
1052 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
1053
1054 static int rndis_proc_show(struct seq_file *m, void *v)
1055 {
1056 rndis_params *param = m->private;
1057
1058 seq_printf(m,
1059 "Config Nr. %d\n"
1060 "used : %s\n"
1061 "state : %s\n"
1062 "medium : 0x%08X\n"
1063 "speed : %d\n"
1064 "cable : %s\n"
1065 "vendor ID : 0x%08X\n"
1066 "vendor : %s\n",
1067 param->confignr, (param->used) ? "y" : "n",
1068 ({ char *s = "?";
1069 switch (param->state) {
1070 case RNDIS_UNINITIALIZED:
1071 s = "RNDIS_UNINITIALIZED"; break;
1072 case RNDIS_INITIALIZED:
1073 s = "RNDIS_INITIALIZED"; break;
1074 case RNDIS_DATA_INITIALIZED:
1075 s = "RNDIS_DATA_INITIALIZED"; break;
1076 }; s; }),
1077 param->medium,
1078 (param->media_state) ? 0 : param->speed*100,
1079 (param->media_state) ? "disconnected" : "connected",
1080 param->vendorID, param->vendorDescr);
1081 return 0;
1082 }
1083
1084 static ssize_t rndis_proc_write(struct file *file, const char __user *buffer,
1085 size_t count, loff_t *ppos)
1086 {
1087 rndis_params *p = PDE(file->f_path.dentry->d_inode)->data;
1088 u32 speed = 0;
1089 int i, fl_speed = 0;
1090
1091 for (i = 0; i < count; i++) {
1092 char c;
1093 if (get_user(c, buffer))
1094 return -EFAULT;
1095 switch (c) {
1096 case '0':
1097 case '1':
1098 case '2':
1099 case '3':
1100 case '4':
1101 case '5':
1102 case '6':
1103 case '7':
1104 case '8':
1105 case '9':
1106 fl_speed = 1;
1107 speed = speed*10 + c - '0';
1108 break;
1109 case 'C':
1110 case 'c':
1111 rndis_signal_connect (p->confignr);
1112 break;
1113 case 'D':
1114 case 'd':
1115 rndis_signal_disconnect(p->confignr);
1116 break;
1117 default:
1118 if (fl_speed) p->speed = speed;
1119 else pr_debug("%c is not valid\n", c);
1120 break;
1121 }
1122
1123 buffer++;
1124 }
1125
1126 return count;
1127 }
1128
1129 static int rndis_proc_open(struct inode *inode, struct file *file)
1130 {
1131 return single_open(file, rndis_proc_show, PDE(inode)->data);
1132 }
1133
1134 static const struct file_operations rndis_proc_fops = {
1135 .owner = THIS_MODULE,
1136 .open = rndis_proc_open,
1137 .read = seq_read,
1138 .llseek = seq_lseek,
1139 .release = single_release,
1140 .write = rndis_proc_write,
1141 };
1142
1143 #define NAME_TEMPLATE "driver/rndis-%03d"
1144
1145 static struct proc_dir_entry *rndis_connect_state [RNDIS_MAX_CONFIGS];
1146
1147 #endif /* CONFIG_USB_GADGET_DEBUG_FILES */
1148
1149
1150 int __init rndis_init (void)
1151 {
1152 u8 i;
1153
1154 for (i = 0; i < RNDIS_MAX_CONFIGS; i++) {
1155 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
1156 char name [20];
1157
1158 sprintf (name, NAME_TEMPLATE, i);
1159 if (!(rndis_connect_state [i]
1160 = proc_create_data(name, 0660, NULL,
1161 &rndis_proc_fops,
1162 (void *)(rndis_per_dev_params + i))))
1163 {
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 }
1196
kernel source for telekom puls (alcatel/mediatek)