sys/dev/usbmisc/uark/uark.c

   1 /*      $DragonFly: src/sys/dev/usbmisc/uark/uark.c,v 1.2 2007/08/17 06:40:19 hasso Exp $       */
   2 /*      $OpenBSD: uark.c,v 1.9 2007/06/13 06:25:03 mbalmer Exp $        */
   3
   4 /*
   5  * Copyright (c) 2006 Jonathan Gray <jsg@openbsd.org>
   6  *
   7  * Permission to use, copy, modify, and distribute this software for any
   8  * purpose with or without fee is hereby granted, provided that the above
   9  * copyright notice and this permission notice appear in all copies.
  10  *
  11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18  */
  19
  20 #include <sys/param.h>
  21 #include <sys/systm.h>
  22 #include <sys/kernel.h>
  23 #include <sys/conf.h>
  24 #include <sys/tty.h>
  25 #include <sys/device.h>
  26 #include <sys/types.h>
  27 #include <sys/bus.h>
  28 #include <sys/module.h>
  29
  30 #include <bus/usb/usb.h>
  31 #include <bus/usb/usbdi.h>
  32 #include <bus/usb/usbdi_util.h>
  33 #include <bus/usb/usbdevs.h>
  34
  35 #include <dev/usbmisc/ucom/ucomvar.h>
  36
  37 #ifdef UARK_DEBUG
  38 #define DPRINTFN(n, x)  do { if (uarkdebug > (n)) kprintf x; } while (0)
  39 int     uarkebug = 0;
  40 #else
  41 #define DPRINTFN(n, x)
  42 #endif
  43 #define DPRINTF(x) DPRINTFN(0, x)
  44
  45 #define UARKBUFSZ               256
  46 #define UARK_CONFIG_NO          0
  47 #define UARK_IFACE_NO           0
  48
  49 #define UARK_SET_DATA_BITS(x)   (x - 5)
  50
  51 #define UARK_PARITY_NONE        0x00
  52 #define UARK_PARITY_ODD         0x08
  53 #define UARK_PARITY_EVEN        0x18
  54
  55 #define UARK_STOP_BITS_1        0x00
  56 #define UARK_STOP_BITS_2        0x04
  57
  58 #define UARK_BAUD_REF           3000000
  59
  60 #define UARK_WRITE              0x40
  61 #define UARK_READ               0xc0
  62
  63 #define UARK_REQUEST            0xfe
  64
  65 struct uark_softc {
  66         struct ucom_softc       sc_ucom;
  67         u_char                  sc_msr;
  68         u_char                  sc_lsr;
  69 };
  70
  71 static void     uark_get_status(void *, int portno, u_char *lsr, u_char *msr);
  72 static void     uark_set(void *, int, int, int);
  73 static int      uark_param(void *, int, struct termios *);
  74 static void     uark_break(void *, int, int);
  75 static int      uark_cmd(struct uark_softc *, uint16_t, uint16_t);
  76
  77 struct ucom_callback uark_callback = {
  78         uark_get_status,
  79         uark_set,
  80         uark_param,
  81         NULL,
  82         NULL,
  83         NULL,
  84         NULL,
  85         NULL,
  86 };
  87
  88 static const struct usb_devno uark_devs[] = {
  89         { USB_VENDOR_ARKMICRO,          USB_PRODUCT_ARKMICRO_ARK3116 }
  90 };
  91
  92 static device_probe_t uark_match;
  93 static device_attach_t uark_attach;
  94 static device_detach_t uark_detach;
  95
  96 static device_method_t uark_methods[] = {
  97         /* Device interface */
  98         DEVMETHOD(device_probe, uark_match),
  99         DEVMETHOD(device_attach, uark_attach),
 100         DEVMETHOD(device_detach, uark_detach),
 101         { 0, 0 }
 102 };
 103
 104 static driver_t uark_driver = {
 105         "ucom",
 106         uark_methods,
 107         sizeof (struct uark_softc)
 108 };
 109
 110 DRIVER_MODULE(uark, uhub, uark_driver, ucom_devclass, usbd_driver_load, 0);
 111 MODULE_DEPEND(uark, usb, 1, 1, 1);
 112 MODULE_DEPEND(uark, ucom, UCOM_MINVER, UCOM_PREFVER, UCOM_MAXVER);
 113 MODULE_VERSION(uark, 1);
 114
 115 static int
 116 uark_match(device_t self)
 117 {
 118         struct usb_attach_arg *uaa = device_get_ivars(self);
 119
 120         if (uaa->iface != NULL)
 121                 return UMATCH_NONE;
 122
 123         return (usb_lookup(uark_devs, uaa->vendor, uaa->product) != NULL) ?
 124             UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
 125 }
 126
 127 static int
 128 uark_attach(device_t self)
 129 {
 130         struct uark_softc *sc = device_get_softc(self);
 131         struct usb_attach_arg *uaa = device_get_ivars(self);
 132         struct ucom_softc *ucom;
 133         usb_interface_descriptor_t *id;
 134         usb_endpoint_descriptor_t *ed;
 135         usbd_status error;
 136         char *devinfo;
 137         const char *devname;
 138         int i;
 139
 140         devinfo = kmalloc(1024, M_USBDEV, M_INTWAIT);
 141         ucom = &sc->sc_ucom;
 142
 143         bzero(sc, sizeof (struct uark_softc));
 144
 145         usbd_devinfo(uaa->device, 0, devinfo);
 146         ucom->sc_dev = self;
 147         device_set_desc_copy(self, devinfo);
 148
 149         ucom->sc_udev = uaa->device;
 150         ucom->sc_iface = uaa->iface;
 151
 152         devname = device_get_nameunit(ucom->sc_dev);
 153         kprintf("%s: %s\n", devname, devinfo);
 154         kfree(devinfo, M_USBDEV);
 155
 156         if (usbd_set_config_index(ucom->sc_udev, UARK_CONFIG_NO, 1) != 0) {
 157                 kprintf("%s: could not set configuration no\n", devname);
 158                 goto error;
 159         }
 160
 161         /* get the first interface handle */
 162         error = usbd_device2interface_handle(ucom->sc_udev, UARK_IFACE_NO,
 163             &ucom->sc_iface);
 164         if (error != 0) {
 165                 kprintf("%s: could not get interface handle\n", devname);
 166                 goto error;
 167         }
 168
 169         id = usbd_get_interface_descriptor(ucom->sc_iface);
 170
 171         ucom->sc_bulkin_no = ucom->sc_bulkout_no = -1;
 172         for (i = 0; i < id->bNumEndpoints; i++) {
 173                 ed = usbd_interface2endpoint_descriptor(ucom->sc_iface, i);
 174                 if (ed == NULL) {
 175                         kprintf("%s: no endpoint descriptor found for %d\n",
 176                             devname, i);
 177                         goto error;
 178                 }
 179
 180                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 181                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
 182                         ucom->sc_bulkin_no = ed->bEndpointAddress;
 183                 else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
 184                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
 185                         ucom->sc_bulkout_no = ed->bEndpointAddress;
 186         }
 187
 188         if (ucom->sc_bulkin_no == -1 || ucom->sc_bulkout_no == -1) {
 189                 kprintf("%s: missing endpoint\n", devname);
 190                 goto error;
 191         }
 192
 193         ucom->sc_parent = sc;
 194         ucom->sc_portno = UCOM_UNK_PORTNO;
 195         ucom->sc_ibufsize = UARKBUFSZ;
 196         ucom->sc_obufsize = UARKBUFSZ;
 197         ucom->sc_ibufsizepad = UARKBUFSZ;
 198         ucom->sc_opkthdrlen = 0;
 199         ucom->sc_callback = &uark_callback;
 200
 201         usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, ucom->sc_udev,
 202                            ucom->sc_dev);
 203
 204         DPRINTF(("uark: in = 0x%x, out = 0x%x, intr = 0x%x\n",
 205                  ucom->sc_bulkin_no, ucom->sc_bulkout_no, sc->sc_intr_number));
 206
 207         ucom_attach(&sc->sc_ucom);
 208
 209         return 0;
 210
 211 error:
 212         ucom->sc_dying = 1;
 213         return ENXIO;
 214 }
 215
 216 static int
 217 uark_detach(device_t self)
 218 {
 219         struct uark_softc *sc = device_get_softc(self);
 220         int rv = 0;
 221
 222         DPRINTF(("uark_detach: sc=%p\n", sc));
 223         sc->sc_ucom.sc_dying = 1;
 224         rv = ucom_detach(&sc->sc_ucom);
 225         usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_ucom.sc_udev,
 226                            sc->sc_ucom.sc_dev);
 227
 228         return (rv);
 229 }
 230
 231 #if 0 /* not yet */
 232 int
 233 uark_activate(struct device *self, enum devact act)
 234 {
 235         struct uark_softc *sc = (struct uark_softc *)self;
 236         int rv = 0;
 237
 238         switch (act) {
 239         case DVACT_ACTIVATE:
 240                 break;
 241
 242         case DVACT_DEACTIVATE:
 243                 if (sc->sc_subdev != NULL)
 244                         rv = config_deactivate(sc->sc_subdev);
 245                 sc->sc_dying = 1;
 246                 break;
 247         }
 248         return (rv);
 249 }
 250 #endif
 251
 252 static void
 253 uark_set(void *vsc, int portno, int reg, int onoff)
 254 {
 255         struct uark_softc *sc = vsc;
 256
 257         switch (reg) {
 258         case UCOM_SET_BREAK:
 259                 uark_break(sc, portno, onoff);
 260                 return;
 261         case UCOM_SET_DTR:
 262         case UCOM_SET_RTS:
 263         default:
 264                 return;
 265         }
 266 }
 267
 268 static int
 269 uark_param(void *vsc, int portno, struct termios *t)
 270 {
 271         struct uark_softc *sc = (struct uark_softc *)vsc;
 272         int data;
 273
 274         switch (t->c_ospeed) {
 275         case 300:
 276         case 600:
 277         case 1200:
 278         case 1800:
 279         case 2400:
 280         case 4800:
 281         case 9600:
 282         case 19200:
 283         case 38400:
 284         case 57600:
 285         case 115200:
 286                 uark_cmd(sc, 3, 0x83);
 287                 uark_cmd(sc, 0, (UARK_BAUD_REF / t->c_ospeed) & 0xFF);
 288                 uark_cmd(sc, 1, (UARK_BAUD_REF / t->c_ospeed) >> 8);
 289                 uark_cmd(sc, 3, 0x03);
 290                 break;
 291         default:
 292                 return (EINVAL);
 293         }
 294
 295         if (ISSET(t->c_cflag, CSTOPB))
 296                 data = UARK_STOP_BITS_2;
 297         else
 298                 data = UARK_STOP_BITS_1;
 299
 300         if (ISSET(t->c_cflag, PARENB)) {
 301                 if (ISSET(t->c_cflag, PARODD))
 302                         data |= UARK_PARITY_ODD;
 303                 else
 304                         data |= UARK_PARITY_EVEN;
 305         } else
 306                 data |= UARK_PARITY_NONE;
 307
 308         switch (ISSET(t->c_cflag, CSIZE)) {
 309         case CS5:
 310                 data |= UARK_SET_DATA_BITS(5);
 311                 break;
 312         case CS6:
 313                 data |= UARK_SET_DATA_BITS(6);
 314                 break;
 315         case CS7:
 316                 data |= UARK_SET_DATA_BITS(7);
 317                 break;
 318         case CS8:
 319                 data |= UARK_SET_DATA_BITS(8);
 320                 break;
 321         }
 322
 323         uark_cmd(sc, 3, 0x00);
 324         uark_cmd(sc, 3, data);
 325
 326 #if 0
 327         /* XXX flow control */
 328         if (ISSET(t->c_cflag, CRTSCTS))
 329                 /*  rts/cts flow ctl */
 330         } else if (ISSET(t->c_iflag, IXON|IXOFF)) {
 331                 /*  xon/xoff flow ctl */
 332         } else {
 333                 /* disable flow ctl */
 334         }
 335 #endif
 336
 337         return (0);
 338 }
 339
 340 static void
 341 uark_get_status(void *vsc, int portno, u_char *lsr, u_char *msr)
 342 {
 343         struct uark_softc *sc = vsc;
 344
 345         if (msr != NULL)
 346                 *msr = sc->sc_msr;
 347         if (lsr != NULL)
 348                 *lsr = sc->sc_lsr;
 349 }
 350
 351 static void
 352 uark_break(void *vsc, int portno, int onoff)
 353 {
 354 #ifdef UARK_DEBUG
 355         struct uark_softc *sc = vsc;
 356
 357         kprintf("%s: break %s!\n", device_get_nameunit(sc->sc_ucom->sc_dev),
 358             onoff ? "on" : "off");
 359
 360         if (onoff)
 361                 /* break on */
 362                 uark_cmd(sc, 4, 0x01);
 363         else
 364                 uark_cmd(sc, 4, 0x00);
 365 #endif
 366 }
 367
 368 static int
 369 uark_cmd(struct uark_softc *sc, uint16_t index, uint16_t value)
 370 {
 371         usb_device_request_t req;
 372         usbd_status err;
 373
 374         req.bmRequestType = UARK_WRITE;
 375         req.bRequest = UARK_REQUEST;
 376         USETW(req.wValue, value);
 377         USETW(req.wIndex, index);
 378         USETW(req.wLength, 0);
 379         err = usbd_do_request(sc->sc_ucom.sc_udev, &req, NULL);
 380
 381         if (err)
 382                 return (EIO);
 383
 384         return (0);
 385 }