]>
Commit | Line | Data |
---|---|---|
7612a43d VK |
1 | /* |
2 | * RNDIS MSG parser | |
3 | * | |
4 | * Authors: Benedikt Spranger, Pengutronix | |
5 | * Robert Schwebel, Pengutronix | |
6 | * | |
7612a43d VK |
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 | |
5b8031cc TR |
18 | * |
19 | * SPDX-License-Identifier: GPL-2.0 | |
7612a43d VK |
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 */ | |
7612a43d VK |
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 | ||
e4ae6660 VK |
995 | #ifdef RNDIS_COMPLETE_SIGNAL_DISCONNECT |
996 | return rndis_indicate_status_msg(configNr, | |
997 | RNDIS_STATUS_MEDIA_DISCONNECT); | |
998 | #else | |
7612a43d | 999 | return 0; |
e4ae6660 | 1000 | #endif |
7612a43d VK |
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 | } |