sys/dev/usb/serial/uark.c

   1 /*      $OpenBSD: uark.c,v 1.1 2006/08/14 08:30:22 jsg Exp $    */
   2
   3 /*
   4  * Copyright (c) 2006 Jonathan Gray <jsg@openbsd.org>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  *
  18  * $FreeBSD$
  19  */
  20
  21 /*
  22  * NOTE: all function names beginning like "uark_cfg_" can only
  23  * be called from within the config thread function !
  24  */
  25
  26
  27 #include <sys/stdint.h>
  28 #include <sys/stddef.h>
  29 #include <sys/param.h>
  30 #include <sys/queue.h>
  31 #include <sys/types.h>
  32 #include <sys/systm.h>
  33 #include <sys/kernel.h>
  34 #include <sys/bus.h>
  35 #include <sys/linker_set.h>
  36 #include <sys/module.h>
  37 #include <sys/lock.h>
  38 #include <sys/mutex.h>
  39 #include <sys/condvar.h>
  40 #include <sys/sysctl.h>
  41 #include <sys/sx.h>
  42 #include <sys/unistd.h>
  43 #include <sys/callout.h>
  44 #include <sys/malloc.h>
  45 #include <sys/priv.h>
  46
  47 #include <dev/usb/usb.h>
  48 #include <dev/usb/usbdi.h>
  49 #include <dev/usb/usbdi_util.h>
  50 #include <dev/usb/usbhid.h>
  51 #include "usbdevs.h"
  52
  53 #define USB_DEBUG_VAR usb_debug
  54 #include <dev/usb/usb_debug.h>
  55 #include <dev/usb/usb_process.h>
  56
  57 #include <dev/usb/serial/usb_serial.h>
  58
  59 #define UARK_BUF_SIZE           1024    /* bytes */
  60
  61 #define UARK_SET_DATA_BITS(x)   ((x) - 5)
  62
  63 #define UARK_PARITY_NONE        0x00
  64 #define UARK_PARITY_ODD         0x08
  65 #define UARK_PARITY_EVEN        0x18
  66
  67 #define UARK_STOP_BITS_1        0x00
  68 #define UARK_STOP_BITS_2        0x04
  69
  70 #define UARK_BAUD_REF           3000000
  71
  72 #define UARK_WRITE              0x40
  73 #define UARK_READ               0xc0
  74
  75 #define UARK_REQUEST            0xfe
  76
  77 #define UARK_CONFIG_INDEX       0
  78 #define UARK_IFACE_INDEX        0
  79
  80 enum {
  81         UARK_BULK_DT_WR,
  82         UARK_BULK_DT_RD,
  83         UARK_N_TRANSFER,
  84 };
  85
  86 struct uark_softc {
  87         struct ucom_super_softc sc_super_ucom;
  88         struct ucom_softc sc_ucom;
  89
  90         struct usb_xfer *sc_xfer[UARK_N_TRANSFER];
  91         struct usb_device *sc_udev;
  92         struct mtx sc_mtx;
  93
  94         uint8_t sc_msr;
  95         uint8_t sc_lsr;
  96 };
  97
  98 /* prototypes */
  99
 100 static device_probe_t uark_probe;
 101 static device_attach_t uark_attach;
 102 static device_detach_t uark_detach;
 103
 104 static usb_callback_t uark_bulk_write_callback;
 105 static usb_callback_t uark_bulk_read_callback;
 106
 107 static void     uark_start_read(struct ucom_softc *);
 108 static void     uark_stop_read(struct ucom_softc *);
 109 static void     uark_start_write(struct ucom_softc *);
 110 static void     uark_stop_write(struct ucom_softc *);
 111 static int      uark_pre_param(struct ucom_softc *, struct termios *);
 112 static void     uark_cfg_param(struct ucom_softc *, struct termios *);
 113 static void     uark_cfg_get_status(struct ucom_softc *, uint8_t *,
 114                     uint8_t *);
 115 static void     uark_cfg_set_break(struct ucom_softc *, uint8_t);
 116 static void     uark_cfg_write(struct uark_softc *, uint16_t, uint16_t);
 117 static void     uark_poll(struct ucom_softc *ucom);
 118
 119 static const struct usb_config
 120         uark_xfer_config[UARK_N_TRANSFER] = {
 121
 122         [UARK_BULK_DT_WR] = {
 123                 .type = UE_BULK,
 124                 .endpoint = UE_ADDR_ANY,
 125                 .direction = UE_DIR_OUT,
 126                 .bufsize = UARK_BUF_SIZE,
 127                 .flags = {.pipe_bof = 1,.force_short_xfer = 1,},
 128                 .callback = &uark_bulk_write_callback,
 129         },
 130
 131         [UARK_BULK_DT_RD] = {
 132                 .type = UE_BULK,
 133                 .endpoint = UE_ADDR_ANY,
 134                 .direction = UE_DIR_IN,
 135                 .bufsize = UARK_BUF_SIZE,
 136                 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
 137                 .callback = &uark_bulk_read_callback,
 138         },
 139 };
 140
 141 static const struct ucom_callback uark_callback = {
 142         .ucom_cfg_get_status = &uark_cfg_get_status,
 143         .ucom_cfg_set_break = &uark_cfg_set_break,
 144         .ucom_cfg_param = &uark_cfg_param,
 145         .ucom_pre_param = &uark_pre_param,
 146         .ucom_start_read = &uark_start_read,
 147         .ucom_stop_read = &uark_stop_read,
 148         .ucom_start_write = &uark_start_write,
 149         .ucom_stop_write = &uark_stop_write,
 150         .ucom_poll = &uark_poll,
 151 };
 152
 153 static device_method_t uark_methods[] = {
 154         /* Device methods */
 155         DEVMETHOD(device_probe, uark_probe),
 156         DEVMETHOD(device_attach, uark_attach),
 157         DEVMETHOD(device_detach, uark_detach),
 158         {0, 0}
 159 };
 160
 161 static devclass_t uark_devclass;
 162
 163 static driver_t uark_driver = {
 164         .name = "uark",
 165         .methods = uark_methods,
 166         .size = sizeof(struct uark_softc),
 167 };
 168
 169 DRIVER_MODULE(uark, uhub, uark_driver, uark_devclass, NULL, 0);
 170 MODULE_DEPEND(uark, ucom, 1, 1, 1);
 171 MODULE_DEPEND(uark, usb, 1, 1, 1);
 172
 173 static const struct usb_device_id uark_devs[] = {
 174         {USB_VPI(USB_VENDOR_ARKMICRO, USB_PRODUCT_ARKMICRO_ARK3116, 0)},
 175 };
 176
 177 static int
 178 uark_probe(device_t dev)
 179 {
 180         struct usb_attach_arg *uaa = device_get_ivars(dev);
 181
 182         if (uaa->usb_mode != USB_MODE_HOST) {
 183                 return (ENXIO);
 184         }
 185         if (uaa->info.bConfigIndex != 0) {
 186                 return (ENXIO);
 187         }
 188         if (uaa->info.bIfaceIndex != UARK_IFACE_INDEX) {
 189                 return (ENXIO);
 190         }
 191         return (usbd_lookup_id_by_uaa(uark_devs, sizeof(uark_devs), uaa));
 192 }
 193
 194 static int
 195 uark_attach(device_t dev)
 196 {
 197         struct usb_attach_arg *uaa = device_get_ivars(dev);
 198         struct uark_softc *sc = device_get_softc(dev);
 199         int32_t error;
 200         uint8_t iface_index;
 201
 202         device_set_usb_desc(dev);
 203         mtx_init(&sc->sc_mtx, "uark", NULL, MTX_DEF);
 204
 205         sc->sc_udev = uaa->device;
 206
 207         iface_index = UARK_IFACE_INDEX;
 208         error = usbd_transfer_setup
 209             (uaa->device, &iface_index, sc->sc_xfer,
 210             uark_xfer_config, UARK_N_TRANSFER, sc, &sc->sc_mtx);
 211
 212         if (error) {
 213                 device_printf(dev, "allocating control USB "
 214                     "transfers failed\n");
 215                 goto detach;
 216         }
 217         /* clear stall at first run */
 218         mtx_lock(&sc->sc_mtx);
 219         usbd_xfer_set_stall(sc->sc_xfer[UARK_BULK_DT_WR]);
 220         usbd_xfer_set_stall(sc->sc_xfer[UARK_BULK_DT_RD]);
 221         mtx_unlock(&sc->sc_mtx);
 222
 223         error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
 224             &uark_callback, &sc->sc_mtx);
 225         if (error) {
 226                 DPRINTF("ucom_attach failed\n");
 227                 goto detach;
 228         }
 229         return (0);                     /* success */
 230
 231 detach:
 232         uark_detach(dev);
 233         return (ENXIO);                 /* failure */
 234 }
 235
 236 static int
 237 uark_detach(device_t dev)
 238 {
 239         struct uark_softc *sc = device_get_softc(dev);
 240
 241         ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
 242         usbd_transfer_unsetup(sc->sc_xfer, UARK_N_TRANSFER);
 243         mtx_destroy(&sc->sc_mtx);
 244
 245         return (0);
 246 }
 247
 248 static void
 249 uark_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
 250 {
 251         struct uark_softc *sc = usbd_xfer_softc(xfer);
 252         struct usb_page_cache *pc;
 253         uint32_t actlen;
 254
 255         switch (USB_GET_STATE(xfer)) {
 256         case USB_ST_SETUP:
 257         case USB_ST_TRANSFERRED:
 258 tr_setup:
 259                 pc = usbd_xfer_get_frame(xfer, 0);
 260                 if (ucom_get_data(&sc->sc_ucom, pc, 0,
 261                     UARK_BUF_SIZE, &actlen)) {
 262                         usbd_xfer_set_frame_len(xfer, 0, actlen);
 263                         usbd_transfer_submit(xfer);
 264                 }
 265                 return;
 266
 267         default:                        /* Error */
 268                 if (error != USB_ERR_CANCELLED) {
 269                         /* try to clear stall first */
 270                         usbd_xfer_set_stall(xfer);
 271                         goto tr_setup;
 272                 }
 273                 return;
 274
 275         }
 276 }
 277
 278 static void
 279 uark_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
 280 {
 281         struct uark_softc *sc = usbd_xfer_softc(xfer);
 282         struct usb_page_cache *pc;
 283         int actlen;
 284
 285         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
 286
 287         switch (USB_GET_STATE(xfer)) {
 288         case USB_ST_TRANSFERRED:
 289                 pc = usbd_xfer_get_frame(xfer, 0);
 290                 ucom_put_data(&sc->sc_ucom, pc, 0, actlen);
 291
 292         case USB_ST_SETUP:
 293 tr_setup:
 294                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
 295                 usbd_transfer_submit(xfer);
 296                 return;
 297
 298         default:                        /* Error */
 299                 if (error != USB_ERR_CANCELLED) {
 300                         /* try to clear stall first */
 301                         usbd_xfer_set_stall(xfer);
 302                         goto tr_setup;
 303                 }
 304                 return;
 305         }
 306 }
 307
 308 static void
 309 uark_start_read(struct ucom_softc *ucom)
 310 {
 311         struct uark_softc *sc = ucom->sc_parent;
 312
 313         usbd_transfer_start(sc->sc_xfer[UARK_BULK_DT_RD]);
 314 }
 315
 316 static void
 317 uark_stop_read(struct ucom_softc *ucom)
 318 {
 319         struct uark_softc *sc = ucom->sc_parent;
 320
 321         usbd_transfer_stop(sc->sc_xfer[UARK_BULK_DT_RD]);
 322 }
 323
 324 static void
 325 uark_start_write(struct ucom_softc *ucom)
 326 {
 327         struct uark_softc *sc = ucom->sc_parent;
 328
 329         usbd_transfer_start(sc->sc_xfer[UARK_BULK_DT_WR]);
 330 }
 331
 332 static void
 333 uark_stop_write(struct ucom_softc *ucom)
 334 {
 335         struct uark_softc *sc = ucom->sc_parent;
 336
 337         usbd_transfer_stop(sc->sc_xfer[UARK_BULK_DT_WR]);
 338 }
 339
 340 static int
 341 uark_pre_param(struct ucom_softc *ucom, struct termios *t)
 342 {
 343         if ((t->c_ospeed < 300) || (t->c_ospeed > 115200))
 344                 return (EINVAL);
 345         return (0);
 346 }
 347
 348 static void
 349 uark_cfg_param(struct ucom_softc *ucom, struct termios *t)
 350 {
 351         struct uark_softc *sc = ucom->sc_parent;
 352         uint32_t speed = t->c_ospeed;
 353         uint16_t data;
 354
 355         /*
 356          * NOTE: When reverse computing the baud rate from the "data" all
 357          * allowed baud rates are within 3% of the initial baud rate.
 358          */
 359         data = (UARK_BAUD_REF + (speed / 2)) / speed;
 360
 361         uark_cfg_write(sc, 3, 0x83);
 362         uark_cfg_write(sc, 0, data & 0xFF);
 363         uark_cfg_write(sc, 1, data >> 8);
 364         uark_cfg_write(sc, 3, 0x03);
 365
 366         if (t->c_cflag & CSTOPB)
 367                 data = UARK_STOP_BITS_2;
 368         else
 369                 data = UARK_STOP_BITS_1;
 370
 371         if (t->c_cflag & PARENB) {
 372                 if (t->c_cflag & PARODD)
 373                         data |= UARK_PARITY_ODD;
 374                 else
 375                         data |= UARK_PARITY_EVEN;
 376         } else
 377                 data |= UARK_PARITY_NONE;
 378
 379         switch (t->c_cflag & CSIZE) {
 380         case CS5:
 381                 data |= UARK_SET_DATA_BITS(5);
 382                 break;
 383         case CS6:
 384                 data |= UARK_SET_DATA_BITS(6);
 385                 break;
 386         case CS7:
 387                 data |= UARK_SET_DATA_BITS(7);
 388                 break;
 389         default:
 390         case CS8:
 391                 data |= UARK_SET_DATA_BITS(8);
 392                 break;
 393         }
 394         uark_cfg_write(sc, 3, 0x00);
 395         uark_cfg_write(sc, 3, data);
 396 }
 397
 398 static void
 399 uark_cfg_get_status(struct ucom_softc *ucom, uint8_t *lsr, uint8_t *msr)
 400 {
 401         struct uark_softc *sc = ucom->sc_parent;
 402
 403         *lsr = sc->sc_lsr;
 404         *msr = sc->sc_msr;
 405 }
 406
 407 static void
 408 uark_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff)
 409 {
 410         struct uark_softc *sc = ucom->sc_parent;
 411
 412         DPRINTF("onoff=%d\n", onoff);
 413
 414         uark_cfg_write(sc, 4, onoff ? 0x01 : 0x00);
 415 }
 416
 417 static void
 418 uark_cfg_write(struct uark_softc *sc, uint16_t index, uint16_t value)
 419 {
 420         struct usb_device_request req;
 421         usb_error_t err;
 422
 423         req.bmRequestType = UARK_WRITE;
 424         req.bRequest = UARK_REQUEST;
 425         USETW(req.wValue, value);
 426         USETW(req.wIndex, index);
 427         USETW(req.wLength, 0);
 428
 429         err = ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom,
 430             &req, NULL, 0, 1000);
 431         if (err) {
 432                 DPRINTFN(0, "device request failed, err=%s "
 433                     "(ignored)\n", usbd_errstr(err));
 434         }
 435 }
 436
 437 static void
 438 uark_poll(struct ucom_softc *ucom)
 439 {
 440         struct uark_softc *sc = ucom->sc_parent;
 441         usbd_transfer_poll(sc->sc_xfer, UARK_N_TRANSFER);
 442 }