umodem.c revision 1.13
1 /* $NetBSD: umodem.c,v 1.13 1999/09/05 19:32:19 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 USBBASEDEVICE 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_DIR(ed->bEndpointAddress) == UE_DIR_IN && 251 (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) { 252 sc->sc_bulkin_no = ed->bEndpointAddress; 253 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT && 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 u_int32_t cc; 382 int s; 383 384 DPRINTFN(5,("umodemwritecb: status=%d\n", status)); 385 386 if (status == USBD_CANCELLED) 387 return; 388 389 if (status != USBD_NORMAL_COMPLETION) { 390 DPRINTF(("umodemwritecb: status=%d\n", status)); 391 usbd_clear_endpoint_stall_async(sc->sc_bulkin_pipe); 392 /* XXX we should restart after some delay. */ 393 return; 394 } 395 396 usbd_get_request_status(reqh, 0, 0, &cc, 0); 397 DPRINTFN(5,("umodemwritecb: cc=%d\n", cc)); 398 399 s = spltty(); 400 CLR(tp->t_state, TS_BUSY); 401 if (ISSET(tp->t_state, TS_FLUSH)) 402 CLR(tp->t_state, TS_FLUSH); 403 else 404 ndflush(&tp->t_outq, cc); 405 (*linesw[tp->t_line].l_start)(tp); 406 splx(s); 407 } 408 409 int 410 umodemparam(tp, t) 411 struct tty *tp; 412 struct termios *t; 413 { 414 struct umodem_softc *sc = umodem_cd.cd_devs[UMODEMUNIT(tp->t_dev)]; 415 usb_cdc_line_state_t ls; 416 417 if (sc->sc_dying) 418 return (EIO); 419 420 /* Check requested parameters. */ 421 if (t->c_ospeed < 0) 422 return (EINVAL); 423 if (t->c_ispeed && t->c_ispeed != t->c_ospeed) 424 return (EINVAL); 425 426 /* 427 * If there were no changes, don't do anything. This avoids dropping 428 * input and improves performance when all we did was frob things like 429 * VMIN and VTIME. 430 */ 431 if (tp->t_ospeed == t->c_ospeed && 432 tp->t_cflag == t->c_cflag) 433 return (0); 434 435 /* And copy to tty. */ 436 tp->t_ispeed = 0; 437 tp->t_ospeed = t->c_ospeed; 438 tp->t_cflag = t->c_cflag; 439 440 USETDW(ls.dwDTERate, t->c_ospeed); 441 if (ISSET(t->c_cflag, CSTOPB)) 442 ls.bCharFormat = UCDC_STOP_BIT_2; 443 else 444 ls.bCharFormat = UCDC_STOP_BIT_1; 445 if (ISSET(t->c_cflag, PARENB)) { 446 if (ISSET(t->c_cflag, PARODD)) 447 ls.bParityType = UCDC_PARITY_ODD; 448 else 449 ls.bParityType = UCDC_PARITY_EVEN; 450 } else 451 ls.bParityType = UCDC_PARITY_NONE; 452 switch (ISSET(t->c_cflag, CSIZE)) { 453 case CS5: 454 ls.bDataBits = 5; 455 break; 456 case CS6: 457 ls.bDataBits = 6; 458 break; 459 case CS7: 460 ls.bDataBits = 7; 461 break; 462 case CS8: 463 ls.bDataBits = 8; 464 break; 465 } 466 /* XXX what can we if it fails? */ 467 (void)umodem_set_line_coding(sc, &ls); 468 469 /* 470 * Update the tty layer's idea of the carrier bit, in case we changed 471 * CLOCAL or MDMBUF. We don't hang up here; we only do that by 472 * explicit request. 473 */ 474 (void) (*linesw[tp->t_line].l_modem)(tp, 1 /* XXX carrier */ ); 475 476 return (0); 477 } 478 479 int 480 umodemopen(dev, flag, mode, p) 481 dev_t dev; 482 int flag, mode; 483 struct proc *p; 484 { 485 int unit = UMODEMUNIT(dev); 486 usbd_status r; 487 struct umodem_softc *sc; 488 struct tty *tp; 489 int s; 490 int error; 491 492 if (unit >= umodem_cd.cd_ndevs) 493 return (ENXIO); 494 sc = umodem_cd.cd_devs[unit]; 495 if (sc == 0) 496 return (ENXIO); 497 498 if (sc->sc_dying) 499 return (EIO); 500 501 if (ISSET(sc->sc_dev.dv_flags, DVF_ACTIVE) == 0) 502 return (ENXIO); 503 504 tp = sc->sc_tty; 505 506 DPRINTF(("umodemopen: unit=%d, tp=%p\n", unit, tp)); 507 508 if (ISSET(tp->t_state, TS_ISOPEN) && 509 ISSET(tp->t_state, TS_XCLUDE) && 510 p->p_ucred->cr_uid != 0) 511 return (EBUSY); 512 513 /* 514 * Do the following iff this is a first open. 515 */ 516 s = spltty(); 517 while (sc->sc_opening) 518 tsleep(&sc->sc_opening, PRIBIO, "umdmop", 0); 519 sc->sc_opening = 1; 520 521 if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) { 522 struct termios t; 523 524 tp->t_dev = dev; 525 526 /* 527 * Initialize the termios status to the defaults. Add in the 528 * sticky bits from TIOCSFLAGS. 529 */ 530 t.c_ispeed = 0; 531 t.c_ospeed = TTYDEF_SPEED; 532 t.c_cflag = TTYDEF_CFLAG; 533 /* Make sure umodemparam() will do something. */ 534 tp->t_ospeed = 0; 535 (void) umodemparam(tp, &t); 536 tp->t_iflag = TTYDEF_IFLAG; 537 tp->t_oflag = TTYDEF_OFLAG; 538 tp->t_lflag = TTYDEF_LFLAG; 539 ttychars(tp); 540 ttsetwater(tp); 541 542 /* 543 * Turn on DTR. We must always do this, even if carrier is not 544 * present, because otherwise we'd have to use TIOCSDTR 545 * immediately after setting CLOCAL, which applications do not 546 * expect. We always assert DTR while the device is open 547 * unless explicitly requested to deassert it. 548 */ 549 umodem_modem(sc, 1); 550 551 DPRINTF(("umodemopen: open pipes\n")); 552 553 /* Open the bulk pipes */ 554 r = usbd_open_pipe(sc->sc_data_iface, sc->sc_bulkin_no, 0, 555 &sc->sc_bulkin_pipe); 556 if (r != USBD_NORMAL_COMPLETION) { 557 DPRINTF(("%s: cannot open bulk out pipe (addr %d)\n", 558 USBDEVNAME(sc->sc_dev), sc->sc_bulkin_no)); 559 return (EIO); 560 } 561 r = usbd_open_pipe(sc->sc_data_iface, sc->sc_bulkout_no, 562 USBD_EXCLUSIVE_USE, &sc->sc_bulkout_pipe); 563 if (r != USBD_NORMAL_COMPLETION) { 564 DPRINTF(("%s: cannot open bulk in pipe (addr %d)\n", 565 USBDEVNAME(sc->sc_dev), sc->sc_bulkout_no)); 566 usbd_close_pipe(sc->sc_bulkin_pipe); 567 return (EIO); 568 } 569 570 /* Allocate a request and an input buffer and start reading. */ 571 sc->sc_ireqh = usbd_alloc_request(); 572 if (sc->sc_ireqh == 0) { 573 usbd_close_pipe(sc->sc_bulkin_pipe); 574 usbd_close_pipe(sc->sc_bulkout_pipe); 575 return (ENOMEM); 576 } 577 sc->sc_oreqh = usbd_alloc_request(); 578 if (sc->sc_oreqh == 0) { 579 usbd_close_pipe(sc->sc_bulkin_pipe); 580 usbd_close_pipe(sc->sc_bulkout_pipe); 581 usbd_free_request(sc->sc_ireqh); 582 return (ENOMEM); 583 } 584 sc->sc_ibuf = malloc(UMODEMIBUFSIZE, M_USBDEV, M_WAITOK); 585 umodemstartread(sc); 586 } 587 sc->sc_opening = 0; 588 wakeup(&sc->sc_opening); 589 splx(s); 590 591 error = ttyopen(tp, UMODEMDIALOUT(dev), ISSET(flag, O_NONBLOCK)); 592 if (error) 593 goto bad; 594 595 error = (*linesw[tp->t_line].l_open)(dev, tp); 596 if (error) 597 goto bad; 598 599 return (0); 600 601 bad: 602 if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) { 603 /* 604 * We failed to open the device, and nobody else had it opened. 605 * Clean up the state as appropriate. 606 */ 607 umodem_cleanup(sc); 608 } 609 610 return (error); 611 } 612 613 usbd_status 614 umodemstartread(sc) 615 struct umodem_softc *sc; 616 { 617 usbd_status r; 618 619 DPRINTFN(5,("umodemstartread: start\n")); 620 r = usbd_setup_request(sc->sc_ireqh, sc->sc_bulkin_pipe, 621 (usbd_private_handle)sc, 622 sc->sc_ibuf, 623 UMODEMIBUFSIZE, 624 USBD_XFER_IN | USBD_SHORT_XFER_OK, 625 USBD_NO_TIMEOUT, umodemreadcb); 626 if (r != USBD_NORMAL_COMPLETION) 627 return (r); 628 r = usbd_transfer(sc->sc_ireqh); 629 if (r != USBD_IN_PROGRESS) 630 return (r); 631 return (USBD_NORMAL_COMPLETION); 632 } 633 634 void 635 umodemreadcb(reqh, p, status) 636 usbd_request_handle reqh; 637 usbd_private_handle p; 638 usbd_status status; 639 { 640 struct umodem_softc *sc = (struct umodem_softc *)p; 641 struct tty *tp = sc->sc_tty; 642 int (*rint) __P((int c, struct tty *tp)) = linesw[tp->t_line].l_rint; 643 usbd_status r; 644 u_int32_t cc; 645 u_char *cp; 646 int s; 647 648 if (status == USBD_CANCELLED) 649 return; 650 651 if (status != USBD_NORMAL_COMPLETION) { 652 DPRINTF(("umodemreadcb: status=%d\n", status)); 653 usbd_clear_endpoint_stall_async(sc->sc_bulkin_pipe); 654 /* XXX we should restart after some delay. */ 655 return; 656 } 657 658 usbd_get_request_status(reqh, 0, (void **)&cp, &cc, 0); 659 DPRINTFN(5,("umodemreadcb: got %d chars, tp=%p\n", cc, tp)); 660 s = spltty(); 661 /* Give characters to tty layer. */ 662 while (cc-- > 0) { 663 DPRINTFN(7,("umodemreadcb: char=0x%02x\n", *cp)); 664 if ((*rint)(*cp++, tp) == -1) { 665 /* XXX what should we do? */ 666 break; 667 } 668 } 669 splx(s); 670 671 r = umodemstartread(sc); 672 if (r != USBD_NORMAL_COMPLETION) { 673 printf("%s: read start failed\n", USBDEVNAME(sc->sc_dev)); 674 /* XXX what should we dow now? */ 675 } 676 } 677 678 int 679 umodemclose(dev, flag, mode, p) 680 dev_t dev; 681 int flag, mode; 682 struct proc *p; 683 { 684 struct umodem_softc *sc = umodem_cd.cd_devs[UMODEMUNIT(dev)]; 685 struct tty *tp = sc->sc_tty; 686 687 DPRINTF(("umodemclose: unit=%d\n", UMODEMUNIT(dev))); 688 if (!ISSET(tp->t_state, TS_ISOPEN)) 689 return (0); 690 691 (*linesw[tp->t_line].l_close)(tp, flag); 692 ttyclose(tp); 693 694 if (sc->sc_dying) 695 return (0); 696 697 if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) { 698 /* 699 * Although we got a last close, the device may still be in 700 * use; e.g. if this was the dialout node, and there are still 701 * processes waiting for carrier on the non-dialout node. 702 */ 703 umodem_cleanup(sc); 704 } 705 706 return (0); 707 } 708 709 void 710 umodem_cleanup(sc) 711 struct umodem_softc *sc; 712 { 713 umodem_shutdown(sc); 714 DPRINTF(("umodem_cleanup: closing pipes\n")); 715 usbd_abort_pipe(sc->sc_bulkin_pipe); 716 usbd_close_pipe(sc->sc_bulkin_pipe); 717 usbd_abort_pipe(sc->sc_bulkout_pipe); 718 usbd_close_pipe(sc->sc_bulkout_pipe); 719 usbd_free_request(sc->sc_ireqh); 720 usbd_free_request(sc->sc_oreqh); 721 free(sc->sc_ibuf, M_USBDEV); 722 } 723 724 int 725 umodemread(dev, uio, flag) 726 dev_t dev; 727 struct uio *uio; 728 int flag; 729 { 730 struct umodem_softc *sc = umodem_cd.cd_devs[UMODEMUNIT(dev)]; 731 struct tty *tp = sc->sc_tty; 732 733 if (sc->sc_dying) 734 return (EIO); 735 736 return ((*linesw[tp->t_line].l_read)(tp, uio, flag)); 737 } 738 739 int 740 umodemwrite(dev, uio, flag) 741 dev_t dev; 742 struct uio *uio; 743 int flag; 744 { 745 struct umodem_softc *sc = umodem_cd.cd_devs[UMODEMUNIT(dev)]; 746 struct tty *tp = sc->sc_tty; 747 748 if (sc->sc_dying) 749 return (EIO); 750 751 return ((*linesw[tp->t_line].l_write)(tp, uio, flag)); 752 } 753 754 void 755 umodemstop(tp, flag) 756 struct tty *tp; 757 int flag; 758 { 759 /*struct umodem_softc *sc = umodem_cd.cd_devs[UMODEMUNIT(tp->t_dev)];*/ 760 int s; 761 762 DPRINTF(("umodemstop: %d\n", flag)); 763 s = spltty(); 764 if (ISSET(tp->t_state, TS_BUSY)) { 765 DPRINTF(("umodemstop: XXX\n")); 766 /* XXX do what? */ 767 if (!ISSET(tp->t_state, TS_TTSTOP)) 768 SET(tp->t_state, TS_FLUSH); 769 } 770 splx(s); 771 } 772 773 struct tty * 774 umodemtty(dev) 775 dev_t dev; 776 { 777 struct umodem_softc *sc = umodem_cd.cd_devs[UMODEMUNIT(dev)]; 778 struct tty *tp = sc->sc_tty; 779 780 return (tp); 781 } 782 783 int 784 umodemioctl(dev, cmd, data, flag, p) 785 dev_t dev; 786 u_long cmd; 787 caddr_t data; 788 int flag; 789 struct proc *p; 790 { 791 struct umodem_softc *sc = umodem_cd.cd_devs[UMODEMUNIT(dev)]; 792 struct tty *tp = sc->sc_tty; 793 int error; 794 int s; 795 796 if (sc->sc_dying) 797 return (EIO); 798 799 DPRINTF(("umodemioctl: cmd=0x%08lx\n", cmd)); 800 801 error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p); 802 if (error >= 0) 803 return (error); 804 805 error = ttioctl(tp, cmd, data, flag, p); 806 if (error >= 0) 807 return (error); 808 809 error = 0; 810 811 DPRINTF(("umodemioctl: our cmd=0x%08lx\n", cmd)); 812 s = spltty(); 813 814 switch (cmd) { 815 case TIOCSBRK: 816 umodem_break(sc, 1); 817 break; 818 819 case TIOCCBRK: 820 umodem_break(sc, 0); 821 break; 822 823 case TIOCSDTR: 824 umodem_modem(sc, 1); 825 break; 826 827 case TIOCCDTR: 828 umodem_modem(sc, 0); 829 break; 830 831 case USB_GET_CM_OVER_DATA: 832 *(int *)data = sc->sc_cm_over_data; 833 break; 834 835 case USB_SET_CM_OVER_DATA: 836 if (*(int *)data != sc->sc_cm_over_data) { 837 /* XXX change it */ 838 } 839 break; 840 841 default: 842 DPRINTF(("umodemioctl: unknown\n")); 843 error = ENOTTY; 844 break; 845 } 846 847 splx(s); 848 849 return (error); 850 } 851 852 void 853 umodem_shutdown(sc) 854 struct umodem_softc *sc; 855 { 856 struct tty *tp = sc->sc_tty; 857 858 DPRINTF(("umodem_shutdown\n")); 859 /* 860 * Hang up if necessary. Wait a bit, so the other side has time to 861 * notice even if we immediately open the port again. 862 */ 863 if (ISSET(tp->t_cflag, HUPCL)) { 864 umodem_modem(sc, 0); 865 (void) tsleep(sc, TTIPRI, ttclos, hz); 866 } 867 } 868 869 void 870 umodem_modem(sc, onoff) 871 struct umodem_softc *sc; 872 int onoff; 873 { 874 usb_device_request_t req; 875 876 DPRINTF(("umodem_modem: onoff=%d\n", onoff)); 877 878 if (sc->sc_dtr == onoff) 879 return; 880 881 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 882 req.bRequest = UCDC_SET_CONTROL_LINE_STATE; 883 USETW(req.wValue, onoff ? UCDC_LINE_DTR : 0); 884 USETW(req.wIndex, sc->sc_ctl_iface_no); 885 USETW(req.wLength, 0); 886 887 (void)usbd_do_request(sc->sc_udev, &req, 0); 888 889 sc->sc_dtr = onoff; 890 } 891 892 void 893 umodem_break(sc, onoff) 894 struct umodem_softc *sc; 895 int onoff; 896 { 897 usb_device_request_t req; 898 899 DPRINTF(("umodem_break: onoff=%d\n", onoff)); 900 901 if (!(sc->sc_acm_cap & USB_CDC_ACM_HAS_BREAK)) 902 return; 903 904 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 905 req.bRequest = UCDC_SEND_BREAK; 906 USETW(req.wValue, onoff ? UCDC_BREAK_ON : UCDC_BREAK_OFF); 907 USETW(req.wIndex, sc->sc_ctl_iface_no); 908 USETW(req.wLength, 0); 909 910 (void)usbd_do_request(sc->sc_udev, &req, 0); 911 } 912 913 void * 914 umodem_get_desc(dev, type, subtype) 915 usbd_device_handle dev; 916 int type; 917 int subtype; 918 { 919 usb_descriptor_t *desc; 920 usb_config_descriptor_t *cd = usbd_get_config_descriptor(dev); 921 uByte *p = (uByte *)cd; 922 uByte *end = p + UGETW(cd->wTotalLength); 923 924 while (p < end) { 925 desc = (usb_descriptor_t *)p; 926 if (desc->bDescriptorType == type && 927 desc->bDescriptorSubtype == subtype) 928 return (desc); 929 p += desc->bLength; 930 } 931 932 return (0); 933 } 934 935 usbd_status 936 umodem_set_comm_feature(sc, feature, state) 937 struct umodem_softc *sc; 938 int feature; 939 int state; 940 { 941 usb_device_request_t req; 942 usbd_status r; 943 usb_cdc_abstract_state_t ast; 944 945 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 946 req.bRequest = UCDC_SET_COMM_FEATURE; 947 USETW(req.wValue, feature); 948 USETW(req.wIndex, sc->sc_ctl_iface_no); 949 USETW(req.wLength, UCDC_ABSTRACT_STATE_LENGTH); 950 USETW(ast.wState, state); 951 952 r = usbd_do_request(sc->sc_udev, &req, &ast); 953 if (r != USBD_NORMAL_COMPLETION) { 954 DPRINTF(("umodem_set_comm_feature: feature=%d failed, r=%d\n", 955 feature, r)); 956 return (r); 957 } 958 959 return (USBD_NORMAL_COMPLETION); 960 } 961 962 usbd_status 963 umodem_set_line_coding(sc, state) 964 struct umodem_softc *sc; 965 usb_cdc_line_state_t *state; 966 { 967 usb_device_request_t req; 968 usbd_status r; 969 970 DPRINTF(("umodem_set_line_coding: rate=%d fmt=%d parity=%d bits=%d\n", 971 UGETDW(state->dwDTERate), state->bCharFormat, 972 state->bParityType, state->bDataBits)); 973 974 if (memcmp(state, &sc->sc_line_state, UCDC_LINE_STATE_LENGTH) == 0) { 975 DPRINTF(("umodem_set_line_coding: already set\n")); 976 return (USBD_NORMAL_COMPLETION); 977 } 978 979 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 980 req.bRequest = UCDC_SET_LINE_CODING; 981 USETW(req.wValue, 0); 982 USETW(req.wIndex, sc->sc_ctl_iface_no); 983 USETW(req.wLength, UCDC_LINE_STATE_LENGTH); 984 985 r = usbd_do_request(sc->sc_udev, &req, state); 986 if (r != USBD_NORMAL_COMPLETION) { 987 DPRINTF(("umodem_set_line_coding: failed, r=%d\n", r)); 988 return (r); 989 } 990 991 sc->sc_line_state = *state; 992 993 return (USBD_NORMAL_COMPLETION); 994 } 995 996 int 997 umodem_activate(self, act) 998 device_ptr_t self; 999 enum devact act; 1000 { 1001 struct umodem_softc *sc = (struct umodem_softc *)self; 1002 1003 switch (act) { 1004 case DVACT_ACTIVATE: 1005 return (EOPNOTSUPP); 1006 break; 1007 1008 case DVACT_DEACTIVATE: 1009 sc->sc_dying = 1; 1010 break; 1011 } 1012 return (0); 1013 } 1014 1015 int 1016 umodem_detach(self, flags) 1017 device_ptr_t self; 1018 int flags; 1019 { 1020 struct umodem_softc *sc = (struct umodem_softc *)self; 1021 int maj, mn; 1022 1023 DPRINTF(("umodem_detach: sc=%p flags=%d tp=%p\n", 1024 sc, flags, sc->sc_tty)); 1025 1026 sc->sc_dying = 1; 1027 1028 #ifdef DIAGNOSTIC 1029 if (sc->sc_tty == 0) { 1030 DPRINTF(("umodem_detach: no tty\n")); 1031 return (0); 1032 } 1033 #endif 1034 1035 /* use refernce count? XXX */ 1036 1037 /* locate the major number */ 1038 for (maj = 0; maj < nchrdev; maj++) 1039 if (cdevsw[maj].d_open == umodemopen) 1040 break; 1041 1042 /* Nuke the vnodes for any open instances. */ 1043 mn = self->dv_unit; 1044 vdevgone(maj, mn, mn, VCHR); 1045 vdevgone(maj, mn, mn | UMODEMDIALOUT_MASK, VCHR); 1046 vdevgone(maj, mn, mn | UMODEMCALLUNIT_MASK, VCHR); 1047 1048 /* Detach and free the tty. */ 1049 tty_detach(sc->sc_tty); 1050 ttyfree(sc->sc_tty); 1051 sc->sc_tty = 0; 1052 1053 return (0); 1054 } 1055
Indexes created Wed Sep 24 05:09:52 GMT 2025