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