usb_generic.c revision 185948
1/* $FreeBSD: head/sys/dev/usb2/core/usb2_generic.c 185948 2008-12-11 23:13:02Z thompsa $ */ 2/*- 3 * Copyright (c) 2008 Hans Petter Selasky. 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 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27#include <dev/usb2/include/usb2_defs.h> 28#include <dev/usb2/include/usb2_mfunc.h> 29#include <dev/usb2/include/usb2_standard.h> 30#include <dev/usb2/include/usb2_ioctl.h> 31#include <dev/usb2/include/usb2_error.h> 32 33#define USB_DEBUG_VAR ugen_debug 34 35#include <dev/usb2/core/usb2_core.h> 36#include <dev/usb2/core/usb2_mbuf.h> 37#include <dev/usb2/core/usb2_dev.h> 38#include <dev/usb2/core/usb2_process.h> 39#include <dev/usb2/core/usb2_device.h> 40#include <dev/usb2/core/usb2_debug.h> 41#include <dev/usb2/core/usb2_request.h> 42#include <dev/usb2/core/usb2_busdma.h> 43#include <dev/usb2/core/usb2_util.h> 44#include <dev/usb2/core/usb2_hub.h> 45#include <dev/usb2/core/usb2_generic.h> 46#include <dev/usb2/core/usb2_transfer.h> 47 48#include <dev/usb2/controller/usb2_controller.h> 49#include <dev/usb2/controller/usb2_bus.h> 50 51/* defines */ 52 53#define UGEN_BULK_FS_BUFFER_SIZE (64*32) /* bytes */ 54#define UGEN_BULK_HS_BUFFER_SIZE (1024*32) /* bytes */ 55#define UGEN_HW_FRAMES 50 /* number of milliseconds per transfer */ 56 57/* function prototypes */ 58 59static usb2_callback_t ugen_read_clear_stall_callback; 60static usb2_callback_t ugen_write_clear_stall_callback; 61static usb2_callback_t ugen_default_read_callback; 62static usb2_callback_t ugen_default_write_callback; 63static usb2_callback_t ugen_isoc_read_callback; 64static usb2_callback_t ugen_isoc_write_callback; 65static usb2_callback_t ugen_default_fs_callback; 66 67static usb2_fifo_open_t ugen_open; 68static usb2_fifo_close_t ugen_close; 69static usb2_fifo_ioctl_t ugen_ioctl; 70static usb2_fifo_ioctl_t ugen_ioctl_post; 71static usb2_fifo_cmd_t ugen_start_read; 72static usb2_fifo_cmd_t ugen_start_write; 73static usb2_fifo_cmd_t ugen_stop_io; 74 75static int ugen_transfer_setup(struct usb2_fifo *, 76 const struct usb2_config *, uint8_t); 77static int ugen_open_pipe_write(struct usb2_fifo *); 78static int ugen_open_pipe_read(struct usb2_fifo *); 79static int ugen_set_config(struct usb2_fifo *, uint8_t); 80static int ugen_set_interface(struct usb2_fifo *, uint8_t, uint8_t); 81static int ugen_get_cdesc(struct usb2_fifo *, struct usb2_gen_descriptor *); 82static int ugen_get_sdesc(struct usb2_fifo *, struct usb2_gen_descriptor *); 83static int usb2_gen_fill_deviceinfo(struct usb2_fifo *, 84 struct usb2_device_info *); 85static int ugen_re_enumerate(struct usb2_fifo *); 86static int ugen_iface_ioctl(struct usb2_fifo *, u_long, void *, int); 87static uint8_t ugen_fs_get_complete(struct usb2_fifo *, uint8_t *); 88static int ugen_fs_uninit(struct usb2_fifo *f); 89 90/* structures */ 91 92struct usb2_fifo_methods usb2_ugen_methods = { 93 .f_open = &ugen_open, 94 .f_close = &ugen_close, 95 .f_ioctl = &ugen_ioctl, 96 .f_ioctl_post = &ugen_ioctl_post, 97 .f_start_read = &ugen_start_read, 98 .f_stop_read = &ugen_stop_io, 99 .f_start_write = &ugen_start_write, 100 .f_stop_write = &ugen_stop_io, 101}; 102 103#if USB_DEBUG 104static int ugen_debug = 0; 105 106SYSCTL_NODE(_hw_usb2, OID_AUTO, ugen, CTLFLAG_RW, 0, "USB generic"); 107SYSCTL_INT(_hw_usb2_ugen, OID_AUTO, debug, CTLFLAG_RW, &ugen_debug, 108 0, "Debug level"); 109#endif 110 111 112/* prototypes */ 113 114static int 115ugen_transfer_setup(struct usb2_fifo *f, 116 const struct usb2_config *setup, uint8_t n_setup) 117{ 118 struct usb2_pipe *pipe = f->priv_sc0; 119 struct usb2_device *udev = f->udev; 120 uint8_t iface_index = pipe->iface_index; 121 int error; 122 123 mtx_unlock(f->priv_mtx); 124 125 /* 126 * "usb2_transfer_setup()" can sleep so one needs to make a wrapper, 127 * exiting the mutex and checking things 128 */ 129 error = usb2_transfer_setup(udev, &iface_index, f->xfer, 130 setup, n_setup, f, f->priv_mtx); 131 if (error == 0) { 132 133 if (f->xfer[0]->nframes == 1) { 134 error = usb2_fifo_alloc_buffer(f, 135 f->xfer[0]->max_data_length, 2); 136 } else { 137 error = usb2_fifo_alloc_buffer(f, 138 f->xfer[0]->max_frame_size, 139 2 * f->xfer[0]->nframes); 140 } 141 if (error) { 142 usb2_transfer_unsetup(f->xfer, n_setup); 143 } 144 } 145 mtx_lock(f->priv_mtx); 146 147 return (error); 148} 149 150static int 151ugen_open(struct usb2_fifo *f, int fflags, struct thread *td) 152{ 153 struct usb2_pipe *pipe = f->priv_sc0; 154 struct usb2_endpoint_descriptor *ed = pipe->edesc; 155 uint8_t type; 156 157 DPRINTFN(6, "flag=0x%x\n", fflags); 158 159 mtx_lock(f->priv_mtx); 160 if (usb2_get_speed(f->udev) == USB_SPEED_HIGH) { 161 f->nframes = UGEN_HW_FRAMES * 8; 162 f->bufsize = UGEN_BULK_HS_BUFFER_SIZE; 163 } else { 164 f->nframes = UGEN_HW_FRAMES; 165 f->bufsize = UGEN_BULK_FS_BUFFER_SIZE; 166 } 167 168 type = ed->bmAttributes & UE_XFERTYPE; 169 if (type == UE_INTERRUPT) { 170 f->bufsize = 0; /* use "wMaxPacketSize" */ 171 } 172 f->timeout = USB_NO_TIMEOUT; 173 f->flag_short = 0; 174 f->fifo_zlp = 0; 175 mtx_unlock(f->priv_mtx); 176 177 return (0); 178} 179 180static void 181ugen_close(struct usb2_fifo *f, int fflags, struct thread *td) 182{ 183 DPRINTFN(6, "flag=0x%x\n", fflags); 184 185 /* cleanup */ 186 187 mtx_lock(f->priv_mtx); 188 usb2_transfer_stop(f->xfer[0]); 189 usb2_transfer_stop(f->xfer[1]); 190 mtx_unlock(f->priv_mtx); 191 192 usb2_transfer_unsetup(f->xfer, 2); 193 usb2_fifo_free_buffer(f); 194 195 if (ugen_fs_uninit(f)) { 196 /* ignore any errors - we are closing */ 197 DPRINTFN(6, "no FIFOs\n"); 198 } 199 return; 200} 201 202static int 203ugen_open_pipe_write(struct usb2_fifo *f) 204{ 205 struct usb2_config usb2_config[2]; 206 struct usb2_pipe *pipe = f->priv_sc0; 207 struct usb2_endpoint_descriptor *ed = pipe->edesc; 208 209 mtx_assert(f->priv_mtx, MA_OWNED); 210 211 if (f->xfer[0] || f->xfer[1]) { 212 /* transfers are already opened */ 213 return (0); 214 } 215 bzero(usb2_config, sizeof(usb2_config)); 216 217 usb2_config[1].type = UE_CONTROL; 218 usb2_config[1].endpoint = 0; 219 usb2_config[1].direction = UE_DIR_ANY; 220 usb2_config[1].mh.timeout = 1000; /* 1 second */ 221 usb2_config[1].mh.interval = 50;/* 50 milliseconds */ 222 usb2_config[1].mh.bufsize = sizeof(struct usb2_device_request); 223 usb2_config[1].mh.callback = &ugen_write_clear_stall_callback; 224 225 usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE; 226 usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR; 227 usb2_config[0].direction = ed->bEndpointAddress & (UE_DIR_OUT | UE_DIR_IN); 228 usb2_config[0].mh.interval = USB_DEFAULT_INTERVAL; 229 usb2_config[0].mh.flags.proxy_buffer = 1; 230 231 switch (ed->bmAttributes & UE_XFERTYPE) { 232 case UE_INTERRUPT: 233 case UE_BULK: 234 if (f->flag_short) { 235 usb2_config[0].mh.flags.force_short_xfer = 1; 236 } 237 usb2_config[0].mh.callback = &ugen_default_write_callback; 238 usb2_config[0].mh.timeout = f->timeout; 239 usb2_config[0].mh.frames = 1; 240 usb2_config[0].mh.bufsize = f->bufsize; 241 usb2_config[0].md = usb2_config[0].mh; /* symmetric config */ 242 if (ugen_transfer_setup(f, usb2_config, 2)) { 243 return (EIO); 244 } 245 /* first transfer does not clear stall */ 246 f->flag_stall = 0; 247 break; 248 249 case UE_ISOCHRONOUS: 250 usb2_config[0].mh.flags.short_xfer_ok = 1; 251 usb2_config[0].mh.bufsize = 0; /* use default */ 252 usb2_config[0].mh.frames = f->nframes; 253 usb2_config[0].mh.callback = &ugen_isoc_write_callback; 254 usb2_config[0].mh.timeout = 0; 255 usb2_config[0].md = usb2_config[0].mh; /* symmetric config */ 256 257 /* clone configuration */ 258 usb2_config[1] = usb2_config[0]; 259 260 if (ugen_transfer_setup(f, usb2_config, 2)) { 261 return (EIO); 262 } 263 break; 264 default: 265 return (EINVAL); 266 } 267 return (0); 268} 269 270static int 271ugen_open_pipe_read(struct usb2_fifo *f) 272{ 273 struct usb2_config usb2_config[2]; 274 struct usb2_pipe *pipe = f->priv_sc0; 275 struct usb2_endpoint_descriptor *ed = pipe->edesc; 276 277 mtx_assert(f->priv_mtx, MA_OWNED); 278 279 if (f->xfer[0] || f->xfer[1]) { 280 /* transfers are already opened */ 281 return (0); 282 } 283 bzero(usb2_config, sizeof(usb2_config)); 284 285 usb2_config[1].type = UE_CONTROL; 286 usb2_config[1].endpoint = 0; 287 usb2_config[1].direction = UE_DIR_ANY; 288 usb2_config[1].mh.timeout = 1000; /* 1 second */ 289 usb2_config[1].mh.interval = 50;/* 50 milliseconds */ 290 usb2_config[1].mh.bufsize = sizeof(struct usb2_device_request); 291 usb2_config[1].mh.callback = &ugen_read_clear_stall_callback; 292 293 usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE; 294 usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR; 295 usb2_config[0].direction = UE_DIR_IN; 296 usb2_config[0].mh.interval = USB_DEFAULT_INTERVAL; 297 usb2_config[0].mh.flags.proxy_buffer = 1; 298 299 switch (ed->bmAttributes & UE_XFERTYPE) { 300 case UE_INTERRUPT: 301 case UE_BULK: 302 if (f->flag_short) { 303 usb2_config[0].mh.flags.short_xfer_ok = 1; 304 } 305 usb2_config[0].mh.timeout = f->timeout; 306 usb2_config[0].mh.frames = 1; 307 usb2_config[0].mh.callback = &ugen_default_read_callback; 308 usb2_config[0].mh.bufsize = f->bufsize; 309 usb2_config[0].md = usb2_config[0].mh; /* symmetric config */ 310 311 if (ugen_transfer_setup(f, usb2_config, 2)) { 312 return (EIO); 313 } 314 /* first transfer does not clear stall */ 315 f->flag_stall = 0; 316 break; 317 318 case UE_ISOCHRONOUS: 319 usb2_config[0].mh.flags.short_xfer_ok = 1; 320 usb2_config[0].mh.bufsize = 0; /* use default */ 321 usb2_config[0].mh.frames = f->nframes; 322 usb2_config[0].mh.callback = &ugen_isoc_read_callback; 323 usb2_config[0].mh.timeout = 0; 324 usb2_config[0].md = usb2_config[0].mh; /* symmetric config */ 325 326 /* clone configuration */ 327 usb2_config[1] = usb2_config[0]; 328 329 if (ugen_transfer_setup(f, usb2_config, 2)) { 330 return (EIO); 331 } 332 break; 333 334 default: 335 return (EINVAL); 336 } 337 return (0); 338} 339 340static void 341ugen_start_read(struct usb2_fifo *f) 342{ 343 /* check that pipes are open */ 344 if (ugen_open_pipe_read(f)) { 345 /* signal error */ 346 usb2_fifo_put_data_error(f); 347 } 348 /* start transfers */ 349 usb2_transfer_start(f->xfer[0]); 350 usb2_transfer_start(f->xfer[1]); 351 return; 352} 353 354static void 355ugen_start_write(struct usb2_fifo *f) 356{ 357 /* check that pipes are open */ 358 if (ugen_open_pipe_write(f)) { 359 /* signal error */ 360 usb2_fifo_get_data_error(f); 361 } 362 /* start transfers */ 363 usb2_transfer_start(f->xfer[0]); 364 usb2_transfer_start(f->xfer[1]); 365 return; 366} 367 368static void 369ugen_stop_io(struct usb2_fifo *f) 370{ 371 /* stop transfers */ 372 usb2_transfer_stop(f->xfer[0]); 373 usb2_transfer_stop(f->xfer[1]); 374 return; 375} 376 377static void 378ugen_default_read_callback(struct usb2_xfer *xfer) 379{ 380 struct usb2_fifo *f = xfer->priv_sc; 381 struct usb2_mbuf *m; 382 383 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes); 384 385 switch (USB_GET_STATE(xfer)) { 386 case USB_ST_TRANSFERRED: 387 if (xfer->actlen == 0) { 388 if (f->fifo_zlp != 4) { 389 f->fifo_zlp++; 390 } else { 391 /* 392 * Throttle a little bit we have multiple ZLPs 393 * in a row! 394 */ 395 xfer->interval = 64; /* ms */ 396 } 397 } else { 398 /* clear throttle */ 399 xfer->interval = 0; 400 f->fifo_zlp = 0; 401 } 402 usb2_fifo_put_data(f, xfer->frbuffers, 0, 403 xfer->actlen, 1); 404 405 case USB_ST_SETUP: 406 if (f->flag_stall) { 407 usb2_transfer_start(f->xfer[1]); 408 break; 409 } 410 USB_IF_POLL(&f->free_q, m); 411 if (m) { 412 xfer->frlengths[0] = xfer->max_data_length; 413 usb2_start_hardware(xfer); 414 } 415 break; 416 417 default: /* Error */ 418 if (xfer->error != USB_ERR_CANCELLED) { 419 f->flag_stall = 1; 420 f->fifo_zlp = 0; 421 usb2_transfer_start(f->xfer[1]); 422 } 423 break; 424 } 425 return; 426} 427 428static void 429ugen_default_write_callback(struct usb2_xfer *xfer) 430{ 431 struct usb2_fifo *f = xfer->priv_sc; 432 uint32_t actlen; 433 434 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes); 435 436 switch (USB_GET_STATE(xfer)) { 437 case USB_ST_SETUP: 438 case USB_ST_TRANSFERRED: 439 /* 440 * If writing is in stall, just jump to clear stall 441 * callback and solve the situation. 442 */ 443 if (f->flag_stall) { 444 usb2_transfer_start(f->xfer[1]); 445 break; 446 } 447 /* 448 * Write data, setup and perform hardware transfer. 449 */ 450 if (usb2_fifo_get_data(f, xfer->frbuffers, 0, 451 xfer->max_data_length, &actlen, 0)) { 452 xfer->frlengths[0] = actlen; 453 usb2_start_hardware(xfer); 454 } 455 break; 456 457 default: /* Error */ 458 if (xfer->error != USB_ERR_CANCELLED) { 459 f->flag_stall = 1; 460 usb2_transfer_start(f->xfer[1]); 461 } 462 break; 463 } 464 return; 465} 466 467static void 468ugen_read_clear_stall_callback(struct usb2_xfer *xfer) 469{ 470 struct usb2_fifo *f = xfer->priv_sc; 471 struct usb2_xfer *xfer_other = f->xfer[0]; 472 473 if (f->flag_stall == 0) { 474 /* nothing to do */ 475 return; 476 } 477 if (usb2_clear_stall_callback(xfer, xfer_other)) { 478 DPRINTFN(5, "f=%p: stall cleared\n", f); 479 f->flag_stall = 0; 480 usb2_transfer_start(xfer_other); 481 } 482 return; 483} 484 485static void 486ugen_write_clear_stall_callback(struct usb2_xfer *xfer) 487{ 488 struct usb2_fifo *f = xfer->priv_sc; 489 struct usb2_xfer *xfer_other = f->xfer[0]; 490 491 if (f->flag_stall == 0) { 492 /* nothing to do */ 493 return; 494 } 495 if (usb2_clear_stall_callback(xfer, xfer_other)) { 496 DPRINTFN(5, "f=%p: stall cleared\n", f); 497 f->flag_stall = 0; 498 usb2_transfer_start(xfer_other); 499 } 500 return; 501} 502 503static void 504ugen_isoc_read_callback(struct usb2_xfer *xfer) 505{ 506 struct usb2_fifo *f = xfer->priv_sc; 507 uint32_t offset; 508 uint16_t n; 509 510 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes); 511 512 switch (USB_GET_STATE(xfer)) { 513 case USB_ST_TRANSFERRED: 514 515 DPRINTFN(6, "actlen=%d\n", xfer->actlen); 516 517 offset = 0; 518 519 for (n = 0; n != xfer->aframes; n++) { 520 usb2_fifo_put_data(f, xfer->frbuffers, offset, 521 xfer->frlengths[n], 1); 522 offset += xfer->max_frame_size; 523 } 524 525 case USB_ST_SETUP: 526tr_setup: 527 for (n = 0; n != xfer->nframes; n++) { 528 /* setup size for next transfer */ 529 xfer->frlengths[n] = xfer->max_frame_size; 530 } 531 usb2_start_hardware(xfer); 532 break; 533 534 default: /* Error */ 535 if (xfer->error == USB_ERR_CANCELLED) { 536 break; 537 } 538 goto tr_setup; 539 } 540 return; 541} 542 543static void 544ugen_isoc_write_callback(struct usb2_xfer *xfer) 545{ 546 struct usb2_fifo *f = xfer->priv_sc; 547 uint32_t actlen; 548 uint32_t offset; 549 uint16_t n; 550 551 DPRINTFN(4, "actlen=%u, aframes=%u\n", xfer->actlen, xfer->aframes); 552 553 switch (USB_GET_STATE(xfer)) { 554 case USB_ST_TRANSFERRED: 555 case USB_ST_SETUP: 556tr_setup: 557 offset = 0; 558 for (n = 0; n != xfer->nframes; n++) { 559 if (usb2_fifo_get_data(f, xfer->frbuffers, offset, 560 xfer->max_frame_size, &actlen, 1)) { 561 xfer->frlengths[n] = actlen; 562 offset += actlen; 563 } else { 564 break; 565 } 566 } 567 568 for (; n != xfer->nframes; n++) { 569 /* fill in zero frames */ 570 xfer->frlengths[n] = 0; 571 } 572 usb2_start_hardware(xfer); 573 break; 574 575 default: /* Error */ 576 if (xfer->error == USB_ERR_CANCELLED) { 577 break; 578 } 579 goto tr_setup; 580 } 581 return; 582} 583 584static int 585ugen_set_config(struct usb2_fifo *f, uint8_t index) 586{ 587 DPRINTFN(2, "index %u\n", index); 588 589 if (f->udev->flags.usb2_mode != USB_MODE_HOST) { 590 /* not possible in device side mode */ 591 return (ENOTTY); 592 } 593 if (f->udev->curr_config_index == index) { 594 /* no change needed */ 595 return (0); 596 } 597 /* make sure all FIFO's are gone */ 598 /* else there can be a deadlock */ 599 if (ugen_fs_uninit(f)) { 600 /* ignore any errors */ 601 DPRINTFN(6, "no FIFOs\n"); 602 } 603 /* change setting - will free generic FIFOs, if any */ 604 if (usb2_set_config_index(f->udev, index)) { 605 return (EIO); 606 } 607 /* probe and attach */ 608 if (usb2_probe_and_attach(f->udev, USB_IFACE_INDEX_ANY)) { 609 return (EIO); 610 } 611 return (0); 612} 613 614static int 615ugen_set_interface(struct usb2_fifo *f, 616 uint8_t iface_index, uint8_t alt_index) 617{ 618 DPRINTFN(2, "%u, %u\n", iface_index, alt_index); 619 620 if (f->udev->flags.usb2_mode != USB_MODE_HOST) { 621 /* not possible in device side mode */ 622 return (ENOTTY); 623 } 624 /* make sure all FIFO's are gone */ 625 /* else there can be a deadlock */ 626 if (ugen_fs_uninit(f)) { 627 /* ignore any errors */ 628 DPRINTFN(6, "no FIFOs\n"); 629 } 630 /* change setting - will free generic FIFOs, if any */ 631 if (usb2_set_alt_interface_index(f->udev, iface_index, alt_index)) { 632 return (EIO); 633 } 634 /* probe and attach */ 635 if (usb2_probe_and_attach(f->udev, iface_index)) { 636 return (EIO); 637 } 638 return (0); 639} 640 641/*------------------------------------------------------------------------* 642 * ugen_get_cdesc 643 * 644 * This function will retrieve the complete configuration descriptor 645 * at the given index. 646 *------------------------------------------------------------------------*/ 647static int 648ugen_get_cdesc(struct usb2_fifo *f, struct usb2_gen_descriptor *ugd) 649{ 650 struct usb2_config_descriptor *cdesc; 651 struct usb2_device *udev = f->udev; 652 int error; 653 uint16_t len; 654 uint8_t free_data; 655 656 DPRINTFN(6, "\n"); 657 658 if (ugd->ugd_data == NULL) { 659 /* userland pointer should not be zero */ 660 return (EINVAL); 661 } 662 if ((ugd->ugd_config_index == USB_UNCONFIG_INDEX) || 663 (ugd->ugd_config_index == udev->curr_config_index)) { 664 cdesc = usb2_get_config_descriptor(udev); 665 if (cdesc == NULL) { 666 return (ENXIO); 667 } 668 free_data = 0; 669 670 } else { 671 if (usb2_req_get_config_desc_full(udev, 672 &Giant, &cdesc, M_USBDEV, 673 ugd->ugd_config_index)) { 674 return (ENXIO); 675 } 676 free_data = 1; 677 } 678 679 len = UGETW(cdesc->wTotalLength); 680 if (len > ugd->ugd_maxlen) { 681 len = ugd->ugd_maxlen; 682 } 683 DPRINTFN(6, "len=%u\n", len); 684 685 ugd->ugd_actlen = len; 686 ugd->ugd_offset = 0; 687 688 error = copyout(cdesc, ugd->ugd_data, len); 689 690 if (free_data) { 691 free(cdesc, M_USBDEV); 692 } 693 return (error); 694} 695 696static int 697ugen_get_sdesc(struct usb2_fifo *f, struct usb2_gen_descriptor *ugd) 698{ 699 void *ptr = f->udev->bus->scratch[0].data; 700 uint16_t size = sizeof(f->udev->bus->scratch[0].data); 701 int error; 702 703 if (usb2_req_get_string_desc(f->udev, &Giant, ptr, 704 size, ugd->ugd_lang_id, ugd->ugd_string_index)) { 705 error = EINVAL; 706 } else { 707 708 if (size > ((uint8_t *)ptr)[0]) { 709 size = ((uint8_t *)ptr)[0]; 710 } 711 if (size > ugd->ugd_maxlen) { 712 size = ugd->ugd_maxlen; 713 } 714 ugd->ugd_actlen = size; 715 ugd->ugd_offset = 0; 716 717 error = copyout(ptr, ugd->ugd_data, size); 718 } 719 return (error); 720} 721 722/*------------------------------------------------------------------------* 723 * usb2_gen_fill_devicenames 724 * 725 * This function dumps information about an USB device names to 726 * userland. 727 * 728 * Returns: 729 * 0: Success 730 * Else: Failure 731 *------------------------------------------------------------------------*/ 732static int 733usb2_gen_fill_devicenames(struct usb2_fifo *f, struct usb2_device_names *dn) 734{ 735 struct usb2_interface *iface; 736 const char *ptr; 737 char *dst; 738 char buf[32]; 739 int error = 0; 740 int len; 741 int max_len; 742 uint8_t i; 743 uint8_t first = 1; 744 745 max_len = dn->udn_devnames_len; 746 dst = dn->udn_devnames_ptr; 747 748 if (max_len == 0) { 749 return (EINVAL); 750 } 751 /* put a zero there */ 752 error = copyout("", dst, 1); 753 if (error) { 754 return (error); 755 } 756 for (i = 0;; i++) { 757 iface = usb2_get_iface(f->udev, i); 758 if (iface == NULL) { 759 break; 760 } 761 if ((iface->subdev != NULL) && 762 device_is_attached(iface->subdev)) { 763 ptr = device_get_nameunit(iface->subdev); 764 if (!first) { 765 strlcpy(buf, ", ", sizeof(buf)); 766 } else { 767 buf[0] = 0; 768 } 769 strlcat(buf, ptr, sizeof(buf)); 770 len = strlen(buf) + 1; 771 if (len > max_len) { 772 break; 773 } 774 error = copyout(buf, dst, len); 775 if (error) { 776 return (error); 777 } 778 len--; 779 dst += len; 780 max_len -= len; 781 first = 0; 782 } 783 } 784 return (0); 785} 786 787/*------------------------------------------------------------------------* 788 * usb2_gen_fill_deviceinfo 789 * 790 * This function dumps information about an USB device to the 791 * structure pointed to by the "di" argument. 792 * 793 * Returns: 794 * 0: Success 795 * Else: Failure 796 *------------------------------------------------------------------------*/ 797static int 798usb2_gen_fill_deviceinfo(struct usb2_fifo *f, struct usb2_device_info *di) 799{ 800 struct usb2_device *udev; 801 struct usb2_device *hub; 802 803 udev = f->udev; 804 805 bzero(di, sizeof(di[0])); 806 807 di->udi_bus = device_get_unit(udev->bus->bdev); 808 di->udi_addr = udev->address; 809 di->udi_index = udev->device_index; 810 strlcpy(di->udi_serial, udev->serial, 811 sizeof(di->udi_serial)); 812 strlcpy(di->udi_vendor, udev->manufacturer, 813 sizeof(di->udi_vendor)); 814 strlcpy(di->udi_product, udev->product, 815 sizeof(di->udi_product)); 816 usb2_printBCD(di->udi_release, sizeof(di->udi_release), 817 UGETW(udev->ddesc.bcdDevice)); 818 di->udi_vendorNo = UGETW(udev->ddesc.idVendor); 819 di->udi_productNo = UGETW(udev->ddesc.idProduct); 820 di->udi_releaseNo = UGETW(udev->ddesc.bcdDevice); 821 di->udi_class = udev->ddesc.bDeviceClass; 822 di->udi_subclass = udev->ddesc.bDeviceSubClass; 823 di->udi_protocol = udev->ddesc.bDeviceProtocol; 824 di->udi_config_no = udev->curr_config_no; 825 di->udi_config_index = udev->curr_config_index; 826 di->udi_power = udev->flags.self_powered ? 0 : udev->power; 827 di->udi_speed = udev->speed; 828 di->udi_mode = udev->flags.usb2_mode; 829 di->udi_power_mode = udev->power_mode; 830 if (udev->flags.suspended) { 831 di->udi_suspended = 1; 832 } else { 833 di->udi_suspended = 0; 834 } 835 836 hub = udev->parent_hub; 837 if (hub) { 838 di->udi_hubaddr = hub->address; 839 di->udi_hubindex = hub->device_index; 840 di->udi_hubport = udev->port_no; 841 } 842 return (0); 843} 844 845/*------------------------------------------------------------------------* 846 * ugen_check_request 847 * 848 * Return values: 849 * 0: Access allowed 850 * Else: No access 851 *------------------------------------------------------------------------*/ 852static int 853ugen_check_request(struct usb2_device *udev, struct usb2_device_request *req) 854{ 855 struct usb2_pipe *pipe; 856 int error; 857 858 /* 859 * Avoid requests that would damage the bus integrity: 860 */ 861 if (((req->bmRequestType == UT_WRITE_DEVICE) && 862 (req->bRequest == UR_SET_ADDRESS)) || 863 ((req->bmRequestType == UT_WRITE_DEVICE) && 864 (req->bRequest == UR_SET_CONFIG)) || 865 ((req->bmRequestType == UT_WRITE_INTERFACE) && 866 (req->bRequest == UR_SET_INTERFACE))) { 867 /* 868 * These requests can be useful for testing USB drivers. 869 */ 870 error = priv_check(curthread, PRIV_DRIVER); 871 if (error) { 872 return (error); 873 } 874 } 875 /* 876 * Special case - handle clearing of stall 877 */ 878 if (req->bmRequestType == UT_WRITE_ENDPOINT) { 879 880 pipe = usb2_get_pipe_by_addr(udev, req->wIndex[0]); 881 if (pipe == NULL) { 882 return (EINVAL); 883 } 884 if (usb2_check_thread_perm(udev, curthread, FREAD | FWRITE, 885 pipe->iface_index, req->wIndex[0] & UE_ADDR)) { 886 return (EPERM); 887 } 888 if ((req->bRequest == UR_CLEAR_FEATURE) && 889 (UGETW(req->wValue) == UF_ENDPOINT_HALT)) { 890 usb2_clear_data_toggle(udev, pipe); 891 } 892 } 893 /* TODO: add more checks to verify the interface index */ 894 895 return (0); 896} 897 898int 899ugen_do_request(struct usb2_fifo *f, struct usb2_ctl_request *ur) 900{ 901 int error; 902 uint16_t len; 903 uint16_t actlen; 904 905 if (ugen_check_request(f->udev, &ur->ucr_request)) { 906 return (EPERM); 907 } 908 len = UGETW(ur->ucr_request.wLength); 909 910 /* check if "ucr_data" is valid */ 911 if (len != 0) { 912 if (ur->ucr_data == NULL) { 913 return (EFAULT); 914 } 915 } 916 /* do the USB request */ 917 error = usb2_do_request_flags 918 (f->udev, NULL, &ur->ucr_request, ur->ucr_data, 919 (ur->ucr_flags & USB_SHORT_XFER_OK) | 920 USB_USER_DATA_PTR, &actlen, 921 USB_DEFAULT_TIMEOUT); 922 923 ur->ucr_actlen = actlen; 924 925 if (error) { 926 error = EIO; 927 } 928 return (error); 929} 930 931/*------------------------------------------------------------------------ 932 * ugen_re_enumerate 933 *------------------------------------------------------------------------*/ 934static int 935ugen_re_enumerate(struct usb2_fifo *f) 936{ 937 struct usb2_device *udev = f->udev; 938 int error; 939 940 /* 941 * This request can be useful for testing USB drivers: 942 */ 943 error = priv_check(curthread, PRIV_DRIVER); 944 if (error) { 945 return (error); 946 } 947 /* get the device unconfigured */ 948 error = ugen_set_config(f, USB_UNCONFIG_INDEX); 949 if (error) { 950 return (error); 951 } 952 /* do a bus-reset */ 953 mtx_lock(f->priv_mtx); 954 error = usb2_req_re_enumerate(udev, f->priv_mtx); 955 mtx_unlock(f->priv_mtx); 956 957 if (error) { 958 return (ENXIO); 959 } 960 /* restore configuration to index 0 */ 961 error = ugen_set_config(f, 0); 962 if (error) { 963 return (error); 964 } 965 return (0); 966} 967 968int 969ugen_fs_uninit(struct usb2_fifo *f) 970{ 971 if (f->fs_xfer == NULL) { 972 return (EINVAL); 973 } 974 usb2_transfer_unsetup(f->fs_xfer, f->fs_ep_max); 975 free(f->fs_xfer, M_USB); 976 f->fs_xfer = NULL; 977 f->fs_ep_max = 0; 978 f->fs_ep_ptr = NULL; 979 f->flag_iscomplete = 0; 980 usb2_fifo_free_buffer(f); 981 return (0); 982} 983 984static uint8_t 985ugen_fs_get_complete(struct usb2_fifo *f, uint8_t *pindex) 986{ 987 struct usb2_mbuf *m; 988 989 USB_IF_DEQUEUE(&f->used_q, m); 990 991 if (m) { 992 *pindex = *((uint8_t *)(m->cur_data_ptr)); 993 994 USB_IF_ENQUEUE(&f->free_q, m); 995 996 return (0); /* success */ 997 } else { 998 999 *pindex = 0; /* fix compiler warning */ 1000 1001 f->flag_iscomplete = 0; 1002 } 1003 return (1); /* failure */ 1004} 1005 1006static void 1007ugen_fs_set_complete(struct usb2_fifo *f, uint8_t index) 1008{ 1009 struct usb2_mbuf *m; 1010 1011 USB_IF_DEQUEUE(&f->free_q, m); 1012 1013 if (m == NULL) { 1014 /* can happen during close */ 1015 DPRINTF("out of buffers\n"); 1016 return; 1017 } 1018 USB_MBUF_RESET(m); 1019 1020 *((uint8_t *)(m->cur_data_ptr)) = index; 1021 1022 USB_IF_ENQUEUE(&f->used_q, m); 1023 1024 f->flag_iscomplete = 1; 1025 1026 usb2_fifo_wakeup(f); 1027 1028 return; 1029} 1030 1031static int 1032ugen_fs_copy_in(struct usb2_fifo *f, uint8_t ep_index) 1033{ 1034 struct usb2_device_request *req; 1035 struct usb2_xfer *xfer; 1036 struct usb2_fs_endpoint fs_ep; 1037 void *uaddr; /* userland pointer */ 1038 void *kaddr; 1039 uint32_t offset; 1040 uint32_t length; 1041 uint32_t n; 1042 uint32_t rem; 1043 int error; 1044 uint8_t isread; 1045 1046 if (ep_index >= f->fs_ep_max) { 1047 return (EINVAL); 1048 } 1049 xfer = f->fs_xfer[ep_index]; 1050 if (xfer == NULL) { 1051 return (EINVAL); 1052 } 1053 mtx_lock(f->priv_mtx); 1054 if (usb2_transfer_pending(xfer)) { 1055 mtx_unlock(f->priv_mtx); 1056 return (EBUSY); /* should not happen */ 1057 } 1058 mtx_unlock(f->priv_mtx); 1059 1060 error = copyin(f->fs_ep_ptr + 1061 ep_index, &fs_ep, sizeof(fs_ep)); 1062 if (error) { 1063 return (error); 1064 } 1065 /* security checks */ 1066 1067 if (fs_ep.nFrames > xfer->max_frame_count) { 1068 xfer->error = USB_ERR_INVAL; 1069 goto complete; 1070 } 1071 if (fs_ep.nFrames == 0) { 1072 xfer->error = USB_ERR_INVAL; 1073 goto complete; 1074 } 1075 error = copyin(fs_ep.ppBuffer, 1076 &uaddr, sizeof(uaddr)); 1077 if (error) { 1078 return (error); 1079 } 1080 /* reset first frame */ 1081 usb2_set_frame_offset(xfer, 0, 0); 1082 1083 if (xfer->flags_int.control_xfr) { 1084 1085 req = xfer->frbuffers[0].buffer; 1086 1087 error = copyin(fs_ep.pLength, 1088 &length, sizeof(length)); 1089 if (error) { 1090 return (error); 1091 } 1092 if (length >= sizeof(*req)) { 1093 xfer->error = USB_ERR_INVAL; 1094 goto complete; 1095 } 1096 if (length != 0) { 1097 error = copyin(uaddr, req, length); 1098 if (error) { 1099 return (error); 1100 } 1101 } 1102 if (ugen_check_request(f->udev, req)) { 1103 xfer->error = USB_ERR_INVAL; 1104 goto complete; 1105 } 1106 xfer->frlengths[0] = length; 1107 1108 /* Host mode only ! */ 1109 if ((req->bmRequestType & 1110 (UT_READ | UT_WRITE)) == UT_READ) { 1111 isread = 1; 1112 } else { 1113 isread = 0; 1114 } 1115 n = 1; 1116 offset = sizeof(*req); 1117 1118 } else { 1119 /* Device and Host mode */ 1120 if (USB_GET_DATA_ISREAD(xfer)) { 1121 isread = 1; 1122 } else { 1123 isread = 0; 1124 } 1125 n = 0; 1126 offset = 0; 1127 } 1128 1129 rem = xfer->max_data_length; 1130 xfer->nframes = fs_ep.nFrames; 1131 xfer->timeout = fs_ep.timeout; 1132 if (xfer->timeout > 65535) { 1133 xfer->timeout = 65535; 1134 } 1135 if (fs_ep.flags & USB_FS_FLAG_SINGLE_SHORT_OK) 1136 xfer->flags.short_xfer_ok = 1; 1137 else 1138 xfer->flags.short_xfer_ok = 0; 1139 1140 if (fs_ep.flags & USB_FS_FLAG_MULTI_SHORT_OK) 1141 xfer->flags.short_frames_ok = 1; 1142 else 1143 xfer->flags.short_frames_ok = 0; 1144 1145 if (fs_ep.flags & USB_FS_FLAG_FORCE_SHORT) 1146 xfer->flags.force_short_xfer = 1; 1147 else 1148 xfer->flags.force_short_xfer = 0; 1149 1150 if (fs_ep.flags & USB_FS_FLAG_CLEAR_STALL) 1151 xfer->flags.stall_pipe = 1; 1152 else 1153 xfer->flags.stall_pipe = 0; 1154 1155 for (; n != xfer->nframes; n++) { 1156 1157 error = copyin(fs_ep.pLength + n, 1158 &length, sizeof(length)); 1159 if (error) { 1160 break; 1161 } 1162 xfer->frlengths[n] = length; 1163 1164 if (length > rem) { 1165 xfer->error = USB_ERR_INVAL; 1166 goto complete; 1167 } 1168 rem -= length; 1169 1170 if (!isread) { 1171 1172 /* we need to know the source buffer */ 1173 error = copyin(fs_ep.ppBuffer + n, 1174 &uaddr, sizeof(uaddr)); 1175 if (error) { 1176 break; 1177 } 1178 if (xfer->flags_int.isochronous_xfr) { 1179 /* get kernel buffer address */ 1180 kaddr = xfer->frbuffers[0].buffer; 1181 kaddr = USB_ADD_BYTES(kaddr, offset); 1182 } else { 1183 /* set current frame offset */ 1184 usb2_set_frame_offset(xfer, offset, n); 1185 1186 /* get kernel buffer address */ 1187 kaddr = xfer->frbuffers[n].buffer; 1188 } 1189 1190 /* move data */ 1191 error = copyin(uaddr, kaddr, length); 1192 if (error) { 1193 break; 1194 } 1195 } 1196 offset += length; 1197 } 1198 return (error); 1199 1200complete: 1201 mtx_lock(f->priv_mtx); 1202 ugen_fs_set_complete(f, ep_index); 1203 mtx_unlock(f->priv_mtx); 1204 return (0); 1205} 1206 1207static int 1208ugen_fs_copy_out(struct usb2_fifo *f, uint8_t ep_index) 1209{ 1210 struct usb2_device_request *req; 1211 struct usb2_xfer *xfer; 1212 struct usb2_fs_endpoint fs_ep; 1213 struct usb2_fs_endpoint *fs_ep_uptr; /* userland ptr */ 1214 void *uaddr; /* userland ptr */ 1215 void *kaddr; 1216 uint32_t offset; 1217 uint32_t length; 1218 uint32_t temp; 1219 uint32_t n; 1220 uint32_t rem; 1221 int error; 1222 uint8_t isread; 1223 1224 if (ep_index >= f->fs_ep_max) { 1225 return (EINVAL); 1226 } 1227 xfer = f->fs_xfer[ep_index]; 1228 if (xfer == NULL) { 1229 return (EINVAL); 1230 } 1231 mtx_lock(f->priv_mtx); 1232 if (usb2_transfer_pending(xfer)) { 1233 mtx_unlock(f->priv_mtx); 1234 return (EBUSY); /* should not happen */ 1235 } 1236 mtx_unlock(f->priv_mtx); 1237 1238 fs_ep_uptr = f->fs_ep_ptr + ep_index; 1239 error = copyin(fs_ep_uptr, &fs_ep, sizeof(fs_ep)); 1240 if (error) { 1241 return (error); 1242 } 1243 fs_ep.status = xfer->error; 1244 fs_ep.aFrames = xfer->aframes; 1245 fs_ep.isoc_time_complete = xfer->isoc_time_complete; 1246 if (xfer->error) { 1247 goto complete; 1248 } 1249 if (xfer->flags_int.control_xfr) { 1250 req = xfer->frbuffers[0].buffer; 1251 1252 /* Host mode only ! */ 1253 if ((req->bmRequestType & (UT_READ | UT_WRITE)) == UT_READ) { 1254 isread = 1; 1255 } else { 1256 isread = 0; 1257 } 1258 if (xfer->nframes == 0) 1259 n = 0; /* should never happen */ 1260 else 1261 n = 1; 1262 } else { 1263 /* Device and Host mode */ 1264 if (USB_GET_DATA_ISREAD(xfer)) { 1265 isread = 1; 1266 } else { 1267 isread = 0; 1268 } 1269 n = 0; 1270 } 1271 1272 /* Update lengths and copy out data */ 1273 1274 rem = xfer->max_data_length; 1275 offset = 0; 1276 1277 for (; n != xfer->nframes; n++) { 1278 1279 /* get initial length into "temp" */ 1280 error = copyin(fs_ep.pLength + n, 1281 &temp, sizeof(temp)); 1282 if (error) { 1283 return (error); 1284 } 1285 if (temp > rem) { 1286 /* the userland length has been corrupted */ 1287 DPRINTF("corrupt userland length " 1288 "%u > %u\n", temp, rem); 1289 fs_ep.status = USB_ERR_INVAL; 1290 goto complete; 1291 } 1292 rem -= temp; 1293 1294 /* get actual transfer length */ 1295 length = xfer->frlengths[n]; 1296 if (length > temp) { 1297 /* data overflow */ 1298 fs_ep.status = USB_ERR_INVAL; 1299 DPRINTF("data overflow %u > %u\n", 1300 length, temp); 1301 goto complete; 1302 } 1303 if (isread) { 1304 1305 /* we need to know the destination buffer */ 1306 error = copyin(fs_ep.ppBuffer + n, 1307 &uaddr, sizeof(uaddr)); 1308 if (error) { 1309 return (error); 1310 } 1311 if (xfer->flags_int.isochronous_xfr) { 1312 /* only one frame buffer */ 1313 kaddr = USB_ADD_BYTES( 1314 xfer->frbuffers[0].buffer, offset); 1315 } else { 1316 /* multiple frame buffers */ 1317 kaddr = xfer->frbuffers[n].buffer; 1318 } 1319 1320 /* move data */ 1321 error = copyout(kaddr, uaddr, length); 1322 if (error) { 1323 return (error); 1324 } 1325 } 1326 /* 1327 * Update offset according to initial length, which is 1328 * needed by isochronous transfers! 1329 */ 1330 offset += temp; 1331 1332 /* update length */ 1333 error = copyout(&length, 1334 fs_ep.pLength + n, sizeof(length)); 1335 if (error) { 1336 return (error); 1337 } 1338 } 1339 1340complete: 1341 /* update "aFrames" */ 1342 error = copyout(&fs_ep.aFrames, &fs_ep_uptr->aFrames, 1343 sizeof(fs_ep.aFrames)); 1344 if (error) 1345 goto done; 1346 1347 /* update "isoc_time_complete" */ 1348 error = copyout(&fs_ep.isoc_time_complete, 1349 &fs_ep_uptr->isoc_time_complete, 1350 sizeof(fs_ep.isoc_time_complete)); 1351 if (error) 1352 goto done; 1353 /* update "status" */ 1354 error = copyout(&fs_ep.status, &fs_ep_uptr->status, 1355 sizeof(fs_ep.status)); 1356done: 1357 return (error); 1358} 1359 1360static uint8_t 1361ugen_fifo_in_use(struct usb2_fifo *f, int fflags) 1362{ 1363 struct usb2_fifo *f_rx; 1364 struct usb2_fifo *f_tx; 1365 1366 f_rx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_RX]; 1367 f_tx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_TX]; 1368 1369 if ((fflags & FREAD) && f_rx && 1370 (f_rx->xfer[0] || f_rx->xfer[1])) { 1371 return (1); /* RX FIFO in use */ 1372 } 1373 if ((fflags & FWRITE) && f_tx && 1374 (f_tx->xfer[0] || f_tx->xfer[1])) { 1375 return (1); /* TX FIFO in use */ 1376 } 1377 return (0); /* not in use */ 1378} 1379 1380static int 1381ugen_ioctl(struct usb2_fifo *f, u_long cmd, void *addr, int fflags, 1382 struct thread *td) 1383{ 1384 struct usb2_config usb2_config[1]; 1385 struct usb2_device_request req; 1386 union { 1387 struct usb2_fs_complete *pcomp; 1388 struct usb2_fs_start *pstart; 1389 struct usb2_fs_stop *pstop; 1390 struct usb2_fs_open *popen; 1391 struct usb2_fs_close *pclose; 1392 struct usb2_fs_clear_stall_sync *pstall; 1393 void *addr; 1394 } u; 1395 struct usb2_pipe *pipe; 1396 struct usb2_endpoint_descriptor *ed; 1397 int error = 0; 1398 uint8_t iface_index; 1399 uint8_t isread; 1400 uint8_t ep_index; 1401 1402 u.addr = addr; 1403 1404 DPRINTFN(6, "cmd=0x%08lx\n", cmd); 1405 1406 switch (cmd) { 1407 case USB_FS_COMPLETE: 1408 mtx_lock(f->priv_mtx); 1409 error = ugen_fs_get_complete(f, &ep_index); 1410 mtx_unlock(f->priv_mtx); 1411 1412 if (error) { 1413 error = EBUSY; 1414 break; 1415 } 1416 u.pcomp->ep_index = ep_index; 1417 error = ugen_fs_copy_out(f, u.pcomp->ep_index); 1418 break; 1419 1420 case USB_FS_START: 1421 error = ugen_fs_copy_in(f, u.pstart->ep_index); 1422 if (error) { 1423 break; 1424 } 1425 mtx_lock(f->priv_mtx); 1426 usb2_transfer_start(f->fs_xfer[u.pstart->ep_index]); 1427 mtx_unlock(f->priv_mtx); 1428 break; 1429 1430 case USB_FS_STOP: 1431 if (u.pstop->ep_index >= f->fs_ep_max) { 1432 error = EINVAL; 1433 break; 1434 } 1435 mtx_lock(f->priv_mtx); 1436 usb2_transfer_stop(f->fs_xfer[u.pstop->ep_index]); 1437 mtx_unlock(f->priv_mtx); 1438 break; 1439 1440 case USB_FS_OPEN: 1441 if (u.popen->ep_index >= f->fs_ep_max) { 1442 error = EINVAL; 1443 break; 1444 } 1445 if (f->fs_xfer[u.popen->ep_index] != NULL) { 1446 error = EBUSY; 1447 break; 1448 } 1449 if (u.popen->max_bufsize > USB_FS_MAX_BUFSIZE) { 1450 u.popen->max_bufsize = USB_FS_MAX_BUFSIZE; 1451 } 1452 if (u.popen->max_frames > USB_FS_MAX_FRAMES) { 1453 u.popen->max_frames = USB_FS_MAX_FRAMES; 1454 break; 1455 } 1456 if (u.popen->max_frames == 0) { 1457 error = EINVAL; 1458 break; 1459 } 1460 pipe = usb2_get_pipe_by_addr(f->udev, u.popen->ep_no); 1461 if (pipe == NULL) { 1462 error = EINVAL; 1463 break; 1464 } 1465 ed = pipe->edesc; 1466 if (ed == NULL) { 1467 error = ENXIO; 1468 break; 1469 } 1470 iface_index = pipe->iface_index; 1471 1472 error = usb2_check_thread_perm(f->udev, curthread, fflags, 1473 iface_index, u.popen->ep_no); 1474 if (error) { 1475 break; 1476 } 1477 bzero(usb2_config, sizeof(usb2_config)); 1478 1479 usb2_config[0].type = ed->bmAttributes & UE_XFERTYPE; 1480 usb2_config[0].endpoint = ed->bEndpointAddress & UE_ADDR; 1481 usb2_config[0].direction = ed->bEndpointAddress & (UE_DIR_OUT | UE_DIR_IN); 1482 usb2_config[0].mh.interval = USB_DEFAULT_INTERVAL; 1483 usb2_config[0].mh.flags.proxy_buffer = 1; 1484 usb2_config[0].mh.callback = &ugen_default_fs_callback; 1485 usb2_config[0].mh.timeout = 0; /* no timeout */ 1486 usb2_config[0].mh.frames = u.popen->max_frames; 1487 usb2_config[0].mh.bufsize = u.popen->max_bufsize; 1488 usb2_config[0].md = usb2_config[0].mh; /* symmetric config */ 1489 1490 if (usb2_config[0].type == UE_CONTROL) { 1491 if (f->udev->flags.usb2_mode != USB_MODE_HOST) { 1492 error = EINVAL; 1493 break; 1494 } 1495 } else { 1496 1497 isread = ((usb2_config[0].endpoint & 1498 (UE_DIR_IN | UE_DIR_OUT)) == UE_DIR_IN); 1499 1500 if (f->udev->flags.usb2_mode != USB_MODE_HOST) { 1501 isread = !isread; 1502 } 1503 /* check permissions */ 1504 if (isread) { 1505 if (!(fflags & FREAD)) { 1506 error = EPERM; 1507 break; 1508 } 1509 } else { 1510 if (!(fflags & FWRITE)) { 1511 error = EPERM; 1512 break; 1513 } 1514 } 1515 } 1516 error = usb2_transfer_setup(f->udev, &iface_index, 1517 f->fs_xfer + u.popen->ep_index, usb2_config, 1, 1518 f, f->priv_mtx); 1519 if (error == 0) { 1520 /* update maximums */ 1521 u.popen->max_packet_length = 1522 f->fs_xfer[u.popen->ep_index]->max_frame_size; 1523 u.popen->max_bufsize = 1524 f->fs_xfer[u.popen->ep_index]->max_data_length; 1525 f->fs_xfer[u.popen->ep_index]->priv_fifo = 1526 ((uint8_t *)0) + u.popen->ep_index; 1527 } else { 1528 error = ENOMEM; 1529 } 1530 break; 1531 1532 case USB_FS_CLOSE: 1533 if (u.pclose->ep_index >= f->fs_ep_max) { 1534 error = EINVAL; 1535 break; 1536 } 1537 if (f->fs_xfer[u.pclose->ep_index] == NULL) { 1538 error = EINVAL; 1539 break; 1540 } 1541 usb2_transfer_unsetup(f->fs_xfer + u.pclose->ep_index, 1); 1542 break; 1543 1544 case USB_FS_CLEAR_STALL_SYNC: 1545 if (u.pstall->ep_index >= f->fs_ep_max) { 1546 error = EINVAL; 1547 break; 1548 } 1549 if (f->fs_xfer[u.pstall->ep_index] == NULL) { 1550 error = EINVAL; 1551 break; 1552 } 1553 if (f->udev->flags.usb2_mode != USB_MODE_HOST) { 1554 error = EINVAL; 1555 break; 1556 } 1557 mtx_lock(f->priv_mtx); 1558 error = usb2_transfer_pending(f->fs_xfer[u.pstall->ep_index]); 1559 mtx_unlock(f->priv_mtx); 1560 1561 if (error) { 1562 return (EBUSY); 1563 } 1564 pipe = f->fs_xfer[u.pstall->ep_index]->pipe; 1565 1566 /* setup a clear-stall packet */ 1567 req.bmRequestType = UT_WRITE_ENDPOINT; 1568 req.bRequest = UR_CLEAR_FEATURE; 1569 USETW(req.wValue, UF_ENDPOINT_HALT); 1570 req.wIndex[0] = pipe->edesc->bEndpointAddress; 1571 req.wIndex[1] = 0; 1572 USETW(req.wLength, 0); 1573 1574 error = usb2_do_request(f->udev, NULL, &req, NULL); 1575 if (error == 0) { 1576 usb2_clear_data_toggle(f->udev, pipe); 1577 } else { 1578 error = ENXIO; 1579 } 1580 break; 1581 1582 default: 1583 error = ENOIOCTL; 1584 break; 1585 } 1586 1587 DPRINTFN(6, "error=%d\n", error); 1588 1589 return (error); 1590} 1591 1592static int 1593ugen_set_short_xfer(struct usb2_fifo *f, void *addr) 1594{ 1595 uint8_t t; 1596 1597 if (*(int *)addr) 1598 t = 1; 1599 else 1600 t = 0; 1601 1602 if (f->flag_short == t) { 1603 /* same value like before - accept */ 1604 return (0); 1605 } 1606 if (f->xfer[0] || f->xfer[1]) { 1607 /* cannot change this during transfer */ 1608 return (EBUSY); 1609 } 1610 f->flag_short = t; 1611 return (0); 1612} 1613 1614static int 1615ugen_set_timeout(struct usb2_fifo *f, void *addr) 1616{ 1617 f->timeout = *(int *)addr; 1618 if (f->timeout > 65535) { 1619 /* limit user input */ 1620 f->timeout = 65535; 1621 } 1622 return (0); 1623} 1624 1625static int 1626ugen_get_frame_size(struct usb2_fifo *f, void *addr) 1627{ 1628 if (f->xfer[0]) { 1629 *(int *)addr = f->xfer[0]->max_frame_size; 1630 } else { 1631 return (EINVAL); 1632 } 1633 return (0); 1634} 1635 1636static int 1637ugen_set_buffer_size(struct usb2_fifo *f, void *addr) 1638{ 1639 uint32_t t; 1640 1641 if (*(int *)addr < 1024) 1642 t = 1024; 1643 else if (*(int *)addr < (256 * 1024)) 1644 t = *(int *)addr; 1645 else 1646 t = 256 * 1024; 1647 1648 if (f->bufsize == t) { 1649 /* same value like before - accept */ 1650 return (0); 1651 } 1652 if (f->xfer[0] || f->xfer[1]) { 1653 /* cannot change this during transfer */ 1654 return (EBUSY); 1655 } 1656 f->bufsize = t; 1657 return (0); 1658} 1659 1660static int 1661ugen_get_buffer_size(struct usb2_fifo *f, void *addr) 1662{ 1663 *(int *)addr = f->bufsize; 1664 return (0); 1665} 1666 1667static int 1668ugen_get_iface_desc(struct usb2_fifo *f, 1669 struct usb2_interface_descriptor *idesc) 1670{ 1671 struct usb2_interface *iface; 1672 1673 iface = usb2_get_iface(f->udev, f->iface_index); 1674 if (iface && iface->idesc) { 1675 *idesc = *(iface->idesc); 1676 } else { 1677 return (EIO); 1678 } 1679 return (0); 1680} 1681 1682static int 1683ugen_get_endpoint_desc(struct usb2_fifo *f, 1684 struct usb2_endpoint_descriptor *ed) 1685{ 1686 struct usb2_pipe *pipe; 1687 1688 pipe = f->priv_sc0; 1689 1690 if (pipe && pipe->edesc) { 1691 *ed = *pipe->edesc; 1692 } else { 1693 return (EINVAL); 1694 } 1695 return (0); 1696} 1697 1698static int 1699ugen_set_power_mode(struct usb2_fifo *f, int mode) 1700{ 1701 struct usb2_device *udev = f->udev; 1702 int err; 1703 1704 if ((udev == NULL) || 1705 (udev->parent_hub == NULL)) { 1706 return (EINVAL); 1707 } 1708 err = priv_check(curthread, PRIV_ROOT); 1709 if (err) { 1710 return (err); 1711 } 1712 switch (mode) { 1713 case USB_POWER_MODE_OFF: 1714 /* clear suspend */ 1715 err = usb2_req_clear_port_feature(udev->parent_hub, 1716 NULL, udev->port_no, UHF_PORT_SUSPEND); 1717 if (err) 1718 break; 1719 1720 /* clear port enable */ 1721 err = usb2_req_clear_port_feature(udev->parent_hub, 1722 NULL, udev->port_no, UHF_PORT_ENABLE); 1723 break; 1724 1725 case USB_POWER_MODE_ON: 1726 /* enable port */ 1727 err = usb2_req_set_port_feature(udev->parent_hub, 1728 NULL, udev->port_no, UHF_PORT_ENABLE); 1729 1730 /* FALLTHROUGH */ 1731 1732 case USB_POWER_MODE_SAVE: 1733 case USB_POWER_MODE_RESUME: 1734 /* TODO: implement USB power save */ 1735 err = usb2_req_clear_port_feature(udev->parent_hub, 1736 NULL, udev->port_no, UHF_PORT_SUSPEND); 1737 break; 1738 1739 case USB_POWER_MODE_SUSPEND: 1740 /* TODO: implement USB power save */ 1741 err = usb2_req_set_port_feature(udev->parent_hub, 1742 NULL, udev->port_no, UHF_PORT_SUSPEND); 1743 break; 1744 default: 1745 return (EINVAL); 1746 } 1747 1748 if (err) 1749 return (ENXIO); /* I/O failure */ 1750 1751 udev->power_mode = mode; /* update copy of power mode */ 1752 1753 return (0); /* success */ 1754} 1755 1756static int 1757ugen_get_power_mode(struct usb2_fifo *f) 1758{ 1759 struct usb2_device *udev = f->udev; 1760 1761 if ((udev == NULL) || 1762 (udev->parent_hub == NULL)) { 1763 return (USB_POWER_MODE_ON); 1764 } 1765 return (udev->power_mode); 1766} 1767 1768static int 1769ugen_do_port_feature(struct usb2_fifo *f, uint8_t port_no, 1770 uint8_t set, uint16_t feature) 1771{ 1772 struct usb2_device *udev = f->udev; 1773 struct usb2_hub *hub; 1774 int err; 1775 1776 err = priv_check(curthread, PRIV_ROOT); 1777 if (err) { 1778 return (err); 1779 } 1780 if (port_no == 0) { 1781 return (EINVAL); 1782 } 1783 if ((udev == NULL) || 1784 (udev->hub == NULL)) { 1785 return (EINVAL); 1786 } 1787 hub = udev->hub; 1788 1789 if (port_no > hub->nports) { 1790 return (EINVAL); 1791 } 1792 if (set) 1793 err = usb2_req_set_port_feature(udev, 1794 NULL, port_no, feature); 1795 else 1796 err = usb2_req_clear_port_feature(udev, 1797 NULL, port_no, feature); 1798 1799 if (err) 1800 return (ENXIO); /* failure */ 1801 1802 return (0); /* success */ 1803} 1804 1805static int 1806ugen_iface_ioctl(struct usb2_fifo *f, u_long cmd, void *addr, int fflags) 1807{ 1808 struct usb2_fifo *f_rx; 1809 struct usb2_fifo *f_tx; 1810 int error = 0; 1811 1812 f_rx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_RX]; 1813 f_tx = f->udev->fifo[(f->fifo_index & ~1) + USB_FIFO_TX]; 1814 1815 switch (cmd) { 1816 case USB_SET_RX_SHORT_XFER: 1817 if (fflags & FREAD) { 1818 error = ugen_set_short_xfer(f_rx, addr); 1819 } else { 1820 error = EINVAL; 1821 } 1822 break; 1823 1824 case USB_SET_TX_FORCE_SHORT: 1825 if (fflags & FWRITE) { 1826 error = ugen_set_short_xfer(f_tx, addr); 1827 } else { 1828 error = EINVAL; 1829 } 1830 break; 1831 1832 case USB_SET_RX_TIMEOUT: 1833 if (fflags & FREAD) { 1834 error = ugen_set_timeout(f_rx, addr); 1835 } else { 1836 error = EINVAL; 1837 } 1838 break; 1839 1840 case USB_SET_TX_TIMEOUT: 1841 if (fflags & FWRITE) { 1842 error = ugen_set_timeout(f_tx, addr); 1843 } else { 1844 error = EINVAL; 1845 } 1846 break; 1847 1848 case USB_GET_RX_FRAME_SIZE: 1849 if (fflags & FREAD) { 1850 error = ugen_get_frame_size(f_rx, addr); 1851 } else { 1852 error = EINVAL; 1853 } 1854 break; 1855 1856 case USB_GET_TX_FRAME_SIZE: 1857 if (fflags & FWRITE) { 1858 error = ugen_get_frame_size(f_tx, addr); 1859 } else { 1860 error = EINVAL; 1861 } 1862 break; 1863 1864 case USB_SET_RX_BUFFER_SIZE: 1865 if (fflags & FREAD) { 1866 error = ugen_set_buffer_size(f_rx, addr); 1867 } else { 1868 error = EINVAL; 1869 } 1870 break; 1871 1872 case USB_SET_TX_BUFFER_SIZE: 1873 if (fflags & FWRITE) { 1874 error = ugen_set_buffer_size(f_tx, addr); 1875 } else { 1876 error = EINVAL; 1877 } 1878 break; 1879 1880 case USB_GET_RX_BUFFER_SIZE: 1881 if (fflags & FREAD) { 1882 error = ugen_get_buffer_size(f_rx, addr); 1883 } else { 1884 error = EINVAL; 1885 } 1886 break; 1887 1888 case USB_GET_TX_BUFFER_SIZE: 1889 if (fflags & FWRITE) { 1890 error = ugen_get_buffer_size(f_tx, addr); 1891 } else { 1892 error = EINVAL; 1893 } 1894 break; 1895 1896 case USB_GET_RX_INTERFACE_DESC: 1897 if (fflags & FREAD) { 1898 error = ugen_get_iface_desc(f_rx, addr); 1899 } else { 1900 error = EINVAL; 1901 } 1902 break; 1903 1904 case USB_GET_TX_INTERFACE_DESC: 1905 if (fflags & FWRITE) { 1906 error = ugen_get_iface_desc(f_tx, addr); 1907 } else { 1908 error = EINVAL; 1909 } 1910 break; 1911 1912 case USB_GET_RX_ENDPOINT_DESC: 1913 if (fflags & FREAD) { 1914 error = ugen_get_endpoint_desc(f_rx, addr); 1915 } else { 1916 error = EINVAL; 1917 } 1918 break; 1919 1920 case USB_GET_TX_ENDPOINT_DESC: 1921 if (fflags & FWRITE) { 1922 error = ugen_get_endpoint_desc(f_tx, addr); 1923 } else { 1924 error = EINVAL; 1925 } 1926 break; 1927 1928 case USB_SET_RX_STALL_FLAG: 1929 if ((fflags & FREAD) && (*(int *)addr)) { 1930 f_rx->flag_stall = 1; 1931 } 1932 break; 1933 1934 case USB_SET_TX_STALL_FLAG: 1935 if ((fflags & FWRITE) && (*(int *)addr)) { 1936 f_tx->flag_stall = 1; 1937 } 1938 break; 1939 1940 default: 1941 error = ENOIOCTL; 1942 break; 1943 } 1944 return (error); 1945} 1946 1947static int 1948ugen_ioctl_post(struct usb2_fifo *f, u_long cmd, void *addr, int fflags, 1949 struct thread *td) 1950{ 1951 union { 1952 struct usb2_interface_descriptor *idesc; 1953 struct usb2_alt_interface *ai; 1954 struct usb2_device_descriptor *ddesc; 1955 struct usb2_config_descriptor *cdesc; 1956 struct usb2_device_stats *stat; 1957 struct usb2_fs_init *pinit; 1958 struct usb2_fs_uninit *puninit; 1959 uint32_t *ptime; 1960 void *addr; 1961 int *pint; 1962 } u; 1963 struct usb2_device_descriptor *dtemp; 1964 struct usb2_config_descriptor *ctemp; 1965 struct usb2_interface *iface; 1966 int error = 0; 1967 uint8_t n; 1968 1969 u.addr = addr; 1970 1971 DPRINTFN(6, "cmd=0x%08lx\n", cmd); 1972 1973 switch (cmd) { 1974 case USB_DISCOVER: 1975 usb2_needs_explore_all(); 1976 break; 1977 1978 case USB_SETDEBUG: 1979 if (!(fflags & FWRITE)) { 1980 error = EPERM; 1981 break; 1982 } 1983 usb2_debug = *(int *)addr; 1984 break; 1985 1986 case USB_GET_CONFIG: 1987 *(int *)addr = f->udev->curr_config_index; 1988 break; 1989 1990 case USB_SET_CONFIG: 1991 if (!(fflags & FWRITE)) { 1992 error = EPERM; 1993 break; 1994 } 1995 error = ugen_set_config(f, *(int *)addr); 1996 break; 1997 1998 case USB_GET_ALTINTERFACE: 1999 iface = usb2_get_iface(f->udev, 2000 u.ai->uai_interface_index); 2001 if (iface && iface->idesc) { 2002 u.ai->uai_alt_index = iface->alt_index; 2003 } else { 2004 error = EINVAL; 2005 } 2006 break; 2007 2008 case USB_SET_ALTINTERFACE: 2009 if (!(fflags & FWRITE)) { 2010 error = EPERM; 2011 break; 2012 } 2013 error = ugen_set_interface(f, 2014 u.ai->uai_interface_index, u.ai->uai_alt_index); 2015 break; 2016 2017 case USB_GET_DEVICE_DESC: 2018 dtemp = usb2_get_device_descriptor(f->udev); 2019 if (!dtemp) { 2020 error = EIO; 2021 break; 2022 } 2023 *u.ddesc = *dtemp; 2024 break; 2025 2026 case USB_GET_CONFIG_DESC: 2027 ctemp = usb2_get_config_descriptor(f->udev); 2028 if (!ctemp) { 2029 error = EIO; 2030 break; 2031 } 2032 *u.cdesc = *ctemp; 2033 break; 2034 2035 case USB_GET_FULL_DESC: 2036 error = ugen_get_cdesc(f, addr); 2037 break; 2038 2039 case USB_GET_STRING_DESC: 2040 error = ugen_get_sdesc(f, addr); 2041 break; 2042 2043 case USB_REQUEST: 2044 case USB_DO_REQUEST: 2045 if (!(fflags & FWRITE)) { 2046 error = EPERM; 2047 break; 2048 } 2049 error = ugen_do_request(f, addr); 2050 break; 2051 2052 case USB_DEVICEINFO: 2053 case USB_GET_DEVICEINFO: 2054 error = usb2_gen_fill_deviceinfo(f, addr); 2055 break; 2056 2057 case USB_GET_DEVICENAMES: 2058 error = usb2_gen_fill_devicenames(f, addr); 2059 break; 2060 2061 case USB_DEVICESTATS: 2062 for (n = 0; n != 4; n++) { 2063 2064 u.stat->uds_requests_fail[n] = 2065 f->udev->bus->stats_err.uds_requests[n]; 2066 2067 u.stat->uds_requests_ok[n] = 2068 f->udev->bus->stats_ok.uds_requests[n]; 2069 } 2070 break; 2071 2072 case USB_DEVICEENUMERATE: 2073 error = ugen_re_enumerate(f); 2074 break; 2075 2076 case USB_GET_PLUGTIME: 2077 *u.ptime = f->udev->plugtime; 2078 break; 2079 2080 case USB_CLAIM_INTERFACE: 2081 case USB_RELEASE_INTERFACE: 2082 /* TODO */ 2083 break; 2084 2085 case USB_IFACE_DRIVER_ACTIVE: 2086 /* TODO */ 2087 *u.pint = 0; 2088 break; 2089 2090 case USB_IFACE_DRIVER_DETACH: 2091 /* TODO */ 2092 error = priv_check(curthread, PRIV_DRIVER); 2093 if (error) { 2094 break; 2095 } 2096 error = EINVAL; 2097 break; 2098 2099 case USB_SET_POWER_MODE: 2100 error = ugen_set_power_mode(f, *u.pint); 2101 break; 2102 2103 case USB_GET_POWER_MODE: 2104 *u.pint = ugen_get_power_mode(f); 2105 break; 2106 2107 case USB_SET_PORT_ENABLE: 2108 error = ugen_do_port_feature(f, 2109 *u.pint, 1, UHF_PORT_ENABLE); 2110 break; 2111 2112 case USB_SET_PORT_DISABLE: 2113 error = ugen_do_port_feature(f, 2114 *u.pint, 0, UHF_PORT_ENABLE); 2115 break; 2116 2117 case USB_FS_INIT: 2118 /* verify input parameters */ 2119 if (u.pinit->pEndpoints == NULL) { 2120 error = EINVAL; 2121 break; 2122 } 2123 if (u.pinit->ep_index_max > 127) { 2124 error = EINVAL; 2125 break; 2126 } 2127 if (u.pinit->ep_index_max == 0) { 2128 error = EINVAL; 2129 break; 2130 } 2131 if (f->fs_xfer != NULL) { 2132 error = EBUSY; 2133 break; 2134 } 2135 if (f->dev_ep_index != 0) { 2136 error = EINVAL; 2137 break; 2138 } 2139 if (ugen_fifo_in_use(f, fflags)) { 2140 error = EBUSY; 2141 break; 2142 } 2143 error = usb2_fifo_alloc_buffer(f, 1, u.pinit->ep_index_max); 2144 if (error) { 2145 break; 2146 } 2147 f->fs_xfer = malloc(sizeof(f->fs_xfer[0]) * 2148 u.pinit->ep_index_max, M_USB, M_WAITOK | M_ZERO); 2149 if (f->fs_xfer == NULL) { 2150 usb2_fifo_free_buffer(f); 2151 error = ENOMEM; 2152 break; 2153 } 2154 f->fs_ep_max = u.pinit->ep_index_max; 2155 f->fs_ep_ptr = u.pinit->pEndpoints; 2156 break; 2157 2158 case USB_FS_UNINIT: 2159 if (u.puninit->dummy != 0) { 2160 error = EINVAL; 2161 break; 2162 } 2163 error = ugen_fs_uninit(f); 2164 break; 2165 2166 default: 2167 mtx_lock(f->priv_mtx); 2168 error = ugen_iface_ioctl(f, cmd, addr, fflags); 2169 mtx_unlock(f->priv_mtx); 2170 break; 2171 } 2172 DPRINTFN(6, "error=%d\n", error); 2173 return (error); 2174} 2175 2176static void 2177ugen_default_fs_callback(struct usb2_xfer *xfer) 2178{ 2179 ; /* workaround for a bug in "indent" */ 2180 2181 DPRINTF("st=%u alen=%u aframes=%u\n", 2182 USB_GET_STATE(xfer), xfer->actlen, xfer->aframes); 2183 2184 switch (USB_GET_STATE(xfer)) { 2185 case USB_ST_SETUP: 2186 usb2_start_hardware(xfer); 2187 break; 2188 default: 2189 ugen_fs_set_complete(xfer->priv_sc, USB_P2U(xfer->priv_fifo)); 2190 break; 2191 } 2192 return; 2193} 2194