Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/compat/ndis/subr_usbd.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Copyright (c) 2005 3 * Bill Paul <wpaul@windriver.com>. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by Bill Paul. 16 * 4. Neither the name of the author nor the names of any co-contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD 24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 30 * THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #include <sys/cdefs.h> 34 __FBSDID("$FreeBSD$"); 35 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/unistd.h> 39 #include <sys/types.h> 40 41 #include <sys/kernel.h> 42 #include <sys/malloc.h> 43 #include <sys/lock.h> 44 #include <sys/mutex.h> 45 #include <sys/sx.h> 46 #include <sys/condvar.h> 47 #include <sys/module.h> 48 #include <sys/conf.h> 49 #include <sys/mbuf.h> 50 #include <sys/socket.h> 51 #include <machine/bus.h> 52 #include <sys/bus.h> 53 54 #include <sys/queue.h> 55 56 #include <net/if.h> 57 #include <net/if_media.h> 58 #include <net80211/ieee80211_var.h> 59 #include <net80211/ieee80211_ioctl.h> 60 61 #include <dev/usb/usb.h> 62 #include <dev/usb/usbdi.h> 63 #include <dev/usb/usbdi_util.h> 64 #include <dev/usb/usb_busdma.h> 65 #include <dev/usb/usb_device.h> 66 #include <dev/usb/usb_request.h> 67 68 #include <compat/ndis/pe_var.h> 69 #include <compat/ndis/cfg_var.h> 70 #include <compat/ndis/resource_var.h> 71 #include <compat/ndis/ntoskrnl_var.h> 72 #include <compat/ndis/ndis_var.h> 73 #include <compat/ndis/hal_var.h> 74 #include <compat/ndis/usbd_var.h> 75 #include <dev/if_ndis/if_ndisvar.h> 76 77 static driver_object usbd_driver; 78 static usb_callback_t usbd_non_isoc_callback; 79 static usb_callback_t usbd_ctrl_callback; 80 81 #define USBD_CTRL_READ_PIPE 0 82 #define USBD_CTRL_WRITE_PIPE 1 83 #define USBD_CTRL_MAX_PIPE 2 84 #define USBD_CTRL_READ_BUFFER_SP 256 85 #define USBD_CTRL_WRITE_BUFFER_SP 256 86 #define USBD_CTRL_READ_BUFFER_SIZE \ 87 (sizeof(struct usb_device_request) + USBD_CTRL_READ_BUFFER_SP) 88 #define USBD_CTRL_WRITE_BUFFER_SIZE \ 89 (sizeof(struct usb_device_request) + USBD_CTRL_WRITE_BUFFER_SP) 90 static struct usb_config usbd_default_epconfig[USBD_CTRL_MAX_PIPE] = { 91 [USBD_CTRL_READ_PIPE] = { 92 .type = UE_CONTROL, 93 .endpoint = 0x00, /* control pipe */ 94 .direction = UE_DIR_ANY, 95 .if_index = 0, 96 .bufsize = USBD_CTRL_READ_BUFFER_SIZE, 97 .flags = { .short_xfer_ok = 1, }, 98 .callback = &usbd_ctrl_callback, 99 .timeout = 5000, /* 5 seconds */ 100 }, 101 [USBD_CTRL_WRITE_PIPE] = { 102 .type = UE_CONTROL, 103 .endpoint = 0x00, /* control pipe */ 104 .direction = UE_DIR_ANY, 105 .if_index = 0, 106 .bufsize = USBD_CTRL_WRITE_BUFFER_SIZE, 107 .flags = { .proxy_buffer = 1, }, 108 .callback = &usbd_ctrl_callback, 109 .timeout = 5000, /* 5 seconds */ 110 } 111 }; 112 113 static int32_t usbd_func_bulkintr(irp *); 114 static int32_t usbd_func_vendorclass(irp *); 115 static int32_t usbd_func_selconf(irp *); 116 static int32_t usbd_func_abort_pipe(irp *); 117 static usb_error_t usbd_setup_endpoint(irp *, uint8_t, 118 struct usb_endpoint_descriptor *); 119 static usb_error_t usbd_setup_endpoint_default(irp *, uint8_t); 120 static usb_error_t usbd_setup_endpoint_one(irp *, uint8_t, 121 struct ndisusb_ep *, struct usb_config *); 122 static int32_t usbd_func_getdesc(irp *); 123 static union usbd_urb *usbd_geturb(irp *); 124 static struct ndisusb_ep*usbd_get_ndisep(irp *, usb_endpoint_descriptor_t *); 125 static int32_t usbd_iodispatch(device_object *, irp *); 126 static int32_t usbd_ioinvalid(device_object *, irp *); 127 static int32_t usbd_pnp(device_object *, irp *); 128 static int32_t usbd_power(device_object *, irp *); 129 static void usbd_irpcancel(device_object *, irp *); 130 static int32_t usbd_submit_urb(irp *); 131 static int32_t usbd_urb2nt(int32_t); 132 static void usbd_task(device_object *, void *); 133 static int32_t usbd_taskadd(irp *, unsigned); 134 static void usbd_xfertask(device_object *, void *); 135 static void dummy(void); 136 137 static union usbd_urb *USBD_CreateConfigurationRequestEx( 138 usb_config_descriptor_t *, 139 struct usbd_interface_list_entry *); 140 static union usbd_urb *USBD_CreateConfigurationRequest( 141 usb_config_descriptor_t *, 142 uint16_t *); 143 static void USBD_GetUSBDIVersion(usbd_version_info *); 144 static usb_interface_descriptor_t *USBD_ParseConfigurationDescriptorEx( 145 usb_config_descriptor_t *, void *, int32_t, int32_t, 146 int32_t, int32_t, int32_t); 147 static usb_interface_descriptor_t *USBD_ParseConfigurationDescriptor( 148 usb_config_descriptor_t *, uint8_t, uint8_t); 149 150 /* 151 * We need to wrap these functions because these need `context switch' from 152 * Windows to UNIX before it's called. 153 */ 154 static funcptr usbd_iodispatch_wrap; 155 static funcptr usbd_ioinvalid_wrap; 156 static funcptr usbd_pnp_wrap; 157 static funcptr usbd_power_wrap; 158 static funcptr usbd_irpcancel_wrap; 159 static funcptr usbd_task_wrap; 160 static funcptr usbd_xfertask_wrap; 161 162 int 163 usbd_libinit(void) 164 { 165 image_patch_table *patch; 166 int i; 167 168 patch = usbd_functbl; 169 while (patch->ipt_func != NULL) { 170 windrv_wrap((funcptr)patch->ipt_func, 171 (funcptr *)&patch->ipt_wrap, 172 patch->ipt_argcnt, patch->ipt_ftype); 173 patch++; 174 } 175 176 windrv_wrap((funcptr)usbd_ioinvalid, 177 (funcptr *)&usbd_ioinvalid_wrap, 2, WINDRV_WRAP_STDCALL); 178 windrv_wrap((funcptr)usbd_iodispatch, 179 (funcptr *)&usbd_iodispatch_wrap, 2, WINDRV_WRAP_STDCALL); 180 windrv_wrap((funcptr)usbd_pnp, 181 (funcptr *)&usbd_pnp_wrap, 2, WINDRV_WRAP_STDCALL); 182 windrv_wrap((funcptr)usbd_power, 183 (funcptr *)&usbd_power_wrap, 2, WINDRV_WRAP_STDCALL); 184 windrv_wrap((funcptr)usbd_irpcancel, 185 (funcptr *)&usbd_irpcancel_wrap, 2, WINDRV_WRAP_STDCALL); 186 windrv_wrap((funcptr)usbd_task, 187 (funcptr *)&usbd_task_wrap, 2, WINDRV_WRAP_STDCALL); 188 windrv_wrap((funcptr)usbd_xfertask, 189 (funcptr *)&usbd_xfertask_wrap, 2, WINDRV_WRAP_STDCALL); 190 191 /* Create a fake USB driver instance. */ 192 193 windrv_bus_attach(&usbd_driver, "USB Bus"); 194 195 /* Set up our dipatch routine. */ 196 for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++) 197 usbd_driver.dro_dispatch[i] = 198 (driver_dispatch)usbd_ioinvalid_wrap; 199 200 usbd_driver.dro_dispatch[IRP_MJ_INTERNAL_DEVICE_CONTROL] = 201 (driver_dispatch)usbd_iodispatch_wrap; 202 usbd_driver.dro_dispatch[IRP_MJ_DEVICE_CONTROL] = 203 (driver_dispatch)usbd_iodispatch_wrap; 204 usbd_driver.dro_dispatch[IRP_MJ_POWER] = 205 (driver_dispatch)usbd_power_wrap; 206 usbd_driver.dro_dispatch[IRP_MJ_PNP] = 207 (driver_dispatch)usbd_pnp_wrap; 208 209 return (0); 210 } 211 212 int 213 usbd_libfini(void) 214 { 215 image_patch_table *patch; 216 217 patch = usbd_functbl; 218 while (patch->ipt_func != NULL) { 219 windrv_unwrap(patch->ipt_wrap); 220 patch++; 221 } 222 223 windrv_unwrap(usbd_ioinvalid_wrap); 224 windrv_unwrap(usbd_iodispatch_wrap); 225 windrv_unwrap(usbd_pnp_wrap); 226 windrv_unwrap(usbd_power_wrap); 227 windrv_unwrap(usbd_irpcancel_wrap); 228 windrv_unwrap(usbd_task_wrap); 229 windrv_unwrap(usbd_xfertask_wrap); 230 231 free(usbd_driver.dro_drivername.us_buf, M_DEVBUF); 232 233 return (0); 234 } 235 236 static int32_t 237 usbd_iodispatch(device_object *dobj, irp *ip) 238 { 239 device_t dev = dobj->do_devext; 240 int32_t status; 241 struct io_stack_location *irp_sl; 242 243 irp_sl = IoGetCurrentIrpStackLocation(ip); 244 switch (irp_sl->isl_parameters.isl_ioctl.isl_iocode) { 245 case IOCTL_INTERNAL_USB_SUBMIT_URB: 246 IRP_NDIS_DEV(ip) = dev; 247 248 status = usbd_submit_urb(ip); 249 break; 250 default: 251 device_printf(dev, "ioctl 0x%x isn't supported\n", 252 irp_sl->isl_parameters.isl_ioctl.isl_iocode); 253 status = USBD_STATUS_NOT_SUPPORTED; 254 break; 255 } 256 257 if (status == USBD_STATUS_PENDING) 258 return (STATUS_PENDING); 259 260 ip->irp_iostat.isb_status = usbd_urb2nt(status); 261 if (status != USBD_STATUS_SUCCESS) 262 ip->irp_iostat.isb_info = 0; 263 return (ip->irp_iostat.isb_status); 264 } 265 266 static int32_t 267 usbd_ioinvalid(device_object *dobj, irp *ip) 268 { 269 device_t dev = dobj->do_devext; 270 struct io_stack_location *irp_sl; 271 272 irp_sl = IoGetCurrentIrpStackLocation(ip); 273 device_printf(dev, "invalid I/O dispatch %d:%d\n", irp_sl->isl_major, 274 irp_sl->isl_minor); 275 276 ip->irp_iostat.isb_status = STATUS_FAILURE; 277 ip->irp_iostat.isb_info = 0; 278 279 IoCompleteRequest(ip, IO_NO_INCREMENT); 280 281 return (STATUS_FAILURE); 282 } 283 284 static int32_t 285 usbd_pnp(device_object *dobj, irp *ip) 286 { 287 device_t dev = dobj->do_devext; 288 struct io_stack_location *irp_sl; 289 290 irp_sl = IoGetCurrentIrpStackLocation(ip); 291 device_printf(dev, "%s: unsupported I/O dispatch %d:%d\n", 292 __func__, irp_sl->isl_major, irp_sl->isl_minor); 293 294 ip->irp_iostat.isb_status = STATUS_FAILURE; 295 ip->irp_iostat.isb_info = 0; 296 297 IoCompleteRequest(ip, IO_NO_INCREMENT); 298 299 return (STATUS_FAILURE); 300 } 301 302 static int32_t 303 usbd_power(device_object *dobj, irp *ip) 304 { 305 device_t dev = dobj->do_devext; 306 struct io_stack_location *irp_sl; 307 308 irp_sl = IoGetCurrentIrpStackLocation(ip); 309 device_printf(dev, "%s: unsupported I/O dispatch %d:%d\n", 310 __func__, irp_sl->isl_major, irp_sl->isl_minor); 311 312 ip->irp_iostat.isb_status = STATUS_FAILURE; 313 ip->irp_iostat.isb_info = 0; 314 315 IoCompleteRequest(ip, IO_NO_INCREMENT); 316 317 return (STATUS_FAILURE); 318 } 319 320 /* Convert USBD_STATUS to NTSTATUS */ 321 static int32_t 322 usbd_urb2nt(int32_t status) 323 { 324 325 switch (status) { 326 case USBD_STATUS_SUCCESS: 327 return (STATUS_SUCCESS); 328 case USBD_STATUS_DEVICE_GONE: 329 return (STATUS_DEVICE_NOT_CONNECTED); 330 case USBD_STATUS_PENDING: 331 return (STATUS_PENDING); 332 case USBD_STATUS_NOT_SUPPORTED: 333 return (STATUS_NOT_IMPLEMENTED); 334 case USBD_STATUS_NO_MEMORY: 335 return (STATUS_NO_MEMORY); 336 case USBD_STATUS_REQUEST_FAILED: 337 return (STATUS_NOT_SUPPORTED); 338 case USBD_STATUS_CANCELED: 339 return (STATUS_CANCELLED); 340 default: 341 break; 342 } 343 344 return (STATUS_FAILURE); 345 } 346 347 /* Convert FreeBSD's usb_error_t to USBD_STATUS */ 348 static int32_t 349 usbd_usb2urb(int status) 350 { 351 352 switch (status) { 353 case USB_ERR_NORMAL_COMPLETION: 354 return (USBD_STATUS_SUCCESS); 355 case USB_ERR_PENDING_REQUESTS: 356 return (USBD_STATUS_PENDING); 357 case USB_ERR_TIMEOUT: 358 return (USBD_STATUS_TIMEOUT); 359 case USB_ERR_SHORT_XFER: 360 return (USBD_STATUS_ERROR_SHORT_TRANSFER); 361 case USB_ERR_IOERROR: 362 return (USBD_STATUS_XACT_ERROR); 363 case USB_ERR_NOMEM: 364 return (USBD_STATUS_NO_MEMORY); 365 case USB_ERR_INVAL: 366 return (USBD_STATUS_REQUEST_FAILED); 367 case USB_ERR_NOT_STARTED: 368 case USB_ERR_TOO_DEEP: 369 case USB_ERR_NO_POWER: 370 return (USBD_STATUS_DEVICE_GONE); 371 case USB_ERR_CANCELLED: 372 return (USBD_STATUS_CANCELED); 373 default: 374 break; 375 } 376 377 return (USBD_STATUS_NOT_SUPPORTED); 378 } 379 380 static union usbd_urb * 381 usbd_geturb(irp *ip) 382 { 383 struct io_stack_location *irp_sl; 384 385 irp_sl = IoGetCurrentIrpStackLocation(ip); 386 387 return (irp_sl->isl_parameters.isl_others.isl_arg1); 388 } 389 390 static int32_t 391 usbd_submit_urb(irp *ip) 392 { 393 device_t dev = IRP_NDIS_DEV(ip); 394 int32_t status; 395 union usbd_urb *urb; 396 397 urb = usbd_geturb(ip); 398 /* 399 * In a case of URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER, 400 * USBD_URB_STATUS(urb) would be set at callback functions like 401 * usbd_intr() or usbd_xfereof(). 402 */ 403 switch (urb->uu_hdr.uuh_func) { 404 case URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER: 405 status = usbd_func_bulkintr(ip); 406 if (status != USBD_STATUS_SUCCESS && 407 status != USBD_STATUS_PENDING) 408 USBD_URB_STATUS(urb) = status; 409 break; 410 case URB_FUNCTION_VENDOR_DEVICE: 411 case URB_FUNCTION_VENDOR_INTERFACE: 412 case URB_FUNCTION_VENDOR_ENDPOINT: 413 case URB_FUNCTION_VENDOR_OTHER: 414 case URB_FUNCTION_CLASS_DEVICE: 415 case URB_FUNCTION_CLASS_INTERFACE: 416 case URB_FUNCTION_CLASS_ENDPOINT: 417 case URB_FUNCTION_CLASS_OTHER: 418 status = usbd_func_vendorclass(ip); 419 USBD_URB_STATUS(urb) = status; 420 break; 421 case URB_FUNCTION_SELECT_CONFIGURATION: 422 status = usbd_func_selconf(ip); 423 USBD_URB_STATUS(urb) = status; 424 break; 425 case URB_FUNCTION_ABORT_PIPE: 426 status = usbd_func_abort_pipe(ip); 427 USBD_URB_STATUS(urb) = status; 428 break; 429 case URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE: 430 status = usbd_func_getdesc(ip); 431 USBD_URB_STATUS(urb) = status; 432 break; 433 default: 434 device_printf(dev, "func 0x%x isn't supported\n", 435 urb->uu_hdr.uuh_func); 436 USBD_URB_STATUS(urb) = status = USBD_STATUS_NOT_SUPPORTED; 437 break; 438 } 439 440 return (status); 441 } 442 443 static int32_t 444 usbd_func_getdesc(irp *ip) 445 { 446 #define NDISUSB_GETDESC_MAXRETRIES 3 447 device_t dev = IRP_NDIS_DEV(ip); 448 struct ndis_softc *sc = device_get_softc(dev); 449 struct usbd_urb_control_descriptor_request *ctldesc; 450 uint16_t actlen; 451 uint32_t len; 452 union usbd_urb *urb; 453 usb_config_descriptor_t *cdp; 454 usb_error_t status; 455 456 urb = usbd_geturb(ip); 457 ctldesc = &urb->uu_ctldesc; 458 if (ctldesc->ucd_desctype == UDESC_CONFIG) { 459 /* 460 * The NDIS driver is not allowed to change the 461 * config! There is only one choice! 462 */ 463 cdp = usbd_get_config_descriptor(sc->ndisusb_dev); 464 if (cdp == NULL) { 465 status = USB_ERR_INVAL; 466 goto exit; 467 } 468 if (cdp->bDescriptorType != UDESC_CONFIG) { 469 device_printf(dev, "bad desc %d\n", 470 cdp->bDescriptorType); 471 status = USB_ERR_INVAL; 472 goto exit; 473 } 474 /* get minimum length */ 475 len = MIN(UGETW(cdp->wTotalLength), ctldesc->ucd_trans_buflen); 476 /* copy out config descriptor */ 477 memcpy(ctldesc->ucd_trans_buf, cdp, len); 478 /* set actual length */ 479 actlen = len; 480 status = USB_ERR_NORMAL_COMPLETION; 481 } else { 482 NDISUSB_LOCK(sc); 483 status = usbd_req_get_desc(sc->ndisusb_dev, &sc->ndisusb_mtx, 484 &actlen, ctldesc->ucd_trans_buf, 2, 485 ctldesc->ucd_trans_buflen, ctldesc->ucd_langid, 486 ctldesc->ucd_desctype, ctldesc->ucd_idx, 487 NDISUSB_GETDESC_MAXRETRIES); 488 NDISUSB_UNLOCK(sc); 489 } 490 exit: 491 if (status != USB_ERR_NORMAL_COMPLETION) { 492 ctldesc->ucd_trans_buflen = 0; 493 return usbd_usb2urb(status); 494 } 495 496 ctldesc->ucd_trans_buflen = actlen; 497 ip->irp_iostat.isb_info = actlen; 498 499 return (USBD_STATUS_SUCCESS); 500 #undef NDISUSB_GETDESC_MAXRETRIES 501 } 502 503 static int32_t 504 usbd_func_selconf(irp *ip) 505 { 506 device_t dev = IRP_NDIS_DEV(ip); 507 int i, j; 508 struct ndis_softc *sc = device_get_softc(dev); 509 struct usb_device *udev = sc->ndisusb_dev; 510 struct usb_endpoint *ep = NULL; 511 struct usbd_interface_information *intf; 512 struct usbd_pipe_information *pipe; 513 struct usbd_urb_select_configuration *selconf; 514 union usbd_urb *urb; 515 usb_config_descriptor_t *conf; 516 usb_endpoint_descriptor_t *edesc; 517 usb_error_t ret; 518 519 urb = usbd_geturb(ip); 520 521 selconf = &urb->uu_selconf; 522 conf = selconf->usc_conf; 523 if (conf == NULL) { 524 device_printf(dev, "select configuration is NULL\n"); 525 return usbd_usb2urb(USB_ERR_NORMAL_COMPLETION); 526 } 527 528 intf = &selconf->usc_intf; 529 for (i = 0; i < conf->bNumInterface && intf->uii_len > 0; i++) { 530 ret = usbd_set_alt_interface_index(udev, 531 intf->uii_intfnum, intf->uii_altset); 532 if (ret != USB_ERR_NORMAL_COMPLETION && ret != USB_ERR_IN_USE) { 533 device_printf(dev, 534 "setting alternate interface failed: %s\n", 535 usbd_errstr(ret)); 536 return usbd_usb2urb(ret); 537 } 538 539 for (j = 0; (ep = usb_endpoint_foreach(udev, ep)); j++) { 540 if (j >= intf->uii_numeps) { 541 device_printf(dev, 542 "endpoint %d and above are ignored", 543 intf->uii_numeps); 544 break; 545 } 546 edesc = ep->edesc; 547 pipe = &intf->uii_pipes[j]; 548 pipe->upi_handle = edesc; 549 pipe->upi_epaddr = edesc->bEndpointAddress; 550 pipe->upi_maxpktsize = UGETW(edesc->wMaxPacketSize); 551 pipe->upi_type = UE_GET_XFERTYPE(edesc->bmAttributes); 552 553 ret = usbd_setup_endpoint(ip, intf->uii_intfnum, edesc); 554 if (ret != USB_ERR_NORMAL_COMPLETION) 555 return usbd_usb2urb(ret); 556 557 if (pipe->upi_type != UE_INTERRUPT) 558 continue; 559 560 /* XXX we're following linux USB's interval policy. */ 561 if (udev->speed == USB_SPEED_LOW) 562 pipe->upi_interval = edesc->bInterval + 5; 563 else if (udev->speed == USB_SPEED_FULL) 564 pipe->upi_interval = edesc->bInterval; 565 else { 566 int k0 = 0, k1 = 1; 567 do { 568 k1 = k1 * 2; 569 k0 = k0 + 1; 570 } while (k1 < edesc->bInterval); 571 pipe->upi_interval = k0; 572 } 573 } 574 575 intf = (struct usbd_interface_information *)(((char *)intf) + 576 intf->uii_len); 577 } 578 579 return (USBD_STATUS_SUCCESS); 580 } 581 582 static usb_error_t 583 usbd_setup_endpoint_one(irp *ip, uint8_t ifidx, struct ndisusb_ep *ne, 584 struct usb_config *epconf) 585 { 586 device_t dev = IRP_NDIS_DEV(ip); 587 struct ndis_softc *sc = device_get_softc(dev); 588 struct usb_xfer *xfer; 589 usb_error_t status; 590 591 InitializeListHead(&ne->ne_active); 592 InitializeListHead(&ne->ne_pending); 593 KeInitializeSpinLock(&ne->ne_lock); 594 595 status = usbd_transfer_setup(sc->ndisusb_dev, &ifidx, ne->ne_xfer, 596 epconf, 1, sc, &sc->ndisusb_mtx); 597 if (status != USB_ERR_NORMAL_COMPLETION) { 598 device_printf(dev, "couldn't setup xfer: %s\n", 599 usbd_errstr(status)); 600 return (status); 601 } 602 xfer = ne->ne_xfer[0]; 603 usbd_xfer_set_priv(xfer, ne); 604 605 return (status); 606 } 607 608 static usb_error_t 609 usbd_setup_endpoint_default(irp *ip, uint8_t ifidx) 610 { 611 device_t dev = IRP_NDIS_DEV(ip); 612 struct ndis_softc *sc = device_get_softc(dev); 613 usb_error_t status; 614 615 if (ifidx > 0) 616 device_printf(dev, "warning: ifidx > 0 isn't supported.\n"); 617 618 status = usbd_setup_endpoint_one(ip, ifidx, &sc->ndisusb_dread_ep, 619 &usbd_default_epconfig[USBD_CTRL_READ_PIPE]); 620 if (status != USB_ERR_NORMAL_COMPLETION) 621 return (status); 622 623 status = usbd_setup_endpoint_one(ip, ifidx, &sc->ndisusb_dwrite_ep, 624 &usbd_default_epconfig[USBD_CTRL_WRITE_PIPE]); 625 return (status); 626 } 627 628 static usb_error_t 629 usbd_setup_endpoint(irp *ip, uint8_t ifidx, 630 struct usb_endpoint_descriptor *ep) 631 { 632 device_t dev = IRP_NDIS_DEV(ip); 633 struct ndis_softc *sc = device_get_softc(dev); 634 struct ndisusb_ep *ne; 635 struct usb_config cfg; 636 struct usb_xfer *xfer; 637 usb_error_t status; 638 639 /* check for non-supported transfer types */ 640 if (UE_GET_XFERTYPE(ep->bmAttributes) == UE_CONTROL || 641 UE_GET_XFERTYPE(ep->bmAttributes) == UE_ISOCHRONOUS) { 642 device_printf(dev, "%s: unsuppotted transfer types %#x\n", 643 __func__, UE_GET_XFERTYPE(ep->bmAttributes)); 644 return (USB_ERR_INVAL); 645 } 646 647 ne = &sc->ndisusb_ep[NDISUSB_GET_ENDPT(ep->bEndpointAddress)]; 648 InitializeListHead(&ne->ne_active); 649 InitializeListHead(&ne->ne_pending); 650 KeInitializeSpinLock(&ne->ne_lock); 651 ne->ne_dirin = UE_GET_DIR(ep->bEndpointAddress) >> 7; 652 653 memset(&cfg, 0, sizeof(struct usb_config)); 654 cfg.type = UE_GET_XFERTYPE(ep->bmAttributes); 655 cfg.endpoint = UE_GET_ADDR(ep->bEndpointAddress); 656 cfg.direction = UE_GET_DIR(ep->bEndpointAddress); 657 cfg.callback = &usbd_non_isoc_callback; 658 cfg.bufsize = UGETW(ep->wMaxPacketSize); 659 cfg.flags.proxy_buffer = 1; 660 if (UE_GET_DIR(ep->bEndpointAddress) == UE_DIR_IN) 661 cfg.flags.short_xfer_ok = 1; 662 663 status = usbd_transfer_setup(sc->ndisusb_dev, &ifidx, ne->ne_xfer, 664 &cfg, 1, sc, &sc->ndisusb_mtx); 665 if (status != USB_ERR_NORMAL_COMPLETION) { 666 device_printf(dev, "couldn't setup xfer: %s\n", 667 usbd_errstr(status)); 668 return (status); 669 } 670 xfer = ne->ne_xfer[0]; 671 usbd_xfer_set_priv(xfer, ne); 672 if (UE_GET_DIR(ep->bEndpointAddress) == UE_DIR_IN) 673 usbd_xfer_set_timeout(xfer, NDISUSB_NO_TIMEOUT); 674 else { 675 if (UE_GET_XFERTYPE(ep->bmAttributes) == UE_BULK) 676 usbd_xfer_set_timeout(xfer, NDISUSB_TX_TIMEOUT); 677 else 678 usbd_xfer_set_timeout(xfer, NDISUSB_INTR_TIMEOUT); 679 } 680 681 return (status); 682 } 683 684 static int32_t 685 usbd_func_abort_pipe(irp *ip) 686 { 687 device_t dev = IRP_NDIS_DEV(ip); 688 struct ndis_softc *sc = device_get_softc(dev); 689 struct ndisusb_ep *ne; 690 union usbd_urb *urb; 691 692 urb = usbd_geturb(ip); 693 ne = usbd_get_ndisep(ip, urb->uu_pipe.upr_handle); 694 if (ne == NULL) { 695 device_printf(IRP_NDIS_DEV(ip), "get NULL endpoint info.\n"); 696 return (USBD_STATUS_INVALID_PIPE_HANDLE); 697 } 698 699 NDISUSB_LOCK(sc); 700 usbd_transfer_stop(ne->ne_xfer[0]); 701 usbd_transfer_start(ne->ne_xfer[0]); 702 NDISUSB_UNLOCK(sc); 703 704 return (USBD_STATUS_SUCCESS); 705 } 706 707 static int32_t 708 usbd_func_vendorclass(irp *ip) 709 { 710 device_t dev = IRP_NDIS_DEV(ip); 711 int32_t error; 712 struct ndis_softc *sc = device_get_softc(dev); 713 struct ndisusb_ep *ne; 714 struct ndisusb_xfer *nx; 715 struct usbd_urb_vendor_or_class_request *vcreq; 716 union usbd_urb *urb; 717 718 if (!(sc->ndisusb_status & NDISUSB_STATUS_SETUP_EP)) { 719 /* 720 * XXX In some cases the interface number isn't 0. However 721 * some driver (eg. RTL8187L NDIS driver) calls this function 722 * before calling URB_FUNCTION_SELECT_CONFIGURATION. 723 */ 724 error = usbd_setup_endpoint_default(ip, 0); 725 if (error != USB_ERR_NORMAL_COMPLETION) 726 return usbd_usb2urb(error); 727 sc->ndisusb_status |= NDISUSB_STATUS_SETUP_EP; 728 } 729 730 urb = usbd_geturb(ip); 731 vcreq = &urb->uu_vcreq; 732 ne = (vcreq->uvc_trans_flags & USBD_TRANSFER_DIRECTION_IN) ? 733 &sc->ndisusb_dread_ep : &sc->ndisusb_dwrite_ep; 734 IRP_NDISUSB_EP(ip) = ne; 735 ip->irp_cancelfunc = (cancel_func)usbd_irpcancel_wrap; 736 737 nx = malloc(sizeof(struct ndisusb_xfer), M_USBDEV, M_NOWAIT | M_ZERO); 738 if (nx == NULL) { 739 device_printf(IRP_NDIS_DEV(ip), "out of memory\n"); 740 return (USBD_STATUS_NO_MEMORY); 741 } 742 nx->nx_ep = ne; 743 nx->nx_priv = ip; 744 KeAcquireSpinLockAtDpcLevel(&ne->ne_lock); 745 InsertTailList((&ne->ne_pending), (&nx->nx_next)); 746 KeReleaseSpinLockFromDpcLevel(&ne->ne_lock); 747 748 /* we've done to setup xfer. Let's transfer it. */ 749 ip->irp_iostat.isb_status = STATUS_PENDING; 750 ip->irp_iostat.isb_info = 0; 751 USBD_URB_STATUS(urb) = USBD_STATUS_PENDING; 752 IoMarkIrpPending(ip); 753 754 error = usbd_taskadd(ip, NDISUSB_TASK_VENDOR); 755 if (error != USBD_STATUS_SUCCESS) 756 return (error); 757 758 return (USBD_STATUS_PENDING); 759 } 760 761 static void 762 usbd_irpcancel(device_object *dobj, irp *ip) 763 { 764 device_t dev = IRP_NDIS_DEV(ip); 765 struct ndis_softc *sc = device_get_softc(dev); 766 struct ndisusb_ep *ne = IRP_NDISUSB_EP(ip); 767 768 if (ne == NULL) { 769 ip->irp_cancel = TRUE; 770 IoReleaseCancelSpinLock(ip->irp_cancelirql); 771 return; 772 } 773 774 /* 775 * Make sure that the current USB transfer proxy is 776 * cancelled and then restarted. 777 */ 778 NDISUSB_LOCK(sc); 779 usbd_transfer_stop(ne->ne_xfer[0]); 780 usbd_transfer_start(ne->ne_xfer[0]); 781 NDISUSB_UNLOCK(sc); 782 783 ip->irp_cancel = TRUE; 784 IoReleaseCancelSpinLock(ip->irp_cancelirql); 785 } 786 787 static void 788 usbd_xfer_complete(struct ndis_softc *sc, struct ndisusb_ep *ne, 789 struct ndisusb_xfer *nx, usb_error_t status) 790 { 791 struct ndisusb_xferdone *nd; 792 uint8_t irql; 793 794 nd = malloc(sizeof(struct ndisusb_xferdone), M_USBDEV, 795 M_NOWAIT | M_ZERO); 796 if (nd == NULL) { 797 device_printf(sc->ndis_dev, "out of memory"); 798 return; 799 } 800 nd->nd_xfer = nx; 801 nd->nd_status = status; 802 803 KeAcquireSpinLock(&sc->ndisusb_xferdonelock, &irql); 804 InsertTailList((&sc->ndisusb_xferdonelist), (&nd->nd_donelist)); 805 KeReleaseSpinLock(&sc->ndisusb_xferdonelock, irql); 806 807 IoQueueWorkItem(sc->ndisusb_xferdoneitem, 808 (io_workitem_func)usbd_xfertask_wrap, WORKQUEUE_CRITICAL, sc); 809 } 810 811 static struct ndisusb_xfer * 812 usbd_aq_getfirst(struct ndis_softc *sc, struct ndisusb_ep *ne) 813 { 814 struct ndisusb_xfer *nx; 815 816 KeAcquireSpinLockAtDpcLevel(&ne->ne_lock); 817 if (IsListEmpty(&ne->ne_active)) { 818 device_printf(sc->ndis_dev, 819 "%s: the active queue can't be empty.\n", __func__); 820 KeReleaseSpinLockFromDpcLevel(&ne->ne_lock); 821 return (NULL); 822 } 823 nx = CONTAINING_RECORD(ne->ne_active.nle_flink, struct ndisusb_xfer, 824 nx_next); 825 RemoveEntryList(&nx->nx_next); 826 KeReleaseSpinLockFromDpcLevel(&ne->ne_lock); 827 828 return (nx); 829 } 830 831 static void 832 usbd_non_isoc_callback(struct usb_xfer *xfer, usb_error_t error) 833 { 834 irp *ip; 835 struct ndis_softc *sc = usbd_xfer_softc(xfer); 836 struct ndisusb_ep *ne = usbd_xfer_get_priv(xfer); 837 struct ndisusb_xfer *nx; 838 struct usbd_urb_bulk_or_intr_transfer *ubi; 839 struct usb_page_cache *pc; 840 uint8_t irql; 841 uint32_t len; 842 union usbd_urb *urb; 843 usb_endpoint_descriptor_t *ep; 844 int actlen, sumlen; 845 846 usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL); 847 848 switch (USB_GET_STATE(xfer)) { 849 case USB_ST_TRANSFERRED: 850 nx = usbd_aq_getfirst(sc, ne); 851 pc = usbd_xfer_get_frame(xfer, 0); 852 if (nx == NULL) 853 return; 854 855 /* copy in data with regard to the URB */ 856 if (ne->ne_dirin != 0) 857 usbd_copy_out(pc, 0, nx->nx_urbbuf, actlen); 858 nx->nx_urbbuf += actlen; 859 nx->nx_urbactlen += actlen; 860 nx->nx_urblen -= actlen; 861 862 /* check for short transfer */ 863 if (actlen < sumlen) 864 nx->nx_urblen = 0; 865 else { 866 /* check remainder */ 867 if (nx->nx_urblen > 0) { 868 KeAcquireSpinLock(&ne->ne_lock, &irql); 869 InsertHeadList((&ne->ne_active), (&nx->nx_next)); 870 KeReleaseSpinLock(&ne->ne_lock, irql); 871 872 ip = nx->nx_priv; 873 urb = usbd_geturb(ip); 874 ubi = &urb->uu_bulkintr; 875 ep = ubi->ubi_epdesc; 876 goto extra; 877 } 878 } 879 usbd_xfer_complete(sc, ne, nx, 880 ((actlen < sumlen) && (nx->nx_shortxfer == 0)) ? 881 USB_ERR_SHORT_XFER : USB_ERR_NORMAL_COMPLETION); 882 883 /* fall through */ 884 case USB_ST_SETUP: 885 next: 886 /* get next transfer */ 887 KeAcquireSpinLock(&ne->ne_lock, &irql); 888 if (IsListEmpty(&ne->ne_pending)) { 889 KeReleaseSpinLock(&ne->ne_lock, irql); 890 return; 891 } 892 nx = CONTAINING_RECORD(ne->ne_pending.nle_flink, 893 struct ndisusb_xfer, nx_next); 894 RemoveEntryList(&nx->nx_next); 895 /* add a entry to the active queue's tail. */ 896 InsertTailList((&ne->ne_active), (&nx->nx_next)); 897 KeReleaseSpinLock(&ne->ne_lock, irql); 898 899 ip = nx->nx_priv; 900 urb = usbd_geturb(ip); 901 ubi = &urb->uu_bulkintr; 902 ep = ubi->ubi_epdesc; 903 904 nx->nx_urbbuf = ubi->ubi_trans_buf; 905 nx->nx_urbactlen = 0; 906 nx->nx_urblen = ubi->ubi_trans_buflen; 907 nx->nx_shortxfer = (ubi->ubi_trans_flags & 908 USBD_SHORT_TRANSFER_OK) ? 1 : 0; 909 extra: 910 len = MIN(usbd_xfer_max_len(xfer), nx->nx_urblen); 911 pc = usbd_xfer_get_frame(xfer, 0); 912 if (UE_GET_DIR(ep->bEndpointAddress) == UE_DIR_OUT) 913 usbd_copy_in(pc, 0, nx->nx_urbbuf, len); 914 usbd_xfer_set_frame_len(xfer, 0, len); 915 usbd_xfer_set_frames(xfer, 1); 916 usbd_transfer_submit(xfer); 917 break; 918 default: 919 nx = usbd_aq_getfirst(sc, ne); 920 if (nx == NULL) 921 return; 922 if (error != USB_ERR_CANCELLED) { 923 usbd_xfer_set_stall(xfer); 924 device_printf(sc->ndis_dev, "usb xfer warning (%s)\n", 925 usbd_errstr(error)); 926 } 927 usbd_xfer_complete(sc, ne, nx, error); 928 if (error != USB_ERR_CANCELLED) 929 goto next; 930 break; 931 } 932 } 933 934 static void 935 usbd_ctrl_callback(struct usb_xfer *xfer, usb_error_t error) 936 { 937 irp *ip; 938 struct ndis_softc *sc = usbd_xfer_softc(xfer); 939 struct ndisusb_ep *ne = usbd_xfer_get_priv(xfer); 940 struct ndisusb_xfer *nx; 941 uint8_t irql; 942 union usbd_urb *urb; 943 struct usbd_urb_vendor_or_class_request *vcreq; 944 struct usb_page_cache *pc; 945 uint8_t type = 0; 946 struct usb_device_request req; 947 int len; 948 949 switch (USB_GET_STATE(xfer)) { 950 case USB_ST_TRANSFERRED: 951 nx = usbd_aq_getfirst(sc, ne); 952 if (nx == NULL) 953 return; 954 955 ip = nx->nx_priv; 956 urb = usbd_geturb(ip); 957 vcreq = &urb->uu_vcreq; 958 959 if (vcreq->uvc_trans_flags & USBD_TRANSFER_DIRECTION_IN) { 960 pc = usbd_xfer_get_frame(xfer, 1); 961 len = usbd_xfer_frame_len(xfer, 1); 962 usbd_copy_out(pc, 0, vcreq->uvc_trans_buf, len); 963 nx->nx_urbactlen += len; 964 } 965 966 usbd_xfer_complete(sc, ne, nx, USB_ERR_NORMAL_COMPLETION); 967 /* fall through */ 968 case USB_ST_SETUP: 969 next: 970 /* get next transfer */ 971 KeAcquireSpinLock(&ne->ne_lock, &irql); 972 if (IsListEmpty(&ne->ne_pending)) { 973 KeReleaseSpinLock(&ne->ne_lock, irql); 974 return; 975 } 976 nx = CONTAINING_RECORD(ne->ne_pending.nle_flink, 977 struct ndisusb_xfer, nx_next); 978 RemoveEntryList(&nx->nx_next); 979 /* add a entry to the active queue's tail. */ 980 InsertTailList((&ne->ne_active), (&nx->nx_next)); 981 KeReleaseSpinLock(&ne->ne_lock, irql); 982 983 ip = nx->nx_priv; 984 urb = usbd_geturb(ip); 985 vcreq = &urb->uu_vcreq; 986 987 switch (urb->uu_hdr.uuh_func) { 988 case URB_FUNCTION_CLASS_DEVICE: 989 type = UT_CLASS | UT_DEVICE; 990 break; 991 case URB_FUNCTION_CLASS_INTERFACE: 992 type = UT_CLASS | UT_INTERFACE; 993 break; 994 case URB_FUNCTION_CLASS_OTHER: 995 type = UT_CLASS | UT_OTHER; 996 break; 997 case URB_FUNCTION_CLASS_ENDPOINT: 998 type = UT_CLASS | UT_ENDPOINT; 999 break; 1000 case URB_FUNCTION_VENDOR_DEVICE: 1001 type = UT_VENDOR | UT_DEVICE; 1002 break; 1003 case URB_FUNCTION_VENDOR_INTERFACE: 1004 type = UT_VENDOR | UT_INTERFACE; 1005 break; 1006 case URB_FUNCTION_VENDOR_OTHER: 1007 type = UT_VENDOR | UT_OTHER; 1008 break; 1009 case URB_FUNCTION_VENDOR_ENDPOINT: 1010 type = UT_VENDOR | UT_ENDPOINT; 1011 break; 1012 default: 1013 /* never reached. */ 1014 break; 1015 } 1016 1017 type |= (vcreq->uvc_trans_flags & USBD_TRANSFER_DIRECTION_IN) ? 1018 UT_READ : UT_WRITE; 1019 type |= vcreq->uvc_reserved1; 1020 1021 req.bmRequestType = type; 1022 req.bRequest = vcreq->uvc_req; 1023 USETW(req.wIndex, vcreq->uvc_idx); 1024 USETW(req.wValue, vcreq->uvc_value); 1025 USETW(req.wLength, vcreq->uvc_trans_buflen); 1026 1027 nx->nx_urbbuf = vcreq->uvc_trans_buf; 1028 nx->nx_urblen = vcreq->uvc_trans_buflen; 1029 nx->nx_urbactlen = 0; 1030 1031 pc = usbd_xfer_get_frame(xfer, 0); 1032 usbd_copy_in(pc, 0, &req, sizeof(req)); 1033 usbd_xfer_set_frame_len(xfer, 0, sizeof(req)); 1034 usbd_xfer_set_frames(xfer, 1); 1035 if (vcreq->uvc_trans_flags & USBD_TRANSFER_DIRECTION_IN) { 1036 if (vcreq->uvc_trans_buflen >= USBD_CTRL_READ_BUFFER_SP) 1037 device_printf(sc->ndis_dev, 1038 "warning: not enough buffer space (%d).\n", 1039 vcreq->uvc_trans_buflen); 1040 usbd_xfer_set_frame_len(xfer, 1, 1041 MIN(usbd_xfer_max_len(xfer), 1042 vcreq->uvc_trans_buflen)); 1043 usbd_xfer_set_frames(xfer, 2); 1044 } else { 1045 if (nx->nx_urblen > USBD_CTRL_WRITE_BUFFER_SP) 1046 device_printf(sc->ndis_dev, 1047 "warning: not enough write buffer space" 1048 " (%d).\n", nx->nx_urblen); 1049 /* 1050 * XXX with my local tests there was no cases to require 1051 * a extra buffer until now but it'd need to update in 1052 * the future if it needs to be. 1053 */ 1054 if (nx->nx_urblen > 0) { 1055 pc = usbd_xfer_get_frame(xfer, 1); 1056 usbd_copy_in(pc, 0, nx->nx_urbbuf, 1057 nx->nx_urblen); 1058 usbd_xfer_set_frame_len(xfer, 1, nx->nx_urblen); 1059 usbd_xfer_set_frames(xfer, 2); 1060 } 1061 } 1062 usbd_transfer_submit(xfer); 1063 break; 1064 default: 1065 nx = usbd_aq_getfirst(sc, ne); 1066 if (nx == NULL) 1067 return; 1068 if (error != USB_ERR_CANCELLED) { 1069 usbd_xfer_set_stall(xfer); 1070 device_printf(sc->ndis_dev, "usb xfer warning (%s)\n", 1071 usbd_errstr(error)); 1072 } 1073 usbd_xfer_complete(sc, ne, nx, error); 1074 if (error != USB_ERR_CANCELLED) 1075 goto next; 1076 break; 1077 } 1078 } 1079 1080 static struct ndisusb_ep * 1081 usbd_get_ndisep(irp *ip, usb_endpoint_descriptor_t *ep) 1082 { 1083 device_t dev = IRP_NDIS_DEV(ip); 1084 struct ndis_softc *sc = device_get_softc(dev); 1085 struct ndisusb_ep *ne; 1086 1087 ne = &sc->ndisusb_ep[NDISUSB_GET_ENDPT(ep->bEndpointAddress)]; 1088 1089 IRP_NDISUSB_EP(ip) = ne; 1090 ip->irp_cancelfunc = (cancel_func)usbd_irpcancel_wrap; 1091 1092 return (ne); 1093 } 1094 1095 static void 1096 usbd_xfertask(device_object *dobj, void *arg) 1097 { 1098 int error; 1099 irp *ip; 1100 device_t dev; 1101 list_entry *l; 1102 struct ndis_softc *sc = arg; 1103 struct ndisusb_xferdone *nd; 1104 struct ndisusb_xfer *nq; 1105 struct usbd_urb_bulk_or_intr_transfer *ubi; 1106 struct usbd_urb_vendor_or_class_request *vcreq; 1107 union usbd_urb *urb; 1108 usb_error_t status; 1109 void *priv; 1110 1111 dev = sc->ndis_dev; 1112 1113 if (IsListEmpty(&sc->ndisusb_xferdonelist)) 1114 return; 1115 1116 KeAcquireSpinLockAtDpcLevel(&sc->ndisusb_xferdonelock); 1117 l = sc->ndisusb_xferdonelist.nle_flink; 1118 while (l != &sc->ndisusb_xferdonelist) { 1119 nd = CONTAINING_RECORD(l, struct ndisusb_xferdone, nd_donelist); 1120 nq = nd->nd_xfer; 1121 priv = nq->nx_priv; 1122 status = nd->nd_status; 1123 error = 0; 1124 ip = priv; 1125 urb = usbd_geturb(ip); 1126 1127 ip->irp_cancelfunc = NULL; 1128 IRP_NDISUSB_EP(ip) = NULL; 1129 1130 switch (status) { 1131 case USB_ERR_NORMAL_COMPLETION: 1132 if (urb->uu_hdr.uuh_func == 1133 URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER) { 1134 ubi = &urb->uu_bulkintr; 1135 ubi->ubi_trans_buflen = nq->nx_urbactlen; 1136 } else { 1137 vcreq = &urb->uu_vcreq; 1138 vcreq->uvc_trans_buflen = nq->nx_urbactlen; 1139 } 1140 ip->irp_iostat.isb_info = nq->nx_urbactlen; 1141 ip->irp_iostat.isb_status = STATUS_SUCCESS; 1142 USBD_URB_STATUS(urb) = USBD_STATUS_SUCCESS; 1143 break; 1144 case USB_ERR_CANCELLED: 1145 ip->irp_iostat.isb_info = 0; 1146 ip->irp_iostat.isb_status = STATUS_CANCELLED; 1147 USBD_URB_STATUS(urb) = USBD_STATUS_CANCELED; 1148 break; 1149 default: 1150 ip->irp_iostat.isb_info = 0; 1151 USBD_URB_STATUS(urb) = usbd_usb2urb(status); 1152 ip->irp_iostat.isb_status = 1153 usbd_urb2nt(USBD_URB_STATUS(urb)); 1154 break; 1155 } 1156 1157 l = l->nle_flink; 1158 RemoveEntryList(&nd->nd_donelist); 1159 free(nq, M_USBDEV); 1160 free(nd, M_USBDEV); 1161 if (error) 1162 continue; 1163 KeReleaseSpinLockFromDpcLevel(&sc->ndisusb_xferdonelock); 1164 /* NB: call after cleaning */ 1165 IoCompleteRequest(ip, IO_NO_INCREMENT); 1166 KeAcquireSpinLockAtDpcLevel(&sc->ndisusb_xferdonelock); 1167 } 1168 KeReleaseSpinLockFromDpcLevel(&sc->ndisusb_xferdonelock); 1169 } 1170 1171 /* 1172 * this function is for mainly deferring a task to the another thread because 1173 * we don't want to be in the scope of HAL lock. 1174 */ 1175 static int32_t 1176 usbd_taskadd(irp *ip, unsigned type) 1177 { 1178 device_t dev = IRP_NDIS_DEV(ip); 1179 struct ndis_softc *sc = device_get_softc(dev); 1180 struct ndisusb_task *nt; 1181 1182 nt = malloc(sizeof(struct ndisusb_task), M_USBDEV, M_NOWAIT | M_ZERO); 1183 if (nt == NULL) 1184 return (USBD_STATUS_NO_MEMORY); 1185 nt->nt_type = type; 1186 nt->nt_ctx = ip; 1187 1188 KeAcquireSpinLockAtDpcLevel(&sc->ndisusb_tasklock); 1189 InsertTailList((&sc->ndisusb_tasklist), (&nt->nt_tasklist)); 1190 KeReleaseSpinLockFromDpcLevel(&sc->ndisusb_tasklock); 1191 1192 IoQueueWorkItem(sc->ndisusb_taskitem, 1193 (io_workitem_func)usbd_task_wrap, WORKQUEUE_CRITICAL, sc); 1194 1195 return (USBD_STATUS_SUCCESS); 1196 } 1197 1198 static void 1199 usbd_task(device_object *dobj, void *arg) 1200 { 1201 irp *ip; 1202 list_entry *l; 1203 struct ndis_softc *sc = arg; 1204 struct ndisusb_ep *ne; 1205 struct ndisusb_task *nt; 1206 union usbd_urb *urb; 1207 1208 if (IsListEmpty(&sc->ndisusb_tasklist)) 1209 return; 1210 1211 KeAcquireSpinLockAtDpcLevel(&sc->ndisusb_tasklock); 1212 l = sc->ndisusb_tasklist.nle_flink; 1213 while (l != &sc->ndisusb_tasklist) { 1214 nt = CONTAINING_RECORD(l, struct ndisusb_task, nt_tasklist); 1215 1216 ip = nt->nt_ctx; 1217 urb = usbd_geturb(ip); 1218 1219 KeReleaseSpinLockFromDpcLevel(&sc->ndisusb_tasklock); 1220 NDISUSB_LOCK(sc); 1221 switch (nt->nt_type) { 1222 case NDISUSB_TASK_TSTART: 1223 ne = usbd_get_ndisep(ip, urb->uu_bulkintr.ubi_epdesc); 1224 if (ne == NULL) 1225 goto exit; 1226 usbd_transfer_start(ne->ne_xfer[0]); 1227 break; 1228 case NDISUSB_TASK_IRPCANCEL: 1229 ne = usbd_get_ndisep(ip, 1230 (nt->nt_type == NDISUSB_TASK_IRPCANCEL) ? 1231 urb->uu_bulkintr.ubi_epdesc : 1232 urb->uu_pipe.upr_handle); 1233 if (ne == NULL) 1234 goto exit; 1235 1236 usbd_transfer_stop(ne->ne_xfer[0]); 1237 usbd_transfer_start(ne->ne_xfer[0]); 1238 break; 1239 case NDISUSB_TASK_VENDOR: 1240 ne = (urb->uu_vcreq.uvc_trans_flags & 1241 USBD_TRANSFER_DIRECTION_IN) ? 1242 &sc->ndisusb_dread_ep : &sc->ndisusb_dwrite_ep; 1243 usbd_transfer_start(ne->ne_xfer[0]); 1244 break; 1245 default: 1246 break; 1247 } 1248 exit: 1249 NDISUSB_UNLOCK(sc); 1250 KeAcquireSpinLockAtDpcLevel(&sc->ndisusb_tasklock); 1251 1252 l = l->nle_flink; 1253 RemoveEntryList(&nt->nt_tasklist); 1254 free(nt, M_USBDEV); 1255 } 1256 KeReleaseSpinLockFromDpcLevel(&sc->ndisusb_tasklock); 1257 } 1258 1259 static int32_t 1260 usbd_func_bulkintr(irp *ip) 1261 { 1262 int32_t error; 1263 struct ndisusb_ep *ne; 1264 struct ndisusb_xfer *nx; 1265 struct usbd_urb_bulk_or_intr_transfer *ubi; 1266 union usbd_urb *urb; 1267 usb_endpoint_descriptor_t *ep; 1268 1269 urb = usbd_geturb(ip); 1270 ubi = &urb->uu_bulkintr; 1271 ep = ubi->ubi_epdesc; 1272 if (ep == NULL) 1273 return (USBD_STATUS_INVALID_PIPE_HANDLE); 1274 1275 ne = usbd_get_ndisep(ip, ep); 1276 if (ne == NULL) { 1277 device_printf(IRP_NDIS_DEV(ip), "get NULL endpoint info.\n"); 1278 return (USBD_STATUS_INVALID_PIPE_HANDLE); 1279 } 1280 1281 nx = malloc(sizeof(struct ndisusb_xfer), M_USBDEV, M_NOWAIT | M_ZERO); 1282 if (nx == NULL) { 1283 device_printf(IRP_NDIS_DEV(ip), "out of memory\n"); 1284 return (USBD_STATUS_NO_MEMORY); 1285 } 1286 nx->nx_ep = ne; 1287 nx->nx_priv = ip; 1288 KeAcquireSpinLockAtDpcLevel(&ne->ne_lock); 1289 InsertTailList((&ne->ne_pending), (&nx->nx_next)); 1290 KeReleaseSpinLockFromDpcLevel(&ne->ne_lock); 1291 1292 /* we've done to setup xfer. Let's transfer it. */ 1293 ip->irp_iostat.isb_status = STATUS_PENDING; 1294 ip->irp_iostat.isb_info = 0; 1295 USBD_URB_STATUS(urb) = USBD_STATUS_PENDING; 1296 IoMarkIrpPending(ip); 1297 1298 error = usbd_taskadd(ip, NDISUSB_TASK_TSTART); 1299 if (error != USBD_STATUS_SUCCESS) 1300 return (error); 1301 1302 return (USBD_STATUS_PENDING); 1303 } 1304 1305 static union usbd_urb * 1306 USBD_CreateConfigurationRequest(usb_config_descriptor_t *conf, uint16_t *len) 1307 { 1308 struct usbd_interface_list_entry list[2]; 1309 union usbd_urb *urb; 1310 1311 bzero(list, sizeof(struct usbd_interface_list_entry) * 2); 1312 list[0].uil_intfdesc = USBD_ParseConfigurationDescriptorEx(conf, conf, 1313 -1, -1, -1, -1, -1); 1314 urb = USBD_CreateConfigurationRequestEx(conf, list); 1315 if (urb == NULL) 1316 return (NULL); 1317 1318 *len = urb->uu_selconf.usc_hdr.uuh_len; 1319 return (urb); 1320 } 1321 1322 static union usbd_urb * 1323 USBD_CreateConfigurationRequestEx(usb_config_descriptor_t *conf, 1324 struct usbd_interface_list_entry *list) 1325 { 1326 int i, j, size; 1327 struct usbd_interface_information *intf; 1328 struct usbd_pipe_information *pipe; 1329 struct usbd_urb_select_configuration *selconf; 1330 usb_interface_descriptor_t *desc; 1331 1332 for (i = 0, size = 0; i < conf->bNumInterface; i++) { 1333 j = list[i].uil_intfdesc->bNumEndpoints; 1334 size = size + sizeof(struct usbd_interface_information) + 1335 sizeof(struct usbd_pipe_information) * (j - 1); 1336 } 1337 size += sizeof(struct usbd_urb_select_configuration) - 1338 sizeof(struct usbd_interface_information); 1339 1340 selconf = ExAllocatePoolWithTag(NonPagedPool, size, 0); 1341 if (selconf == NULL) 1342 return (NULL); 1343 selconf->usc_hdr.uuh_func = URB_FUNCTION_SELECT_CONFIGURATION; 1344 selconf->usc_hdr.uuh_len = size; 1345 selconf->usc_handle = conf; 1346 selconf->usc_conf = conf; 1347 1348 intf = &selconf->usc_intf; 1349 for (i = 0; i < conf->bNumInterface; i++) { 1350 if (list[i].uil_intfdesc == NULL) 1351 break; 1352 1353 list[i].uil_intf = intf; 1354 desc = list[i].uil_intfdesc; 1355 1356 intf->uii_len = sizeof(struct usbd_interface_information) + 1357 (desc->bNumEndpoints - 1) * 1358 sizeof(struct usbd_pipe_information); 1359 intf->uii_intfnum = desc->bInterfaceNumber; 1360 intf->uii_altset = desc->bAlternateSetting; 1361 intf->uii_intfclass = desc->bInterfaceClass; 1362 intf->uii_intfsubclass = desc->bInterfaceSubClass; 1363 intf->uii_intfproto = desc->bInterfaceProtocol; 1364 intf->uii_handle = desc; 1365 intf->uii_numeps = desc->bNumEndpoints; 1366 1367 pipe = &intf->uii_pipes[0]; 1368 for (j = 0; j < intf->uii_numeps; j++) 1369 pipe[j].upi_maxtxsize = 1370 USBD_DEFAULT_MAXIMUM_TRANSFER_SIZE; 1371 1372 intf = (struct usbd_interface_information *)((char *)intf + 1373 intf->uii_len); 1374 } 1375 1376 return ((union usbd_urb *)selconf); 1377 } 1378 1379 static void 1380 USBD_GetUSBDIVersion(usbd_version_info *ui) 1381 { 1382 1383 /* Pretend to be Windows XP. */ 1384 1385 ui->uvi_usbdi_vers = USBDI_VERSION; 1386 ui->uvi_supported_vers = USB_VER_2_0; 1387 } 1388 1389 static usb_interface_descriptor_t * 1390 USBD_ParseConfigurationDescriptor(usb_config_descriptor_t *conf, 1391 uint8_t intfnum, uint8_t altset) 1392 { 1393 1394 return USBD_ParseConfigurationDescriptorEx(conf, conf, intfnum, altset, 1395 -1, -1, -1); 1396 } 1397 1398 static usb_interface_descriptor_t * 1399 USBD_ParseConfigurationDescriptorEx(usb_config_descriptor_t *conf, 1400 void *start, int32_t intfnum, int32_t altset, int32_t intfclass, 1401 int32_t intfsubclass, int32_t intfproto) 1402 { 1403 struct usb_descriptor *next = NULL; 1404 usb_interface_descriptor_t *desc; 1405 1406 while ((next = usb_desc_foreach(conf, next)) != NULL) { 1407 desc = (usb_interface_descriptor_t *)next; 1408 if (desc->bDescriptorType != UDESC_INTERFACE) 1409 continue; 1410 if (!(intfnum == -1 || desc->bInterfaceNumber == intfnum)) 1411 continue; 1412 if (!(altset == -1 || desc->bAlternateSetting == altset)) 1413 continue; 1414 if (!(intfclass == -1 || desc->bInterfaceClass == intfclass)) 1415 continue; 1416 if (!(intfsubclass == -1 || 1417 desc->bInterfaceSubClass == intfsubclass)) 1418 continue; 1419 if (!(intfproto == -1 || desc->bInterfaceProtocol == intfproto)) 1420 continue; 1421 return (desc); 1422 } 1423 1424 return (NULL); 1425 } 1426 1427 static void 1428 dummy(void) 1429 { 1430 printf("USBD dummy called\n"); 1431 } 1432 1433 image_patch_table usbd_functbl[] = { 1434 IMPORT_SFUNC(USBD_CreateConfigurationRequest, 2), 1435 IMPORT_SFUNC(USBD_CreateConfigurationRequestEx, 2), 1436 IMPORT_SFUNC_MAP(_USBD_CreateConfigurationRequestEx@8, 1437 USBD_CreateConfigurationRequestEx, 2), 1438 IMPORT_SFUNC(USBD_GetUSBDIVersion, 1), 1439 IMPORT_SFUNC(USBD_ParseConfigurationDescriptor, 3), 1440 IMPORT_SFUNC(USBD_ParseConfigurationDescriptorEx, 7), 1441 IMPORT_SFUNC_MAP(_USBD_ParseConfigurationDescriptorEx@28, 1442 USBD_ParseConfigurationDescriptorEx, 7), 1443 1444 /* 1445 * This last entry is a catch-all for any function we haven't 1446 * implemented yet. The PE import list patching routine will 1447 * use it for any function that doesn't have an explicit match 1448 * in this table. 1449 */ 1450 1451 { NULL, (FUNC)dummy, NULL, 0, WINDRV_WRAP_STDCALL }, 1452 1453 /* End of list. */ 1454 1455 { NULL, NULL, NULL } 1456 }; 1457 1458 MODULE_DEPEND(ndis, usb, 1, 1, 1);
Cache object: 6409c9ea7fc765348b20d22ef89c3c3a
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]