1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * Copyright 2013 Hans Rosenfeld <rosenfeld@grumpf.hope-2000.org> 29 */ 30 31 /* 32 * FTDI FT232R USB UART device-specific driver 33 * 34 * May work on the (many) devices based on earlier versions of the chip. 35 */ 36 37 #include <sys/types.h> 38 #include <sys/param.h> 39 #include <sys/conf.h> 40 #include <sys/stream.h> 41 #include <sys/strsun.h> 42 #include <sys/termio.h> 43 #include <sys/termiox.h> 44 #include <sys/ddi.h> 45 #include <sys/sunddi.h> 46 47 #define USBDRV_MAJOR_VER 2 48 #define USBDRV_MINOR_VER 0 49 50 #include <sys/usb/usba.h> 51 #include <sys/usb/usba/usba_types.h> 52 #include <sys/usb/usba/usba_impl.h> 53 54 #include <sys/usb/clients/usbser/usbser_dsdi.h> 55 #include <sys/usb/clients/usbser/usbftdi/uftdi_var.h> 56 #include <sys/usb/clients/usbser/usbftdi/uftdi_reg.h> 57 58 #include <sys/usb/usbdevs.h> 59 60 /* 61 * DSD operations 62 */ 63 static int uftdi_attach(ds_attach_info_t *); 64 static void uftdi_detach(ds_hdl_t); 65 static int uftdi_register_cb(ds_hdl_t, uint_t, ds_cb_t *); 66 static void uftdi_unregister_cb(ds_hdl_t, uint_t); 67 static int uftdi_open_port(ds_hdl_t, uint_t); 68 static int uftdi_close_port(ds_hdl_t, uint_t); 69 70 /* power management */ 71 static int uftdi_usb_power(ds_hdl_t, int, int, int *); 72 static int uftdi_suspend(ds_hdl_t); 73 static int uftdi_resume(ds_hdl_t); 74 static int uftdi_disconnect(ds_hdl_t); 75 static int uftdi_reconnect(ds_hdl_t); 76 77 /* standard UART operations */ 78 static int uftdi_set_port_params(ds_hdl_t, uint_t, ds_port_params_t *); 79 static int uftdi_set_modem_ctl(ds_hdl_t, uint_t, int, int); 80 static int uftdi_get_modem_ctl(ds_hdl_t, uint_t, int, int *); 81 static int uftdi_break_ctl(ds_hdl_t, uint_t, int); 82 83 /* data xfer */ 84 static int uftdi_tx(ds_hdl_t, uint_t, mblk_t *); 85 static mblk_t *uftdi_rx(ds_hdl_t, uint_t); 86 static void uftdi_stop(ds_hdl_t, uint_t, int); 87 static void uftdi_start(ds_hdl_t, uint_t, int); 88 static int uftdi_fifo_flush(ds_hdl_t, uint_t, int); 89 static int uftdi_fifo_drain(ds_hdl_t, uint_t, int); 90 91 /* polled I/O support */ 92 static usb_pipe_handle_t uftdi_out_pipe(ds_hdl_t, uint_t); 93 static usb_pipe_handle_t uftdi_in_pipe(ds_hdl_t, uint_t); 94 95 /* 96 * Sub-routines 97 */ 98 99 /* configuration routines */ 100 static void uftdi_cleanup(uftdi_state_t *, int); 101 static int uftdi_dev_attach(uftdi_state_t *); 102 static int uftdi_open_hw_port(uftdi_state_t *, int); 103 104 /* hotplug */ 105 static int uftdi_restore_device_state(uftdi_state_t *); 106 static int uftdi_restore_port_state(uftdi_state_t *); 107 108 /* power management */ 109 static int uftdi_create_pm_components(uftdi_state_t *); 110 static void uftdi_destroy_pm_components(uftdi_state_t *); 111 static int uftdi_pm_set_busy(uftdi_state_t *); 112 static void uftdi_pm_set_idle(uftdi_state_t *); 113 static int uftdi_pwrlvl0(uftdi_state_t *); 114 static int uftdi_pwrlvl1(uftdi_state_t *); 115 static int uftdi_pwrlvl2(uftdi_state_t *); 116 static int uftdi_pwrlvl3(uftdi_state_t *); 117 118 /* pipe operations */ 119 static int uftdi_open_pipes(uftdi_state_t *); 120 static void uftdi_close_pipes(uftdi_state_t *); 121 static void uftdi_disconnect_pipes(uftdi_state_t *); 122 static int uftdi_reconnect_pipes(uftdi_state_t *); 123 124 /* pipe callbacks */ 125 static void uftdi_bulkin_cb(usb_pipe_handle_t, usb_bulk_req_t *); 126 static void uftdi_bulkout_cb(usb_pipe_handle_t, usb_bulk_req_t *); 127 128 /* data transfer routines */ 129 static int uftdi_rx_start(uftdi_state_t *); 130 static void uftdi_tx_start(uftdi_state_t *, int *); 131 static int uftdi_send_data(uftdi_state_t *, mblk_t *); 132 static int uftdi_wait_tx_drain(uftdi_state_t *, int); 133 134 /* vendor-specific commands */ 135 static int uftdi_cmd_vendor_write0(uftdi_state_t *, 136 uint16_t, uint16_t, uint16_t); 137 138 /* misc */ 139 static void uftdi_put_tail(mblk_t **, mblk_t *); 140 static void uftdi_put_head(mblk_t **, mblk_t *); 141 142 143 /* 144 * DSD ops structure 145 */ 146 ds_ops_t uftdi_ds_ops = { 147 DS_OPS_VERSION, 148 uftdi_attach, 149 uftdi_detach, 150 uftdi_register_cb, 151 uftdi_unregister_cb, 152 uftdi_open_port, 153 uftdi_close_port, 154 uftdi_usb_power, 155 uftdi_suspend, 156 uftdi_resume, 157 uftdi_disconnect, 158 uftdi_reconnect, 159 uftdi_set_port_params, 160 uftdi_set_modem_ctl, 161 uftdi_get_modem_ctl, 162 uftdi_break_ctl, 163 NULL, /* no loopback support */ 164 uftdi_tx, 165 uftdi_rx, 166 uftdi_stop, 167 uftdi_start, 168 uftdi_fifo_flush, 169 uftdi_fifo_drain, 170 uftdi_out_pipe, 171 uftdi_in_pipe 172 }; 173 174 /* debug support */ 175 static uint_t uftdi_errlevel = USB_LOG_L4; 176 static uint_t uftdi_errmask = DPRINT_MASK_ALL; 177 static uint_t uftdi_instance_debug = (uint_t)-1; 178 static uint_t uftdi_attach_unrecognized = B_FALSE; 179 180 /* 181 * ds_attach 182 */ 183 static int 184 uftdi_attach(ds_attach_info_t *aip) 185 { 186 uftdi_state_t *uf; 187 usb_dev_descr_t *dd; 188 int recognized; 189 190 uf = kmem_zalloc(sizeof (*uf), KM_SLEEP); 191 uf->uf_dip = aip->ai_dip; 192 uf->uf_usb_events = aip->ai_usb_events; 193 *aip->ai_hdl = (ds_hdl_t)uf; 194 195 /* only one port */ 196 *aip->ai_port_cnt = 1; 197 198 if (usb_client_attach(uf->uf_dip, USBDRV_VERSION, 0) != USB_SUCCESS) { 199 uftdi_cleanup(uf, 1); 200 return (USB_FAILURE); 201 } 202 203 if (usb_get_dev_data(uf->uf_dip, 204 &uf->uf_dev_data, USB_PARSE_LVL_IF, 0) != USB_SUCCESS) { 205 uftdi_cleanup(uf, 2); 206 return (USB_FAILURE); 207 } 208 209 uf->uf_hwport = FTDI_PIT_SIOA + uf->uf_dev_data->dev_curr_if; 210 211 mutex_init(&uf->uf_lock, NULL, MUTEX_DRIVER, 212 uf->uf_dev_data->dev_iblock_cookie); 213 214 cv_init(&uf->uf_tx_cv, NULL, CV_DRIVER, NULL); 215 216 uf->uf_lh = usb_alloc_log_hdl(uf->uf_dip, "uftdi", 217 &uftdi_errlevel, &uftdi_errmask, &uftdi_instance_debug, 0); 218 219 /* 220 * This device and its clones has numerous physical instantiations. 221 */ 222 recognized = B_TRUE; 223 dd = uf->uf_dev_data->dev_descr; 224 switch (dd->idVendor) { 225 case USB_VENDOR_FTDI: 226 switch (dd->idProduct) { 227 case USB_PRODUCT_FTDI_SERIAL_2232C: 228 case USB_PRODUCT_FTDI_SERIAL_8U232AM: 229 case USB_PRODUCT_FTDI_SEMC_DSS20: 230 case USB_PRODUCT_FTDI_CFA_631: 231 case USB_PRODUCT_FTDI_CFA_632: 232 case USB_PRODUCT_FTDI_CFA_633: 233 case USB_PRODUCT_FTDI_CFA_634: 234 case USB_PRODUCT_FTDI_CFA_635: 235 case USB_PRODUCT_FTDI_USBSERIAL: 236 case USB_PRODUCT_FTDI_MX2_3: 237 case USB_PRODUCT_FTDI_MX4_5: 238 case USB_PRODUCT_FTDI_LK202: 239 case USB_PRODUCT_FTDI_LK204: 240 case USB_PRODUCT_FTDI_TACTRIX_OPENPORT_13M: 241 case USB_PRODUCT_FTDI_TACTRIX_OPENPORT_13S: 242 case USB_PRODUCT_FTDI_TACTRIX_OPENPORT_13U: 243 case USB_PRODUCT_FTDI_EISCOU: 244 case USB_PRODUCT_FTDI_UOPTBR: 245 case USB_PRODUCT_FTDI_EMCU2D: 246 case USB_PRODUCT_FTDI_PCMSFU: 247 case USB_PRODUCT_FTDI_EMCU2H: 248 break; 249 default: 250 recognized = B_FALSE; 251 break; 252 } 253 break; 254 case USB_VENDOR_SIIG2: 255 switch (dd->idProduct) { 256 case USB_PRODUCT_SIIG2_US2308: 257 break; 258 default: 259 recognized = B_FALSE; 260 break; 261 } 262 break; 263 case USB_VENDOR_INTREPIDCS: 264 switch (dd->idProduct) { 265 case USB_PRODUCT_INTREPIDCS_VALUECAN: 266 case USB_PRODUCT_INTREPIDCS_NEOVI: 267 break; 268 default: 269 recognized = B_FALSE; 270 break; 271 } 272 break; 273 case USB_VENDOR_BBELECTRONICS: 274 switch (dd->idProduct) { 275 case USB_PRODUCT_BBELECTRONICS_USOTL4: 276 break; 277 default: 278 recognized = B_FALSE; 279 break; 280 } 281 break; 282 case USB_VENDOR_MELCO: 283 switch (dd->idProduct) { 284 case USB_PRODUCT_MELCO_PCOPRS1: 285 break; 286 default: 287 recognized = B_FALSE; 288 break; 289 } 290 break; 291 case USB_VENDOR_MARVELL: 292 switch (dd->idProduct) { 293 case USB_PRODUCT_MARVELL_SHEEVAPLUG_JTAG: 294 break; 295 default: 296 recognized = B_FALSE; 297 break; 298 } 299 break; 300 default: 301 recognized = B_FALSE; 302 break; 303 } 304 305 /* 306 * Set 'uftdi_attach_unrecognized' to non-zero to 307 * experiment with newer devices .. 308 */ 309 if (!recognized && !uftdi_attach_unrecognized) { 310 uftdi_cleanup(uf, 3); 311 return (USB_FAILURE); 312 } 313 314 USB_DPRINTF_L3(DPRINT_ATTACH, uf->uf_lh, 315 "uftdi: matched vendor 0x%x product 0x%x port %d", 316 dd->idVendor, dd->idProduct, uf->uf_hwport); 317 318 uf->uf_def_ph = uf->uf_dev_data->dev_default_ph; 319 320 mutex_enter(&uf->uf_lock); 321 uf->uf_dev_state = USB_DEV_ONLINE; 322 uf->uf_port_state = UFTDI_PORT_CLOSED; 323 mutex_exit(&uf->uf_lock); 324 325 if (uftdi_create_pm_components(uf) != USB_SUCCESS) { 326 uftdi_cleanup(uf, 3); 327 return (USB_FAILURE); 328 } 329 330 if (usb_register_event_cbs(uf->uf_dip, 331 uf->uf_usb_events, 0) != USB_SUCCESS) { 332 uftdi_cleanup(uf, 4); 333 return (USB_FAILURE); 334 } 335 336 if (uftdi_dev_attach(uf) != USB_SUCCESS) { 337 uftdi_cleanup(uf, 5); 338 return (USB_FAILURE); 339 } 340 341 return (USB_SUCCESS); 342 } 343 344 #define FTDI_CLEANUP_LEVEL_MAX 6 345 346 /* 347 * ds_detach 348 */ 349 static void 350 uftdi_detach(ds_hdl_t hdl) 351 { 352 uftdi_cleanup((uftdi_state_t *)hdl, FTDI_CLEANUP_LEVEL_MAX); 353 } 354 355 356 /* 357 * ds_register_cb 358 */ 359 /*ARGSUSED*/ 360 static int 361 uftdi_register_cb(ds_hdl_t hdl, uint_t portno, ds_cb_t *cb) 362 { 363 uftdi_state_t *uf = (uftdi_state_t *)hdl; 364 365 ASSERT(portno == 0); 366 367 uf->uf_cb = *cb; 368 return (USB_SUCCESS); 369 } 370 371 372 /* 373 * ds_unregister_cb 374 */ 375 /*ARGSUSED*/ 376 static void 377 uftdi_unregister_cb(ds_hdl_t hdl, uint_t portno) 378 { 379 uftdi_state_t *uf = (uftdi_state_t *)hdl; 380 381 ASSERT(portno == 0); 382 383 bzero(&uf->uf_cb, sizeof (uf->uf_cb)); 384 } 385 386 387 /* 388 * ds_open_port 389 */ 390 /*ARGSUSED*/ 391 static int 392 uftdi_open_port(ds_hdl_t hdl, uint_t portno) 393 { 394 uftdi_state_t *uf = (uftdi_state_t *)hdl; 395 int rval; 396 397 USB_DPRINTF_L4(DPRINT_OPEN, uf->uf_lh, "uftdi_open_port %d", portno); 398 399 ASSERT(portno == 0); 400 401 mutex_enter(&uf->uf_lock); 402 if (uf->uf_dev_state == USB_DEV_DISCONNECTED || 403 uf->uf_port_state != UFTDI_PORT_CLOSED) { 404 mutex_exit(&uf->uf_lock); 405 return (USB_FAILURE); 406 } 407 mutex_exit(&uf->uf_lock); 408 409 if ((rval = uftdi_pm_set_busy(uf)) != USB_SUCCESS) 410 return (rval); 411 412 /* initialize hardware serial port */ 413 rval = uftdi_open_hw_port(uf, 0); 414 415 if (rval == USB_SUCCESS) { 416 mutex_enter(&uf->uf_lock); 417 418 /* start to receive data */ 419 if (uftdi_rx_start(uf) != USB_SUCCESS) { 420 mutex_exit(&uf->uf_lock); 421 return (USB_FAILURE); 422 } 423 uf->uf_port_state = UFTDI_PORT_OPEN; 424 mutex_exit(&uf->uf_lock); 425 } else 426 uftdi_pm_set_idle(uf); 427 428 return (rval); 429 } 430 431 432 /* 433 * ds_close_port 434 */ 435 /*ARGSUSED*/ 436 static int 437 uftdi_close_port(ds_hdl_t hdl, uint_t portno) 438 { 439 uftdi_state_t *uf = (uftdi_state_t *)hdl; 440 441 USB_DPRINTF_L4(DPRINT_CLOSE, uf->uf_lh, "uftdi_close_port %d", portno); 442 443 ASSERT(portno == 0); 444 445 mutex_enter(&uf->uf_lock); 446 447 /* free resources and finalize state */ 448 freemsg(uf->uf_rx_mp); 449 uf->uf_rx_mp = NULL; 450 451 freemsg(uf->uf_tx_mp); 452 uf->uf_tx_mp = NULL; 453 454 uf->uf_port_state = UFTDI_PORT_CLOSED; 455 mutex_exit(&uf->uf_lock); 456 457 uftdi_pm_set_idle(uf); 458 459 return (USB_SUCCESS); 460 } 461 462 463 /* 464 * ds_usb_power 465 */ 466 /*ARGSUSED*/ 467 static int 468 uftdi_usb_power(ds_hdl_t hdl, int comp, int level, int *new_state) 469 { 470 uftdi_state_t *uf = (uftdi_state_t *)hdl; 471 uftdi_pm_t *pm = uf->uf_pm; 472 int rval; 473 474 USB_DPRINTF_L4(DPRINT_PM, uf->uf_lh, "uftdi_usb_power"); 475 476 if (!pm) 477 return (USB_FAILURE); 478 479 mutex_enter(&uf->uf_lock); 480 481 /* 482 * check if we are transitioning to a legal power level 483 */ 484 if (USB_DEV_PWRSTATE_OK(pm->pm_pwr_states, level)) { 485 USB_DPRINTF_L2(DPRINT_PM, uf->uf_lh, "uftdi_usb_power: " 486 "illegal power level %d, pwr_states=0x%x", 487 level, pm->pm_pwr_states); 488 mutex_exit(&uf->uf_lock); 489 return (USB_FAILURE); 490 } 491 492 /* 493 * if we are about to raise power and asked to lower power, fail 494 */ 495 if (pm->pm_raise_power && (level < (int)pm->pm_cur_power)) { 496 mutex_exit(&uf->uf_lock); 497 return (USB_FAILURE); 498 } 499 500 switch (level) { 501 case USB_DEV_OS_PWR_OFF: 502 rval = uftdi_pwrlvl0(uf); 503 break; 504 case USB_DEV_OS_PWR_1: 505 rval = uftdi_pwrlvl1(uf); 506 break; 507 case USB_DEV_OS_PWR_2: 508 rval = uftdi_pwrlvl2(uf); 509 break; 510 case USB_DEV_OS_FULL_PWR: 511 rval = uftdi_pwrlvl3(uf); 512 /* 513 * If usbser dev_state is DISCONNECTED or SUSPENDED, it shows 514 * that the usb serial device is disconnected/suspended while it 515 * is under power down state, now the device is powered up 516 * before it is reconnected/resumed. xxx_pwrlvl3() will set dev 517 * state to ONLINE, we need to set the dev state back to 518 * DISCONNECTED/SUSPENDED. 519 */ 520 if (rval == USB_SUCCESS && 521 (*new_state == USB_DEV_DISCONNECTED || 522 *new_state == USB_DEV_SUSPENDED)) 523 uf->uf_dev_state = *new_state; 524 break; 525 default: 526 ASSERT(0); /* cannot happen */ 527 } 528 529 *new_state = uf->uf_dev_state; 530 mutex_exit(&uf->uf_lock); 531 532 return (rval); 533 } 534 535 536 /* 537 * ds_suspend 538 */ 539 static int 540 uftdi_suspend(ds_hdl_t hdl) 541 { 542 uftdi_state_t *uf = (uftdi_state_t *)hdl; 543 int state = USB_DEV_SUSPENDED; 544 545 USB_DPRINTF_L4(DPRINT_PM, uf->uf_lh, "uftdi_suspend"); 546 547 /* 548 * If the device is suspended while it is under PWRED_DOWN state, we 549 * need to keep the PWRED_DOWN state so that it could be powered up 550 * later. In the mean while, usbser dev state will be changed to 551 * SUSPENDED state. 552 */ 553 mutex_enter(&uf->uf_lock); 554 if (uf->uf_dev_state != USB_DEV_PWRED_DOWN) 555 uf->uf_dev_state = USB_DEV_SUSPENDED; 556 mutex_exit(&uf->uf_lock); 557 558 uftdi_disconnect_pipes(uf); 559 return (state); 560 } 561 562 563 /* 564 * ds_resume 565 */ 566 static int 567 uftdi_resume(ds_hdl_t hdl) 568 { 569 uftdi_state_t *uf = (uftdi_state_t *)hdl; 570 int current_state; 571 int rval; 572 573 USB_DPRINTF_L4(DPRINT_PM, uf->uf_lh, "uftdi_resume"); 574 575 mutex_enter(&uf->uf_lock); 576 current_state = uf->uf_dev_state; 577 mutex_exit(&uf->uf_lock); 578 579 if (current_state == USB_DEV_ONLINE) 580 rval = USB_SUCCESS; 581 else 582 rval = uftdi_restore_device_state(uf); 583 return (rval); 584 } 585 586 587 /* 588 * ds_disconnect 589 */ 590 static int 591 uftdi_disconnect(ds_hdl_t hdl) 592 { 593 uftdi_state_t *uf = (uftdi_state_t *)hdl; 594 int state = USB_DEV_DISCONNECTED; 595 596 USB_DPRINTF_L4(DPRINT_HOTPLUG, uf->uf_lh, "uftdi_disconnect"); 597 598 /* 599 * If the device is disconnected while it is under PWRED_DOWN state, we 600 * need to keep the PWRED_DOWN state so that it could be powered up 601 * later. In the mean while, usbser dev state will be changed to 602 * DISCONNECTED state. 603 */ 604 mutex_enter(&uf->uf_lock); 605 if (uf->uf_dev_state != USB_DEV_PWRED_DOWN) 606 uf->uf_dev_state = USB_DEV_DISCONNECTED; 607 mutex_exit(&uf->uf_lock); 608 609 uftdi_disconnect_pipes(uf); 610 return (state); 611 } 612 613 614 /* 615 * ds_reconnect 616 */ 617 static int 618 uftdi_reconnect(ds_hdl_t hdl) 619 { 620 uftdi_state_t *uf = (uftdi_state_t *)hdl; 621 622 USB_DPRINTF_L4(DPRINT_HOTPLUG, uf->uf_lh, "uftdi_reconnect"); 623 return (uftdi_restore_device_state(uf)); 624 } 625 626 /* translate parameters into device-specific bits */ 627 628 static int 629 uftdi_param2regs(uftdi_state_t *uf, ds_port_params_t *tp, uftdi_regs_t *ur) 630 { 631 ds_port_param_entry_t *pe; 632 int i; 633 634 ur->ur_data = 0; 635 ur->ur_flowval = 0; 636 ur->ur_flowidx = FTDI_SIO_DISABLE_FLOW_CTRL << 8; 637 638 for (i = 0, pe = tp->tp_entries; i < tp->tp_cnt; i++, pe++) { 639 switch (pe->param) { 640 case DS_PARAM_BAUD: 641 switch (pe->val.ui) { 642 case B300: 643 ur->ur_baud = ftdi_8u232am_b300; 644 break; 645 case B600: 646 ur->ur_baud = ftdi_8u232am_b600; 647 break; 648 case B1200: 649 ur->ur_baud = ftdi_8u232am_b1200; 650 break; 651 case B2400: 652 ur->ur_baud = ftdi_8u232am_b2400; 653 break; 654 case B4800: 655 ur->ur_baud = ftdi_8u232am_b4800; 656 break; 657 case B9600: 658 ur->ur_baud = ftdi_8u232am_b9600; 659 break; 660 case B19200: 661 ur->ur_baud = ftdi_8u232am_b19200; 662 break; 663 case B38400: 664 ur->ur_baud = ftdi_8u232am_b38400; 665 break; 666 case B57600: 667 ur->ur_baud = ftdi_8u232am_b57600; 668 break; 669 case B115200: 670 ur->ur_baud = ftdi_8u232am_b115200; 671 break; 672 case B230400: 673 ur->ur_baud = ftdi_8u232am_b230400; 674 break; 675 case B460800: 676 ur->ur_baud = ftdi_8u232am_b460800; 677 break; 678 case B921600: 679 ur->ur_baud = ftdi_8u232am_b921600; 680 break; 681 default: 682 USB_DPRINTF_L3(DPRINT_CTLOP, uf->uf_lh, 683 "uftdi_param2regs: bad baud %d", 684 pe->val.ui); 685 return (USB_FAILURE); 686 } 687 break; 688 689 case DS_PARAM_PARITY: 690 if (pe->val.ui & PARENB) { 691 if (pe->val.ui & PARODD) 692 ur->ur_data |= 693 FTDI_SIO_SET_DATA_PARITY_ODD; 694 else 695 ur->ur_data |= 696 FTDI_SIO_SET_DATA_PARITY_EVEN; 697 } else { 698 /* LINTED [E_EXPR_NULL_EFFECT] */ 699 ur->ur_data |= FTDI_SIO_SET_DATA_PARITY_NONE; 700 } 701 break; 702 703 case DS_PARAM_STOPB: 704 if (pe->val.ui & CSTOPB) 705 ur->ur_data |= FTDI_SIO_SET_DATA_STOP_BITS_2; 706 else { 707 /* LINTED [E_EXPR_NULL_EFFECT] */ 708 ur->ur_data |= FTDI_SIO_SET_DATA_STOP_BITS_1; 709 } 710 break; 711 712 case DS_PARAM_CHARSZ: 713 switch (pe->val.ui) { 714 case CS5: 715 ur->ur_data |= FTDI_SIO_SET_DATA_BITS(5); 716 break; 717 case CS6: 718 ur->ur_data |= FTDI_SIO_SET_DATA_BITS(6); 719 break; 720 case CS7: 721 ur->ur_data |= FTDI_SIO_SET_DATA_BITS(7); 722 break; 723 case CS8: 724 default: 725 ur->ur_data |= FTDI_SIO_SET_DATA_BITS(8); 726 break; 727 } 728 break; 729 730 case DS_PARAM_XON_XOFF: /* Software flow control */ 731 if ((pe->val.ui & IXON) || (pe->val.ui & IXOFF)) { 732 uint8_t xonc = pe->val.uc[0]; 733 uint8_t xoffc = pe->val.uc[1]; 734 735 ur->ur_flowval = (xoffc << 8) | xonc; 736 ur->ur_flowidx = FTDI_SIO_XON_XOFF_HS << 8; 737 } 738 break; 739 740 case DS_PARAM_FLOW_CTL: /* Hardware flow control */ 741 if (pe->val.ui & (RTSXOFF | CTSXON)) { 742 ur->ur_flowval = 0; 743 ur->ur_flowidx = FTDI_SIO_RTS_CTS_HS << 8; 744 } 745 if (pe->val.ui & DTRXOFF) { 746 ur->ur_flowval = 0; 747 ur->ur_flowidx = FTDI_SIO_DTR_DSR_HS << 8; 748 } 749 break; 750 default: 751 USB_DPRINTF_L2(DPRINT_CTLOP, uf->uf_lh, 752 "uftdi_param2regs: bad param %d", pe->param); 753 break; 754 } 755 } 756 return (USB_SUCCESS); 757 } 758 759 /* 760 * Write the register set to the device and update the state structure. 761 * If there are errors, return the device to its previous state. 762 */ 763 static int 764 uftdi_setregs(uftdi_state_t *uf, uftdi_regs_t *ur) 765 { 766 int rval; 767 uftdi_regs_t uold; 768 769 mutex_enter(&uf->uf_lock); 770 uold = uf->uf_softr; 771 mutex_exit(&uf->uf_lock); 772 773 if (ur == NULL) 774 ur = &uold; /* NULL => restore previous values */ 775 776 rval = uftdi_cmd_vendor_write0(uf, FTDI_SIO_SET_BAUD_RATE, 777 ur->ur_baud, uf->uf_hwport); 778 if (rval != USB_SUCCESS) { 779 (void) uftdi_cmd_vendor_write0(uf, FTDI_SIO_SET_BAUD_RATE, 780 uold.ur_baud, uf->uf_hwport); 781 goto out; 782 } else { 783 mutex_enter(&uf->uf_lock); 784 uf->uf_softr.ur_baud = ur->ur_baud; 785 mutex_exit(&uf->uf_lock); 786 } 787 788 rval = uftdi_cmd_vendor_write0(uf, FTDI_SIO_SET_DATA, 789 ur->ur_data, uf->uf_hwport); 790 if (rval != USB_SUCCESS) { 791 (void) uftdi_cmd_vendor_write0(uf, FTDI_SIO_SET_DATA, 792 uold.ur_data, uf->uf_hwport); 793 goto out; 794 } else { 795 mutex_enter(&uf->uf_lock); 796 uf->uf_softr.ur_data = ur->ur_data; 797 mutex_exit(&uf->uf_lock); 798 } 799 800 rval = uftdi_cmd_vendor_write0(uf, FTDI_SIO_SET_FLOW_CTRL, 801 ur->ur_flowval, ur->ur_flowidx | uf->uf_hwport); 802 if (rval != USB_SUCCESS) { 803 (void) uftdi_cmd_vendor_write0(uf, FTDI_SIO_SET_FLOW_CTRL, 804 uold.ur_flowval, uold.ur_flowidx | uf->uf_hwport); 805 goto out; 806 } else { 807 mutex_enter(&uf->uf_lock); 808 uf->uf_softr.ur_flowval = ur->ur_flowval; 809 uf->uf_softr.ur_flowidx = ur->ur_flowidx; 810 mutex_exit(&uf->uf_lock); 811 } 812 out: 813 return (rval); 814 } 815 816 /* 817 * ds_set_port_params 818 */ 819 static int 820 uftdi_set_port_params(ds_hdl_t hdl, uint_t portno, ds_port_params_t *tp) 821 { 822 uftdi_state_t *uf = (uftdi_state_t *)hdl; 823 int rval; 824 uftdi_regs_t uregs; 825 826 ASSERT(portno == 0); 827 828 USB_DPRINTF_L4(DPRINT_CTLOP, uf->uf_lh, "uftdi_set_port_params"); 829 830 rval = uftdi_param2regs(uf, tp, &uregs); 831 if (rval == USB_SUCCESS) 832 rval = uftdi_setregs(uf, &uregs); 833 return (rval); 834 } 835 836 /* 837 * ds_set_modem_ctl 838 */ 839 static int 840 uftdi_set_modem_ctl(ds_hdl_t hdl, uint_t portno, int mask, int val) 841 { 842 uftdi_state_t *uf = (uftdi_state_t *)hdl; 843 int rval; 844 uint16_t mctl; 845 846 ASSERT(portno == 0); 847 848 USB_DPRINTF_L4(DPRINT_CTLOP, uf->uf_lh, "uftdi_set_modem_ctl"); 849 850 /* 851 * Note that we cannot set DTR and RTS simultaneously, so 852 * we do separate operations for each bit. 853 */ 854 855 if (mask & TIOCM_DTR) { 856 mctl = (val & TIOCM_DTR) ? 857 FTDI_SIO_SET_DTR_HIGH : FTDI_SIO_SET_DTR_LOW; 858 859 rval = uftdi_cmd_vendor_write0(uf, 860 FTDI_SIO_MODEM_CTRL, mctl, uf->uf_hwport); 861 862 if (rval == USB_SUCCESS) { 863 mutex_enter(&uf->uf_lock); 864 uf->uf_mctl &= ~FTDI_SIO_SET_DTR_HIGH; 865 uf->uf_mctl |= mctl & FTDI_SIO_SET_DTR_HIGH; 866 mutex_exit(&uf->uf_lock); 867 } else 868 return (rval); 869 } 870 871 if (mask & TIOCM_RTS) { 872 mctl = (val & TIOCM_RTS) ? 873 FTDI_SIO_SET_RTS_HIGH : FTDI_SIO_SET_RTS_LOW; 874 875 rval = uftdi_cmd_vendor_write0(uf, 876 FTDI_SIO_MODEM_CTRL, mctl, uf->uf_hwport); 877 878 if (rval == USB_SUCCESS) { 879 mutex_enter(&uf->uf_lock); 880 uf->uf_mctl &= ~FTDI_SIO_SET_RTS_HIGH; 881 uf->uf_mctl |= mctl & FTDI_SIO_SET_RTS_HIGH; 882 mutex_exit(&uf->uf_lock); 883 } 884 } 885 886 return (rval); 887 } 888 889 /* 890 * ds_get_modem_ctl 891 */ 892 static int 893 uftdi_get_modem_ctl(ds_hdl_t hdl, uint_t portno, int mask, int *valp) 894 { 895 uftdi_state_t *uf = (uftdi_state_t *)hdl; 896 uint_t val = 0; 897 898 ASSERT(portno == 0); 899 900 USB_DPRINTF_L4(DPRINT_CTLOP, uf->uf_lh, "uftdi_get_modem_ctl"); 901 902 mutex_enter(&uf->uf_lock); 903 /* 904 * This status info is delivered to us at least every 40ms 905 * while the receive pipe is active 906 */ 907 if (uf->uf_msr & FTDI_MSR_STATUS_CTS) 908 val |= TIOCM_CTS; 909 if (uf->uf_msr & FTDI_MSR_STATUS_DSR) 910 val |= TIOCM_DSR; 911 if (uf->uf_msr & FTDI_MSR_STATUS_RI) 912 val |= TIOCM_RI; 913 if (uf->uf_msr & FTDI_MSR_STATUS_RLSD) 914 val |= TIOCM_CD; 915 916 /* 917 * Note, this status info is simply a replay of what we 918 * asked it to be in some previous "set" command, and 919 * is *not* directly sensed from the hardware. 920 */ 921 if ((uf->uf_mctl & FTDI_SIO_SET_RTS_HIGH) == FTDI_SIO_SET_RTS_HIGH) 922 val |= TIOCM_RTS; 923 if ((uf->uf_mctl & FTDI_SIO_SET_DTR_HIGH) == FTDI_SIO_SET_DTR_HIGH) 924 val |= TIOCM_DTR; 925 mutex_exit(&uf->uf_lock); 926 927 *valp = val & mask; 928 929 return (USB_SUCCESS); 930 } 931 932 933 /* 934 * ds_break_ctl 935 */ 936 static int 937 uftdi_break_ctl(ds_hdl_t hdl, uint_t portno, int ctl) 938 { 939 uftdi_state_t *uf = (uftdi_state_t *)hdl; 940 uftdi_regs_t *ur = &uf->uf_softr; 941 uint16_t data; 942 943 ASSERT(portno == 0); 944 945 USB_DPRINTF_L4(DPRINT_CTLOP, uf->uf_lh, "uftdi_break_ctl"); 946 947 mutex_enter(&uf->uf_lock); 948 data = ur->ur_data | (ctl == DS_ON) ? FTDI_SIO_SET_BREAK : 0; 949 mutex_exit(&uf->uf_lock); 950 951 return (uftdi_cmd_vendor_write0(uf, FTDI_SIO_SET_DATA, 952 data, uf->uf_hwport)); 953 } 954 955 956 /* 957 * ds_tx 958 */ 959 /*ARGSUSED*/ 960 static int 961 uftdi_tx(ds_hdl_t hdl, uint_t portno, mblk_t *mp) 962 { 963 uftdi_state_t *uf = (uftdi_state_t *)hdl; 964 965 ASSERT(portno == 0); 966 967 USB_DPRINTF_L4(DPRINT_CTLOP, uf->uf_lh, "uftdi_tx"); 968 969 ASSERT(mp != NULL && MBLKL(mp) >= 1); 970 971 mutex_enter(&uf->uf_lock); 972 uftdi_put_tail(&uf->uf_tx_mp, mp); /* add to the chain */ 973 uftdi_tx_start(uf, NULL); 974 mutex_exit(&uf->uf_lock); 975 976 return (USB_SUCCESS); 977 } 978 979 980 /* 981 * ds_rx 982 */ 983 /*ARGSUSED*/ 984 static mblk_t * 985 uftdi_rx(ds_hdl_t hdl, uint_t portno) 986 { 987 uftdi_state_t *uf = (uftdi_state_t *)hdl; 988 mblk_t *mp; 989 990 ASSERT(portno == 0); 991 992 USB_DPRINTF_L4(DPRINT_CTLOP, uf->uf_lh, "uftdi_rx"); 993 994 mutex_enter(&uf->uf_lock); 995 mp = uf->uf_rx_mp; 996 uf->uf_rx_mp = NULL; 997 mutex_exit(&uf->uf_lock); 998 999 return (mp); 1000 } 1001 1002 1003 /* 1004 * ds_stop 1005 */ 1006 /*ARGSUSED*/ 1007 static void 1008 uftdi_stop(ds_hdl_t hdl, uint_t portno, int dir) 1009 { 1010 uftdi_state_t *uf = (uftdi_state_t *)hdl; 1011 1012 ASSERT(portno == 0); 1013 1014 USB_DPRINTF_L4(DPRINT_CTLOP, uf->uf_lh, "uftdi_stop"); 1015 1016 if (dir & DS_TX) { 1017 mutex_enter(&uf->uf_lock); 1018 uf->uf_port_flags |= UFTDI_PORT_TX_STOPPED; 1019 mutex_exit(&uf->uf_lock); 1020 } 1021 } 1022 1023 1024 /* 1025 * ds_start 1026 */ 1027 /*ARGSUSED*/ 1028 static void 1029 uftdi_start(ds_hdl_t hdl, uint_t portno, int dir) 1030 { 1031 uftdi_state_t *uf = (uftdi_state_t *)hdl; 1032 1033 ASSERT(portno == 0); 1034 1035 USB_DPRINTF_L4(DPRINT_CTLOP, uf->uf_lh, "uftdi_start"); 1036 1037 if (dir & DS_TX) { 1038 mutex_enter(&uf->uf_lock); 1039 if (uf->uf_port_flags & UFTDI_PORT_TX_STOPPED) { 1040 uf->uf_port_flags &= ~UFTDI_PORT_TX_STOPPED; 1041 uftdi_tx_start(uf, NULL); 1042 } 1043 mutex_exit(&uf->uf_lock); 1044 } 1045 } 1046 1047 1048 /* 1049 * ds_fifo_flush 1050 */ 1051 /*ARGSUSED*/ 1052 static int 1053 uftdi_fifo_flush(ds_hdl_t hdl, uint_t portno, int dir) 1054 { 1055 uftdi_state_t *uf = (uftdi_state_t *)hdl; 1056 1057 ASSERT(portno == 0); 1058 1059 USB_DPRINTF_L4(DPRINT_CTLOP, uf->uf_lh, 1060 "uftdi_fifo_flush: dir=0x%x", dir); 1061 1062 mutex_enter(&uf->uf_lock); 1063 ASSERT(uf->uf_port_state == UFTDI_PORT_OPEN); 1064 1065 if (dir & DS_TX) { 1066 freemsg(uf->uf_tx_mp); 1067 uf->uf_tx_mp = NULL; 1068 } 1069 1070 if (dir & DS_RX) { 1071 freemsg(uf->uf_rx_mp); 1072 uf->uf_rx_mp = NULL; 1073 } 1074 mutex_exit(&uf->uf_lock); 1075 1076 if (dir & DS_TX) 1077 (void) uftdi_cmd_vendor_write0(uf, 1078 FTDI_SIO_RESET, FTDI_SIO_RESET_PURGE_TX, uf->uf_hwport); 1079 1080 if (dir & DS_RX) 1081 (void) uftdi_cmd_vendor_write0(uf, 1082 FTDI_SIO_RESET, FTDI_SIO_RESET_PURGE_RX, uf->uf_hwport); 1083 1084 return (USB_SUCCESS); 1085 } 1086 1087 1088 /* 1089 * ds_fifo_drain 1090 */ 1091 /*ARGSUSED*/ 1092 static int 1093 uftdi_fifo_drain(ds_hdl_t hdl, uint_t portno, int timeout) 1094 { 1095 uftdi_state_t *uf = (uftdi_state_t *)hdl; 1096 unsigned int count; 1097 const uint_t countmax = 50; /* at least 500ms */ 1098 const uint8_t txempty = 1099 FTDI_LSR_STATUS_TEMT | FTDI_LSR_STATUS_THRE; 1100 1101 ASSERT(portno == 0); 1102 1103 USB_DPRINTF_L4(DPRINT_CTLOP, uf->uf_lh, "uftdi_fifo_drain"); 1104 1105 mutex_enter(&uf->uf_lock); 1106 ASSERT(uf->uf_port_state == UFTDI_PORT_OPEN); 1107 1108 if (uftdi_wait_tx_drain(uf, 0) != USB_SUCCESS) { 1109 mutex_exit(&uf->uf_lock); 1110 return (USB_FAILURE); 1111 } 1112 1113 /* 1114 * Wait for the TX fifo to indicate empty. 1115 * 1116 * At all but the slowest baud rates, this is 1117 * likely to be a one-shot test that instantly 1118 * succeeds, but poll for at least 'countmax' 1119 * tries before giving up. 1120 */ 1121 for (count = 0; count < countmax; count++) { 1122 if ((uf->uf_lsr & txempty) == txempty) 1123 break; 1124 mutex_exit(&uf->uf_lock); 1125 delay(drv_usectohz(10*1000)); /* 10ms */ 1126 mutex_enter(&uf->uf_lock); 1127 } 1128 1129 mutex_exit(&uf->uf_lock); 1130 1131 return (count < countmax ? USB_SUCCESS : USB_FAILURE); 1132 } 1133 1134 1135 /* 1136 * configuration clean up 1137 */ 1138 static void 1139 uftdi_cleanup(uftdi_state_t *uf, int level) 1140 { 1141 ASSERT(level > 0 && level <= UFTDI_CLEANUP_LEVEL_MAX); 1142 1143 switch (level) { 1144 default: 1145 case 6: 1146 uftdi_close_pipes(uf); 1147 /*FALLTHROUGH*/ 1148 case 5: 1149 usb_unregister_event_cbs(uf->uf_dip, uf->uf_usb_events); 1150 /*FALLTHROUGH*/ 1151 case 4: 1152 uftdi_destroy_pm_components(uf); 1153 /*FALLTHROUGH*/ 1154 case 3: 1155 mutex_destroy(&uf->uf_lock); 1156 cv_destroy(&uf->uf_tx_cv); 1157 1158 usb_free_log_hdl(uf->uf_lh); 1159 uf->uf_lh = NULL; 1160 1161 usb_free_descr_tree(uf->uf_dip, uf->uf_dev_data); 1162 uf->uf_def_ph = NULL; 1163 /*FALLTHROUGH*/ 1164 case 2: 1165 usb_client_detach(uf->uf_dip, uf->uf_dev_data); 1166 /*FALLTHROUGH*/ 1167 case 1: 1168 kmem_free(uf, sizeof (*uf)); 1169 break; 1170 } 1171 } 1172 1173 1174 /* 1175 * device specific attach 1176 */ 1177 static int 1178 uftdi_dev_attach(uftdi_state_t *uf) 1179 { 1180 return (uftdi_open_pipes(uf)); 1181 } 1182 1183 1184 /* 1185 * restore device state after CPR resume or reconnect 1186 */ 1187 static int 1188 uftdi_restore_device_state(uftdi_state_t *uf) 1189 { 1190 int state; 1191 1192 mutex_enter(&uf->uf_lock); 1193 state = uf->uf_dev_state; 1194 mutex_exit(&uf->uf_lock); 1195 1196 if (state != USB_DEV_DISCONNECTED && state != USB_DEV_SUSPENDED) 1197 return (state); 1198 1199 if (usb_check_same_device(uf->uf_dip, uf->uf_lh, USB_LOG_L0, 1200 DPRINT_MASK_ALL, USB_CHK_ALL, NULL) != USB_SUCCESS) { 1201 mutex_enter(&uf->uf_lock); 1202 state = uf->uf_dev_state = USB_DEV_DISCONNECTED; 1203 mutex_exit(&uf->uf_lock); 1204 return (state); 1205 } 1206 1207 if (state == USB_DEV_DISCONNECTED) { 1208 USB_DPRINTF_L0(DPRINT_HOTPLUG, uf->uf_lh, 1209 "Device has been reconnected but data may have been lost"); 1210 } 1211 1212 if (uftdi_reconnect_pipes(uf) != USB_SUCCESS) 1213 return (state); 1214 1215 /* 1216 * init device state 1217 */ 1218 mutex_enter(&uf->uf_lock); 1219 state = uf->uf_dev_state = USB_DEV_ONLINE; 1220 mutex_exit(&uf->uf_lock); 1221 1222 if ((uftdi_restore_port_state(uf) != USB_SUCCESS)) { 1223 USB_DPRINTF_L2(DPRINT_HOTPLUG, uf->uf_lh, 1224 "uftdi_restore_device_state: failed"); 1225 } 1226 1227 return (state); 1228 } 1229 1230 1231 /* 1232 * restore ports state after CPR resume or reconnect 1233 */ 1234 static int 1235 uftdi_restore_port_state(uftdi_state_t *uf) 1236 { 1237 int rval; 1238 1239 mutex_enter(&uf->uf_lock); 1240 if (uf->uf_port_state != UFTDI_PORT_OPEN) { 1241 mutex_exit(&uf->uf_lock); 1242 return (USB_SUCCESS); 1243 } 1244 mutex_exit(&uf->uf_lock); 1245 1246 /* open hardware serial port, restoring old settings */ 1247 if ((rval = uftdi_open_hw_port(uf, 1)) != USB_SUCCESS) { 1248 USB_DPRINTF_L2(DPRINT_HOTPLUG, uf->uf_lh, 1249 "uftdi_restore_port_state: failed"); 1250 } 1251 1252 return (rval); 1253 } 1254 1255 1256 /* 1257 * create PM components 1258 */ 1259 static int 1260 uftdi_create_pm_components(uftdi_state_t *uf) 1261 { 1262 dev_info_t *dip = uf->uf_dip; 1263 uftdi_pm_t *pm; 1264 uint_t pwr_states; 1265 1266 if (usb_create_pm_components(dip, &pwr_states) != USB_SUCCESS) { 1267 USB_DPRINTF_L2(DPRINT_PM, uf->uf_lh, 1268 "uftdi_create_pm_components: failed"); 1269 return (USB_SUCCESS); 1270 } 1271 1272 pm = uf->uf_pm = kmem_zalloc(sizeof (*pm), KM_SLEEP); 1273 1274 pm->pm_pwr_states = (uint8_t)pwr_states; 1275 pm->pm_cur_power = USB_DEV_OS_FULL_PWR; 1276 pm->pm_wakeup_enabled = usb_handle_remote_wakeup(dip, 1277 USB_REMOTE_WAKEUP_ENABLE) == USB_SUCCESS; 1278 1279 (void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR); 1280 1281 return (USB_SUCCESS); 1282 } 1283 1284 1285 /* 1286 * destroy PM components 1287 */ 1288 static void 1289 uftdi_destroy_pm_components(uftdi_state_t *uf) 1290 { 1291 uftdi_pm_t *pm = uf->uf_pm; 1292 dev_info_t *dip = uf->uf_dip; 1293 int rval; 1294 1295 if (!pm) 1296 return; 1297 1298 if (uf->uf_dev_state != USB_DEV_DISCONNECTED) { 1299 if (pm->pm_wakeup_enabled) { 1300 rval = pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR); 1301 if (rval != DDI_SUCCESS) { 1302 USB_DPRINTF_L2(DPRINT_PM, uf->uf_lh, 1303 "uftdi_destroy_pm_components: " 1304 "raising power failed, rval=%d", rval); 1305 } 1306 rval = usb_handle_remote_wakeup(dip, 1307 USB_REMOTE_WAKEUP_DISABLE); 1308 if (rval != USB_SUCCESS) { 1309 USB_DPRINTF_L2(DPRINT_PM, uf->uf_lh, 1310 "uftdi_destroy_pm_components: disable " 1311 "remote wakeup failed, rval=%d", rval); 1312 } 1313 } 1314 (void) pm_lower_power(dip, 0, USB_DEV_OS_PWR_OFF); 1315 } 1316 kmem_free(pm, sizeof (*pm)); 1317 uf->uf_pm = NULL; 1318 } 1319 1320 1321 /* 1322 * mark device busy and raise power 1323 */ 1324 static int 1325 uftdi_pm_set_busy(uftdi_state_t *uf) 1326 { 1327 uftdi_pm_t *pm = uf->uf_pm; 1328 dev_info_t *dip = uf->uf_dip; 1329 int rval; 1330 1331 USB_DPRINTF_L4(DPRINT_PM, uf->uf_lh, "uftdi_pm_set_busy"); 1332 1333 if (!pm) 1334 return (USB_SUCCESS); 1335 1336 mutex_enter(&uf->uf_lock); 1337 /* if already marked busy, just increment the counter */ 1338 if (pm->pm_busy_cnt++ > 0) { 1339 mutex_exit(&uf->uf_lock); 1340 return (USB_SUCCESS); 1341 } 1342 1343 rval = pm_busy_component(dip, 0); 1344 ASSERT(rval == DDI_SUCCESS); 1345 1346 if (pm->pm_cur_power == USB_DEV_OS_FULL_PWR) { 1347 mutex_exit(&uf->uf_lock); 1348 return (USB_SUCCESS); 1349 } 1350 1351 /* need to raise power */ 1352 pm->pm_raise_power = B_TRUE; 1353 mutex_exit(&uf->uf_lock); 1354 1355 rval = pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR); 1356 if (rval != DDI_SUCCESS) { 1357 USB_DPRINTF_L2(DPRINT_PM, uf->uf_lh, "raising power failed"); 1358 } 1359 1360 mutex_enter(&uf->uf_lock); 1361 pm->pm_raise_power = B_FALSE; 1362 mutex_exit(&uf->uf_lock); 1363 1364 return (USB_SUCCESS); 1365 } 1366 1367 1368 /* 1369 * mark device idle 1370 */ 1371 static void 1372 uftdi_pm_set_idle(uftdi_state_t *uf) 1373 { 1374 uftdi_pm_t *pm = uf->uf_pm; 1375 dev_info_t *dip = uf->uf_dip; 1376 1377 USB_DPRINTF_L4(DPRINT_PM, uf->uf_lh, "uftdi_pm_set_idle"); 1378 1379 if (!pm) 1380 return; 1381 1382 /* 1383 * if more ports use the device, do not mark as yet 1384 */ 1385 mutex_enter(&uf->uf_lock); 1386 if (--pm->pm_busy_cnt > 0) { 1387 mutex_exit(&uf->uf_lock); 1388 return; 1389 } 1390 (void) pm_idle_component(dip, 0); 1391 mutex_exit(&uf->uf_lock); 1392 } 1393 1394 1395 /* 1396 * Functions to handle power transition for OS levels 0 -> 3 1397 * The same level as OS state, different from USB state 1398 */ 1399 static int 1400 uftdi_pwrlvl0(uftdi_state_t *uf) 1401 { 1402 int rval; 1403 1404 USB_DPRINTF_L4(DPRINT_PM, uf->uf_lh, "uftdi_pwrlvl0"); 1405 1406 switch (uf->uf_dev_state) { 1407 case USB_DEV_ONLINE: 1408 /* issue USB D3 command to the device */ 1409 rval = usb_set_device_pwrlvl3(uf->uf_dip); 1410 ASSERT(rval == USB_SUCCESS); 1411 1412 uf->uf_dev_state = USB_DEV_PWRED_DOWN; 1413 uf->uf_pm->pm_cur_power = USB_DEV_OS_PWR_OFF; 1414 1415 /*FALLTHROUGH*/ 1416 case USB_DEV_DISCONNECTED: 1417 case USB_DEV_SUSPENDED: 1418 /* allow a disconnect/cpr'ed device to go to lower power */ 1419 return (USB_SUCCESS); 1420 case USB_DEV_PWRED_DOWN: 1421 default: 1422 USB_DPRINTF_L2(DPRINT_PM, uf->uf_lh, 1423 "uftdi_pwrlvl0: illegal device state"); 1424 return (USB_FAILURE); 1425 } 1426 } 1427 1428 1429 static int 1430 uftdi_pwrlvl1(uftdi_state_t *uf) 1431 { 1432 USB_DPRINTF_L4(DPRINT_PM, uf->uf_lh, "uftdi_pwrlvl1"); 1433 1434 /* issue USB D2 command to the device */ 1435 (void) usb_set_device_pwrlvl2(uf->uf_dip); 1436 return (USB_FAILURE); 1437 } 1438 1439 1440 static int 1441 uftdi_pwrlvl2(uftdi_state_t *uf) 1442 { 1443 USB_DPRINTF_L4(DPRINT_PM, uf->uf_lh, "uftdi_pwrlvl2"); 1444 1445 /* issue USB D1 command to the device */ 1446 (void) usb_set_device_pwrlvl1(uf->uf_dip); 1447 return (USB_FAILURE); 1448 } 1449 1450 1451 static int 1452 uftdi_pwrlvl3(uftdi_state_t *uf) 1453 { 1454 int rval; 1455 1456 USB_DPRINTF_L4(DPRINT_PM, uf->uf_lh, "uftdi_pwrlvl3"); 1457 1458 switch (uf->uf_dev_state) { 1459 case USB_DEV_PWRED_DOWN: 1460 /* Issue USB D0 command to the device here */ 1461 rval = usb_set_device_pwrlvl0(uf->uf_dip); 1462 ASSERT(rval == USB_SUCCESS); 1463 1464 uf->uf_dev_state = USB_DEV_ONLINE; 1465 uf->uf_pm->pm_cur_power = USB_DEV_OS_FULL_PWR; 1466 1467 /*FALLTHROUGH*/ 1468 case USB_DEV_ONLINE: 1469 /* we are already in full power */ 1470 1471 /*FALLTHROUGH*/ 1472 case USB_DEV_DISCONNECTED: 1473 case USB_DEV_SUSPENDED: 1474 return (USB_SUCCESS); 1475 default: 1476 USB_DPRINTF_L2(DPRINT_PM, uf->uf_lh, 1477 "uftdi_pwrlvl3: illegal device state"); 1478 return (USB_FAILURE); 1479 } 1480 } 1481 1482 1483 /* 1484 * pipe operations 1485 */ 1486 static int 1487 uftdi_open_pipes(uftdi_state_t *uf) 1488 { 1489 int ifc, alt; 1490 usb_pipe_policy_t policy; 1491 usb_ep_data_t *in_data, *out_data; 1492 size_t max_xfer_sz; 1493 1494 /* get max transfer size */ 1495 if (usb_pipe_get_max_bulk_transfer_size(uf->uf_dip, &max_xfer_sz) 1496 != USB_SUCCESS) 1497 return (USB_FAILURE); 1498 1499 /* get ep data */ 1500 ifc = uf->uf_dev_data->dev_curr_if; 1501 alt = 0; 1502 1503 in_data = usb_lookup_ep_data(uf->uf_dip, uf->uf_dev_data, ifc, alt, 1504 0, USB_EP_ATTR_BULK, USB_EP_DIR_IN); 1505 1506 out_data = usb_lookup_ep_data(uf->uf_dip, uf->uf_dev_data, ifc, alt, 1507 0, USB_EP_ATTR_BULK, USB_EP_DIR_OUT); 1508 1509 if (in_data == NULL || out_data == NULL) { 1510 USB_DPRINTF_L2(DPRINT_ATTACH, uf->uf_lh, 1511 "uftdi_open_pipes: can't get ep data"); 1512 return (USB_FAILURE); 1513 } 1514 1515 /* 1516 * Set buffer sizes. Default to UFTDI_XFER_SZ_MAX. 1517 * Use wMaxPacketSize from endpoint descriptor if it is nonzero. 1518 * Cap at a max transfer size of host controller. 1519 */ 1520 uf->uf_ibuf_sz = uf->uf_obuf_sz = UFTDI_XFER_SZ_MAX; 1521 1522 if (in_data->ep_descr.wMaxPacketSize) 1523 uf->uf_ibuf_sz = in_data->ep_descr.wMaxPacketSize; 1524 uf->uf_ibuf_sz = min(uf->uf_ibuf_sz, max_xfer_sz); 1525 1526 if (out_data->ep_descr.wMaxPacketSize) 1527 uf->uf_obuf_sz = out_data->ep_descr.wMaxPacketSize; 1528 uf->uf_obuf_sz = min(uf->uf_obuf_sz, max_xfer_sz); 1529 1530 /* open pipes */ 1531 policy.pp_max_async_reqs = 2; 1532 1533 if (usb_pipe_open(uf->uf_dip, &in_data->ep_descr, &policy, 1534 USB_FLAGS_SLEEP, &uf->uf_bulkin_ph) != USB_SUCCESS) 1535 return (USB_FAILURE); 1536 1537 if (usb_pipe_open(uf->uf_dip, &out_data->ep_descr, &policy, 1538 USB_FLAGS_SLEEP, &uf->uf_bulkout_ph) != USB_SUCCESS) { 1539 usb_pipe_close(uf->uf_dip, uf->uf_bulkin_ph, USB_FLAGS_SLEEP, 1540 NULL, NULL); 1541 return (USB_FAILURE); 1542 } 1543 1544 mutex_enter(&uf->uf_lock); 1545 uf->uf_bulkin_state = UFTDI_PIPE_IDLE; 1546 uf->uf_bulkout_state = UFTDI_PIPE_IDLE; 1547 mutex_exit(&uf->uf_lock); 1548 1549 return (USB_SUCCESS); 1550 } 1551 1552 1553 static void 1554 uftdi_close_pipes(uftdi_state_t *uf) 1555 { 1556 if (uf->uf_bulkin_ph) 1557 usb_pipe_close(uf->uf_dip, uf->uf_bulkin_ph, 1558 USB_FLAGS_SLEEP, 0, 0); 1559 if (uf->uf_bulkout_ph) 1560 usb_pipe_close(uf->uf_dip, uf->uf_bulkout_ph, 1561 USB_FLAGS_SLEEP, 0, 0); 1562 1563 mutex_enter(&uf->uf_lock); 1564 uf->uf_bulkin_state = UFTDI_PIPE_CLOSED; 1565 uf->uf_bulkout_state = UFTDI_PIPE_CLOSED; 1566 mutex_exit(&uf->uf_lock); 1567 } 1568 1569 1570 static void 1571 uftdi_disconnect_pipes(uftdi_state_t *uf) 1572 { 1573 uftdi_close_pipes(uf); 1574 } 1575 1576 1577 static int 1578 uftdi_reconnect_pipes(uftdi_state_t *uf) 1579 { 1580 return (uftdi_open_pipes(uf)); 1581 } 1582 1583 1584 static void 1585 uftdi_rxerr_put(mblk_t **rx_mpp, mblk_t *data, uint8_t lsr) 1586 { 1587 uchar_t errflg; 1588 1589 if (lsr & FTDI_LSR_STATUS_BI) { 1590 /* 1591 * parity and framing errors only "count" if they 1592 * occur independently of a break being received. 1593 */ 1594 lsr &= ~(uint8_t)(FTDI_LSR_STATUS_PE | FTDI_LSR_STATUS_FE); 1595 } 1596 errflg = 1597 ((lsr & FTDI_LSR_STATUS_OE) ? DS_OVERRUN_ERR : 0) | 1598 ((lsr & FTDI_LSR_STATUS_PE) ? DS_PARITY_ERR : 0) | 1599 ((lsr & FTDI_LSR_STATUS_FE) ? DS_FRAMING_ERR : 0) | 1600 ((lsr & FTDI_LSR_STATUS_BI) ? DS_BREAK_ERR : 0); 1601 1602 /* 1603 * If there's no actual data, we send a NUL character along 1604 * with the error flags. Otherwise, the data mblk contains 1605 * some number of highly questionable characters. 1606 * 1607 * According to FTDI tech support, there is no synchronous 1608 * error reporting i.e. we cannot assume that only the 1609 * first character in the mblk is bad -- so we treat all 1610 * of them them as if they have the error noted in the LSR. 1611 */ 1612 do { 1613 mblk_t *mp; 1614 uchar_t c = (MBLKL(data) == 0) ? '\0' : *data->b_rptr++; 1615 1616 if ((mp = allocb(2, BPRI_HI)) != NULL) { 1617 DB_TYPE(mp) = M_BREAK; 1618 *mp->b_wptr++ = errflg; 1619 *mp->b_wptr++ = c; 1620 uftdi_put_tail(rx_mpp, mp); 1621 } else { 1622 /* 1623 * low memory - just discard the bad data 1624 */ 1625 data->b_rptr = data->b_wptr; 1626 break; 1627 } 1628 } while (MBLKL(data) > 0); 1629 } 1630 1631 1632 /* 1633 * bulk in pipe normal and exception callback handler 1634 */ 1635 /*ARGSUSED*/ 1636 static void 1637 uftdi_bulkin_cb(usb_pipe_handle_t pipe, usb_bulk_req_t *req) 1638 { 1639 uftdi_state_t *uf = (uftdi_state_t *)req->bulk_client_private; 1640 mblk_t *data; 1641 int data_len; 1642 1643 data = req->bulk_data; 1644 data_len = data ? MBLKL(data) : 0; 1645 1646 /* 1647 * The first two bytes of data are status register bytes 1648 * that arrive with every packet from the device. Process 1649 * them here before handing the rest of the data on. 1650 * 1651 * When active, the device will send us these bytes at least 1652 * every 40 milliseconds, even if there's no received data. 1653 */ 1654 if (req->bulk_completion_reason == USB_CR_OK && data_len >= 2) { 1655 uint8_t msr = FTDI_GET_MSR(data->b_rptr); 1656 uint8_t lsr = FTDI_GET_LSR(data->b_rptr); 1657 int new_rx_err; 1658 1659 data->b_rptr += 2; 1660 1661 mutex_enter(&uf->uf_lock); 1662 1663 if (uf->uf_msr != msr) { 1664 /* 1665 * modem status register changed 1666 */ 1667 USB_DPRINTF_L3(DPRINT_IN_PIPE, uf->uf_lh, 1668 "uftdi_bulkin_cb: new msr: 0x%02x -> 0x%02x", 1669 uf->uf_msr, msr); 1670 1671 uf->uf_msr = msr; 1672 1673 if (uf->uf_port_state == UFTDI_PORT_OPEN && 1674 uf->uf_cb.cb_status) { 1675 mutex_exit(&uf->uf_lock); 1676 uf->uf_cb.cb_status(uf->uf_cb.cb_arg); 1677 mutex_enter(&uf->uf_lock); 1678 } 1679 } 1680 1681 if ((uf->uf_lsr & FTDI_LSR_MASK) != (lsr & FTDI_LSR_MASK)) { 1682 /* 1683 * line status register *receive* bits changed 1684 * 1685 * (The THRE and TEMT (transmit) status bits are 1686 * masked out above.) 1687 */ 1688 USB_DPRINTF_L3(DPRINT_IN_PIPE, uf->uf_lh, 1689 "uftdi_bulkin_cb: new lsr: 0x%02x -> 0x%02x", 1690 uf->uf_lsr, lsr); 1691 new_rx_err = B_TRUE; 1692 } else 1693 new_rx_err = B_FALSE; 1694 1695 uf->uf_lsr = lsr; /* THRE and TEMT captured here */ 1696 1697 if ((lsr & FTDI_LSR_MASK) != 0 && 1698 (MBLKL(data) > 0 || new_rx_err) && 1699 uf->uf_port_state == UFTDI_PORT_OPEN) { 1700 /* 1701 * The current line status register value indicates 1702 * that there's been some sort of unusual condition 1703 * on the receive side. We either received a break, 1704 * or got some badly formed characters from the 1705 * serial port - framing errors, overrun, parity etc. 1706 * So there's either some new data to post, or a 1707 * new error (break) to post, or both. 1708 * 1709 * Invoke uftdi_rxerr_put() to place the inbound 1710 * characters as M_BREAK messages on the receive 1711 * mblk chain, decorated with error flag(s) for 1712 * upper-level modules (e.g. ldterm) to process. 1713 */ 1714 mutex_exit(&uf->uf_lock); 1715 uftdi_rxerr_put(&uf->uf_rx_mp, data, lsr); 1716 ASSERT(MBLKL(data) == 0); 1717 1718 /* 1719 * Since we've converted all the received 1720 * characters into M_BREAK messages, we 1721 * invoke the rx callback to shove the mblks 1722 * up the STREAM. 1723 */ 1724 if (uf->uf_cb.cb_rx) 1725 uf->uf_cb.cb_rx(uf->uf_cb.cb_arg); 1726 mutex_enter(&uf->uf_lock); 1727 } 1728 1729 mutex_exit(&uf->uf_lock); 1730 data_len = MBLKL(data); 1731 } 1732 1733 USB_DPRINTF_L4(DPRINT_IN_PIPE, uf->uf_lh, "uftdi_bulkin_cb: " 1734 "cr=%d len=%d", req->bulk_completion_reason, data_len); 1735 1736 /* save data and notify GSD */ 1737 if (data_len > 0 && 1738 uf->uf_port_state == UFTDI_PORT_OPEN && 1739 req->bulk_completion_reason == USB_CR_OK) { 1740 req->bulk_data = NULL; 1741 uftdi_put_tail(&uf->uf_rx_mp, data); 1742 if (uf->uf_cb.cb_rx) 1743 uf->uf_cb.cb_rx(uf->uf_cb.cb_arg); 1744 } 1745 1746 usb_free_bulk_req(req); 1747 1748 /* receive more */ 1749 mutex_enter(&uf->uf_lock); 1750 uf->uf_bulkin_state = UFTDI_PIPE_IDLE; 1751 if (uf->uf_port_state == UFTDI_PORT_OPEN && 1752 uf->uf_dev_state == USB_DEV_ONLINE) { 1753 if (uftdi_rx_start(uf) != USB_SUCCESS) { 1754 USB_DPRINTF_L2(DPRINT_IN_PIPE, uf->uf_lh, 1755 "uftdi_bulkin_cb: restart rx fail"); 1756 } 1757 } 1758 mutex_exit(&uf->uf_lock); 1759 } 1760 1761 1762 /* 1763 * bulk out common and exception callback 1764 */ 1765 /*ARGSUSED*/ 1766 static void 1767 uftdi_bulkout_cb(usb_pipe_handle_t pipe, usb_bulk_req_t *req) 1768 { 1769 uftdi_state_t *uf = (uftdi_state_t *)req->bulk_client_private; 1770 int data_len; 1771 mblk_t *data = req->bulk_data; 1772 1773 data_len = data ? MBLKL(data) : 0; 1774 1775 USB_DPRINTF_L4(DPRINT_OUT_PIPE, uf->uf_lh, 1776 "uftdi_bulkout_cb: cr=%d len=%d", 1777 req->bulk_completion_reason, data_len); 1778 1779 if (uf->uf_port_state == UFTDI_PORT_OPEN && 1780 req->bulk_completion_reason && data_len > 0) { 1781 uftdi_put_head(&uf->uf_tx_mp, data); 1782 req->bulk_data = NULL; 1783 } 1784 1785 usb_free_bulk_req(req); 1786 1787 /* notify GSD */ 1788 if (uf->uf_cb.cb_tx) 1789 uf->uf_cb.cb_tx(uf->uf_cb.cb_arg); 1790 1791 /* send more */ 1792 mutex_enter(&uf->uf_lock); 1793 uf->uf_bulkout_state = UFTDI_PIPE_IDLE; 1794 if (uf->uf_tx_mp == NULL) 1795 cv_broadcast(&uf->uf_tx_cv); 1796 else 1797 uftdi_tx_start(uf, NULL); 1798 mutex_exit(&uf->uf_lock); 1799 } 1800 1801 1802 /* 1803 * start receiving data 1804 */ 1805 static int 1806 uftdi_rx_start(uftdi_state_t *uf) 1807 { 1808 usb_bulk_req_t *br; 1809 int rval; 1810 1811 USB_DPRINTF_L4(DPRINT_OUT_PIPE, uf->uf_lh, "uftdi_rx_start"); 1812 1813 ASSERT(mutex_owned(&uf->uf_lock)); 1814 1815 uf->uf_bulkin_state = UFTDI_PIPE_BUSY; 1816 mutex_exit(&uf->uf_lock); 1817 1818 br = usb_alloc_bulk_req(uf->uf_dip, uf->uf_ibuf_sz, USB_FLAGS_SLEEP); 1819 br->bulk_len = uf->uf_ibuf_sz; 1820 br->bulk_timeout = UFTDI_BULKIN_TIMEOUT; 1821 br->bulk_cb = uftdi_bulkin_cb; 1822 br->bulk_exc_cb = uftdi_bulkin_cb; 1823 br->bulk_client_private = (usb_opaque_t)uf; 1824 br->bulk_attributes = USB_ATTRS_AUTOCLEARING | USB_ATTRS_SHORT_XFER_OK; 1825 1826 rval = usb_pipe_bulk_xfer(uf->uf_bulkin_ph, br, 0); 1827 1828 if (rval != USB_SUCCESS) { 1829 USB_DPRINTF_L2(DPRINT_IN_PIPE, uf->uf_lh, 1830 "uftdi_rx_start: xfer failed %d", rval); 1831 usb_free_bulk_req(br); 1832 } 1833 1834 mutex_enter(&uf->uf_lock); 1835 if (rval != USB_SUCCESS) 1836 uf->uf_bulkin_state = UFTDI_PIPE_IDLE; 1837 1838 return (rval); 1839 } 1840 1841 1842 /* 1843 * start data transmit 1844 */ 1845 static void 1846 uftdi_tx_start(uftdi_state_t *uf, int *xferd) 1847 { 1848 int len; /* bytes we can transmit */ 1849 mblk_t *data; /* data to be transmitted */ 1850 int data_len; /* bytes in 'data' */ 1851 mblk_t *mp; /* current msgblk */ 1852 int copylen; /* bytes copy from 'mp' to 'data' */ 1853 int rval; 1854 1855 USB_DPRINTF_L4(DPRINT_OUT_PIPE, uf->uf_lh, "uftdi_tx_start"); 1856 ASSERT(mutex_owned(&uf->uf_lock)); 1857 ASSERT(uf->uf_port_state != UFTDI_PORT_CLOSED); 1858 1859 if (xferd) 1860 *xferd = 0; 1861 if ((uf->uf_port_flags & UFTDI_PORT_TX_STOPPED) || 1862 uf->uf_tx_mp == NULL) { 1863 return; 1864 } 1865 if (uf->uf_bulkout_state != UFTDI_PIPE_IDLE) { 1866 USB_DPRINTF_L4(DPRINT_OUT_PIPE, uf->uf_lh, 1867 "uftdi_tx_start: pipe busy"); 1868 return; 1869 } 1870 ASSERT(MBLKL(uf->uf_tx_mp) > 0); 1871 1872 /* send as much data as port can receive */ 1873 len = min(msgdsize(uf->uf_tx_mp), uf->uf_obuf_sz); 1874 1875 if (len <= 0) 1876 return; 1877 if ((data = allocb(len, BPRI_LO)) == NULL) 1878 return; 1879 1880 /* 1881 * copy no more than 'len' bytes from mblk chain to transmit mblk 'data' 1882 */ 1883 data_len = 0; 1884 while (data_len < len && uf->uf_tx_mp) { 1885 mp = uf->uf_tx_mp; 1886 copylen = min(MBLKL(mp), len - data_len); 1887 bcopy(mp->b_rptr, data->b_wptr, copylen); 1888 mp->b_rptr += copylen; 1889 data->b_wptr += copylen; 1890 data_len += copylen; 1891 1892 if (MBLKL(mp) < 1) { 1893 uf->uf_tx_mp = unlinkb(mp); 1894 freeb(mp); 1895 } else { 1896 ASSERT(data_len == len); 1897 } 1898 } 1899 1900 ASSERT(data_len > 0); 1901 1902 uf->uf_bulkout_state = UFTDI_PIPE_BUSY; 1903 mutex_exit(&uf->uf_lock); 1904 1905 rval = uftdi_send_data(uf, data); 1906 mutex_enter(&uf->uf_lock); 1907 1908 if (rval != USB_SUCCESS) { 1909 uf->uf_bulkout_state = UFTDI_PIPE_IDLE; 1910 uftdi_put_head(&uf->uf_tx_mp, data); 1911 } else { 1912 if (xferd) 1913 *xferd = data_len; 1914 } 1915 } 1916 1917 1918 static int 1919 uftdi_send_data(uftdi_state_t *uf, mblk_t *data) 1920 { 1921 usb_bulk_req_t *br; 1922 int len = MBLKL(data); 1923 int rval; 1924 1925 USB_DPRINTF_L4(DPRINT_OUT_PIPE, uf->uf_lh, 1926 "uftdi_send_data: %d 0x%x 0x%x 0x%x", len, data->b_rptr[0], 1927 (len > 1) ? data->b_rptr[1] : 0, (len > 2) ? data->b_rptr[2] : 0); 1928 1929 ASSERT(!mutex_owned(&uf->uf_lock)); 1930 1931 br = usb_alloc_bulk_req(uf->uf_dip, 0, USB_FLAGS_SLEEP); 1932 br->bulk_data = data; 1933 br->bulk_len = len; 1934 br->bulk_timeout = UFTDI_BULKOUT_TIMEOUT; 1935 br->bulk_cb = uftdi_bulkout_cb; 1936 br->bulk_exc_cb = uftdi_bulkout_cb; 1937 br->bulk_client_private = (usb_opaque_t)uf; 1938 br->bulk_attributes = USB_ATTRS_AUTOCLEARING; 1939 1940 rval = usb_pipe_bulk_xfer(uf->uf_bulkout_ph, br, 0); 1941 1942 if (rval != USB_SUCCESS) { 1943 USB_DPRINTF_L2(DPRINT_OUT_PIPE, uf->uf_lh, 1944 "uftdi_send_data: xfer failed %d", rval); 1945 br->bulk_data = NULL; 1946 usb_free_bulk_req(br); 1947 } 1948 1949 return (rval); 1950 } 1951 1952 1953 /* 1954 * wait until local tx buffer drains. 1955 * 'timeout' is in seconds, zero means wait forever 1956 */ 1957 static int 1958 uftdi_wait_tx_drain(uftdi_state_t *uf, int timeout) 1959 { 1960 clock_t until; 1961 int over = 0; 1962 1963 until = ddi_get_lbolt() + drv_usectohz(1000 * 1000 * timeout); 1964 1965 while (uf->uf_tx_mp && !over) { 1966 if (timeout > 0) { 1967 /* whether timedout or signal pending */ 1968 over = cv_timedwait_sig(&uf->uf_tx_cv, 1969 &uf->uf_lock, until) <= 0; 1970 } else { 1971 /* whether a signal is pending */ 1972 over = cv_wait_sig(&uf->uf_tx_cv, 1973 &uf->uf_lock) == 0; 1974 } 1975 } 1976 1977 return (uf->uf_tx_mp == NULL ? USB_SUCCESS : USB_FAILURE); 1978 } 1979 1980 /* 1981 * initialize hardware serial port 1982 */ 1983 static int 1984 uftdi_open_hw_port(uftdi_state_t *uf, int dorestore) 1985 { 1986 int rval; 1987 1988 /* 1989 * Perform a full reset on the device 1990 */ 1991 rval = uftdi_cmd_vendor_write0(uf, 1992 FTDI_SIO_RESET, FTDI_SIO_RESET_SIO, uf->uf_hwport); 1993 if (rval != USB_SUCCESS) { 1994 USB_DPRINTF_L2(DPRINT_DEF_PIPE, uf->uf_lh, 1995 "uftdi_open_hw_port: failed to reset!"); 1996 return (rval); 1997 } 1998 1999 if (dorestore) { 2000 /* 2001 * Restore settings from our soft copy of HW registers 2002 */ 2003 (void) uftdi_setregs(uf, NULL); 2004 } else { 2005 /* 2006 * 9600 baud, 2 stop bits, no parity, 8-bit, h/w flow control 2007 */ 2008 static ds_port_param_entry_t ents[] = { 2009 #if defined(__lock_lint) 2010 /* 2011 * (Sigh - wlcc doesn't understand this newer 2012 * form of structure member initialization.) 2013 */ 2014 { 0 } 2015 #else 2016 { DS_PARAM_BAUD, .val.ui = B9600 }, 2017 { DS_PARAM_STOPB, .val.ui = CSTOPB }, 2018 { DS_PARAM_PARITY, .val.ui = 0 }, 2019 { DS_PARAM_CHARSZ, .val.ui = CS8 }, 2020 { DS_PARAM_FLOW_CTL, .val.ui = CTSXON } 2021 #endif 2022 }; 2023 static ds_port_params_t params = { 2024 ents, 2025 sizeof (ents) / sizeof (ents[0]) 2026 }; 2027 2028 rval = uftdi_set_port_params(uf, 0, ¶ms); 2029 if (rval != USB_SUCCESS) { 2030 USB_DPRINTF_L2(DPRINT_DEF_PIPE, uf->uf_lh, 2031 "uftdi_open_hw_port: failed 9600/2/n/8 rval %d", 2032 rval); 2033 } 2034 } 2035 2036 return (rval); 2037 } 2038 2039 static int 2040 uftdi_cmd_vendor_write0(uftdi_state_t *uf, 2041 uint16_t reqno, uint16_t val, uint16_t idx) 2042 { 2043 usb_ctrl_setup_t req; 2044 usb_cb_flags_t cb_flags; 2045 usb_cr_t cr; 2046 int rval; 2047 2048 ASSERT(!mutex_owned(&uf->uf_lock)); 2049 2050 req.bmRequestType = 2051 USB_DEV_REQ_TYPE_VENDOR | USB_DEV_REQ_HOST_TO_DEV; 2052 req.bRequest = (uchar_t)reqno; 2053 req.wValue = val; 2054 req.wIndex = idx; 2055 req.wLength = 0; 2056 req.attrs = USB_ATTRS_NONE; 2057 2058 if ((rval = usb_pipe_ctrl_xfer_wait(uf->uf_def_ph, 2059 &req, NULL, &cr, &cb_flags, 0)) != USB_SUCCESS) { 2060 USB_DPRINTF_L2(DPRINT_DEF_PIPE, uf->uf_lh, 2061 "uftdi_cmd_vendor_write0: 0x%x 0x%x 0x%x failed %d %d 0x%x", 2062 reqno, val, idx, rval, cr, cb_flags); 2063 } 2064 2065 return (rval); 2066 } 2067 2068 /* 2069 * misc routines 2070 */ 2071 2072 /* 2073 * link a message block to tail of message 2074 * account for the case when message is null 2075 */ 2076 static void 2077 uftdi_put_tail(mblk_t **mpp, mblk_t *bp) 2078 { 2079 if (*mpp) 2080 linkb(*mpp, bp); 2081 else 2082 *mpp = bp; 2083 } 2084 2085 /* 2086 * put a message block at the head of the message 2087 * account for the case when message is null 2088 */ 2089 static void 2090 uftdi_put_head(mblk_t **mpp, mblk_t *bp) 2091 { 2092 if (*mpp) 2093 linkb(bp, *mpp); 2094 *mpp = bp; 2095 } 2096 2097 /*ARGSUSED*/ 2098 static usb_pipe_handle_t 2099 uftdi_out_pipe(ds_hdl_t hdl, uint_t portno) 2100 { 2101 ASSERT(portno == 0); 2102 2103 return (((uftdi_state_t *)hdl)->uf_bulkout_ph); 2104 } 2105 2106 /*ARGSUSED*/ 2107 static usb_pipe_handle_t 2108 uftdi_in_pipe(ds_hdl_t hdl, uint_t portno) 2109 { 2110 ASSERT(portno == 0); 2111 2112 return (((uftdi_state_t *)hdl)->uf_bulkin_ph); 2113 } 2114