1/* $NetBSD: if_urndis.c,v 1.13 2016/07/14 04:00:46 msaitoh Exp $ */
2/* $OpenBSD: if_urndis.c,v 1.31 2011/07/03 15:47:17 matthew Exp $ */
3
4/*
5 * Copyright (c) 2010 Jonathan Armani <armani@openbsd.org>
6 * Copyright (c) 2010 Fabien Romano <fabien@openbsd.org>
7 * Copyright (c) 2010 Michael Knudsen <mk@openbsd.org>
8 * All rights reserved.
9 *
10 * Permission to use, copy, modify, and distribute this software for any
11 * purpose with or without fee is hereby granted, provided that the above
12 * copyright notice and this permission notice appear in all copies.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
15 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
16 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
17 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
18 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
19 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
20 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21 */
22
23#include <sys/cdefs.h>
24__KERNEL_RCSID(0, "$NetBSD: if_urndis.c,v 1.13 2016/07/14 04:00:46 msaitoh Exp $");
25
26#include <sys/param.h>
27#include <sys/systm.h>
28#include <sys/sockio.h>
29#include <sys/rwlock.h>
30#include <sys/mbuf.h>
31#include <sys/kmem.h>
32#include <sys/kernel.h>
33#include <sys/proc.h>
34#include <sys/socket.h>
35#include <sys/device.h>
36
37#include <net/if.h>
38#include <net/if_dl.h>
39#include <net/if_media.h>
40#include <net/if_ether.h>
41
42#include <net/bpf.h>
43
44#include <sys/bus.h>
45#include <dev/usb/usb.h>
46#include <dev/usb/usbdi.h>
47#include <dev/usb/usbdi_util.h>
48#include <dev/usb/usbdivar.h>
49#include <dev/usb/usbdevs.h>
50#include <dev/usb/usbcdc.h>
51
52#include <dev/usb/if_urndisreg.h>
53
54#ifdef URNDIS_DEBUG
55#define DPRINTF(x) do { printf x; } while (0)
56#else
57#define DPRINTF(x)
58#endif
59
60#define DEVNAME(sc) (device_xname(sc->sc_dev))
61
62#define ETHER_ALIGN 2
63#define URNDIS_RESPONSE_LEN 0x400
64
65
66static int urndis_newbuf(struct urndis_softc *, struct urndis_chain *);
67
68static int urndis_ioctl(struct ifnet *, unsigned long, void *);
69#if 0
70static void urndis_watchdog(struct ifnet *);
71#endif
72
73static void urndis_start(struct ifnet *);
74static void urndis_rxeof(struct usbd_xfer *, void *, usbd_status);
75static void urndis_txeof(struct usbd_xfer *, void *, usbd_status);
76static int urndis_rx_list_init(struct urndis_softc *);
77static int urndis_tx_list_init(struct urndis_softc *);
78
79static int urndis_init(struct ifnet *);
80static void urndis_stop(struct ifnet *);
81
82static usbd_status urndis_ctrl_msg(struct urndis_softc *, uint8_t, uint8_t,
83 uint16_t, uint16_t, void *, size_t);
84static usbd_status urndis_ctrl_send(struct urndis_softc *, void *, size_t);
85static struct urndis_comp_hdr *urndis_ctrl_recv(struct urndis_softc *);
86
87static uint32_t urndis_ctrl_handle(struct urndis_softc *,
88 struct urndis_comp_hdr *, void **, size_t *);
89static uint32_t urndis_ctrl_handle_init(struct urndis_softc *,
90 const struct urndis_comp_hdr *);
91static uint32_t urndis_ctrl_handle_query(struct urndis_softc *,
92 const struct urndis_comp_hdr *, void **, size_t *);
93static uint32_t urndis_ctrl_handle_reset(struct urndis_softc *,
94 const struct urndis_comp_hdr *);
95
96static uint32_t urndis_ctrl_init(struct urndis_softc *);
97#if 0
98static uint32_t urndis_ctrl_halt(struct urndis_softc *);
99#endif
100static uint32_t urndis_ctrl_query(struct urndis_softc *, uint32_t, void *,
101 size_t, void **, size_t *);
102static uint32_t urndis_ctrl_set(struct urndis_softc *, uint32_t, void *,
103 size_t);
104#if 0
105static uint32_t urndis_ctrl_set_param(struct urndis_softc *, const char *,
106 uint32_t, void *, size_t);
107static uint32_t urndis_ctrl_reset(struct urndis_softc *);
108static uint32_t urndis_ctrl_keepalive(struct urndis_softc *);
109#endif
110
111static int urndis_encap(struct urndis_softc *, struct mbuf *, int);
112static void urndis_decap(struct urndis_softc *, struct urndis_chain *,
113 uint32_t);
114
115static int urndis_match(device_t, cfdata_t, void *);
116static void urndis_attach(device_t, device_t, void *);
117static int urndis_detach(device_t, int);
118static int urndis_activate(device_t, enum devact);
119
120CFATTACH_DECL_NEW(urndis, sizeof(struct urndis_softc),
121 urndis_match, urndis_attach, urndis_detach, urndis_activate);
122
123/*
124 * Supported devices that we can't match by class IDs.
125 */
126static const struct usb_devno urndis_devs[] = {
127 { USB_VENDOR_HTC, USB_PRODUCT_HTC_ANDROID },
128 { USB_VENDOR_SAMSUNG, USB_PRODUCT_SAMSUNG_ANDROID2 },
129};
130
131static usbd_status
132urndis_ctrl_msg(struct urndis_softc *sc, uint8_t rt, uint8_t r,
133 uint16_t index, uint16_t value, void *buf, size_t buflen)
134{
135 usb_device_request_t req;
136
137 req.bmRequestType = rt;
138 req.bRequest = r;
139 USETW(req.wValue, value);
140 USETW(req.wIndex, index);
141 USETW(req.wLength, buflen);
142
143 return usbd_do_request(sc->sc_udev, &req, buf);
144}
145
146static usbd_status
147urndis_ctrl_send(struct urndis_softc *sc, void *buf, size_t len)
148{
149 usbd_status err;
150
151 if (sc->sc_dying)
152 return(0);
153
154 err = urndis_ctrl_msg(sc, UT_WRITE_CLASS_INTERFACE, UR_GET_STATUS,
155 sc->sc_ifaceno_ctl, 0, buf, len);
156
157 if (err != USBD_NORMAL_COMPLETION)
158 printf("%s: %s\n", DEVNAME(sc), usbd_errstr(err));
159
160 return err;
161}
162
163static struct urndis_comp_hdr *
164urndis_ctrl_recv(struct urndis_softc *sc)
165{
166 struct urndis_comp_hdr *hdr;
167 char *buf;
168 usbd_status err;
169
170 buf = kmem_alloc(URNDIS_RESPONSE_LEN, KM_SLEEP);
171 if (buf == NULL) {
172 printf("%s: out of memory\n", DEVNAME(sc));
173 return NULL;
174 }
175
176 err = urndis_ctrl_msg(sc, UT_READ_CLASS_INTERFACE, UR_CLEAR_FEATURE,
177 sc->sc_ifaceno_ctl, 0, buf, URNDIS_RESPONSE_LEN);
178
179 if (err != USBD_NORMAL_COMPLETION && err != USBD_SHORT_XFER) {
180 printf("%s: %s\n", DEVNAME(sc), usbd_errstr(err));
181 kmem_free(buf, URNDIS_RESPONSE_LEN);
182 return NULL;
183 }
184
185 hdr = (struct urndis_comp_hdr *)buf;
186 DPRINTF(("%s: urndis_ctrl_recv: type 0x%x len %u\n",
187 DEVNAME(sc),
188 le32toh(hdr->rm_type),
189 le32toh(hdr->rm_len)));
190
191 if (le32toh(hdr->rm_len) > URNDIS_RESPONSE_LEN) {
192 printf("%s: ctrl message error: wrong size %u > %u\n",
193 DEVNAME(sc),
194 le32toh(hdr->rm_len),
195 URNDIS_RESPONSE_LEN);
196 kmem_free(buf, URNDIS_RESPONSE_LEN);
197 return NULL;
198 }
199
200 return hdr;
201}
202
203static uint32_t
204urndis_ctrl_handle(struct urndis_softc *sc, struct urndis_comp_hdr *hdr,
205 void **buf, size_t *bufsz)
206{
207 uint32_t rval;
208
209 DPRINTF(("%s: urndis_ctrl_handle\n", DEVNAME(sc)));
210
211 if (buf && bufsz) {
212 *buf = NULL;
213 *bufsz = 0;
214 }
215
216 switch (le32toh(hdr->rm_type)) {
217 case REMOTE_NDIS_INITIALIZE_CMPLT:
218 rval = urndis_ctrl_handle_init(sc, hdr);
219 break;
220
221 case REMOTE_NDIS_QUERY_CMPLT:
222 rval = urndis_ctrl_handle_query(sc, hdr, buf, bufsz);
223 break;
224
225 case REMOTE_NDIS_RESET_CMPLT:
226 rval = urndis_ctrl_handle_reset(sc, hdr);
227 break;
228
229 case REMOTE_NDIS_KEEPALIVE_CMPLT:
230 case REMOTE_NDIS_SET_CMPLT:
231 rval = le32toh(hdr->rm_status);
232 break;
233
234 default:
235 printf("%s: ctrl message error: unknown event 0x%x\n",
236 DEVNAME(sc), le32toh(hdr->rm_type));
237 rval = RNDIS_STATUS_FAILURE;
238 }
239
240 kmem_free(hdr, URNDIS_RESPONSE_LEN);
241
242 return rval;
243}
244
245static uint32_t
246urndis_ctrl_handle_init(struct urndis_softc *sc,
247 const struct urndis_comp_hdr *hdr)
248{
249 const struct urndis_init_comp *msg;
250
251 msg = (const struct urndis_init_comp *) hdr;
252
253 DPRINTF(("%s: urndis_ctrl_handle_init: len %u rid %u status 0x%x "
254 "ver_major %u ver_minor %u devflags 0x%x medium 0x%x pktmaxcnt %u "
255 "pktmaxsz %u align %u aflistoffset %u aflistsz %u\n",
256 DEVNAME(sc),
257 le32toh(msg->rm_len),
258 le32toh(msg->rm_rid),
259 le32toh(msg->rm_status),
260 le32toh(msg->rm_ver_major),
261 le32toh(msg->rm_ver_minor),
262 le32toh(msg->rm_devflags),
263 le32toh(msg->rm_medium),
264 le32toh(msg->rm_pktmaxcnt),
265 le32toh(msg->rm_pktmaxsz),
266 le32toh(msg->rm_align),
267 le32toh(msg->rm_aflistoffset),
268 le32toh(msg->rm_aflistsz)));
269
270 if (le32toh(msg->rm_status) != RNDIS_STATUS_SUCCESS) {
271 printf("%s: init failed 0x%x\n",
272 DEVNAME(sc),
273 le32toh(msg->rm_status));
274
275 return le32toh(msg->rm_status);
276 }
277
278 if (le32toh(msg->rm_devflags) != RNDIS_DF_CONNECTIONLESS) {
279 printf("%s: wrong device type (current type: 0x%x)\n",
280 DEVNAME(sc),
281 le32toh(msg->rm_devflags));
282
283 return RNDIS_STATUS_FAILURE;
284 }
285
286 if (le32toh(msg->rm_medium) != RNDIS_MEDIUM_802_3) {
287 printf("%s: medium not 802.3 (current medium: 0x%x)\n",
288 DEVNAME(sc), le32toh(msg->rm_medium));
289
290 return RNDIS_STATUS_FAILURE;
291 }
292
293 sc->sc_lim_pktsz = le32toh(msg->rm_pktmaxsz);
294
295 return le32toh(msg->rm_status);
296}
297
298static uint32_t
299urndis_ctrl_handle_query(struct urndis_softc *sc,
300 const struct urndis_comp_hdr *hdr, void **buf, size_t *bufsz)
301{
302 const struct urndis_query_comp *msg;
303
304 msg = (const struct urndis_query_comp *) hdr;
305
306 DPRINTF(("%s: urndis_ctrl_handle_query: len %u rid %u status 0x%x "
307 "buflen %u bufoff %u\n",
308 DEVNAME(sc),
309 le32toh(msg->rm_len),
310 le32toh(msg->rm_rid),
311 le32toh(msg->rm_status),
312 le32toh(msg->rm_infobuflen),
313 le32toh(msg->rm_infobufoffset)));
314
315 if (buf && bufsz) {
316 *buf = NULL;
317 *bufsz = 0;
318 }
319
320 if (le32toh(msg->rm_status) != RNDIS_STATUS_SUCCESS) {
321 printf("%s: query failed 0x%x\n",
322 DEVNAME(sc),
323 le32toh(msg->rm_status));
324
325 return le32toh(msg->rm_status);
326 }
327
328 if (le32toh(msg->rm_infobuflen) + le32toh(msg->rm_infobufoffset) +
329 RNDIS_HEADER_OFFSET > le32toh(msg->rm_len)) {
330 printf("%s: ctrl message error: invalid query info "
331 "len/offset/end_position(%u/%u/%u) -> "
332 "go out of buffer limit %u\n",
333 DEVNAME(sc),
334 le32toh(msg->rm_infobuflen),
335 le32toh(msg->rm_infobufoffset),
336 le32toh(msg->rm_infobuflen) +
337 le32toh(msg->rm_infobufoffset) + (uint32_t)RNDIS_HEADER_OFFSET,
338 le32toh(msg->rm_len));
339 return RNDIS_STATUS_FAILURE;
340 }
341
342 if (buf && bufsz) {
343 *buf = kmem_alloc(le32toh(msg->rm_infobuflen), KM_SLEEP);
344 if (*buf == NULL) {
345 printf("%s: out of memory\n", DEVNAME(sc));
346 return RNDIS_STATUS_FAILURE;
347 } else {
348 const char *p;
349 *bufsz = le32toh(msg->rm_infobuflen);
350
351 p = (const char *)&msg->rm_rid;
352 p += le32toh(msg->rm_infobufoffset);
353 memcpy(*buf, p, le32toh(msg->rm_infobuflen));
354 }
355 }
356
357 return le32toh(msg->rm_status);
358}
359
360static uint32_t
361urndis_ctrl_handle_reset(struct urndis_softc *sc,
362 const struct urndis_comp_hdr *hdr)
363{
364 const struct urndis_reset_comp *msg;
365 uint32_t rval;
366
367 msg = (const struct urndis_reset_comp *) hdr;
368
369 rval = le32toh(msg->rm_status);
370
371 DPRINTF(("%s: urndis_ctrl_handle_reset: len %u status 0x%x "
372 "adrreset %u\n",
373 DEVNAME(sc),
374 le32toh(msg->rm_len),
375 rval,
376 le32toh(msg->rm_adrreset)));
377
378 if (rval != RNDIS_STATUS_SUCCESS) {
379 printf("%s: reset failed 0x%x\n", DEVNAME(sc), rval);
380 return rval;
381 }
382
383 if (le32toh(msg->rm_adrreset) != 0) {
384 uint32_t filter;
385
386 filter = htole32(sc->sc_filter);
387 rval = urndis_ctrl_set(sc, OID_GEN_CURRENT_PACKET_FILTER,
388 &filter, sizeof(filter));
389 if (rval != RNDIS_STATUS_SUCCESS) {
390 printf("%s: unable to reset data filters\n",
391 DEVNAME(sc));
392 return rval;
393 }
394 }
395
396 return rval;
397}
398
399static uint32_t
400urndis_ctrl_init(struct urndis_softc *sc)
401{
402 struct urndis_init_req *msg;
403 uint32_t rval;
404 struct urndis_comp_hdr *hdr;
405
406 msg = kmem_alloc(sizeof(*msg), KM_SLEEP);
407 if (msg == NULL) {
408 printf("%s: out of memory\n", DEVNAME(sc));
409 return RNDIS_STATUS_FAILURE;
410 }
411
412 msg->rm_type = htole32(REMOTE_NDIS_INITIALIZE_MSG);
413 msg->rm_len = htole32(sizeof(*msg));
414 msg->rm_rid = htole32(0);
415 msg->rm_ver_major = htole32(1);
416 msg->rm_ver_minor = htole32(1);
417 msg->rm_max_xfersz = htole32(RNDIS_BUFSZ);
418
419 DPRINTF(("%s: urndis_ctrl_init send: type %u len %u rid %u ver_major %u "
420 "ver_minor %u max_xfersz %u\n",
421 DEVNAME(sc),
422 le32toh(msg->rm_type),
423 le32toh(msg->rm_len),
424 le32toh(msg->rm_rid),
425 le32toh(msg->rm_ver_major),
426 le32toh(msg->rm_ver_minor),
427 le32toh(msg->rm_max_xfersz)));
428
429 rval = urndis_ctrl_send(sc, msg, sizeof(*msg));
430 kmem_free(msg, sizeof(*msg));
431
432 if (rval != RNDIS_STATUS_SUCCESS) {
433 printf("%s: init failed\n", DEVNAME(sc));
434 return rval;
435 }
436
437 if ((hdr = urndis_ctrl_recv(sc)) == NULL) {
438 printf("%s: unable to get init response\n", DEVNAME(sc));
439 return RNDIS_STATUS_FAILURE;
440 }
441 rval = urndis_ctrl_handle(sc, hdr, NULL, NULL);
442
443 return rval;
444}
445
446#if 0
447static uint32_t
448urndis_ctrl_halt(struct urndis_softc *sc)
449{
450 struct urndis_halt_req *msg;
451 uint32_t rval;
452
453 msg = kmem_alloc(sizeof(*msg), KM_SLEEP);
454 if (msg == NULL) {
455 printf("%s: out of memory\n", DEVNAME(sc));
456 return RNDIS_STATUS_FAILURE;
457 }
458
459 msg->rm_type = htole32(REMOTE_NDIS_HALT_MSG);
460 msg->rm_len = htole32(sizeof(*msg));
461 msg->rm_rid = 0;
462
463 DPRINTF(("%s: urndis_ctrl_halt send: type %u len %u rid %u\n",
464 DEVNAME(sc),
465 le32toh(msg->rm_type),
466 le32toh(msg->rm_len),
467 le32toh(msg->rm_rid)));
468
469 rval = urndis_ctrl_send(sc, msg, sizeof(*msg));
470 kmem_free(msg, sizeof(*msg));
471
472 if (rval != RNDIS_STATUS_SUCCESS)
473 printf("%s: halt failed\n", DEVNAME(sc));
474
475 return rval;
476}
477#endif
478
479static uint32_t
480urndis_ctrl_query(struct urndis_softc *sc, uint32_t oid,
481 void *qbuf, size_t qlen,
482 void **rbuf, size_t *rbufsz)
483{
484 struct urndis_query_req *msg;
485 uint32_t rval;
486 struct urndis_comp_hdr *hdr;
487
488 msg = kmem_alloc(sizeof(*msg) + qlen, KM_SLEEP);
489 if (msg == NULL) {
490 printf("%s: out of memory\n", DEVNAME(sc));
491 return RNDIS_STATUS_FAILURE;
492 }
493
494 msg->rm_type = htole32(REMOTE_NDIS_QUERY_MSG);
495 msg->rm_len = htole32(sizeof(*msg) + qlen);
496 msg->rm_rid = 0; /* XXX */
497 msg->rm_oid = htole32(oid);
498 msg->rm_infobuflen = htole32(qlen);
499 if (qlen != 0) {
500 msg->rm_infobufoffset = htole32(20);
501 memcpy((char*)msg + 20, qbuf, qlen);
502 } else
503 msg->rm_infobufoffset = 0;
504 msg->rm_devicevchdl = 0;
505
506 DPRINTF(("%s: urndis_ctrl_query send: type %u len %u rid %u oid 0x%x "
507 "infobuflen %u infobufoffset %u devicevchdl %u\n",
508 DEVNAME(sc),
509 le32toh(msg->rm_type),
510 le32toh(msg->rm_len),
511 le32toh(msg->rm_rid),
512 le32toh(msg->rm_oid),
513 le32toh(msg->rm_infobuflen),
514 le32toh(msg->rm_infobufoffset),
515 le32toh(msg->rm_devicevchdl)));
516
517 rval = urndis_ctrl_send(sc, msg, sizeof(*msg));
518 kmem_free(msg, sizeof(*msg) + qlen);
519
520 if (rval != RNDIS_STATUS_SUCCESS) {
521 printf("%s: query failed\n", DEVNAME(sc));
522 return rval;
523 }
524
525 if ((hdr = urndis_ctrl_recv(sc)) == NULL) {
526 printf("%s: unable to get query response\n", DEVNAME(sc));
527 return RNDIS_STATUS_FAILURE;
528 }
529 rval = urndis_ctrl_handle(sc, hdr, rbuf, rbufsz);
530
531 return rval;
532}
533
534static uint32_t
535urndis_ctrl_set(struct urndis_softc *sc, uint32_t oid, void *buf, size_t len)
536{
537 struct urndis_set_req *msg;
538 uint32_t rval;
539 struct urndis_comp_hdr *hdr;
540
541 msg = kmem_alloc(sizeof(*msg) + len, KM_SLEEP);
542 if (msg == NULL) {
543 printf("%s: out of memory\n", DEVNAME(sc));
544 return RNDIS_STATUS_FAILURE;
545 }
546
547 msg->rm_type = htole32(REMOTE_NDIS_SET_MSG);
548 msg->rm_len = htole32(sizeof(*msg) + len);
549 msg->rm_rid = 0; /* XXX */
550 msg->rm_oid = htole32(oid);
551 msg->rm_infobuflen = htole32(len);
552 if (len != 0) {
553 msg->rm_infobufoffset = htole32(20);
554 memcpy((char*)msg + 20, buf, len);
555 } else
556 msg->rm_infobufoffset = 0;
557 msg->rm_devicevchdl = 0;
558
559 DPRINTF(("%s: urndis_ctrl_set send: type %u len %u rid %u oid 0x%x "
560 "infobuflen %u infobufoffset %u devicevchdl %u\n",
561 DEVNAME(sc),
562 le32toh(msg->rm_type),
563 le32toh(msg->rm_len),
564 le32toh(msg->rm_rid),
565 le32toh(msg->rm_oid),
566 le32toh(msg->rm_infobuflen),
567 le32toh(msg->rm_infobufoffset),
568 le32toh(msg->rm_devicevchdl)));
569
570 rval = urndis_ctrl_send(sc, msg, sizeof(*msg));
571 kmem_free(msg, sizeof(*msg) + len);
572
573 if (rval != RNDIS_STATUS_SUCCESS) {
574 printf("%s: set failed\n", DEVNAME(sc));
575 return rval;
576 }
577
578 if ((hdr = urndis_ctrl_recv(sc)) == NULL) {
579 printf("%s: unable to get set response\n", DEVNAME(sc));
580 return RNDIS_STATUS_FAILURE;
581 }
582 rval = urndis_ctrl_handle(sc, hdr, NULL, NULL);
583 if (rval != RNDIS_STATUS_SUCCESS)
584 printf("%s: set failed 0x%x\n", DEVNAME(sc), rval);
585
586 return rval;
587}
588
589#if 0
590static uint32_t
591urndis_ctrl_set_param(struct urndis_softc *sc,
592 const char *name,
593 uint32_t type,
594 void *buf,
595 size_t len)
596{
597 struct urndis_set_parameter *param;
598 uint32_t rval;
599 size_t namelen, tlen;
600
601 if (name)
602 namelen = strlen(name);
603 else
604 namelen = 0;
605 tlen = sizeof(*param) + len + namelen;
606 param = kmem_alloc(tlen, KM_SLEEP);
607 if (param == NULL) {
608 printf("%s: out of memory\n", DEVNAME(sc));
609 return RNDIS_STATUS_FAILURE;
610 }
611
612 param->rm_namelen = htole32(namelen);
613 param->rm_valuelen = htole32(len);
614 param->rm_type = htole32(type);
615 if (namelen != 0) {
616 param->rm_nameoffset = htole32(20);
617 memcpy(param + 20, name, namelen);
618 } else
619 param->rm_nameoffset = 0;
620 if (len != 0) {
621 param->rm_valueoffset = htole32(20 + namelen);
622 memcpy(param + 20 + namelen, buf, len);
623 } else
624 param->rm_valueoffset = 0;
625
626 DPRINTF(("%s: urndis_ctrl_set_param send: nameoffset %u namelen %u "
627 "type 0x%x valueoffset %u valuelen %u\n",
628 DEVNAME(sc),
629 le32toh(param->rm_nameoffset),
630 le32toh(param->rm_namelen),
631 le32toh(param->rm_type),
632 le32toh(param->rm_valueoffset),
633 le32toh(param->rm_valuelen)));
634
635 rval = urndis_ctrl_set(sc, OID_GEN_RNDIS_CONFIG_PARAMETER, param, tlen);
636 kmem_free(param, tlen);
637 if (rval != RNDIS_STATUS_SUCCESS)
638 printf("%s: set param failed 0x%x\n", DEVNAME(sc), rval);
639
640 return rval;
641}
642
643/* XXX : adrreset, get it from response */
644static uint32_t
645urndis_ctrl_reset(struct urndis_softc *sc)
646{
647 struct urndis_reset_req *reset;
648 uint32_t rval;
649 struct urndis_comp_hdr *hdr;
650
651 reset = kmem_alloc(sizeof(*reset), KM_SLEEP);
652 if (reset == NULL) {
653 printf("%s: out of memory\n", DEVNAME(sc));
654 return RNDIS_STATUS_FAILURE;
655 }
656
657 reset->rm_type = htole32(REMOTE_NDIS_RESET_MSG);
658 reset->rm_len = htole32(sizeof(*reset));
659 reset->rm_rid = 0; /* XXX rm_rid == reserved ... remove ? */
660
661 DPRINTF(("%s: urndis_ctrl_reset send: type %u len %u rid %u\n",
662 DEVNAME(sc),
663 le32toh(reset->rm_type),
664 le32toh(reset->rm_len),
665 le32toh(reset->rm_rid)));
666
667 rval = urndis_ctrl_send(sc, reset, sizeof(*reset));
668 kmem_free(reset, sizeof(*reset));
669
670 if (rval != RNDIS_STATUS_SUCCESS) {
671 printf("%s: reset failed\n", DEVNAME(sc));
672 return rval;
673 }
674
675 if ((hdr = urndis_ctrl_recv(sc)) == NULL) {
676 printf("%s: unable to get reset response\n", DEVNAME(sc));
677 return RNDIS_STATUS_FAILURE;
678 }
679 rval = urndis_ctrl_handle(sc, hdr, NULL, NULL);
680
681 return rval;
682}
683
684static uint32_t
685urndis_ctrl_keepalive(struct urndis_softc *sc)
686{
687 struct urndis_keepalive_req *keep;
688 uint32_t rval;
689 struct urndis_comp_hdr *hdr;
690
691 keep = kmem_alloc(sizeof(*keep), KM_SLEEP);
692 if (keep == NULL) {
693 printf("%s: out of memory\n", DEVNAME(sc));
694 return RNDIS_STATUS_FAILURE;
695 }
696
697 keep->rm_type = htole32(REMOTE_NDIS_KEEPALIVE_MSG);
698 keep->rm_len = htole32(sizeof(*keep));
699 keep->rm_rid = 0; /* XXX rm_rid == reserved ... remove ? */
700
701 DPRINTF(("%s: urndis_ctrl_keepalive: type %u len %u rid %u\n",
702 DEVNAME(sc),
703 le32toh(keep->rm_type),
704 le32toh(keep->rm_len),
705 le32toh(keep->rm_rid)));
706
707 rval = urndis_ctrl_send(sc, keep, sizeof(*keep));
708 kmem_free(keep, sizeof(*keep));
709
710 if (rval != RNDIS_STATUS_SUCCESS) {
711 printf("%s: keepalive failed\n", DEVNAME(sc));
712 return rval;
713 }
714
715 if ((hdr = urndis_ctrl_recv(sc)) == NULL) {
716 printf("%s: unable to get keepalive response\n", DEVNAME(sc));
717 return RNDIS_STATUS_FAILURE;
718 }
719 rval = urndis_ctrl_handle(sc, hdr, NULL, NULL);
720 if (rval != RNDIS_STATUS_SUCCESS) {
721 printf("%s: keepalive failed 0x%x\n", DEVNAME(sc), rval);
722 urndis_ctrl_reset(sc);
723 }
724
725 return rval;
726}
727#endif
728
729static int
730urndis_encap(struct urndis_softc *sc, struct mbuf *m, int idx)
731{
732 struct urndis_chain *c;
733 usbd_status err;
734 struct urndis_packet_msg *msg;
735
736 c = &sc->sc_data.sc_tx_chain[idx];
737
738 msg = (struct urndis_packet_msg *)c->sc_buf;
739
740 memset(msg, 0, sizeof(*msg));
741 msg->rm_type = htole32(REMOTE_NDIS_PACKET_MSG);
742 msg->rm_len = htole32(sizeof(*msg) + m->m_pkthdr.len);
743
744 msg->rm_dataoffset = htole32(RNDIS_DATA_OFFSET);
745 msg->rm_datalen = htole32(m->m_pkthdr.len);
746
747 m_copydata(m, 0, m->m_pkthdr.len,
748 ((char*)msg + RNDIS_DATA_OFFSET + RNDIS_HEADER_OFFSET));
749
750 DPRINTF(("%s: urndis_encap type 0x%x len %u data(off %u len %u)\n",
751 DEVNAME(sc),
752 le32toh(msg->rm_type),
753 le32toh(msg->rm_len),
754 le32toh(msg->rm_dataoffset),
755 le32toh(msg->rm_datalen)));
756
757 c->sc_mbuf = m;
758
759 usbd_setup_xfer(c->sc_xfer, c, c->sc_buf, le32toh(msg->rm_len),
760 USBD_FORCE_SHORT_XFER, 10000, urndis_txeof);
761
762 /* Transmit */
763 err = usbd_transfer(c->sc_xfer);
764 if (err != USBD_IN_PROGRESS) {
765 urndis_stop(GET_IFP(sc));
766 return(EIO);
767 }
768
769 sc->sc_data.sc_tx_cnt++;
770
771 return(0);
772}
773
774static void
775urndis_decap(struct urndis_softc *sc, struct urndis_chain *c, uint32_t len)
776{
777 struct mbuf *m;
778 struct urndis_packet_msg *msg;
779 struct ifnet *ifp;
780 int s;
781 int offset;
782
783 ifp = GET_IFP(sc);
784 offset = 0;
785
786 while (len > 0) {
787 msg = (struct urndis_packet_msg *)((char*)c->sc_buf + offset);
788 m = c->sc_mbuf;
789
790 DPRINTF(("%s: urndis_decap buffer size left %u\n", DEVNAME(sc),
791 len));
792
793 if (len < sizeof(*msg)) {
794 printf("%s: urndis_decap invalid buffer len %u < "
795 "minimum header %zu\n",
796 DEVNAME(sc),
797 len,
798 sizeof(*msg));
799 return;
800 }
801
802 DPRINTF(("%s: urndis_decap len %u data(off:%u len:%u) "
803 "oobdata(off:%u len:%u nb:%u) perpacket(off:%u len:%u)\n",
804 DEVNAME(sc),
805 le32toh(msg->rm_len),
806 le32toh(msg->rm_dataoffset),
807 le32toh(msg->rm_datalen),
808 le32toh(msg->rm_oobdataoffset),
809 le32toh(msg->rm_oobdatalen),
810 le32toh(msg->rm_oobdataelements),
811 le32toh(msg->rm_pktinfooffset),
812 le32toh(msg->rm_pktinfooffset)));
813
814 if (le32toh(msg->rm_type) != REMOTE_NDIS_PACKET_MSG) {
815 printf("%s: urndis_decap invalid type 0x%x != 0x%x\n",
816 DEVNAME(sc),
817 le32toh(msg->rm_type),
818 REMOTE_NDIS_PACKET_MSG);
819 return;
820 }
821 if (le32toh(msg->rm_len) < sizeof(*msg)) {
822 printf("%s: urndis_decap invalid msg len %u < %zu\n",
823 DEVNAME(sc),
824 le32toh(msg->rm_len),
825 sizeof(*msg));
826 return;
827 }
828 if (le32toh(msg->rm_len) > len) {
829 printf("%s: urndis_decap invalid msg len %u > buffer "
830 "len %u\n",
831 DEVNAME(sc),
832 le32toh(msg->rm_len),
833 len);
834 return;
835 }
836
837 if (le32toh(msg->rm_dataoffset) +
838 le32toh(msg->rm_datalen) + RNDIS_HEADER_OFFSET
839 > le32toh(msg->rm_len)) {
840 printf("%s: urndis_decap invalid data "
841 "len/offset/end_position(%u/%u/%u) -> "
842 "go out of receive buffer limit %u\n",
843 DEVNAME(sc),
844 le32toh(msg->rm_datalen),
845 le32toh(msg->rm_dataoffset),
846 le32toh(msg->rm_dataoffset) +
847 le32toh(msg->rm_datalen) + (uint32_t)RNDIS_HEADER_OFFSET,
848 le32toh(msg->rm_len));
849 return;
850 }
851
852 if (le32toh(msg->rm_datalen) < sizeof(struct ether_header)) {
853 ifp->if_ierrors++;
854 printf("%s: urndis_decap invalid ethernet size "
855 "%d < %zu\n",
856 DEVNAME(sc),
857 le32toh(msg->rm_datalen),
858 sizeof(struct ether_header));
859 return;
860 }
861
862 memcpy(mtod(m, char*),
863 ((char*)&msg->rm_dataoffset + le32toh(msg->rm_dataoffset)),
864 le32toh(msg->rm_datalen));
865 m->m_pkthdr.len = m->m_len = le32toh(msg->rm_datalen);
866
867 ifp->if_ipackets++;
868 m_set_rcvif(m, ifp);
869
870 s = splnet();
871
872 if (urndis_newbuf(sc, c) == ENOBUFS) {
873 ifp->if_ierrors++;
874 } else {
875
876 bpf_mtap(ifp, m);
877
878 if_percpuq_enqueue(ifp->if_percpuq, m);
879 }
880 splx(s);
881
882 offset += le32toh(msg->rm_len);
883 len -= le32toh(msg->rm_len);
884 }
885}
886
887static int
888urndis_newbuf(struct urndis_softc *sc, struct urndis_chain *c)
889{
890 struct mbuf *m_new = NULL;
891
892 MGETHDR(m_new, M_DONTWAIT, MT_DATA);
893 if (m_new == NULL) {
894 printf("%s: no memory for rx list -- packet dropped!\n",
895 DEVNAME(sc));
896 return ENOBUFS;
897 }
898 MCLGET(m_new, M_DONTWAIT);
899 if (!(m_new->m_flags & M_EXT)) {
900 printf("%s: no memory for rx list -- packet dropped!\n",
901 DEVNAME(sc));
902 m_freem(m_new);
903 return ENOBUFS;
904 }
905 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
906
907 m_adj(m_new, ETHER_ALIGN);
908 c->sc_mbuf = m_new;
909 return 0;
910}
911
912static int
913urndis_rx_list_init(struct urndis_softc *sc)
914{
915 struct urndis_cdata *cd;
916 struct urndis_chain *c;
917 int i;
918
919 cd = &sc->sc_data;
920 for (i = 0; i < RNDIS_RX_LIST_CNT; i++) {
921 c = &cd->sc_rx_chain[i];
922 c->sc_softc = sc;
923 c->sc_idx = i;
924
925 if (urndis_newbuf(sc, c) == ENOBUFS)
926 return ENOBUFS;
927
928 if (c->sc_xfer == NULL) {
929 int err = usbd_create_xfer(sc->sc_bulkin_pipe,
930 RNDIS_BUFSZ, USBD_SHORT_XFER_OK, 0, &c->sc_xfer);
931 if (err)
932 return err;
933 c->sc_buf = usbd_get_buffer(c->sc_xfer);
934 }
935 }
936
937 return 0;
938}
939
940static int
941urndis_tx_list_init(struct urndis_softc *sc)
942{
943 struct urndis_cdata *cd;
944 struct urndis_chain *c;
945 int i;
946
947 cd = &sc->sc_data;
948 for (i = 0; i < RNDIS_TX_LIST_CNT; i++) {
949 c = &cd->sc_tx_chain[i];
950 c->sc_softc = sc;
951 c->sc_idx = i;
952 c->sc_mbuf = NULL;
953 if (c->sc_xfer == NULL) {
954 int err = usbd_create_xfer(sc->sc_bulkout_pipe,
955 RNDIS_BUFSZ, USBD_FORCE_SHORT_XFER, 0, &c->sc_xfer);
956 if (err)
957 return err;
958 c->sc_buf = usbd_get_buffer(c->sc_xfer);
959 }
960 }
961 return 0;
962}
963
964static int
965urndis_ioctl(struct ifnet *ifp, unsigned long command, void *data)
966{
967 struct urndis_softc *sc;
968 int s, error;
969
970 sc = ifp->if_softc;
971 error = 0;
972
973 if (sc->sc_dying)
974 return EIO;
975
976 s = splnet();
977
978 switch(command) {
979 case SIOCSIFFLAGS:
980 if ((error = ifioctl_common(ifp, command, data)) != 0)
981 break;
982 if (ifp->if_flags & IFF_UP) {
983 if (!(ifp->if_flags & IFF_RUNNING))
984 urndis_init(ifp);
985 } else {
986 if (ifp->if_flags & IFF_RUNNING)
987 urndis_stop(ifp);
988 }
989 error = 0;
990 break;
991
992 default:
993 error = ether_ioctl(ifp, command, data);
994 break;
995 }
996
997 if (error == ENETRESET)
998 error = 0;
999
1000 splx(s);
1001 return error;
1002}
1003
1004#if 0
1005static void
1006urndis_watchdog(struct ifnet *ifp)
1007{
1008 struct urndis_softc *sc;
1009
1010 sc = ifp->if_softc;
1011
1012 if (sc->sc_dying)
1013 return;
1014
1015 ifp->if_oerrors++;
1016 printf("%s: watchdog timeout\n", DEVNAME(sc));
1017
1018 urndis_ctrl_keepalive(sc);
1019}
1020#endif
1021
1022static int
1023urndis_init(struct ifnet *ifp)
1024{
1025 struct urndis_softc *sc;
1026 int i, s;
1027 int err;
1028 usbd_status usberr;
1029
1030 sc = ifp->if_softc;
1031
1032 if (ifp->if_flags & IFF_RUNNING)
1033 return 0;
1034
1035 err = urndis_ctrl_init(sc);
1036 if (err != RNDIS_STATUS_SUCCESS)
1037 return EIO;
1038
1039 s = splnet();
1040
1041 usberr = usbd_open_pipe(sc->sc_iface_data, sc->sc_bulkin_no,
1042 USBD_EXCLUSIVE_USE, &sc->sc_bulkin_pipe);
1043 if (usberr) {
1044 printf("%s: open rx pipe failed: %s\n", DEVNAME(sc),
1045 usbd_errstr(err));
1046 splx(s);
1047 return EIO;
1048 }
1049
1050 usberr = usbd_open_pipe(sc->sc_iface_data, sc->sc_bulkout_no,
1051 USBD_EXCLUSIVE_USE, &sc->sc_bulkout_pipe);
1052 if (usberr) {
1053 printf("%s: open tx pipe failed: %s\n", DEVNAME(sc),
1054 usbd_errstr(err));
1055 splx(s);
1056 return EIO;
1057 }
1058
1059 err = urndis_tx_list_init(sc);
1060 if (err) {
1061 printf("%s: tx list init failed\n",
1062 DEVNAME(sc));
1063 splx(s);
1064 return err;
1065 }
1066
1067 err = urndis_rx_list_init(sc);
1068 if (err) {
1069 printf("%s: rx list init failed\n",
1070 DEVNAME(sc));
1071 splx(s);
1072 return err;
1073 }
1074
1075 for (i = 0; i < RNDIS_RX_LIST_CNT; i++) {
1076 struct urndis_chain *c;
1077
1078 c = &sc->sc_data.sc_rx_chain[i];
1079
1080 usbd_setup_xfer(c->sc_xfer, c, c->sc_buf, RNDIS_BUFSZ,
1081 USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, urndis_rxeof);
1082 usbd_transfer(c->sc_xfer);
1083 }
1084
1085 ifp->if_flags |= IFF_RUNNING;
1086 ifp->if_flags &= ~IFF_OACTIVE;
1087
1088 splx(s);
1089 return 0;
1090}
1091
1092static void
1093urndis_stop(struct ifnet *ifp)
1094{
1095 struct urndis_softc *sc;
1096 usbd_status err;
1097 int i;
1098
1099 sc = ifp->if_softc;
1100
1101 ifp->if_timer = 0;
1102 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1103
1104 if (sc->sc_bulkin_pipe != NULL) {
1105 err = usbd_abort_pipe(sc->sc_bulkin_pipe);
1106 if (err)
1107 printf("%s: abort rx pipe failed: %s\n",
1108 DEVNAME(sc), usbd_errstr(err));
1109 }
1110
1111 if (sc->sc_bulkout_pipe != NULL) {
1112 err = usbd_abort_pipe(sc->sc_bulkout_pipe);
1113 if (err)
1114 printf("%s: abort tx pipe failed: %s\n",
1115 DEVNAME(sc), usbd_errstr(err));
1116 }
1117
1118 for (i = 0; i < RNDIS_RX_LIST_CNT; i++) {
1119 if (sc->sc_data.sc_rx_chain[i].sc_mbuf != NULL) {
1120 m_freem(sc->sc_data.sc_rx_chain[i].sc_mbuf);
1121 sc->sc_data.sc_rx_chain[i].sc_mbuf = NULL;
1122 }
1123 if (sc->sc_data.sc_rx_chain[i].sc_xfer != NULL) {
1124 usbd_destroy_xfer(sc->sc_data.sc_rx_chain[i].sc_xfer);
1125 sc->sc_data.sc_rx_chain[i].sc_xfer = NULL;
1126 }
1127 }
1128
1129 for (i = 0; i < RNDIS_TX_LIST_CNT; i++) {
1130 if (sc->sc_data.sc_tx_chain[i].sc_mbuf != NULL) {
1131 m_freem(sc->sc_data.sc_tx_chain[i].sc_mbuf);
1132 sc->sc_data.sc_tx_chain[i].sc_mbuf = NULL;
1133 }
1134 if (sc->sc_data.sc_tx_chain[i].sc_xfer != NULL) {
1135 usbd_destroy_xfer(sc->sc_data.sc_tx_chain[i].sc_xfer);
1136 sc->sc_data.sc_tx_chain[i].sc_xfer = NULL;
1137 }
1138 }
1139
1140 /* Close pipes. */
1141 if (sc->sc_bulkin_pipe != NULL) {
1142 err = usbd_close_pipe(sc->sc_bulkin_pipe);
1143 if (err)
1144 printf("%s: close rx pipe failed: %s\n",
1145 DEVNAME(sc), usbd_errstr(err));
1146 sc->sc_bulkin_pipe = NULL;
1147 }
1148
1149 if (sc->sc_bulkout_pipe != NULL) {
1150 err = usbd_close_pipe(sc->sc_bulkout_pipe);
1151 if (err)
1152 printf("%s: close tx pipe failed: %s\n",
1153 DEVNAME(sc), usbd_errstr(err));
1154 sc->sc_bulkout_pipe = NULL;
1155 }
1156}
1157
1158static void
1159urndis_start(struct ifnet *ifp)
1160{
1161 struct urndis_softc *sc;
1162 struct mbuf *m_head = NULL;
1163
1164 sc = ifp->if_softc;
1165
1166 if (sc->sc_dying || (ifp->if_flags & IFF_OACTIVE))
1167 return;
1168
1169 IFQ_POLL(&ifp->if_snd, m_head);
1170 if (m_head == NULL)
1171 return;
1172
1173 if (urndis_encap(sc, m_head, 0)) {
1174 ifp->if_flags |= IFF_OACTIVE;
1175 return;
1176 }
1177 IFQ_DEQUEUE(&ifp->if_snd, m_head);
1178
1179 /*
1180 * If there's a BPF listener, bounce a copy of this frame
1181 * to him.
1182 */
1183 bpf_mtap(ifp, m_head);
1184
1185 ifp->if_flags |= IFF_OACTIVE;
1186
1187 /*
1188 * Set a timeout in case the chip goes out to lunch.
1189 */
1190 ifp->if_timer = 5;
1191
1192 return;
1193}
1194
1195static void
1196urndis_rxeof(struct usbd_xfer *xfer,
1197 void *priv,
1198 usbd_status status)
1199{
1200 struct urndis_chain *c;
1201 struct urndis_softc *sc;
1202 struct ifnet *ifp;
1203 uint32_t total_len;
1204
1205 c = priv;
1206 sc = c->sc_softc;
1207 ifp = GET_IFP(sc);
1208 total_len = 0;
1209
1210 if (sc->sc_dying || !(ifp->if_flags & IFF_RUNNING))
1211 return;
1212
1213 if (status != USBD_NORMAL_COMPLETION) {
1214 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
1215 return;
1216 if (usbd_ratecheck(&sc->sc_rx_notice)) {
1217 printf("%s: usb errors on rx: %s\n",
1218 DEVNAME(sc), usbd_errstr(status));
1219 }
1220 if (status == USBD_STALLED)
1221 usbd_clear_endpoint_stall_async(sc->sc_bulkin_pipe);
1222
1223 goto done;
1224 }
1225
1226 usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
1227 urndis_decap(sc, c, total_len);
1228
1229done:
1230 /* Setup new transfer. */
1231 usbd_setup_xfer(c->sc_xfer, c, c->sc_buf, RNDIS_BUFSZ,
1232 USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, urndis_rxeof);
1233 usbd_transfer(c->sc_xfer);
1234}
1235
1236static void
1237urndis_txeof(struct usbd_xfer *xfer,
1238 void *priv,
1239 usbd_status status)
1240{
1241 struct urndis_chain *c;
1242 struct urndis_softc *sc;
1243 struct ifnet *ifp;
1244 usbd_status err;
1245 int s;
1246
1247 c = priv;
1248 sc = c->sc_softc;
1249 ifp = GET_IFP(sc);
1250
1251 DPRINTF(("%s: urndis_txeof\n", DEVNAME(sc)));
1252
1253 if (sc->sc_dying)
1254 return;
1255
1256 s = splnet();
1257
1258 ifp->if_timer = 0;
1259 ifp->if_flags &= ~IFF_OACTIVE;
1260
1261 if (status != USBD_NORMAL_COMPLETION) {
1262 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
1263 splx(s);
1264 return;
1265 }
1266 ifp->if_oerrors++;
1267 printf("%s: usb error on tx: %s\n", DEVNAME(sc),
1268 usbd_errstr(status));
1269 if (status == USBD_STALLED)
1270 usbd_clear_endpoint_stall_async(sc->sc_bulkout_pipe);
1271 splx(s);
1272 return;
1273 }
1274
1275 usbd_get_xfer_status(c->sc_xfer, NULL, NULL, NULL, &err);
1276
1277 if (c->sc_mbuf != NULL) {
1278 m_freem(c->sc_mbuf);
1279 c->sc_mbuf = NULL;
1280 }
1281
1282 if (err)
1283 ifp->if_oerrors++;
1284 else
1285 ifp->if_opackets++;
1286
1287 if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
1288 urndis_start(ifp);
1289
1290 splx(s);
1291}
1292
1293static int
1294urndis_match(device_t parent, cfdata_t match, void *aux)
1295{
1296 struct usbif_attach_arg *uiaa = aux;
1297 usb_interface_descriptor_t *id;
1298
1299 if (!uiaa->uiaa_iface)
1300 return UMATCH_NONE;
1301
1302 id = usbd_get_interface_descriptor(uiaa->uiaa_iface);
1303 if (id == NULL)
1304 return UMATCH_NONE;
1305
1306 if (id->bInterfaceClass == UICLASS_WIRELESS &&
1307 id->bInterfaceSubClass == UISUBCLASS_RF &&
1308 id->bInterfaceProtocol == UIPROTO_RNDIS)
1309 return UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO;
1310
1311 return usb_lookup(urndis_devs, uiaa->uiaa_vendor, uiaa->uiaa_product) != NULL ?
1312 UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
1313}
1314
1315static void
1316urndis_attach(device_t parent, device_t self, void *aux)
1317{
1318 struct urndis_softc *sc;
1319 struct usbif_attach_arg *uiaa;
1320 struct ifnet *ifp;
1321 usb_interface_descriptor_t *id;
1322 usb_endpoint_descriptor_t *ed;
1323 usb_config_descriptor_t *cd;
1324 const usb_cdc_union_descriptor_t *ud;
1325 const usb_cdc_header_descriptor_t *desc;
1326 usbd_desc_iter_t iter;
1327 int if_ctl, if_data;
1328 int i, j, altcnt;
1329 int s;
1330 u_char eaddr[ETHER_ADDR_LEN];
1331 void *buf;
1332 size_t bufsz;
1333 uint32_t filter;
1334 char *devinfop;
1335
1336 sc = device_private(self);
1337 uiaa = aux;
1338 sc->sc_dev = self;
1339 sc->sc_udev = uiaa->uiaa_device;
1340
1341 aprint_naive("\n");
1342 aprint_normal("\n");
1343
1344 devinfop = usbd_devinfo_alloc(uiaa->uiaa_device, 0);
1345 aprint_normal_dev(self, "%s\n", devinfop);
1346 usbd_devinfo_free(devinfop);
1347
1348 sc->sc_iface_ctl = uiaa->uiaa_iface;
1349 id = usbd_get_interface_descriptor(sc->sc_iface_ctl);
1350 if_ctl = id->bInterfaceNumber;
1351 sc->sc_ifaceno_ctl = if_ctl;
1352 if_data = -1;
1353
1354 usb_desc_iter_init(sc->sc_udev, &iter);
1355 while ((desc = (const void *)usb_desc_iter_next(&iter)) != NULL) {
1356
1357 if (desc->bDescriptorType != UDESC_CS_INTERFACE) {
1358 continue;
1359 }
1360 switch (desc->bDescriptorSubtype) {
1361 case UDESCSUB_CDC_UNION:
1362 /* XXX bail out when found first? */
1363 ud = (const usb_cdc_union_descriptor_t *)desc;
1364 if (if_data == -1)
1365 if_data = ud->bSlaveInterface[0];
1366 break;
1367 }
1368 }
1369
1370 if (if_data == -1) {
1371 DPRINTF(("urndis_attach: no union interface\n"));
1372 sc->sc_iface_data = sc->sc_iface_ctl;
1373 } else {
1374 DPRINTF(("urndis_attach: union interface: ctl %u, data %u\n",
1375 if_ctl, if_data));
1376 for (i = 0; i < uiaa->uiaa_nifaces; i++) {
1377 if (uiaa->uiaa_ifaces[i] != NULL) {
1378 id = usbd_get_interface_descriptor(
1379 uiaa->uiaa_ifaces[i]);
1380 if (id != NULL && id->bInterfaceNumber ==
1381 if_data) {
1382 sc->sc_iface_data = uiaa->uiaa_ifaces[i];
1383 uiaa->uiaa_ifaces[i] = NULL;
1384 }
1385 }
1386 }
1387 }
1388
1389 if (sc->sc_iface_data == NULL) {
1390 aprint_error("%s: no data interface\n", DEVNAME(sc));
1391 return;
1392 }
1393
1394 id = usbd_get_interface_descriptor(sc->sc_iface_data);
1395 cd = usbd_get_config_descriptor(sc->sc_udev);
1396 altcnt = usbd_get_no_alts(cd, id->bInterfaceNumber);
1397
1398 for (j = 0; j < altcnt; j++) {
1399 if (usbd_set_interface(sc->sc_iface_data, j)) {
1400 aprint_error("%s: interface alternate setting %u "
1401 "failed\n", DEVNAME(sc), j);
1402 return;
1403 }
1404 /* Find endpoints. */
1405 id = usbd_get_interface_descriptor(sc->sc_iface_data);
1406 sc->sc_bulkin_no = sc->sc_bulkout_no = -1;
1407 for (i = 0; i < id->bNumEndpoints; i++) {
1408 ed = usbd_interface2endpoint_descriptor(
1409 sc->sc_iface_data, i);
1410 if (!ed) {
1411 aprint_error("%s: no descriptor for bulk "
1412 "endpoint %u\n", DEVNAME(sc), i);
1413 return;
1414 }
1415 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
1416 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
1417 sc->sc_bulkin_no = ed->bEndpointAddress;
1418 }
1419 else if (
1420 UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
1421 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
1422 sc->sc_bulkout_no = ed->bEndpointAddress;
1423 }
1424 }
1425
1426 if (sc->sc_bulkin_no != -1 && sc->sc_bulkout_no != -1) {
1427 DPRINTF(("%s: in=0x%x, out=0x%x\n",
1428 DEVNAME(sc),
1429 sc->sc_bulkin_no,
1430 sc->sc_bulkout_no));
1431 goto found;
1432 }
1433 }
1434
1435 if (sc->sc_bulkin_no == -1)
1436 aprint_error("%s: could not find data bulk in\n", DEVNAME(sc));
1437 if (sc->sc_bulkout_no == -1 )
1438 aprint_error("%s: could not find data bulk out\n",DEVNAME(sc));
1439 return;
1440
1441 found:
1442
1443 ifp = GET_IFP(sc);
1444 ifp->if_softc = sc;
1445 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
1446 ifp->if_start = urndis_start;
1447 ifp->if_ioctl = urndis_ioctl;
1448 ifp->if_init = urndis_init;
1449#if 0
1450 ifp->if_watchdog = urndis_watchdog;
1451#endif
1452
1453 strlcpy(ifp->if_xname, DEVNAME(sc), IFNAMSIZ);
1454
1455 IFQ_SET_READY(&ifp->if_snd);
1456
1457 urndis_init(ifp);
1458
1459 s = splnet();
1460
1461 if (urndis_ctrl_query(sc, OID_802_3_PERMANENT_ADDRESS, NULL, 0,
1462 &buf, &bufsz) != RNDIS_STATUS_SUCCESS) {
1463 aprint_error("%s: unable to get hardware address\n",
1464 DEVNAME(sc));
1465 urndis_stop(ifp);
1466 splx(s);
1467 return;
1468 }
1469
1470 if (bufsz == ETHER_ADDR_LEN) {
1471 memcpy(eaddr, buf, ETHER_ADDR_LEN);
1472 aprint_normal("%s: address %s\n", DEVNAME(sc),
1473 ether_sprintf(eaddr));
1474 kmem_free(buf, bufsz);
1475 } else {
1476 aprint_error("%s: invalid address\n", DEVNAME(sc));
1477 kmem_free(buf, bufsz);
1478 urndis_stop(ifp);
1479 splx(s);
1480 return;
1481 }
1482
1483 /* Initialize packet filter */
1484 sc->sc_filter = RNDIS_PACKET_TYPE_BROADCAST;
1485 sc->sc_filter |= RNDIS_PACKET_TYPE_ALL_MULTICAST;
1486 filter = htole32(sc->sc_filter);
1487 if (urndis_ctrl_set(sc, OID_GEN_CURRENT_PACKET_FILTER, &filter,
1488 sizeof(filter)) != RNDIS_STATUS_SUCCESS) {
1489 aprint_error("%s: unable to set data filters\n", DEVNAME(sc));
1490 urndis_stop(ifp);
1491 splx(s);
1492 return;
1493 }
1494
1495 if_attach(ifp);
1496 ether_ifattach(ifp, eaddr);
1497 sc->sc_attached = 1;
1498
1499 splx(s);
1500}
1501
1502static int
1503urndis_detach(device_t self, int flags)
1504{
1505 struct urndis_softc *sc;
1506 struct ifnet *ifp;
1507 int s;
1508
1509 sc = device_private(self);
1510
1511 DPRINTF(("urndis_detach: %s flags %u\n", DEVNAME(sc),
1512 flags));
1513
1514 if (!sc->sc_attached)
1515 return 0;
1516
1517 s = splusb();
1518
1519 ifp = GET_IFP(sc);
1520
1521 if (ifp->if_softc != NULL) {
1522 ether_ifdetach(ifp);
1523 if_detach(ifp);
1524 }
1525
1526 urndis_stop(ifp);
1527 sc->sc_attached = 0;
1528
1529 splx(s);
1530
1531 return 0;
1532}
1533
1534static int
1535urndis_activate(device_t self, enum devact act)
1536{
1537 struct urndis_softc *sc;
1538
1539 sc = device_private(self);
1540
1541 switch (act) {
1542 case DVACT_DEACTIVATE:
1543 sc->sc_dying = 1;
1544 return 0;
1545 }
1546
1547 return EOPNOTSUPP;
1548}
1549
1550