umodem.c revision 1.9
1 /* $NetBSD: umodem.c,v 1.9 1999/08/16 20:26:53 augustss Exp $ */ 2 3 /* 4 * Copyright (c) 1998 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Lennart Augustsson (augustss (at) carlstedt.se) at 9 * Carlstedt Research & Technology. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 /* 41 * Comm Class spec: http://www.usb.org/developers/data/usbcdc11.pdf 42 */ 43 44 /* 45 * TODO: 46 * - Add error recovery in various places; the big problem is what 47 * to do in a callback if there is an error. 48 * - Implement a Call Device for modems without multiplexed commands. 49 * 50 */ 51 52 #include <sys/param.h> 53 #include <sys/systm.h> 54 #include <sys/kernel.h> 55 #include <sys/malloc.h> 56 #include <sys/ioctl.h> 57 #include <sys/conf.h> 58 #include <sys/tty.h> 59 #include <sys/file.h> 60 #include <sys/select.h> 61 #include <sys/proc.h> 62 #include <sys/vnode.h> 63 #include <sys/device.h> 64 #include <sys/poll.h> 65 66 #include <dev/usb/usb.h> 67 #include <dev/usb/usbcdc.h> 68 69 #include <dev/usb/usbdi.h> 70 #include <dev/usb/usbdi_util.h> 71 #include <dev/usb/usbdevs.h> 72 #include <dev/usb/usb_quirks.h> 73 74 #include <dev/usb/usbdevs.h> 75 76 #ifdef USB_DEBUG 77 #define DPRINTFN(n, x) if (umodemdebug > (n)) logprintf x 78 int umodemdebug = 0; 79 #else 80 #define DPRINTFN(n, x) 81 #endif 82 #define DPRINTF(x) DPRINTFN(0, x) 83 84 /* Macros to clear/set/test flags. */ 85 #define SET(t, f) (t) |= (f) 86 #define CLR(t, f) (t) &= ~((unsigned)(f)) 87 #define ISSET(t, f) ((t) & (f)) 88 89 #define UMODEMUNIT_MASK 0x3ffff 90 #define UMODEMDIALOUT_MASK 0x80000 91 #define UMODEMCALLUNIT_MASK 0x40000 92 93 #define UMODEMUNIT(x) (minor(x) & UMODEMUNIT_MASK) 94 #define UMODEMDIALOUT(x) (minor(x) & UMODEMDIALOUT_MASK) 95 #define UMODEMCALLUNIT(x) (minor(x) & UMODEMCALLUNIT_MASK) 96 97 #define UMODEMIBUFSIZE 64 98 99 struct umodem_softc { 100 bdevice sc_dev; /* base device */ 101 102 usbd_device_handle sc_udev; /* USB device */ 103 104 int sc_ctl_iface_no; 105 usbd_interface_handle sc_ctl_iface; /* control interface */ 106 int sc_data_iface_no; 107 usbd_interface_handle sc_data_iface; /* data interface */ 108 109 int sc_bulkin_no; /* bulk in endpoint address */ 110 usbd_pipe_handle sc_bulkin_pipe; /* bulk in pipe */ 111 usbd_request_handle sc_ireqh; /* read request */ 112 u_char *sc_ibuf; /* read buffer */ 113 114 int sc_bulkout_no; /* bulk out endpoint address */ 115 usbd_pipe_handle sc_bulkout_pipe;/* bulk out pipe */ 116 usbd_request_handle sc_oreqh; /* read request */ 117 118 int sc_cm_cap; /* CM capabilities */ 119 int sc_acm_cap; /* ACM capabilities */ 120 121 int sc_cm_over_data; 122 123 struct tty *sc_tty; /* our tty */ 124 125 usb_cdc_line_state_t sc_line_state; /* current line state */ 126 u_char sc_dtr; /* current DTR state */ 127 128 u_char sc_opening; /* lock during open */ 129 u_char sc_dying; /* disconnecting */ 130 }; 131 132 cdev_decl(umodem); 133 134 void *umodem_get_desc 135 __P((usbd_device_handle dev, int type, int subtype)); 136 usbd_status umodem_set_comm_feature 137 __P((struct umodem_softc *sc, int feature, int state)); 138 usbd_status umodem_set_line_coding 139 __P((struct umodem_softc *sc, usb_cdc_line_state_t *state)); 140 141 void umodem_get_caps __P((usbd_device_handle, int *, int *)); 142 void umodem_cleanup __P((struct umodem_softc *)); 143 int umodemparam __P((struct tty *, struct termios *)); 144 void umodemstart __P((struct tty *)); 145 void umodem_shutdown __P((struct umodem_softc *)); 146 void umodem_modem __P((struct umodem_softc *, int)); 147 void umodem_break __P((struct umodem_softc *, int)); 148 usbd_status umodemstartread __P((struct umodem_softc *)); 149 void umodemreadcb __P((usbd_request_handle, usbd_private_handle, 150 usbd_status status)); 151 void umodemwritecb __P((usbd_request_handle, usbd_private_handle, 152 usbd_status status)); 153 154 USB_DECLARE_DRIVER(umodem); 155 156 USB_MATCH(umodem) 157 { 158 USB_MATCH_START(umodem, uaa); 159 usb_interface_descriptor_t *id; 160 int cm, acm; 161 162 if (!uaa->iface) 163 return (UMATCH_NONE); 164 165 id = usbd_get_interface_descriptor(uaa->iface); 166 if (id == 0 || 167 id->bInterfaceClass != UCLASS_CDC || 168 id->bInterfaceSubClass != USUBCLASS_ABSTRACT_CONTROL_MODEL || 169 id->bInterfaceProtocol != UPROTO_CDC_AT) 170 return (UMATCH_NONE); 171 172 umodem_get_caps(uaa->device, &cm, &acm); 173 if (!(cm & USB_CDC_CM_DOES_CM) || 174 !(cm & USB_CDC_CM_OVER_DATA) || 175 !(acm & USB_CDC_ACM_HAS_LINE)) 176 return (UMATCH_NONE); 177 178 return (UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO); 179 } 180 181 USB_ATTACH(umodem) 182 { 183 USB_ATTACH_START(umodem, sc, uaa); 184 usbd_device_handle dev = uaa->device; 185 usb_interface_descriptor_t *id; 186 usb_endpoint_descriptor_t *ed; 187 usb_cdc_cm_descriptor_t *cmd; 188 char devinfo[1024]; 189 usbd_status r; 190 int data_ifaceno; 191 int i; 192 struct tty *tp; 193 194 usbd_devinfo(uaa->device, 0, devinfo); 195 USB_ATTACH_SETUP; 196 197 sc->sc_udev = dev; 198 199 sc->sc_ctl_iface = uaa->iface; 200 id = usbd_get_interface_descriptor(sc->sc_ctl_iface); 201 printf("%s: %s, iclass %d/%d\n", USBDEVNAME(sc->sc_dev), 202 devinfo, id->bInterfaceClass, id->bInterfaceSubClass); 203 sc->sc_ctl_iface_no = id->bInterfaceNumber; 204 205 umodem_get_caps(dev, &sc->sc_cm_cap, &sc->sc_acm_cap); 206 207 /* Get the data interface no. */ 208 cmd = umodem_get_desc(dev, UDESC_CS_INTERFACE, UDESCSUB_CDC_CM); 209 if (!cmd) { 210 DPRINTF(("%s: no CM desc\n", USBDEVNAME(sc->sc_dev))); 211 goto bad; 212 } 213 sc->sc_data_iface_no = data_ifaceno = cmd->bDataInterface; 214 215 printf("%s: data interface %d, has %sCM over data, has %sbreak\n", 216 USBDEVNAME(sc->sc_dev), data_ifaceno, 217 sc->sc_cm_cap & USB_CDC_CM_OVER_DATA ? "" : "no ", 218 sc->sc_acm_cap & USB_CDC_ACM_HAS_BREAK ? "" : "no "); 219 220 221 /* Get the data interface too. */ 222 for (i = 0; i < uaa->nifaces; i++) { 223 if (uaa->ifaces[i]) { 224 id = usbd_get_interface_descriptor(uaa->ifaces[i]); 225 if (id->bInterfaceNumber == data_ifaceno) { 226 sc->sc_data_iface = uaa->ifaces[i]; 227 uaa->ifaces[i] = 0; 228 } 229 } 230 } 231 if (!sc->sc_data_iface) { 232 printf("%s: no data interface\n", USBDEVNAME(sc->sc_dev)); 233 goto bad; 234 } 235 236 /* 237 * Find the bulk endpoints. 238 * Iterate over all endpoints in the data interface and take note. 239 */ 240 sc->sc_bulkin_no = sc->sc_bulkout_no = -1; 241 242 id = usbd_get_interface_descriptor(sc->sc_data_iface); 243 for (i = 0; i < id->bNumEndpoints; i++) { 244 ed = usbd_interface2endpoint_descriptor(sc->sc_data_iface, i); 245 if (!ed) { 246 printf("%s: no endpoint descriptor for %d\n", 247 USBDEVNAME(sc->sc_dev), i); 248 goto bad; 249 } 250 if (UE_GET_IN(ed->bEndpointAddress) && 251 (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) { 252 sc->sc_bulkin_no = ed->bEndpointAddress; 253 } else if (!UE_GET_IN(ed->bEndpointAddress) && 254 (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) { 255 sc->sc_bulkout_no = ed->bEndpointAddress; 256 } 257 } 258 259 if (sc->sc_bulkin_no == -1) { 260 DPRINTF(("%s: Could not find data bulk in\n", 261 USBDEVNAME(sc->sc_dev))); 262 goto bad; 263 } 264 if (sc->sc_bulkout_no == -1) { 265 DPRINTF(("%s: Could not find data bulk out\n", 266 USBDEVNAME(sc->sc_dev))); 267 goto bad; 268 } 269 270 if (sc->sc_cm_cap & USB_CDC_CM_OVER_DATA) { 271 r = umodem_set_comm_feature(sc, UCDC_ABSTRACT_STATE, 272 UCDC_DATA_MULTIPLEXED); 273 if (r != USBD_NORMAL_COMPLETION) 274 goto bad; 275 sc->sc_cm_over_data = 1; 276 } 277 278 tp = ttymalloc(); 279 tp->t_oproc = umodemstart; 280 tp->t_param = umodemparam; 281 sc->sc_tty = tp; 282 DPRINTF(("umodem_attach: tty_attach %p\n", tp)); 283 tty_attach(tp); 284 285 sc->sc_dtr = -1; 286 287 USB_ATTACH_SUCCESS_RETURN; 288 289 bad: 290 sc->sc_dying = 1; 291 USB_ATTACH_ERROR_RETURN; 292 } 293 294 void 295 umodem_get_caps(dev, cm, acm) 296 usbd_device_handle dev; 297 int *cm, *acm; 298 { 299 usb_cdc_cm_descriptor_t *cmd; 300 usb_cdc_acm_descriptor_t *cad; 301 302 *cm = *acm = 0; 303 304 cmd = umodem_get_desc(dev, UDESC_CS_INTERFACE, UDESCSUB_CDC_CM); 305 if (!cmd) { 306 DPRINTF(("umodem_get_desc: no CM desc\n")); 307 return; 308 } 309 *cm = cmd->bmCapabilities; 310 311 cad = umodem_get_desc(dev, UDESC_CS_INTERFACE, UDESCSUB_CDC_ACM); 312 if (!cad) { 313 DPRINTF(("umodem_get_desc: no ACM desc\n")); 314 return; 315 } 316 *acm = cad->bmCapabilities; 317 } 318 319 void 320 umodemstart(tp) 321 struct tty *tp; 322 { 323 struct umodem_softc *sc = umodem_cd.cd_devs[UMODEMUNIT(tp->t_dev)]; 324 usbd_status r; 325 int s; 326 u_char *data; 327 int cnt; 328 329 if (sc->sc_dying) 330 return; 331 332 s = spltty(); 333 if (ISSET(tp->t_state, TS_BUSY | TS_TIMEOUT | TS_TTSTOP)) { 334 DPRINTFN(4,("umodemstart: stopped\n")); 335 goto out; 336 } 337 338 if (tp->t_outq.c_cc <= tp->t_lowat) { 339 if (ISSET(tp->t_state, TS_ASLEEP)) { 340 CLR(tp->t_state, TS_ASLEEP); 341 wakeup(&tp->t_outq); 342 } 343 selwakeup(&tp->t_wsel); 344 if (tp->t_outq.c_cc == 0) 345 goto out; 346 } 347 348 /* Grab the first contiguous region of buffer space. */ 349 data = tp->t_outq.c_cf; 350 cnt = ndqb(&tp->t_outq, 0); 351 352 if (cnt == 0) { 353 DPRINTF(("umodemstart: cnt==0\n")); 354 splx(s); 355 return; 356 } 357 358 SET(tp->t_state, TS_BUSY); 359 360 DPRINTFN(4,("umodemstart: %d chars\n", cnt)); 361 /* XXX what can we do on error? */ 362 r = usbd_setup_request(sc->sc_oreqh, sc->sc_bulkout_pipe, 363 (usbd_private_handle)sc, data, cnt, 364 USBD_XFER_OUT, USBD_NO_TIMEOUT, umodemwritecb); 365 if (r != USBD_NORMAL_COMPLETION) 366 return; 367 (void)usbd_transfer(sc->sc_oreqh); 368 369 out: 370 splx(s); 371 } 372 373 void 374 umodemwritecb(reqh, p, status) 375 usbd_request_handle reqh; 376 usbd_private_handle p; 377 usbd_status status; 378 { 379 struct umodem_softc *sc = (struct umodem_softc *)p; 380 struct tty *tp = sc->sc_tty; 381 usbd_private_handle priv; 382 usbd_status r; 383 u_int32_t cc; 384 void *cp; 385 int s; 386 387 DPRINTFN(5,("umodemwritecb: status=%d\n", status)); 388 389 if (status == USBD_CANCELLED) 390 return; 391 392 if (status != USBD_NORMAL_COMPLETION) { 393 DPRINTF(("umodemwritecb: status=%d\n", status)); 394 usbd_clear_endpoint_stall_async(sc->sc_bulkin_pipe); 395 /* XXX we should restart after some delay. */ 396 return; 397 } 398 399 (void)usbd_get_request_status(reqh, &priv, &cp, &cc, &r); 400 DPRINTFN(5,("umodemwritecb: cc=%d\n", cc)); 401 402 s = spltty(); 403 CLR(tp->t_state, TS_BUSY); 404 if (ISSET(tp->t_state, TS_FLUSH)) 405 CLR(tp->t_state, TS_FLUSH); 406 else 407 ndflush(&tp->t_outq, cc); 408 (*linesw[tp->t_line].l_start)(tp); 409 splx(s); 410 } 411 412 int 413 umodemparam(tp, t) 414 struct tty *tp; 415 struct termios *t; 416 { 417 struct umodem_softc *sc = umodem_cd.cd_devs[UMODEMUNIT(tp->t_dev)]; 418 usb_cdc_line_state_t ls; 419 420 if (sc->sc_dying) 421 return (EIO); 422 423 /* Check requested parameters. */ 424 if (t->c_ospeed < 0) 425 return (EINVAL); 426 if (t->c_ispeed && t->c_ispeed != t->c_ospeed) 427 return (EINVAL); 428 429 /* 430 * If there were no changes, don't do anything. This avoids dropping 431 * input and improves performance when all we did was frob things like 432 * VMIN and VTIME. 433 */ 434 if (tp->t_ospeed == t->c_ospeed && 435 tp->t_cflag == t->c_cflag) 436 return (0); 437 438 /* And copy to tty. */ 439 tp->t_ispeed = 0; 440 tp->t_ospeed = t->c_ospeed; 441 tp->t_cflag = t->c_cflag; 442 443 USETDW(ls.dwDTERate, t->c_ospeed); 444 if (ISSET(t->c_cflag, CSTOPB)) 445 ls.bCharFormat = UCDC_STOP_BIT_2; 446 else 447 ls.bCharFormat = UCDC_STOP_BIT_1; 448 if (ISSET(t->c_cflag, PARENB)) { 449 if (ISSET(t->c_cflag, PARODD)) 450 ls.bParityType = UCDC_PARITY_ODD; 451 else 452 ls.bParityType = UCDC_PARITY_EVEN; 453 } else 454 ls.bParityType = UCDC_PARITY_NONE; 455 switch (ISSET(t->c_cflag, CSIZE)) { 456 case CS5: 457 ls.bDataBits = 5; 458 break; 459 case CS6: 460 ls.bDataBits = 6; 461 break; 462 case CS7: 463 ls.bDataBits = 7; 464 break; 465 case CS8: 466 ls.bDataBits = 8; 467 break; 468 } 469 /* XXX what can we if it fails? */ 470 (void)umodem_set_line_coding(sc, &ls); 471 472 /* 473 * Update the tty layer's idea of the carrier bit, in case we changed 474 * CLOCAL or MDMBUF. We don't hang up here; we only do that by 475 * explicit request. 476 */ 477 (void) (*linesw[tp->t_line].l_modem)(tp, 1 /* XXX carrier */ ); 478 479 return (0); 480 } 481 482 int 483 umodemopen(dev, flag, mode, p) 484 dev_t dev; 485 int flag, mode; 486 struct proc *p; 487 { 488 int unit = UMODEMUNIT(dev); 489 usbd_status r; 490 struct umodem_softc *sc; 491 struct tty *tp; 492 int s; 493 int error; 494 495 if (unit >= umodem_cd.cd_ndevs) 496 return (ENXIO); 497 sc = umodem_cd.cd_devs[unit]; 498 if (sc == 0) 499 return (ENXIO); 500 501 if (sc->sc_dying) 502 return (EIO); 503 504 if (ISSET(sc->sc_dev.dv_flags, DVF_ACTIVE) == 0) 505 return (ENXIO); 506 507 tp = sc->sc_tty; 508 509 DPRINTF(("umodemopen: unit=%d, tp=%p\n", unit, tp)); 510 511 if (ISSET(tp->t_state, TS_ISOPEN) && 512 ISSET(tp->t_state, TS_XCLUDE) && 513 p->p_ucred->cr_uid != 0) 514 return (EBUSY); 515 516 /* 517 * Do the following iff this is a first open. 518 */ 519 s = spltty(); 520 while (sc->sc_opening) 521 tsleep(&sc->sc_opening, PRIBIO, "umdmop", 0); 522 sc->sc_opening = 1; 523 524 if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) { 525 struct termios t; 526 527 tp->t_dev = dev; 528 529 /* 530 * Initialize the termios status to the defaults. Add in the 531 * sticky bits from TIOCSFLAGS. 532 */ 533 t.c_ispeed = 0; 534 t.c_ospeed = TTYDEF_SPEED; 535 t.c_cflag = TTYDEF_CFLAG; 536 /* Make sure umodemparam() will do something. */ 537 tp->t_ospeed = 0; 538 (void) umodemparam(tp, &t); 539 tp->t_iflag = TTYDEF_IFLAG; 540 tp->t_oflag = TTYDEF_OFLAG; 541 tp->t_lflag = TTYDEF_LFLAG; 542 ttychars(tp); 543 ttsetwater(tp); 544 545 /* 546 * Turn on DTR. We must always do this, even if carrier is not 547 * present, because otherwise we'd have to use TIOCSDTR 548 * immediately after setting CLOCAL, which applications do not 549 * expect. We always assert DTR while the device is open 550 * unless explicitly requested to deassert it. 551 */ 552 umodem_modem(sc, 1); 553 554 DPRINTF(("umodemopen: open pipes\n")); 555 556 /* Open the bulk pipes */ 557 r = usbd_open_pipe(sc->sc_data_iface, sc->sc_bulkin_no, 0, 558 &sc->sc_bulkin_pipe); 559 if (r != USBD_NORMAL_COMPLETION) { 560 DPRINTF(("%s: cannot open bulk out pipe (addr %d)\n", 561 USBDEVNAME(sc->sc_dev), sc->sc_bulkin_no)); 562 return (EIO); 563 } 564 r = usbd_open_pipe(sc->sc_data_iface, sc->sc_bulkout_no, 565 USBD_EXCLUSIVE_USE, &sc->sc_bulkout_pipe); 566 if (r != USBD_NORMAL_COMPLETION) { 567 DPRINTF(("%s: cannot open bulk in pipe (addr %d)\n", 568 USBDEVNAME(sc->sc_dev), sc->sc_bulkout_no)); 569 usbd_close_pipe(sc->sc_bulkin_pipe); 570 return (EIO); 571 } 572 573 /* Allocate a request and an input buffer and start reading. */ 574 sc->sc_ireqh = usbd_alloc_request(); 575 if (sc->sc_ireqh == 0) { 576 usbd_close_pipe(sc->sc_bulkin_pipe); 577 usbd_close_pipe(sc->sc_bulkout_pipe); 578 return (ENOMEM); 579 } 580 sc->sc_oreqh = usbd_alloc_request(); 581 if (sc->sc_oreqh == 0) { 582 usbd_close_pipe(sc->sc_bulkin_pipe); 583 usbd_close_pipe(sc->sc_bulkout_pipe); 584 usbd_free_request(sc->sc_ireqh); 585 return (ENOMEM); 586 } 587 sc->sc_ibuf = malloc(UMODEMIBUFSIZE, M_USBDEV, M_WAITOK); 588 umodemstartread(sc); 589 } 590 sc->sc_opening = 0; 591 wakeup(&sc->sc_opening); 592 splx(s); 593 594 error = ttyopen(tp, UMODEMDIALOUT(dev), ISSET(flag, O_NONBLOCK)); 595 if (error) 596 goto bad; 597 598 error = (*linesw[tp->t_line].l_open)(dev, tp); 599 if (error) 600 goto bad; 601 602 return (0); 603 604 bad: 605 if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) { 606 /* 607 * We failed to open the device, and nobody else had it opened. 608 * Clean up the state as appropriate. 609 */ 610 umodem_cleanup(sc); 611 } 612 613 return (error); 614 } 615 616 usbd_status 617 umodemstartread(sc) 618 struct umodem_softc *sc; 619 { 620 usbd_status r; 621 622 DPRINTFN(5,("umodemstartread: start\n")); 623 r = usbd_setup_request(sc->sc_ireqh, sc->sc_bulkin_pipe, 624 (usbd_private_handle)sc, 625 sc->sc_ibuf, 626 UMODEMIBUFSIZE, 627 USBD_XFER_IN | USBD_SHORT_XFER_OK, 628 USBD_NO_TIMEOUT, umodemreadcb); 629 if (r != USBD_NORMAL_COMPLETION) 630 return (r); 631 r = usbd_transfer(sc->sc_ireqh); 632 if (r != USBD_IN_PROGRESS) 633 return (r); 634 return (USBD_NORMAL_COMPLETION); 635 } 636 637 void 638 umodemreadcb(reqh, p, status) 639 usbd_request_handle reqh; 640 usbd_private_handle p; 641 usbd_status status; 642 { 643 struct umodem_softc *sc = (struct umodem_softc *)p; 644 struct tty *tp = sc->sc_tty; 645 int (*rint) __P((int c, struct tty *tp)) = linesw[tp->t_line].l_rint; 646 usbd_private_handle priv; 647 usbd_status r; 648 u_int32_t cc; 649 u_char *cp; 650 int s; 651 652 if (status == USBD_CANCELLED) 653 return; 654 655 if (status != USBD_NORMAL_COMPLETION) { 656 DPRINTF(("umodemreadcb: status=%d\n", status)); 657 usbd_clear_endpoint_stall_async(sc->sc_bulkin_pipe); 658 /* XXX we should restart after some delay. */ 659 return; 660 } 661 662 (void)usbd_get_request_status(reqh, &priv, (void **)&cp, &cc, &r); 663 DPRINTFN(5,("umodemreadcb: got %d chars, tp=%p\n", cc, tp)); 664 s = spltty(); 665 /* Give characters to tty layer. */ 666 while (cc-- > 0) { 667 DPRINTFN(7,("umodemreadcb: char=0x%02x\n", *cp)); 668 if ((*rint)(*cp++, tp) == -1) { 669 /* XXX what should we do? */ 670 break; 671 } 672 } 673 splx(s); 674 675 r = umodemstartread(sc); 676 if (r != USBD_NORMAL_COMPLETION) { 677 printf("%s: read start failed\n", USBDEVNAME(sc->sc_dev)); 678 /* XXX what should we dow now? */ 679 } 680 } 681 682 int 683 umodemclose(dev, flag, mode, p) 684 dev_t dev; 685 int flag, mode; 686 struct proc *p; 687 { 688 struct umodem_softc *sc = umodem_cd.cd_devs[UMODEMUNIT(dev)]; 689 struct tty *tp = sc->sc_tty; 690 691 DPRINTF(("umodemclose: unit=%d\n", UMODEMUNIT(dev))); 692 if (!ISSET(tp->t_state, TS_ISOPEN)) 693 return (0); 694 695 (*linesw[tp->t_line].l_close)(tp, flag); 696 ttyclose(tp); 697 698 if (sc->sc_dying) 699 return (0); 700 701 if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) { 702 /* 703 * Although we got a last close, the device may still be in 704 * use; e.g. if this was the dialout node, and there are still 705 * processes waiting for carrier on the non-dialout node. 706 */ 707 umodem_cleanup(sc); 708 } 709 710 return (0); 711 } 712 713 void 714 umodem_cleanup(sc) 715 struct umodem_softc *sc; 716 { 717 umodem_shutdown(sc); 718 DPRINTF(("umodem_cleanup: closing pipes\n")); 719 usbd_abort_pipe(sc->sc_bulkin_pipe); 720 usbd_close_pipe(sc->sc_bulkin_pipe); 721 usbd_abort_pipe(sc->sc_bulkout_pipe); 722 usbd_close_pipe(sc->sc_bulkout_pipe); 723 usbd_free_request(sc->sc_ireqh); 724 usbd_free_request(sc->sc_oreqh); 725 free(sc->sc_ibuf, M_USBDEV); 726 } 727 728 int 729 umodemread(dev, uio, flag) 730 dev_t dev; 731 struct uio *uio; 732 int flag; 733 { 734 struct umodem_softc *sc = umodem_cd.cd_devs[UMODEMUNIT(dev)]; 735 struct tty *tp = sc->sc_tty; 736 737 if (sc->sc_dying) 738 return (EIO); 739 740 return ((*linesw[tp->t_line].l_read)(tp, uio, flag)); 741 } 742 743 int 744 umodemwrite(dev, uio, flag) 745 dev_t dev; 746 struct uio *uio; 747 int flag; 748 { 749 struct umodem_softc *sc = umodem_cd.cd_devs[UMODEMUNIT(dev)]; 750 struct tty *tp = sc->sc_tty; 751 752 if (sc->sc_dying) 753 return (EIO); 754 755 return ((*linesw[tp->t_line].l_write)(tp, uio, flag)); 756 } 757 758 void 759 umodemstop(tp, flag) 760 struct tty *tp; 761 int flag; 762 { 763 /*struct umodem_softc *sc = umodem_cd.cd_devs[UMODEMUNIT(tp->t_dev)];*/ 764 int s; 765 766 DPRINTF(("umodemstop: %d\n", flag)); 767 s = spltty(); 768 if (ISSET(tp->t_state, TS_BUSY)) { 769 DPRINTF(("umodemstop: XXX\n")); 770 /* XXX do what? */ 771 if (!ISSET(tp->t_state, TS_TTSTOP)) 772 SET(tp->t_state, TS_FLUSH); 773 } 774 splx(s); 775 } 776 777 struct tty * 778 umodemtty(dev) 779 dev_t dev; 780 { 781 struct umodem_softc *sc = umodem_cd.cd_devs[UMODEMUNIT(dev)]; 782 struct tty *tp = sc->sc_tty; 783 784 return (tp); 785 } 786 787 int 788 umodemioctl(dev, cmd, data, flag, p) 789 dev_t dev; 790 u_long cmd; 791 caddr_t data; 792 int flag; 793 struct proc *p; 794 { 795 struct umodem_softc *sc = umodem_cd.cd_devs[UMODEMUNIT(dev)]; 796 struct tty *tp = sc->sc_tty; 797 int error; 798 int s; 799 800 if (sc->sc_dying) 801 return (EIO); 802 803 DPRINTF(("umodemioctl: cmd=0x%08lx\n", cmd)); 804 805 error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p); 806 if (error >= 0) 807 return (error); 808 809 error = ttioctl(tp, cmd, data, flag, p); 810 if (error >= 0) 811 return (error); 812 813 error = 0; 814 815 DPRINTF(("umodemioctl: our cmd=0x%08lx\n", cmd)); 816 s = spltty(); 817 818 switch (cmd) { 819 case TIOCSBRK: 820 umodem_break(sc, 1); 821 break; 822 823 case TIOCCBRK: 824 umodem_break(sc, 0); 825 break; 826 827 case TIOCSDTR: 828 umodem_modem(sc, 1); 829 break; 830 831 case TIOCCDTR: 832 umodem_modem(sc, 0); 833 break; 834 835 case USB_GET_CM_OVER_DATA: 836 *(int *)data = sc->sc_cm_over_data; 837 break; 838 839 case USB_SET_CM_OVER_DATA: 840 if (*(int *)data != sc->sc_cm_over_data) { 841 /* XXX change it */ 842 } 843 break; 844 845 default: 846 DPRINTF(("umodemioctl: unknown\n")); 847 error = ENOTTY; 848 break; 849 } 850 851 splx(s); 852 853 return (error); 854 } 855 856 void 857 umodem_shutdown(sc) 858 struct umodem_softc *sc; 859 { 860 struct tty *tp = sc->sc_tty; 861 862 DPRINTF(("umodem_shutdown\n")); 863 /* 864 * Hang up if necessary. Wait a bit, so the other side has time to 865 * notice even if we immediately open the port again. 866 */ 867 if (ISSET(tp->t_cflag, HUPCL)) { 868 umodem_modem(sc, 0); 869 (void) tsleep(sc, TTIPRI, ttclos, hz); 870 } 871 } 872 873 void 874 umodem_modem(sc, onoff) 875 struct umodem_softc *sc; 876 int onoff; 877 { 878 usb_device_request_t req; 879 880 DPRINTF(("umodem_modem: onoff=%d\n", onoff)); 881 882 if (sc->sc_dtr == onoff) 883 return; 884 885 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 886 req.bRequest = UCDC_SET_CONTROL_LINE_STATE; 887 USETW(req.wValue, onoff ? UCDC_LINE_DTR : 0); 888 USETW(req.wIndex, sc->sc_ctl_iface_no); 889 USETW(req.wLength, 0); 890 891 (void)usbd_do_request(sc->sc_udev, &req, 0); 892 893 sc->sc_dtr = onoff; 894 } 895 896 void 897 umodem_break(sc, onoff) 898 struct umodem_softc *sc; 899 int onoff; 900 { 901 usb_device_request_t req; 902 903 DPRINTF(("umodem_break: onoff=%d\n", onoff)); 904 905 if (!(sc->sc_acm_cap & USB_CDC_ACM_HAS_BREAK)) 906 return; 907 908 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 909 req.bRequest = UCDC_SEND_BREAK; 910 USETW(req.wValue, onoff ? UCDC_BREAK_ON : UCDC_BREAK_OFF); 911 USETW(req.wIndex, sc->sc_ctl_iface_no); 912 USETW(req.wLength, 0); 913 914 (void)usbd_do_request(sc->sc_udev, &req, 0); 915 } 916 917 void * 918 umodem_get_desc(dev, type, subtype) 919 usbd_device_handle dev; 920 int type; 921 int subtype; 922 { 923 usb_descriptor_t *desc; 924 usb_config_descriptor_t *cd = usbd_get_config_descriptor(dev); 925 uByte *p = (uByte *)cd; 926 uByte *end = p + UGETW(cd->wTotalLength); 927 928 while (p < end) { 929 desc = (usb_descriptor_t *)p; 930 if (desc->bDescriptorType == type && 931 desc->bDescriptorSubtype == subtype) 932 return (desc); 933 p += desc->bLength; 934 } 935 936 return (0); 937 } 938 939 usbd_status 940 umodem_set_comm_feature(sc, feature, state) 941 struct umodem_softc *sc; 942 int feature; 943 int state; 944 { 945 usb_device_request_t req; 946 usbd_status r; 947 usb_cdc_abstract_state_t ast; 948 949 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 950 req.bRequest = UCDC_SET_COMM_FEATURE; 951 USETW(req.wValue, feature); 952 USETW(req.wIndex, sc->sc_ctl_iface_no); 953 USETW(req.wLength, UCDC_ABSTRACT_STATE_LENGTH); 954 USETW(ast.wState, state); 955 956 r = usbd_do_request(sc->sc_udev, &req, &ast); 957 if (r != USBD_NORMAL_COMPLETION) { 958 DPRINTF(("umodem_set_comm_feature: feature=%d failed, r=%d\n", 959 feature, r)); 960 return (r); 961 } 962 963 return (USBD_NORMAL_COMPLETION); 964 } 965 966 usbd_status 967 umodem_set_line_coding(sc, state) 968 struct umodem_softc *sc; 969 usb_cdc_line_state_t *state; 970 { 971 usb_device_request_t req; 972 usbd_status r; 973 974 DPRINTF(("umodem_set_line_coding: rate=%d fmt=%d parity=%d bits=%d\n", 975 UGETDW(state->dwDTERate), state->bCharFormat, 976 state->bParityType, state->bDataBits)); 977 978 if (memcmp(state, &sc->sc_line_state, UCDC_LINE_STATE_LENGTH) == 0) { 979 DPRINTF(("umodem_set_line_coding: already set\n")); 980 return (USBD_NORMAL_COMPLETION); 981 } 982 983 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 984 req.bRequest = UCDC_SET_LINE_CODING; 985 USETW(req.wValue, 0); 986 USETW(req.wIndex, sc->sc_ctl_iface_no); 987 USETW(req.wLength, UCDC_LINE_STATE_LENGTH); 988 989 r = usbd_do_request(sc->sc_udev, &req, state); 990 if (r != USBD_NORMAL_COMPLETION) { 991 DPRINTF(("umodem_set_line_coding: failed, r=%d\n", r)); 992 return (r); 993 } 994 995 sc->sc_line_state = *state; 996 997 return (USBD_NORMAL_COMPLETION); 998 } 999 1000 int 1001 umodem_activate(self, act) 1002 struct device *self; 1003 enum devact act; 1004 { 1005 struct umodem_softc *sc = (struct umodem_softc *)self; 1006 1007 switch (act) { 1008 case DVACT_ACTIVATE: 1009 return (EOPNOTSUPP); 1010 break; 1011 1012 case DVACT_DEACTIVATE: 1013 sc->sc_dying = 1; 1014 break; 1015 } 1016 return (0); 1017 } 1018 1019 int 1020 umodem_detach(self, flags) 1021 struct device *self; 1022 int flags; 1023 { 1024 struct umodem_softc *sc = (struct umodem_softc *)self; 1025 int maj, mn; 1026 1027 DPRINTF(("umodem_detach: sc=%p flags=%d tp=%p\n", 1028 sc, flags, sc->sc_tty)); 1029 1030 sc->sc_dying = 1; 1031 1032 #ifdef DIAGNOSTIC 1033 if (sc->sc_tty == 0) { 1034 DPRINTF(("umodem_detach: no tty\n")); 1035 return (0); 1036 } 1037 #endif 1038 1039 /* use refernce count? XXX */ 1040 1041 /* locate the major number */ 1042 for (maj = 0; maj < nchrdev; maj++) 1043 if (cdevsw[maj].d_open == umodemopen) 1044 break; 1045 1046 /* Nuke the vnodes for any open instances. */ 1047 mn = self->dv_unit; 1048 vdevgone(maj, mn, mn, VCHR); 1049 vdevgone(maj, mn, mn | UMODEMDIALOUT_MASK, VCHR); 1050 vdevgone(maj, mn, mn | UMODEMCALLUNIT_MASK, VCHR); 1051 1052 /* Detach and free the tty. */ 1053 tty_detach(sc->sc_tty); 1054 ttyfree(sc->sc_tty); 1055 sc->sc_tty = 0; 1056 1057 return (0); 1058 } 1059
Indexes created Thu Sep 25 02:09:54 GMT 2025