sys/dev/usbmisc/ugensa/ugensa.c

   1 /* $DragonFly: src/sys/dev/usbmisc/ugensa/ugensa.c,v 1.2 2008/02/20 09:00:55 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
  51 struct ugensa_softc {
  52         struct ucom_softc        sc_ucom;
  53 };
  54
  55 struct ucom_callback ugensa_callback = {
  56         NULL,
  57         NULL,
  58         NULL,
  59         NULL,
  60         NULL,
  61         NULL,
  62         NULL,
  63         NULL
  64 };
  65
  66 static const struct usb_devno ugensa_devs[] = {
  67         { USB_DEVICE(0x05c6, 0x6613) }, /* Qualcomm HSDPA MSM */
  68         { USB_DEVICE(0x0c88, 0x17da) }, /* Kyocera KPC650 */
  69         { USB_DEVICE(0x0f3d, 0x0112) }, /* AirPrime PC5220 */
  70         { USB_DEVICE(0x1199, 0x0017) }, /* Sierra Wireless EM5625 */
  71         { USB_DEVICE(0x1199, 0x0018) }, /* Sierra Wireless MC5720 */
  72         { USB_DEVICE(0x1199, 0x0019) }, /* Sierra Wireless AirCard 595 */
  73         { USB_DEVICE(0x1199, 0x0020) }, /* Sierra Wireless MC5725 */
  74         { USB_DEVICE(0x1199, 0x0021) }, /* Sierra Wireless AirCard 597E */
  75         { USB_DEVICE(0x1199, 0x0112) }, /* Sierra Wireless AirCard 580 */
  76         { USB_DEVICE(0x1199, 0x0120) }, /* Sierra Wireless AirCard 595U */
  77         { USB_DEVICE(0x1199, 0x0218) }, /* Sierra Wireless MC5720 */
  78         { USB_DEVICE(0x1199, 0x0220) }, /* Sierra Wireless MC5725 */
  79         { USB_DEVICE(0x1199, 0x6802) }, /* Sierra Wireless MC8755 */
  80         { USB_DEVICE(0x1199, 0x6803) }, /* Sierra Wireless MC8765 */
  81         { USB_DEVICE(0x1199, 0x6804) }, /* Sierra Wireless MC8755 */
  82         { USB_DEVICE(0x1199, 0x6812) }, /* Sierra Wireless MC8775 */
  83         { USB_DEVICE(0x1199, 0x6813) }, /* Sierra Wireless MC8755 */
  84         { USB_DEVICE(0x1199, 0x6820) }, /* Sierra Wireless AirCard 875 */
  85         { USB_DEVICE(0x1199, 0x6832) }, /* Sierra Wireless MC8780 */
  86         { USB_DEVICE(0x1199, 0x6833) }, /* Sierra Wireless MC8781 */
  87         { USB_DEVICE(0x1199, 0x6850) }, /* Sierra Wireless AirCard 880 */
  88         { USB_DEVICE(0x1199, 0x6851) }, /* Sierra Wireless AirCard 881 */
  89         { USB_DEVICE(0x1199, 0x6852) }, /* Sierra Wireless AirCard 880E */
  90         { USB_DEVICE(0x1199, 0x6853) }, /* Sierra Wireless AirCard 881E */
  91         { USB_DEVICE(0x12d1, 0x1001) }, /* Huawei Mobile Connect */
  92         { USB_DEVICE(0x1410, 0x1100) }, /* Novatel Wireless ExpressCard 3G */
  93         { USB_DEVICE(0x1410, 0x1110) }, /* Novatel Wireless Merlin V620 */
  94         { USB_DEVICE(0x1410, 0x1130) }, /* Novatel Wireless S720 */
  95         { USB_DEVICE(0x1410, 0x1410) }, /* Novatel Wireless U740 */
  96         { USB_DEVICE(0x1410, 0x1430) }, /* Novatel Wireless XU870 */
  97         { USB_DEVICE(0x1410, 0x2100) }, /* Novatel Wireless ES620 */
  98         { USB_DEVICE(0x1410, 0x2110) }, /* Novatel Wireless U720 */
  99         { USB_DEVICE(0x413c, 0x8115) }, /* Dell W5500 */
 100 };
 101
 102 static device_probe_t ugensa_match;
 103 static device_attach_t ugensa_attach;
 104 static device_detach_t ugensa_detach;
 105
 106 static device_method_t ugensa_methods[] = {
 107         /* Device interface */
 108         DEVMETHOD(device_probe, ugensa_match),
 109         DEVMETHOD(device_attach, ugensa_attach),
 110         DEVMETHOD(device_detach, ugensa_detach),
 111         { 0, 0 }
 112 };
 113
 114 static driver_t ugensa_driver = {
 115         "ucom",
 116         ugensa_methods,
 117         sizeof (struct ugensa_softc)
 118 };
 119
 120 DRIVER_MODULE(ugensa, uhub, ugensa_driver, ucom_devclass, usbd_driver_load, 0);
 121 MODULE_DEPEND(ugensa, usb, 1, 1, 1);
 122 MODULE_DEPEND(ugensa, ucom, UCOM_MINVER, UCOM_PREFVER, UCOM_MAXVER);
 123 MODULE_VERSION(ugensa, 1);
 124
 125 static int
 126 ugensa_match(device_t self)
 127 {
 128         struct usb_attach_arg *uaa = device_get_ivars(self);
 129
 130         if (uaa->iface == NULL)
 131                 return UMATCH_NONE;
 132
 133         return (usb_lookup(ugensa_devs, uaa->vendor, uaa->product) != NULL) ?
 134             UMATCH_VENDOR_IFACESUBCLASS : UMATCH_NONE;
 135 }
 136
 137 static int
 138 ugensa_attach(device_t self)
 139 {
 140         struct ugensa_softc *sc = device_get_softc(self);
 141         struct usb_attach_arg *uaa = device_get_ivars(self);
 142         struct ucom_softc *ucom;
 143         usb_interface_descriptor_t *id;
 144         usb_endpoint_descriptor_t *ed;
 145         int i;
 146
 147         ucom = &sc->sc_ucom;
 148         bzero(sc, sizeof (struct ugensa_softc));
 149
 150         ucom->sc_dev = self;
 151         ucom->sc_udev = uaa->device;
 152         ucom->sc_iface = uaa->iface;
 153
 154         id = usbd_get_interface_descriptor(ucom->sc_iface);
 155
 156         ucom->sc_bulkin_no = ucom->sc_bulkout_no = -1;
 157         for (i = 0; i < id->bNumEndpoints; i++) {
 158                 ed = usbd_interface2endpoint_descriptor(ucom->sc_iface, i);
 159                 if (ed == NULL) {
 160                         device_printf(ucom->sc_dev, "no endpoint descriptor "
 161                                       "found for %d\n", i);
 162                         goto error;
 163                 }
 164
 165                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 166                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
 167                         ucom->sc_bulkin_no = ed->bEndpointAddress;
 168                 else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
 169                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
 170                         ucom->sc_bulkout_no = ed->bEndpointAddress;
 171         }
 172         if (ucom->sc_bulkin_no == -1 || ucom->sc_bulkout_no == -1) {
 173                 device_printf(ucom->sc_dev, "missing endpoint\n");
 174                 goto error;
 175         }
 176
 177         ucom->sc_parent = sc;
 178         ucom->sc_portno = UCOM_UNK_PORTNO;
 179         ucom->sc_ibufsize = UGENSABUFSZ;
 180         ucom->sc_obufsize = UGENSABUFSZ;
 181         ucom->sc_ibufsizepad = UGENSABUFSZ;
 182         ucom->sc_opkthdrlen = 0;
 183         ucom->sc_callback = &ugensa_callback;
 184
 185         usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, ucom->sc_udev,
 186                            ucom->sc_dev);
 187
 188         DPRINTF(("%s: in = 0x%x, out = 0x%x\n",
 189                  device_get_nameunit(ucom->sc_dev), ucom->sc_bulkin_no,
 190                  ucom->sc_bulkout_no));
 191
 192         ucom_attach(&sc->sc_ucom);
 193
 194         return 0;
 195
 196 error:
 197         ucom->sc_dying = 1;
 198         return ENXIO;
 199 }
 200
 201 static int
 202 ugensa_detach(device_t self)
 203 {
 204         struct ugensa_softc *sc = device_get_softc(self);
 205         int rv = 0;
 206
 207         DPRINTF(("ugensa_detach: sc=%p\n", sc));
 208         sc->sc_ucom.sc_dying = 1;
 209         rv = ucom_detach(&sc->sc_ucom);
 210         usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_ucom.sc_udev,
 211                            sc->sc_ucom.sc_dev);
 212
 213         return (rv);
 214 }
 215
 216 #if 0 /* not yet */
 217 int
 218 ugensa_activate(struct device *self, enum devact act)
 219 {
 220         struct ugensa_softc *sc = (struct ugensa_softc *)self;
 221         int rv = 0;
 222
 223         switch (act) {
 224         case DVACT_ACTIVATE:
 225                 break;
 226
 227         case DVACT_DEACTIVATE:
 228                 if (sc->sc_subdev != NULL)
 229                         rv = config_deactivate(sc->sc_subdev);
 230                 sc->sc_dying = 1;
 231                 break;
 232         }
 233         return (rv);
 234 }
 235 #endif