1 /* $NetBSD: usbdi.c,v 1.171 2016/05/17 11:37:50 pooka Exp $ */ 2 3 /* 4 * Copyright (c) 1998, 2012, 2015 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Lennart Augustsson (lennart@augustsson.net) at 9 * Carlstedt Research & Technology, Matthew R. Green (mrg@eterna.com.au), 10 * and Nick Hudson. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 23 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 24 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 31 * POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include <sys/cdefs.h> 35 __KERNEL_RCSID(0, "$NetBSD: usbdi.c,v 1.171 2016/05/17 11:37:50 pooka Exp $"); 36 37 #ifdef _KERNEL_OPT 38 #include "opt_usb.h" 39 #include "opt_compat_netbsd.h" 40 #include "usb_dma.h" 41 #endif 42 43 #include <sys/param.h> 44 #include <sys/systm.h> 45 #include <sys/kernel.h> 46 #include <sys/device.h> 47 #include <sys/kmem.h> 48 #include <sys/proc.h> 49 #include <sys/bus.h> 50 #include <sys/cpu.h> 51 52 #include <dev/usb/usb.h> 53 #include <dev/usb/usbdi.h> 54 #include <dev/usb/usbdi_util.h> 55 #include <dev/usb/usbdivar.h> 56 #include <dev/usb/usb_mem.h> 57 #include <dev/usb/usb_quirks.h> 58 #include <dev/usb/usbhist.h> 59 60 /* UTF-8 encoding stuff */ 61 #include <fs/unicode.h> 62 63 extern int usbdebug; 64 65 Static usbd_status usbd_ar_pipe(struct usbd_pipe *); 66 Static void usbd_start_next(struct usbd_pipe *); 67 Static usbd_status usbd_open_pipe_ival 68 (struct usbd_interface *, uint8_t, uint8_t, struct usbd_pipe **, int); 69 static void *usbd_alloc_buffer(struct usbd_xfer *, uint32_t); 70 static void usbd_free_buffer(struct usbd_xfer *); 71 static struct usbd_xfer *usbd_alloc_xfer(struct usbd_device *, unsigned int); 72 static usbd_status usbd_free_xfer(struct usbd_xfer *); 73 74 #if defined(USB_DEBUG) 75 void 76 usbd_dump_iface(struct usbd_interface *iface) 77 { 78 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 79 80 USBHIST_LOG(usbdebug, "iface %p", iface, 0, 0, 0); 81 if (iface == NULL) 82 return; 83 USBHIST_LOG(usbdebug, " device = %p idesc = %p index = %d", 84 iface->ui_dev, iface->ui_idesc, iface->ui_index, 0); 85 USBHIST_LOG(usbdebug, " altindex=%d priv=%p", 86 iface->ui_altindex, iface->ui_priv, 0, 0); 87 } 88 89 void 90 usbd_dump_device(struct usbd_device *dev) 91 { 92 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 93 94 USBHIST_LOG(usbdebug, "dev = %p", dev, 0, 0, 0); 95 if (dev == NULL) 96 return; 97 USBHIST_LOG(usbdebug, " bus = %p default_pipe = %p", 98 dev->ud_bus, dev->ud_pipe0, 0, 0); 99 USBHIST_LOG(usbdebug, " address = %d config = %d depth = %d ", 100 dev->ud_addr, dev->ud_config, dev->ud_depth, 0); 101 USBHIST_LOG(usbdebug, " speed = %d self_powered = %d " 102 "power = %d langid = %d", 103 dev->ud_speed, dev->ud_selfpowered, dev->ud_power, dev->ud_langid); 104 } 105 106 void 107 usbd_dump_endpoint(struct usbd_endpoint *endp) 108 { 109 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 110 111 USBHIST_LOG(usbdebug, "endp = %p", endp, 0, 0, 0); 112 if (endp == NULL) 113 return; 114 USBHIST_LOG(usbdebug, " edesc = %p refcnt = %d", 115 endp->ue_edesc, endp->ue_refcnt, 0, 0); 116 if (endp->ue_edesc) 117 USBHIST_LOG(usbdebug, " bEndpointAddress=0x%02x", 118 endp->ue_edesc->bEndpointAddress, 0, 0, 0); 119 } 120 121 void 122 usbd_dump_queue(struct usbd_pipe *pipe) 123 { 124 struct usbd_xfer *xfer; 125 126 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 127 128 USBHIST_LOG(usbdebug, "pipe = %p", pipe, 0, 0, 0); 129 SIMPLEQ_FOREACH(xfer, &pipe->up_queue, ux_next) { 130 USBHIST_LOG(usbdebug, " xfer = %p", xfer, 0, 0, 0); 131 } 132 } 133 134 void 135 usbd_dump_pipe(struct usbd_pipe *pipe) 136 { 137 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 138 139 USBHIST_LOG(usbdebug, "pipe = %p", pipe, 0, 0, 0); 140 if (pipe == NULL) 141 return; 142 usbd_dump_iface(pipe->up_iface); 143 usbd_dump_device(pipe->up_dev); 144 usbd_dump_endpoint(pipe->up_endpoint); 145 USBHIST_LOG(usbdebug, "(usbd_dump_pipe)", 0, 0, 0, 0); 146 USBHIST_LOG(usbdebug, " running = %d aborting = %d", 147 pipe->up_running, pipe->up_aborting, 0, 0); 148 USBHIST_LOG(usbdebug, " intrxfer = %p, repeat = %d, interval = %d", 149 pipe->up_intrxfer, pipe->up_repeat, pipe->up_interval, 0); 150 } 151 #endif 152 153 usbd_status 154 usbd_open_pipe(struct usbd_interface *iface, uint8_t address, 155 uint8_t flags, struct usbd_pipe **pipe) 156 { 157 return (usbd_open_pipe_ival(iface, address, flags, pipe, 158 USBD_DEFAULT_INTERVAL)); 159 } 160 161 usbd_status 162 usbd_open_pipe_ival(struct usbd_interface *iface, uint8_t address, 163 uint8_t flags, struct usbd_pipe **pipe, int ival) 164 { 165 struct usbd_pipe *p; 166 struct usbd_endpoint *ep; 167 usbd_status err; 168 int i; 169 170 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 171 172 USBHIST_LOG(usbdebug, "iface = %p address = 0x%x flags = 0x%x", 173 iface, address, flags, 0); 174 175 for (i = 0; i < iface->ui_idesc->bNumEndpoints; i++) { 176 ep = &iface->ui_endpoints[i]; 177 if (ep->ue_edesc == NULL) 178 return USBD_IOERROR; 179 if (ep->ue_edesc->bEndpointAddress == address) 180 goto found; 181 } 182 return USBD_BAD_ADDRESS; 183 found: 184 if ((flags & USBD_EXCLUSIVE_USE) && ep->ue_refcnt != 0) 185 return USBD_IN_USE; 186 err = usbd_setup_pipe_flags(iface->ui_dev, iface, ep, ival, &p, flags); 187 if (err) 188 return err; 189 LIST_INSERT_HEAD(&iface->ui_pipes, p, up_next); 190 *pipe = p; 191 return USBD_NORMAL_COMPLETION; 192 } 193 194 usbd_status 195 usbd_open_pipe_intr(struct usbd_interface *iface, uint8_t address, 196 uint8_t flags, struct usbd_pipe **pipe, 197 void *priv, void *buffer, uint32_t len, 198 usbd_callback cb, int ival) 199 { 200 usbd_status err; 201 struct usbd_xfer *xfer; 202 struct usbd_pipe *ipipe; 203 204 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 205 206 USBHIST_LOG(usbdebug, "address = 0x%x flags = 0x%x len = %d", 207 address, flags, len, 0); 208 209 err = usbd_open_pipe_ival(iface, address, 210 USBD_EXCLUSIVE_USE | (flags & USBD_MPSAFE), 211 &ipipe, ival); 212 if (err) 213 return err; 214 err = usbd_create_xfer(ipipe, len, flags, 0, &xfer); 215 if (err) 216 goto bad1; 217 218 usbd_setup_xfer(xfer, priv, buffer, len, flags, USBD_NO_TIMEOUT, cb); 219 ipipe->up_intrxfer = xfer; 220 ipipe->up_repeat = 1; 221 err = usbd_transfer(xfer); 222 *pipe = ipipe; 223 if (err != USBD_IN_PROGRESS) 224 goto bad3; 225 return USBD_NORMAL_COMPLETION; 226 227 bad3: 228 ipipe->up_intrxfer = NULL; 229 ipipe->up_repeat = 0; 230 231 usbd_destroy_xfer(xfer); 232 bad1: 233 usbd_close_pipe(ipipe); 234 return err; 235 } 236 237 usbd_status 238 usbd_close_pipe(struct usbd_pipe *pipe) 239 { 240 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 241 242 KASSERT(pipe != NULL); 243 244 usbd_lock_pipe(pipe); 245 246 if (!SIMPLEQ_EMPTY(&pipe->up_queue)) { 247 printf("WARNING: pipe closed with active xfers on addr %d\n", 248 pipe->up_dev->ud_addr); 249 usbd_ar_pipe(pipe); 250 } 251 252 KASSERT(SIMPLEQ_EMPTY(&pipe->up_queue)); 253 254 LIST_REMOVE(pipe, up_next); 255 pipe->up_endpoint->ue_refcnt--; 256 257 if (pipe->up_intrxfer != NULL) { 258 usbd_unlock_pipe(pipe); 259 usbd_destroy_xfer(pipe->up_intrxfer); 260 usbd_lock_pipe(pipe); 261 } 262 263 pipe->up_methods->upm_close(pipe); 264 usbd_unlock_pipe(pipe); 265 kmem_free(pipe, pipe->up_dev->ud_bus->ub_pipesize); 266 267 return USBD_NORMAL_COMPLETION; 268 } 269 270 usbd_status 271 usbd_transfer(struct usbd_xfer *xfer) 272 { 273 struct usbd_pipe *pipe = xfer->ux_pipe; 274 usbd_status err; 275 unsigned int size, flags; 276 277 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 278 279 USBHIST_LOG(usbdebug, 280 "xfer = %p, flags = %#x, pipe = %p, running = %d", 281 xfer, xfer->ux_flags, pipe, pipe->up_running); 282 283 #ifdef USB_DEBUG 284 if (usbdebug > 5) 285 usbd_dump_queue(pipe); 286 #endif 287 xfer->ux_done = 0; 288 289 if (pipe->up_aborting) { 290 USBHIST_LOG(usbdebug, "<- done xfer %p, aborting", xfer, 0, 0, 291 0); 292 return USBD_CANCELLED; 293 } 294 295 KASSERT(xfer->ux_length == 0 || xfer->ux_buf != NULL); 296 297 size = xfer->ux_length; 298 flags = xfer->ux_flags; 299 300 if (size != 0) { 301 /* 302 * Use the xfer buffer if none specified in transfer setup. 303 * isoc transfers always use the xfer buffer, i.e. 304 * ux_buffer is always NULL for isoc. 305 */ 306 if (xfer->ux_buffer == NULL) { 307 xfer->ux_buffer = xfer->ux_buf; 308 } 309 310 /* 311 * If not using the xfer buffer copy data to the 312 * xfer buffer for OUT transfers of >0 length 313 */ 314 if (xfer->ux_buffer != xfer->ux_buf) { 315 KASSERT(xfer->ux_buf); 316 if (!usbd_xfer_isread(xfer)) { 317 memcpy(xfer->ux_buf, xfer->ux_buffer, size); 318 } 319 } 320 } 321 322 /* xfer is not valid after the transfer method unless synchronous */ 323 err = pipe->up_methods->upm_transfer(xfer); 324 USBHIST_LOG(usbdebug, "<- done transfer %p, err = %d", xfer, err, 0, 0); 325 326 if (err != USBD_IN_PROGRESS && err) { 327 /* 328 * The transfer made it onto the pipe queue, but didn't get 329 * accepted by the HCD for some reason. It needs removing 330 * from the pipe queue. 331 */ 332 usbd_lock_pipe(pipe); 333 SIMPLEQ_REMOVE_HEAD(&pipe->up_queue, ux_next); 334 if (pipe->up_serialise) 335 usbd_start_next(pipe); 336 usbd_unlock_pipe(pipe); 337 } 338 339 if (!(flags & USBD_SYNCHRONOUS)) { 340 USBHIST_LOG(usbdebug, "<- done xfer %p, not sync (err %d)", 341 xfer, err, 0, 0); 342 return err; 343 } 344 345 if (err != USBD_IN_PROGRESS) { 346 USBHIST_LOG(usbdebug, "<- done xfer %p, err %d (complete/error)", xfer, 347 err, 0, 0); 348 return err; 349 } 350 351 /* Sync transfer, wait for completion. */ 352 usbd_lock_pipe(pipe); 353 while (!xfer->ux_done) { 354 if (pipe->up_dev->ud_bus->ub_usepolling) 355 panic("usbd_transfer: not done"); 356 USBHIST_LOG(usbdebug, "<- sleeping on xfer %p", xfer, 0, 0, 0); 357 358 err = 0; 359 if ((flags & USBD_SYNCHRONOUS_SIG) != 0) { 360 err = cv_wait_sig(&xfer->ux_cv, pipe->up_dev->ud_bus->ub_lock); 361 } else { 362 cv_wait(&xfer->ux_cv, pipe->up_dev->ud_bus->ub_lock); 363 } 364 if (err) { 365 if (!xfer->ux_done) 366 pipe->up_methods->upm_abort(xfer); 367 break; 368 } 369 } 370 usbd_unlock_pipe(pipe); 371 return xfer->ux_status; 372 } 373 374 /* Like usbd_transfer(), but waits for completion. */ 375 usbd_status 376 usbd_sync_transfer(struct usbd_xfer *xfer) 377 { 378 xfer->ux_flags |= USBD_SYNCHRONOUS; 379 return usbd_transfer(xfer); 380 } 381 382 /* Like usbd_transfer(), but waits for completion and listens for signals. */ 383 usbd_status 384 usbd_sync_transfer_sig(struct usbd_xfer *xfer) 385 { 386 xfer->ux_flags |= USBD_SYNCHRONOUS | USBD_SYNCHRONOUS_SIG; 387 return usbd_transfer(xfer); 388 } 389 390 static void * 391 usbd_alloc_buffer(struct usbd_xfer *xfer, uint32_t size) 392 { 393 KASSERT(xfer->ux_buf == NULL); 394 KASSERT(size != 0); 395 396 xfer->ux_bufsize = 0; 397 #if NUSB_DMA > 0 398 struct usbd_bus *bus = xfer->ux_bus; 399 400 if (bus->ub_usedma) { 401 usb_dma_t *dmap = &xfer->ux_dmabuf; 402 403 int err = usb_allocmem_flags(bus, size, 0, dmap, bus->ub_dmaflags); 404 if (err) { 405 return NULL; 406 } 407 xfer->ux_buf = KERNADDR(&xfer->ux_dmabuf, 0); 408 xfer->ux_bufsize = size; 409 410 return xfer->ux_buf; 411 } 412 #endif 413 KASSERT(xfer->ux_bus->ub_usedma == false); 414 xfer->ux_buf = kmem_alloc(size, KM_SLEEP); 415 416 if (xfer->ux_buf != NULL) { 417 xfer->ux_bufsize = size; 418 } 419 420 return xfer->ux_buf; 421 } 422 423 static void 424 usbd_free_buffer(struct usbd_xfer *xfer) 425 { 426 KASSERT(xfer->ux_buf != NULL); 427 KASSERT(xfer->ux_bufsize != 0); 428 429 void *buf = xfer->ux_buf; 430 uint32_t size = xfer->ux_bufsize; 431 432 xfer->ux_buf = NULL; 433 xfer->ux_bufsize = 0; 434 435 #if NUSB_DMA > 0 436 struct usbd_bus *bus = xfer->ux_bus; 437 438 if (bus->ub_usedma) { 439 usb_dma_t *dmap = &xfer->ux_dmabuf; 440 441 usb_freemem(bus, dmap); 442 return; 443 } 444 #endif 445 KASSERT(xfer->ux_bus->ub_usedma == false); 446 447 kmem_free(buf, size); 448 } 449 450 void * 451 usbd_get_buffer(struct usbd_xfer *xfer) 452 { 453 return xfer->ux_buf; 454 } 455 456 struct usbd_pipe * 457 usbd_get_pipe0(struct usbd_device *dev) 458 { 459 460 return dev->ud_pipe0; 461 } 462 463 static struct usbd_xfer * 464 usbd_alloc_xfer(struct usbd_device *dev, unsigned int nframes) 465 { 466 struct usbd_xfer *xfer; 467 468 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 469 470 ASSERT_SLEEPABLE(); 471 472 xfer = dev->ud_bus->ub_methods->ubm_allocx(dev->ud_bus, nframes); 473 if (xfer == NULL) 474 return NULL; 475 xfer->ux_bus = dev->ud_bus; 476 callout_init(&xfer->ux_callout, CALLOUT_MPSAFE); 477 cv_init(&xfer->ux_cv, "usbxfer"); 478 cv_init(&xfer->ux_hccv, "usbhcxfer"); 479 480 USBHIST_LOG(usbdebug, "returns %p", xfer, 0, 0, 0); 481 482 return xfer; 483 } 484 485 static usbd_status 486 usbd_free_xfer(struct usbd_xfer *xfer) 487 { 488 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 489 490 USBHIST_LOG(usbdebug, "%p", xfer, 0, 0, 0); 491 if (xfer->ux_buf) { 492 usbd_free_buffer(xfer); 493 } 494 #if defined(DIAGNOSTIC) 495 if (callout_pending(&xfer->ux_callout)) { 496 callout_stop(&xfer->ux_callout); 497 printf("usbd_free_xfer: timeout_handle pending\n"); 498 } 499 #endif 500 cv_destroy(&xfer->ux_cv); 501 cv_destroy(&xfer->ux_hccv); 502 xfer->ux_bus->ub_methods->ubm_freex(xfer->ux_bus, xfer); 503 return USBD_NORMAL_COMPLETION; 504 } 505 506 int 507 usbd_create_xfer(struct usbd_pipe *pipe, size_t len, unsigned int flags, 508 unsigned int nframes, struct usbd_xfer **xp) 509 { 510 KASSERT(xp != NULL); 511 void *buf = NULL; 512 513 struct usbd_xfer *xfer = usbd_alloc_xfer(pipe->up_dev, nframes); 514 if (xfer == NULL) 515 return ENOMEM; 516 517 if (len) { 518 buf = usbd_alloc_buffer(xfer, len); 519 if (!buf) { 520 usbd_free_xfer(xfer); 521 return ENOMEM; 522 } 523 } 524 xfer->ux_pipe = pipe; 525 xfer->ux_flags = flags; 526 xfer->ux_nframes = nframes; 527 xfer->ux_methods = pipe->up_methods; 528 529 if (xfer->ux_methods->upm_init) { 530 int err = xfer->ux_methods->upm_init(xfer); 531 if (err) { 532 if (buf) 533 usbd_free_buffer(xfer); 534 usbd_free_xfer(xfer); 535 return err; 536 } 537 } 538 539 *xp = xfer; 540 return 0; 541 } 542 543 void 544 usbd_destroy_xfer(struct usbd_xfer *xfer) 545 { 546 547 if (xfer->ux_methods->upm_fini) { 548 xfer->ux_methods->upm_fini(xfer); 549 } 550 551 usbd_free_xfer(xfer); 552 } 553 554 void 555 usbd_setup_xfer(struct usbd_xfer *xfer, void *priv, void *buffer, 556 uint32_t length, uint16_t flags, uint32_t timeout, usbd_callback callback) 557 { 558 KASSERT(xfer->ux_pipe); 559 560 xfer->ux_priv = priv; 561 xfer->ux_buffer = buffer; 562 xfer->ux_length = length; 563 xfer->ux_actlen = 0; 564 xfer->ux_flags = flags; 565 xfer->ux_timeout = timeout; 566 xfer->ux_status = USBD_NOT_STARTED; 567 xfer->ux_callback = callback; 568 xfer->ux_rqflags &= ~URQ_REQUEST; 569 xfer->ux_nframes = 0; 570 } 571 572 void 573 usbd_setup_default_xfer(struct usbd_xfer *xfer, struct usbd_device *dev, 574 void *priv, uint32_t timeout, usb_device_request_t *req, void *buffer, 575 uint32_t length, uint16_t flags, usbd_callback callback) 576 { 577 KASSERT(xfer->ux_pipe == dev->ud_pipe0); 578 579 xfer->ux_priv = priv; 580 xfer->ux_buffer = buffer; 581 xfer->ux_length = length; 582 xfer->ux_actlen = 0; 583 xfer->ux_flags = flags; 584 xfer->ux_timeout = timeout; 585 xfer->ux_status = USBD_NOT_STARTED; 586 xfer->ux_callback = callback; 587 xfer->ux_request = *req; 588 xfer->ux_rqflags |= URQ_REQUEST; 589 xfer->ux_nframes = 0; 590 } 591 592 void 593 usbd_setup_isoc_xfer(struct usbd_xfer *xfer, void *priv, uint16_t *frlengths, 594 uint32_t nframes, uint16_t flags, usbd_callback callback) 595 { 596 xfer->ux_priv = priv; 597 xfer->ux_buffer = NULL; 598 xfer->ux_length = 0; 599 xfer->ux_actlen = 0; 600 xfer->ux_flags = flags; 601 xfer->ux_timeout = USBD_NO_TIMEOUT; 602 xfer->ux_status = USBD_NOT_STARTED; 603 xfer->ux_callback = callback; 604 xfer->ux_rqflags &= ~URQ_REQUEST; 605 xfer->ux_frlengths = frlengths; 606 xfer->ux_nframes = nframes; 607 } 608 609 void 610 usbd_get_xfer_status(struct usbd_xfer *xfer, void **priv, 611 void **buffer, uint32_t *count, usbd_status *status) 612 { 613 if (priv != NULL) 614 *priv = xfer->ux_priv; 615 if (buffer != NULL) 616 *buffer = xfer->ux_buffer; 617 if (count != NULL) 618 *count = xfer->ux_actlen; 619 if (status != NULL) 620 *status = xfer->ux_status; 621 } 622 623 usb_config_descriptor_t * 624 usbd_get_config_descriptor(struct usbd_device *dev) 625 { 626 KASSERT(dev != NULL); 627 628 return dev->ud_cdesc; 629 } 630 631 usb_interface_descriptor_t * 632 usbd_get_interface_descriptor(struct usbd_interface *iface) 633 { 634 KASSERT(iface != NULL); 635 636 return iface->ui_idesc; 637 } 638 639 usb_device_descriptor_t * 640 usbd_get_device_descriptor(struct usbd_device *dev) 641 { 642 KASSERT(dev != NULL); 643 644 return &dev->ud_ddesc; 645 } 646 647 usb_endpoint_descriptor_t * 648 usbd_interface2endpoint_descriptor(struct usbd_interface *iface, uint8_t index) 649 { 650 651 if (index >= iface->ui_idesc->bNumEndpoints) 652 return NULL; 653 return iface->ui_endpoints[index].ue_edesc; 654 } 655 656 /* Some drivers may wish to abort requests on the default pipe, * 657 * but there is no mechanism for getting a handle on it. */ 658 usbd_status 659 usbd_abort_default_pipe(struct usbd_device *device) 660 { 661 return usbd_abort_pipe(device->ud_pipe0); 662 } 663 664 usbd_status 665 usbd_abort_pipe(struct usbd_pipe *pipe) 666 { 667 usbd_status err; 668 669 KASSERT(pipe != NULL); 670 671 usbd_lock_pipe(pipe); 672 err = usbd_ar_pipe(pipe); 673 usbd_unlock_pipe(pipe); 674 return err; 675 } 676 677 usbd_status 678 usbd_clear_endpoint_stall(struct usbd_pipe *pipe) 679 { 680 struct usbd_device *dev = pipe->up_dev; 681 usb_device_request_t req; 682 usbd_status err; 683 684 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 685 686 /* 687 * Clearing en endpoint stall resets the endpoint toggle, so 688 * do the same to the HC toggle. 689 */ 690 pipe->up_methods->upm_cleartoggle(pipe); 691 692 req.bmRequestType = UT_WRITE_ENDPOINT; 693 req.bRequest = UR_CLEAR_FEATURE; 694 USETW(req.wValue, UF_ENDPOINT_HALT); 695 USETW(req.wIndex, pipe->up_endpoint->ue_edesc->bEndpointAddress); 696 USETW(req.wLength, 0); 697 err = usbd_do_request(dev, &req, 0); 698 #if 0 699 XXX should we do this? 700 if (!err) { 701 pipe->state = USBD_PIPE_ACTIVE; 702 /* XXX activate pipe */ 703 } 704 #endif 705 return err; 706 } 707 708 void 709 usbd_clear_endpoint_stall_task(void *arg) 710 { 711 struct usbd_pipe *pipe = arg; 712 struct usbd_device *dev = pipe->up_dev; 713 usb_device_request_t req; 714 715 pipe->up_methods->upm_cleartoggle(pipe); 716 717 req.bmRequestType = UT_WRITE_ENDPOINT; 718 req.bRequest = UR_CLEAR_FEATURE; 719 USETW(req.wValue, UF_ENDPOINT_HALT); 720 USETW(req.wIndex, pipe->up_endpoint->ue_edesc->bEndpointAddress); 721 USETW(req.wLength, 0); 722 (void)usbd_do_request(dev, &req, 0); 723 } 724 725 void 726 usbd_clear_endpoint_stall_async(struct usbd_pipe *pipe) 727 { 728 usb_add_task(pipe->up_dev, &pipe->up_async_task, USB_TASKQ_DRIVER); 729 } 730 731 void 732 usbd_clear_endpoint_toggle(struct usbd_pipe *pipe) 733 { 734 735 pipe->up_methods->upm_cleartoggle(pipe); 736 } 737 738 usbd_status 739 usbd_endpoint_count(struct usbd_interface *iface, uint8_t *count) 740 { 741 KASSERT(iface != NULL); 742 KASSERT(iface->ui_idesc != NULL); 743 744 *count = iface->ui_idesc->bNumEndpoints; 745 return USBD_NORMAL_COMPLETION; 746 } 747 748 usbd_status 749 usbd_interface_count(struct usbd_device *dev, uint8_t *count) 750 { 751 752 if (dev->ud_cdesc == NULL) 753 return USBD_NOT_CONFIGURED; 754 *count = dev->ud_cdesc->bNumInterface; 755 return USBD_NORMAL_COMPLETION; 756 } 757 758 void 759 usbd_interface2device_handle(struct usbd_interface *iface, 760 struct usbd_device **dev) 761 { 762 763 *dev = iface->ui_dev; 764 } 765 766 usbd_status 767 usbd_device2interface_handle(struct usbd_device *dev, 768 uint8_t ifaceno, struct usbd_interface **iface) 769 { 770 771 if (dev->ud_cdesc == NULL) 772 return USBD_NOT_CONFIGURED; 773 if (ifaceno >= dev->ud_cdesc->bNumInterface) 774 return USBD_INVAL; 775 *iface = &dev->ud_ifaces[ifaceno]; 776 return USBD_NORMAL_COMPLETION; 777 } 778 779 struct usbd_device * 780 usbd_pipe2device_handle(struct usbd_pipe *pipe) 781 { 782 KASSERT(pipe != NULL); 783 784 return pipe->up_dev; 785 } 786 787 /* XXXX use altno */ 788 usbd_status 789 usbd_set_interface(struct usbd_interface *iface, int altidx) 790 { 791 usb_device_request_t req; 792 usbd_status err; 793 void *endpoints; 794 795 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 796 797 if (LIST_FIRST(&iface->ui_pipes) != NULL) 798 return USBD_IN_USE; 799 800 endpoints = iface->ui_endpoints; 801 int nendpt = iface->ui_idesc->bNumEndpoints; 802 USBHIST_LOG(usbdebug, "iface %p endpoints = %p nendpt", iface, 803 endpoints, iface->ui_idesc->bNumEndpoints, 0); 804 err = usbd_fill_iface_data(iface->ui_dev, iface->ui_index, altidx); 805 if (err) 806 return err; 807 808 /* new setting works, we can free old endpoints */ 809 if (endpoints != NULL) { 810 USBHIST_LOG(usbdebug, "iface %p endpoints = %p nendpt", iface, 811 endpoints, nendpt, 0); 812 kmem_free(endpoints, nendpt * sizeof(struct usbd_endpoint)); 813 } 814 KASSERT(iface->ui_idesc != NULL); 815 816 req.bmRequestType = UT_WRITE_INTERFACE; 817 req.bRequest = UR_SET_INTERFACE; 818 USETW(req.wValue, iface->ui_idesc->bAlternateSetting); 819 USETW(req.wIndex, iface->ui_idesc->bInterfaceNumber); 820 USETW(req.wLength, 0); 821 return usbd_do_request(iface->ui_dev, &req, 0); 822 } 823 824 int 825 usbd_get_no_alts(usb_config_descriptor_t *cdesc, int ifaceno) 826 { 827 char *p = (char *)cdesc; 828 char *end = p + UGETW(cdesc->wTotalLength); 829 usb_interface_descriptor_t *d; 830 int n; 831 832 for (n = 0; p < end; p += d->bLength) { 833 d = (usb_interface_descriptor_t *)p; 834 if (p + d->bLength <= end && 835 d->bDescriptorType == UDESC_INTERFACE && 836 d->bInterfaceNumber == ifaceno) 837 n++; 838 } 839 return n; 840 } 841 842 int 843 usbd_get_interface_altindex(struct usbd_interface *iface) 844 { 845 return iface->ui_altindex; 846 } 847 848 usbd_status 849 usbd_get_interface(struct usbd_interface *iface, uint8_t *aiface) 850 { 851 usb_device_request_t req; 852 853 req.bmRequestType = UT_READ_INTERFACE; 854 req.bRequest = UR_GET_INTERFACE; 855 USETW(req.wValue, 0); 856 USETW(req.wIndex, iface->ui_idesc->bInterfaceNumber); 857 USETW(req.wLength, 1); 858 return usbd_do_request(iface->ui_dev, &req, aiface); 859 } 860 861 /*** Internal routines ***/ 862 863 /* Dequeue all pipe operations, called at splusb(). */ 864 Static usbd_status 865 usbd_ar_pipe(struct usbd_pipe *pipe) 866 { 867 struct usbd_xfer *xfer; 868 869 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 870 871 KASSERT(mutex_owned(pipe->up_dev->ud_bus->ub_lock)); 872 873 USBHIST_LOG(usbdebug, "pipe = %p", pipe, 0, 0, 0); 874 #ifdef USB_DEBUG 875 if (usbdebug > 5) 876 usbd_dump_queue(pipe); 877 #endif 878 pipe->up_repeat = 0; 879 pipe->up_aborting = 1; 880 while ((xfer = SIMPLEQ_FIRST(&pipe->up_queue)) != NULL) { 881 USBHIST_LOG(usbdebug, "pipe = %p xfer = %p (methods = %p)", 882 pipe, xfer, pipe->up_methods, 0); 883 /* Make the HC abort it (and invoke the callback). */ 884 pipe->up_methods->upm_abort(xfer); 885 /* XXX only for non-0 usbd_clear_endpoint_stall(pipe); */ 886 } 887 pipe->up_aborting = 0; 888 return USBD_NORMAL_COMPLETION; 889 } 890 891 /* Called with USB lock held. */ 892 void 893 usb_transfer_complete(struct usbd_xfer *xfer) 894 { 895 struct usbd_pipe *pipe = xfer->ux_pipe; 896 struct usbd_bus *bus = pipe->up_dev->ud_bus; 897 int sync = xfer->ux_flags & USBD_SYNCHRONOUS; 898 int erred = 899 xfer->ux_status == USBD_CANCELLED || 900 xfer->ux_status == USBD_TIMEOUT; 901 int polling = bus->ub_usepolling; 902 int repeat = pipe->up_repeat; 903 904 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 905 906 USBHIST_LOG(usbdebug, "pipe = %p xfer = %p status = %d actlen = %d", 907 pipe, xfer, xfer->ux_status, xfer->ux_actlen); 908 909 KASSERT(polling || mutex_owned(pipe->up_dev->ud_bus->ub_lock)); 910 KASSERT(xfer->ux_state == XFER_ONQU); 911 KASSERT(pipe != NULL); 912 913 if (!repeat) { 914 /* Remove request from queue. */ 915 916 KASSERTMSG(!SIMPLEQ_EMPTY(&pipe->up_queue), 917 "pipe %p is empty, but xfer %p wants to complete", pipe, 918 xfer); 919 KASSERTMSG(xfer == SIMPLEQ_FIRST(&pipe->up_queue), 920 "xfer %p is not start of queue (%p is at start)", xfer, 921 SIMPLEQ_FIRST(&pipe->up_queue)); 922 923 #ifdef DIAGNOSTIC 924 xfer->ux_state = XFER_BUSY; 925 #endif 926 SIMPLEQ_REMOVE_HEAD(&pipe->up_queue, ux_next); 927 } 928 USBHIST_LOG(usbdebug, "xfer %p: repeat %d new head = %p", 929 xfer, repeat, SIMPLEQ_FIRST(&pipe->up_queue), 0); 930 931 /* Count completed transfers. */ 932 ++pipe->up_dev->ud_bus->ub_stats.uds_requests 933 [pipe->up_endpoint->ue_edesc->bmAttributes & UE_XFERTYPE]; 934 935 xfer->ux_done = 1; 936 if (!xfer->ux_status && xfer->ux_actlen < xfer->ux_length && 937 !(xfer->ux_flags & USBD_SHORT_XFER_OK)) { 938 USBHIST_LOG(usbdebug, "short transfer %d < %d", 939 xfer->ux_actlen, xfer->ux_length, 0, 0); 940 xfer->ux_status = USBD_SHORT_XFER; 941 } 942 943 USBHIST_LOG(usbdebug, "xfer %p doing done %p", xfer, 944 pipe->up_methods->upm_done, 0, 0); 945 pipe->up_methods->upm_done(xfer); 946 947 if (xfer->ux_length != 0 && xfer->ux_buffer != xfer->ux_buf) { 948 KDASSERTMSG(xfer->ux_actlen <= xfer->ux_length, 949 "actlen %d length %d",xfer->ux_actlen, xfer->ux_length); 950 951 /* Only if IN transfer */ 952 if (usbd_xfer_isread(xfer)) { 953 memcpy(xfer->ux_buffer, xfer->ux_buf, xfer->ux_actlen); 954 } 955 } 956 957 USBHIST_LOG(usbdebug, "xfer %p doing callback %p status %d", 958 xfer, xfer->ux_callback, xfer->ux_status, 0); 959 960 if (xfer->ux_callback) { 961 if (!polling) 962 mutex_exit(pipe->up_dev->ud_bus->ub_lock); 963 964 if (!(pipe->up_flags & USBD_MPSAFE)) 965 KERNEL_LOCK(1, curlwp); 966 967 xfer->ux_callback(xfer, xfer->ux_priv, xfer->ux_status); 968 969 if (!(pipe->up_flags & USBD_MPSAFE)) 970 KERNEL_UNLOCK_ONE(curlwp); 971 972 if (!polling) 973 mutex_enter(pipe->up_dev->ud_bus->ub_lock); 974 } 975 976 if (sync && !polling) { 977 USBHIST_LOG(usbdebug, "<- done xfer %p, wakeup", xfer, 0, 0, 0); 978 cv_broadcast(&xfer->ux_cv); 979 } 980 981 if (repeat) { 982 xfer->ux_actlen = 0; 983 xfer->ux_status = USBD_NOT_STARTED; 984 } else { 985 /* XXX should we stop the queue on all errors? */ 986 if (erred && pipe->up_iface != NULL) /* not control pipe */ 987 pipe->up_running = 0; 988 } 989 if (pipe->up_running && pipe->up_serialise) 990 usbd_start_next(pipe); 991 } 992 993 /* Called with USB lock held. */ 994 usbd_status 995 usb_insert_transfer(struct usbd_xfer *xfer) 996 { 997 struct usbd_pipe *pipe = xfer->ux_pipe; 998 usbd_status err; 999 1000 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 1001 1002 USBHIST_LOG(usbdebug, "xfer = %p pipe = %p running = %d timeout = %d", 1003 xfer, pipe, pipe->up_running, xfer->ux_timeout); 1004 1005 KASSERT(mutex_owned(pipe->up_dev->ud_bus->ub_lock)); 1006 KASSERT(xfer->ux_state == XFER_BUSY); 1007 1008 #ifdef DIAGNOSTIC 1009 xfer->ux_state = XFER_ONQU; 1010 #endif 1011 SIMPLEQ_INSERT_TAIL(&pipe->up_queue, xfer, ux_next); 1012 if (pipe->up_running && pipe->up_serialise) 1013 err = USBD_IN_PROGRESS; 1014 else { 1015 pipe->up_running = 1; 1016 err = USBD_NORMAL_COMPLETION; 1017 } 1018 USBHIST_LOG(usbdebug, "<- done xfer %p, err %d", xfer, err, 0, 0); 1019 return err; 1020 } 1021 1022 /* Called with USB lock held. */ 1023 void 1024 usbd_start_next(struct usbd_pipe *pipe) 1025 { 1026 struct usbd_xfer *xfer; 1027 usbd_status err; 1028 1029 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 1030 1031 KASSERT(pipe != NULL); 1032 KASSERT(pipe->up_methods != NULL); 1033 KASSERT(pipe->up_methods->upm_start != NULL); 1034 KASSERT(pipe->up_serialise == true); 1035 1036 int polling = pipe->up_dev->ud_bus->ub_usepolling; 1037 KASSERT(polling || mutex_owned(pipe->up_dev->ud_bus->ub_lock)); 1038 1039 /* Get next request in queue. */ 1040 xfer = SIMPLEQ_FIRST(&pipe->up_queue); 1041 USBHIST_LOG(usbdebug, "pipe = %p, xfer = %p", pipe, xfer, 0, 0); 1042 if (xfer == NULL) { 1043 pipe->up_running = 0; 1044 } else { 1045 if (!polling) 1046 mutex_exit(pipe->up_dev->ud_bus->ub_lock); 1047 err = pipe->up_methods->upm_start(xfer); 1048 if (!polling) 1049 mutex_enter(pipe->up_dev->ud_bus->ub_lock); 1050 1051 if (err != USBD_IN_PROGRESS) { 1052 USBHIST_LOG(usbdebug, "error = %d", err, 0, 0, 0); 1053 pipe->up_running = 0; 1054 /* XXX do what? */ 1055 } 1056 } 1057 1058 KASSERT(polling || mutex_owned(pipe->up_dev->ud_bus->ub_lock)); 1059 } 1060 1061 usbd_status 1062 usbd_do_request(struct usbd_device *dev, usb_device_request_t *req, void *data) 1063 { 1064 1065 return usbd_do_request_flags(dev, req, data, 0, 0, 1066 USBD_DEFAULT_TIMEOUT); 1067 } 1068 1069 usbd_status 1070 usbd_do_request_flags(struct usbd_device *dev, usb_device_request_t *req, 1071 void *data, uint16_t flags, int *actlen, uint32_t timeout) 1072 { 1073 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 1074 struct usbd_xfer *xfer; 1075 usbd_status err; 1076 1077 ASSERT_SLEEPABLE(); 1078 1079 size_t len = UGETW(req->wLength); 1080 int error = usbd_create_xfer(dev->ud_pipe0, len, 0, 0, &xfer); 1081 if (error) 1082 return error; 1083 1084 usbd_setup_default_xfer(xfer, dev, 0, timeout, req, data, 1085 UGETW(req->wLength), flags, NULL); 1086 KASSERT(xfer->ux_pipe == dev->ud_pipe0); 1087 err = usbd_sync_transfer(xfer); 1088 #if defined(USB_DEBUG) || defined(DIAGNOSTIC) 1089 if (xfer->ux_actlen > xfer->ux_length) { 1090 USBHIST_LOG(usbdebug, "overrun addr = %d type = 0x%02x", 1091 dev->ud_addr, xfer->ux_request.bmRequestType, 0, 0); 1092 USBHIST_LOG(usbdebug, " req = 0x%02x val = %d index = %d", 1093 xfer->ux_request.bRequest, UGETW(xfer->ux_request.wValue), 1094 UGETW(xfer->ux_request.wIndex), 0); 1095 USBHIST_LOG(usbdebug, " rlen = %d length = %d actlen = %d", 1096 UGETW(xfer->ux_request.wLength), 1097 xfer->ux_length, xfer->ux_actlen, 0); 1098 } 1099 #endif 1100 if (actlen != NULL) 1101 *actlen = xfer->ux_actlen; 1102 1103 usbd_destroy_xfer(xfer); 1104 1105 if (err) { 1106 USBHIST_LOG(usbdebug, "returning err = %d", err, 0, 0, 0); 1107 } 1108 return err; 1109 } 1110 1111 const struct usbd_quirks * 1112 usbd_get_quirks(struct usbd_device *dev) 1113 { 1114 #ifdef DIAGNOSTIC 1115 if (dev == NULL) { 1116 printf("usbd_get_quirks: dev == NULL\n"); 1117 return 0; 1118 } 1119 #endif 1120 return dev->ud_quirks; 1121 } 1122 1123 /* XXX do periodic free() of free list */ 1124 1125 /* 1126 * Called from keyboard driver when in polling mode. 1127 */ 1128 void 1129 usbd_dopoll(struct usbd_interface *iface) 1130 { 1131 iface->ui_dev->ud_bus->ub_methods->ubm_dopoll(iface->ui_dev->ud_bus); 1132 } 1133 1134 /* 1135 * XXX use this more??? ub_usepolling it touched manually all over 1136 */ 1137 void 1138 usbd_set_polling(struct usbd_device *dev, int on) 1139 { 1140 if (on) 1141 dev->ud_bus->ub_usepolling++; 1142 else 1143 dev->ud_bus->ub_usepolling--; 1144 1145 /* Kick the host controller when switching modes */ 1146 mutex_enter(dev->ud_bus->ub_lock); 1147 dev->ud_bus->ub_methods->ubm_softint(dev->ud_bus); 1148 mutex_exit(dev->ud_bus->ub_lock); 1149 } 1150 1151 1152 usb_endpoint_descriptor_t * 1153 usbd_get_endpoint_descriptor(struct usbd_interface *iface, uint8_t address) 1154 { 1155 struct usbd_endpoint *ep; 1156 int i; 1157 1158 for (i = 0; i < iface->ui_idesc->bNumEndpoints; i++) { 1159 ep = &iface->ui_endpoints[i]; 1160 if (ep->ue_edesc->bEndpointAddress == address) 1161 return iface->ui_endpoints[i].ue_edesc; 1162 } 1163 return NULL; 1164 } 1165 1166 /* 1167 * usbd_ratecheck() can limit the number of error messages that occurs. 1168 * When a device is unplugged it may take up to 0.25s for the hub driver 1169 * to notice it. If the driver continuously tries to do I/O operations 1170 * this can generate a large number of messages. 1171 */ 1172 int 1173 usbd_ratecheck(struct timeval *last) 1174 { 1175 static struct timeval errinterval = { 0, 250000 }; /* 0.25 s*/ 1176 1177 return ratecheck(last, &errinterval); 1178 } 1179 1180 /* 1181 * Search for a vendor/product pair in an array. The item size is 1182 * given as an argument. 1183 */ 1184 const struct usb_devno * 1185 usb_match_device(const struct usb_devno *tbl, u_int nentries, u_int sz, 1186 uint16_t vendor, uint16_t product) 1187 { 1188 while (nentries-- > 0) { 1189 uint16_t tproduct = tbl->ud_product; 1190 if (tbl->ud_vendor == vendor && 1191 (tproduct == product || tproduct == USB_PRODUCT_ANY)) 1192 return tbl; 1193 tbl = (const struct usb_devno *)((const char *)tbl + sz); 1194 } 1195 return NULL; 1196 } 1197 1198 1199 void 1200 usb_desc_iter_init(struct usbd_device *dev, usbd_desc_iter_t *iter) 1201 { 1202 const usb_config_descriptor_t *cd = usbd_get_config_descriptor(dev); 1203 1204 iter->cur = (const uByte *)cd; 1205 iter->end = (const uByte *)cd + UGETW(cd->wTotalLength); 1206 } 1207 1208 const usb_descriptor_t * 1209 usb_desc_iter_next(usbd_desc_iter_t *iter) 1210 { 1211 const usb_descriptor_t *desc; 1212 1213 if (iter->cur + sizeof(usb_descriptor_t) >= iter->end) { 1214 if (iter->cur != iter->end) 1215 printf("usb_desc_iter_next: bad descriptor\n"); 1216 return NULL; 1217 } 1218 desc = (const usb_descriptor_t *)iter->cur; 1219 if (desc->bLength == 0) { 1220 printf("usb_desc_iter_next: descriptor length = 0\n"); 1221 return NULL; 1222 } 1223 iter->cur += desc->bLength; 1224 if (iter->cur > iter->end) { 1225 printf("usb_desc_iter_next: descriptor length too large\n"); 1226 return NULL; 1227 } 1228 return desc; 1229 } 1230 1231 usbd_status 1232 usbd_get_string(struct usbd_device *dev, int si, char *buf) 1233 { 1234 return usbd_get_string0(dev, si, buf, 1); 1235 } 1236 1237 usbd_status 1238 usbd_get_string0(struct usbd_device *dev, int si, char *buf, int unicode) 1239 { 1240 int swap = dev->ud_quirks->uq_flags & UQ_SWAP_UNICODE; 1241 usb_string_descriptor_t us; 1242 char *s; 1243 int i, n; 1244 uint16_t c; 1245 usbd_status err; 1246 int size; 1247 1248 USBHIST_FUNC(); USBHIST_CALLED(usbdebug); 1249 1250 buf[0] = '\0'; 1251 if (si == 0) 1252 return USBD_INVAL; 1253 if (dev->ud_quirks->uq_flags & UQ_NO_STRINGS) 1254 return USBD_STALLED; 1255 if (dev->ud_langid == USBD_NOLANG) { 1256 /* Set up default language */ 1257 err = usbd_get_string_desc(dev, USB_LANGUAGE_TABLE, 0, &us, 1258 &size); 1259 if (err || size < 4) { 1260 USBHIST_LOG(usbdebug, "getting lang failed, using 0", 1261 0, 0, 0, 0); 1262 dev->ud_langid = 0; /* Well, just pick something then */ 1263 } else { 1264 /* Pick the first language as the default. */ 1265 dev->ud_langid = UGETW(us.bString[0]); 1266 } 1267 } 1268 err = usbd_get_string_desc(dev, si, dev->ud_langid, &us, &size); 1269 if (err) 1270 return err; 1271 s = buf; 1272 n = size / 2 - 1; 1273 if (unicode) { 1274 for (i = 0; i < n; i++) { 1275 c = UGETW(us.bString[i]); 1276 if (swap) 1277 c = (c >> 8) | (c << 8); 1278 s += wput_utf8(s, 3, c); 1279 } 1280 *s++ = 0; 1281 } 1282 #ifdef COMPAT_30 1283 else { 1284 for (i = 0; i < n; i++) { 1285 c = UGETW(us.bString[i]); 1286 if (swap) 1287 c = (c >> 8) | (c << 8); 1288 *s++ = (c < 0x80) ? c : '?'; 1289 } 1290 *s++ = 0; 1291 } 1292 #endif 1293 return USBD_NORMAL_COMPLETION; 1294 } 1295