1 /* $NetBSD: ucycom.c,v 1.57 2024/03/17 20:10:52 jakllsch Exp $ */ 2 3 /* 4 * Copyright (c) 2005 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Nick Hudson 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 /* 32 * This code is based on the ucom driver. 33 */ 34 35 /* 36 * Device driver for Cypress CY7C637xx and CY7C640/1xx series USB to 37 * RS232 bridges. 38 */ 39 40 #include <sys/cdefs.h> 41 __KERNEL_RCSID(0, "$NetBSD: ucycom.c,v 1.57 2024/03/17 20:10:52 jakllsch Exp $"); 42 43 #ifdef _KERNEL_OPT 44 #include "opt_usb.h" 45 #endif 46 47 #include <sys/param.h> 48 #include <sys/systm.h> 49 #include <sys/conf.h> 50 #include <sys/kernel.h> 51 #include <sys/kmem.h> 52 #include <sys/device.h> 53 #include <sys/sysctl.h> 54 #include <sys/tty.h> 55 #include <sys/file.h> 56 #include <sys/vnode.h> 57 #include <sys/kauth.h> 58 #include <sys/lwp.h> 59 60 #include <dev/usb/usb.h> 61 #include <dev/usb/usbhid.h> 62 63 #include <dev/usb/usbdi.h> 64 #include <dev/usb/usbdi_util.h> 65 #include <dev/usb/usbdevs.h> 66 #include <dev/usb/uhidev.h> 67 #include <dev/hid/hid.h> 68 69 #include "ioconf.h" 70 71 #ifdef UCYCOM_DEBUG 72 #define DPRINTF(x) if (ucycomdebug) printf x 73 #define DPRINTFN(n, x) if (ucycomdebug > (n)) printf x 74 int ucycomdebug = 20; 75 #else 76 #define DPRINTF(x) 77 #define DPRINTFN(n,x) 78 #endif 79 80 81 #define UCYCOMCALLUNIT_MASK TTCALLUNIT_MASK 82 #define UCYCOMUNIT_MASK TTUNIT_MASK 83 #define UCYCOMDIALOUT_MASK TTDIALOUT_MASK 84 85 #define UCYCOMCALLUNIT(x) TTCALLUNIT(x) 86 #define UCYCOMUNIT(x) TTUNIT(x) 87 #define UCYCOMDIALOUT(x) TTDIALOUT(x) 88 89 /* Configuration Byte */ 90 #define UCYCOM_RESET 0x80 91 #define UCYCOM_PARITY_TYPE_MASK 0x20 92 #define UCYCOM_PARITY_ODD 0x20 93 #define UCYCOM_PARITY_EVEN 0x00 94 #define UCYCOM_PARITY_MASK 0x10 95 #define UCYCOM_PARITY_ON 0x10 96 #define UCYCOM_PARITY_OFF 0x00 97 #define UCYCOM_STOP_MASK 0x08 98 #define UCYCOM_STOP_BITS_2 0x08 99 #define UCYCOM_STOP_BITS_1 0x00 100 #define UCYCOM_DATA_MASK 0x03 101 #define UCYCOM_DATA_BITS_8 0x03 102 #define UCYCOM_DATA_BITS_7 0x02 103 #define UCYCOM_DATA_BITS_6 0x01 104 #define UCYCOM_DATA_BITS_5 0x00 105 106 /* Modem (Input) status byte */ 107 #define UCYCOM_RI 0x80 108 #define UCYCOM_DCD 0x40 109 #define UCYCOM_DSR 0x20 110 #define UCYCOM_CTS 0x10 111 #define UCYCOM_ERROR 0x08 112 #define UCYCOM_LMASK 0x07 113 114 /* Modem (Output) control byte */ 115 #define UCYCOM_DTR 0x20 116 #define UCYCOM_RTS 0x10 117 #define UCYCOM_ORESET 0x08 118 119 struct ucycom_softc { 120 device_t sc_dev; 121 struct uhidev *sc_hdev; 122 struct usbd_device *sc_udev; 123 124 struct usb_task sc_task; 125 struct tty *sc_tty; 126 127 enum { 128 UCYCOM_INIT_NONE, 129 UCYCOM_INIT_INITED 130 } sc_init_state; 131 132 kmutex_t sc_lock; /* protects refcnt, others */ 133 134 /* uhidev parameters */ 135 size_t sc_flen; /* feature report length */ 136 size_t sc_olen; /* output report length */ 137 138 uint8_t *sc_obuf; 139 int sc_wlen; 140 141 /* settings */ 142 uint32_t sc_baud; 143 uint8_t sc_cfg; /* Data format */ 144 uint8_t sc_mcr; /* Modem control */ 145 uint8_t sc_msr; /* Modem status */ 146 int sc_swflags; 147 148 /* flags */ 149 char sc_dying; 150 }; 151 152 static dev_type_open(ucycomopen); 153 static dev_type_close(ucycomclose); 154 static dev_type_read(ucycomread); 155 static dev_type_write(ucycomwrite); 156 static dev_type_ioctl(ucycomioctl); 157 static dev_type_stop(ucycomstop); 158 static dev_type_tty(ucycomtty); 159 static dev_type_poll(ucycompoll); 160 161 const struct cdevsw ucycom_cdevsw = { 162 .d_open = ucycomopen, 163 .d_close = ucycomclose, 164 .d_read = ucycomread, 165 .d_write = ucycomwrite, 166 .d_ioctl = ucycomioctl, 167 .d_stop = ucycomstop, 168 .d_tty = ucycomtty, 169 .d_poll = ucycompoll, 170 .d_mmap = nommap, 171 .d_kqfilter = ttykqfilter, 172 .d_discard = nodiscard, 173 .d_flag = D_TTY 174 }; 175 176 Static int ucycomparam(struct tty *, struct termios *); 177 Static void ucycomstart(struct tty *); 178 Static void ucycomstarttask(void *); 179 Static void ucycomwritecb(struct usbd_xfer *, void *, usbd_status); 180 Static void ucycom_intr(void *, void *, u_int); 181 Static int ucycom_configure(struct ucycom_softc *, uint32_t, uint8_t); 182 Static void tiocm_to_ucycom(struct ucycom_softc *, u_long, int); 183 Static int ucycom_to_tiocm(struct ucycom_softc *); 184 Static void ucycom_set_status(struct ucycom_softc *); 185 Static void ucycom_dtr(struct ucycom_softc *, int); 186 #if 0 187 Static void ucycom_rts(struct ucycom_softc *, int); 188 #endif 189 Static void ucycom_cleanup(struct ucycom_softc *); 190 191 #ifdef UCYCOM_DEBUG 192 Static void ucycom_get_cfg(struct ucycom_softc *); 193 #endif 194 195 Static const struct usb_devno ucycom_devs[] = { 196 { USB_VENDOR_CYPRESS, USB_PRODUCT_CYPRESS_USBRS232 }, 197 { USB_VENDOR_DELORME, USB_PRODUCT_DELORME_EARTHMATE }, 198 }; 199 #define ucycom_lookup(v, p) usb_lookup(ucycom_devs, v, p) 200 201 static int ucycom_match(device_t, cfdata_t, void *); 202 static void ucycom_attach(device_t, device_t, void *); 203 static int ucycom_detach(device_t, int); 204 static int ucycom_activate(device_t, enum devact); 205 206 CFATTACH_DECL_NEW(ucycom, sizeof(struct ucycom_softc), ucycom_match, 207 ucycom_attach, ucycom_detach, ucycom_activate); 208 209 static int 210 ucycom_match(device_t parent, cfdata_t match, void *aux) 211 { 212 struct uhidev_attach_arg *uha = aux; 213 214 return ucycom_lookup(uha->uiaa->uiaa_vendor, uha->uiaa->uiaa_product) 215 != NULL ? UMATCH_VENDOR_PRODUCT : UMATCH_NONE; 216 } 217 218 static void 219 ucycom_attach(device_t parent, device_t self, void *aux) 220 { 221 struct ucycom_softc *sc = device_private(self); 222 struct uhidev_attach_arg *uha = aux; 223 int size, repid; 224 void *desc; 225 226 sc->sc_dev = self; 227 sc->sc_hdev = uha->parent; 228 sc->sc_udev = uha->uiaa->uiaa_device; 229 sc->sc_init_state = UCYCOM_INIT_NONE; 230 231 uhidev_get_report_desc(uha->parent, &desc, &size); 232 repid = uha->reportid; 233 sc->sc_olen = hid_report_size(desc, size, hid_output, repid); 234 sc->sc_flen = hid_report_size(desc, size, hid_feature, repid); 235 236 if (sc->sc_olen != 8 && sc->sc_olen != 32) 237 return; 238 if (sc->sc_flen != 5) 239 return; 240 241 sc->sc_msr = sc->sc_mcr = 0; 242 243 /* not MP-safe */ 244 usb_init_task(&sc->sc_task, ucycomstarttask, sc, 0); 245 246 /* set up tty */ 247 sc->sc_tty = tty_alloc(); 248 sc->sc_tty->t_sc = sc; 249 sc->sc_tty->t_oproc = ucycomstart; 250 sc->sc_tty->t_param = ucycomparam; 251 252 tty_attach(sc->sc_tty); 253 254 /* Nothing interesting to report */ 255 aprint_normal("\n"); 256 257 sc->sc_init_state = UCYCOM_INIT_INITED; 258 } 259 260 261 static int 262 ucycom_detach(device_t self, int flags) 263 { 264 struct ucycom_softc *sc = device_private(self); 265 struct tty *tp = sc->sc_tty; 266 int maj, mn; 267 int s; 268 269 DPRINTF(("ucycom_detach: sc=%p flags=%d tp=%p\n", sc, flags, tp)); 270 271 sc->sc_dying = 1; 272 273 s = splusb(); 274 if (tp != NULL) { 275 ttylock(tp); 276 CLR(tp->t_state, TS_CARR_ON); 277 CLR(tp->t_cflag, CLOCAL | MDMBUF); 278 ttyflush(tp, FREAD|FWRITE); 279 ttyunlock(tp); 280 } 281 /* Wait for processes to go away. */ 282 usb_detach_waitold(sc->sc_dev); 283 splx(s); 284 285 /* locate the major number */ 286 maj = cdevsw_lookup_major(&ucycom_cdevsw); 287 288 /* Nuke the vnodes for any open instances. */ 289 mn = device_unit(self); 290 291 DPRINTFN(2, ("ucycom_detach: maj=%d mn=%d\n", maj, mn)); 292 vdevgone(maj, mn, mn, VCHR); 293 vdevgone(maj, mn | UCYCOMDIALOUT_MASK, mn | UCYCOMDIALOUT_MASK, VCHR); 294 vdevgone(maj, mn | UCYCOMCALLUNIT_MASK, mn | UCYCOMCALLUNIT_MASK, VCHR); 295 296 usb_rem_task_wait(sc->sc_udev, &sc->sc_task, USB_TASKQ_DRIVER, NULL); 297 298 /* Detach and free the tty. */ 299 if (tp != NULL) { 300 DPRINTF(("ucycom_detach: tty_detach %p\n", tp)); 301 tty_detach(tp); 302 tty_free(tp); 303 sc->sc_tty = NULL; 304 } 305 306 return 0; 307 } 308 309 static int 310 ucycom_activate(device_t self, enum devact act) 311 { 312 struct ucycom_softc *sc = device_private(self); 313 314 DPRINTFN(5,("ucycom_activate: %d\n", act)); 315 316 switch (act) { 317 case DVACT_DEACTIVATE: 318 sc->sc_dying = 1; 319 return 0; 320 default: 321 return EOPNOTSUPP; 322 } 323 } 324 325 #if 0 326 void 327 ucycom_shutdown(struct ucycom_softc *sc) 328 { 329 struct tty *tp = sc->sc_tty; 330 331 DPRINTF(("ucycom_shutdown\n")); 332 /* 333 * Hang up if necessary. Wait a bit, so the other side has time to 334 * notice even if we immediately open the port again. 335 */ 336 if (ISSET(tp->t_cflag, HUPCL)) { 337 ucycom_dtr(sc, 0); 338 (void)tsleep(sc, TTIPRI, ttclos, hz); 339 } 340 } 341 #endif 342 343 static int 344 ucycomopen(dev_t dev, int flag, int mode, struct lwp *l) 345 { 346 struct ucycom_softc *sc = 347 device_lookup_private(&ucycom_cd, UCYCOMUNIT(dev)); 348 struct tty *tp; 349 int s, err; 350 351 DPRINTF(("ucycomopen: unit=%d\n", UCYCOMUNIT(dev))); 352 DPRINTF(("ucycomopen: sc=%p\n", sc)); 353 354 if (sc == NULL) 355 return ENXIO; 356 if (sc->sc_dying) 357 return EIO; 358 if (sc->sc_init_state != UCYCOM_INIT_INITED) 359 return ENXIO; 360 if (!device_is_active(sc->sc_dev)) 361 return ENXIO; 362 363 tp = sc->sc_tty; 364 365 DPRINTF(("ucycomopen: tp=%p\n", tp)); 366 367 if (kauth_authorize_device_tty(l->l_cred, KAUTH_DEVICE_TTY_OPEN, tp)) 368 return EBUSY; 369 370 s = spltty(); 371 372 if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) { 373 struct termios t; 374 375 tp->t_dev = dev; 376 377 err = uhidev_open(sc->sc_hdev, &ucycom_intr, sc); 378 if (err) { 379 /* Any cleanup? */ 380 splx(s); 381 return err; 382 } 383 384 /* 385 * Initialize the termios status to the defaults. Add in the 386 * sticky bits from TIOCSFLAGS. 387 */ 388 t.c_ispeed = 0; 389 t.c_ospeed = TTYDEF_SPEED; 390 t.c_cflag = TTYDEF_CFLAG; 391 if (ISSET(sc->sc_swflags, TIOCFLAG_CLOCAL)) 392 SET(t.c_cflag, CLOCAL); 393 if (ISSET(sc->sc_swflags, TIOCFLAG_CRTSCTS)) 394 SET(t.c_cflag, CRTSCTS); 395 if (ISSET(sc->sc_swflags, TIOCFLAG_MDMBUF)) 396 SET(t.c_cflag, MDMBUF); 397 398 tp->t_ospeed = 0; 399 (void) ucycomparam(tp, &t); 400 tp->t_iflag = TTYDEF_IFLAG; 401 tp->t_oflag = TTYDEF_OFLAG; 402 tp->t_lflag = TTYDEF_LFLAG; 403 ttychars(tp); 404 ttsetwater(tp); 405 406 /* Allocate an output report buffer */ 407 sc->sc_obuf = kmem_alloc(sc->sc_olen, KM_SLEEP); 408 409 DPRINTF(("ucycomopen: sc->sc_obuf=%p\n", sc->sc_obuf)); 410 411 #if 0 412 /* XXX Don't do this as for some reason trying to do an 413 * XXX interrupt out transfer at this point means everything 414 * XXX gets stuck!?! 415 */ 416 /* 417 * Turn on DTR. We must always do this, even if carrier is not 418 * present, because otherwise we'd have to use TIOCSDTR 419 * immediately after setting CLOCAL, which applications do not 420 * expect. We always assert DTR while the device is open 421 * unless explicitly requested to deassert it. 422 */ 423 ucycom_dtr(sc, 1); 424 #endif 425 426 #if 0 427 /* XXX CLR(sc->sc_rx_flags, RX_ANY_BLOCK);*/ 428 ucycom_hwiflow(sc); 429 #endif 430 431 } 432 splx(s); 433 434 err = ttyopen(tp, UCYCOMDIALOUT(dev), ISSET(flag, O_NONBLOCK)); 435 if (err) 436 goto bad; 437 438 err = (*tp->t_linesw->l_open)(dev, tp); 439 if (err) 440 goto bad; 441 442 return 0; 443 444 bad: 445 if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) { 446 /* 447 * We failed to open the device, and nobody else had it opened. 448 * Clean up the state as appropriate. 449 */ 450 ucycom_cleanup(sc); 451 } 452 453 return err; 454 455 } 456 457 458 static int 459 ucycomclose(dev_t dev, int flag, int mode, struct lwp *l) 460 { 461 struct ucycom_softc *sc = 462 device_lookup_private(&ucycom_cd, UCYCOMUNIT(dev)); 463 struct tty *tp = sc->sc_tty; 464 465 DPRINTF(("ucycomclose: unit=%d\n", UCYCOMUNIT(dev))); 466 if (!ISSET(tp->t_state, TS_ISOPEN)) 467 return 0; 468 469 (*tp->t_linesw->l_close)(tp, flag); 470 ttyclose(tp); 471 472 if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) { 473 /* 474 * Although we got a last close, the device may still be in 475 * use; e.g. if this was the dialout node, and there are still 476 * processes waiting for carrier on the non-dialout node. 477 */ 478 ucycom_cleanup(sc); 479 } 480 481 return 0; 482 } 483 484 Static void 485 ucycomstart(struct tty *tp) 486 { 487 struct ucycom_softc *sc = 488 device_lookup_private(&ucycom_cd, UCYCOMUNIT(tp->t_dev)); 489 usbd_status err __unused; 490 u_char *data; 491 int cnt, len, s; 492 493 KASSERT(ttylocked(tp)); 494 495 if (sc->sc_dying) 496 return; 497 498 s = spltty(); 499 if (ISSET(tp->t_state, TS_BUSY | TS_TIMEOUT | TS_TTSTOP)) { 500 DPRINTFN(4,("ucycomstart: no go, state=%#x\n", tp->t_state)); 501 goto out; 502 } 503 504 #if 0 505 /* HW FLOW CTL */ 506 if (sc->sc_tx_stopped) 507 goto out; 508 #endif 509 510 if (ttypull(tp) == 0) 511 goto out; 512 513 /* Grab the first contiguous region of buffer space. */ 514 data = tp->t_outq.c_cf; 515 cnt = ndqb(&tp->t_outq, 0); 516 517 if (cnt == 0) { 518 DPRINTF(("ucycomstart: cnt == 0\n")); 519 goto out; 520 } 521 522 SET(tp->t_state, TS_BUSY); 523 524 /* 525 * The 8 byte output report uses byte 0 for control and byte 526 * count. 527 * 528 * The 32 byte output report uses byte 0 for control. Byte 1 529 * is used for byte count. 530 */ 531 memset(sc->sc_obuf, 0, sc->sc_olen); 532 len = cnt; 533 switch (sc->sc_olen) { 534 case 8: 535 if (cnt > sc->sc_olen - 1) { 536 DPRINTF(("ucycomstart(8): big buffer %d chars\n", len)); 537 len = sc->sc_olen - 1; 538 } 539 540 memcpy(sc->sc_obuf + 1, data, len); 541 sc->sc_obuf[0] = len | sc->sc_mcr; 542 543 DPRINTF(("ucycomstart(8): sc->sc_obuf[0] = %d | %d = %d\n", 544 len, sc->sc_mcr, sc->sc_obuf[0])); 545 #ifdef UCYCOM_DEBUG 546 if (ucycomdebug > 10) { 547 uint32_t i; 548 uint8_t *d = data; 549 550 DPRINTF(("ucycomstart(8): data =")); 551 for (i = 0; i < len; i++) 552 DPRINTF((" %02x", d[i])); 553 DPRINTF(("\n")); 554 } 555 #endif 556 break; 557 558 case 32: 559 if (cnt > sc->sc_olen - 2) { 560 DPRINTF(("ucycomstart(32): big buffer %d chars\n", 561 len)); 562 len = sc->sc_olen - 2; 563 } 564 565 memcpy(sc->sc_obuf + 2, data, len); 566 sc->sc_obuf[0] = sc->sc_mcr; 567 sc->sc_obuf[1] = len; 568 DPRINTF(("ucycomstart(32): sc->sc_obuf[0] = %d\n" 569 "sc->sc_obuf[1] = %d\n", sc->sc_obuf[0], sc->sc_obuf[1])); 570 #ifdef UCYCOM_DEBUG 571 if (ucycomdebug > 10) { 572 uint32_t i; 573 uint8_t *d = data; 574 575 DPRINTF(("ucycomstart(32): data =")); 576 for (i = 0; i < len; i++) 577 DPRINTF((" %02x", d[i])); 578 DPRINTF(("\n")); 579 } 580 #endif 581 break; 582 583 default: 584 DPRINTFN(2,("ucycomstart: unknown output report size (%zd)\n", 585 sc->sc_olen)); 586 goto out; 587 } 588 splx(s); 589 sc->sc_wlen = len; 590 591 #ifdef UCYCOM_DEBUG 592 if (ucycomdebug > 5) { 593 int i; 594 595 if (len != 0) { 596 DPRINTF(("ucycomstart: sc->sc_obuf[0..%zd) =", 597 sc->sc_olen)); 598 for (i = 0; i < sc->sc_olen; i++) 599 DPRINTF((" %02x", sc->sc_obuf[i])); 600 DPRINTF(("\n")); 601 } 602 } 603 #endif 604 DPRINTFN(4,("ucycomstart: %d chars\n", len)); 605 usb_add_task(sc->sc_udev, &sc->sc_task, USB_TASKQ_DRIVER); 606 return; 607 608 out: 609 splx(s); 610 } 611 612 Static void 613 ucycomstarttask(void *cookie) 614 { 615 struct ucycom_softc *sc = cookie; 616 usbd_status err; 617 618 /* What can we do on error? */ 619 err = uhidev_write_async(sc->sc_hdev, sc->sc_obuf, sc->sc_olen, 0, 620 USBD_NO_TIMEOUT, ucycomwritecb, sc); 621 622 #ifdef UCYCOM_DEBUG 623 if (err != USBD_IN_PROGRESS) 624 DPRINTF(("ucycomstart: err=%s\n", usbd_errstr(err))); 625 #else 626 __USE(err); 627 #endif 628 } 629 630 Static void 631 ucycomwritecb(struct usbd_xfer *xfer, void *p, usbd_status status) 632 { 633 struct ucycom_softc *sc = (struct ucycom_softc *)p; 634 struct tty *tp = sc->sc_tty; 635 usbd_status stat; 636 int len, s; 637 638 if (status == USBD_CANCELLED || sc->sc_dying) 639 goto error; 640 641 if (status) { 642 DPRINTF(("ucycomwritecb: status=%d\n", status)); 643 /* XXX we should restart after some delay. */ 644 goto error; 645 } 646 647 usbd_get_xfer_status(xfer, NULL, NULL, &len, &stat); 648 649 if (status != USBD_NORMAL_COMPLETION) { 650 DPRINTFN(4,("ucycomwritecb: status = %d\n", status)); 651 goto error; 652 } 653 654 DPRINTFN(4,("ucycomwritecb: did %d/%d chars\n", sc->sc_wlen, len)); 655 656 s = spltty(); 657 CLR(tp->t_state, TS_BUSY); 658 if (ISSET(tp->t_state, TS_FLUSH)) 659 CLR(tp->t_state, TS_FLUSH); 660 else 661 ndflush(&tp->t_outq, sc->sc_wlen); 662 (*tp->t_linesw->l_start)(tp); 663 splx(s); 664 return; 665 666 error: 667 s = spltty(); 668 CLR(tp->t_state, TS_BUSY); 669 splx(s); 670 } 671 672 Static int 673 ucycomparam(struct tty *tp, struct termios *t) 674 { 675 struct ucycom_softc *sc = tp->t_sc; 676 uint32_t baud; 677 uint8_t cfg; 678 int err; 679 680 if (t->c_ospeed < 0) { 681 DPRINTF(("ucycomparam: c_ospeed < 0\n")); 682 return EINVAL; 683 } 684 685 /* Check requested parameters. */ 686 if (t->c_ispeed && t->c_ispeed != t->c_ospeed) 687 return EINVAL; 688 689 /* 690 * For the console, always force CLOCAL and !HUPCL, so that the port 691 * is always active. 692 */ 693 if (ISSET(sc->sc_swflags, TIOCFLAG_SOFTCAR)) { 694 SET(t->c_cflag, CLOCAL); 695 CLR(t->c_cflag, HUPCL); 696 } 697 698 /* 699 * If there were no changes, don't do anything. This avoids dropping 700 * input and improves performance when all we did was frob things like 701 * VMIN and VTIME. 702 */ 703 if (tp->t_ospeed == t->c_ospeed && 704 tp->t_cflag == t->c_cflag) 705 return 0; 706 707 /* XXX lcr = ISSET(sc->sc_lcr, LCR_SBREAK) | cflag2lcr(t->c_cflag); */ 708 709 /* And copy to tty. */ 710 tp->t_ispeed = 0; 711 tp->t_ospeed = t->c_ospeed; 712 tp->t_cflag = t->c_cflag; 713 714 baud = t->c_ispeed; 715 DPRINTF(("ucycomparam: baud=%d\n", baud)); 716 717 if (t->c_cflag & CIGNORE) { 718 cfg = sc->sc_cfg; 719 } else { 720 cfg = 0; 721 switch (t->c_cflag & CSIZE) { 722 case CS8: 723 cfg |= UCYCOM_DATA_BITS_8; 724 break; 725 case CS7: 726 cfg |= UCYCOM_DATA_BITS_7; 727 break; 728 case CS6: 729 cfg |= UCYCOM_DATA_BITS_6; 730 break; 731 case CS5: 732 cfg |= UCYCOM_DATA_BITS_5; 733 break; 734 default: 735 return EINVAL; 736 } 737 cfg |= ISSET(t->c_cflag, CSTOPB) ? 738 UCYCOM_STOP_BITS_2 : UCYCOM_STOP_BITS_1; 739 cfg |= ISSET(t->c_cflag, PARENB) ? 740 UCYCOM_PARITY_ON : UCYCOM_PARITY_OFF; 741 cfg |= ISSET(t->c_cflag, PARODD) ? 742 UCYCOM_PARITY_ODD : UCYCOM_PARITY_EVEN; 743 } 744 745 /* 746 * Update the tty layer's idea of the carrier bit, in case we changed 747 * CLOCAL or MDMBUF. We don't hang up here; we only do that by 748 * explicit request. 749 */ 750 DPRINTF(("ucycomparam: l_modem\n")); 751 (void) (*tp->t_linesw->l_modem)(tp, 1 /* XXX carrier */ ); 752 753 err = ucycom_configure(sc, baud, cfg); 754 return err; 755 } 756 757 static void 758 ucycomstop(struct tty *tp, int flag) 759 { 760 DPRINTF(("ucycomstop: flag=%d\n", flag)); 761 } 762 763 static int 764 ucycomread(dev_t dev, struct uio *uio, int flag) 765 { 766 struct ucycom_softc *sc = 767 device_lookup_private(&ucycom_cd, UCYCOMUNIT(dev)); 768 struct tty *tp = sc->sc_tty; 769 int err; 770 771 DPRINTF(("ucycomread: sc=%p, tp=%p, uio=%p, flag=%d\n", sc, tp, uio, 772 flag)); 773 if (sc->sc_dying) 774 return EIO; 775 776 err = ((*tp->t_linesw->l_read)(tp, uio, flag)); 777 return err; 778 } 779 780 781 static int 782 ucycomwrite(dev_t dev, struct uio *uio, int flag) 783 { 784 struct ucycom_softc *sc = 785 device_lookup_private(&ucycom_cd, UCYCOMUNIT(dev)); 786 struct tty *tp = sc->sc_tty; 787 int err; 788 789 DPRINTF(("ucycomwrite: sc=%p, tp=%p, uio=%p, flag=%d\n", sc, tp, uio, 790 flag)); 791 if (sc->sc_dying) 792 return EIO; 793 794 err = ((*tp->t_linesw->l_write)(tp, uio, flag)); 795 return err; 796 } 797 798 static struct tty * 799 ucycomtty(dev_t dev) 800 { 801 struct ucycom_softc *sc = 802 device_lookup_private(&ucycom_cd, UCYCOMUNIT(dev)); 803 struct tty *tp = sc->sc_tty; 804 805 DPRINTF(("ucycomtty: sc=%p, tp=%p\n", sc, tp)); 806 807 return tp; 808 } 809 810 static int 811 ucycomioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) 812 { 813 struct ucycom_softc *sc = 814 device_lookup_private(&ucycom_cd, UCYCOMUNIT(dev)); 815 struct tty *tp = sc->sc_tty; 816 int err; 817 int s; 818 819 if (sc->sc_dying) 820 return EIO; 821 822 DPRINTF(("ucycomioctl: sc=%p, tp=%p, data=%p\n", sc, tp, data)); 823 824 err = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, l); 825 if (err != EPASSTHROUGH) 826 return err; 827 828 err = ttioctl(tp, cmd, data, flag, l); 829 if (err != EPASSTHROUGH) 830 return err; 831 832 err = 0; 833 834 DPRINTF(("ucycomioctl: our cmd=0x%08lx\n", cmd)); 835 s = spltty(); 836 837 switch (cmd) { 838 /* case TIOCSBRK: 839 ucycom_break(sc, 1); 840 break; 841 842 case TIOCCBRK: 843 ucycom_break(sc, 0); 844 break; 845 */ 846 case TIOCSDTR: 847 ucycom_dtr(sc, 1); 848 break; 849 850 case TIOCCDTR: 851 ucycom_dtr(sc, 0); 852 break; 853 854 case TIOCGFLAGS: 855 *(int *)data = sc->sc_swflags; 856 break; 857 858 case TIOCSFLAGS: 859 err = kauth_authorize_device_tty(l->l_cred, 860 KAUTH_DEVICE_TTY_PRIVSET, tp); 861 if (err) 862 break; 863 sc->sc_swflags = *(int *)data; 864 break; 865 866 case TIOCMSET: 867 case TIOCMBIS: 868 case TIOCMBIC: 869 tiocm_to_ucycom(sc, cmd, *(int *)data); 870 break; 871 872 case TIOCMGET: 873 *(int *)data = ucycom_to_tiocm(sc); 874 break; 875 876 default: 877 err = EPASSTHROUGH; 878 break; 879 } 880 881 splx(s); 882 883 return err; 884 } 885 886 static int 887 ucycompoll(dev_t dev, int events, struct lwp *l) 888 { 889 struct ucycom_softc *sc = 890 device_lookup_private(&ucycom_cd, UCYCOMUNIT(dev)); 891 struct tty *tp = sc->sc_tty; 892 int err; 893 894 DPRINTF(("ucycompoll: sc=%p, tp=%p, events=%d, lwp=%p\n", sc, tp, 895 events, l)); 896 897 if (sc->sc_dying) 898 return EIO; 899 900 err = ((*tp->t_linesw->l_poll)(tp, events, l)); 901 return err; 902 } 903 904 Static int 905 ucycom_configure(struct ucycom_softc *sc, uint32_t baud, uint8_t cfg) 906 { 907 uint8_t report[5]; 908 int err; 909 910 switch (baud) { 911 case 600: 912 case 1200: 913 case 2400: 914 case 4800: 915 case 9600: 916 case 19200: 917 case 38400: 918 case 57600: 919 #if 0 920 /* 921 * Stock chips only support standard baud rates in the 600 - 57600 922 * range, but higher rates can be achieved using custom firmware. 923 */ 924 case 115200: 925 case 153600: 926 case 192000: 927 #endif 928 break; 929 default: 930 return EINVAL; 931 } 932 933 DPRINTF(("ucycom_configure: setting %d baud, %d-%c-%d (%d)\n", baud, 934 5 + (cfg & UCYCOM_DATA_MASK), 935 (cfg & UCYCOM_PARITY_MASK) ? 936 ((cfg & UCYCOM_PARITY_TYPE_MASK) ? 'O' : 'E') : 'N', 937 (cfg & UCYCOM_STOP_MASK) ? 2 : 1, cfg)); 938 939 report[0] = baud & 0xff; 940 report[1] = (baud >> 8) & 0xff; 941 report[2] = (baud >> 16) & 0xff; 942 report[3] = (baud >> 24) & 0xff; 943 report[4] = cfg; 944 err = uhidev_set_report(sc->sc_hdev, UHID_FEATURE_REPORT, 945 report, sc->sc_flen); 946 if (err != 0) { 947 DPRINTF(("%s\n", usbd_errstr(err))); 948 return EIO; 949 } 950 sc->sc_baud = baud; 951 sc->sc_cfg = cfg; 952 953 #ifdef UCYCOM_DEBUG 954 ucycom_get_cfg(sc); 955 #endif 956 957 return 0; 958 } 959 960 Static void 961 ucycom_intr(void *cookie, void *ibuf, u_int len) 962 { 963 struct ucycom_softc *sc = cookie; 964 struct tty *tp = sc->sc_tty; 965 int (*rint)(int , struct tty *) = tp->t_linesw->l_rint; 966 uint8_t *cp = ibuf; 967 int s, n, st, chg; 968 969 /* We understand 8 byte and 32 byte input records */ 970 switch (len) { 971 case 8: 972 n = cp[0] & UCYCOM_LMASK; 973 st = cp[0] & ~UCYCOM_LMASK; 974 cp++; 975 break; 976 977 case 32: 978 st = cp[0]; 979 n = cp[1]; 980 cp += 2; 981 n = uimin(n, 30); 982 break; 983 984 default: 985 DPRINTFN(3,("ucycom_intr: Unknown input report length\n")); 986 return; 987 } 988 989 #ifdef UCYCOM_DEBUG 990 if (ucycomdebug > 5) { 991 uint32_t i; 992 993 if (n != 0) { 994 DPRINTF(("ucycom_intr: ibuf[0..%d) =", n)); 995 for (i = 0; i < n; i++) 996 DPRINTF((" %02x", cp[i])); 997 DPRINTF(("\n")); 998 } 999 } 1000 #endif 1001 1002 /* Give characters to tty layer. */ 1003 s = spltty(); 1004 while (n-- > 0) { 1005 DPRINTFN(7,("ucycom_intr: char=0x%02x\n", *cp)); 1006 if ((*rint)(*cp++, tp) == -1) { 1007 /* XXX what should we do? */ 1008 aprint_error_dev(sc->sc_dev, "lost a character\n"); 1009 break; 1010 } 1011 } 1012 splx(s); 1013 chg = st ^ sc->sc_msr; 1014 sc->sc_msr = st; 1015 if (ISSET(chg, UCYCOM_DCD)) 1016 (*tp->t_linesw->l_modem)(tp, 1017 ISSET(sc->sc_msr, UCYCOM_DCD)); 1018 1019 } 1020 1021 Static void 1022 tiocm_to_ucycom(struct ucycom_softc *sc, u_long how, int ttybits) 1023 { 1024 u_char combits; 1025 u_char before = sc->sc_mcr; 1026 1027 combits = 0; 1028 if (ISSET(ttybits, TIOCM_DTR)) 1029 SET(combits, UCYCOM_DTR); 1030 if (ISSET(ttybits, TIOCM_RTS)) 1031 SET(combits, UCYCOM_RTS); 1032 1033 switch (how) { 1034 case TIOCMBIC: 1035 CLR(sc->sc_mcr, combits); 1036 break; 1037 1038 case TIOCMBIS: 1039 SET(sc->sc_mcr, combits); 1040 break; 1041 1042 case TIOCMSET: 1043 CLR(sc->sc_mcr, UCYCOM_DTR | UCYCOM_RTS); 1044 SET(sc->sc_mcr, combits); 1045 break; 1046 } 1047 if (before ^ sc->sc_mcr) { 1048 DPRINTF(("tiocm_to_ucycom: something has changed\n")); 1049 ucycom_set_status(sc); 1050 } 1051 } 1052 1053 Static int 1054 ucycom_to_tiocm(struct ucycom_softc *sc) 1055 { 1056 u_char combits; 1057 int ttybits = 0; 1058 1059 combits = sc->sc_mcr; 1060 if (ISSET(combits, UCYCOM_DTR)) 1061 SET(ttybits, TIOCM_DTR); 1062 if (ISSET(combits, UCYCOM_RTS)) 1063 SET(ttybits, TIOCM_RTS); 1064 1065 combits = sc->sc_msr; 1066 if (ISSET(combits, UCYCOM_DCD)) 1067 SET(ttybits, TIOCM_CD); 1068 if (ISSET(combits, UCYCOM_CTS)) 1069 SET(ttybits, TIOCM_CTS); 1070 if (ISSET(combits, UCYCOM_DSR)) 1071 SET(ttybits, TIOCM_DSR); 1072 if (ISSET(combits, UCYCOM_RI)) 1073 SET(ttybits, TIOCM_RI); 1074 1075 return ttybits; 1076 } 1077 1078 Static void 1079 ucycom_dtr(struct ucycom_softc *sc, int set) 1080 { 1081 uint8_t old; 1082 1083 old = sc->sc_mcr; 1084 if (set) 1085 SET(sc->sc_mcr, UCYCOM_DTR); 1086 else 1087 CLR(sc->sc_mcr, UCYCOM_DTR); 1088 1089 if (old ^ sc->sc_mcr) 1090 ucycom_set_status(sc); 1091 } 1092 1093 #if 0 1094 Static void 1095 ucycom_rts(struct ucycom_softc *sc, int set) 1096 { 1097 uint8_t old; 1098 1099 old = sc->sc_msr; 1100 if (set) 1101 SET(sc->sc_mcr, UCYCOM_RTS); 1102 else 1103 CLR(sc->sc_mcr, UCYCOM_RTS); 1104 1105 if (old ^ sc->sc_mcr) 1106 ucycom_set_status(sc); 1107 } 1108 #endif 1109 1110 Static void 1111 ucycom_set_status(struct ucycom_softc *sc) 1112 { 1113 int err; 1114 1115 if (sc->sc_olen != 8 && sc->sc_olen != 32) { 1116 DPRINTFN(2,("ucycom_set_status: unknown output report " 1117 "size (%zd)\n", sc->sc_olen)); 1118 return; 1119 } 1120 1121 DPRINTF(("ucycom_set_status: %d\n", sc->sc_mcr)); 1122 1123 memset(sc->sc_obuf, 0, sc->sc_olen); 1124 sc->sc_obuf[0] = sc->sc_mcr; 1125 1126 err = uhidev_write(sc->sc_hdev, sc->sc_obuf, sc->sc_olen); 1127 if (err) { 1128 DPRINTF(("ucycom_set_status: err=%d\n", err)); 1129 } 1130 } 1131 1132 #ifdef UCYCOM_DEBUG 1133 Static void 1134 ucycom_get_cfg(struct ucycom_softc *sc) 1135 { 1136 int err, cfg, baud; 1137 uint8_t report[5]; 1138 1139 err = uhidev_get_report(sc->sc_hdev, UHID_FEATURE_REPORT, 1140 report, sc->sc_flen); 1141 if (err) { 1142 DPRINTF(("%s: failed\n", __func__)); 1143 return; 1144 } 1145 cfg = report[4]; 1146 baud = (report[3] << 24) + (report[2] << 16) + (report[1] << 8) + 1147 report[0]; 1148 DPRINTF(("ucycom_get_cfg: device reports %d baud, %d-%c-%d (%d)\n", 1149 baud, 5 + (cfg & UCYCOM_DATA_MASK), 1150 (cfg & UCYCOM_PARITY_MASK) ? 1151 ((cfg & UCYCOM_PARITY_TYPE_MASK) ? 'O' : 'E') : 'N', 1152 (cfg & UCYCOM_STOP_MASK) ? 2 : 1, cfg)); 1153 } 1154 #endif 1155 1156 Static void 1157 ucycom_cleanup(struct ucycom_softc *sc) 1158 { 1159 uint8_t *obuf; 1160 1161 DPRINTF(("ucycom_cleanup: closing uhidev\n")); 1162 1163 obuf = sc->sc_obuf; 1164 sc->sc_obuf = NULL; 1165 uhidev_close(sc->sc_hdev); 1166 1167 if (obuf != NULL) 1168 kmem_free(obuf, sc->sc_olen); 1169 } 1170
Indexes created Tue Sep 30 11:09:46 GMT 2025