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