sys/dev/usbmisc/ugensa/ugensa.c

   1 /* $DragonFly: src/sys/dev/usbmisc/ugensa/ugensa.c,v 1.4 2008/05/14 20:21:22 hasso Exp $ */
   2 /* $OpenBSD: umsm.c,v 1.15 2007/06/14 10:11:16 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 /*
  21  * Generic USB serial driver used for devices where hardware specific
  22  * don't apply or doesn't make sense (for example Qualcomm MSM EVDO, UMTS
  23  * and other similar communication devices).
  24  */
  25
  26 #include <sys/param.h>
  27 #include <sys/systm.h>
  28 #include <sys/kernel.h>
  29 #include <sys/device.h>
  30 #include <sys/conf.h>
  31 #include <sys/tty.h>
  32 #include <sys/types.h>
  33 #include <sys/bus.h>
  34 #include <sys/module.h>
  35
  36 #include <bus/usb/usb.h>
  37 #include <bus/usb/usbdi.h>
  38 #include <bus/usb/usbdi_util.h>
  39 #include <dev/usbmisc/ucom/ucomvar.h>
  40
  41 #ifdef UGENSA_DEBUG
  42 static int      ugensadebug = 1;
  43 #define DPRINTFN(n, x)  do { if (ugensadebug > (n)) kprintf x; } while (0)
  44 #else
  45 #define DPRINTFN(n, x)
  46 #endif
  47 #define DPRINTF(x) DPRINTFN(0, x)
  48
  49 #define UGENSABUFSZ             4096
  50 #define UGENSA_INTR_INTERVAL    100     /* ms */
  51
  52 struct ugensa_softc {
  53         struct ucom_softc        sc_ucom;
  54
  55         /* interrupt ep */
  56         int                      sc_intr_number;
  57         usbd_pipe_handle         sc_intr_pipe;
  58         u_char                  *sc_intr_buf;
  59         int                      sc_isize;
  60
  61         u_char                   sc_lsr;        /* Local status register */
  62         u_char                   sc_msr;        /* Status register */
  63 };
  64
  65 static device_probe_t ugensa_match;
  66 static device_attach_t ugensa_attach;
  67 static device_detach_t ugensa_detach;
  68
  69 int ugensa_open(void *, int);
  70 void ugensa_close(void *, int);
  71 void ugensa_intr(usbd_xfer_handle, usbd_private_handle, usbd_status);
  72 void ugensa_get_status(void *, int, u_char *, u_char *);
  73
  74 static device_method_t ugensa_methods[] = {
  75         /* Device interface */
  76         DEVMETHOD(device_probe, ugensa_match),
  77         DEVMETHOD(device_attach, ugensa_attach),
  78         DEVMETHOD(device_detach, ugensa_detach),
  79         { 0, 0 }
  80 };
  81
  82 static driver_t ugensa_driver = {
  83         "ucom",
  84         ugensa_methods,
  85         sizeof (struct ugensa_softc)
  86 };
  87
  88 struct ucom_callback ugensa_callback = {
  89         ugensa_get_status,
  90         NULL,
  91         NULL,
  92         NULL,
  93         ugensa_open,
  94         ugensa_close,
  95         NULL,
  96         NULL
  97 };
  98
  99 static const struct usb_devno ugensa_devs[] = {
 100         { USB_DEVICE(0x05c6, 0x6613) }, /* Qualcomm HSDPA MSM */
 101         { USB_DEVICE(0x0c88, 0x17da) }, /* Kyocera KPC650 */
 102         { USB_DEVICE(0x0f3d, 0x0112) }, /* AirPrime PC5220 */
 103         { USB_DEVICE(0x1199, 0x0017) }, /* Sierra Wireless EM5625 */
 104         { USB_DEVICE(0x1199, 0x0018) }, /* Sierra Wireless MC5720 */
 105         { USB_DEVICE(0x1199, 0x0019) }, /* Sierra Wireless AirCard 595 */
 106         { USB_DEVICE(0x1199, 0x0020) }, /* Sierra Wireless MC5725 */
 107         { USB_DEVICE(0x1199, 0x0021) }, /* Sierra Wireless AirCard 597E */
 108         { USB_DEVICE(0x1199, 0x0112) }, /* Sierra Wireless AirCard 580 */
 109         { USB_DEVICE(0x1199, 0x0120) }, /* Sierra Wireless AirCard 595U */
 110         { USB_DEVICE(0x1199, 0x0218) }, /* Sierra Wireless MC5720 */
 111         { USB_DEVICE(0x1199, 0x0220) }, /* Sierra Wireless MC5725 */
 112         { USB_DEVICE(0x1199, 0x6802) }, /* Sierra Wireless MC8755 */
 113         { USB_DEVICE(0x1199, 0x6803) }, /* Sierra Wireless MC8765 */
 114         { USB_DEVICE(0x1199, 0x6804) }, /* Sierra Wireless MC8755 */
 115         { USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 */
 116         { USB_DEVICE(0x1199, 0x6813) }, /* Sierra Wireless MC8755 */
 117         { USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */
 118         { USB_DEVICE(0x1199, 0x6832) }, /* Sierra Wireless MC8780 */
 119         { USB_DEVICE(0x1199, 0x6833) }, /* Sierra Wireless MC8781 */
 120         { USB_DEVICE(0x1199, 0x6850) }, /* Sierra Wireless AirCard 880 */
 121         { USB_DEVICE(0x1199, 0x6851) }, /* Sierra Wireless AirCard 881 */
 122         { USB_DEVICE(0x1199, 0x6852) }, /* Sierra Wireless AirCard 880E */
 123         { USB_DEVICE(0x1199, 0x6853) }, /* Sierra Wireless AirCard 881E */
 124         { USB_DEVICE(0x1199, 0x6855) }, /* Sierra Wireless AirCard 880U */
 125         { USB_DEVICE(0x1199, 0x6856) }, /* Sierra Wireless AirCard 881U */
 126         { USB_DEVICE(0x12d1, 0x1001) }, /* Huawei Mobile Connect */
 127         { USB_DEVICE(0x12d1, 0x1003) }, /* Huawei Mobile E220 */
 128         { USB_DEVICE(0x12d1, 0x1004) }, /* Huawei Mobile E220 */
 129         { USB_DEVICE(0x1410, 0x1100) }, /* Novatel Wireless Merlin XS620/S640 */
 130         { USB_DEVICE(0x1410, 0x1110) }, /* Novatel Wireless Merlin S620/V620 */
 131         { USB_DEVICE(0x1410, 0x1120) }, /* Novatel Wireless Merlin EX720 */
 132         { USB_DEVICE(0x1410, 0x1130) }, /* Novatel Wireless Merlin S720 */
 133         { USB_DEVICE(0x1410, 0x1400) }, /* Novatel Wireless Merlin U730 */
 134         { USB_DEVICE(0x1410, 0x1410) }, /* Novatel Wireless Merlin U740 */
 135         { USB_DEVICE(0x1410, 0x1420) }, /* Novatel Wireless Expedite EU870D */
 136         { USB_DEVICE(0x1410, 0x1430) }, /* Novatel Wireless Merlin XU870 */
 137         { USB_DEVICE(0x1410, 0x2100) }, /* Novatel Wireless Expedite EV620 */
 138         { USB_DEVICE(0x1410, 0x2110) }, /* Novatel Wireless Merlin ES620,
 139                                            Merlin ES720, Ovation U720 */
 140         { USB_DEVICE(0x1410, 0x2130) }, /* Novatel Wireless Merlin ES620 */
 141         { USB_DEVICE(0x1410, 0x2410) }, /* Novatel Wireless Expedite EU740 */
 142         { USB_DEVICE(0x1410, 0x4100) }, /* Novatel Wireless Ovation MC727 */
 143         { USB_DEVICE(0x1410, 0x4400) }, /* Novatel Wireless Ovation MC950D */
 144         { USB_DEVICE(0x16d5, 0x6501) }, /* AnyDATA ADU-E100A/D/H */
 145         { USB_DEVICE(0x413c, 0x8114) }, /* Dell Wireless 5700 */
 146         { USB_DEVICE(0x413c, 0x8115) }, /* Dell Wireless 5500 */
 147         { USB_DEVICE(0x413c, 0x8116) }, /* Dell Wireless 5505 */
 148         { USB_DEVICE(0x413c, 0x8117) }, /* Dell Wireless 5700 */
 149         { USB_DEVICE(0x413c, 0x8118) }, /* Dell Wireless 5510 */
 150         { USB_DEVICE(0x413c, 0x8128) }, /* Dell Wireless 5700 */
 151         { USB_DEVICE(0x413c, 0x8136) }, /* Dell Wireless 5520 */
 152         { USB_DEVICE(0x413c, 0x8137) }, /* Dell Wireless 5520 */
 153 };
 154
 155 DRIVER_MODULE(ugensa, uhub, ugensa_driver, ucom_devclass, usbd_driver_load, 0);
 156 MODULE_DEPEND(ugensa, usb, 1, 1, 1);
 157 MODULE_DEPEND(ugensa, ucom, UCOM_MINVER, UCOM_PREFVER, UCOM_MAXVER);
 158 MODULE_VERSION(ugensa, 1);
 159
 160 static int
 161 ugensa_match(device_t self)
 162 {
 163         struct usb_attach_arg *uaa = device_get_ivars(self);
 164
 165         if (uaa->iface == NULL)
 166                 return UMATCH_NONE;
 167
 168         return (usb_lookup(ugensa_devs, uaa->vendor, uaa->product) != NULL) ?
 169             UMATCH_VENDOR_IFACESUBCLASS : UMATCH_NONE;
 170 }
 171
 172 static int
 173 ugensa_attach(device_t self)
 174 {
 175         struct ugensa_softc *sc = device_get_softc(self);
 176         struct usb_attach_arg *uaa = device_get_ivars(self);
 177         struct ucom_softc *ucom;
 178         usb_interface_descriptor_t *id;
 179         usb_endpoint_descriptor_t *ed;
 180         int i;
 181
 182         ucom = &sc->sc_ucom;
 183         bzero(sc, sizeof (struct ugensa_softc));
 184
 185         ucom->sc_dev = self;
 186         ucom->sc_udev = uaa->device;
 187         ucom->sc_iface = uaa->iface;
 188
 189         id = usbd_get_interface_descriptor(ucom->sc_iface);
 190
 191         ucom->sc_bulkin_no = ucom->sc_bulkout_no = -1;
 192         for (i = 0; i < id->bNumEndpoints; i++) {
 193                 ed = usbd_interface2endpoint_descriptor(ucom->sc_iface, i);
 194                 if (ed == NULL) {
 195                         device_printf(ucom->sc_dev, "no endpoint descriptor "
 196                                       "found for %d\n", i);
 197                         goto error;
 198                 }
 199
 200                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 201                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
 202                         sc->sc_intr_number = ed->bEndpointAddress;
 203                         sc->sc_isize = UGETW(ed->wMaxPacketSize);
 204                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 205                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
 206                         ucom->sc_bulkin_no = ed->bEndpointAddress;
 207                 else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
 208                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
 209                         ucom->sc_bulkout_no = ed->bEndpointAddress;
 210         }
 211         if (ucom->sc_bulkin_no == -1 || ucom->sc_bulkout_no == -1) {
 212                 device_printf(ucom->sc_dev, "missing endpoint\n");
 213                 goto error;
 214         }
 215
 216         ucom->sc_parent = sc;
 217         ucom->sc_portno = UCOM_UNK_PORTNO;
 218         ucom->sc_ibufsize = UGENSABUFSZ;
 219         ucom->sc_obufsize = UGENSABUFSZ;
 220         ucom->sc_ibufsizepad = UGENSABUFSZ;
 221         ucom->sc_opkthdrlen = 0;
 222         ucom->sc_callback = &ugensa_callback;
 223
 224         usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, ucom->sc_udev,
 225                            ucom->sc_dev);
 226
 227         DPRINTF(("%s: in = 0x%x, out = 0x%x\n",
 228                  device_get_nameunit(ucom->sc_dev), ucom->sc_bulkin_no,
 229                  ucom->sc_bulkout_no));
 230
 231         ucom_attach(&sc->sc_ucom);
 232
 233         return 0;
 234
 235 error:
 236         ucom->sc_dying = 1;
 237         return ENXIO;
 238 }
 239
 240 static int
 241 ugensa_detach(device_t self)
 242 {
 243         struct ugensa_softc *sc = device_get_softc(self);
 244         int rv = 0;
 245
 246         DPRINTF(("ugensa_detach: sc=%p\n", sc));
 247         sc->sc_ucom.sc_dying = 1;
 248         rv = ucom_detach(&sc->sc_ucom);
 249         usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_ucom.sc_udev,
 250                            sc->sc_ucom.sc_dev);
 251
 252         return (rv);
 253 }
 254
 255 #if 0 /* not yet */
 256 int
 257 ugensa_activate(struct device *self, enum devact act)
 258 {
 259         struct ugensa_softc *sc = (struct ugensa_softc *)self;
 260         int rv = 0;
 261
 262         switch (act) {
 263         case DVACT_ACTIVATE:
 264                 break;
 265
 266         case DVACT_DEACTIVATE:
 267                 if (sc->sc_subdev != NULL)
 268                         rv = config_deactivate(sc->sc_subdev);
 269                 sc->sc_dying = 1;
 270                 break;
 271         }
 272         return (rv);
 273 }
 274 #endif
 275
 276 int
 277 ugensa_open(void *addr, int portno)
 278 {
 279         struct ugensa_softc *sc = addr;
 280         int err;
 281
 282         if (sc->sc_ucom.sc_dying)
 283                 return (ENXIO);
 284
 285         if (sc->sc_intr_number != -1 && sc->sc_intr_pipe == NULL) {
 286                 sc->sc_intr_buf = kmalloc(sc->sc_isize, M_USBDEV, M_WAITOK);
 287                 err = usbd_open_pipe_intr(sc->sc_ucom.sc_iface,
 288                     sc->sc_intr_number, USBD_SHORT_XFER_OK, &sc->sc_intr_pipe,
 289                     sc, sc->sc_intr_buf, sc->sc_isize, ugensa_intr,
 290                     UGENSA_INTR_INTERVAL);
 291                 if (err) {
 292                         device_printf(sc->sc_ucom.sc_dev,
 293                             "cannot open interrupt pipe (addr %d)\n",
 294                             sc->sc_intr_number);
 295                         return (EIO);
 296                 }
 297         }
 298
 299         return (0);
 300 }
 301
 302 void
 303 ugensa_close(void *addr, int portno)
 304 {
 305         struct ugensa_softc *sc = addr;
 306         int err;
 307
 308         if (sc->sc_ucom.sc_dying)
 309                 return;
 310
 311         if (sc->sc_intr_pipe != NULL) {
 312                 err = usbd_abort_pipe(sc->sc_intr_pipe);
 313                 if (err)
 314                         device_printf(sc->sc_ucom.sc_dev,
 315                             "abort interrupt pipe failed: %s\n",
 316                             usbd_errstr(err));
 317                 err = usbd_close_pipe(sc->sc_intr_pipe);
 318                 if (err)
 319                         device_printf(sc->sc_ucom.sc_dev,
 320                             "close interrupt pipe failed: %s\n",
 321                             usbd_errstr(err));
 322                 kfree(sc->sc_intr_buf, M_USBDEV);
 323                 sc->sc_intr_pipe = NULL;
 324         }
 325
 326 }
 327
 328 void
 329 ugensa_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
 330 {
 331         struct ugensa_softc *sc = priv;
 332         u_char *buf;
 333
 334         buf = sc->sc_intr_buf;
 335         if (sc->sc_ucom.sc_dying)
 336                 return;
 337
 338         if (status != USBD_NORMAL_COMPLETION) {
 339                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
 340                         return;
 341
 342                 device_printf(sc->sc_ucom.sc_dev,
 343                     "ugensa_intr: abnormal status: %s\n", usbd_errstr(status));
 344                 usbd_clear_endpoint_stall_async(sc->sc_intr_pipe);
 345                 return;
 346         }
 347
 348         /* XXX */
 349         sc->sc_lsr = buf[2];
 350         sc->sc_msr = buf[3];
 351
 352         ucom_status_change(&sc->sc_ucom);
 353 }
 354
 355 void
 356 ugensa_get_status(void *addr, int portno, u_char *lsr, u_char *msr)
 357 {
 358         struct ugensa_softc *sc = addr;
 359
 360         if (lsr != NULL)
 361                 *lsr = sc->sc_lsr;
 362         if (msr != NULL)
 363                 *msr = sc->sc_msr;
 364 }