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