4 * Authors: Benedikt Spranger, Pengutronix
5 * Robert Schwebel, Pengutronix
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * version 2, as published by the Free Software Foundation.
11 * This software was originally developed in conformance with
12 * Microsoft's Remote NDIS Specification License Agreement.
14 * 03/12/2004 Kai-Uwe Bloem <linux-development@auerswald.de>
15 * Fixed message length bug in init_response
17 * 03/25/2004 Kai-Uwe Bloem <linux-development@auerswald.de>
18 * Fixed rndis_rm_hdr length bug.
20 * Copyright (C) 2004 by David Brownell
21 * updates to merge with Linux 2.6, better match RNDIS spec
24 #include <linux/module.h>
25 #include <linux/moduleparam.h>
26 #include <linux/kernel.h>
27 #include <linux/errno.h>
28 #include <linux/init.h>
29 #include <linux/list.h>
30 #include <linux/proc_fs.h>
31 #include <linux/slab.h>
32 #include <linux/seq_file.h>
33 #include <linux/netdevice.h>
36 #include <asm/byteorder.h>
37 #include <asm/unaligned.h>
45 /* The driver for your USB chip needs to support ep0 OUT to work with
46 * RNDIS, plus all three CDC Ethernet endpoints (interrupt not optional).
48 * Windows hosts need an INF file like Documentation/usb/linux.inf
49 * and will be happier if you provide the host_addr module parameter.
53 static int rndis_debug
= 0;
54 module_param (rndis_debug
, int, 0);
55 MODULE_PARM_DESC (rndis_debug
, "enable debugging");
60 #define RNDIS_MAX_CONFIGS 1
62 int rndis_ul_max_pkt_per_xfer_rcvd
;
63 module_param(rndis_ul_max_pkt_per_xfer_rcvd
, int, S_IRUGO
);
64 MODULE_PARM_DESC(rndis_ul_max_pkt_per_xfer_rcvd
,
65 "Max num of REMOTE_NDIS_PACKET_MSGs received in a single transfer");
67 int rndis_ul_max_xfer_size_rcvd
;
68 module_param(rndis_ul_max_xfer_size_rcvd
, int, S_IRUGO
);
69 MODULE_PARM_DESC(rndis_ul_max_xfer_size_rcvd
,
70 "Max size of bus transfer received");
73 static rndis_params rndis_per_dev_params
[RNDIS_MAX_CONFIGS
];
76 static const __le32 rndis_driver_version
= cpu_to_le32(1);
78 /* Function Prototypes */
79 static rndis_resp_t
*rndis_add_response(int configNr
, u32 length
);
83 static const u32 oid_supported_list
[] =
85 /* the general stuff */
86 RNDIS_OID_GEN_SUPPORTED_LIST
,
87 RNDIS_OID_GEN_HARDWARE_STATUS
,
88 RNDIS_OID_GEN_MEDIA_SUPPORTED
,
89 RNDIS_OID_GEN_MEDIA_IN_USE
,
90 RNDIS_OID_GEN_MAXIMUM_FRAME_SIZE
,
91 RNDIS_OID_GEN_LINK_SPEED
,
92 RNDIS_OID_GEN_TRANSMIT_BLOCK_SIZE
,
93 RNDIS_OID_GEN_RECEIVE_BLOCK_SIZE
,
94 RNDIS_OID_GEN_VENDOR_ID
,
95 RNDIS_OID_GEN_VENDOR_DESCRIPTION
,
96 RNDIS_OID_GEN_VENDOR_DRIVER_VERSION
,
97 RNDIS_OID_GEN_CURRENT_PACKET_FILTER
,
98 RNDIS_OID_GEN_MAXIMUM_TOTAL_SIZE
,
99 RNDIS_OID_GEN_MEDIA_CONNECT_STATUS
,
100 RNDIS_OID_GEN_PHYSICAL_MEDIUM
,
102 /* the statistical stuff */
103 RNDIS_OID_GEN_XMIT_OK
,
104 RNDIS_OID_GEN_RCV_OK
,
105 RNDIS_OID_GEN_XMIT_ERROR
,
106 RNDIS_OID_GEN_RCV_ERROR
,
107 RNDIS_OID_GEN_RCV_NO_BUFFER
,
108 #ifdef RNDIS_OPTIONAL_STATS
109 RNDIS_OID_GEN_DIRECTED_BYTES_XMIT
,
110 RNDIS_OID_GEN_DIRECTED_FRAMES_XMIT
,
111 RNDIS_OID_GEN_MULTICAST_BYTES_XMIT
,
112 RNDIS_OID_GEN_MULTICAST_FRAMES_XMIT
,
113 RNDIS_OID_GEN_BROADCAST_BYTES_XMIT
,
114 RNDIS_OID_GEN_BROADCAST_FRAMES_XMIT
,
115 RNDIS_OID_GEN_DIRECTED_BYTES_RCV
,
116 RNDIS_OID_GEN_DIRECTED_FRAMES_RCV
,
117 RNDIS_OID_GEN_MULTICAST_BYTES_RCV
,
118 RNDIS_OID_GEN_MULTICAST_FRAMES_RCV
,
119 RNDIS_OID_GEN_BROADCAST_BYTES_RCV
,
120 RNDIS_OID_GEN_BROADCAST_FRAMES_RCV
,
121 RNDIS_OID_GEN_RCV_CRC_ERROR
,
122 RNDIS_OID_GEN_TRANSMIT_QUEUE_LENGTH
,
123 #endif /* RNDIS_OPTIONAL_STATS */
125 /* mandatory 802.3 */
126 /* the general stuff */
127 RNDIS_OID_802_3_PERMANENT_ADDRESS
,
128 RNDIS_OID_802_3_CURRENT_ADDRESS
,
129 RNDIS_OID_802_3_MULTICAST_LIST
,
130 RNDIS_OID_802_3_MAC_OPTIONS
,
131 RNDIS_OID_802_3_MAXIMUM_LIST_SIZE
,
133 /* the statistical stuff */
134 RNDIS_OID_802_3_RCV_ERROR_ALIGNMENT
,
135 RNDIS_OID_802_3_XMIT_ONE_COLLISION
,
136 RNDIS_OID_802_3_XMIT_MORE_COLLISIONS
,
137 #ifdef RNDIS_OPTIONAL_STATS
138 RNDIS_OID_802_3_XMIT_DEFERRED
,
139 RNDIS_OID_802_3_XMIT_MAX_COLLISIONS
,
140 RNDIS_OID_802_3_RCV_OVERRUN
,
141 RNDIS_OID_802_3_XMIT_UNDERRUN
,
142 RNDIS_OID_802_3_XMIT_HEARTBEAT_FAILURE
,
143 RNDIS_OID_802_3_XMIT_TIMES_CRS_LOST
,
144 RNDIS_OID_802_3_XMIT_LATE_COLLISIONS
,
145 #endif /* RNDIS_OPTIONAL_STATS */
148 /* PM and wakeup are "mandatory" for USB, but the RNDIS specs
149 * don't say what they mean ... and the NDIS specs are often
150 * confusing and/or ambiguous in this context. (That is, more
151 * so than their specs for the other OIDs.)
153 * FIXME someone who knows what these should do, please
157 /* power management */
158 OID_PNP_CAPABILITIES
,
164 OID_PNP_ENABLE_WAKE_UP
,
165 OID_PNP_ADD_WAKE_UP_PATTERN
,
166 OID_PNP_REMOVE_WAKE_UP_PATTERN
,
167 #endif /* RNDIS_WAKEUP */
168 #endif /* RNDIS_PM */
171 unsigned long rndis_test_reset_msg_cnt
= 0;
172 u32 rndis_test_last_msg_id
= 0;
173 extern u32 rndis_test_last_resp_id
;
175 extern unsigned long rndis_test_rx_usb_in
;
176 extern unsigned long rndis_test_rx_net_out
;
177 extern unsigned long rndis_test_rx_nomem
;
178 extern unsigned long rndis_test_rx_error
;
180 extern unsigned long rndis_test_tx_net_in
;
181 extern unsigned long rndis_test_tx_busy
;
182 extern unsigned long rndis_test_tx_usb_out
;
183 extern unsigned long rndis_test_tx_complete
;
186 static int gen_ndis_query_resp(int configNr
, u32 OID
, u8
*buf
,
187 unsigned buf_len
, rndis_resp_t
*r
)
189 int retval
= -ENOTSUPP
;
190 u32 length
= 4; /* usually */
193 rndis_query_cmplt_type
*resp
;
194 struct net_device
*net
;
195 struct rtnl_link_stats64 temp
;
196 const struct rtnl_link_stats64
*stats
;
198 if (!r
) return -ENOMEM
;
199 resp
= (rndis_query_cmplt_type
*)r
->buf
;
201 if (!resp
) return -ENOMEM
;
203 if (buf_len
&& rndis_debug
> 1) {
204 pr_debug("query OID %08x value, len %d:\n", OID
, buf_len
);
205 for (i
= 0; i
< buf_len
; i
+= 16) {
206 pr_debug("%03d: %08x %08x %08x %08x\n", i
,
207 get_unaligned_le32(&buf
[i
]),
208 get_unaligned_le32(&buf
[i
+ 4]),
209 get_unaligned_le32(&buf
[i
+ 8]),
210 get_unaligned_le32(&buf
[i
+ 12]));
214 /* response goes here, right after the header */
215 outbuf
= (__le32
*)&resp
[1];
216 resp
->InformationBufferOffset
= cpu_to_le32(16);
218 net
= rndis_per_dev_params
[configNr
].dev
;
219 stats
= dev_get_stats(net
, &temp
);
222 pr_debug("gen_ndis_query_resp, OID is 0x%x, configNr is %d\n", OID
, configNr
) ;
227 /* general oids (table 4-1) */
230 case RNDIS_OID_GEN_SUPPORTED_LIST
:
231 pr_debug("%s: RNDIS_OID_GEN_SUPPORTED_LIST\n", __func__
);
232 length
= sizeof(oid_supported_list
);
233 count
= length
/ sizeof(u32
);
234 for (i
= 0; i
< count
; i
++)
235 outbuf
[i
] = cpu_to_le32(oid_supported_list
[i
]);
240 case RNDIS_OID_GEN_HARDWARE_STATUS
:
241 pr_debug("%s: RNDIS_OID_GEN_HARDWARE_STATUS\n", __func__
);
243 * Hardware must be ready to receive high level protocols.
245 * reddite ergo quae sunt Caesaris Caesari
246 * et quae sunt Dei Deo!
248 *outbuf
= cpu_to_le32(0);
253 case RNDIS_OID_GEN_MEDIA_SUPPORTED
:
254 pr_debug("%s: RNDIS_OID_GEN_MEDIA_SUPPORTED\n", __func__
);
255 *outbuf
= cpu_to_le32(rndis_per_dev_params
[configNr
].medium
);
260 case RNDIS_OID_GEN_MEDIA_IN_USE
:
261 pr_debug("%s: RNDIS_OID_GEN_MEDIA_IN_USE\n", __func__
);
262 /* one medium, one transport... (maybe you do it better) */
263 *outbuf
= cpu_to_le32(rndis_per_dev_params
[configNr
].medium
);
268 case RNDIS_OID_GEN_MAXIMUM_FRAME_SIZE
:
269 pr_debug("%s: RNDIS_OID_GEN_MAXIMUM_FRAME_SIZE\n", __func__
);
270 if (rndis_per_dev_params
[configNr
].dev
) {
271 *outbuf
= cpu_to_le32(
272 rndis_per_dev_params
[configNr
].dev
->mtu
);
278 case RNDIS_OID_GEN_LINK_SPEED
:
280 pr_debug("%s: RNDIS_OID_GEN_LINK_SPEED\n", __func__
);
281 if (rndis_per_dev_params
[configNr
].media_state
282 == RNDIS_MEDIA_STATE_DISCONNECTED
)
283 *outbuf
= cpu_to_le32(0);
285 *outbuf
= cpu_to_le32(
286 rndis_per_dev_params
[configNr
].speed
);
289 pr_debug("OID_GEN_LINK_SPEED, speed %d. data: rx_in %lu, rx_out %lu, rx_nomem %lu, rx_error %lu, tx_in %lu, tx_out %lu, tx_busy %lu, tx_complete %lu, last_msg_id: 0x%x, last_resp_id: 0x%x, RNDIS reset cnt: 0x%lu, queue stopped? %d\n",
290 rndis_per_dev_params
[configNr
].speed
, rndis_test_rx_usb_in
, rndis_test_rx_net_out
, rndis_test_rx_nomem
, rndis_test_rx_error
, rndis_test_tx_net_in
,
291 rndis_test_tx_usb_out
, rndis_test_tx_busy
, rndis_test_tx_complete
, rndis_test_last_msg_id
, rndis_test_last_resp_id
, rndis_test_reset_msg_cnt
,
292 netif_queue_stopped(rndis_per_dev_params
[configNr
].dev
)) ;
299 case RNDIS_OID_GEN_TRANSMIT_BLOCK_SIZE
:
300 pr_debug("%s: RNDIS_OID_GEN_TRANSMIT_BLOCK_SIZE\n", __func__
);
301 if (rndis_per_dev_params
[configNr
].dev
) {
302 *outbuf
= cpu_to_le32(
303 rndis_per_dev_params
[configNr
].dev
->mtu
);
309 case RNDIS_OID_GEN_RECEIVE_BLOCK_SIZE
:
310 pr_debug("%s: RNDIS_OID_GEN_RECEIVE_BLOCK_SIZE\n", __func__
);
311 if (rndis_per_dev_params
[configNr
].dev
) {
312 *outbuf
= cpu_to_le32(
313 rndis_per_dev_params
[configNr
].dev
->mtu
);
319 case RNDIS_OID_GEN_VENDOR_ID
:
320 pr_debug("%s: RNDIS_OID_GEN_VENDOR_ID\n", __func__
);
321 *outbuf
= cpu_to_le32(
322 rndis_per_dev_params
[configNr
].vendorID
);
327 case RNDIS_OID_GEN_VENDOR_DESCRIPTION
:
328 pr_debug("%s: RNDIS_OID_GEN_VENDOR_DESCRIPTION\n", __func__
);
329 if (rndis_per_dev_params
[configNr
].vendorDescr
) {
330 length
= strlen(rndis_per_dev_params
[configNr
].
333 rndis_per_dev_params
[configNr
].vendorDescr
,
341 case RNDIS_OID_GEN_VENDOR_DRIVER_VERSION
:
342 pr_debug("%s: RNDIS_OID_GEN_VENDOR_DRIVER_VERSION\n", __func__
);
344 *outbuf
= rndis_driver_version
;
349 case RNDIS_OID_GEN_CURRENT_PACKET_FILTER
:
350 pr_debug("%s: RNDIS_OID_GEN_CURRENT_PACKET_FILTER\n", __func__
);
351 *outbuf
= cpu_to_le32(*rndis_per_dev_params
[configNr
].filter
);
356 case RNDIS_OID_GEN_MAXIMUM_TOTAL_SIZE
:
357 pr_debug("%s: RNDIS_OID_GEN_MAXIMUM_TOTAL_SIZE\n", __func__
);
358 *outbuf
= cpu_to_le32(RNDIS_MAX_TOTAL_SIZE
);
363 case RNDIS_OID_GEN_MEDIA_CONNECT_STATUS
:
365 pr_debug("%s: RNDIS_OID_GEN_MEDIA_CONNECT_STATUS\n", __func__
);
366 *outbuf
= cpu_to_le32(rndis_per_dev_params
[configNr
]
369 pr_debug("OID_GEN_MEDIA_CONNECT_STATUS, media_state %d\n", rndis_per_dev_params
[configNr
].media_state
) ;
374 case RNDIS_OID_GEN_PHYSICAL_MEDIUM
:
375 pr_debug("%s: RNDIS_OID_GEN_PHYSICAL_MEDIUM\n", __func__
);
376 *outbuf
= cpu_to_le32(0);
380 /* The RNDIS specification is incomplete/wrong. Some versions
381 * of MS-Windows expect OIDs that aren't specified there. Other
382 * versions emit undefined RNDIS messages. DOCUMENT ALL THESE!
384 case RNDIS_OID_GEN_MAC_OPTIONS
: /* from WinME */
385 pr_debug("%s: RNDIS_OID_GEN_MAC_OPTIONS\n", __func__
);
386 *outbuf
= cpu_to_le32(
387 RNDIS_MAC_OPTION_RECEIVE_SERIALIZED
388 | RNDIS_MAC_OPTION_FULL_DUPLEX
);
392 /* statistics OIDs (table 4-2) */
395 case RNDIS_OID_GEN_XMIT_OK
:
397 pr_debug("%s: RNDIS_OID_GEN_XMIT_OK\n", __func__
);
399 *outbuf
= cpu_to_le32(stats
->tx_packets
400 - stats
->tx_errors
- stats
->tx_dropped
);
406 case RNDIS_OID_GEN_RCV_OK
:
408 pr_debug("%s: RNDIS_OID_GEN_RCV_OK\n", __func__
);
410 *outbuf
= cpu_to_le32(stats
->rx_packets
411 - stats
->rx_errors
- stats
->rx_dropped
);
417 case RNDIS_OID_GEN_XMIT_ERROR
:
419 pr_debug("%s: RNDIS_OID_GEN_XMIT_ERROR\n", __func__
);
421 *outbuf
= cpu_to_le32(stats
->tx_errors
);
423 pr_err("OID_GEN_XMIT_ERROR, stats->tx_errors %llu\n", stats
->tx_errors
) ;
430 case RNDIS_OID_GEN_RCV_ERROR
:
432 pr_debug("%s: RNDIS_OID_GEN_RCV_ERROR\n", __func__
);
434 *outbuf
= cpu_to_le32(stats
->rx_errors
);
436 pr_err("OID_GEN_RCV_ERROR, stats->rx_errors %llu\n", stats
->rx_errors
) ;
443 case RNDIS_OID_GEN_RCV_NO_BUFFER
:
444 pr_debug("%s: RNDIS_OID_GEN_RCV_NO_BUFFER\n", __func__
);
446 *outbuf
= cpu_to_le32(stats
->rx_dropped
);
448 pr_err("OID_GEN_RCV_NO_BUFFER, stats->rx_dropped %llu\n", stats
->rx_dropped
) ;
454 /* ieee802.3 OIDs (table 4-3) */
457 case RNDIS_OID_802_3_PERMANENT_ADDRESS
:
458 pr_debug("%s: RNDIS_OID_802_3_PERMANENT_ADDRESS\n", __func__
);
459 if (rndis_per_dev_params
[configNr
].dev
) {
462 rndis_per_dev_params
[configNr
].host_mac
,
466 pr_debug("OID_802_3_PERMANENT_ADDRESS, host_mac is %x %x ....\n",
467 rndis_per_dev_params
[configNr
].host_mac
[0],
468 rndis_per_dev_params
[configNr
].host_mac
[1]) ;
474 case RNDIS_OID_802_3_CURRENT_ADDRESS
:
475 pr_debug("%s: RNDIS_OID_802_3_CURRENT_ADDRESS\n", __func__
);
476 if (rndis_per_dev_params
[configNr
].dev
) {
479 rndis_per_dev_params
[configNr
].host_mac
,
483 pr_debug("OID_802_3_CURRENT_ADDRESS, host_mac is %x %x ....\n",
484 rndis_per_dev_params
[configNr
].host_mac
[0],
485 rndis_per_dev_params
[configNr
].host_mac
[1]) ;
493 case RNDIS_OID_802_3_MULTICAST_LIST
:
494 pr_debug("%s: RNDIS_OID_802_3_MULTICAST_LIST\n", __func__
);
495 /* Multicast base address only */
496 *outbuf
= cpu_to_le32(0xE0000000);
501 case RNDIS_OID_802_3_MAXIMUM_LIST_SIZE
:
502 pr_debug("%s: RNDIS_OID_802_3_MAXIMUM_LIST_SIZE\n", __func__
);
503 /* Multicast base address only */
504 *outbuf
= cpu_to_le32(1);
508 case RNDIS_OID_802_3_MAC_OPTIONS
:
509 pr_debug("%s: RNDIS_OID_802_3_MAC_OPTIONS\n", __func__
);
510 *outbuf
= cpu_to_le32(0);
514 /* ieee802.3 statistics OIDs (table 4-4) */
517 case RNDIS_OID_802_3_RCV_ERROR_ALIGNMENT
:
518 pr_debug("%s: RNDIS_OID_802_3_RCV_ERROR_ALIGNMENT\n", __func__
);
521 pr_debug("OID_802_3_RCV_ERROR_ALIGNMENT, stats->rx_frame_errors is %llu\n", stats
->rx_frame_errors
) ;
523 *outbuf
= cpu_to_le32(stats
->rx_frame_errors
);
529 case RNDIS_OID_802_3_XMIT_ONE_COLLISION
:
530 pr_debug("%s: RNDIS_OID_802_3_XMIT_ONE_COLLISION\n", __func__
);
531 *outbuf
= cpu_to_le32(0);
536 case RNDIS_OID_802_3_XMIT_MORE_COLLISIONS
:
537 pr_debug("%s: RNDIS_OID_802_3_XMIT_MORE_COLLISIONS\n", __func__
);
538 *outbuf
= cpu_to_le32(0);
543 pr_warning("%s: query unknown OID 0x%08X\n",
548 pr_warning("%s: bad gen_ndis_query_resp, retval is 0x%d\n", __func__
, retval
) ;
551 resp
->InformationBufferLength
= cpu_to_le32(length
);
552 r
->length
= length
+ sizeof(*resp
);
553 resp
->MessageLength
= cpu_to_le32(r
->length
);
557 static int gen_ndis_set_resp(u8 configNr
, u32 OID
, u8
*buf
, u32 buf_len
,
560 rndis_set_cmplt_type
*resp
;
561 int i
, retval
= -ENOTSUPP
;
562 struct rndis_params
*params
;
566 resp
= (rndis_set_cmplt_type
*)r
->buf
;
570 if (buf_len
&& rndis_debug
> 1) {
571 pr_debug("set OID %08x value, len %d:\n", OID
, buf_len
);
572 for (i
= 0; i
< buf_len
; i
+= 16) {
573 pr_debug("%03d: %08x %08x %08x %08x\n", i
,
574 get_unaligned_le32(&buf
[i
]),
575 get_unaligned_le32(&buf
[i
+ 4]),
576 get_unaligned_le32(&buf
[i
+ 8]),
577 get_unaligned_le32(&buf
[i
+ 12]));
582 pr_debug("gen_ndis_set_resp, OID is 0x%x\n", OID
) ;
585 params
= &rndis_per_dev_params
[configNr
];
587 case RNDIS_OID_GEN_CURRENT_PACKET_FILTER
:
589 /* these NDIS_PACKET_TYPE_* bitflags are shared with
590 * cdc_filter; it's not RNDIS-specific
591 * NDIS_PACKET_TYPE_x == USB_CDC_PACKET_TYPE_x for x in:
592 * PROMISCUOUS, DIRECTED,
593 * MULTICAST, ALL_MULTICAST, BROADCAST
595 *params
->filter
= (u16
)get_unaligned_le32(buf
);
596 pr_debug("%s: RNDIS_OID_GEN_CURRENT_PACKET_FILTER %08x\n",
597 __func__
, *params
->filter
);
599 /* this call has a significant side effect: it's
600 * what makes the packet flow start and stop, like
601 * activating the CDC Ethernet altsetting.
604 if (*params
->filter
) {
605 params
->state
= RNDIS_DATA_INITIALIZED
;
606 netif_carrier_on(params
->dev
);
607 if (netif_running(params
->dev
))
608 netif_wake_queue(params
->dev
);
610 params
->state
= RNDIS_INITIALIZED
;
611 netif_carrier_off(params
->dev
);
612 netif_stop_queue(params
->dev
);
616 case RNDIS_OID_802_3_MULTICAST_LIST
:
617 /* I think we can ignore this */
618 pr_debug("%s: RNDIS_OID_802_3_MULTICAST_LIST\n", __func__
);
623 pr_warning("%s: set unknown OID 0x%08X, size %d\n",
624 __func__
, OID
, buf_len
);
628 pr_debug("gen_ndis_set_resp, <==== retval is 0x%d\n", retval
) ;
638 static int rndis_init_response(int configNr
, rndis_init_msg_type
*buf
)
640 rndis_init_cmplt_type
*resp
;
642 struct rndis_params
*params
= rndis_per_dev_params
+ configNr
;
647 r
= rndis_add_response(configNr
, sizeof(rndis_init_cmplt_type
));
650 resp
= (rndis_init_cmplt_type
*)r
->buf
;
652 resp
->MessageType
= cpu_to_le32(RNDIS_MSG_INIT_C
);
653 resp
->MessageLength
= cpu_to_le32(52);
654 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
655 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
656 resp
->MajorVersion
= cpu_to_le32(RNDIS_MAJOR_VERSION
);
657 resp
->MinorVersion
= cpu_to_le32(RNDIS_MINOR_VERSION
);
658 resp
->DeviceFlags
= cpu_to_le32(RNDIS_DF_CONNECTIONLESS
);
659 resp
->Medium
= cpu_to_le32(RNDIS_MEDIUM_802_3
);
660 resp
->MaxPacketsPerTransfer
= cpu_to_le32(params
->max_pkt_per_xfer
);
661 resp
->MaxTransferSize
= cpu_to_le32(params
->max_pkt_per_xfer
*
663 + sizeof(struct ethhdr
)
664 + sizeof(struct rndis_packet_msg_type
)
666 resp
->PacketAlignmentFactor
= cpu_to_le32(0);
667 resp
->AFListOffset
= cpu_to_le32(0);
668 resp
->AFListSize
= cpu_to_le32(0);
670 params
->resp_avail(params
->v
);
674 static int rndis_query_response(int configNr
, rndis_query_msg_type
*buf
)
676 rndis_query_cmplt_type
*resp
;
678 struct rndis_params
*params
= rndis_per_dev_params
+ configNr
;
680 /* pr_debug("%s: OID = %08X\n", __func__, cpu_to_le32(buf->OID)); */
685 * we need more memory:
686 * gen_ndis_query_resp expects enough space for
687 * rndis_query_cmplt_type followed by data.
688 * oid_supported_list is the largest data reply
690 r
= rndis_add_response(configNr
,
691 sizeof(oid_supported_list
) + sizeof(rndis_query_cmplt_type
));
694 pr_err("rndis_query_response, rndis_add_response return NULL\n") ;
697 resp
= (rndis_query_cmplt_type
*)r
->buf
;
699 resp
->MessageType
= cpu_to_le32(RNDIS_MSG_QUERY_C
);
700 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
702 if (gen_ndis_query_resp(configNr
, le32_to_cpu(buf
->OID
),
703 le32_to_cpu(buf
->InformationBufferOffset
)
705 le32_to_cpu(buf
->InformationBufferLength
),
707 /* OID not supported */
708 resp
->Status
= cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED
);
709 resp
->MessageLength
= cpu_to_le32(sizeof *resp
);
710 resp
->InformationBufferLength
= cpu_to_le32(0);
711 resp
->InformationBufferOffset
= cpu_to_le32(0);
713 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
715 params
->resp_avail(params
->v
);
719 static int rndis_set_response(int configNr
, rndis_set_msg_type
*buf
)
721 u32 BufLength
, BufOffset
;
722 rndis_set_cmplt_type
*resp
;
724 struct rndis_params
*params
= rndis_per_dev_params
+ configNr
;
726 r
= rndis_add_response(configNr
, sizeof(rndis_set_cmplt_type
));
729 pr_err("rndis_set_response, rndis_add_response return NULL\n") ;
732 resp
= (rndis_set_cmplt_type
*)r
->buf
;
734 BufLength
= le32_to_cpu(buf
->InformationBufferLength
);
735 BufOffset
= le32_to_cpu(buf
->InformationBufferOffset
);
738 pr_debug("%s: Length: %d\n", __func__
, BufLength
);
739 pr_debug("%s: Offset: %d\n", __func__
, BufOffset
);
740 pr_debug("%s: InfoBuffer: ", __func__
);
742 for (i
= 0; i
< BufLength
; i
++) {
743 pr_debug("%02x ", *(((u8
*) buf
) + i
+ 8 + BufOffset
));
749 resp
->MessageType
= cpu_to_le32(RNDIS_MSG_SET_C
);
750 resp
->MessageLength
= cpu_to_le32(16);
751 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
752 if (gen_ndis_set_resp(configNr
, le32_to_cpu(buf
->OID
),
753 ((u8
*)buf
) + 8 + BufOffset
, BufLength
, r
))
754 resp
->Status
= cpu_to_le32(RNDIS_STATUS_NOT_SUPPORTED
);
756 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
758 params
->resp_avail(params
->v
);
762 static int rndis_reset_response(int configNr
, rndis_reset_msg_type
*buf
)
764 rndis_reset_cmplt_type
*resp
;
766 struct rndis_params
*params
= rndis_per_dev_params
+ configNr
;
768 /* patch for RNDIS reset msg : clear the previous response ~*/
772 pr_debug("%s: rndis reset !! clean the old resposes...\n", __func__
);
773 while ((buf_legacy
= rndis_get_next_response(configNr
, &length
)))
774 rndis_free_response(configNr
, buf_legacy
);
776 rndis_test_reset_msg_cnt
++ ;
777 /* patch for RNDIS reset msg */
779 r
= rndis_add_response(configNr
, sizeof(rndis_reset_cmplt_type
));
782 resp
= (rndis_reset_cmplt_type
*)r
->buf
;
784 resp
->MessageType
= cpu_to_le32(RNDIS_MSG_RESET_C
);
785 resp
->MessageLength
= cpu_to_le32(16);
786 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
787 /* resent information */
788 resp
->AddressingReset
= cpu_to_le32(1);
790 params
->resp_avail(params
->v
);
794 static int rndis_keepalive_response(int configNr
,
795 rndis_keepalive_msg_type
*buf
)
797 rndis_keepalive_cmplt_type
*resp
;
799 struct rndis_params
*params
= rndis_per_dev_params
+ configNr
;
801 /* host "should" check only in RNDIS_DATA_INITIALIZED state */
803 r
= rndis_add_response(configNr
, sizeof(rndis_keepalive_cmplt_type
));
806 pr_err("rndis_keepalive_response, rndis_add_response return NULL\n") ;
810 resp
= (rndis_keepalive_cmplt_type
*)r
->buf
;
812 resp
->MessageType
= cpu_to_le32(RNDIS_MSG_KEEPALIVE_C
);
813 resp
->MessageLength
= cpu_to_le32(16);
814 resp
->RequestID
= buf
->RequestID
; /* Still LE in msg buffer */
815 resp
->Status
= cpu_to_le32(RNDIS_STATUS_SUCCESS
);
817 params
->resp_avail(params
->v
);
820 pr_debug("rndis_keepalive_response, data: rx_in %lu, rx_out %lu, rx_nomem %lu, rx_error %lu, tx_in %lu, tx_out %lu, tx_busy %lu, tx_complete %lu, last_msg_id: 0x%x, last_resp_id: 0x%x, RNDIS reset cnt: 0x%lu, queue stopped? %d\n",
821 rndis_test_rx_usb_in
, rndis_test_rx_net_out
, rndis_test_rx_nomem
, rndis_test_rx_error
, rndis_test_tx_net_in
,
822 rndis_test_tx_usb_out
, rndis_test_tx_busy
, rndis_test_tx_complete
, rndis_test_last_msg_id
, rndis_test_last_resp_id
, rndis_test_reset_msg_cnt
,
823 netif_queue_stopped(params
->dev
)) ;
831 * Device to Host Comunication
833 static int rndis_indicate_status_msg(int configNr
, u32 status
)
835 rndis_indicate_status_msg_type
*resp
;
837 struct rndis_params
*params
= rndis_per_dev_params
+ configNr
;
839 if (params
->state
== RNDIS_UNINITIALIZED
)
842 r
= rndis_add_response(configNr
,
843 sizeof(rndis_indicate_status_msg_type
));
846 resp
= (rndis_indicate_status_msg_type
*)r
->buf
;
848 resp
->MessageType
= cpu_to_le32(RNDIS_MSG_INDICATE
);
849 resp
->MessageLength
= cpu_to_le32(20);
850 resp
->Status
= cpu_to_le32(status
);
851 resp
->StatusBufferLength
= cpu_to_le32(0);
852 resp
->StatusBufferOffset
= cpu_to_le32(0);
854 params
->resp_avail(params
->v
);
858 int rndis_signal_connect(int configNr
)
860 rndis_per_dev_params
[configNr
].media_state
861 = RNDIS_MEDIA_STATE_CONNECTED
;
862 return rndis_indicate_status_msg(configNr
,
863 RNDIS_STATUS_MEDIA_CONNECT
);
866 int rndis_signal_disconnect(int configNr
)
868 rndis_per_dev_params
[configNr
].media_state
869 = RNDIS_MEDIA_STATE_DISCONNECTED
;
870 return rndis_indicate_status_msg(configNr
,
871 RNDIS_STATUS_MEDIA_DISCONNECT
);
874 void rndis_uninit(int configNr
)
879 if (configNr
>= RNDIS_MAX_CONFIGS
)
881 rndis_per_dev_params
[configNr
].state
= RNDIS_UNINITIALIZED
;
883 /* drain the response queue */
884 while ((buf
= rndis_get_next_response(configNr
, &length
)))
885 rndis_free_response(configNr
, buf
);
888 void rndis_set_host_mac(int configNr
, const u8
*addr
)
890 rndis_per_dev_params
[configNr
].host_mac
= addr
;
896 int rndis_msg_parser(u8 configNr
, u8
*buf
)
898 u32 MsgType
, MsgLength
, MsgID
;
900 struct rndis_params
*params
;
906 MsgType
= get_unaligned_le32(tmp
++);
907 MsgLength
= get_unaligned_le32(tmp
++);
908 MsgID
= get_unaligned_le32(tmp
++);
910 pr_debug("rndis_msg_parser, MsgType is %d,configNr is %d, RequestID is 0x%x\n", MsgType
,configNr
, MsgID
) ;
912 rndis_test_last_msg_id
= MsgID
;
914 if (configNr
>= RNDIS_MAX_CONFIGS
)
916 params
= &rndis_per_dev_params
[configNr
];
918 /* NOTE: RNDIS is *EXTREMELY* chatty ... Windows constantly polls for
919 * rx/tx statistics and link status, in addition to KEEPALIVE traffic
920 * and normal HC level polling to see if there's any IN traffic.
923 /* For USB: responses may take up to 10 seconds */
926 pr_debug("%s: RNDIS_MSG_INIT\n",
928 params
->state
= RNDIS_INITIALIZED
;
929 return rndis_init_response(configNr
,
930 (rndis_init_msg_type
*)buf
);
933 pr_debug("%s: RNDIS_MSG_HALT\n",
935 params
->state
= RNDIS_UNINITIALIZED
;
937 netif_carrier_off(params
->dev
);
938 netif_stop_queue(params
->dev
);
942 case RNDIS_MSG_QUERY
:
943 return rndis_query_response(configNr
,
944 (rndis_query_msg_type
*)buf
);
947 return rndis_set_response(configNr
,
948 (rndis_set_msg_type
*)buf
);
950 case RNDIS_MSG_RESET
:
951 pr_debug("%s: RNDIS_MSG_RESET\n",
953 return rndis_reset_response(configNr
,
954 (rndis_reset_msg_type
*)buf
);
956 case RNDIS_MSG_KEEPALIVE
:
957 /* For USB: host does this every 5 seconds */
959 pr_debug("%s: RNDIS_MSG_KEEPALIVE\n",
961 return rndis_keepalive_response(configNr
,
962 (rndis_keepalive_msg_type
*)
966 /* At least Windows XP emits some undefined RNDIS messages.
967 * In one case those messages seemed to relate to the host
970 pr_warning("%s: unknown RNDIS message 0x%08X len %d\n",
971 __func__
, MsgType
, MsgLength
);
975 for (i
= 0; i
< MsgLength
; i
+= 16) {
977 " %02x %02x %02x %02x"
978 " %02x %02x %02x %02x"
979 " %02x %02x %02x %02x"
980 " %02x %02x %02x %02x"
988 buf
[i
+10], buf
[i
+11],
989 buf
[i
+12], buf
[i
+13],
990 buf
[i
+14], buf
[i
+15]);
993 //print_hex_dump_bytes(__func__, DUMP_PREFIX_OFFSET,
1001 int rndis_register(void (*resp_avail
)(void *v
), void *v
)
1008 for (i
= 0; i
< RNDIS_MAX_CONFIGS
; i
++) {
1009 if (!rndis_per_dev_params
[i
].used
) {
1010 rndis_per_dev_params
[i
].used
= 1;
1011 rndis_per_dev_params
[i
].resp_avail
= resp_avail
;
1012 rndis_per_dev_params
[i
].v
= v
;
1013 rndis_per_dev_params
[i
].max_pkt_per_xfer
= 1;
1014 pr_debug("%s: configNr = %d\n", __func__
, i
);
1018 pr_debug("failed\n");
1023 void rndis_deregister(int configNr
)
1025 pr_debug("%s:\n", __func__
);
1027 if (configNr
>= RNDIS_MAX_CONFIGS
) return;
1028 rndis_per_dev_params
[configNr
].used
= 0;
1031 int rndis_set_param_dev(u8 configNr
, struct net_device
*dev
, u16
*cdc_filter
)
1033 pr_debug("%s:\n", __func__
);
1036 if (configNr
>= RNDIS_MAX_CONFIGS
) return -1;
1038 rndis_per_dev_params
[configNr
].dev
= dev
;
1039 rndis_per_dev_params
[configNr
].filter
= cdc_filter
;
1041 /* reset aggregation stats for every set_alt */
1042 rndis_ul_max_xfer_size_rcvd
= 0;
1043 rndis_ul_max_pkt_per_xfer_rcvd
= 0;
1048 int rndis_set_param_vendor(u8 configNr
, u32 vendorID
, const char *vendorDescr
)
1050 pr_debug("%s:\n", __func__
);
1051 if (!vendorDescr
) return -1;
1052 if (configNr
>= RNDIS_MAX_CONFIGS
) return -1;
1054 rndis_per_dev_params
[configNr
].vendorID
= vendorID
;
1055 rndis_per_dev_params
[configNr
].vendorDescr
= vendorDescr
;
1060 int rndis_set_param_medium(u8 configNr
, u32 medium
, u32 speed
)
1062 pr_debug("%s: %u %u\n", __func__
, medium
, speed
);
1063 if (configNr
>= RNDIS_MAX_CONFIGS
) return -1;
1065 rndis_per_dev_params
[configNr
].medium
= medium
;
1066 rndis_per_dev_params
[configNr
].speed
= speed
;
1071 void rndis_set_max_pkt_xfer(u8 configNr
, u8 max_pkt_per_xfer
)
1073 pr_debug("%s:\n", __func__
);
1075 rndis_per_dev_params
[configNr
].max_pkt_per_xfer
= max_pkt_per_xfer
;
1078 void rndis_add_hdr(struct sk_buff
*skb
)
1080 struct rndis_packet_msg_type
*header
;
1084 header
= (void *)skb_push(skb
, sizeof(*header
));
1085 memset(header
, 0, sizeof *header
);
1086 header
->MessageType
= cpu_to_le32(RNDIS_MSG_PACKET
);
1087 header
->MessageLength
= cpu_to_le32(skb
->len
);
1088 header
->DataOffset
= cpu_to_le32(36);
1089 header
->DataLength
= cpu_to_le32(skb
->len
- sizeof(*header
));
1092 void rndis_free_response(int configNr
, u8
*buf
)
1095 struct list_head
*act
, *tmp
;
1097 list_for_each_safe(act
, tmp
,
1098 &(rndis_per_dev_params
[configNr
].resp_queue
))
1103 r
= list_entry(act
, rndis_resp_t
, list
);
1104 if (r
&& r
->buf
== buf
) {
1111 u8
*rndis_get_next_response(int configNr
, u32
*length
)
1114 struct list_head
*act
, *tmp
;
1116 if (!length
) return NULL
;
1118 list_for_each_safe(act
, tmp
,
1119 &(rndis_per_dev_params
[configNr
].resp_queue
))
1121 r
= list_entry(act
, rndis_resp_t
, list
);
1124 *length
= r
->length
;
1132 static rndis_resp_t
*rndis_add_response(int configNr
, u32 length
)
1136 /* NOTE: this gets copied into ether.c USB_BUFSIZ bytes ... */
1137 r
= kmalloc(sizeof(rndis_resp_t
) + length
, GFP_ATOMIC
);
1138 if (!r
) return NULL
;
1140 r
->buf
= (u8
*)(r
+ 1);
1144 list_add_tail(&r
->list
,
1145 &(rndis_per_dev_params
[configNr
].resp_queue
));
1149 int rndis_rm_hdr(struct gether
*port
,
1150 struct sk_buff
*skb
,
1151 struct sk_buff_head
*list
)
1155 if (skb
->len
> rndis_ul_max_xfer_size_rcvd
)
1156 rndis_ul_max_xfer_size_rcvd
= skb
->len
;
1159 struct rndis_packet_msg_type
*hdr
;
1160 struct sk_buff
*skb2
;
1161 u32 msg_len
, data_offset
, data_len
;
1163 if (skb
->len
< sizeof *hdr
) {
1164 pr_err("invalid rndis pkt: skblen:%u hdr_len:%lu",
1165 skb
->len
, (long)sizeof *hdr
);
1166 dev_kfree_skb_any(skb
);
1170 hdr
= (void *)skb
->data
;
1171 msg_len
= le32_to_cpu(hdr
->MessageLength
);
1172 data_offset
= le32_to_cpu(hdr
->DataOffset
);
1173 data_len
= le32_to_cpu(hdr
->DataLength
);
1175 if (skb
->len
< msg_len
||
1176 ((data_offset
+ data_len
+ 8) > msg_len
)) {
1177 pr_err("invalid rndis message: %d/%d/%d/%d, len:%d\n",
1178 le32_to_cpu(hdr
->MessageType
),
1179 msg_len
, data_offset
, data_len
, skb
->len
);
1180 dev_kfree_skb_any(skb
);
1184 if (le32_to_cpu(hdr
->MessageType
) != RNDIS_MSG_PACKET
) {
1185 pr_err("invalid rndis message: %d/%d/%d/%d, len:%d\n",
1186 le32_to_cpu(hdr
->MessageType
),
1187 msg_len
, data_offset
, data_len
, skb
->len
);
1188 dev_kfree_skb_any(skb
);
1194 skb_pull(skb
, data_offset
+ 8);
1196 if (data_len
== skb
->len
||
1197 data_len
== (skb
->len
- 1)) {
1198 skb_trim(skb
, data_len
);
1202 skb2
= skb_clone(skb
, GFP_ATOMIC
);
1204 pr_err("%s:skb clone failed\n", __func__
);
1205 dev_kfree_skb_any(skb
);
1209 skb_pull(skb
, msg_len
- sizeof *hdr
);
1210 skb_trim(skb2
, data_len
);
1211 skb_queue_tail(list
, skb2
);
1214 if (num_pkts
> rndis_ul_max_pkt_per_xfer_rcvd
)
1215 rndis_ul_max_pkt_per_xfer_rcvd
= num_pkts
;
1217 skb_queue_tail(list
, skb
);
1222 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
1224 static int rndis_proc_show(struct seq_file
*m
, void *v
)
1226 rndis_params
*param
= m
->private;
1235 "vendor ID : 0x%08X\n"
1237 "ul-max-xfer-size:%d max-xfer-size-rcvd: %d\n"
1238 "ul-max-pkts-per-xfer:%d max-pkts-per-xfer-rcvd:%d\n",
1239 param
->confignr
, (param
->used
) ? "y" : "n",
1241 switch (param
->state
) {
1242 case RNDIS_UNINITIALIZED
:
1243 s
= "RNDIS_UNINITIALIZED"; break;
1244 case RNDIS_INITIALIZED
:
1245 s
= "RNDIS_INITIALIZED"; break;
1246 case RNDIS_DATA_INITIALIZED
:
1247 s
= "RNDIS_DATA_INITIALIZED"; break;
1250 (param
->media_state
) ? 0 : param
->speed
*100,
1251 (param
->media_state
) ? "disconnected" : "connected",
1252 param
->vendorID
, param
->vendorDescr
,
1253 param
->max_pkt_per_xfer
*
1254 (param
->dev
->mtu
+ sizeof(struct ethhdr
) +
1255 sizeof(struct rndis_packet_msg_type
) + 22),
1256 rndis_ul_max_xfer_size_rcvd
,
1257 param
->max_pkt_per_xfer
,
1258 rndis_ul_max_pkt_per_xfer_rcvd
);
1262 static ssize_t
rndis_proc_write(struct file
*file
, const char __user
*buffer
,
1263 size_t count
, loff_t
*ppos
)
1265 rndis_params
*p
= PDE_DATA(file_inode(file
));
1267 int i
, fl_speed
= 0;
1269 for (i
= 0; i
< count
; i
++) {
1271 if (get_user(c
, buffer
))
1285 speed
= speed
* 10 + c
- '0';
1289 rndis_signal_connect(p
->confignr
);
1293 rndis_signal_disconnect(p
->confignr
);
1296 if (fl_speed
) p
->speed
= speed
;
1297 else pr_debug("%c is not valid\n", c
);
1307 static int rndis_proc_open(struct inode
*inode
, struct file
*file
)
1309 return single_open(file
, rndis_proc_show
, PDE_DATA(inode
));
1312 static const struct file_operations rndis_proc_fops
= {
1313 .owner
= THIS_MODULE
,
1314 .open
= rndis_proc_open
,
1316 .llseek
= seq_lseek
,
1317 .release
= single_release
,
1318 .write
= rndis_proc_write
,
1321 #define NAME_TEMPLATE "driver/rndis-%03d"
1323 static struct proc_dir_entry
*rndis_connect_state
[RNDIS_MAX_CONFIGS
];
1325 #endif /* CONFIG_USB_GADGET_DEBUG_FILES */
1327 static int rndis_test_proc_show(struct seq_file
*m
, void *v
)
1329 seq_printf(m
, "[RNDIS] rx_in %lu, rx_out %lu, rx_nomem %lu, rx_error %lu, tx_in %lu, tx_out %lu, tx_busy %lu, tx_complete %lu, last_msg_id: 0x%x, last_resp_id: 0x%x, RNDIS reset cnt: %lu, queue stopped? %d\n",
1330 rndis_test_rx_usb_in
, rndis_test_rx_net_out
, rndis_test_rx_nomem
, rndis_test_rx_error
, rndis_test_tx_net_in
,
1331 rndis_test_tx_usb_out
, rndis_test_tx_busy
, rndis_test_tx_complete
, rndis_test_last_msg_id
, rndis_test_last_resp_id
, rndis_test_reset_msg_cnt
,
1332 netif_queue_stopped(rndis_per_dev_params
[0].dev
)) ;
1337 static int rndis_test_proc_open(struct inode
*inode
, struct file
*file
)
1339 //return single_open(file, rndis_test_proc_show, inode->i_private);
1340 return single_open(file
, rndis_test_proc_show
, inode
->i_private
);
1343 static ssize_t
rndis_test_proc_write(struct file
*file
, const char __user
*buf
, size_t length
, loff_t
*ppos
)
1347 if (length
>= sizeof(msg
)) {
1350 if (copy_from_user(msg
, buf
, length
))
1358 static bool rndis_initialized
;
1360 static const struct file_operations rndis_test_proc_fops
= {
1361 .owner
= THIS_MODULE
,
1362 .open
= rndis_test_proc_open
,
1363 .write
= rndis_test_proc_write
,
1365 .llseek
= seq_lseek
,
1370 static struct proc_dir_entry
*rndis_test_proc
;
1372 int rndis_init(void)
1376 if (rndis_initialized
)
1379 rndis_test_proc
= proc_create("rndis_test_proc", 0444, NULL
,
1380 &rndis_test_proc_fops
);
1382 for (i
= 0; i
< RNDIS_MAX_CONFIGS
; i
++) {
1383 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
1386 sprintf(name
, NAME_TEMPLATE
, i
);
1387 rndis_connect_state
[i
] = proc_create_data(name
, 0660, NULL
,
1389 (void *)(rndis_per_dev_params
+ i
));
1390 if (!rndis_connect_state
[i
]) {
1391 pr_debug("%s: remove entries", __func__
);
1393 sprintf(name
, NAME_TEMPLATE
, --i
);
1394 remove_proc_entry(name
, NULL
);
1400 rndis_per_dev_params
[i
].confignr
= i
;
1401 rndis_per_dev_params
[i
].used
= 0;
1402 rndis_per_dev_params
[i
].state
= RNDIS_UNINITIALIZED
;
1403 rndis_per_dev_params
[i
].media_state
1404 = RNDIS_MEDIA_STATE_DISCONNECTED
;
1405 INIT_LIST_HEAD(&(rndis_per_dev_params
[i
].resp_queue
));
1408 rndis_initialized
= true;
1412 void rndis_exit(void)
1414 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
1419 if (!rndis_initialized
)
1421 rndis_initialized
= false;
1423 remove_proc_entry("rndis_test_proc", NULL
);
1425 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
1426 for (i
= 0; i
< RNDIS_MAX_CONFIGS
; i
++) {
1427 sprintf(name
, NAME_TEMPLATE
, i
);
1428 remove_proc_entry(name
, NULL
);