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