1 /* $NetBSD: if_urndis.c,v 1.50 2026/01/01 00:48:42 riastradh 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.50 2026/01/01 00:48:42 riastradh Exp $"); 25 26 #ifdef _KERNEL_OPT 27 #include "opt_usb.h" 28 #endif 29 30 #include <sys/param.h> 31 #include <sys/kmem.h> 32 33 #include <dev/usb/usbnet.h> 34 #include <dev/usb/usbdevs.h> 35 #include <dev/usb/usbcdc.h> 36 37 #include <dev/ic/rndisreg.h> 38 39 #define RNDIS_RX_LIST_CNT 1 40 #define RNDIS_TX_LIST_CNT 1 41 #define RNDIS_BUFSZ 1562 42 43 struct urndis_softc { 44 struct usbnet sc_un; 45 46 int sc_ifaceno_ctl; 47 48 /* RNDIS device info */ 49 uint32_t sc_filter; 50 uint32_t sc_maxppt; 51 uint32_t sc_maxtsz; 52 uint32_t sc_palign; 53 }; 54 55 #ifdef URNDIS_DEBUG 56 #define DPRINTF(x) do { printf x; } while (0) 57 #else 58 #define DPRINTF(x) 59 #endif 60 61 #define DEVNAME(un) (device_xname(un->un_dev)) 62 63 #define URNDIS_RESPONSE_LEN 0x400 64 65 #if 0 66 static void urndis_watchdog(struct ifnet *); 67 #endif 68 69 static int urndis_uno_init(struct ifnet *); 70 static void urndis_uno_rx_loop(struct usbnet *, struct usbnet_chain *, 71 uint32_t); 72 static unsigned urndis_uno_tx_prepare(struct usbnet *, struct mbuf *, 73 struct usbnet_chain *); 74 75 static uint32_t urndis_ctrl_handle_init(struct usbnet *, 76 const struct rndis_comp_hdr *); 77 static uint32_t urndis_ctrl_handle_query(struct usbnet *, 78 const struct rndis_comp_hdr *, void **, size_t *); 79 static uint32_t urndis_ctrl_handle_reset(struct usbnet *, 80 const struct rndis_comp_hdr *); 81 static uint32_t urndis_ctrl_handle_status(struct usbnet *, 82 const struct rndis_comp_hdr *); 83 84 static uint32_t urndis_ctrl_set(struct usbnet *, uint32_t, void *, 85 size_t); 86 87 static int urndis_match(device_t, cfdata_t, void *); 88 static void urndis_attach(device_t, device_t, void *); 89 90 static const struct usbnet_ops urndis_ops = { 91 .uno_init = urndis_uno_init, 92 .uno_tx_prepare = urndis_uno_tx_prepare, 93 .uno_rx_loop = urndis_uno_rx_loop, 94 }; 95 96 CFATTACH_DECL_NEW(urndis, sizeof(struct urndis_softc), 97 urndis_match, urndis_attach, usbnet_detach, usbnet_activate); 98 99 /* 100 * Supported devices that we can't match by class IDs. 101 */ 102 static const struct usb_devno urndis_devs[] = { 103 { USB_VENDOR_HTC, USB_PRODUCT_HTC_ANDROID }, 104 { USB_VENDOR_SAMSUNG, USB_PRODUCT_SAMSUNG_ANDROID2 }, 105 { USB_VENDOR_SAMSUNG, USB_PRODUCT_SAMSUNG_ANDROID }, 106 { USB_VENDOR_ONEPLUS, USB_PRODUCT_ONEPLUS_A5010 } 107 }; 108 109 /* 110 * Supported class/interface/protocol IDs. 111 */ 112 static const struct urndis_interface { 113 uByte uif_class; 114 uByte uif_subclass; 115 uByte uif_proto; 116 } urndis_interfaces[] = { 117 { UICLASS_WIRELESS, UISUBCLASS_RF, UIPROTO_RNDIS }, 118 { UICLASS_MISC, UISUBCLASS_MISC_RNDIS, UIPROTO_MISC_RNDIS_ETHERNET }, 119 }; 120 121 static const struct urndis_interface * 122 urndis_interface_lookup(const usb_interface_descriptor_t *id) 123 { 124 size_t i; 125 126 for (i = 0; i < __arraycount(urndis_interfaces); i++) { 127 const struct urndis_interface *uif = &urndis_interfaces[i]; 128 129 if (id->bInterfaceClass == uif->uif_class && 130 id->bInterfaceSubClass == uif->uif_subclass && 131 id->bInterfaceProtocol == uif->uif_proto) 132 return uif; 133 } 134 135 return NULL; 136 } 137 138 static usbd_status 139 urndis_ctrl_msg(struct usbnet *un, uint8_t rt, uint8_t r, 140 uint16_t index, uint16_t value, void *buf, size_t buflen) 141 { 142 usb_device_request_t req; 143 144 req.bmRequestType = rt; 145 req.bRequest = r; 146 USETW(req.wValue, value); 147 USETW(req.wIndex, index); 148 USETW(req.wLength, buflen); 149 150 return usbd_do_request(un->un_udev, &req, buf); 151 } 152 153 static usbd_status 154 urndis_ctrl_send(struct usbnet *un, void *buf, size_t len) 155 { 156 struct urndis_softc *sc = usbnet_softc(un); 157 usbd_status err; 158 159 if (usbnet_isdying(un)) 160 return(0); 161 162 err = urndis_ctrl_msg(un, UT_WRITE_CLASS_INTERFACE, UR_GET_STATUS, 163 sc->sc_ifaceno_ctl, 0, buf, len); 164 165 if (err != USBD_NORMAL_COMPLETION) 166 printf("%s: %s\n", DEVNAME(un), usbd_errstr(err)); 167 168 return err; 169 } 170 171 static struct rndis_comp_hdr * 172 urndis_ctrl_recv(struct usbnet *un) 173 { 174 struct urndis_softc *sc = usbnet_softc(un); 175 struct rndis_comp_hdr *hdr; 176 char *buf; 177 usbd_status err; 178 179 if (usbnet_isdying(un)) 180 return(0); 181 182 buf = kmem_alloc(URNDIS_RESPONSE_LEN, KM_SLEEP); 183 err = urndis_ctrl_msg(un, UT_READ_CLASS_INTERFACE, UR_CLEAR_FEATURE, 184 sc->sc_ifaceno_ctl, 0, buf, URNDIS_RESPONSE_LEN); 185 186 if (err != USBD_NORMAL_COMPLETION && err != USBD_SHORT_XFER) { 187 printf("%s: %s\n", DEVNAME(un), usbd_errstr(err)); 188 kmem_free(buf, URNDIS_RESPONSE_LEN); 189 return NULL; 190 } 191 192 hdr = (struct rndis_comp_hdr *)buf; 193 DPRINTF(("%s: urndis_ctrl_recv: type %#x len %u\n", 194 DEVNAME(un), 195 le32toh(hdr->rm_type), 196 le32toh(hdr->rm_len))); 197 198 if (le32toh(hdr->rm_len) > URNDIS_RESPONSE_LEN) { 199 printf("%s: ctrl message error: wrong size %u > %u\n", 200 DEVNAME(un), 201 le32toh(hdr->rm_len), 202 URNDIS_RESPONSE_LEN); 203 kmem_free(buf, URNDIS_RESPONSE_LEN); 204 return NULL; 205 } 206 207 return hdr; 208 } 209 210 static uint32_t 211 urndis_ctrl_handle(struct usbnet *un, struct rndis_comp_hdr *hdr, 212 void **buf, size_t *bufsz) 213 { 214 uint32_t rval; 215 216 DPRINTF(("%s: urndis_ctrl_handle\n", DEVNAME(un))); 217 218 if (buf && bufsz) { 219 *buf = NULL; 220 *bufsz = 0; 221 } 222 223 switch (le32toh(hdr->rm_type)) { 224 case REMOTE_NDIS_INITIALIZE_CMPLT: 225 rval = urndis_ctrl_handle_init(un, hdr); 226 break; 227 228 case REMOTE_NDIS_QUERY_CMPLT: 229 rval = urndis_ctrl_handle_query(un, hdr, buf, bufsz); 230 break; 231 232 case REMOTE_NDIS_RESET_CMPLT: 233 rval = urndis_ctrl_handle_reset(un, hdr); 234 break; 235 236 case REMOTE_NDIS_KEEPALIVE_CMPLT: 237 case REMOTE_NDIS_SET_CMPLT: 238 rval = le32toh(hdr->rm_status); 239 break; 240 241 case REMOTE_NDIS_INDICATE_STATUS_MSG: 242 rval = urndis_ctrl_handle_status(un, hdr); 243 break; 244 245 default: 246 printf("%s: ctrl message error: unknown event %#x\n", 247 DEVNAME(un), le32toh(hdr->rm_type)); 248 rval = RNDIS_STATUS_FAILURE; 249 } 250 251 kmem_free(hdr, URNDIS_RESPONSE_LEN); 252 253 return rval; 254 } 255 256 static uint32_t 257 urndis_ctrl_handle_init(struct usbnet *un, const struct rndis_comp_hdr *hdr) 258 { 259 struct urndis_softc *sc = usbnet_softc(un); 260 const struct rndis_init_comp *msg; 261 262 msg = (const struct rndis_init_comp *) hdr; 263 264 DPRINTF(("%s: urndis_ctrl_handle_init: len %u rid %u status %#x " 265 "ver_major %u ver_minor %u devflags %#x medium %#x pktmaxcnt %u " 266 "pktmaxsz %u align %u aflistoffset %u aflistsz %u\n", 267 DEVNAME(un), 268 le32toh(msg->rm_len), 269 le32toh(msg->rm_rid), 270 le32toh(msg->rm_status), 271 le32toh(msg->rm_ver_major), 272 le32toh(msg->rm_ver_minor), 273 le32toh(msg->rm_devflags), 274 le32toh(msg->rm_medium), 275 le32toh(msg->rm_pktmaxcnt), 276 le32toh(msg->rm_pktmaxsz), 277 le32toh(msg->rm_align), 278 le32toh(msg->rm_aflistoffset), 279 le32toh(msg->rm_aflistsz))); 280 281 if (le32toh(msg->rm_status) != RNDIS_STATUS_SUCCESS) { 282 printf("%s: init failed %#x\n", 283 DEVNAME(un), 284 le32toh(msg->rm_status)); 285 286 return le32toh(msg->rm_status); 287 } 288 289 if (le32toh(msg->rm_devflags) != RNDIS_DF_CONNECTIONLESS) { 290 printf("%s: wrong device type (current type: %#x)\n", 291 DEVNAME(un), 292 le32toh(msg->rm_devflags)); 293 294 return RNDIS_STATUS_FAILURE; 295 } 296 297 if (le32toh(msg->rm_medium) != RNDIS_MEDIUM_802_3) { 298 printf("%s: medium not 802.3 (current medium: %#x)\n", 299 DEVNAME(un), le32toh(msg->rm_medium)); 300 301 return RNDIS_STATUS_FAILURE; 302 } 303 304 if (le32toh(msg->rm_ver_major) != RNDIS_MAJOR_VERSION || 305 le32toh(msg->rm_ver_minor) != RNDIS_MINOR_VERSION) { 306 printf("%s: version not %u.%u (current version: %u.%u)\n", 307 DEVNAME(un), RNDIS_MAJOR_VERSION, RNDIS_MINOR_VERSION, 308 le32toh(msg->rm_ver_major), le32toh(msg->rm_ver_minor)); 309 310 return RNDIS_STATUS_FAILURE; 311 } 312 313 sc->sc_maxppt = le32toh(msg->rm_pktmaxcnt); 314 sc->sc_maxtsz = le32toh(msg->rm_pktmaxsz); 315 sc->sc_palign = 1U << le32toh(msg->rm_align); 316 317 return le32toh(msg->rm_status); 318 } 319 320 static uint32_t 321 urndis_ctrl_handle_query(struct usbnet *un, 322 const struct rndis_comp_hdr *hdr, void **buf, size_t *bufsz) 323 { 324 const struct rndis_query_comp *msg; 325 326 msg = (const struct rndis_query_comp *) hdr; 327 328 DPRINTF(("%s: urndis_ctrl_handle_query: len %u rid %u status %#x " 329 "buflen %u bufoff %u\n", 330 DEVNAME(un), 331 le32toh(msg->rm_len), 332 le32toh(msg->rm_rid), 333 le32toh(msg->rm_status), 334 le32toh(msg->rm_infobuflen), 335 le32toh(msg->rm_infobufoffset))); 336 337 if (buf && bufsz) { 338 *buf = NULL; 339 *bufsz = 0; 340 } 341 342 if (le32toh(msg->rm_status) != RNDIS_STATUS_SUCCESS) { 343 printf("%s: query failed %#x\n", 344 DEVNAME(un), 345 le32toh(msg->rm_status)); 346 347 return le32toh(msg->rm_status); 348 } 349 350 if (le32toh(msg->rm_infobuflen) + le32toh(msg->rm_infobufoffset) + 351 RNDIS_HEADER_OFFSET > le32toh(msg->rm_len)) { 352 printf("%s: ctrl message error: invalid query info " 353 "len/offset/end_position(%u/%u/%u) -> " 354 "go out of buffer limit %u\n", 355 DEVNAME(un), 356 le32toh(msg->rm_infobuflen), 357 le32toh(msg->rm_infobufoffset), 358 le32toh(msg->rm_infobuflen) + 359 le32toh(msg->rm_infobufoffset) + (uint32_t)RNDIS_HEADER_OFFSET, 360 le32toh(msg->rm_len)); 361 return RNDIS_STATUS_FAILURE; 362 } 363 364 if (buf && bufsz) { 365 const char *p; 366 367 *buf = kmem_alloc(le32toh(msg->rm_infobuflen), KM_SLEEP); 368 *bufsz = le32toh(msg->rm_infobuflen); 369 370 p = (const char *)&msg->rm_rid; 371 p += le32toh(msg->rm_infobufoffset); 372 memcpy(*buf, p, le32toh(msg->rm_infobuflen)); 373 } 374 375 return le32toh(msg->rm_status); 376 } 377 378 static uint32_t 379 urndis_ctrl_handle_reset(struct usbnet *un, const struct rndis_comp_hdr *hdr) 380 { 381 struct urndis_softc *sc = usbnet_softc(un); 382 const struct rndis_reset_comp *msg; 383 uint32_t rval; 384 385 msg = (const struct rndis_reset_comp *) hdr; 386 387 rval = le32toh(msg->rm_status); 388 389 DPRINTF(("%s: urndis_ctrl_handle_reset: len %u status %#x " 390 "adrreset %u\n", 391 DEVNAME(un), 392 le32toh(msg->rm_len), 393 rval, 394 le32toh(msg->rm_adrreset))); 395 396 if (rval != RNDIS_STATUS_SUCCESS) { 397 printf("%s: reset failed %#x\n", DEVNAME(un), rval); 398 return rval; 399 } 400 401 if (le32toh(msg->rm_adrreset) != 0) { 402 uint32_t filter; 403 404 filter = htole32(sc->sc_filter); 405 rval = urndis_ctrl_set(un, OID_GEN_CURRENT_PACKET_FILTER, 406 &filter, sizeof(filter)); 407 if (rval != RNDIS_STATUS_SUCCESS) { 408 printf("%s: unable to reset data filters\n", 409 DEVNAME(un)); 410 return rval; 411 } 412 } 413 414 return rval; 415 } 416 417 static uint32_t 418 urndis_ctrl_handle_status(struct usbnet *un, 419 const struct rndis_comp_hdr *hdr) 420 { 421 const struct rndis_status_msg *msg; 422 uint32_t rval; 423 424 msg = (const struct rndis_status_msg *)hdr; 425 426 rval = le32toh(msg->rm_status); 427 428 DPRINTF(("%s: urndis_ctrl_handle_status: len %u status %#x " 429 "stbuflen %u\n", 430 DEVNAME(un), 431 le32toh(msg->rm_len), 432 rval, 433 le32toh(msg->rm_stbuflen))); 434 435 switch (rval) { 436 case RNDIS_STATUS_MEDIA_CONNECT: 437 case RNDIS_STATUS_MEDIA_DISCONNECT: 438 case RNDIS_STATUS_OFFLOAD_CURRENT_CONFIG: 439 rval = RNDIS_STATUS_SUCCESS; 440 break; 441 442 default: 443 printf("%s: status %#x\n", DEVNAME(un), rval); 444 } 445 446 return rval; 447 } 448 449 static uint32_t 450 urndis_ctrl_init(struct usbnet *un) 451 { 452 struct rndis_init_req *msg; 453 uint32_t rval; 454 struct rndis_comp_hdr *hdr; 455 456 msg = kmem_alloc(sizeof(*msg), KM_SLEEP); 457 msg->rm_type = htole32(REMOTE_NDIS_INITIALIZE_MSG); 458 msg->rm_len = htole32(sizeof(*msg)); 459 msg->rm_rid = htole32(0); 460 msg->rm_ver_major = htole32(RNDIS_MAJOR_VERSION); 461 msg->rm_ver_minor = htole32(RNDIS_MINOR_VERSION); 462 msg->rm_max_xfersz = htole32(RNDIS_BUFSZ); 463 464 DPRINTF(("%s: urndis_ctrl_init send: type %u len %u rid %u ver_major %u " 465 "ver_minor %u max_xfersz %u\n", 466 DEVNAME(un), 467 le32toh(msg->rm_type), 468 le32toh(msg->rm_len), 469 le32toh(msg->rm_rid), 470 le32toh(msg->rm_ver_major), 471 le32toh(msg->rm_ver_minor), 472 le32toh(msg->rm_max_xfersz))); 473 474 rval = urndis_ctrl_send(un, msg, sizeof(*msg)); 475 kmem_free(msg, sizeof(*msg)); 476 477 if (rval != RNDIS_STATUS_SUCCESS) { 478 printf("%s: init failed\n", DEVNAME(un)); 479 return rval; 480 } 481 482 if ((hdr = urndis_ctrl_recv(un)) == NULL) { 483 printf("%s: unable to get init response\n", DEVNAME(un)); 484 return RNDIS_STATUS_FAILURE; 485 } 486 rval = urndis_ctrl_handle(un, hdr, NULL, NULL); 487 488 return rval; 489 } 490 491 #if 0 492 static uint32_t 493 urndis_ctrl_halt(struct usbnet *un) 494 { 495 struct rndis_halt_req *msg; 496 uint32_t rval; 497 498 msg = kmem_alloc(sizeof(*msg), KM_SLEEP); 499 msg->rm_type = htole32(REMOTE_NDIS_HALT_MSG); 500 msg->rm_len = htole32(sizeof(*msg)); 501 msg->rm_rid = 0; 502 503 DPRINTF(("%s: urndis_ctrl_halt send: type %u len %u rid %u\n", 504 DEVNAME(un), 505 le32toh(msg->rm_type), 506 le32toh(msg->rm_len), 507 le32toh(msg->rm_rid))); 508 509 rval = urndis_ctrl_send(un, msg, sizeof(*msg)); 510 kmem_free(msg, sizeof(*msg)); 511 512 if (rval != RNDIS_STATUS_SUCCESS) 513 printf("%s: halt failed\n", DEVNAME(un)); 514 515 return rval; 516 } 517 #endif 518 519 static uint32_t 520 urndis_ctrl_query(struct usbnet *un, uint32_t oid, 521 void *qbuf, size_t qlen, 522 void **rbuf, size_t *rbufsz) 523 { 524 struct rndis_query_req *msg; 525 uint32_t rval; 526 struct rndis_comp_hdr *hdr; 527 528 msg = kmem_alloc(sizeof(*msg) + qlen, KM_SLEEP); 529 msg->rm_type = htole32(REMOTE_NDIS_QUERY_MSG); 530 msg->rm_len = htole32(sizeof(*msg) + qlen); 531 msg->rm_rid = 0; /* XXX */ 532 msg->rm_oid = htole32(oid); 533 msg->rm_infobuflen = htole32(qlen); 534 if (qlen != 0) { 535 msg->rm_infobufoffset = htole32(20); 536 memcpy((char*)msg + 20, qbuf, qlen); 537 } else 538 msg->rm_infobufoffset = 0; 539 msg->rm_devicevchdl = 0; 540 541 DPRINTF(("%s: urndis_ctrl_query send: type %u len %u rid %u oid %#x " 542 "infobuflen %u infobufoffset %u devicevchdl %u\n", 543 DEVNAME(un), 544 le32toh(msg->rm_type), 545 le32toh(msg->rm_len), 546 le32toh(msg->rm_rid), 547 le32toh(msg->rm_oid), 548 le32toh(msg->rm_infobuflen), 549 le32toh(msg->rm_infobufoffset), 550 le32toh(msg->rm_devicevchdl))); 551 552 rval = urndis_ctrl_send(un, msg, sizeof(*msg)); 553 kmem_free(msg, sizeof(*msg) + qlen); 554 555 if (rval != RNDIS_STATUS_SUCCESS) { 556 printf("%s: query failed\n", DEVNAME(un)); 557 return rval; 558 } 559 560 if ((hdr = urndis_ctrl_recv(un)) == NULL) { 561 printf("%s: unable to get query response\n", DEVNAME(un)); 562 return RNDIS_STATUS_FAILURE; 563 } 564 rval = urndis_ctrl_handle(un, hdr, rbuf, rbufsz); 565 566 return rval; 567 } 568 569 static uint32_t 570 urndis_ctrl_set(struct usbnet *un, uint32_t oid, void *buf, size_t len) 571 { 572 struct rndis_set_req *msg; 573 uint32_t rval; 574 struct rndis_comp_hdr *hdr; 575 576 msg = kmem_alloc(sizeof(*msg) + len, KM_SLEEP); 577 msg->rm_type = htole32(REMOTE_NDIS_SET_MSG); 578 msg->rm_len = htole32(sizeof(*msg) + len); 579 msg->rm_rid = 0; /* XXX */ 580 msg->rm_oid = htole32(oid); 581 msg->rm_infobuflen = htole32(len); 582 if (len != 0) { 583 msg->rm_infobufoffset = htole32(20); 584 memcpy((char*)msg + 20, buf, len); 585 } else 586 msg->rm_infobufoffset = 0; 587 msg->rm_devicevchdl = 0; 588 589 DPRINTF(("%s: urndis_ctrl_set send: type %u len %u rid %u oid %#x " 590 "infobuflen %u infobufoffset %u devicevchdl %u\n", 591 DEVNAME(un), 592 le32toh(msg->rm_type), 593 le32toh(msg->rm_len), 594 le32toh(msg->rm_rid), 595 le32toh(msg->rm_oid), 596 le32toh(msg->rm_infobuflen), 597 le32toh(msg->rm_infobufoffset), 598 le32toh(msg->rm_devicevchdl))); 599 600 rval = urndis_ctrl_send(un, msg, sizeof(*msg)); 601 kmem_free(msg, sizeof(*msg) + len); 602 603 if (rval != RNDIS_STATUS_SUCCESS) { 604 printf("%s: set failed\n", DEVNAME(un)); 605 return rval; 606 } 607 608 if ((hdr = urndis_ctrl_recv(un)) == NULL) { 609 printf("%s: unable to get set response\n", DEVNAME(un)); 610 return RNDIS_STATUS_FAILURE; 611 } 612 rval = urndis_ctrl_handle(un, hdr, NULL, NULL); 613 if (rval != RNDIS_STATUS_SUCCESS) 614 printf("%s: set failed %#x\n", DEVNAME(un), rval); 615 616 return rval; 617 } 618 619 #if 0 620 static uint32_t 621 urndis_ctrl_set_param(struct urndis_softc *un, 622 const char *name, 623 uint32_t type, 624 void *buf, 625 size_t len) 626 { 627 struct rndis_set_parameter *param; 628 uint32_t rval; 629 size_t namelen, tlen; 630 631 if (name) 632 namelen = strlen(name); 633 else 634 namelen = 0; 635 tlen = sizeof(*param) + len + namelen; 636 param = kmem_alloc(tlen, KM_SLEEP); 637 param->rm_namelen = htole32(namelen); 638 param->rm_valuelen = htole32(len); 639 param->rm_type = htole32(type); 640 if (namelen != 0) { 641 param->rm_nameoffset = htole32(20); 642 memcpy(param + 20, name, namelen); 643 } else 644 param->rm_nameoffset = 0; 645 if (len != 0) { 646 param->rm_valueoffset = htole32(20 + namelen); 647 memcpy(param + 20 + namelen, buf, len); 648 } else 649 param->rm_valueoffset = 0; 650 651 DPRINTF(("%s: urndis_ctrl_set_param send: nameoffset %u namelen %u " 652 "type %#x valueoffset %u valuelen %u\n", 653 DEVNAME(un), 654 le32toh(param->rm_nameoffset), 655 le32toh(param->rm_namelen), 656 le32toh(param->rm_type), 657 le32toh(param->rm_valueoffset), 658 le32toh(param->rm_valuelen))); 659 660 rval = urndis_ctrl_set(un, OID_GEN_RNDIS_CONFIG_PARAMETER, param, tlen); 661 kmem_free(param, tlen); 662 if (rval != RNDIS_STATUS_SUCCESS) 663 printf("%s: set param failed %#x\n", DEVNAME(un), rval); 664 665 return rval; 666 } 667 668 /* XXX : adrreset, get it from response */ 669 static uint32_t 670 urndis_ctrl_reset(struct usbnet *un) 671 { 672 struct rndis_reset_req *reset; 673 uint32_t rval; 674 struct rndis_comp_hdr *hdr; 675 676 reset = kmem_alloc(sizeof(*reset), KM_SLEEP); 677 reset->rm_type = htole32(REMOTE_NDIS_RESET_MSG); 678 reset->rm_len = htole32(sizeof(*reset)); 679 reset->rm_rid = 0; /* XXX rm_rid == reserved ... remove ? */ 680 681 DPRINTF(("%s: urndis_ctrl_reset send: type %u len %u rid %u\n", 682 DEVNAME(un), 683 le32toh(reset->rm_type), 684 le32toh(reset->rm_len), 685 le32toh(reset->rm_rid))); 686 687 rval = urndis_ctrl_send(un, reset, sizeof(*reset)); 688 kmem_free(reset, sizeof(*reset)); 689 690 if (rval != RNDIS_STATUS_SUCCESS) { 691 printf("%s: reset failed\n", DEVNAME(un)); 692 return rval; 693 } 694 695 if ((hdr = urndis_ctrl_recv(un)) == NULL) { 696 printf("%s: unable to get reset response\n", DEVNAME(un)); 697 return RNDIS_STATUS_FAILURE; 698 } 699 rval = urndis_ctrl_handle(un, hdr, NULL, NULL); 700 701 return rval; 702 } 703 704 static uint32_t 705 urndis_ctrl_keepalive(struct usbnet *un) 706 { 707 struct rndis_keepalive_req *keep; 708 uint32_t rval; 709 struct rndis_comp_hdr *hdr; 710 711 keep = kmem_alloc(sizeof(*keep), KM_SLEEP); 712 keep->rm_type = htole32(REMOTE_NDIS_KEEPALIVE_MSG); 713 keep->rm_len = htole32(sizeof(*keep)); 714 keep->rm_rid = 0; /* XXX rm_rid == reserved ... remove ? */ 715 716 DPRINTF(("%s: urndis_ctrl_keepalive: type %u len %u rid %u\n", 717 DEVNAME(un), 718 le32toh(keep->rm_type), 719 le32toh(keep->rm_len), 720 le32toh(keep->rm_rid))); 721 722 rval = urndis_ctrl_send(un, keep, sizeof(*keep)); 723 kmem_free(keep, sizeof(*keep)); 724 725 if (rval != RNDIS_STATUS_SUCCESS) { 726 printf("%s: keepalive failed\n", DEVNAME(un)); 727 return rval; 728 } 729 730 if ((hdr = urndis_ctrl_recv(un)) == NULL) { 731 printf("%s: unable to get keepalive response\n", DEVNAME(un)); 732 return RNDIS_STATUS_FAILURE; 733 } 734 rval = urndis_ctrl_handle(un, hdr, NULL, NULL); 735 if (rval != RNDIS_STATUS_SUCCESS) { 736 printf("%s: keepalive failed %#x\n", DEVNAME(un), rval); 737 urndis_ctrl_reset(un); 738 } 739 740 return rval; 741 } 742 #endif 743 744 static unsigned 745 urndis_uno_tx_prepare(struct usbnet *un, struct mbuf *m, struct usbnet_chain *c) 746 { 747 struct rndis_packet_msg *msg; 748 749 if ((unsigned)m->m_pkthdr.len > un->un_tx_bufsz - sizeof(*msg)) 750 return 0; 751 752 msg = (struct rndis_packet_msg *)c->unc_buf; 753 754 memset(msg, 0, sizeof(*msg)); 755 msg->rm_type = htole32(REMOTE_NDIS_PACKET_MSG); 756 msg->rm_len = htole32(sizeof(*msg) + m->m_pkthdr.len); 757 758 msg->rm_dataoffset = htole32(RNDIS_DATA_OFFSET); 759 msg->rm_datalen = htole32(m->m_pkthdr.len); 760 761 m_copydata(m, 0, m->m_pkthdr.len, 762 ((char*)msg + RNDIS_DATA_OFFSET + RNDIS_HEADER_OFFSET)); 763 764 DPRINTF(("%s: %s type %#x len %u data(off %u len %u)\n", 765 __func__, 766 DEVNAME(un), 767 le32toh(msg->rm_type), 768 le32toh(msg->rm_len), 769 le32toh(msg->rm_dataoffset), 770 le32toh(msg->rm_datalen))); 771 772 return le32toh(msg->rm_len); 773 } 774 775 static void 776 urndis_uno_rx_loop(struct usbnet * un, struct usbnet_chain *c, 777 uint32_t total_len) 778 { 779 struct rndis_packet_msg *msg; 780 struct ifnet *ifp = usbnet_ifp(un); 781 int offset; 782 783 offset = 0; 784 785 while (total_len > 1) { 786 msg = (struct rndis_packet_msg *)((char*)c->unc_buf + offset); 787 788 DPRINTF(("%s: %s buffer size left %u\n", DEVNAME(un), __func__, 789 total_len)); 790 791 if (total_len < sizeof(*msg)) { 792 printf("%s: urndis_decap invalid buffer total_len %u < " 793 "minimum header %zu\n", 794 DEVNAME(un), 795 total_len, 796 sizeof(*msg)); 797 return; 798 } 799 800 DPRINTF(("%s: urndis_decap total_len %u data(off:%u len:%u) " 801 "oobdata(off:%u len:%u nb:%u) perpacket(off:%u len:%u)\n", 802 DEVNAME(un), 803 le32toh(msg->rm_len), 804 le32toh(msg->rm_dataoffset), 805 le32toh(msg->rm_datalen), 806 le32toh(msg->rm_oobdataoffset), 807 le32toh(msg->rm_oobdatalen), 808 le32toh(msg->rm_oobdataelements), 809 le32toh(msg->rm_pktinfooffset), 810 le32toh(msg->rm_pktinfooffset))); 811 812 if (le32toh(msg->rm_type) != REMOTE_NDIS_PACKET_MSG) { 813 printf("%s: urndis_decap invalid type %#x != %#x\n", 814 DEVNAME(un), 815 le32toh(msg->rm_type), 816 REMOTE_NDIS_PACKET_MSG); 817 return; 818 } 819 if (le32toh(msg->rm_len) < sizeof(*msg)) { 820 printf("%s: urndis_decap invalid msg len %u < %zu\n", 821 DEVNAME(un), 822 le32toh(msg->rm_len), 823 sizeof(*msg)); 824 return; 825 } 826 if (le32toh(msg->rm_len) > total_len) { 827 printf("%s: urndis_decap invalid msg len %u > buffer " 828 "total_len %u\n", 829 DEVNAME(un), 830 le32toh(msg->rm_len), 831 total_len); 832 return; 833 } 834 835 if (le32toh(msg->rm_dataoffset) + 836 le32toh(msg->rm_datalen) + RNDIS_HEADER_OFFSET 837 > le32toh(msg->rm_len)) { 838 printf("%s: urndis_decap invalid data " 839 "len/offset/end_position(%u/%u/%u) -> " 840 "go out of receive buffer limit %u\n", 841 DEVNAME(un), 842 le32toh(msg->rm_datalen), 843 le32toh(msg->rm_dataoffset), 844 le32toh(msg->rm_dataoffset) + 845 le32toh(msg->rm_datalen) + (uint32_t)RNDIS_HEADER_OFFSET, 846 le32toh(msg->rm_len)); 847 return; 848 } 849 850 if (le32toh(msg->rm_datalen) < sizeof(struct ether_header)) { 851 if_statinc(ifp, if_ierrors); 852 printf("%s: urndis_decap invalid ethernet size " 853 "%d < %zu\n", 854 DEVNAME(un), 855 le32toh(msg->rm_datalen), 856 sizeof(struct ether_header)); 857 return; 858 } 859 860 usbnet_enqueue(un, 861 ((char*)&msg->rm_dataoffset + le32toh(msg->rm_dataoffset)), 862 le32toh(msg->rm_datalen), 0, 0, 0); 863 864 offset += le32toh(msg->rm_len); 865 total_len -= le32toh(msg->rm_len); 866 } 867 } 868 869 #if 0 870 static void 871 urndis_watchdog(struct ifnet *ifp) 872 { 873 struct urndis_softc *sc = usbnet_softc(un); 874 875 if (un->un_dying) 876 return; 877 878 if_statinc(ifp, if_oerrors); 879 printf("%s: watchdog timeout\n", DEVNAME(un)); 880 881 urndis_ctrl_keepalive(un); 882 } 883 #endif 884 885 static int 886 urndis_uno_init(struct ifnet *ifp) 887 { 888 struct usbnet *un = ifp->if_softc; 889 890 KASSERT(IFNET_LOCKED(ifp)); 891 892 if (urndis_ctrl_init(un) != RNDIS_STATUS_SUCCESS) 893 return EIO; 894 895 return 0; 896 } 897 898 static int 899 urndis_match(device_t parent, cfdata_t match, void *aux) 900 { 901 struct usbif_attach_arg *uiaa = aux; 902 usb_interface_descriptor_t *id; 903 904 if (!uiaa->uiaa_iface) 905 return UMATCH_NONE; 906 907 id = usbd_get_interface_descriptor(uiaa->uiaa_iface); 908 if (id == NULL) 909 return UMATCH_NONE; 910 911 /* 912 * XXX Shouldn't we check vendor/product first as 913 * higher-priority than interface? 914 */ 915 if (urndis_interface_lookup(id) != NULL) 916 return UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO; 917 918 return usb_lookup(urndis_devs, uiaa->uiaa_vendor, uiaa->uiaa_product) != NULL ? 919 UMATCH_VENDOR_PRODUCT : UMATCH_NONE; 920 } 921 922 static void 923 urndis_attach(device_t parent, device_t self, void *aux) 924 { 925 struct urndis_softc *sc = device_private(self); 926 struct usbnet * const un = &sc->sc_un; 927 struct usbif_attach_arg *uiaa = aux; 928 struct usbd_device *dev = uiaa->uiaa_device; 929 usb_interface_descriptor_t *id; 930 usb_endpoint_descriptor_t *ed; 931 usb_config_descriptor_t *cd; 932 struct usbd_interface *iface_ctl; 933 const usb_cdc_union_descriptor_t *ud; 934 const usb_cdc_header_descriptor_t *desc; 935 const usb_interface_assoc_descriptor_t *ad; 936 usbd_desc_iter_t iter; 937 int if_ctl, if_data, if_data_ia; 938 int i, j, altcnt; 939 void *buf; 940 size_t bufsz; 941 uint32_t filter; 942 char *devinfop; 943 944 KASSERT((void *)sc == un); 945 946 aprint_naive("\n"); 947 aprint_normal("\n"); 948 devinfop = usbd_devinfo_alloc(dev, 0); 949 aprint_normal_dev(self, "%s\n", devinfop); 950 usbd_devinfo_free(devinfop); 951 952 un->un_dev = self; 953 un->un_udev = dev; 954 un->un_sc = sc; 955 un->un_ops = &urndis_ops; 956 un->un_rx_xfer_flags = USBD_SHORT_XFER_OK; 957 un->un_tx_xfer_flags = USBD_FORCE_SHORT_XFER; 958 un->un_rx_list_cnt = RNDIS_RX_LIST_CNT; 959 un->un_tx_list_cnt = RNDIS_TX_LIST_CNT; 960 un->un_rx_bufsz = RNDIS_BUFSZ; 961 un->un_tx_bufsz = RNDIS_BUFSZ; 962 963 iface_ctl = uiaa->uiaa_iface; 964 un->un_iface = uiaa->uiaa_iface; 965 id = usbd_get_interface_descriptor(iface_ctl); 966 if_ctl = id->bInterfaceNumber; 967 sc->sc_ifaceno_ctl = if_ctl; 968 if_data = -1; 969 if_data_ia = -1; 970 971 /* 972 * Use a matching Interface Association Descriptor 973 * as a fallback if no CDC Union Descriptor is found. 974 */ 975 usb_desc_iter_init(un->un_udev, &iter); 976 while ((desc = (const void *)usb_desc_iter_next(&iter)) != NULL) { 977 if (desc->bDescriptorType == UDESC_INTERFACE_ASSOC) { 978 if (desc->bLength < sizeof(*ad)) 979 continue; 980 ad = (const usb_interface_assoc_descriptor_t *)desc; 981 if (ad->bFirstInterface == if_ctl && 982 ad->bInterfaceCount > 1) 983 if_data_ia = if_ctl + 1; 984 continue; 985 } 986 if (desc->bDescriptorType != UDESC_CS_INTERFACE) { 987 continue; 988 } 989 switch (desc->bDescriptorSubtype) { 990 case UDESCSUB_CDC_UNION: 991 /* XXX bail out when found first? */ 992 ud = (const usb_cdc_union_descriptor_t *)desc; 993 if (if_data == -1) 994 if_data = ud->bSlaveInterface[0]; 995 break; 996 } 997 } 998 if (if_data == -1 && if_data_ia != -1) 999 if_data = if_data_ia; 1000 1001 if (if_data == -1) { 1002 DPRINTF(("urndis_attach: no union interface\n")); 1003 un->un_iface = iface_ctl; 1004 } else { 1005 DPRINTF(("urndis_attach: union interface: ctl %u, data %u\n", 1006 if_ctl, if_data)); 1007 for (i = 0; i < uiaa->uiaa_nifaces; i++) { 1008 if (uiaa->uiaa_ifaces[i] != NULL) { 1009 id = usbd_get_interface_descriptor( 1010 uiaa->uiaa_ifaces[i]); 1011 if (id != NULL && id->bInterfaceNumber == 1012 if_data) { 1013 un->un_iface = uiaa->uiaa_ifaces[i]; 1014 uiaa->uiaa_ifaces[i] = NULL; 1015 } 1016 } 1017 } 1018 } 1019 1020 if (un->un_iface == NULL) { 1021 aprint_error("%s: no data interface\n", DEVNAME(un)); 1022 return; 1023 } 1024 1025 id = usbd_get_interface_descriptor(un->un_iface); 1026 cd = usbd_get_config_descriptor(un->un_udev); 1027 altcnt = usbd_get_no_alts(cd, id->bInterfaceNumber); 1028 1029 for (j = 0; j < altcnt; j++) { 1030 if (usbd_set_interface(un->un_iface, j)) { 1031 aprint_error("%s: interface alternate setting %u " 1032 "failed\n", DEVNAME(un), j); 1033 return; 1034 } 1035 /* Find endpoints. */ 1036 id = usbd_get_interface_descriptor(un->un_iface); 1037 un->un_ed[USBNET_ENDPT_RX] = un->un_ed[USBNET_ENDPT_TX] = 0; 1038 for (i = 0; i < id->bNumEndpoints; i++) { 1039 ed = usbd_interface2endpoint_descriptor( 1040 un->un_iface, i); 1041 if (!ed) { 1042 aprint_error("%s: no descriptor for bulk " 1043 "endpoint %u\n", DEVNAME(un), i); 1044 return; 1045 } 1046 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 1047 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 1048 un->un_ed[USBNET_ENDPT_RX] = ed->bEndpointAddress; 1049 } 1050 else if ( 1051 UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT && 1052 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 1053 un->un_ed[USBNET_ENDPT_TX] = ed->bEndpointAddress; 1054 } 1055 } 1056 1057 if (un->un_ed[USBNET_ENDPT_RX] != 0 && un->un_ed[USBNET_ENDPT_TX] != 0) { 1058 DPRINTF(("%s: in=%#x, out=%#x\n", 1059 DEVNAME(un), 1060 un->un_ed[USBNET_ENDPT_RX], 1061 un->un_ed[USBNET_ENDPT_TX])); 1062 break; 1063 } 1064 } 1065 1066 if (un->un_ed[USBNET_ENDPT_RX] == 0) 1067 aprint_error("%s: could not find data bulk in\n", DEVNAME(un)); 1068 if (un->un_ed[USBNET_ENDPT_TX] == 0) 1069 aprint_error("%s: could not find data bulk out\n",DEVNAME(un)); 1070 if (un->un_ed[USBNET_ENDPT_RX] == 0 || un->un_ed[USBNET_ENDPT_TX] == 0) 1071 return; 1072 1073 #if 0 1074 ifp->if_watchdog = urndis_watchdog; 1075 #endif 1076 1077 usbnet_attach(un); 1078 1079 if (urndis_ctrl_init(un) != RNDIS_STATUS_SUCCESS) { 1080 aprint_error("%s: unable to initialize hardware\n", 1081 DEVNAME(un)); 1082 return; 1083 } 1084 1085 if (urndis_ctrl_query(un, OID_802_3_PERMANENT_ADDRESS, NULL, 0, 1086 &buf, &bufsz) != RNDIS_STATUS_SUCCESS) { 1087 aprint_error("%s: unable to get hardware address\n", 1088 DEVNAME(un)); 1089 return; 1090 } 1091 1092 if (bufsz == ETHER_ADDR_LEN) { 1093 memcpy(un->un_eaddr, buf, ETHER_ADDR_LEN); 1094 kmem_free(buf, bufsz); 1095 } else { 1096 aprint_error("%s: invalid address\n", DEVNAME(un)); 1097 if (buf && bufsz) 1098 kmem_free(buf, bufsz); 1099 return; 1100 } 1101 1102 /* Initialize packet filter */ 1103 sc->sc_filter = RNDIS_PACKET_TYPE_BROADCAST; 1104 sc->sc_filter |= RNDIS_PACKET_TYPE_ALL_MULTICAST; 1105 filter = htole32(sc->sc_filter); 1106 if (urndis_ctrl_set(un, OID_GEN_CURRENT_PACKET_FILTER, &filter, 1107 sizeof(filter)) != RNDIS_STATUS_SUCCESS) { 1108 aprint_error("%s: unable to set data filters\n", DEVNAME(un)); 1109 return; 1110 } 1111 1112 usbnet_attach_ifp(un, IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST, 1113 0, NULL); 1114 } 1115 1116 #ifdef _MODULE 1117 #include "ioconf.c" 1118 #endif 1119 1120 USBNET_MODULE(urndis) 1121
Indexes created Sun Oct 25 00:26:45 UTC 2026