sys/dev/usbmisc/uvscom/uvscom.c

   1 /*-
   2  * Copyright (c) 2001-2002, Shunsuke Akiyama <akiyama@jp.FreeBSD.org>.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $NetBSD: usb/uvscom.c,v 1.1 2002/03/19 15:08:42 augustss Exp $
  27  * $FreeBSD: src/sys/dev/usb/uvscom.c,v 1.19 2003/11/16 12:26:10 akiyama Exp $
  28  * $DragonFly: src/sys/dev/usbmisc/uvscom/uvscom.c,v 1.11 2007/06/28 06:32:33 hasso Exp $
  29  */
  30
  31 /*
  32  * uvscom: SUNTAC Slipper U VS-10U driver.
  33  * Slipper U is a PC card to USB converter for data communication card
  34  * adapter.  It supports DDI Pocket's Air H" C@rd, C@rd H" 64, NTT's P-in,
  35  * P-in m@ater and various data communication card adapters.
  36  */
  37
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/kernel.h>
  41 #include <sys/malloc.h>
  42 #include <sys/fcntl.h>
  43 #include <sys/conf.h>
  44 #include <sys/tty.h>
  45 #include <sys/file.h>
  46 #include <sys/bus.h>
  47 #include <sys/ioccom.h>
  48 #include <sys/select.h>
  49 #include <sys/proc.h>
  50 #include <sys/vnode.h>
  51 #include <sys/poll.h>
  52 #include <sys/sysctl.h>
  53
  54 #include <bus/usb/usb.h>
  55 #include <bus/usb/usbcdc.h>
  56
  57 #include <bus/usb/usbdi.h>
  58 #include <bus/usb/usbdi_util.h>
  59 #include <bus/usb/usbdevs.h>
  60 #include <bus/usb/usb_quirks.h>
  61
  62 #include "../ucom/ucomvar.h"
  63
  64 #ifdef USB_DEBUG
  65 static int      uvscomdebug = 0;
  66 SYSCTL_NODE(_hw_usb, OID_AUTO, uvscom, CTLFLAG_RW, 0, "USB uvscom");
  67 SYSCTL_INT(_hw_usb_uvscom, OID_AUTO, debug, CTLFLAG_RW,
  68            &uvscomdebug, 0, "uvscom debug level");
  69
  70 #define DPRINTFN(n, x) do { \
  71                                 if (uvscomdebug > (n)) \
  72                                         logprintf x; \
  73                         } while (0)
  74 #else
  75 #define DPRINTFN(n, x)
  76 #endif
  77 #define DPRINTF(x) DPRINTFN(0, x)
  78
  79 #define UVSCOM_MODVER           1       /* module version */
  80
  81 #define UVSCOM_CONFIG_INDEX     0
  82 #define UVSCOM_IFACE_INDEX      0
  83
  84 #define UVSCOM_INTR_INTERVAL    100     /* mS */
  85
  86 #define UVSCOM_UNIT_WAIT        5
  87
  88 /* Request */
  89 #define UVSCOM_SET_SPEED        0x10
  90 #define UVSCOM_LINE_CTL         0x11
  91 #define UVSCOM_SET_PARAM        0x12
  92 #define UVSCOM_READ_STATUS      0xd0
  93 #define UVSCOM_SHUTDOWN         0xe0
  94
  95 /* UVSCOM_SET_SPEED parameters */
  96 #define UVSCOM_SPEED_150BPS     0x00
  97 #define UVSCOM_SPEED_300BPS     0x01
  98 #define UVSCOM_SPEED_600BPS     0x02
  99 #define UVSCOM_SPEED_1200BPS    0x03
 100 #define UVSCOM_SPEED_2400BPS    0x04
 101 #define UVSCOM_SPEED_4800BPS    0x05
 102 #define UVSCOM_SPEED_9600BPS    0x06
 103 #define UVSCOM_SPEED_19200BPS   0x07
 104 #define UVSCOM_SPEED_38400BPS   0x08
 105 #define UVSCOM_SPEED_57600BPS   0x09
 106 #define UVSCOM_SPEED_115200BPS  0x0a
 107
 108 /* UVSCOM_LINE_CTL parameters */
 109 #define UVSCOM_BREAK            0x40
 110 #define UVSCOM_RTS              0x02
 111 #define UVSCOM_DTR              0x01
 112 #define UVSCOM_LINE_INIT        0x08
 113
 114 /* UVSCOM_SET_PARAM parameters */
 115 #define UVSCOM_DATA_MASK        0x03
 116 #define UVSCOM_DATA_BIT_8       0x03
 117 #define UVSCOM_DATA_BIT_7       0x02
 118 #define UVSCOM_DATA_BIT_6       0x01
 119 #define UVSCOM_DATA_BIT_5       0x00
 120
 121 #define UVSCOM_STOP_MASK        0x04
 122 #define UVSCOM_STOP_BIT_2       0x04
 123 #define UVSCOM_STOP_BIT_1       0x00
 124
 125 #define UVSCOM_PARITY_MASK      0x18
 126 #define UVSCOM_PARITY_EVEN      0x18
 127 #if 0
 128 #define UVSCOM_PARITY_UNK       0x10
 129 #endif
 130 #define UVSCOM_PARITY_ODD       0x08
 131 #define UVSCOM_PARITY_NONE      0x00
 132
 133 /* Status bits */
 134 #define UVSCOM_TXRDY            0x04
 135 #define UVSCOM_RXRDY            0x01
 136
 137 #define UVSCOM_DCD              0x08
 138 #define UVSCOM_NOCARD           0x04
 139 #define UVSCOM_DSR              0x02
 140 #define UVSCOM_CTS              0x01
 141 #define UVSCOM_USTAT_MASK       (UVSCOM_NOCARD | UVSCOM_DSR | UVSCOM_CTS)
 142
 143 struct  uvscom_softc {
 144         struct ucom_softc       sc_ucom;
 145
 146         int                     sc_iface_number;/* interface number */
 147
 148         usbd_interface_handle   sc_intr_iface;  /* interrupt interface */
 149         int                     sc_intr_number; /* interrupt number */
 150         usbd_pipe_handle        sc_intr_pipe;   /* interrupt pipe */
 151         u_char                  *sc_intr_buf;   /* interrupt buffer */
 152         int                     sc_isize;
 153
 154         u_char                  sc_dtr;         /* current DTR state */
 155         u_char                  sc_rts;         /* current RTS state */
 156
 157         u_char                  sc_lsr;         /* Local status register */
 158         u_char                  sc_msr;         /* uvscom status register */
 159
 160         uint16_t                sc_lcr;         /* Line control */
 161         u_char                  sc_usr;         /* unit status */
 162 };
 163
 164 /*
 165  * These are the maximum number of bytes transferred per frame.
 166  * The output buffer size cannot be increased due to the size encoding.
 167  */
 168 #define UVSCOMIBUFSIZE 512
 169 #define UVSCOMOBUFSIZE 64
 170
 171 static  usbd_status uvscom_shutdown(struct uvscom_softc *);
 172 static  usbd_status uvscom_reset(struct uvscom_softc *);
 173 static  usbd_status uvscom_set_line_coding(struct uvscom_softc *,
 174                                            uint16_t, uint16_t);
 175 static  usbd_status uvscom_set_line(struct uvscom_softc *, uint16_t);
 176 static  usbd_status uvscom_set_crtscts(struct uvscom_softc *);
 177 static  void uvscom_get_status(void *, int, u_char *, u_char *);
 178 static  void uvscom_dtr(struct uvscom_softc *, int);
 179 static  void uvscom_rts(struct uvscom_softc *, int);
 180 static  void uvscom_break(struct uvscom_softc *, int);
 181
 182 static  void uvscom_set(void *, int, int, int);
 183 static  void uvscom_intr(usbd_xfer_handle, usbd_private_handle, usbd_status);
 184 #if TODO
 185 static  int  uvscom_ioctl(void *, int, u_long, caddr_t, int, usb_proc_ptr);
 186 #endif
 187 static  int  uvscom_param(void *, int, struct termios *);
 188 static  int  uvscom_open(void *, int);
 189 static  void uvscom_close(void *, int);
 190
 191 struct ucom_callback uvscom_callback = {
 192         uvscom_get_status,
 193         uvscom_set,
 194         uvscom_param,
 195         NULL, /* uvscom_ioctl, TODO */
 196         uvscom_open,
 197         uvscom_close,
 198         NULL,
 199         NULL
 200 };
 201
 202 static const struct usb_devno uvscom_devs [] = {
 203         /* SUNTAC U-Cable type D2 */
 204         { USB_VENDOR_SUNTAC, USB_PRODUCT_SUNTAC_DS96L },
 205         /* SUNTAC Ir-Trinity */
 206         { USB_VENDOR_SUNTAC, USB_PRODUCT_SUNTAC_IS96U },
 207         /* SUNTAC U-Cable type P1 */
 208         { USB_VENDOR_SUNTAC, USB_PRODUCT_SUNTAC_PS64P1 },
 209         /* SUNTAC Slipper U */
 210         { USB_VENDOR_SUNTAC, USB_PRODUCT_SUNTAC_VS10U },
 211 };
 212 #define uvscom_lookup(v, p) usb_lookup(uvscom_devs, v, p)
 213
 214 static device_probe_t uvscom_match;
 215 static device_attach_t uvscom_attach;
 216 static device_detach_t uvscom_detach;
 217
 218 static device_method_t uvscom_methods[] = {
 219         /* Device interface */
 220         DEVMETHOD(device_probe, uvscom_match),
 221         DEVMETHOD(device_attach, uvscom_attach),
 222         DEVMETHOD(device_detach, uvscom_detach),
 223         { 0, 0 }
 224 };
 225
 226 static driver_t uvscom_driver = {
 227         "uvscom",
 228         uvscom_methods,
 229         sizeof (struct uvscom_softc)
 230 };
 231
 232 DRIVER_MODULE(uvscom, uhub, uvscom_driver, ucom_devclass, usbd_driver_load, 0);
 233 MODULE_DEPEND(uvscom, ucom, UCOM_MINVER, UCOM_PREFVER, UCOM_MAXVER);
 234 MODULE_VERSION(uvscom, UVSCOM_MODVER);
 235
 236 USB_MATCH(uvscom)
 237 {
 238         USB_MATCH_START(uvscom, uaa);
 239
 240         if (uaa->iface != NULL)
 241                 return (UMATCH_NONE);
 242
 243         return (uvscom_lookup(uaa->vendor, uaa->product) != NULL ?
 244                 UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
 245 }
 246
 247 USB_ATTACH(uvscom)
 248 {
 249         USB_ATTACH_START(uvscom, sc, uaa);
 250         usbd_device_handle dev = uaa->device;
 251         struct ucom_softc *ucom;
 252         usb_config_descriptor_t *cdesc;
 253         usb_interface_descriptor_t *id;
 254         usb_endpoint_descriptor_t *ed;
 255         char *devinfo;
 256         const char *devname;
 257         usbd_status err;
 258         int i;
 259
 260         devinfo = kmalloc(1024, M_USBDEV, M_INTWAIT);
 261         ucom = &sc->sc_ucom;
 262
 263         bzero(sc, sizeof (struct uvscom_softc));
 264
 265         usbd_devinfo(dev, 0, devinfo);
 266         /* USB_ATTACH_SETUP; */
 267         ucom->sc_dev = self;
 268         device_set_desc_copy(self, devinfo);
 269         /* USB_ATTACH_SETUP; */
 270
 271         ucom->sc_udev = dev;
 272         ucom->sc_iface = uaa->iface;
 273
 274         devname = device_get_nameunit(ucom->sc_dev);
 275         kprintf("%s: %s\n", devname, devinfo);
 276
 277         DPRINTF(("uvscom attach: sc = %p\n", sc));
 278
 279         /* initialize endpoints */
 280         ucom->sc_bulkin_no = ucom->sc_bulkout_no = -1;
 281         sc->sc_intr_number = -1;
 282         sc->sc_intr_pipe = NULL;
 283
 284         /* Move the device into the configured state. */
 285         err = usbd_set_config_index(dev, UVSCOM_CONFIG_INDEX, 1);
 286         if (err) {
 287                 kprintf("%s: failed to set configuration, err=%s\n",
 288                         devname, usbd_errstr(err));
 289                 goto error;
 290         }
 291
 292         /* get the config descriptor */
 293         cdesc = usbd_get_config_descriptor(ucom->sc_udev);
 294
 295         if (cdesc == NULL) {
 296                 kprintf("%s: failed to get configuration descriptor\n",
 297                         device_get_nameunit(ucom->sc_dev));
 298                 goto error;
 299         }
 300
 301         /* get the common interface */
 302         err = usbd_device2interface_handle(dev, UVSCOM_IFACE_INDEX,
 303                                            &ucom->sc_iface);
 304         if (err) {
 305                 kprintf("%s: failed to get interface, err=%s\n",
 306                         devname, usbd_errstr(err));
 307                 goto error;
 308         }
 309
 310         id = usbd_get_interface_descriptor(ucom->sc_iface);
 311         sc->sc_iface_number = id->bInterfaceNumber;
 312
 313         /* Find endpoints */
 314         for (i = 0; i < id->bNumEndpoints; i++) {
 315                 ed = usbd_interface2endpoint_descriptor(ucom->sc_iface, i);
 316                 if (ed == NULL) {
 317                         kprintf("%s: no endpoint descriptor for %d\n",
 318                                 device_get_nameunit(ucom->sc_dev), i);
 319                         goto error;
 320                 }
 321
 322                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 323                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 324                         ucom->sc_bulkin_no = ed->bEndpointAddress;
 325                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
 326                            UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 327                         ucom->sc_bulkout_no = ed->bEndpointAddress;
 328                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 329                            UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
 330                         sc->sc_intr_number = ed->bEndpointAddress;
 331                         sc->sc_isize = UGETW(ed->wMaxPacketSize);
 332                 }
 333         }
 334
 335         if (ucom->sc_bulkin_no == -1) {
 336                 kprintf("%s: Could not find data bulk in\n",
 337                         device_get_nameunit(ucom->sc_dev));
 338                 goto error;
 339         }
 340         if (ucom->sc_bulkout_no == -1) {
 341                 kprintf("%s: Could not find data bulk out\n",
 342                         device_get_nameunit(ucom->sc_dev));
 343                 goto error;
 344         }
 345         if (sc->sc_intr_number == -1) {
 346                 kprintf("%s: Could not find interrupt in\n",
 347                         device_get_nameunit(ucom->sc_dev));
 348                 goto error;
 349         }
 350
 351         sc->sc_dtr = sc->sc_rts = 0;
 352         sc->sc_lcr = UVSCOM_LINE_INIT;
 353
 354         ucom->sc_parent = sc;
 355         ucom->sc_portno = UCOM_UNK_PORTNO;
 356         /* bulkin, bulkout set above */
 357         ucom->sc_ibufsize = UVSCOMIBUFSIZE;
 358         ucom->sc_obufsize = UVSCOMOBUFSIZE;
 359         ucom->sc_ibufsizepad = UVSCOMIBUFSIZE;
 360         ucom->sc_opkthdrlen = 0;
 361         ucom->sc_callback = &uvscom_callback;
 362
 363         err = uvscom_reset(sc);
 364
 365         if (err) {
 366                 kprintf("%s: reset failed, %s\n", device_get_nameunit(ucom->sc_dev),
 367                         usbd_errstr(err));
 368                 goto error;
 369         }
 370
 371         DPRINTF(("uvscom: in = 0x%x out = 0x%x intr = 0x%x\n",
 372                  ucom->sc_bulkin_no, ucom->sc_bulkout_no, sc->sc_intr_number));
 373
 374         ucom_attach(&sc->sc_ucom);
 375
 376         kfree(devinfo, M_USBDEV);
 377         USB_ATTACH_SUCCESS_RETURN;
 378
 379 error:
 380         ucom->sc_dying = 1;
 381         kfree(devinfo, M_USBDEV);
 382         USB_ATTACH_ERROR_RETURN;
 383 }
 384
 385 USB_DETACH(uvscom)
 386 {
 387         USB_DETACH_START(uvscom, sc);
 388         int rv = 0;
 389
 390         DPRINTF(("uvscom_detach: sc = %p\n", sc));
 391
 392         sc->sc_ucom.sc_dying = 1;
 393
 394         if (sc->sc_intr_pipe != NULL) {
 395                 usbd_abort_pipe(sc->sc_intr_pipe);
 396                 usbd_close_pipe(sc->sc_intr_pipe);
 397                 kfree(sc->sc_intr_buf, M_USBDEV);
 398                 sc->sc_intr_pipe = NULL;
 399         }
 400
 401         rv = ucom_detach(&sc->sc_ucom);
 402
 403         return (rv);
 404 }
 405
 406 static usbd_status
 407 uvscom_readstat(struct uvscom_softc *sc)
 408 {
 409         usb_device_request_t req;
 410         usbd_status err;
 411         uint16_t r;
 412
 413         DPRINTF(("%s: send readstat\n", device_get_nameunit(sc->sc_ucom.sc_dev)));
 414
 415         req.bmRequestType = UT_READ_VENDOR_DEVICE;
 416         req.bRequest = UVSCOM_READ_STATUS;
 417         USETW(req.wValue, 0);
 418         USETW(req.wIndex, 0);
 419         USETW(req.wLength, 2);
 420
 421         err = usbd_do_request(sc->sc_ucom.sc_udev, &req, &r);
 422         if (err) {
 423                 kprintf("%s: uvscom_readstat: %s\n",
 424                        device_get_nameunit(sc->sc_ucom.sc_dev), usbd_errstr(err));
 425                 return (err);
 426         }
 427
 428         DPRINTF(("%s: uvscom_readstat: r = %d\n",
 429                  device_get_nameunit(sc->sc_ucom.sc_dev), r));
 430
 431         return (USBD_NORMAL_COMPLETION);
 432 }
 433
 434 static usbd_status
 435 uvscom_shutdown(struct uvscom_softc *sc)
 436 {
 437         usb_device_request_t req;
 438         usbd_status err;
 439
 440         DPRINTF(("%s: send shutdown\n", device_get_nameunit(sc->sc_ucom.sc_dev)));
 441
 442         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 443         req.bRequest = UVSCOM_SHUTDOWN;
 444         USETW(req.wValue, 0);
 445         USETW(req.wIndex, 0);
 446         USETW(req.wLength, 0);
 447
 448         err = usbd_do_request(sc->sc_ucom.sc_udev, &req, NULL);
 449         if (err) {
 450                 kprintf("%s: uvscom_shutdown: %s\n",
 451                        device_get_nameunit(sc->sc_ucom.sc_dev), usbd_errstr(err));
 452                 return (err);
 453         }
 454
 455         return (USBD_NORMAL_COMPLETION);
 456 }
 457
 458 static usbd_status
 459 uvscom_reset(struct uvscom_softc *sc)
 460 {
 461         DPRINTF(("%s: uvscom_reset\n", device_get_nameunit(sc->sc_ucom.sc_dev)));
 462
 463         return (USBD_NORMAL_COMPLETION);
 464 }
 465
 466 static usbd_status
 467 uvscom_set_crtscts(struct uvscom_softc *sc)
 468 {
 469         DPRINTF(("%s: uvscom_set_crtscts\n", device_get_nameunit(sc->sc_ucom.sc_dev)));
 470
 471         return (USBD_NORMAL_COMPLETION);
 472 }
 473
 474 static usbd_status
 475 uvscom_set_line(struct uvscom_softc *sc, uint16_t line)
 476 {
 477         usb_device_request_t req;
 478         usbd_status err;
 479
 480         DPRINTF(("%s: uvscom_set_line: %04x\n",
 481                  device_get_nameunit(sc->sc_ucom.sc_dev), line));
 482
 483         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 484         req.bRequest = UVSCOM_LINE_CTL;
 485         USETW(req.wValue, line);
 486         USETW(req.wIndex, 0);
 487         USETW(req.wLength, 0);
 488
 489         err = usbd_do_request(sc->sc_ucom.sc_udev, &req, NULL);
 490         if (err) {
 491                 kprintf("%s: uvscom_set_line: %s\n",
 492                        device_get_nameunit(sc->sc_ucom.sc_dev), usbd_errstr(err));
 493                 return (err);
 494         }
 495
 496         return (USBD_NORMAL_COMPLETION);
 497 }
 498
 499 static usbd_status
 500 uvscom_set_line_coding(struct uvscom_softc *sc, uint16_t lsp, uint16_t ls)
 501 {
 502         usb_device_request_t req;
 503         usbd_status err;
 504
 505         DPRINTF(("%s: uvscom_set_line_coding: %02x %02x\n",
 506                  device_get_nameunit(sc->sc_ucom.sc_dev), lsp, ls));
 507
 508         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 509         req.bRequest = UVSCOM_SET_SPEED;
 510         USETW(req.wValue, lsp);
 511         USETW(req.wIndex, 0);
 512         USETW(req.wLength, 0);
 513
 514         err = usbd_do_request(sc->sc_ucom.sc_udev, &req, NULL);
 515         if (err) {
 516                 kprintf("%s: uvscom_set_line_coding: %s\n",
 517                        device_get_nameunit(sc->sc_ucom.sc_dev), usbd_errstr(err));
 518                 return (err);
 519         }
 520
 521         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 522         req.bRequest = UVSCOM_SET_PARAM;
 523         USETW(req.wValue, ls);
 524         USETW(req.wIndex, 0);
 525         USETW(req.wLength, 0);
 526
 527         err = usbd_do_request(sc->sc_ucom.sc_udev, &req, NULL);
 528         if (err) {
 529                 kprintf("%s: uvscom_set_line_coding: %s\n",
 530                        device_get_nameunit(sc->sc_ucom.sc_dev), usbd_errstr(err));
 531                 return (err);
 532         }
 533
 534         return (USBD_NORMAL_COMPLETION);
 535 }
 536
 537 static void
 538 uvscom_dtr(struct uvscom_softc *sc, int onoff)
 539 {
 540         DPRINTF(("%s: uvscom_dtr: onoff = %d\n",
 541                  device_get_nameunit(sc->sc_ucom.sc_dev), onoff));
 542
 543         if (sc->sc_dtr == onoff)
 544                 return;                 /* no change */
 545
 546         sc->sc_dtr = onoff;
 547
 548         if (onoff)
 549                 SET(sc->sc_lcr, UVSCOM_DTR);
 550         else
 551                 CLR(sc->sc_lcr, UVSCOM_DTR);
 552
 553         uvscom_set_line(sc, sc->sc_lcr);
 554 }
 555
 556 static void
 557 uvscom_rts(struct uvscom_softc *sc, int onoff)
 558 {
 559         DPRINTF(("%s: uvscom_rts: onoff = %d\n",
 560                  device_get_nameunit(sc->sc_ucom.sc_dev), onoff));
 561
 562         if (sc->sc_rts == onoff)
 563                 return;                 /* no change */
 564
 565         sc->sc_rts = onoff;
 566
 567         if (onoff)
 568                 SET(sc->sc_lcr, UVSCOM_RTS);
 569         else
 570                 CLR(sc->sc_lcr, UVSCOM_RTS);
 571
 572         uvscom_set_line(sc, sc->sc_lcr);
 573 }
 574
 575 static void
 576 uvscom_break(struct uvscom_softc *sc, int onoff)
 577 {
 578         DPRINTF(("%s: uvscom_break: onoff = %d\n",
 579                  device_get_nameunit(sc->sc_ucom.sc_dev), onoff));
 580
 581         if (onoff)
 582                 uvscom_set_line(sc, SET(sc->sc_lcr, UVSCOM_BREAK));
 583 }
 584
 585 static void
 586 uvscom_set(void *addr, int portno, int reg, int onoff)
 587 {
 588         struct uvscom_softc *sc = addr;
 589
 590         switch (reg) {
 591         case UCOM_SET_DTR:
 592                 uvscom_dtr(sc, onoff);
 593                 break;
 594         case UCOM_SET_RTS:
 595                 uvscom_rts(sc, onoff);
 596                 break;
 597         case UCOM_SET_BREAK:
 598                 uvscom_break(sc, onoff);
 599                 break;
 600         default:
 601                 break;
 602         }
 603 }
 604
 605 static int
 606 uvscom_param(void *addr, int portno, struct termios *t)
 607 {
 608         struct uvscom_softc *sc = addr;
 609         usbd_status err;
 610         uint16_t lsp;
 611         uint16_t ls;
 612
 613         DPRINTF(("%s: uvscom_param: sc = %p\n",
 614                  device_get_nameunit(sc->sc_ucom.sc_dev), sc));
 615
 616         ls = 0;
 617
 618         switch (t->c_ospeed) {
 619         case B150:
 620                 lsp = UVSCOM_SPEED_150BPS;
 621                 break;
 622         case B300:
 623                 lsp = UVSCOM_SPEED_300BPS;
 624                 break;
 625         case B600:
 626                 lsp = UVSCOM_SPEED_600BPS;
 627                 break;
 628         case B1200:
 629                 lsp = UVSCOM_SPEED_1200BPS;
 630                 break;
 631         case B2400:
 632                 lsp = UVSCOM_SPEED_2400BPS;
 633                 break;
 634         case B4800:
 635                 lsp = UVSCOM_SPEED_4800BPS;
 636                 break;
 637         case B9600:
 638                 lsp = UVSCOM_SPEED_9600BPS;
 639                 break;
 640         case B19200:
 641                 lsp = UVSCOM_SPEED_19200BPS;
 642                 break;
 643         case B38400:
 644                 lsp = UVSCOM_SPEED_38400BPS;
 645                 break;
 646         case B57600:
 647                 lsp = UVSCOM_SPEED_57600BPS;
 648                 break;
 649         case B115200:
 650                 lsp = UVSCOM_SPEED_115200BPS;
 651                 break;
 652         default:
 653                 return (EIO);
 654         }
 655
 656         if (ISSET(t->c_cflag, CSTOPB))
 657                 SET(ls, UVSCOM_STOP_BIT_2);
 658         else
 659                 SET(ls, UVSCOM_STOP_BIT_1);
 660
 661         if (ISSET(t->c_cflag, PARENB)) {
 662                 if (ISSET(t->c_cflag, PARODD))
 663                         SET(ls, UVSCOM_PARITY_ODD);
 664                 else
 665                         SET(ls, UVSCOM_PARITY_EVEN);
 666         } else
 667                 SET(ls, UVSCOM_PARITY_NONE);
 668
 669         switch (ISSET(t->c_cflag, CSIZE)) {
 670         case CS5:
 671                 SET(ls, UVSCOM_DATA_BIT_5);
 672                 break;
 673         case CS6:
 674                 SET(ls, UVSCOM_DATA_BIT_6);
 675                 break;
 676         case CS7:
 677                 SET(ls, UVSCOM_DATA_BIT_7);
 678                 break;
 679         case CS8:
 680                 SET(ls, UVSCOM_DATA_BIT_8);
 681                 break;
 682         default:
 683                 return (EIO);
 684         }
 685
 686         err = uvscom_set_line_coding(sc, lsp, ls);
 687         if (err)
 688                 return (EIO);
 689
 690         if (ISSET(t->c_cflag, CRTSCTS)) {
 691                 err = uvscom_set_crtscts(sc);
 692                 if (err)
 693                         return (EIO);
 694         }
 695
 696         return (0);
 697 }
 698
 699 static int
 700 uvscom_open(void *addr, int portno)
 701 {
 702         struct uvscom_softc *sc = addr;
 703         int err;
 704         int i;
 705
 706         if (sc->sc_ucom.sc_dying)
 707                 return (ENXIO);
 708
 709         DPRINTF(("uvscom_open: sc = %p\n", sc));
 710
 711         if (sc->sc_intr_number != -1 && sc->sc_intr_pipe == NULL) {
 712                 DPRINTF(("uvscom_open: open interrupt pipe.\n"));
 713
 714                 sc->sc_usr = 0;         /* clear unit status */
 715
 716                 err = uvscom_readstat(sc);
 717                 if (err) {
 718                         DPRINTF(("%s: uvscom_open: readstat faild\n",
 719                                  device_get_nameunit(sc->sc_ucom.sc_dev)));
 720                         return (ENXIO);
 721                 }
 722
 723                 sc->sc_intr_buf = kmalloc(sc->sc_isize, M_USBDEV, M_WAITOK);
 724                 err = usbd_open_pipe_intr(sc->sc_ucom.sc_iface,
 725                                           sc->sc_intr_number,
 726                                           USBD_SHORT_XFER_OK,
 727                                           &sc->sc_intr_pipe,
 728                                           sc,
 729                                           sc->sc_intr_buf,
 730                                           sc->sc_isize,
 731                                           uvscom_intr,
 732                                           UVSCOM_INTR_INTERVAL);
 733                 if (err) {
 734                         kprintf("%s: cannot open interrupt pipe (addr %d)\n",
 735                                  device_get_nameunit(sc->sc_ucom.sc_dev),
 736                                  sc->sc_intr_number);
 737                         return (ENXIO);
 738                 }
 739         } else {
 740                 DPRINTF(("uvscom_open: did not open interrupt pipe.\n"));
 741         }
 742
 743         if ((sc->sc_usr & UVSCOM_USTAT_MASK) == 0) {
 744                 /* unit is not ready */
 745
 746                 for (i = UVSCOM_UNIT_WAIT; i > 0; --i) {
 747                         tsleep(&err, 0, "uvsop", hz);   /* XXX */
 748                         if (ISSET(sc->sc_usr, UVSCOM_USTAT_MASK))
 749                                 break;
 750                 }
 751                 if (i == 0) {
 752                         DPRINTF(("%s: unit is not ready\n",
 753                                  device_get_nameunit(sc->sc_ucom.sc_dev)));
 754                         return (ENXIO);
 755                 }
 756
 757                 /* check PC card was inserted */
 758                 if (ISSET(sc->sc_usr, UVSCOM_NOCARD)) {
 759                         DPRINTF(("%s: no card\n",
 760                                  device_get_nameunit(sc->sc_ucom.sc_dev)));
 761                         return (ENXIO);
 762                 }
 763         }
 764
 765         return (0);
 766 }
 767
 768 static void
 769 uvscom_close(void *addr, int portno)
 770 {
 771         struct uvscom_softc *sc = addr;
 772         int err;
 773
 774         if (sc->sc_ucom.sc_dying)
 775                 return;
 776
 777         DPRINTF(("uvscom_close: close\n"));
 778
 779         uvscom_shutdown(sc);
 780
 781         if (sc->sc_intr_pipe != NULL) {
 782                 err = usbd_abort_pipe(sc->sc_intr_pipe);
 783                 if (err)
 784                         kprintf("%s: abort interrupt pipe failed: %s\n",
 785                                 device_get_nameunit(sc->sc_ucom.sc_dev),
 786                                            usbd_errstr(err));
 787                 err = usbd_close_pipe(sc->sc_intr_pipe);
 788                 if (err)
 789                         kprintf("%s: close interrupt pipe failed: %s\n",
 790                                 device_get_nameunit(sc->sc_ucom.sc_dev),
 791                                            usbd_errstr(err));
 792                 kfree(sc->sc_intr_buf, M_USBDEV);
 793                 sc->sc_intr_pipe = NULL;
 794         }
 795 }
 796
 797 static void
 798 uvscom_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
 799 {
 800         struct uvscom_softc *sc = priv;
 801         u_char *buf = sc->sc_intr_buf;
 802         u_char pstatus;
 803
 804         if (sc->sc_ucom.sc_dying)
 805                 return;
 806
 807         if (status != USBD_NORMAL_COMPLETION) {
 808                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
 809                         return;
 810
 811                 kprintf("%s: uvscom_intr: abnormal status: %s\n",
 812                         device_get_nameunit(sc->sc_ucom.sc_dev),
 813                         usbd_errstr(status));
 814                 usbd_clear_endpoint_stall_async(sc->sc_intr_pipe);
 815                 return;
 816         }
 817
 818         DPRINTFN(2, ("%s: uvscom status = %02x %02x\n",
 819                  device_get_nameunit(sc->sc_ucom.sc_dev), buf[0], buf[1]));
 820
 821         sc->sc_lsr = sc->sc_msr = 0;
 822         sc->sc_usr = buf[1];
 823
 824         pstatus = buf[0];
 825         if (ISSET(pstatus, UVSCOM_TXRDY))
 826                 SET(sc->sc_lsr, ULSR_TXRDY);
 827         if (ISSET(pstatus, UVSCOM_RXRDY))
 828                 SET(sc->sc_lsr, ULSR_RXRDY);
 829
 830         pstatus = buf[1];
 831         if (ISSET(pstatus, UVSCOM_CTS))
 832                 SET(sc->sc_msr, UMSR_CTS);
 833         if (ISSET(pstatus, UVSCOM_DSR))
 834                 SET(sc->sc_msr, UMSR_DSR);
 835         if (ISSET(pstatus, UVSCOM_DCD))
 836                 SET(sc->sc_msr, UMSR_DCD);
 837
 838         ucom_status_change(&sc->sc_ucom);
 839 }
 840
 841 static void
 842 uvscom_get_status(void *addr, int portno, u_char *lsr, u_char *msr)
 843 {
 844         struct uvscom_softc *sc = addr;
 845
 846         if (lsr != NULL)
 847                 *lsr = sc->sc_lsr;
 848         if (msr != NULL)
 849                 *msr = sc->sc_msr;
 850 }
 851
 852 #if TODO
 853 static int
 854 uvscom_ioctl(void *addr, int portno, u_long cmd, caddr_t data, int flag,
 855              usb_proc_ptr p)
 856 {
 857         struct uvscom_softc *sc = addr;
 858         int error = 0;
 859
 860         if (sc->sc_ucom.sc_dying)
 861                 return (EIO);
 862
 863         DPRINTF(("uvscom_ioctl: cmd = 0x%08lx\n", cmd));
 864
 865         switch (cmd) {
 866         case TIOCNOTTY:
 867         case TIOCMGET:
 868         case TIOCMSET:
 869                 break;
 870
 871         default:
 872                 DPRINTF(("uvscom_ioctl: unknown\n"));
 873                 error = ENOTTY;
 874                 break;
 875         }
 876
 877         return (error);
 878 }
 879 #endif