sys/dev/usbmisc/ugensa/ugensa.c

   1 /* $DragonFly: src/sys/dev/usbmisc/ugensa/ugensa.c,v 1.5 2008/08/10 21:57:45 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 <bus/usb/usbcdc.h>
  40 #include <dev/usbmisc/ucom/ucomvar.h>
  41
  42 #ifdef UGENSA_DEBUG
  43 static int      ugensadebug = 1;
  44 #define DPRINTFN(n, x)  do { if (ugensadebug > (n)) kprintf x; } while (0)
  45 #else
  46 #define DPRINTFN(n, x)
  47 #endif
  48 #define DPRINTF(x) DPRINTFN(0, x)
  49
  50 #define UGENSABUFSZ             4096
  51 #define UGENSA_INTR_INTERVAL    100     /* ms */
  52
  53 struct ugensa_softc {
  54         struct ucom_softc        sc_ucom;
  55         int                      sc_iface_no;
  56
  57         /* interrupt ep */
  58         int                      sc_intr_number;
  59         usbd_pipe_handle         sc_intr_pipe;
  60         u_char                  *sc_intr_buf;
  61         int                      sc_isize;
  62
  63         u_char                   sc_lsr;        /* Local status register */
  64         u_char                   sc_msr;        /* Status register */
  65         u_char                   sc_dtr;        /* Current DTR state */
  66         u_char                   sc_rts;        /* Current RTS state */
  67 };
  68
  69 static device_probe_t ugensa_match;
  70 static device_attach_t ugensa_attach;
  71 static device_detach_t ugensa_detach;
  72
  73 int ugensa_open(void *, int);
  74 void ugensa_close(void *, int);
  75 void ugensa_intr(usbd_xfer_handle, usbd_private_handle, usbd_status);
  76 void ugensa_get_status(void *, int, u_char *, u_char *);
  77 void ugensa_set(void *, int, int, int);
  78
  79 static device_method_t ugensa_methods[] = {
  80         /* Device interface */
  81         DEVMETHOD(device_probe, ugensa_match),
  82         DEVMETHOD(device_attach, ugensa_attach),
  83         DEVMETHOD(device_detach, ugensa_detach),
  84         { 0, 0 }
  85 };
  86
  87 static driver_t ugensa_driver = {
  88         "ucom",
  89         ugensa_methods,
  90         sizeof (struct ugensa_softc)
  91 };
  92
  93 struct ucom_callback ugensa_callback = {
  94         ugensa_get_status,
  95         ugensa_set,
  96         NULL,
  97         NULL,
  98         ugensa_open,
  99         ugensa_close,
 100         NULL,
 101         NULL
 102 };
 103
 104 static const struct usb_devno ugensa_devs[] = {
 105         { USB_DEVICE(0x05c6, 0x6613) }, /* Qualcomm HSDPA MSM */
 106         { USB_DEVICE(0x0c88, 0x17da) }, /* Kyocera KPC650 */
 107         { USB_DEVICE(0x0f3d, 0x0112) }, /* AirPrime PC5220 */
 108         { USB_DEVICE(0x1199, 0x0017) }, /* Sierra Wireless EM5625 */
 109         { USB_DEVICE(0x1199, 0x0018) }, /* Sierra Wireless MC5720 */
 110         { USB_DEVICE(0x1199, 0x0019) }, /* Sierra Wireless AirCard 595 */
 111         { USB_DEVICE(0x1199, 0x0020) }, /* Sierra Wireless MC5725 */
 112         { USB_DEVICE(0x1199, 0x0021) }, /* Sierra Wireless AirCard 597E */
 113         { USB_DEVICE(0x1199, 0x0112) }, /* Sierra Wireless AirCard 580 */
 114         { USB_DEVICE(0x1199, 0x0120) }, /* Sierra Wireless AirCard 595U */
 115         { USB_DEVICE(0x1199, 0x0218) }, /* Sierra Wireless MC5720 */
 116         { USB_DEVICE(0x1199, 0x0220) }, /* Sierra Wireless MC5725 */
 117         { USB_DEVICE(0x1199, 0x6802) }, /* Sierra Wireless MC8755 */
 118         { USB_DEVICE(0x1199, 0x6803) }, /* Sierra Wireless MC8765 */
 119         { USB_DEVICE(0x1199, 0x6804) }, /* Sierra Wireless MC8755 */
 120         { USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 */
 121         { USB_DEVICE(0x1199, 0x6813) }, /* Sierra Wireless MC8755 */
 122         { USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */
 123         { USB_DEVICE(0x1199, 0x6832) }, /* Sierra Wireless MC8780 */
 124         { USB_DEVICE(0x1199, 0x6833) }, /* Sierra Wireless MC8781 */
 125         { USB_DEVICE(0x1199, 0x6850) }, /* Sierra Wireless AirCard 880 */
 126         { USB_DEVICE(0x1199, 0x6851) }, /* Sierra Wireless AirCard 881 */
 127         { USB_DEVICE(0x1199, 0x6852) }, /* Sierra Wireless AirCard 880E */
 128         { USB_DEVICE(0x1199, 0x6853) }, /* Sierra Wireless AirCard 881E */
 129         { USB_DEVICE(0x1199, 0x6855) }, /* Sierra Wireless AirCard 880U */
 130         { USB_DEVICE(0x1199, 0x6856) }, /* Sierra Wireless AirCard 881U */
 131         { USB_DEVICE(0x12d1, 0x1001) }, /* Huawei Mobile Connect */
 132         { USB_DEVICE(0x12d1, 0x1003) }, /* Huawei Mobile E220 */
 133         { USB_DEVICE(0x12d1, 0x1004) }, /* Huawei Mobile E220 */
 134         { USB_DEVICE(0x1410, 0x1100) }, /* Novatel Wireless Merlin XS620/S640 */
 135         { USB_DEVICE(0x1410, 0x1110) }, /* Novatel Wireless Merlin S620/V620 */
 136         { USB_DEVICE(0x1410, 0x1120) }, /* Novatel Wireless Merlin EX720 */
 137         { USB_DEVICE(0x1410, 0x1130) }, /* Novatel Wireless Merlin S720 */
 138         { USB_DEVICE(0x1410, 0x1400) }, /* Novatel Wireless Merlin U730 */
 139         { USB_DEVICE(0x1410, 0x1410) }, /* Novatel Wireless Merlin U740 */
 140         { USB_DEVICE(0x1410, 0x1420) }, /* Novatel Wireless Expedite EU870D */
 141         { USB_DEVICE(0x1410, 0x1430) }, /* Novatel Wireless Merlin XU870 */
 142         { USB_DEVICE(0x1410, 0x2100) }, /* Novatel Wireless Expedite EV620 */
 143         { USB_DEVICE(0x1410, 0x2110) }, /* Novatel Wireless Merlin ES620,
 144                                            Merlin ES720, Ovation U720 */
 145         { USB_DEVICE(0x1410, 0x2130) }, /* Novatel Wireless Merlin ES620 */
 146         { USB_DEVICE(0x1410, 0x2410) }, /* Novatel Wireless Expedite EU740 */
 147         { USB_DEVICE(0x1410, 0x4100) }, /* Novatel Wireless Ovation MC727 */
 148         { USB_DEVICE(0x1410, 0x4400) }, /* Novatel Wireless Ovation MC950D */
 149         { USB_DEVICE(0x16d5, 0x6501) }, /* AnyDATA ADU-E100A/D/H */
 150         { USB_DEVICE(0x413c, 0x8114) }, /* Dell Wireless 5700 */
 151         { USB_DEVICE(0x413c, 0x8115) }, /* Dell Wireless 5500 */
 152         { USB_DEVICE(0x413c, 0x8116) }, /* Dell Wireless 5505 */
 153         { USB_DEVICE(0x413c, 0x8117) }, /* Dell Wireless 5700 */
 154         { USB_DEVICE(0x413c, 0x8118) }, /* Dell Wireless 5510 */
 155         { USB_DEVICE(0x413c, 0x8128) }, /* Dell Wireless 5700 */
 156         { USB_DEVICE(0x413c, 0x8136) }, /* Dell Wireless 5520 */
 157         { USB_DEVICE(0x413c, 0x8137) }, /* Dell Wireless 5520 */
 158 };
 159
 160 DRIVER_MODULE(ugensa, uhub, ugensa_driver, ucom_devclass, usbd_driver_load, 0);
 161 MODULE_DEPEND(ugensa, usb, 1, 1, 1);
 162 MODULE_DEPEND(ugensa, ucom, UCOM_MINVER, UCOM_PREFVER, UCOM_MAXVER);
 163 MODULE_VERSION(ugensa, 1);
 164
 165 static int
 166 ugensa_match(device_t self)
 167 {
 168         struct usb_attach_arg *uaa = device_get_ivars(self);
 169
 170         if (uaa->iface == NULL)
 171                 return UMATCH_NONE;
 172
 173         return (usb_lookup(ugensa_devs, uaa->vendor, uaa->product) != NULL) ?
 174             UMATCH_VENDOR_IFACESUBCLASS : UMATCH_NONE;
 175 }
 176
 177 static int
 178 ugensa_attach(device_t self)
 179 {
 180         struct ugensa_softc *sc = device_get_softc(self);
 181         struct usb_attach_arg *uaa = device_get_ivars(self);
 182         struct ucom_softc *ucom;
 183         usb_interface_descriptor_t *id;
 184         usb_endpoint_descriptor_t *ed;
 185         int i;
 186
 187         ucom = &sc->sc_ucom;
 188         bzero(sc, sizeof (struct ugensa_softc));
 189
 190         ucom->sc_dev = self;
 191         ucom->sc_udev = uaa->device;
 192         ucom->sc_iface = uaa->iface;
 193
 194         id = usbd_get_interface_descriptor(ucom->sc_iface);
 195
 196         sc->sc_iface_no = id->bInterfaceNumber;
 197         ucom->sc_bulkin_no = ucom->sc_bulkout_no = -1;
 198         for (i = 0; i < id->bNumEndpoints; i++) {
 199                 ed = usbd_interface2endpoint_descriptor(ucom->sc_iface, i);
 200                 if (ed == NULL) {
 201                         device_printf(ucom->sc_dev, "no endpoint descriptor "
 202                                       "found for %d\n", i);
 203                         goto error;
 204                 }
 205
 206                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 207                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
 208                         sc->sc_intr_number = ed->bEndpointAddress;
 209                         sc->sc_isize = UGETW(ed->wMaxPacketSize);
 210                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 211                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
 212                         ucom->sc_bulkin_no = ed->bEndpointAddress;
 213                 else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
 214                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
 215                         ucom->sc_bulkout_no = ed->bEndpointAddress;
 216         }
 217         if (ucom->sc_bulkin_no == -1 || ucom->sc_bulkout_no == -1) {
 218                 device_printf(ucom->sc_dev, "missing endpoint\n");
 219                 goto error;
 220         }
 221
 222         sc->sc_dtr = sc->sc_rts = -1;
 223
 224         ucom->sc_parent = sc;
 225         ucom->sc_portno = UCOM_UNK_PORTNO;
 226         ucom->sc_ibufsize = UGENSABUFSZ;
 227         ucom->sc_obufsize = UGENSABUFSZ;
 228         ucom->sc_ibufsizepad = UGENSABUFSZ;
 229         ucom->sc_opkthdrlen = 0;
 230         ucom->sc_callback = &ugensa_callback;
 231
 232         usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, ucom->sc_udev,
 233                            ucom->sc_dev);
 234
 235         DPRINTF(("%s: in = 0x%x, out = 0x%x\n",
 236                  device_get_nameunit(ucom->sc_dev), ucom->sc_bulkin_no,
 237                  ucom->sc_bulkout_no));
 238
 239         ucom_attach(&sc->sc_ucom);
 240
 241         return 0;
 242
 243 error:
 244         ucom->sc_dying = 1;
 245         return ENXIO;
 246 }
 247
 248 static int
 249 ugensa_detach(device_t self)
 250 {
 251         struct ugensa_softc *sc = device_get_softc(self);
 252         int rv = 0;
 253
 254         /* close the interrupt endpoint if that is opened */
 255         if (sc->sc_intr_pipe != NULL) {
 256                 usbd_abort_pipe(sc->sc_intr_pipe);
 257                 usbd_close_pipe(sc->sc_intr_pipe);
 258                 kfree(sc->sc_intr_buf, M_USBDEV);
 259                 sc->sc_intr_pipe = NULL;
 260         }
 261
 262         DPRINTF(("ugensa_detach: sc=%p\n", sc));
 263         sc->sc_ucom.sc_dying = 1;
 264         rv = ucom_detach(&sc->sc_ucom);
 265         usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_ucom.sc_udev,
 266                            sc->sc_ucom.sc_dev);
 267
 268         return (rv);
 269 }
 270
 271 #if 0 /* not yet */
 272 int
 273 ugensa_activate(struct device *self, enum devact act)
 274 {
 275         struct ugensa_softc *sc = (struct ugensa_softc *)self;
 276         int rv = 0;
 277
 278         switch (act) {
 279         case DVACT_ACTIVATE:
 280                 break;
 281
 282         case DVACT_DEACTIVATE:
 283                 if (sc->sc_subdev != NULL)
 284                         rv = config_deactivate(sc->sc_subdev);
 285                 sc->sc_dying = 1;
 286                 break;
 287         }
 288         return (rv);
 289 }
 290 #endif
 291
 292 int
 293 ugensa_open(void *addr, int portno)
 294 {
 295         struct ugensa_softc *sc = addr;
 296         int err;
 297
 298         if (sc->sc_ucom.sc_dying)
 299                 return (ENXIO);
 300
 301         if (sc->sc_intr_number != -1 && sc->sc_intr_pipe == NULL) {
 302                 sc->sc_intr_buf = kmalloc(sc->sc_isize, M_USBDEV, M_WAITOK);
 303                 err = usbd_open_pipe_intr(sc->sc_ucom.sc_iface,
 304                     sc->sc_intr_number, USBD_SHORT_XFER_OK, &sc->sc_intr_pipe,
 305                     sc, sc->sc_intr_buf, sc->sc_isize, ugensa_intr,
 306                     UGENSA_INTR_INTERVAL);
 307                 if (err) {
 308                         device_printf(sc->sc_ucom.sc_dev,
 309                             "cannot open interrupt pipe (addr %d)\n",
 310                             sc->sc_intr_number);
 311                         return (EIO);
 312                 }
 313         }
 314
 315         return (0);
 316 }
 317
 318 void
 319 ugensa_close(void *addr, int portno)
 320 {
 321         struct ugensa_softc *sc = addr;
 322         int err;
 323
 324         if (sc->sc_ucom.sc_dying)
 325                 return;
 326
 327         if (sc->sc_intr_pipe != NULL) {
 328                 err = usbd_abort_pipe(sc->sc_intr_pipe);
 329                 if (err)
 330                         device_printf(sc->sc_ucom.sc_dev,
 331                             "abort interrupt pipe failed: %s\n",
 332                             usbd_errstr(err));
 333                 err = usbd_close_pipe(sc->sc_intr_pipe);
 334                 if (err)
 335                         device_printf(sc->sc_ucom.sc_dev,
 336                             "close interrupt pipe failed: %s\n",
 337                             usbd_errstr(err));
 338                 kfree(sc->sc_intr_buf, M_USBDEV);
 339                 sc->sc_intr_pipe = NULL;
 340         }
 341
 342 }
 343
 344 void
 345 ugensa_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
 346 {
 347         struct ugensa_softc *sc = priv;
 348         usb_cdc_notification_t *buf;
 349         u_char mstatus;
 350
 351         buf = (usb_cdc_notification_t *)sc->sc_intr_buf;
 352         if (sc->sc_ucom.sc_dying)
 353                 return;
 354
 355         if (status != USBD_NORMAL_COMPLETION) {
 356                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
 357                         return;
 358
 359                 device_printf(sc->sc_ucom.sc_dev,
 360                     "ugensa_intr: abnormal status: %s\n", usbd_errstr(status));
 361                 usbd_clear_endpoint_stall_async(sc->sc_intr_pipe);
 362                 return;
 363         }
 364
 365         if (buf->bmRequestType != UCDC_NOTIFICATION) {
 366                 DPRINTF(("%s: umsm_intr: unknown message type(0x%02x)\n",
 367                     sc->sc_dev.dv_xname, buf->bmRequestType));
 368                 return;
 369         }
 370
 371         if (buf->bNotification == UCDC_N_SERIAL_STATE) {
 372                 /* invalid message length, discard it */
 373                 if (UGETW(buf->wLength) != 2)
 374                         return;
 375                 /* XXX: sc_lsr is always 0 */
 376                 sc->sc_lsr = sc->sc_msr = 0;
 377                 mstatus = buf->data[0];
 378                 if (ISSET(mstatus, UCDC_N_SERIAL_RI))
 379                         sc->sc_msr |= UMSR_RI;
 380                 if (ISSET(mstatus, UCDC_N_SERIAL_DSR))
 381                         sc->sc_msr |= UMSR_DSR;
 382                 if (ISSET(mstatus, UCDC_N_SERIAL_DCD))
 383                         sc->sc_msr |= UMSR_DCD;
 384         } else if (buf->bNotification != UCDC_N_CONNECTION_SPEED_CHANGE) {
 385                 DPRINTF(("%s: umsm_intr: unknown notify message (0x%02x)\n",
 386                     sc->sc_dev.dv_xname, buf->bNotification));
 387                 return;
 388         }
 389
 390         ucom_status_change(&sc->sc_ucom);
 391 }
 392
 393 void
 394 ugensa_get_status(void *addr, int portno, u_char *lsr, u_char *msr)
 395 {
 396         struct ugensa_softc *sc = addr;
 397
 398         if (lsr != NULL)
 399                 *lsr = sc->sc_lsr;
 400         if (msr != NULL)
 401                 *msr = sc->sc_msr;
 402 }
 403
 404 void
 405 ugensa_set(void *addr, int portno, int reg, int onoff)
 406 {
 407         struct ugensa_softc *sc = addr;
 408         usb_device_request_t req;
 409         int ls;
 410
 411         switch (reg) {
 412         case UCOM_SET_DTR:
 413                 if (sc->sc_dtr == onoff)
 414                         return;
 415                 sc->sc_dtr = onoff;
 416                 break;
 417         case UCOM_SET_RTS:
 418                 if (sc->sc_rts == onoff)
 419                         return;
 420                 sc->sc_rts = onoff;
 421                 break;
 422         default:
 423                 return;
 424         }
 425
 426         /* build an usb request */
 427         ls = (sc->sc_dtr ? UCDC_LINE_DTR : 0) |
 428             (sc->sc_rts ? UCDC_LINE_RTS : 0);
 429         req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
 430         req.bRequest = UCDC_SET_CONTROL_LINE_STATE;
 431         USETW(req.wValue, ls);
 432         USETW(req.wIndex, sc->sc_iface_no);
 433         USETW(req.wLength, 0);
 434
 435         (void)usbd_do_request(sc->sc_ucom.sc_udev, &req, 0);
 436 }
 437