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/module.h>
  36 #include <sys/lock.h>
  37 #include <sys/mutex.h>
  38 #include <sys/condvar.h>
  39 #include <sys/sysctl.h>
  40 #include <sys/sx.h>
  41 #include <sys/unistd.h>
  42 #include <sys/callout.h>
  43 #include <sys/malloc.h>
  44 #include <sys/priv.h>
  45
  46 #include <dev/usb/usb.h>
  47 #include <dev/usb/usbdi.h>
  48 #include <dev/usb/usbdi_util.h>
  49 #include <dev/usb/usbhid.h>
  50 #include "usbdevs.h"
  51
  52 #define USB_DEBUG_VAR usb_debug
  53 #include <dev/usb/usb_debug.h>
  54 #include <dev/usb/usb_process.h>
  55
  56 #include <dev/usb/serial/usb_serial.h>
  57
  58 #define UARK_BUF_SIZE           1024    /* bytes */
  59
  60 #define UARK_SET_DATA_BITS(x)   ((x) - 5)
  61
  62 #define UARK_PARITY_NONE        0x00
  63 #define UARK_PARITY_ODD         0x08
  64 #define UARK_PARITY_EVEN        0x18
  65
  66 #define UARK_STOP_BITS_1        0x00
  67 #define UARK_STOP_BITS_2        0x04
  68
  69 #define UARK_BAUD_REF           3000000
  70
  71 #define UARK_WRITE              0x40
  72 #define UARK_READ               0xc0
  73
  74 #define UARK_REQUEST            0xfe
  75
  76 #define UARK_CONFIG_INDEX       0
  77 #define UARK_IFACE_INDEX        0
  78
  79 enum {
  80         UARK_BULK_DT_WR,
  81         UARK_BULK_DT_RD,
  82         UARK_N_TRANSFER,
  83 };
  84
  85 struct uark_softc {
  86         struct ucom_super_softc sc_super_ucom;
  87         struct ucom_softc sc_ucom;
  88
  89         struct usb_xfer *sc_xfer[UARK_N_TRANSFER];
  90         struct usb_device *sc_udev;
  91         struct mtx sc_mtx;
  92
  93         uint8_t sc_msr;
  94         uint8_t sc_lsr;
  95 };
  96
  97 /* prototypes */
  98
  99 static device_probe_t uark_probe;
 100 static device_attach_t uark_attach;
 101 static device_detach_t uark_detach;
 102 static void uark_free_softc(struct uark_softc *);
 103
 104 static usb_callback_t uark_bulk_write_callback;
 105 static usb_callback_t uark_bulk_read_callback;
 106
 107 static void     uark_free(struct ucom_softc *);
 108 static void     uark_start_read(struct ucom_softc *);
 109 static void     uark_stop_read(struct ucom_softc *);
 110 static void     uark_start_write(struct ucom_softc *);
 111 static void     uark_stop_write(struct ucom_softc *);
 112 static int      uark_pre_param(struct ucom_softc *, struct termios *);
 113 static void     uark_cfg_param(struct ucom_softc *, struct termios *);
 114 static void     uark_cfg_get_status(struct ucom_softc *, uint8_t *,
 115                     uint8_t *);
 116 static void     uark_cfg_set_break(struct ucom_softc *, uint8_t);
 117 static void     uark_cfg_write(struct uark_softc *, uint16_t, uint16_t);
 118 static void     uark_poll(struct ucom_softc *ucom);
 119
 120 static const struct usb_config
 121         uark_xfer_config[UARK_N_TRANSFER] = {
 122
 123         [UARK_BULK_DT_WR] = {
 124                 .type = UE_BULK,
 125                 .endpoint = UE_ADDR_ANY,
 126                 .direction = UE_DIR_OUT,
 127                 .bufsize = UARK_BUF_SIZE,
 128                 .flags = {.pipe_bof = 1,.force_short_xfer = 1,},
 129                 .callback = &uark_bulk_write_callback,
 130         },
 131
 132         [UARK_BULK_DT_RD] = {
 133                 .type = UE_BULK,
 134                 .endpoint = UE_ADDR_ANY,
 135                 .direction = UE_DIR_IN,
 136                 .bufsize = UARK_BUF_SIZE,
 137                 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
 138                 .callback = &uark_bulk_read_callback,
 139         },
 140 };
 141
 142 static const struct ucom_callback uark_callback = {
 143         .ucom_cfg_get_status = &uark_cfg_get_status,
 144         .ucom_cfg_set_break = &uark_cfg_set_break,
 145         .ucom_cfg_param = &uark_cfg_param,
 146         .ucom_pre_param = &uark_pre_param,
 147         .ucom_start_read = &uark_start_read,
 148         .ucom_stop_read = &uark_stop_read,
 149         .ucom_start_write = &uark_start_write,
 150         .ucom_stop_write = &uark_stop_write,
 151         .ucom_poll = &uark_poll,
 152         .ucom_free = &uark_free,
 153 };
 154
 155 static device_method_t uark_methods[] = {
 156         /* Device methods */
 157         DEVMETHOD(device_probe, uark_probe),
 158         DEVMETHOD(device_attach, uark_attach),
 159         DEVMETHOD(device_detach, uark_detach),
 160         DEVMETHOD_END
 161 };
 162
 163 static devclass_t uark_devclass;
 164
 165 static driver_t uark_driver = {
 166         .name = "uark",
 167         .methods = uark_methods,
 168         .size = sizeof(struct uark_softc),
 169 };
 170
 171 DRIVER_MODULE(uark, uhub, uark_driver, uark_devclass, NULL, 0);
 172 MODULE_DEPEND(uark, ucom, 1, 1, 1);
 173 MODULE_DEPEND(uark, usb, 1, 1, 1);
 174 MODULE_VERSION(uark, 1);
 175
 176 static const STRUCT_USB_HOST_ID uark_devs[] = {
 177         {USB_VPI(USB_VENDOR_ARKMICRO, USB_PRODUCT_ARKMICRO_ARK3116, 0)},
 178 };
 179
 180 static int
 181 uark_probe(device_t dev)
 182 {
 183         struct usb_attach_arg *uaa = device_get_ivars(dev);
 184
 185         if (uaa->usb_mode != USB_MODE_HOST) {
 186                 return (ENXIO);
 187         }
 188         if (uaa->info.bConfigIndex != 0) {
 189                 return (ENXIO);
 190         }
 191         if (uaa->info.bIfaceIndex != UARK_IFACE_INDEX) {
 192                 return (ENXIO);
 193         }
 194         return (usbd_lookup_id_by_uaa(uark_devs, sizeof(uark_devs), uaa));
 195 }
 196
 197 static int
 198 uark_attach(device_t dev)
 199 {
 200         struct usb_attach_arg *uaa = device_get_ivars(dev);
 201         struct uark_softc *sc = device_get_softc(dev);
 202         int32_t error;
 203         uint8_t iface_index;
 204
 205         device_set_usb_desc(dev);
 206         mtx_init(&sc->sc_mtx, "uark", NULL, MTX_DEF);
 207         ucom_ref(&sc->sc_super_ucom);
 208
 209         sc->sc_udev = uaa->device;
 210
 211         iface_index = UARK_IFACE_INDEX;
 212         error = usbd_transfer_setup
 213             (uaa->device, &iface_index, sc->sc_xfer,
 214             uark_xfer_config, UARK_N_TRANSFER, sc, &sc->sc_mtx);
 215
 216         if (error) {
 217                 device_printf(dev, "allocating control USB "
 218                     "transfers failed\n");
 219                 goto detach;
 220         }
 221         /* clear stall at first run */
 222         mtx_lock(&sc->sc_mtx);
 223         usbd_xfer_set_stall(sc->sc_xfer[UARK_BULK_DT_WR]);
 224         usbd_xfer_set_stall(sc->sc_xfer[UARK_BULK_DT_RD]);
 225         mtx_unlock(&sc->sc_mtx);
 226
 227         error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
 228             &uark_callback, &sc->sc_mtx);
 229         if (error) {
 230                 DPRINTF("ucom_attach failed\n");
 231                 goto detach;
 232         }
 233         ucom_set_pnpinfo_usb(&sc->sc_super_ucom, dev);
 234
 235         return (0);                     /* success */
 236
 237 detach:
 238         uark_detach(dev);
 239         return (ENXIO);                 /* failure */
 240 }
 241
 242 static int
 243 uark_detach(device_t dev)
 244 {
 245         struct uark_softc *sc = device_get_softc(dev);
 246
 247         ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom);
 248         usbd_transfer_unsetup(sc->sc_xfer, UARK_N_TRANSFER);
 249
 250         device_claim_softc(dev);
 251
 252         uark_free_softc(sc);
 253
 254         return (0);
 255 }
 256
 257 UCOM_UNLOAD_DRAIN(uark);
 258
 259 static void
 260 uark_free_softc(struct uark_softc *sc)
 261 {
 262         if (ucom_unref(&sc->sc_super_ucom)) {
 263                 mtx_destroy(&sc->sc_mtx);
 264                 device_free_softc(sc);
 265         }
 266 }
 267
 268 static void
 269 uark_free(struct ucom_softc *ucom)
 270 {
 271         uark_free_softc(ucom->sc_parent);
 272 }
 273
 274 static void
 275 uark_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
 276 {
 277         struct uark_softc *sc = usbd_xfer_softc(xfer);
 278         struct usb_page_cache *pc;
 279         uint32_t actlen;
 280
 281         switch (USB_GET_STATE(xfer)) {
 282         case USB_ST_SETUP:
 283         case USB_ST_TRANSFERRED:
 284 tr_setup:
 285                 pc = usbd_xfer_get_frame(xfer, 0);
 286                 if (ucom_get_data(&sc->sc_ucom, pc, 0,
 287                     UARK_BUF_SIZE, &actlen)) {
 288                         usbd_xfer_set_frame_len(xfer, 0, actlen);
 289                         usbd_transfer_submit(xfer);
 290                 }
 291                 return;
 292
 293         default:                        /* Error */
 294                 if (error != USB_ERR_CANCELLED) {
 295                         /* try to clear stall first */
 296                         usbd_xfer_set_stall(xfer);
 297                         goto tr_setup;
 298                 }
 299                 return;
 300
 301         }
 302 }
 303
 304 static void
 305 uark_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
 306 {
 307         struct uark_softc *sc = usbd_xfer_softc(xfer);
 308         struct usb_page_cache *pc;
 309         int actlen;
 310
 311         usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
 312
 313         switch (USB_GET_STATE(xfer)) {
 314         case USB_ST_TRANSFERRED:
 315                 pc = usbd_xfer_get_frame(xfer, 0);
 316                 ucom_put_data(&sc->sc_ucom, pc, 0, actlen);
 317
 318         case USB_ST_SETUP:
 319 tr_setup:
 320                 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
 321                 usbd_transfer_submit(xfer);
 322                 return;
 323
 324         default:                        /* Error */
 325                 if (error != USB_ERR_CANCELLED) {
 326                         /* try to clear stall first */
 327                         usbd_xfer_set_stall(xfer);
 328                         goto tr_setup;
 329                 }
 330                 return;
 331         }
 332 }
 333
 334 static void
 335 uark_start_read(struct ucom_softc *ucom)
 336 {
 337         struct uark_softc *sc = ucom->sc_parent;
 338
 339         usbd_transfer_start(sc->sc_xfer[UARK_BULK_DT_RD]);
 340 }
 341
 342 static void
 343 uark_stop_read(struct ucom_softc *ucom)
 344 {
 345         struct uark_softc *sc = ucom->sc_parent;
 346
 347         usbd_transfer_stop(sc->sc_xfer[UARK_BULK_DT_RD]);
 348 }
 349
 350 static void
 351 uark_start_write(struct ucom_softc *ucom)
 352 {
 353         struct uark_softc *sc = ucom->sc_parent;
 354
 355         usbd_transfer_start(sc->sc_xfer[UARK_BULK_DT_WR]);
 356 }
 357
 358 static void
 359 uark_stop_write(struct ucom_softc *ucom)
 360 {
 361         struct uark_softc *sc = ucom->sc_parent;
 362
 363         usbd_transfer_stop(sc->sc_xfer[UARK_BULK_DT_WR]);
 364 }
 365
 366 static int
 367 uark_pre_param(struct ucom_softc *ucom, struct termios *t)
 368 {
 369         if ((t->c_ospeed < 300) || (t->c_ospeed > 115200))
 370                 return (EINVAL);
 371         return (0);
 372 }
 373
 374 static void
 375 uark_cfg_param(struct ucom_softc *ucom, struct termios *t)
 376 {
 377         struct uark_softc *sc = ucom->sc_parent;
 378         uint32_t speed = t->c_ospeed;
 379         uint16_t data;
 380
 381         /*
 382          * NOTE: When reverse computing the baud rate from the "data" all
 383          * allowed baud rates are within 3% of the initial baud rate.
 384          */
 385         data = (UARK_BAUD_REF + (speed / 2)) / speed;
 386
 387         uark_cfg_write(sc, 3, 0x83);
 388         uark_cfg_write(sc, 0, data & 0xFF);
 389         uark_cfg_write(sc, 1, data >> 8);
 390         uark_cfg_write(sc, 3, 0x03);
 391
 392         if (t->c_cflag & CSTOPB)
 393                 data = UARK_STOP_BITS_2;
 394         else
 395                 data = UARK_STOP_BITS_1;
 396
 397         if (t->c_cflag & PARENB) {
 398                 if (t->c_cflag & PARODD)
 399                         data |= UARK_PARITY_ODD;
 400                 else
 401                         data |= UARK_PARITY_EVEN;
 402         } else
 403                 data |= UARK_PARITY_NONE;
 404
 405         switch (t->c_cflag & CSIZE) {
 406         case CS5:
 407                 data |= UARK_SET_DATA_BITS(5);
 408                 break;
 409         case CS6:
 410                 data |= UARK_SET_DATA_BITS(6);
 411                 break;
 412         case CS7:
 413                 data |= UARK_SET_DATA_BITS(7);
 414                 break;
 415         default:
 416         case CS8:
 417                 data |= UARK_SET_DATA_BITS(8);
 418                 break;
 419         }
 420         uark_cfg_write(sc, 3, 0x00);
 421         uark_cfg_write(sc, 3, data);
 422 }
 423
 424 static void
 425 uark_cfg_get_status(struct ucom_softc *ucom, uint8_t *lsr, uint8_t *msr)
 426 {
 427         struct uark_softc *sc = ucom->sc_parent;
 428
 429         *lsr = sc->sc_lsr;
 430         *msr = sc->sc_msr;
 431 }
 432
 433 static void
 434 uark_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff)
 435 {
 436         struct uark_softc *sc = ucom->sc_parent;
 437
 438         DPRINTF("onoff=%d\n", onoff);
 439
 440         uark_cfg_write(sc, 4, onoff ? 0x01 : 0x00);
 441 }
 442
 443 static void
 444 uark_cfg_write(struct uark_softc *sc, uint16_t index, uint16_t value)
 445 {
 446         struct usb_device_request req;
 447         usb_error_t err;
 448
 449         req.bmRequestType = UARK_WRITE;
 450         req.bRequest = UARK_REQUEST;
 451         USETW(req.wValue, value);
 452         USETW(req.wIndex, index);
 453         USETW(req.wLength, 0);
 454
 455         err = ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom,
 456             &req, NULL, 0, 1000);
 457         if (err) {
 458                 DPRINTFN(0, "device request failed, err=%s "
 459                     "(ignored)\n", usbd_errstr(err));
 460         }
 461 }
 462
 463 static void
 464 uark_poll(struct ucom_softc *ucom)
 465 {
 466         struct uark_softc *sc = ucom->sc_parent;
 467         usbd_transfer_poll(sc->sc_xfer, UARK_N_TRANSFER);
 468 }