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 MODULE_VERSION(uark, 1);
 173
 174 static const struct usb_device_id uark_devs[] = {
 175         {USB_VPI(USB_VENDOR_ARKMICRO, USB_PRODUCT_ARKMICRO_ARK3116, 0)},
 176 };
 177
 178 static int
 179 uark_probe(device_t dev)
 180 {
 181         struct usb_attach_arg *uaa = device_get_ivars(dev);
 182
 183         if (uaa->usb_mode != USB_MODE_HOST) {
 184                 return (ENXIO);
 185         }
 186         if (uaa->info.bConfigIndex != 0) {
 187                 return (ENXIO);
 188         }
 189         if (uaa->info.bIfaceIndex != UARK_IFACE_INDEX) {
 190                 return (ENXIO);
 191         }
 192         return (usbd_lookup_id_by_uaa(uark_devs, sizeof(uark_devs), uaa));
 193 }
 194
 195 static int
 196 uark_attach(device_t dev)
 197 {
 198         struct usb_attach_arg *uaa = device_get_ivars(dev);
 199         struct uark_softc *sc = device_get_softc(dev);
 200         int32_t error;
 201         uint8_t iface_index;
 202
 203         device_set_usb_desc(dev);
 204         mtx_init(&sc->sc_mtx, "uark", NULL, MTX_DEF);
 205
 206         sc->sc_udev = uaa->device;
 207
 208         iface_index = UARK_IFACE_INDEX;
 209         error = usbd_transfer_setup
 210             (uaa->device, &iface_index, sc->sc_xfer,
 211             uark_xfer_config, UARK_N_TRANSFER, sc, &sc->sc_mtx);
 212
 213         if (error) {
 214                 device_printf(dev, "allocating control USB "
 215                     "transfers failed\n");
 216                 goto detach;
 217         }
 218         /* clear stall at first run */
 219         mtx_lock(&sc->sc_mtx);
 220         usbd_xfer_set_stall(sc->sc_xfer[UARK_BULK_DT_WR]);
 221         usbd_xfer_set_stall(sc->sc_xfer[UARK_BULK_DT_RD]);
 222         mtx_unlock(&sc->sc_mtx);
 223
 224         error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
 225             &uark_callback, &sc->sc_mtx);
 226         if (error) {
 227                 DPRINTF("ucom_attach failed\n");
 228                 goto detach;
 229         }
 230         return (0);                     /* success */
 231
 232 detach:
 233         uark_detach(dev);
 234         return (ENXIO);                 /* failure */
 235 }
 236
 237 static int
 238 uark_detach(device_t dev)
 239 {
 240         struct uark_softc *sc = device_get_softc(dev);
 241
 242         ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1);
 243         usbd_transfer_unsetup(sc->sc_xfer, UARK_N_TRANSFER);
 244         mtx_destroy(&sc->sc_mtx);
 245
 246         return (0);
 247 }
 248
 249 static void
 250 uark_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
 251 {
 252         struct uark_softc *sc = usbd_xfer_softc(xfer);
 253         struct usb_page_cache *pc;
 254         uint32_t actlen;
 255
 256         switch (USB_GET_STATE(xfer)) {
 257         case USB_ST_SETUP:
 258         case USB_ST_TRANSFERRED:
 259 tr_setup:
 260                 pc = usbd_xfer_get_frame(xfer, 0);
 261                 if (ucom_get_data(&sc->sc_ucom, pc, 0,
 262                     UARK_BUF_SIZE, &actlen)) {
 263                         usbd_xfer_set_frame_len(xfer, 0, actlen);
 264                         usbd_transfer_submit(xfer);
 265                 }
 266                 return;
 267
 268         default:                        /* Error */
 269                 if (error != USB_ERR_CANCELLED) {
 270                         /* try to clear stall first */
 271                         usbd_xfer_set_stall(xfer);
 272                         goto tr_setup;
 273                 }
 274                 return;
 275
 276         }
 277 }
 278
 279 static void
 280 uark_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
 281 {
 282         struct uark_softc *sc = usbd_xfer_softc(xfer);
 283         struct usb_page_cache *pc;
 284         int actlen;
 285
 286         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
 287
 288         switch (USB_GET_STATE(xfer)) {
 289         case USB_ST_TRANSFERRED:
 290                 pc = usbd_xfer_get_frame(xfer, 0);
 291                 ucom_put_data(&sc->sc_ucom, pc, 0, actlen);
 292
 293         case USB_ST_SETUP:
 294 tr_setup:
 295                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
 296                 usbd_transfer_submit(xfer);
 297                 return;
 298
 299         default:                        /* Error */
 300                 if (error != USB_ERR_CANCELLED) {
 301                         /* try to clear stall first */
 302                         usbd_xfer_set_stall(xfer);
 303                         goto tr_setup;
 304                 }
 305                 return;
 306         }
 307 }
 308
 309 static void
 310 uark_start_read(struct ucom_softc *ucom)
 311 {
 312         struct uark_softc *sc = ucom->sc_parent;
 313
 314         usbd_transfer_start(sc->sc_xfer[UARK_BULK_DT_RD]);
 315 }
 316
 317 static void
 318 uark_stop_read(struct ucom_softc *ucom)
 319 {
 320         struct uark_softc *sc = ucom->sc_parent;
 321
 322         usbd_transfer_stop(sc->sc_xfer[UARK_BULK_DT_RD]);
 323 }
 324
 325 static void
 326 uark_start_write(struct ucom_softc *ucom)
 327 {
 328         struct uark_softc *sc = ucom->sc_parent;
 329
 330         usbd_transfer_start(sc->sc_xfer[UARK_BULK_DT_WR]);
 331 }
 332
 333 static void
 334 uark_stop_write(struct ucom_softc *ucom)
 335 {
 336         struct uark_softc *sc = ucom->sc_parent;
 337
 338         usbd_transfer_stop(sc->sc_xfer[UARK_BULK_DT_WR]);
 339 }
 340
 341 static int
 342 uark_pre_param(struct ucom_softc *ucom, struct termios *t)
 343 {
 344         if ((t->c_ospeed < 300) || (t->c_ospeed > 115200))
 345                 return (EINVAL);
 346         return (0);
 347 }
 348
 349 static void
 350 uark_cfg_param(struct ucom_softc *ucom, struct termios *t)
 351 {
 352         struct uark_softc *sc = ucom->sc_parent;
 353         uint32_t speed = t->c_ospeed;
 354         uint16_t data;
 355
 356         /*
 357          * NOTE: When reverse computing the baud rate from the "data" all
 358          * allowed baud rates are within 3% of the initial baud rate.
 359          */
 360         data = (UARK_BAUD_REF + (speed / 2)) / speed;
 361
 362         uark_cfg_write(sc, 3, 0x83);
 363         uark_cfg_write(sc, 0, data & 0xFF);
 364         uark_cfg_write(sc, 1, data >> 8);
 365         uark_cfg_write(sc, 3, 0x03);
 366
 367         if (t->c_cflag & CSTOPB)
 368                 data = UARK_STOP_BITS_2;
 369         else
 370                 data = UARK_STOP_BITS_1;
 371
 372         if (t->c_cflag & PARENB) {
 373                 if (t->c_cflag & PARODD)
 374                         data |= UARK_PARITY_ODD;
 375                 else
 376                         data |= UARK_PARITY_EVEN;
 377         } else
 378                 data |= UARK_PARITY_NONE;
 379
 380         switch (t->c_cflag & CSIZE) {
 381         case CS5:
 382                 data |= UARK_SET_DATA_BITS(5);
 383                 break;
 384         case CS6:
 385                 data |= UARK_SET_DATA_BITS(6);
 386                 break;
 387         case CS7:
 388                 data |= UARK_SET_DATA_BITS(7);
 389                 break;
 390         default:
 391         case CS8:
 392                 data |= UARK_SET_DATA_BITS(8);
 393                 break;
 394         }
 395         uark_cfg_write(sc, 3, 0x00);
 396         uark_cfg_write(sc, 3, data);
 397 }
 398
 399 static void
 400 uark_cfg_get_status(struct ucom_softc *ucom, uint8_t *lsr, uint8_t *msr)
 401 {
 402         struct uark_softc *sc = ucom->sc_parent;
 403
 404         *lsr = sc->sc_lsr;
 405         *msr = sc->sc_msr;
 406 }
 407
 408 static void
 409 uark_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff)
 410 {
 411         struct uark_softc *sc = ucom->sc_parent;
 412
 413         DPRINTF("onoff=%d\n", onoff);
 414
 415         uark_cfg_write(sc, 4, onoff ? 0x01 : 0x00);
 416 }
 417
 418 static void
 419 uark_cfg_write(struct uark_softc *sc, uint16_t index, uint16_t value)
 420 {
 421         struct usb_device_request req;
 422         usb_error_t err;
 423
 424         req.bmRequestType = UARK_WRITE;
 425         req.bRequest = UARK_REQUEST;
 426         USETW(req.wValue, value);
 427         USETW(req.wIndex, index);
 428         USETW(req.wLength, 0);
 429
 430         err = ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom,
 431             &req, NULL, 0, 1000);
 432         if (err) {
 433                 DPRINTFN(0, "device request failed, err=%s "
 434                     "(ignored)\n", usbd_errstr(err));
 435         }
 436 }
 437
 438 static void
 439 uark_poll(struct ucom_softc *ucom)
 440 {
 441         struct uark_softc *sc = ucom->sc_parent;
 442         usbd_transfer_poll(sc->sc_xfer, UARK_N_TRANSFER);
 443 }