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