1 /* $NetBSD: ucom.c,v 1.40 2001/11/13 06:24:54 lukem Exp $ */ 2 3 /*- 4 * Copyright (c) 2001-2003, 2005, 2008 5 * Shunsuke Akiyama <akiyama@jp.FreeBSD.org>. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 /*- 31 * Copyright (c) 1998, 2000 The NetBSD Foundation, Inc. 32 * All rights reserved. 33 * 34 * This code is derived from software contributed to The NetBSD Foundation 35 * by Lennart Augustsson (lennart@augustsson.net) at 36 * Carlstedt Research & Technology. 37 * 38 * Redistribution and use in source and binary forms, with or without 39 * modification, are permitted provided that the following conditions 40 * are met: 41 * 1. Redistributions of source code must retain the above copyright 42 * notice, this list of conditions and the following disclaimer. 43 * 2. Redistributions in binary form must reproduce the above copyright 44 * notice, this list of conditions and the following disclaimer in the 45 * documentation and/or other materials provided with the distribution. 46 * 3. All advertising materials mentioning features or use of this software 47 * must display the following acknowledgement: 48 * This product includes software developed by the NetBSD 49 * Foundation, Inc. and its contributors. 50 * 4. Neither the name of The NetBSD Foundation nor the names of its 51 * contributors may be used to endorse or promote products derived 52 * from this software without specific prior written permission. 53 * 54 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 55 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 56 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 57 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 58 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 59 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 60 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 61 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 62 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 63 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 64 * POSSIBILITY OF SUCH DAMAGE. 65 */ 66 67 /* 68 * XXX profmakx 69 * This is a Frankenstein of FreeBSD's usb4bsd ucom and Dragonfly's old ucom 70 * module. There might be bugs lurking everywhere still 71 * 72 * In particular serial console on ucom is completely untested and likely broken 73 * as well as anyting that requires the modem control lines. 74 */ 75 76 #include <sys/stdint.h> 77 #include <sys/param.h> 78 #include <sys/queue.h> 79 #include <sys/types.h> 80 #include <sys/systm.h> 81 #include <sys/kernel.h> 82 #include <sys/bus.h> 83 #include <sys/module.h> 84 #include <sys/lock.h> 85 #include <sys/condvar.h> 86 #include <sys/sysctl.h> 87 #include <sys/unistd.h> 88 #include <sys/callout.h> 89 #include <sys/malloc.h> 90 #include <sys/priv.h> 91 #include <sys/cons.h> 92 #include <sys/serial.h> 93 #include <sys/thread2.h> 94 #include <sys/conf.h> 95 #include <sys/clist.h> 96 97 #include <bus/u4b/usb.h> 98 #include <bus/u4b/usbdi.h> 99 #include <bus/u4b/usbdi_util.h> 100 101 #define USB_DEBUG_VAR ucom_debug 102 #include <bus/u4b/usb_debug.h> 103 #include <bus/u4b/usb_busdma.h> 104 #include <bus/u4b/usb_process.h> 105 106 #include <bus/u4b/serial/usb_serial.h> 107 108 //#include "opt_gdb.h" 109 110 static SYSCTL_NODE(_hw_usb, OID_AUTO, ucom, CTLFLAG_RW, 0, "USB ucom"); 111 112 static int ucom_pps_mode; 113 114 SYSCTL_INT(_hw_usb_ucom, OID_AUTO, pps_mode, CTLFLAG_RW, 115 &ucom_pps_mode, 0, "pulse capturing mode - 0/1/2 - disabled/CTS/DCD"); 116 TUNABLE_INT("hw.usb.ucom.pss_mode", &ucom_pps_mode); 117 118 119 #ifdef USB_DEBUG 120 static int ucom_debug = 0; 121 122 SYSCTL_INT(_hw_usb_ucom, OID_AUTO, debug, CTLFLAG_RW, 123 &ucom_debug, 0, "ucom debug level"); 124 #endif 125 126 #define UCOM_CONS_BUFSIZE 1024 127 128 static uint8_t ucom_cons_rx_buf[UCOM_CONS_BUFSIZE]; 129 static uint8_t ucom_cons_tx_buf[UCOM_CONS_BUFSIZE]; 130 131 static unsigned int ucom_cons_rx_low = 0; 132 static unsigned int ucom_cons_rx_high = 0; 133 134 static unsigned int ucom_cons_tx_low = 0; 135 static unsigned int ucom_cons_tx_high = 0; 136 137 static int ucom_cons_unit = -1; 138 static int ucom_cons_subunit = 0; 139 static int ucom_cons_baud = 9600; 140 static struct ucom_softc *ucom_cons_softc = NULL; 141 142 TUNABLE_INT("hw.usb.ucom.cons_unit", &ucom_cons_unit); 143 SYSCTL_INT(_hw_usb_ucom, OID_AUTO, cons_unit, CTLFLAG_RW, 144 &ucom_cons_unit, 0, "console unit number"); 145 TUNABLE_INT("hw.usb.ucom.cons_subunit", &ucom_cons_subunit); 146 SYSCTL_INT(_hw_usb_ucom, OID_AUTO, cons_subunit, CTLFLAG_RW, 147 &ucom_cons_subunit, 0, "console subunit number"); 148 TUNABLE_INT("hw.usb.ucom.cons_baud", &ucom_cons_baud); 149 SYSCTL_INT(_hw_usb_ucom, OID_AUTO, cons_baud, CTLFLAG_RW, 150 &ucom_cons_baud, 0, "console baud rate"); 151 152 static usb_proc_callback_t ucom_cfg_start_transfers; 153 static usb_proc_callback_t ucom_cfg_open; 154 static usb_proc_callback_t ucom_cfg_close; 155 static usb_proc_callback_t ucom_cfg_line_state; 156 static usb_proc_callback_t ucom_cfg_status_change; 157 static usb_proc_callback_t ucom_cfg_param; 158 159 static int ucom_unit_alloc(void); 160 static void ucom_unit_free(int); 161 static int ucom_attach_tty(struct ucom_super_softc *, struct ucom_softc *); 162 static void ucom_detach_tty(struct ucom_super_softc *, struct ucom_softc *); 163 static void ucom_queue_command(struct ucom_softc *, 164 usb_proc_callback_t *, struct termios *pt, 165 struct usb_proc_msg *t0, struct usb_proc_msg *t1); 166 static void ucom_shutdown(struct ucom_softc *); 167 static void ucom_ring(struct ucom_softc *, uint8_t); 168 static void ucom_break(struct ucom_softc *, uint8_t); 169 static void ucom_dtr(struct ucom_softc *, uint8_t); 170 static void ucom_rts(struct ucom_softc *, uint8_t); 171 172 static int ucom_open(struct ucom_softc *sc); 173 static int ucom_close(struct ucom_softc *sc); 174 static void ucom_start(struct tty *tp); 175 static void ucom_stop(struct tty *tp, int); 176 static int ucom_param(struct tty *tp, struct termios *t); 177 static int ucom_modem(struct tty *tp, int sigon, int sigoff); 178 179 static int ucom_fromtio(int); 180 static int ucom_totio(int); 181 182 static void disc_optim(struct tty *, struct termios *, struct ucom_softc *); 183 184 static d_open_t ucom_dev_open; 185 static d_close_t ucom_dev_close; 186 static d_read_t ucom_dev_read; 187 static d_write_t ucom_dev_write; 188 static d_ioctl_t ucom_dev_ioctl; 189 190 static struct dev_ops ucom_ops = { 191 { "ucom", 0, D_MPSAFE | D_TTY }, 192 .d_open = ucom_dev_open, 193 .d_close = ucom_dev_close, 194 .d_read = ucom_dev_read, 195 .d_write = ucom_dev_write, 196 .d_ioctl = ucom_dev_ioctl, 197 .d_kqfilter = ttykqfilter, 198 .d_revoke = ttyrevoke 199 }; 200 201 static moduledata_t ucom_mod = { 202 "ucom", 203 NULL, 204 NULL 205 }; 206 207 DECLARE_MODULE(ucom, ucom_mod, SI_SUB_DRIVERS, SI_ORDER_MIDDLE); 208 MODULE_DEPEND(ucom, usb, 1, 1, 1); 209 MODULE_VERSION(ucom, UCOM_MODVER); 210 211 /* XXXDF */ 212 #define tty_gone(tp) ((tp->t_state) & (TS_ZOMBIE)) 213 214 #define UCOM_UNIT_MAX 128 /* maximum number of units */ 215 #define UCOM_TTY_PREFIX "ucom" 216 217 218 #define CALLOUT_MASK 0x80 219 #define CONTROL_MASK 0x60 220 #define CONTROL_INIT_STATE 0x20 221 #define CONTROL_LOCK_STATE 0x40 222 223 static struct unrhdr *ucom_unrhdr; 224 static struct lock ucom_lock; 225 static int ucom_close_refs; 226 227 static void 228 ucom_init(void *arg) 229 { 230 DPRINTF("\n"); 231 ucom_unrhdr = new_unrhdr(0, UCOM_UNIT_MAX - 1, NULL); 232 lockinit(&ucom_lock, "UCOM LOCK", 0, 0); 233 } 234 SYSINIT(ucom_init, SI_BOOT2_KLD - 1, SI_ORDER_ANY, ucom_init, NULL); 235 236 static void 237 ucom_uninit(void *arg) 238 { 239 struct unrhdr *hdr; 240 hdr = ucom_unrhdr; 241 ucom_unrhdr = NULL; 242 243 DPRINTF("\n"); 244 245 if (hdr != NULL) 246 delete_unrhdr(hdr); 247 248 lockuninit(&ucom_lock); 249 } 250 SYSUNINIT(ucom_uninit, SI_BOOT2_KLD - 2, SI_ORDER_ANY, ucom_uninit, NULL); 251 252 /* 253 * Mark a unit number (the X in cuaUX) as in use. 254 * 255 * Note that devices using a different naming scheme (see ucom_tty_name() 256 * callback) still use this unit allocation. 257 */ 258 static int 259 ucom_unit_alloc(void) 260 { 261 int unit; 262 263 /* sanity checks */ 264 if (ucom_unrhdr == NULL) { 265 DPRINTF("ucom_unrhdr is NULL\n"); 266 return (-1); 267 } 268 unit = alloc_unr(ucom_unrhdr); 269 DPRINTF("unit %d is allocated\n", unit); 270 return (unit); 271 } 272 273 /* 274 * Mark the unit number as not in use. 275 */ 276 static void 277 ucom_unit_free(int unit) 278 { 279 /* sanity checks */ 280 if (unit < 0 || unit >= UCOM_UNIT_MAX || ucom_unrhdr == NULL) { 281 DPRINTF("cannot free unit number\n"); 282 return; 283 } 284 DPRINTF("unit %d is freed\n", unit); 285 free_unr(ucom_unrhdr, unit); 286 } 287 288 /* 289 * Setup a group of one or more serial ports. 290 * 291 * The lock pointed to by "lock" is applied before all 292 * callbacks are called back. Also "lock" must be applied 293 * before calling into the ucom-layer! 294 */ 295 int 296 ucom_attach(struct ucom_super_softc *ssc, struct ucom_softc *sc, 297 int subunits, void *parent, 298 const struct ucom_callback *callback, struct lock *lock) 299 { 300 int subunit; 301 int error = 0; 302 303 if ((sc == NULL) || 304 (subunits <= 0) || 305 (callback == NULL) || 306 (lock == NULL)) { 307 return (EINVAL); 308 } 309 310 /* XXX Do we want our own lock here maybe */ 311 sc->sc_lock = lock; 312 313 /* allocate a uniq unit number */ 314 ssc->sc_unit = ucom_unit_alloc(); 315 if (ssc->sc_unit == -1) 316 return (ENOMEM); 317 318 /* generate TTY name string */ 319 ksnprintf(ssc->sc_ttyname, sizeof(ssc->sc_ttyname), 320 UCOM_TTY_PREFIX "%d", ssc->sc_unit); 321 322 /* create USB request handling process */ 323 error = usb_proc_create(&ssc->sc_tq, lock, "ucom", USB_PRI_MED); 324 if (error) { 325 ucom_unit_free(ssc->sc_unit); 326 return (error); 327 } 328 ssc->sc_subunits = subunits; 329 ssc->sc_flag = UCOM_FLAG_ATTACHED | 330 UCOM_FLAG_FREE_UNIT; 331 332 if (callback->ucom_free == NULL) 333 ssc->sc_flag |= UCOM_FLAG_WAIT_REFS; 334 335 /* increment reference count */ 336 ucom_ref(ssc); 337 338 for (subunit = 0; subunit < ssc->sc_subunits; subunit++) { 339 sc[subunit].sc_subunit = subunit; 340 sc[subunit].sc_super = ssc; 341 sc[subunit].sc_lock = lock; 342 sc[subunit].sc_parent = parent; 343 sc[subunit].sc_callback = callback; 344 345 error = ucom_attach_tty(ssc, &sc[subunit]); 346 if (error) { 347 ucom_detach(ssc, &sc[0]); 348 return (error); 349 } 350 /* increment reference count */ 351 ucom_ref(ssc); 352 353 /* set subunit attached */ 354 sc[subunit].sc_flag |= UCOM_FLAG_ATTACHED; 355 } 356 357 DPRINTF("tp = %p, unit = %d, subunits = %d\n", 358 sc->sc_tty, ssc->sc_unit, ssc->sc_subunits); 359 360 return (0); 361 } 362 363 /* 364 * The following function will do nothing if the structure pointed to 365 * by "ssc" and "sc" is zero or has already been detached. 366 */ 367 void 368 ucom_detach(struct ucom_super_softc *ssc, struct ucom_softc *sc) 369 { 370 int subunit; 371 372 if (!(ssc->sc_flag & UCOM_FLAG_ATTACHED)) 373 return; /* not initialized */ 374 375 destroy_dev(sc->sc_cdev); 376 destroy_dev(sc->sc_cdev_init); 377 destroy_dev(sc->sc_cdev_lock); 378 destroy_dev(sc->sc_cdev2); 379 destroy_dev(sc->sc_cdev2_init); 380 destroy_dev(sc->sc_cdev2_lock); 381 382 lwkt_gettoken(&tty_token); 383 384 if (ssc->sc_sysctl_ttyname != NULL) { 385 sysctl_remove_oid(ssc->sc_sysctl_ttyname, 1, 0); 386 ssc->sc_sysctl_ttyname = NULL; 387 } 388 389 if (ssc->sc_sysctl_ttyports != NULL) { 390 sysctl_remove_oid(ssc->sc_sysctl_ttyports, 1, 0); 391 ssc->sc_sysctl_ttyports = NULL; 392 } 393 394 usb_proc_drain(&ssc->sc_tq); 395 396 for (subunit = 0; subunit < ssc->sc_subunits; subunit++) { 397 if (sc[subunit].sc_flag & UCOM_FLAG_ATTACHED) { 398 ucom_detach_tty(ssc, &sc[subunit]); 399 400 /* avoid duplicate detach */ 401 sc[subunit].sc_flag &= ~UCOM_FLAG_ATTACHED; 402 } 403 } 404 usb_proc_free(&ssc->sc_tq); 405 406 ucom_unref(ssc); 407 408 if (ssc->sc_flag & UCOM_FLAG_WAIT_REFS) 409 ucom_drain(ssc); 410 411 /* make sure we don't detach twice */ 412 ssc->sc_flag &= ~UCOM_FLAG_ATTACHED; 413 414 lwkt_reltoken(&tty_token); 415 } 416 417 void 418 ucom_drain(struct ucom_super_softc *ssc) 419 { 420 lockmgr(&ucom_lock, LK_EXCLUSIVE); 421 while (ssc->sc_refs > 0) { 422 kprintf("ucom: Waiting for a TTY device to close.\n"); 423 usb_pause_mtx(&ucom_lock, hz); 424 } 425 lockmgr(&ucom_lock, LK_RELEASE); 426 } 427 428 void 429 ucom_drain_all(void *arg) 430 { 431 lockmgr(&ucom_lock, LK_EXCLUSIVE); 432 while (ucom_close_refs > 0) { 433 kprintf("ucom: Waiting for all detached TTY " 434 "devices to have open fds closed.\n"); 435 usb_pause_mtx(&ucom_lock, hz); 436 } 437 lockmgr(&ucom_lock, LK_RELEASE); 438 } 439 440 static int 441 ucom_attach_tty(struct ucom_super_softc *ssc, struct ucom_softc *sc) 442 { 443 struct tty *tp; 444 char buf[32]; /* temporary TTY device name buffer */ 445 446 lwkt_gettoken(&tty_token); 447 448 sc->sc_tty = tp = ttymalloc(sc->sc_tty); 449 450 if (tp == NULL) { 451 lwkt_reltoken(&tty_token); 452 return (ENOMEM); 453 } 454 455 tp->t_sc = (void *)sc; 456 457 tp->t_oproc = ucom_start; 458 tp->t_param = ucom_param; 459 tp->t_stop = ucom_stop; 460 461 /* Check if the client has a custom TTY name */ 462 buf[0] = '\0'; 463 if (sc->sc_callback->ucom_tty_name) { 464 sc->sc_callback->ucom_tty_name(sc, buf, 465 sizeof(buf), ssc->sc_unit, sc->sc_subunit); 466 } 467 if (buf[0] == 0) { 468 /* Use default TTY name */ 469 if (ssc->sc_subunits > 1) { 470 /* multiple modems in one */ 471 ksnprintf(buf, sizeof(buf), UCOM_TTY_PREFIX "%u.%u", 472 ssc->sc_unit, sc->sc_subunit); 473 } else { 474 /* single modem */ 475 ksnprintf(buf, sizeof(buf), UCOM_TTY_PREFIX "%u", 476 ssc->sc_unit); 477 } 478 } 479 480 sc->sc_cdev = make_dev(&ucom_ops, ssc->sc_unit, 481 UID_ROOT, GID_WHEEL, 0600, "ttyU%r", ssc->sc_unit); 482 sc->sc_cdev_init = make_dev(&ucom_ops, ssc->sc_unit | CONTROL_INIT_STATE, 483 UID_ROOT, GID_WHEEL, 0600, "ttyiU%r", ssc->sc_unit); 484 sc->sc_cdev_lock = make_dev(&ucom_ops, ssc->sc_unit | CONTROL_LOCK_STATE, 485 UID_ROOT, GID_WHEEL, 0600, "ttylU%r", ssc->sc_unit); 486 sc->sc_cdev2 = make_dev(&ucom_ops, ssc->sc_unit | CALLOUT_MASK, 487 UID_UUCP, GID_DIALER, 0660, "cuaU%r", ssc->sc_unit); 488 sc->sc_cdev2_init = make_dev(&ucom_ops, ssc->sc_unit | CALLOUT_MASK | CONTROL_INIT_STATE, 489 UID_UUCP, GID_DIALER, 0660, "cuaiU%r", ssc->sc_unit); 490 sc->sc_cdev2_lock = make_dev(&ucom_ops, ssc->sc_unit | CALLOUT_MASK | CONTROL_LOCK_STATE, 491 UID_UUCP, GID_DIALER, 0660, "cualU%r", ssc->sc_unit); 492 493 sc->sc_cdev->si_tty = tp; 494 sc->sc_cdev_init->si_tty = tp; 495 sc->sc_cdev_lock->si_tty = tp; 496 497 sc->sc_cdev->si_drv1 = sc; 498 sc->sc_cdev_init->si_drv1 = sc; 499 sc->sc_cdev_lock->si_drv1 = sc; 500 501 sc->sc_cdev2->si_tty = tp; 502 sc->sc_cdev2_init->si_tty = tp; 503 sc->sc_cdev2_lock->si_tty = tp; 504 505 sc->sc_cdev2->si_drv1 = sc; 506 sc->sc_cdev2_init->si_drv1 = sc; 507 sc->sc_cdev2_lock->si_drv1 = sc; 508 509 sc->sc_tty = tp; 510 511 DPRINTF("ttycreate: %s\n", buf); 512 513 /* Check if this device should be a console */ 514 if ((ucom_cons_softc == NULL) && 515 (ssc->sc_unit == ucom_cons_unit) && 516 (sc->sc_subunit == ucom_cons_subunit)) { 517 518 DPRINTF("unit %d subunit %d is console", 519 ssc->sc_unit, sc->sc_subunit); 520 521 ucom_cons_softc = sc; 522 523 /* XXXDF 524 tty_init_console(tp, ucom_cons_baud); 525 */ 526 tp->t_termios.c_ispeed = ucom_cons_baud; 527 tp->t_termios.c_ospeed = ucom_cons_baud; 528 529 UCOM_MTX_LOCK(ucom_cons_softc); 530 ucom_cons_rx_low = 0; 531 ucom_cons_rx_high = 0; 532 ucom_cons_tx_low = 0; 533 ucom_cons_tx_high = 0; 534 sc->sc_flag |= UCOM_FLAG_CONSOLE; 535 536 ucom_open(ucom_cons_softc); 537 ucom_param(tp, &tp->t_termios); 538 UCOM_MTX_UNLOCK(ucom_cons_softc); 539 } 540 541 lwkt_reltoken(&tty_token); 542 return (0); 543 } 544 545 static void 546 ucom_detach_tty(struct ucom_super_softc *ssc, struct ucom_softc *sc) 547 { 548 struct tty *tp = sc->sc_tty; 549 550 DPRINTF("sc = %p, tp = %p\n", sc, sc->sc_tty); 551 552 if (sc->sc_flag & UCOM_FLAG_CONSOLE) { 553 UCOM_MTX_LOCK(ucom_cons_softc); 554 ucom_close(ucom_cons_softc); 555 sc->sc_flag &= ~UCOM_FLAG_CONSOLE; 556 UCOM_MTX_UNLOCK(ucom_cons_softc); 557 ucom_cons_softc = NULL; 558 } 559 560 /* the config thread has been stopped when we get here */ 561 562 UCOM_MTX_LOCK(sc); 563 sc->sc_flag |= UCOM_FLAG_GONE; 564 sc->sc_flag &= ~(UCOM_FLAG_HL_READY | UCOM_FLAG_LL_READY); 565 UCOM_MTX_UNLOCK(sc); 566 567 lwkt_gettoken(&tty_token); 568 if (tp != NULL) { 569 ucom_close_refs++; 570 571 UCOM_MTX_LOCK(sc); 572 if (tp->t_state & TS_ISOPEN) { 573 kprintf("device still open, forcing close\n"); 574 (*linesw[tp->t_line].l_close)(tp, 0); 575 ttyclose(tp); 576 } 577 ucom_close(sc); /* close, if any */ 578 579 /* 580 * make sure that read and write transfers are stopped 581 */ 582 if (sc->sc_callback->ucom_stop_read) { 583 (sc->sc_callback->ucom_stop_read) (sc); 584 } 585 if (sc->sc_callback->ucom_stop_write) { 586 (sc->sc_callback->ucom_stop_write) (sc); 587 } 588 UCOM_MTX_UNLOCK(sc); 589 } else { 590 DPRINTF("no tty\n"); 591 } 592 593 dev_ops_remove_minor(&ucom_ops,ssc->sc_unit); 594 595 lwkt_reltoken(&tty_token); 596 ucom_unref(ssc); 597 } 598 599 void 600 ucom_set_pnpinfo_usb(struct ucom_super_softc *ssc, device_t dev) 601 { 602 char buf[64]; 603 uint8_t iface_index; 604 struct usb_attach_arg *uaa; 605 606 ksnprintf(buf, sizeof(buf), "ttyname=" UCOM_TTY_PREFIX 607 "%d ttyports=%d", ssc->sc_unit, ssc->sc_subunits); 608 609 /* Store the PNP info in the first interface for the device */ 610 uaa = device_get_ivars(dev); 611 iface_index = uaa->info.bIfaceIndex; 612 613 if (usbd_set_pnpinfo(uaa->device, iface_index, buf) != 0) 614 device_printf(dev, "Could not set PNP info\n"); 615 616 /* 617 * The following information is also replicated in the PNP-info 618 * string which is registered above: 619 */ 620 if (ssc->sc_sysctl_ttyname == NULL) { 621 /* 622 ssc->sc_sysctl_ttyname = SYSCTL_ADD_STRING(NULL, 623 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 624 OID_AUTO, "ttyname", CTLFLAG_RD, ssc->sc_ttyname, 0, 625 "TTY device basename"); 626 */ 627 } 628 if (ssc->sc_sysctl_ttyports == NULL) { 629 /* 630 ssc->sc_sysctl_ttyports = SYSCTL_ADD_INT(NULL, 631 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 632 OID_AUTO, "ttyports", CTLFLAG_RD, 633 NULL, ssc->sc_subunits, "Number of ports"); 634 */ 635 } 636 } 637 638 static void 639 ucom_queue_command(struct ucom_softc *sc, 640 usb_proc_callback_t *fn, struct termios *pt, 641 struct usb_proc_msg *t0, struct usb_proc_msg *t1) 642 { 643 struct ucom_super_softc *ssc = sc->sc_super; 644 struct ucom_param_task *task; 645 646 UCOM_MTX_ASSERT(sc, MA_OWNED); 647 648 if (usb_proc_is_gone(&ssc->sc_tq)) { 649 DPRINTF("proc is gone\n"); 650 return; /* nothing to do */ 651 } 652 /* 653 * NOTE: The task cannot get executed before we drop the 654 * "sc_lock" lock. It is safe to update fields in the message 655 * structure after that the message got queued. 656 */ 657 task = (struct ucom_param_task *) 658 usb_proc_msignal(&ssc->sc_tq, t0, t1); 659 660 /* Setup callback and softc pointers */ 661 task->hdr.pm_callback = fn; 662 task->sc = sc; 663 664 /* 665 * Make a copy of the termios. This field is only present if 666 * the "pt" field is not NULL. 667 */ 668 if (pt != NULL) 669 task->termios_copy = *pt; 670 671 /* 672 * Closing the device should be synchronous. 673 */ 674 if (fn == ucom_cfg_close) 675 usb_proc_mwait(&ssc->sc_tq, t0, t1); 676 677 /* 678 * In case of multiple configure requests, 679 * keep track of the last one! 680 */ 681 if (fn == ucom_cfg_start_transfers) 682 sc->sc_last_start_xfer = &task->hdr; 683 } 684 685 static void 686 ucom_shutdown(struct ucom_softc *sc) 687 { 688 struct tty *tp = sc->sc_tty; 689 690 UCOM_MTX_ASSERT(sc, MA_OWNED); 691 692 DPRINTF("\n"); 693 694 /* 695 * Hang up if necessary: 696 */ 697 if (tp->t_termios.c_cflag & HUPCL) { 698 ucom_modem(tp, 0, SER_DTR); 699 } 700 } 701 702 /* 703 * Return values: 704 * 0: normal 705 * else: taskqueue is draining or gone 706 */ 707 uint8_t 708 ucom_cfg_is_gone(struct ucom_softc *sc) 709 { 710 struct ucom_super_softc *ssc = sc->sc_super; 711 712 return (usb_proc_is_gone(&ssc->sc_tq)); 713 } 714 715 static void 716 ucom_cfg_start_transfers(struct usb_proc_msg *_task) 717 { 718 struct ucom_cfg_task *task = 719 (struct ucom_cfg_task *)_task; 720 struct ucom_softc *sc = task->sc; 721 722 if (!(sc->sc_flag & UCOM_FLAG_LL_READY)) { 723 return; 724 } 725 if (!(sc->sc_flag & UCOM_FLAG_HL_READY)) { 726 /* TTY device closed */ 727 return; 728 } 729 730 if (_task == sc->sc_last_start_xfer) 731 sc->sc_flag |= UCOM_FLAG_GP_DATA; 732 733 if (sc->sc_callback->ucom_start_read) { 734 (sc->sc_callback->ucom_start_read) (sc); 735 } 736 if (sc->sc_callback->ucom_start_write) { 737 (sc->sc_callback->ucom_start_write) (sc); 738 } 739 } 740 741 static void 742 ucom_start_transfers(struct ucom_softc *sc) 743 { 744 if (!(sc->sc_flag & UCOM_FLAG_HL_READY)) { 745 return; 746 } 747 /* 748 * Make sure that data transfers are started in both 749 * directions: 750 */ 751 if (sc->sc_callback->ucom_start_read) { 752 (sc->sc_callback->ucom_start_read) (sc); 753 } 754 if (sc->sc_callback->ucom_start_write) { 755 (sc->sc_callback->ucom_start_write) (sc); 756 } 757 } 758 759 static void 760 ucom_cfg_open(struct usb_proc_msg *_task) 761 { 762 struct ucom_cfg_task *task = 763 (struct ucom_cfg_task *)_task; 764 struct ucom_softc *sc = task->sc; 765 766 DPRINTF("\n"); 767 768 if (sc->sc_flag & UCOM_FLAG_LL_READY) { 769 770 /* already opened */ 771 772 } else { 773 774 sc->sc_flag |= UCOM_FLAG_LL_READY; 775 776 if (sc->sc_callback->ucom_cfg_open) { 777 (sc->sc_callback->ucom_cfg_open) (sc); 778 779 /* wait a little */ 780 usb_pause_mtx(sc->sc_lock, hz / 10); 781 } 782 } 783 } 784 785 static int 786 ucom_dev_open(struct dev_open_args *ap) 787 { 788 cdev_t dev = ap->a_head.a_dev; 789 struct ucom_softc *sc = (struct ucom_softc *)dev->si_drv1; 790 int error; 791 int mynor; 792 793 error = 0; 794 mynor = minor(dev); 795 796 UCOM_MTX_LOCK(sc); 797 error = ucom_open(sc); 798 UCOM_MTX_UNLOCK(sc); 799 800 return error; 801 } 802 803 static int 804 ucom_open(struct ucom_softc *sc) 805 { 806 int error; 807 struct tty *tp; 808 809 int mynor; 810 811 mynor = minor(sc->sc_cdev); 812 813 if (sc->sc_flag & UCOM_FLAG_GONE) { 814 return (ENXIO); 815 } 816 if (sc->sc_flag & UCOM_FLAG_HL_READY) { 817 /* already opened */ 818 return (0); 819 } 820 DPRINTF("tp = %p\n", sc->sc_tty); 821 822 if (sc->sc_callback->ucom_pre_open) { 823 /* 824 * give the lower layer a chance to disallow TTY open, for 825 * example if the device is not present: 826 */ 827 error = (sc->sc_callback->ucom_pre_open) (sc); 828 if (error) { 829 return (error); 830 } 831 } 832 sc->sc_flag |= UCOM_FLAG_HL_READY; 833 834 lwkt_gettoken(&tty_token); 835 tp = sc->sc_tty; 836 837 crit_enter(); 838 839 if (!ISSET(tp->t_state, TS_ISOPEN)) { 840 struct termios t; 841 842 tp->t_dev = reference_dev(sc->sc_cdev); 843 844 t = mynor & CALLOUT_MASK ? sc->sc_it_out : sc->sc_it_in; 845 846 tp->t_ospeed = 0; 847 ucom_param(tp, &t); 848 tp->t_iflag = TTYDEF_IFLAG; 849 tp->t_oflag = TTYDEF_OFLAG; 850 tp->t_lflag = TTYDEF_LFLAG; 851 ttychars(tp); 852 ttsetwater(tp); 853 854 /* Disable transfers */ 855 sc->sc_flag &= ~UCOM_FLAG_GP_DATA; 856 857 sc->sc_lsr = 0; 858 sc->sc_msr = 0; 859 sc->sc_mcr = 0; 860 861 /* reset programmed line state */ 862 sc->sc_pls_curr = 0; 863 sc->sc_pls_set = 0; 864 sc->sc_pls_clr = 0; 865 866 /* reset jitter buffer */ 867 sc->sc_jitterbuf_in = 0; 868 sc->sc_jitterbuf_out = 0; 869 870 ucom_queue_command(sc, ucom_cfg_open, NULL, 871 &sc->sc_open_task[0].hdr, 872 &sc->sc_open_task[1].hdr); 873 874 /* Queue transfer enable command last */ 875 ucom_queue_command(sc, ucom_cfg_start_transfers, NULL, 876 &sc->sc_start_task[0].hdr, 877 &sc->sc_start_task[1].hdr); 878 879 ucom_modem(sc->sc_tty, SER_DTR | SER_RTS, 0); 880 881 ucom_ring(sc, 0); 882 883 ucom_break(sc, 0); 884 885 ucom_status_change(sc); 886 887 if (ISSET(sc->sc_msr, SER_DCD)) { 888 (*linesw[tp->t_line].l_modem)(tp, 1); 889 } 890 } 891 crit_exit(); 892 893 error = ttyopen(sc->sc_cdev, tp); 894 if (error) { 895 lwkt_reltoken(&tty_token); 896 return (error); 897 } 898 899 error = (*linesw[tp->t_line].l_open)(sc->sc_cdev, tp); 900 if (error) { 901 lwkt_reltoken(&tty_token); 902 return (error); 903 } 904 905 disc_optim(tp, &tp->t_termios, sc); 906 907 lwkt_reltoken(&tty_token); 908 909 return (0); 910 } 911 912 static void 913 ucom_cfg_close(struct usb_proc_msg *_task) 914 { 915 struct ucom_cfg_task *task = 916 (struct ucom_cfg_task *)_task; 917 struct ucom_softc *sc = task->sc; 918 919 DPRINTF("\n"); 920 921 if (sc->sc_flag & UCOM_FLAG_LL_READY) { 922 sc->sc_flag &= ~UCOM_FLAG_LL_READY; 923 if (sc->sc_callback->ucom_cfg_close) 924 (sc->sc_callback->ucom_cfg_close) (sc); 925 } else { 926 /* already closed */ 927 } 928 } 929 930 static int 931 ucom_dev_close(struct dev_close_args *ap) 932 { 933 cdev_t dev = ap->a_head.a_dev; 934 struct ucom_softc *sc = (struct ucom_softc *)dev->si_drv1; 935 int error; 936 937 UCOM_MTX_LOCK(sc); 938 error = ucom_close(sc); 939 UCOM_MTX_UNLOCK(sc); 940 941 return error; 942 } 943 944 static int 945 ucom_close(struct ucom_softc *sc) 946 { 947 struct tty *tp = sc->sc_tty; 948 int error = 0; 949 950 DPRINTF("tp=%p\n", tp); 951 952 if (!(sc->sc_flag & UCOM_FLAG_HL_READY)) { 953 DPRINTF("tp=%p already closed\n", tp); 954 return (error); 955 } 956 if (!ISSET(tp->t_state, TS_ISOPEN)) { 957 return(error); 958 } 959 ucom_shutdown(sc); 960 961 ucom_queue_command(sc, ucom_cfg_close, NULL, 962 &sc->sc_close_task[0].hdr, 963 &sc->sc_close_task[1].hdr); 964 965 sc->sc_flag &= ~(UCOM_FLAG_HL_READY | UCOM_FLAG_RTS_IFLOW); 966 967 if (sc->sc_callback->ucom_stop_read) { 968 (sc->sc_callback->ucom_stop_read) (sc); 969 } 970 971 lwkt_gettoken(&tty_token); 972 crit_enter(); 973 (*linesw[tp->t_line].l_close)(tp, 0); /* XXX: flags */ 974 disc_optim(tp, &tp->t_termios, sc); 975 ttyclose(tp); 976 crit_exit(); 977 978 if (tp->t_dev) { 979 release_dev(tp->t_dev); 980 tp->t_dev = NULL; 981 } 982 /* XXX: Detach wakeup */ 983 lwkt_reltoken(&tty_token); 984 985 return (error); 986 } 987 988 #if 0 /* XXX */ 989 static void 990 ucom_inwakeup(struct tty *tp) 991 { 992 struct ucom_softc *sc = tty_softc(tp); 993 uint16_t pos; 994 995 if (sc == NULL) 996 return; 997 998 UCOM_MTX_ASSERT(sc, MA_OWNED); 999 1000 DPRINTF("tp=%p\n", tp); 1001 1002 if (ttydisc_can_bypass(tp) != 0 || 1003 (sc->sc_flag & UCOM_FLAG_HL_READY) == 0 || 1004 (sc->sc_flag & UCOM_FLAG_INWAKEUP) != 0) { 1005 return; 1006 } 1007 1008 /* prevent recursion */ 1009 sc->sc_flag |= UCOM_FLAG_INWAKEUP; 1010 1011 pos = sc->sc_jitterbuf_out; 1012 1013 while (sc->sc_jitterbuf_in != pos) { 1014 int c; 1015 1016 c = (char)sc->sc_jitterbuf[pos]; 1017 1018 if (ttydisc_rint(tp, c, 0) == -1) 1019 break; 1020 pos++; 1021 if (pos >= UCOM_JITTERBUF_SIZE) 1022 pos -= UCOM_JITTERBUF_SIZE; 1023 } 1024 1025 sc->sc_jitterbuf_out = pos; 1026 1027 /* clear RTS in async fashion */ 1028 if ((sc->sc_jitterbuf_in == pos) && 1029 (sc->sc_flag & UCOM_FLAG_RTS_IFLOW)) 1030 ucom_rts(sc, 0); 1031 1032 sc->sc_flag &= ~UCOM_FLAG_INWAKEUP; 1033 } 1034 #endif 1035 1036 static int 1037 ucom_dev_read(struct dev_read_args *ap) 1038 { 1039 cdev_t dev = ap->a_head.a_dev; 1040 struct ucom_softc *sc; 1041 struct tty *tp; 1042 int error; 1043 1044 sc = 0; 1045 1046 lwkt_gettoken(&tty_token); 1047 1048 tp = dev->si_tty; 1049 KKASSERT(tp!=NULL); 1050 sc = tp->t_sc; 1051 KKASSERT(sc!=NULL); 1052 1053 DPRINTF("tp = %p, flag = 0x%x\n", tp, ap->a_ioflag); 1054 1055 /* must not be locked in case it blocks */ 1056 /*UCOM_MTX_LOCK(sc);*/ 1057 error = (*linesw[tp->t_line].l_read)(tp, ap->a_uio, ap->a_ioflag); 1058 /*UCOM_MTX_UNLOCK(sc);*/ 1059 1060 DPRINTF("error = %d\n", error); 1061 1062 lwkt_reltoken(&tty_token); 1063 return (error); 1064 } 1065 1066 static int 1067 ucom_dev_write(struct dev_write_args *ap) 1068 { 1069 cdev_t dev = ap->a_head.a_dev; 1070 struct ucom_softc *sc; 1071 struct tty *tp; 1072 int error; 1073 1074 lwkt_gettoken(&tty_token); 1075 tp = dev->si_tty; 1076 KKASSERT(tp!=NULL); 1077 sc = tp->t_sc; 1078 KKASSERT(sc!=NULL); 1079 1080 DPRINTF("tp = %p, flag = 0x%x\n", tp, ap->a_ioflag); 1081 1082 /* must not be locked in case it blocks */ 1083 /*UCOM_MTX_LOCK(sc);*/ 1084 error = (*linesw[tp->t_line].l_write)(tp, ap->a_uio, ap->a_ioflag); 1085 /*UCOM_MTX_UNLOCK(sc);*/ 1086 1087 DPRINTF("ucomwrite: error = %d\n", error); 1088 1089 lwkt_reltoken(&tty_token); 1090 return (error); 1091 } 1092 1093 static int 1094 ucom_dev_ioctl(struct dev_ioctl_args *ap) 1095 { 1096 cdev_t dev = ap->a_head.a_dev; 1097 struct ucom_softc *sc = (struct ucom_softc *)dev->si_drv1; 1098 u_long cmd = ap->a_cmd; 1099 caddr_t data = ap->a_data; 1100 struct tty *tp = sc->sc_tty; 1101 int d; 1102 int error; 1103 int mynor; 1104 1105 UCOM_MTX_LOCK(sc); 1106 lwkt_gettoken(&tty_token); 1107 1108 mynor = minor(dev); 1109 1110 if (!(sc->sc_flag & UCOM_FLAG_HL_READY)) { 1111 lwkt_reltoken(&tty_token); 1112 UCOM_MTX_UNLOCK(sc); 1113 return (EIO); 1114 } 1115 DPRINTF("cmd = 0x%08lx\n", cmd); 1116 if (mynor & CONTROL_MASK) { 1117 struct termios *ct; 1118 1119 switch (mynor & CONTROL_MASK) { 1120 case CONTROL_INIT_STATE: 1121 ct = mynor & CALLOUT_MASK ? &sc->sc_it_out : &sc->sc_it_in; 1122 break; 1123 case CONTROL_LOCK_STATE: 1124 ct = mynor & CALLOUT_MASK ? &sc->sc_lt_out : &sc->sc_lt_in; 1125 break; 1126 default: 1127 lwkt_reltoken(&tty_token); 1128 UCOM_MTX_UNLOCK(sc); 1129 return (ENODEV); /* /dev/nodev */ 1130 } 1131 switch (ap->a_cmd) { 1132 case TIOCSETA: 1133 error = priv_check_cred(ap->a_cred, PRIV_ROOT, 0); 1134 if (error != 0) { 1135 lwkt_reltoken(&tty_token); 1136 UCOM_MTX_UNLOCK(sc); 1137 return (error); 1138 } 1139 *ct = *(struct termios *)data; 1140 lwkt_reltoken(&tty_token); 1141 UCOM_MTX_UNLOCK(sc); 1142 return (0); 1143 case TIOCGETA: 1144 *(struct termios *)data = *ct; 1145 lwkt_reltoken(&tty_token); 1146 UCOM_MTX_UNLOCK(sc); 1147 return (0); 1148 case TIOCGETD: 1149 *(int *)data = TTYDISC; 1150 lwkt_reltoken(&tty_token); 1151 UCOM_MTX_UNLOCK(sc); 1152 return (0); 1153 case TIOCGWINSZ: 1154 bzero(data, sizeof(struct winsize)); 1155 lwkt_reltoken(&tty_token); 1156 UCOM_MTX_UNLOCK(sc); 1157 return (0); 1158 default: 1159 lwkt_reltoken(&tty_token); 1160 UCOM_MTX_UNLOCK(sc); 1161 return (ENOTTY); 1162 } 1163 } 1164 1165 error = (*linesw[tp->t_line].l_ioctl)(tp, ap->a_cmd, ap->a_data, 1166 ap->a_fflag, ap->a_cred); 1167 1168 if (error != ENOIOCTL) { 1169 DPRINTF("ucomioctl: l_ioctl: error = %d\n", error); 1170 lwkt_reltoken(&tty_token); 1171 UCOM_MTX_UNLOCK(sc); 1172 return (error); 1173 } 1174 1175 crit_enter(); 1176 1177 error = ttioctl(tp, ap->a_cmd, ap->a_data, ap->a_fflag); 1178 disc_optim(tp, &tp->t_termios, sc); 1179 if (error != ENOIOCTL) { 1180 crit_exit(); 1181 DPRINTF("ucomioctl: ttioctl: error = %d\n", error); 1182 lwkt_reltoken(&tty_token); 1183 UCOM_MTX_UNLOCK(sc); 1184 1185 return (error); 1186 } 1187 1188 error = 0; 1189 1190 switch (cmd) { 1191 #if 0 /* XXXDF */ 1192 case TIOCSRING: 1193 ucom_ring(sc, 1); 1194 error = 0; 1195 break; 1196 case TIOCCRING: 1197 ucom_ring(sc, 0); 1198 error = 0; 1199 break; 1200 #endif 1201 case TIOCSBRK: 1202 ucom_break(sc, 1); 1203 error = 0; 1204 break; 1205 case TIOCCBRK: 1206 ucom_break(sc, 0); 1207 error = 0; 1208 break; 1209 case TIOCSDTR: 1210 ucom_dtr(sc, 1); 1211 break; 1212 case TIOCCDTR: 1213 ucom_dtr(sc, 0); 1214 break; 1215 case TIOCMSET: 1216 d = *(int *)ap->a_data; 1217 DPRINTF("ucomioctl: TIOCMSET, 0x%x\n", d); 1218 ucom_modem(tp, ucom_fromtio(d), 0); 1219 break; 1220 case TIOCMGET: 1221 d = ucom_modem(tp, 0, 0); 1222 DPRINTF("ucomioctl: TIOCMGET, 0x%x\n", d); 1223 *(int *)ap->a_data = ucom_totio(d); 1224 ucom_status_change(sc); 1225 break; 1226 case TIOCMBIS: 1227 d = *(int *)ap->a_data; 1228 ucom_modem(tp, ucom_fromtio(d), 0); 1229 break; 1230 case TIOCMBIC: 1231 d = *(int *)ap->a_data; 1232 ucom_modem(tp, 0, ucom_fromtio(d)); 1233 break; 1234 default: 1235 if (sc->sc_callback->ucom_ioctl) { 1236 error = (sc->sc_callback->ucom_ioctl) 1237 (sc, cmd, data, 0, curthread); 1238 if (error>=0) { 1239 crit_exit(); 1240 1241 lwkt_reltoken(&tty_token); 1242 UCOM_MTX_UNLOCK(sc); 1243 1244 return(error); 1245 } 1246 } else { 1247 error = ENOIOCTL; 1248 } 1249 if (error == ENOIOCTL) 1250 error = pps_ioctl(cmd, data, &sc->sc_pps); 1251 break; 1252 } 1253 crit_exit(); 1254 1255 lwkt_reltoken(&tty_token); 1256 UCOM_MTX_UNLOCK(sc); 1257 1258 return (error); 1259 } 1260 1261 static int 1262 ucom_totio(int bits) 1263 { 1264 int rbits = 0; 1265 1266 SET(bits, TIOCM_LE); 1267 1268 if (ISSET(bits, SER_DTR)) { 1269 SET(rbits, TIOCM_DTR); 1270 } 1271 if (ISSET(bits, SER_RTS)) { 1272 SET(rbits, TIOCM_RTS); 1273 } 1274 if (ISSET(bits, SER_CTS)) { 1275 SET(rbits, TIOCM_CTS); 1276 } 1277 if (ISSET(bits, SER_DCD)) { 1278 SET(rbits, TIOCM_CD); 1279 } 1280 if (ISSET(bits, SER_DSR)) { 1281 SET(rbits, TIOCM_DSR); 1282 } 1283 if (ISSET(bits, SER_RI)) { 1284 SET(rbits, TIOCM_RI); 1285 } 1286 1287 return (rbits); 1288 } 1289 1290 static int 1291 ucom_fromtio(int bits) 1292 { 1293 int rbits = 0; 1294 1295 if (ISSET(bits, TIOCM_DTR)) { 1296 SET(rbits, SER_DTR); 1297 } 1298 if (ISSET(bits, TIOCM_RTS)) { 1299 SET(rbits, SER_RTS); 1300 } 1301 if (ISSET(bits, TIOCM_CTS)) { 1302 SET(rbits, SER_CTS); 1303 } 1304 if (ISSET(bits, TIOCM_CD)) { 1305 SET(rbits, SER_DCD); 1306 } 1307 if (ISSET(bits, TIOCM_DSR)) { 1308 SET(rbits, SER_DSR); 1309 } 1310 if (ISSET(bits, TIOCM_RI)) { 1311 SET(rbits, SER_RI); 1312 } 1313 1314 return (rbits); 1315 } 1316 1317 static int 1318 ucom_modem(struct tty *tp, int sigon, int sigoff) 1319 { 1320 struct ucom_softc *sc = (struct ucom_softc *)tp->t_sc; 1321 uint8_t onoff; 1322 1323 UCOM_MTX_ASSERT(sc, MA_OWNED); 1324 1325 if (!(sc->sc_flag & UCOM_FLAG_HL_READY)) { 1326 return (0); 1327 } 1328 if ((sigon == 0) && (sigoff == 0)) { 1329 1330 if (sc->sc_mcr & SER_DTR) { 1331 sigon |= SER_DTR; 1332 } 1333 if (sc->sc_mcr & SER_RTS) { 1334 sigon |= SER_RTS; 1335 } 1336 if (sc->sc_msr & SER_CTS) { 1337 sigon |= SER_CTS; 1338 } 1339 if (sc->sc_msr & SER_DCD) { 1340 sigon |= SER_DCD; 1341 } 1342 if (sc->sc_msr & SER_DSR) { 1343 sigon |= SER_DSR; 1344 } 1345 if (sc->sc_msr & SER_RI) { 1346 sigon |= SER_RI; 1347 } 1348 return (sigon); 1349 } 1350 if (sigon & SER_DTR) { 1351 sc->sc_mcr |= SER_DTR; 1352 } 1353 if (sigoff & SER_DTR) { 1354 sc->sc_mcr &= ~SER_DTR; 1355 } 1356 if (sigon & SER_RTS) { 1357 sc->sc_mcr |= SER_RTS; 1358 } 1359 if (sigoff & SER_RTS) { 1360 sc->sc_mcr &= ~SER_RTS; 1361 } 1362 onoff = (sc->sc_mcr & SER_DTR) ? 1 : 0; 1363 ucom_dtr(sc, onoff); 1364 1365 onoff = (sc->sc_mcr & SER_RTS) ? 1 : 0; 1366 ucom_rts(sc, onoff); 1367 1368 return (0); 1369 } 1370 1371 static void 1372 ucom_cfg_line_state(struct usb_proc_msg *_task) 1373 { 1374 struct ucom_cfg_task *task = 1375 (struct ucom_cfg_task *)_task; 1376 struct ucom_softc *sc = task->sc; 1377 uint8_t notch_bits; 1378 uint8_t any_bits; 1379 uint8_t prev_value; 1380 uint8_t last_value; 1381 uint8_t mask; 1382 1383 if (!(sc->sc_flag & UCOM_FLAG_LL_READY)) { 1384 return; 1385 } 1386 1387 mask = 0; 1388 /* compute callback mask */ 1389 if (sc->sc_callback->ucom_cfg_set_dtr) 1390 mask |= UCOM_LS_DTR; 1391 if (sc->sc_callback->ucom_cfg_set_rts) 1392 mask |= UCOM_LS_RTS; 1393 if (sc->sc_callback->ucom_cfg_set_break) 1394 mask |= UCOM_LS_BREAK; 1395 if (sc->sc_callback->ucom_cfg_set_ring) 1396 mask |= UCOM_LS_RING; 1397 1398 /* compute the bits we are to program */ 1399 notch_bits = (sc->sc_pls_set & sc->sc_pls_clr) & mask; 1400 any_bits = (sc->sc_pls_set | sc->sc_pls_clr) & mask; 1401 prev_value = sc->sc_pls_curr ^ notch_bits; 1402 last_value = sc->sc_pls_curr; 1403 1404 /* reset programmed line state */ 1405 sc->sc_pls_curr = 0; 1406 sc->sc_pls_set = 0; 1407 sc->sc_pls_clr = 0; 1408 1409 /* ensure that we don't lose any levels */ 1410 if (notch_bits & UCOM_LS_DTR) 1411 sc->sc_callback->ucom_cfg_set_dtr(sc, 1412 (prev_value & UCOM_LS_DTR) ? 1 : 0); 1413 if (notch_bits & UCOM_LS_RTS) 1414 sc->sc_callback->ucom_cfg_set_rts(sc, 1415 (prev_value & UCOM_LS_RTS) ? 1 : 0); 1416 if (notch_bits & UCOM_LS_BREAK) 1417 sc->sc_callback->ucom_cfg_set_break(sc, 1418 (prev_value & UCOM_LS_BREAK) ? 1 : 0); 1419 if (notch_bits & UCOM_LS_RING) 1420 sc->sc_callback->ucom_cfg_set_ring(sc, 1421 (prev_value & UCOM_LS_RING) ? 1 : 0); 1422 1423 /* set last value */ 1424 if (any_bits & UCOM_LS_DTR) 1425 sc->sc_callback->ucom_cfg_set_dtr(sc, 1426 (last_value & UCOM_LS_DTR) ? 1 : 0); 1427 if (any_bits & UCOM_LS_RTS) 1428 sc->sc_callback->ucom_cfg_set_rts(sc, 1429 (last_value & UCOM_LS_RTS) ? 1 : 0); 1430 if (any_bits & UCOM_LS_BREAK) 1431 sc->sc_callback->ucom_cfg_set_break(sc, 1432 (last_value & UCOM_LS_BREAK) ? 1 : 0); 1433 if (any_bits & UCOM_LS_RING) 1434 sc->sc_callback->ucom_cfg_set_ring(sc, 1435 (last_value & UCOM_LS_RING) ? 1 : 0); 1436 } 1437 1438 static void 1439 ucom_line_state(struct ucom_softc *sc, 1440 uint8_t set_bits, uint8_t clear_bits) 1441 { 1442 UCOM_MTX_ASSERT(sc, MA_OWNED); 1443 1444 if (!(sc->sc_flag & UCOM_FLAG_HL_READY)) { 1445 return; 1446 } 1447 1448 DPRINTF("on=0x%02x, off=0x%02x\n", set_bits, clear_bits); 1449 1450 /* update current programmed line state */ 1451 sc->sc_pls_curr |= set_bits; 1452 sc->sc_pls_curr &= ~clear_bits; 1453 sc->sc_pls_set |= set_bits; 1454 sc->sc_pls_clr |= clear_bits; 1455 1456 /* defer driver programming */ 1457 ucom_queue_command(sc, ucom_cfg_line_state, NULL, 1458 &sc->sc_line_state_task[0].hdr, 1459 &sc->sc_line_state_task[1].hdr); 1460 } 1461 1462 static void 1463 ucom_ring(struct ucom_softc *sc, uint8_t onoff) 1464 { 1465 DPRINTF("onoff = %d\n", onoff); 1466 1467 if (onoff) 1468 ucom_line_state(sc, UCOM_LS_RING, 0); 1469 else 1470 ucom_line_state(sc, 0, UCOM_LS_RING); 1471 } 1472 1473 static void 1474 ucom_break(struct ucom_softc *sc, uint8_t onoff) 1475 { 1476 DPRINTF("onoff = %d\n", onoff); 1477 1478 if (onoff) 1479 ucom_line_state(sc, UCOM_LS_BREAK, 0); 1480 else 1481 ucom_line_state(sc, 0, UCOM_LS_BREAK); 1482 } 1483 1484 static void 1485 ucom_dtr(struct ucom_softc *sc, uint8_t onoff) 1486 { 1487 DPRINTF("onoff = %d\n", onoff); 1488 1489 if (onoff) 1490 ucom_line_state(sc, UCOM_LS_DTR, 0); 1491 else 1492 ucom_line_state(sc, 0, UCOM_LS_DTR); 1493 } 1494 1495 static void 1496 ucom_rts(struct ucom_softc *sc, uint8_t onoff) 1497 { 1498 DPRINTF("onoff = %d\n", onoff); 1499 1500 if (onoff) 1501 ucom_line_state(sc, UCOM_LS_RTS, 0); 1502 else 1503 ucom_line_state(sc, 0, UCOM_LS_RTS); 1504 } 1505 1506 static void 1507 ucom_cfg_status_change(struct usb_proc_msg *_task) 1508 { 1509 struct ucom_cfg_task *task = 1510 (struct ucom_cfg_task *)_task; 1511 struct ucom_softc *sc = task->sc; 1512 struct tty *tp; 1513 uint8_t new_msr; 1514 uint8_t new_lsr; 1515 uint8_t msr_delta; 1516 uint8_t lsr_delta; 1517 1518 tp = sc->sc_tty; 1519 1520 UCOM_MTX_ASSERT(sc, MA_OWNED); 1521 1522 if (!(sc->sc_flag & UCOM_FLAG_LL_READY)) { 1523 return; 1524 } 1525 if (sc->sc_callback->ucom_cfg_get_status == NULL) { 1526 return; 1527 } 1528 /* get status */ 1529 1530 new_msr = 0; 1531 new_lsr = 0; 1532 1533 (sc->sc_callback->ucom_cfg_get_status) (sc, &new_lsr, &new_msr); 1534 1535 if (!(sc->sc_flag & UCOM_FLAG_HL_READY)) { 1536 /* TTY device closed */ 1537 return; 1538 } 1539 msr_delta = (sc->sc_msr ^ new_msr); 1540 lsr_delta = (sc->sc_lsr ^ new_lsr); 1541 1542 sc->sc_msr = new_msr; 1543 sc->sc_lsr = new_lsr; 1544 1545 #if 0 /* missing pps_capture */ 1546 /* 1547 * Time pulse counting support. Note that both CTS and DCD are 1548 * active-low signals. The status bit is high to indicate that 1549 * the signal on the line is low, which corresponds to a PPS 1550 * clear event. 1551 */ 1552 switch(ucom_pps_mode) { 1553 case 1: 1554 if ((sc->sc_pps.ppsparam.mode & PPS_CAPTUREBOTH) && 1555 (msr_delta & SER_CTS)) { 1556 pps_capture(&sc->sc_pps); 1557 pps_event(&sc->sc_pps, (sc->sc_msr & SER_CTS) ? 1558 PPS_CAPTURECLEAR : PPS_CAPTUREASSERT); 1559 } 1560 break; 1561 case 2: 1562 if ((sc->sc_pps.ppsparam.mode & PPS_CAPTUREBOTH) && 1563 (msr_delta & SER_DCD)) { 1564 pps_capture(&sc->sc_pps); 1565 pps_event(&sc->sc_pps, (sc->sc_msr & SER_DCD) ? 1566 PPS_CAPTURECLEAR : PPS_CAPTUREASSERT); 1567 } 1568 break; 1569 default: 1570 break; 1571 } 1572 #endif 1573 1574 if (msr_delta & SER_DCD) { 1575 1576 int onoff = (sc->sc_msr & SER_DCD) ? 1 : 0; 1577 1578 DPRINTF("DCD changed to %d\n", onoff); 1579 1580 (*linesw[tp->t_line].l_modem)(tp, onoff); 1581 } 1582 1583 if ((lsr_delta & ULSR_BI) && (sc->sc_lsr & ULSR_BI)) { 1584 1585 DPRINTF("BREAK detected\n"); 1586 (*linesw[tp->t_line].l_rint)(0, tp); 1587 1588 /* 1589 ttydisc_rint(tp, 0, TRE_BREAK); 1590 ttydisc_rint_done(tp); 1591 */ 1592 } 1593 1594 if ((lsr_delta & ULSR_FE) && (sc->sc_lsr & ULSR_FE)) { 1595 1596 DPRINTF("Frame error detected\n"); 1597 (*linesw[tp->t_line].l_rint)(0, tp); 1598 1599 /* 1600 ttydisc_rint(tp, 0, TRE_FRAMING); 1601 ttydisc_rint_done(tp); 1602 */ 1603 } 1604 1605 if ((lsr_delta & ULSR_PE) && (sc->sc_lsr & ULSR_PE)) { 1606 1607 DPRINTF("Parity error detected\n"); 1608 (*linesw[tp->t_line].l_rint)(0, tp); 1609 /* 1610 ttydisc_rint(tp, 0, TRE_PARITY); 1611 ttydisc_rint_done(tp); 1612 */ 1613 } 1614 } 1615 1616 void 1617 ucom_status_change(struct ucom_softc *sc) 1618 { 1619 UCOM_MTX_ASSERT(sc, MA_OWNED); 1620 1621 if (sc->sc_flag & UCOM_FLAG_CONSOLE) 1622 return; /* not supported */ 1623 1624 if (!(sc->sc_flag & UCOM_FLAG_HL_READY)) { 1625 return; 1626 } 1627 DPRINTF("\n"); 1628 1629 ucom_queue_command(sc, ucom_cfg_status_change, NULL, 1630 &sc->sc_status_task[0].hdr, 1631 &sc->sc_status_task[1].hdr); 1632 } 1633 1634 static void 1635 ucom_cfg_param(struct usb_proc_msg *_task) 1636 { 1637 struct ucom_param_task *task = 1638 (struct ucom_param_task *)_task; 1639 struct ucom_softc *sc = task->sc; 1640 1641 if (!(sc->sc_flag & UCOM_FLAG_LL_READY)) { 1642 return; 1643 } 1644 if (sc->sc_callback->ucom_cfg_param == NULL) { 1645 return; 1646 } 1647 1648 (sc->sc_callback->ucom_cfg_param) (sc, &task->termios_copy); 1649 1650 /* wait a little */ 1651 usb_pause_mtx(sc->sc_lock, hz / 10); 1652 } 1653 1654 static int 1655 ucom_param(struct tty *tp, struct termios *t) 1656 { 1657 struct ucom_softc *sc = (struct ucom_softc *)tp->t_sc; 1658 uint8_t opened; 1659 int error; 1660 1661 lwkt_gettoken(&tty_token); 1662 UCOM_MTX_ASSERT(sc, MA_OWNED); 1663 1664 opened = 0; 1665 error = 0; 1666 1667 if (!(sc->sc_flag & UCOM_FLAG_HL_READY)) { 1668 1669 /* XXX the TTY layer should call "open()" first! */ 1670 /* 1671 * Not quite: Its ordering is partly backwards, but 1672 * some parameters must be set early in ttydev_open(), 1673 * possibly before calling ttydevsw_open(). 1674 */ 1675 error = ucom_open(sc); 1676 1677 if (error) { 1678 goto done; 1679 } 1680 opened = 1; 1681 } 1682 DPRINTF("sc = %p\n", sc); 1683 1684 /* Check requested parameters. */ 1685 if (t->c_ispeed && (t->c_ispeed != t->c_ospeed)) { 1686 /* XXX c_ospeed == 0 is perfectly valid. */ 1687 DPRINTF("mismatch ispeed and ospeed\n"); 1688 error = EINVAL; 1689 goto done; 1690 } 1691 t->c_ispeed = t->c_ospeed; 1692 1693 if (sc->sc_callback->ucom_pre_param) { 1694 /* Let the lower layer verify the parameters */ 1695 error = (sc->sc_callback->ucom_pre_param) (sc, t); 1696 if (error) { 1697 DPRINTF("callback error = %d\n", error); 1698 goto done; 1699 } 1700 } 1701 1702 /* Disable transfers */ 1703 sc->sc_flag &= ~UCOM_FLAG_GP_DATA; 1704 1705 /* Queue baud rate programming command first */ 1706 ucom_queue_command(sc, ucom_cfg_param, t, 1707 &sc->sc_param_task[0].hdr, 1708 &sc->sc_param_task[1].hdr); 1709 1710 /* Queue transfer enable command last */ 1711 ucom_queue_command(sc, ucom_cfg_start_transfers, NULL, 1712 &sc->sc_start_task[0].hdr, 1713 &sc->sc_start_task[1].hdr); 1714 1715 if (t->c_cflag & CRTS_IFLOW) { 1716 sc->sc_flag |= UCOM_FLAG_RTS_IFLOW; 1717 } else if (sc->sc_flag & UCOM_FLAG_RTS_IFLOW) { 1718 sc->sc_flag &= ~UCOM_FLAG_RTS_IFLOW; 1719 ucom_modem(tp, SER_RTS, 0); 1720 } 1721 done: 1722 if (error) { 1723 if (opened) { 1724 ucom_close(sc); 1725 } 1726 } 1727 1728 lwkt_reltoken(&tty_token); 1729 return (error); 1730 } 1731 1732 static void 1733 ucom_start(struct tty *tp) 1734 { 1735 struct ucom_softc *sc = (struct ucom_softc *)tp->t_sc; 1736 int didlock; 1737 1738 /* may be called locked or unlocked */ 1739 if (lockowned(sc->sc_lock)) { 1740 didlock = 0; 1741 } else { 1742 UCOM_MTX_LOCK(sc); 1743 didlock = 1; 1744 } 1745 /* UCOM_MTX_ASSERT(sc, MA_OWNED); */ 1746 1747 DPRINTF("sc = %p\n", sc); 1748 1749 if (!(sc->sc_flag & UCOM_FLAG_HL_READY)) { 1750 /* The higher layer is not ready */ 1751 if (didlock) 1752 UCOM_MTX_UNLOCK(sc); 1753 return; 1754 } 1755 1756 lwkt_gettoken(&tty_token); 1757 crit_enter(); 1758 1759 if (tp->t_state & TS_TBLOCK) { 1760 if (ISSET(sc->sc_mcr, SER_RTS) && 1761 ISSET(sc->sc_flag, UCOM_FLAG_RTS_IFLOW)) { 1762 DPRINTF("ucom_start: clear RTS\n"); 1763 (void)ucom_modem(tp, 0, SER_RTS); 1764 } 1765 } else { 1766 if (!ISSET(sc->sc_mcr, SER_RTS) && 1767 tp->t_rawq.c_cc <= tp->t_ilowat && 1768 ISSET(sc->sc_flag, UCOM_FLAG_RTS_IFLOW)) { 1769 DPRINTF("ucom_start: set RTS\n"); 1770 (void)ucom_modem(tp, SER_RTS, 0); 1771 } 1772 } 1773 1774 if (ISSET(tp->t_state, TS_BUSY | TS_TIMEOUT | TS_TTSTOP)) { 1775 ttwwakeup(tp); 1776 DPRINTF("ucom_start: stopped\n"); 1777 goto out; 1778 } 1779 1780 if (tp->t_outq.c_cc <= tp->t_olowat) { 1781 if (ISSET(tp->t_state, TS_SO_OLOWAT)) { 1782 CLR(tp->t_state, TS_SO_OLOWAT); 1783 wakeup(TSA_OLOWAT(tp)); 1784 } 1785 KNOTE(&tp->t_wkq.ki_note, 0); 1786 if (tp->t_outq.c_cc == 0) { 1787 if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) == 1788 TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) { 1789 CLR(tp->t_state, TS_SO_OCOMPLETE); 1790 wakeup(TSA_OCOMPLETE(tp)); 1791 } 1792 goto out; 1793 } 1794 } 1795 1796 DPRINTF("about to start write?\n"); 1797 ucom_start_transfers(sc); 1798 1799 ttwwakeup(tp); 1800 1801 out: 1802 crit_exit(); 1803 lwkt_reltoken(&tty_token); 1804 if (didlock) 1805 UCOM_MTX_UNLOCK(sc); 1806 } 1807 1808 static void 1809 ucom_stop(struct tty *tp, int flag) 1810 { 1811 struct ucom_softc *sc = (struct ucom_softc *)tp->t_sc; 1812 1813 DPRINTF("sc = %p, x = 0x%x\n", sc, flag); 1814 1815 lwkt_gettoken(&tty_token); 1816 if (flag & FREAD) { 1817 /* 1818 * This is just supposed to flush pending receive data, 1819 * not stop the reception of data entirely! 1820 */ 1821 DPRINTF("read\n"); 1822 if (sc->sc_callback->ucom_stop_read) { 1823 (sc->sc_callback->ucom_stop_read) (sc); 1824 } 1825 if (sc->sc_callback->ucom_start_read) { 1826 (sc->sc_callback->ucom_start_read) (sc); 1827 } 1828 /* ucomstopread(sc); 1829 ucomstartread(sc); 1830 */ } 1831 1832 if (flag & FWRITE) { 1833 DPRINTF("write\n"); 1834 crit_enter(); 1835 if (ISSET(tp->t_state, TS_BUSY)) { 1836 /* XXX do what? */ 1837 if (!ISSET(tp->t_state, TS_TTSTOP)) 1838 SET(tp->t_state, TS_FLUSH); 1839 } 1840 crit_exit(); 1841 } 1842 1843 DPRINTF("done\n"); 1844 lwkt_reltoken(&tty_token); 1845 } 1846 1847 /*------------------------------------------------------------------------* 1848 * ucom_get_data 1849 * Input values: 1850 * len: maximum length of data to get 1851 * 1852 * Get data from the TTY layer 1853 * 1854 * Return values: 1855 * 0: No data is available. 1856 * Else: Data is available. 1857 *------------------------------------------------------------------------*/ 1858 1859 /* Copy data from the tty layer to usb */ 1860 uint8_t 1861 ucom_get_data(struct ucom_softc *sc, struct usb_page_cache *pc, 1862 uint32_t offset, uint32_t len, uint32_t *actlen) 1863 { 1864 struct usb_page_search res; 1865 struct tty *tp = sc->sc_tty; 1866 uint32_t cnt; 1867 uint32_t offset_orig; 1868 1869 DPRINTF("\n"); 1870 1871 UCOM_MTX_ASSERT(sc, MA_OWNED); 1872 if (sc->sc_flag & UCOM_FLAG_CONSOLE) { 1873 unsigned int temp; 1874 1875 /* get total TX length */ 1876 1877 temp = ucom_cons_tx_high - ucom_cons_tx_low; 1878 temp %= UCOM_CONS_BUFSIZE; 1879 1880 /* limit TX length */ 1881 1882 if (temp > (UCOM_CONS_BUFSIZE - ucom_cons_tx_low)) 1883 temp = (UCOM_CONS_BUFSIZE - ucom_cons_tx_low); 1884 1885 if (temp > len) 1886 temp = len; 1887 1888 /* copy in data */ 1889 1890 usbd_copy_in(pc, offset, ucom_cons_tx_buf + ucom_cons_tx_low, temp); 1891 1892 /* update counters */ 1893 1894 ucom_cons_tx_low += temp; 1895 ucom_cons_tx_low %= UCOM_CONS_BUFSIZE; 1896 1897 /* store actual length */ 1898 1899 *actlen = temp; 1900 1901 return (temp ? 1 : 0); 1902 } 1903 1904 if (tty_gone(tp) || 1905 !(sc->sc_flag & UCOM_FLAG_GP_DATA)) { 1906 actlen[0] = 0; 1907 return (0); /* multiport device polling */ 1908 } 1909 1910 offset_orig = offset; 1911 1912 lwkt_gettoken(&tty_token); 1913 crit_enter(); 1914 while (len != 0) { 1915 usbd_get_page(pc, offset, &res); 1916 1917 /* Buffer bigger than max requested data */ 1918 if (res.length > len) { 1919 res.length = len; 1920 } 1921 /* copy data directly into USB buffer */ 1922 SET(tp->t_state, TS_BUSY); 1923 cnt = q_to_b(&tp->t_outq, res.buffer, len); 1924 if (cnt == 0) { 1925 DPRINTF("ucom_get_data: cnt == 0\n"); 1926 CLR(tp->t_state, TS_BUSY); 1927 break; 1928 } 1929 1930 CLR(tp->t_state, TS_BUSY); 1931 1932 /* XXX mp: This breaks avrdude, 1933 does the flush need to happen 1934 elsewhere? 1935 if (ISSET(tp->t_state, TS_FLUSH)) 1936 CLR(tp->t_state, TS_FLUSH); 1937 else 1938 ndflush(&tp->t_outq,cnt); 1939 */ 1940 1941 offset += cnt; 1942 len -= cnt; 1943 1944 if (cnt < res.length) { 1945 /* end of buffer */ 1946 break; 1947 } 1948 } 1949 crit_exit(); 1950 lwkt_reltoken(&tty_token); 1951 1952 actlen[0] = offset - offset_orig; 1953 1954 DPRINTF("cnt=%d\n", actlen[0]); 1955 1956 if (actlen[0] == 0) { 1957 return (0); 1958 } 1959 return (1); 1960 } 1961 1962 /* 1963 * Write data to the tty layer 1964 */ 1965 1966 void 1967 ucom_put_data(struct ucom_softc *sc, struct usb_page_cache *pc, 1968 uint32_t offset, uint32_t len) 1969 { 1970 struct usb_page_search res; 1971 struct tty *tp = sc->sc_tty; 1972 char *buf; 1973 uint32_t cnt; 1974 int lostcc; 1975 1976 DPRINTF("\n"); 1977 1978 UCOM_MTX_ASSERT(sc, MA_OWNED); 1979 lwkt_gettoken(&tty_token); 1980 1981 if (sc->sc_flag & UCOM_FLAG_CONSOLE) { 1982 unsigned int temp; 1983 1984 /* get maximum RX length */ 1985 1986 temp = (UCOM_CONS_BUFSIZE - 1) - ucom_cons_rx_high + ucom_cons_rx_low; 1987 temp %= UCOM_CONS_BUFSIZE; 1988 1989 /* limit RX length */ 1990 1991 if (temp > (UCOM_CONS_BUFSIZE - ucom_cons_rx_high)) 1992 temp = (UCOM_CONS_BUFSIZE - ucom_cons_rx_high); 1993 1994 if (temp > len) 1995 temp = len; 1996 1997 /* copy out data */ 1998 1999 usbd_copy_out(pc, offset, ucom_cons_rx_buf + ucom_cons_rx_high, temp); 2000 2001 /* update counters */ 2002 2003 ucom_cons_rx_high += temp; 2004 ucom_cons_rx_high %= UCOM_CONS_BUFSIZE; 2005 2006 lwkt_reltoken(&tty_token); 2007 return; 2008 } 2009 2010 if (tty_gone(tp)) { 2011 lwkt_reltoken(&tty_token); 2012 return; /* multiport device polling */ 2013 } 2014 if (len == 0) { 2015 lwkt_reltoken(&tty_token); 2016 return; /* no data */ 2017 } 2018 2019 /* set a flag to prevent recursation ? */ 2020 2021 crit_enter(); 2022 while (len > 0) { 2023 usbd_get_page(pc, offset, &res); 2024 2025 if (res.length > len) { 2026 res.length = len; 2027 } 2028 len -= res.length; 2029 offset += res.length; 2030 2031 /* pass characters to tty layer */ 2032 2033 buf = res.buffer; 2034 cnt = res.length; 2035 2036 /* first check if we can pass the buffer directly */ 2037 2038 if (tp->t_state & TS_CAN_BYPASS_L_RINT) { 2039 /* clear any jitter buffer */ 2040 sc->sc_jitterbuf_in = 0; 2041 sc->sc_jitterbuf_out = 0; 2042 2043 if (tp->t_rawq.c_cc + cnt > tp->t_ihiwat 2044 && (sc->sc_flag & UCOM_FLAG_RTS_IFLOW 2045 || tp->t_iflag & IXOFF) 2046 && !(tp->t_state & TS_TBLOCK)) 2047 ttyblock(tp); 2048 lostcc = b_to_q((char *)buf, cnt, &tp->t_rawq); 2049 tp->t_rawcc += cnt; 2050 if (sc->hotchar) { 2051 while (cnt) { 2052 if (*buf == sc->hotchar) 2053 break; 2054 --cnt; 2055 ++buf; 2056 } 2057 if (cnt) 2058 setsofttty(); 2059 } 2060 ttwakeup(tp); 2061 if (tp->t_state & TS_TTSTOP 2062 && (tp->t_iflag & IXANY 2063 || tp->t_cc[VSTART] == tp->t_cc[VSTOP])) { 2064 tp->t_state &= ~TS_TTSTOP; 2065 tp->t_lflag &= ~FLUSHO; 2066 ucom_start(tp); 2067 } 2068 if (lostcc > 0) 2069 kprintf("lost %d chars\n", lostcc); 2070 2071 /* 2072 if (ttydisc_rint_bypass(tp, buf, cnt) != cnt) { 2073 DPRINTF("tp=%p, data lost\n", tp); 2074 } 2075 */ 2076 continue; 2077 } else { 2078 /* need to loop */ 2079 for (cnt = 0; cnt != res.length; cnt++) { 2080 if (sc->sc_jitterbuf_in != sc->sc_jitterbuf_out || 2081 (*linesw[tp->t_line].l_rint)((unsigned char)buf[cnt], tp) == -1) { 2082 uint16_t end; 2083 uint16_t pos; 2084 2085 pos = sc->sc_jitterbuf_in; 2086 end = sc->sc_jitterbuf_out + 2087 UCOM_JITTERBUF_SIZE - 1; 2088 2089 if (end >= UCOM_JITTERBUF_SIZE) 2090 end -= UCOM_JITTERBUF_SIZE; 2091 2092 for (; cnt != res.length; cnt++) { 2093 if (pos == end) 2094 break; 2095 sc->sc_jitterbuf[pos] = buf[cnt]; 2096 pos++; 2097 if (pos >= UCOM_JITTERBUF_SIZE) 2098 pos -= UCOM_JITTERBUF_SIZE; 2099 } 2100 2101 sc->sc_jitterbuf_in = pos; 2102 2103 /* set RTS in async fashion */ 2104 if (sc->sc_flag & UCOM_FLAG_RTS_IFLOW) 2105 ucom_rts(sc, 1); 2106 2107 DPRINTF("tp=%p, lost %d " 2108 "chars\n", tp, res.length - cnt); 2109 break; 2110 } 2111 } 2112 } 2113 } 2114 crit_exit(); 2115 lwkt_reltoken(&tty_token); 2116 /* 2117 ttydisc_rint_done(tp); 2118 */ 2119 } 2120 2121 #if 0 /* XXX */ 2122 static void 2123 ucom_free(void *xsc) 2124 { 2125 struct ucom_softc *sc = xsc; 2126 2127 if (sc->sc_callback->ucom_free != NULL) 2128 sc->sc_callback->ucom_free(sc); 2129 else 2130 /*ucom_unref(sc->sc_super) XXX hack, see end of ucom_detach_tty() */; 2131 2132 lockmgr(&ucom_lock, LK_EXCLUSIVE); 2133 ucom_close_refs--; 2134 lockmgr(&ucom_lock, LK_RELEASE); 2135 } 2136 2137 static cn_probe_t ucom_cnprobe; 2138 static cn_init_t ucom_cninit; 2139 static cn_term_t ucom_cnterm; 2140 static cn_getc_t ucom_cngetc; 2141 static cn_putc_t ucom_cnputc; 2142 2143 /* 2144 static cn_grab_t ucom_cngrab; 2145 static cn_ungrab_t ucom_cnungrab; 2146 CONSOLE_DRIVER(ucom); 2147 */ 2148 2149 static void 2150 ucom_cnprobe(struct consdev *cp) 2151 { 2152 if (ucom_cons_unit != -1) 2153 cp->cn_pri = CN_NORMAL; 2154 else 2155 cp->cn_pri = CN_DEAD; 2156 2157 /* 2158 strlcpy(cp->cn_name, "ucom", sizeof(cp->cn_name)); 2159 */ 2160 } 2161 2162 static void 2163 ucom_cninit(struct consdev *cp) 2164 { 2165 } 2166 2167 static void 2168 ucom_cnterm(struct consdev *cp) 2169 { 2170 } 2171 2172 static void 2173 ucom_cngrab(struct consdev *cp) 2174 { 2175 } 2176 2177 static void 2178 ucom_cnungrab(struct consdev *cp) 2179 { 2180 } 2181 2182 static int 2183 ucom_cngetc(struct consdev *cd) 2184 { 2185 struct ucom_softc *sc = ucom_cons_softc; 2186 int c; 2187 2188 if (sc == NULL) 2189 return (-1); 2190 2191 UCOM_MTX_LOCK(sc); 2192 2193 if (ucom_cons_rx_low != ucom_cons_rx_high) { 2194 c = ucom_cons_rx_buf[ucom_cons_rx_low]; 2195 ucom_cons_rx_low ++; 2196 ucom_cons_rx_low %= UCOM_CONS_BUFSIZE; 2197 } else { 2198 c = -1; 2199 } 2200 2201 /* start USB transfers */ 2202 ucom_outwakeup(sc->sc_tty); 2203 2204 UCOM_MTX_UNLOCK(sc); 2205 2206 /* poll if necessary */ 2207 /* 2208 if (kdb_active && sc->sc_callback->ucom_poll) 2209 (sc->sc_callback->ucom_poll) (sc); 2210 */ 2211 return (c); 2212 } 2213 2214 static void 2215 ucom_cnputc(void *cd, int c) 2216 /* 2217 ucom_cnputc(struct consdev *cd, int c) 2218 */ 2219 2220 { 2221 struct ucom_softc *sc = ucom_cons_softc; 2222 unsigned int temp; 2223 2224 if (sc == NULL) 2225 return; 2226 2227 repeat: 2228 2229 UCOM_MTX_LOCK(sc); 2230 2231 /* compute maximum TX length */ 2232 2233 temp = (UCOM_CONS_BUFSIZE - 1) - ucom_cons_tx_high + ucom_cons_tx_low; 2234 temp %= UCOM_CONS_BUFSIZE; 2235 2236 if (temp) { 2237 ucom_cons_tx_buf[ucom_cons_tx_high] = c; 2238 ucom_cons_tx_high ++; 2239 ucom_cons_tx_high %= UCOM_CONS_BUFSIZE; 2240 } 2241 2242 /* start USB transfers */ 2243 ucom_outwakeup(sc->sc_tty); 2244 2245 UCOM_MTX_UNLOCK(sc); 2246 2247 /* poll if necessary */ 2248 #if 0 /* XXX */ 2249 if (kdb_active && sc->sc_callback->ucom_poll) { 2250 (sc->sc_callback->ucom_poll) (sc); 2251 /* simple flow control */ 2252 if (temp == 0) 2253 goto repeat; 2254 } 2255 #endif 2256 } 2257 #endif 2258 /*------------------------------------------------------------------------* 2259 * ucom_ref 2260 * 2261 * This function will increment the super UCOM reference count. 2262 *------------------------------------------------------------------------*/ 2263 void 2264 ucom_ref(struct ucom_super_softc *ssc) 2265 { 2266 lockmgr(&ucom_lock, LK_EXCLUSIVE); 2267 ssc->sc_refs++; 2268 lockmgr(&ucom_lock, LK_RELEASE); 2269 } 2270 2271 /*------------------------------------------------------------------------* 2272 * ucom_free_unit 2273 * 2274 * This function will free the super UCOM's allocated unit 2275 * number. This function can be called on a zero-initialized 2276 * structure. This function can be called multiple times. 2277 *------------------------------------------------------------------------*/ 2278 static void 2279 ucom_free_unit(struct ucom_super_softc *ssc) 2280 { 2281 if (!(ssc->sc_flag & UCOM_FLAG_FREE_UNIT)) 2282 return; 2283 2284 ucom_unit_free(ssc->sc_unit); 2285 2286 ssc->sc_flag &= ~UCOM_FLAG_FREE_UNIT; 2287 } 2288 2289 /*------------------------------------------------------------------------* 2290 * ucom_unref 2291 * 2292 * This function will decrement the super UCOM reference count. 2293 * 2294 * Return values: 2295 * 0: UCOM structures are still referenced. 2296 * Else: UCOM structures are no longer referenced. 2297 *------------------------------------------------------------------------*/ 2298 int 2299 ucom_unref(struct ucom_super_softc *ssc) 2300 { 2301 int retval; 2302 2303 lockmgr(&ucom_lock, LK_EXCLUSIVE); 2304 retval = (ssc->sc_refs < 2); 2305 ssc->sc_refs--; 2306 lockmgr(&ucom_lock, LK_RELEASE); 2307 2308 if (retval) 2309 ucom_free_unit(ssc); 2310 2311 return (retval); 2312 } 2313 2314 /* 2315 * NOTE: Must be called with tty_token held. 2316 */ 2317 static void 2318 disc_optim(struct tty *tp, struct termios *t, struct ucom_softc *sc) 2319 { 2320 ASSERT_LWKT_TOKEN_HELD(&tty_token); 2321 if (!(t->c_iflag & (ICRNL | IGNCR | IMAXBEL | INLCR | ISTRIP | IXON)) 2322 && (!(t->c_iflag & BRKINT) || (t->c_iflag & IGNBRK)) 2323 && (!(t->c_iflag & PARMRK) 2324 || (t->c_iflag & (IGNPAR | IGNBRK)) == (IGNPAR | IGNBRK)) 2325 && !(t->c_lflag & (ECHO | ICANON | IEXTEN | ISIG | PENDIN)) 2326 && linesw[tp->t_line].l_rint == ttyinput) { 2327 DPRINTF("disc_optim: bypass l_rint\n"); 2328 tp->t_state |= TS_CAN_BYPASS_L_RINT; 2329 } else { 2330 DPRINTF("disc_optim: can't bypass l_rint\n"); 2331 tp->t_state &= ~TS_CAN_BYPASS_L_RINT; 2332 } 2333 sc->hotchar = linesw[tp->t_line].l_hotchar; 2334 } 2335 2336 #if defined(GDB) 2337 2338 #include <gdb/gdb.h> 2339 2340 static gdb_probe_f ucom_gdbprobe; 2341 static gdb_init_f ucom_gdbinit; 2342 static gdb_term_f ucom_gdbterm; 2343 static gdb_getc_f ucom_gdbgetc; 2344 static gdb_putc_f ucom_gdbputc; 2345 2346 GDB_DBGPORT(sio, ucom_gdbprobe, ucom_gdbinit, ucom_gdbterm, ucom_gdbgetc, ucom_gdbputc); 2347 2348 static int 2349 ucom_gdbprobe(void) 2350 { 2351 return ((ucom_cons_softc != NULL) ? 0 : -1); 2352 } 2353 2354 static void 2355 ucom_gdbinit(void) 2356 { 2357 } 2358 2359 static void 2360 ucom_gdbterm(void) 2361 { 2362 } 2363 2364 static void 2365 ucom_gdbputc(int c) 2366 { 2367 ucom_cnputc(NULL, c); 2368 } 2369 2370 static int 2371 ucom_gdbgetc(void) 2372 { 2373 return (ucom_cngetc(NULL)); 2374 } 2375 2376 #endif 2377 2378 2379