sys/dev/usb/serial/uslcom.c

   1 /*      $OpenBSD: uslcom.c,v 1.17 2007/11/24 10:52:12 jsg Exp $ */
   2
   3 #include <sys/cdefs.h>
   4 __FBSDID("$FreeBSD$");
   5
   6 /*
   7  * Copyright (c) 2006 Jonathan Gray <jsg@openbsd.org>
   8  *
   9  * Permission to use, copy, modify, and distribute this software for any
  10  * purpose with or without fee is hereby granted, provided that the above
  11  * copyright notice and this permission notice appear in all copies.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  14  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  15  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  16  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  17  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  18  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  19  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  20  */
  21
  22 #include <sys/stdint.h>
  23 #include <sys/stddef.h>
  24 #include <sys/param.h>
  25 #include <sys/queue.h>
  26 #include <sys/types.h>
  27 #include <sys/systm.h>
  28 #include <sys/kernel.h>
  29 #include <sys/bus.h>
  30 #include <sys/linker_set.h>
  31 #include <sys/module.h>
  32 #include <sys/lock.h>
  33 #include <sys/mutex.h>
  34 #include <sys/condvar.h>
  35 #include <sys/sysctl.h>
  36 #include <sys/sx.h>
  37 #include <sys/unistd.h>
  38 #include <sys/callout.h>
  39 #include <sys/malloc.h>
  40 #include <sys/priv.h>
  41
  42 #include <dev/usb/usb.h>
  43 #include <dev/usb/usbdi.h>
  44 #include <dev/usb/usbdi_util.h>
  45 #include "usbdevs.h"
  46
  47 #define USB_DEBUG_VAR uslcom_debug
  48 #include <dev/usb/usb_debug.h>
  49 #include <dev/usb/usb_process.h>
  50
  51 #include <dev/usb/serial/usb_serial.h>
  52
  53 #ifdef USB_DEBUG
  54 static int uslcom_debug = 0;
  55
  56 SYSCTL_NODE(_hw_usb, OID_AUTO, uslcom, CTLFLAG_RW, 0, "USB uslcom");
  57 SYSCTL_INT(_hw_usb_uslcom, OID_AUTO, debug, CTLFLAG_RW,
  58     &uslcom_debug, 0, "Debug level");
  59 #endif
  60
  61 #define USLCOM_BULK_BUF_SIZE            1024
  62 #define USLCOM_CONFIG_INDEX     0
  63 #define USLCOM_IFACE_INDEX      0
  64
  65 #define USLCOM_SET_DATA_BITS(x) ((x) << 8)
  66
  67 #define USLCOM_WRITE            0x41
  68 #define USLCOM_READ             0xc1
  69
  70 #define USLCOM_UART             0x00
  71 #define USLCOM_BAUD_RATE        0x01
  72 #define USLCOM_DATA             0x03
  73 #define USLCOM_BREAK            0x05
  74 #define USLCOM_CTRL             0x07
  75
  76 #define USLCOM_UART_DISABLE     0x00
  77 #define USLCOM_UART_ENABLE      0x01
  78
  79 #define USLCOM_CTRL_DTR_ON      0x0001
  80 #define USLCOM_CTRL_DTR_SET     0x0100
  81 #define USLCOM_CTRL_RTS_ON      0x0002
  82 #define USLCOM_CTRL_RTS_SET     0x0200
  83 #define USLCOM_CTRL_CTS         0x0010
  84 #define USLCOM_CTRL_DSR         0x0020
  85 #define USLCOM_CTRL_DCD         0x0080
  86
  87 #define USLCOM_BAUD_REF         0x384000
  88
  89 #define USLCOM_STOP_BITS_1      0x00
  90 #define USLCOM_STOP_BITS_2      0x02
  91
  92 #define USLCOM_PARITY_NONE      0x00
  93 #define USLCOM_PARITY_ODD       0x10
  94 #define USLCOM_PARITY_EVEN      0x20
  95
  96 #define USLCOM_PORT_NO          0xFFFF /* XXX think this should be 0 --hps */
  97
  98 #define USLCOM_BREAK_OFF        0x00
  99 #define USLCOM_BREAK_ON         0x01
 100
 101 enum {
 102         USLCOM_BULK_DT_WR,
 103         USLCOM_BULK_DT_RD,
 104         USLCOM_N_TRANSFER,
 105 };
 106
 107 struct uslcom_softc {
 108         struct ucom_super_softc sc_super_ucom;
 109         struct ucom_softc sc_ucom;
 110
 111         struct usb_xfer *sc_xfer[USLCOM_N_TRANSFER];
 112         struct usb_device *sc_udev;
 113         struct mtx sc_mtx;
 114
 115         uint8_t          sc_msr;
 116         uint8_t          sc_lsr;
 117 };
 118
 119 static device_probe_t uslcom_probe;
 120 static device_attach_t uslcom_attach;
 121 static device_detach_t uslcom_detach;
 122
 123 static usb_callback_t uslcom_write_callback;
 124 static usb_callback_t uslcom_read_callback;
 125
 126 static void uslcom_open(struct ucom_softc *);
 127 static void uslcom_close(struct ucom_softc *);
 128 static void uslcom_set_dtr(struct ucom_softc *, uint8_t);
 129 static void uslcom_set_rts(struct ucom_softc *, uint8_t);
 130 static void uslcom_set_break(struct ucom_softc *, uint8_t);
 131 static int uslcom_pre_param(struct ucom_softc *, struct termios *);
 132 static void uslcom_param(struct ucom_softc *, struct termios *);
 133 static void uslcom_get_status(struct ucom_softc *, uint8_t *, uint8_t *);
 134 static void uslcom_start_read(struct ucom_softc *);
 135 static void uslcom_stop_read(struct ucom_softc *);
 136 static void uslcom_start_write(struct ucom_softc *);
 137 static void uslcom_stop_write(struct ucom_softc *);
 138 static void uslcom_poll(struct ucom_softc *ucom);
 139
 140 static const struct usb_config uslcom_config[USLCOM_N_TRANSFER] = {
 141
 142         [USLCOM_BULK_DT_WR] = {
 143                 .type = UE_BULK,
 144                 .endpoint = UE_ADDR_ANY,
 145                 .direction = UE_DIR_OUT,
 146                 .bufsize = USLCOM_BULK_BUF_SIZE,
 147                 .flags = {.pipe_bof = 1,.force_short_xfer = 1,},
 148                 .callback = &uslcom_write_callback,
 149         },
 150
 151         [USLCOM_BULK_DT_RD] = {
 152                 .type = UE_BULK,
 153                 .endpoint = UE_ADDR_ANY,
 154                 .direction = UE_DIR_IN,
 155                 .bufsize = USLCOM_BULK_BUF_SIZE,
 156                 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
 157                 .callback = &uslcom_read_callback,
 158         },
 159 };
 160
 161 static struct ucom_callback uslcom_callback = {
 162         .ucom_cfg_open = &uslcom_open,
 163         .ucom_cfg_close = &uslcom_close,
 164         .ucom_cfg_get_status = &uslcom_get_status,
 165         .ucom_cfg_set_dtr = &uslcom_set_dtr,
 166         .ucom_cfg_set_rts = &uslcom_set_rts,
 167         .ucom_cfg_set_break = &uslcom_set_break,
 168         .ucom_cfg_param = &uslcom_param,
 169         .ucom_pre_param = &uslcom_pre_param,
 170         .ucom_start_read = &uslcom_start_read,
 171         .ucom_stop_read = &uslcom_stop_read,
 172         .ucom_start_write = &uslcom_start_write,
 173         .ucom_stop_write = &uslcom_stop_write,
 174         .ucom_poll = &uslcom_poll,
 175 };
 176
 177 static const struct usb_device_id uslcom_devs[] = {
 178 #define USLCOM_DEV(v,p)  { USB_VP(USB_VENDOR_##v, USB_PRODUCT_##v##_##p) }
 179     USLCOM_DEV(BALTECH, CARDREADER),
 180     USLCOM_DEV(DYNASTREAM, ANTDEVBOARD),
 181     USLCOM_DEV(JABLOTRON, PC60B),
 182     USLCOM_DEV(SILABS, ARGUSISP),
 183     USLCOM_DEV(SILABS, CRUMB128),
 184     USLCOM_DEV(SILABS, DEGREE),
 185     USLCOM_DEV(SILABS, BURNSIDE),
 186     USLCOM_DEV(SILABS, HELICOM),
 187     USLCOM_DEV(SILABS, LIPOWSKY_HARP),
 188     USLCOM_DEV(SILABS, LIPOWSKY_JTAG),
 189     USLCOM_DEV(SILABS, LIPOWSKY_LIN),
 190     USLCOM_DEV(SILABS, POLOLU),
 191     USLCOM_DEV(SILABS, CP2102),
 192     USLCOM_DEV(SILABS, CP210X_2),
 193     USLCOM_DEV(SILABS, SUUNTO),
 194     USLCOM_DEV(SILABS, TRAQMATE),
 195     USLCOM_DEV(SILABS2, DCU11CLONE),
 196     USLCOM_DEV(USI, MC60),
 197 #undef USLCOM_DEV
 198 };
 199
 200 static device_method_t uslcom_methods[] = {
 201         DEVMETHOD(device_probe, uslcom_probe),
 202         DEVMETHOD(device_attach, uslcom_attach),
 203         DEVMETHOD(device_detach, uslcom_detach),
 204         {0, 0}
 205 };
 206
 207 static devclass_t uslcom_devclass;
 208
 209 static driver_t uslcom_driver = {
 210         .name = "uslcom",
 211         .methods = uslcom_methods,
 212         .size = sizeof(struct uslcom_softc),
 213 };
 214
 215 DRIVER_MODULE(uslcom, uhub, uslcom_driver, uslcom_devclass, NULL, 0);
 216 MODULE_DEPEND(uslcom, ucom, 1, 1, 1);
 217 MODULE_DEPEND(uslcom, usb, 1, 1, 1);
 218 MODULE_VERSION(uslcom, 1);
 219
 220 static int
 221 uslcom_probe(device_t dev)
 222 {
 223         struct usb_attach_arg *uaa = device_get_ivars(dev);
 224
 225         DPRINTFN(11, "\n");
 226
 227         if (uaa->usb_mode != USB_MODE_HOST) {
 228                 return (ENXIO);
 229         }
 230         if (uaa->info.bConfigIndex != USLCOM_CONFIG_INDEX) {
 231                 return (ENXIO);
 232         }
 233         if (uaa->info.bIfaceIndex != USLCOM_IFACE_INDEX) {
 234                 return (ENXIO);
 235         }
 236         return (usbd_lookup_id_by_uaa(uslcom_devs, sizeof(uslcom_devs), uaa));
 237 }
 238
 239 static int
 240 uslcom_attach(device_t dev)
 241 {
 242         struct usb_attach_arg *uaa = device_get_ivars(dev);
 243         struct uslcom_softc *sc = device_get_softc(dev);
 244         int error;
 245
 246         DPRINTFN(11, "\n");
 247
 248         device_set_usb_desc(dev);
 249         mtx_init(&sc->sc_mtx, "uslcom", NULL, MTX_DEF);
 250
 251         sc->sc_udev = uaa->device;
 252
 253         error = usbd_transfer_setup(uaa->device,
 254             &uaa->info.bIfaceIndex, sc->sc_xfer, uslcom_config,
 255             USLCOM_N_TRANSFER, sc, &sc->sc_mtx);
 256         if (error) {
 257                 DPRINTF("one or more missing USB endpoints, "
 258                     "error=%s\n", usbd_errstr(error));
 259                 goto detach;
 260         }
 261         /* clear stall at first run */
 262         mtx_lock(&sc->sc_mtx);
 263         usbd_xfer_set_stall(sc->sc_xfer[USLCOM_BULK_DT_WR]);
 264         usbd_xfer_set_stall(sc->sc_xfer[USLCOM_BULK_DT_RD]);
 265         mtx_unlock(&sc->sc_mtx);
 266
 267         error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
 268             &uslcom_callback, &sc->sc_mtx);
 269         if (error) {
 270                 goto detach;
 271         }
 272         return (0);
 273
 274 detach:
 275         uslcom_detach(dev);
 276         return (ENXIO);
 277 }
 278
 279 static int
 280 uslcom_detach(device_t dev)
 281 {
 282         struct uslcom_softc *sc = device_get_softc(dev);
 283
 284         DPRINTF("sc=%p\n", sc);
 285
 286         ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
 287         usbd_transfer_unsetup(sc->sc_xfer, USLCOM_N_TRANSFER);
 288         mtx_destroy(&sc->sc_mtx);
 289
 290         return (0);
 291 }
 292
 293 static void
 294 uslcom_open(struct ucom_softc *ucom)
 295 {
 296         struct uslcom_softc *sc = ucom->sc_parent;
 297         struct usb_device_request req;
 298
 299         req.bmRequestType = USLCOM_WRITE;
 300         req.bRequest = USLCOM_UART;
 301         USETW(req.wValue, USLCOM_UART_ENABLE);
 302         USETW(req.wIndex, USLCOM_PORT_NO);
 303         USETW(req.wLength, 0);
 304
 305         if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom,
 306             &req, NULL, 0, 1000)) {
 307                 DPRINTF("UART enable failed (ignored)\n");
 308         }
 309 }
 310
 311 static void
 312 uslcom_close(struct ucom_softc *ucom)
 313 {
 314         struct uslcom_softc *sc = ucom->sc_parent;
 315         struct usb_device_request req;
 316
 317         req.bmRequestType = USLCOM_WRITE;
 318         req.bRequest = USLCOM_UART;
 319         USETW(req.wValue, USLCOM_UART_DISABLE);
 320         USETW(req.wIndex, USLCOM_PORT_NO);
 321         USETW(req.wLength, 0);
 322
 323         if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom,
 324             &req, NULL, 0, 1000)) {
 325                 DPRINTF("UART disable failed (ignored)\n");
 326         }
 327 }
 328
 329 static void
 330 uslcom_set_dtr(struct ucom_softc *ucom, uint8_t onoff)
 331 {
 332         struct uslcom_softc *sc = ucom->sc_parent;
 333         struct usb_device_request req;
 334         uint16_t ctl;
 335
 336         DPRINTF("onoff = %d\n", onoff);
 337
 338         ctl = onoff ? USLCOM_CTRL_DTR_ON : 0;
 339         ctl |= USLCOM_CTRL_DTR_SET;
 340
 341         req.bmRequestType = USLCOM_WRITE;
 342         req.bRequest = USLCOM_CTRL;
 343         USETW(req.wValue, ctl);
 344         USETW(req.wIndex, USLCOM_PORT_NO);
 345         USETW(req.wLength, 0);
 346
 347         if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom,
 348             &req, NULL, 0, 1000)) {
 349                 DPRINTF("Setting DTR failed (ignored)\n");
 350         }
 351 }
 352
 353 static void
 354 uslcom_set_rts(struct ucom_softc *ucom, uint8_t onoff)
 355 {
 356         struct uslcom_softc *sc = ucom->sc_parent;
 357         struct usb_device_request req;
 358         uint16_t ctl;
 359
 360         DPRINTF("onoff = %d\n", onoff);
 361
 362         ctl = onoff ? USLCOM_CTRL_RTS_ON : 0;
 363         ctl |= USLCOM_CTRL_RTS_SET;
 364
 365         req.bmRequestType = USLCOM_WRITE;
 366         req.bRequest = USLCOM_CTRL;
 367         USETW(req.wValue, ctl);
 368         USETW(req.wIndex, USLCOM_PORT_NO);
 369         USETW(req.wLength, 0);
 370
 371         if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom,
 372             &req, NULL, 0, 1000)) {
 373                 DPRINTF("Setting DTR failed (ignored)\n");
 374         }
 375 }
 376
 377 static int
 378 uslcom_pre_param(struct ucom_softc *ucom, struct termios *t)
 379 {
 380         if (t->c_ospeed <= 0 || t->c_ospeed > 921600)
 381                 return (EINVAL);
 382         return (0);
 383 }
 384
 385 static void
 386 uslcom_param(struct ucom_softc *ucom, struct termios *t)
 387 {
 388         struct uslcom_softc *sc = ucom->sc_parent;
 389         struct usb_device_request req;
 390         uint16_t data;
 391
 392         DPRINTF("\n");
 393
 394         req.bmRequestType = USLCOM_WRITE;
 395         req.bRequest = USLCOM_BAUD_RATE;
 396         USETW(req.wValue, USLCOM_BAUD_REF / t->c_ospeed);
 397         USETW(req.wIndex, USLCOM_PORT_NO);
 398         USETW(req.wLength, 0);
 399
 400         if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom,
 401             &req, NULL, 0, 1000)) {
 402                 DPRINTF("Set baudrate failed (ignored)\n");
 403         }
 404
 405         if (t->c_cflag & CSTOPB)
 406                 data = USLCOM_STOP_BITS_2;
 407         else
 408                 data = USLCOM_STOP_BITS_1;
 409         if (t->c_cflag & PARENB) {
 410                 if (t->c_cflag & PARODD)
 411                         data |= USLCOM_PARITY_ODD;
 412                 else
 413                         data |= USLCOM_PARITY_EVEN;
 414         } else
 415                 data |= USLCOM_PARITY_NONE;
 416         switch (t->c_cflag & CSIZE) {
 417         case CS5:
 418                 data |= USLCOM_SET_DATA_BITS(5);
 419                 break;
 420         case CS6:
 421                 data |= USLCOM_SET_DATA_BITS(6);
 422                 break;
 423         case CS7:
 424                 data |= USLCOM_SET_DATA_BITS(7);
 425                 break;
 426         case CS8:
 427                 data |= USLCOM_SET_DATA_BITS(8);
 428                 break;
 429         }
 430
 431         req.bmRequestType = USLCOM_WRITE;
 432         req.bRequest = USLCOM_DATA;
 433         USETW(req.wValue, data);
 434         USETW(req.wIndex, USLCOM_PORT_NO);
 435         USETW(req.wLength, 0);
 436
 437         if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom,
 438             &req, NULL, 0, 1000)) {
 439                 DPRINTF("Set format failed (ignored)\n");
 440         }
 441         return;
 442 }
 443
 444 static void
 445 uslcom_get_status(struct ucom_softc *ucom, uint8_t *lsr, uint8_t *msr)
 446 {
 447         struct uslcom_softc *sc = ucom->sc_parent;
 448
 449         DPRINTF("\n");
 450
 451         *lsr = sc->sc_lsr;
 452         *msr = sc->sc_msr;
 453 }
 454
 455 static void
 456 uslcom_set_break(struct ucom_softc *ucom, uint8_t onoff)
 457 {
 458         struct uslcom_softc *sc = ucom->sc_parent;
 459         struct usb_device_request req;
 460         uint16_t brk = onoff ? USLCOM_BREAK_ON : USLCOM_BREAK_OFF;
 461
 462         req.bmRequestType = USLCOM_WRITE;
 463         req.bRequest = USLCOM_BREAK;
 464         USETW(req.wValue, brk);
 465         USETW(req.wIndex, USLCOM_PORT_NO);
 466         USETW(req.wLength, 0);
 467
 468         if (ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom,
 469             &req, NULL, 0, 1000)) {
 470                 DPRINTF("Set BREAK failed (ignored)\n");
 471         }
 472 }
 473
 474 static void
 475 uslcom_write_callback(struct usb_xfer *xfer, usb_error_t error)
 476 {
 477         struct uslcom_softc *sc = usbd_xfer_softc(xfer);
 478         struct usb_page_cache *pc;
 479         uint32_t actlen;
 480
 481         switch (USB_GET_STATE(xfer)) {
 482         case USB_ST_SETUP:
 483         case USB_ST_TRANSFERRED:
 484 tr_setup:
 485                 pc = usbd_xfer_get_frame(xfer, 0);
 486                 if (ucom_get_data(&sc->sc_ucom, pc, 0,
 487                     USLCOM_BULK_BUF_SIZE, &actlen)) {
 488
 489                         DPRINTF("actlen = %d\n", actlen);
 490
 491                         usbd_xfer_set_frame_len(xfer, 0, actlen);
 492                         usbd_transfer_submit(xfer);
 493                 }
 494                 return;
 495
 496         default:                        /* Error */
 497                 if (error != USB_ERR_CANCELLED) {
 498                         /* try to clear stall first */
 499                         usbd_xfer_set_stall(xfer);
 500                         goto tr_setup;
 501                 }
 502                 return;
 503         }
 504 }
 505
 506 static void
 507 uslcom_read_callback(struct usb_xfer *xfer, usb_error_t error)
 508 {
 509         struct uslcom_softc *sc = usbd_xfer_softc(xfer);
 510         struct usb_page_cache *pc;
 511         int actlen;
 512
 513         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
 514
 515         switch (USB_GET_STATE(xfer)) {
 516         case USB_ST_TRANSFERRED:
 517                 pc = usbd_xfer_get_frame(xfer, 0);
 518                 ucom_put_data(&sc->sc_ucom, pc, 0, actlen);
 519
 520         case USB_ST_SETUP:
 521 tr_setup:
 522                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
 523                 usbd_transfer_submit(xfer);
 524                 return;
 525
 526         default:                        /* Error */
 527                 if (error != USB_ERR_CANCELLED) {
 528                         /* try to clear stall first */
 529                         usbd_xfer_set_stall(xfer);
 530                         goto tr_setup;
 531                 }
 532                 return;
 533         }
 534 }
 535
 536 static void
 537 uslcom_start_read(struct ucom_softc *ucom)
 538 {
 539         struct uslcom_softc *sc = ucom->sc_parent;
 540
 541         /* start read endpoint */
 542         usbd_transfer_start(sc->sc_xfer[USLCOM_BULK_DT_RD]);
 543 }
 544
 545 static void
 546 uslcom_stop_read(struct ucom_softc *ucom)
 547 {
 548         struct uslcom_softc *sc = ucom->sc_parent;
 549
 550         /* stop read endpoint */
 551         usbd_transfer_stop(sc->sc_xfer[USLCOM_BULK_DT_RD]);
 552 }
 553
 554 static void
 555 uslcom_start_write(struct ucom_softc *ucom)
 556 {
 557         struct uslcom_softc *sc = ucom->sc_parent;
 558
 559         usbd_transfer_start(sc->sc_xfer[USLCOM_BULK_DT_WR]);
 560 }
 561
 562 static void
 563 uslcom_stop_write(struct ucom_softc *ucom)
 564 {
 565         struct uslcom_softc *sc = ucom->sc_parent;
 566
 567         usbd_transfer_stop(sc->sc_xfer[USLCOM_BULK_DT_WR]);
 568 }
 569
 570 static void
 571 uslcom_poll(struct ucom_softc *ucom)
 572 {
 573         struct uslcom_softc *sc = ucom->sc_parent;
 574         usbd_transfer_poll(sc->sc_xfer, USLCOM_N_TRANSFER);
 575 }