sys/dev/usb/ugensa.c

   1 /*      $NetBSD: ugensa.c,v 1.24 2009/11/12 19:51:44 dyoung Exp $       */
   2
   3 /*
   4  * Copyright (c) 2004, 2005 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Roland C. Dowdeswell <elric@netbsd.org>.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __KERNEL_RCSID(0, "$NetBSD: ugensa.c,v 1.24 2009/11/12 19:51:44 dyoung Exp $");
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/kernel.h>
  38 #include <sys/device.h>
  39 #include <sys/conf.h>
  40 #include <sys/tty.h>
  41
  42 #include <dev/usb/usb.h>
  43
  44 #include <dev/usb/usbdi.h>
  45 #include <dev/usb/usbdi_util.h>
  46 #include <dev/usb/usbdevs.h>
  47
  48 #include <dev/usb/ucomvar.h>
  49
  50 /* XXXrcd: heh */
  51 #define UGENSA_DEBUG 1
  52
  53 #ifdef UGENSA_DEBUG
  54 #define DPRINTF(x)      if (ugensadebug) printf x
  55 #define DPRINTFN(n,x)   if (ugensadebug>(n)) printf x
  56 int ugensadebug = 0;
  57 #else
  58 #define DPRINTF(x)
  59 #define DPRINTFN(n,x)
  60 #endif
  61
  62 struct ugensa_softc {
  63         USBBASEDEVICE           sc_dev;         /* base device */
  64         usbd_device_handle      sc_udev;        /* device */
  65         usbd_interface_handle   sc_iface;       /* interface */
  66
  67         device_t                sc_subdev;
  68         int                     sc_numcon;
  69
  70         u_char                  sc_dying;
  71 };
  72
  73 struct ucom_methods ugensa_methods = {
  74         NULL,
  75         NULL,
  76         NULL,
  77         NULL,
  78         NULL,
  79         NULL,
  80         NULL,
  81         NULL,
  82 };
  83
  84 #define UGENSA_CONFIG_INDEX     0
  85 #define UGENSA_IFACE_INDEX      0
  86 #define UGENSA_BUFSIZE          1024
  87
  88 struct ugensa_type {
  89         struct usb_devno        ugensa_dev;
  90         u_int16_t               ugensa_flags;
  91 #define UNTESTED                0x0001
  92 };
  93
  94 static const struct ugensa_type ugensa_devs[] = {
  95         {{ USB_VENDOR_AIRPRIME, USB_PRODUCT_AIRPRIME_PC5220 }, 0 },
  96         {{ USB_VENDOR_NOVATEL, USB_PRODUCT_NOVATEL_FLEXPACKGPS }, 0 },
  97         {{ USB_VENDOR_QUALCOMM_K, USB_PRODUCT_QUALCOMM_K_CDMA_MSM_K }, 0 },
  98         {{ USB_VENDOR_DELL, USB_PRODUCT_DELL_HSDPA }, 0 },
  99         {{ USB_VENDOR_QUALCOMMINC, USB_PRODUCT_QUALCOMMINC_AC8700 }, 0 },
 100
 101         /*
 102          * The following devices are untested, but they are purported to
 103          * to work in similar device drivers on other OSes:
 104          */
 105
 106         {{ USB_VENDOR_ANYDATA, USB_PRODUCT_ANYDATA_ADU_500A }, UNTESTED },
 107         {{ USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_EXPRESSCARD }, UNTESTED },
 108         {{ USB_VENDOR_QUALCOMM, USB_PRODUCT_QUALCOMM_MSM_HSDPA }, UNTESTED },
 109         {{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_EM5625 }, UNTESTED },
 110         {{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AIRCARD875 }, UNTESTED },
 111 };
 112 #define ugensa_lookup(v, p) \
 113         ((const struct ugensa_type *)usb_lookup(ugensa_devs, v, p))
 114
 115 int ugensa_match(device_t, cfdata_t, void *);
 116 void ugensa_attach(device_t, device_t, void *);
 117 void ugensa_childdet(device_t, device_t);
 118 int ugensa_detach(device_t, int);
 119 int ugensa_activate(device_t, enum devact);
 120 extern struct cfdriver ugensa_cd;
 121 CFATTACH_DECL2_NEW(ugensa, sizeof(struct ugensa_softc), ugensa_match,
 122     ugensa_attach, ugensa_detach, ugensa_activate, NULL, ugensa_childdet);
 123
 124 USB_MATCH(ugensa)
 125 {
 126         USB_MATCH_START(ugensa, uaa);
 127
 128         DPRINTFN(20,("ugensa: vendor=0x%x, product=0x%x\n",
 129                      uaa->vendor, uaa->product));
 130
 131         return (ugensa_lookup(uaa->vendor, uaa->product) != NULL ?
 132                 UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
 133 }
 134
 135 USB_ATTACH(ugensa)
 136 {
 137         USB_ATTACH_START(ugensa, sc, uaa);
 138         usbd_device_handle dev = uaa->device;
 139         usbd_interface_handle iface;
 140         usb_interface_descriptor_t *id;
 141         usb_endpoint_descriptor_t *ed;
 142         char *devinfop;
 143         const char *devname = device_xname(self);
 144         usbd_status err;
 145         struct ucom_attach_args uca;
 146         int i;
 147
 148         DPRINTFN(10,("\nugensa_attach: sc=%p\n", sc));
 149
 150         sc->sc_dev = self;
 151
 152         aprint_naive("\n");
 153         aprint_normal("\n");
 154
 155         devinfop = usbd_devinfo_alloc(dev, 0);
 156         aprint_normal_dev(self, "%s\n", devinfop);
 157         usbd_devinfo_free(devinfop);
 158
 159         /* Move the device into the configured state. */
 160         err = usbd_set_config_index(dev, UGENSA_CONFIG_INDEX, 1);
 161         if (err) {
 162                 aprint_error("\n%s: failed to set configuration, err=%s\n",
 163                        devname, usbd_errstr(err));
 164                 goto bad;
 165         }
 166
 167         err = usbd_device2interface_handle(dev, UGENSA_IFACE_INDEX, &iface);
 168         if (err) {
 169                 aprint_error("\n%s: failed to get interface, err=%s\n",
 170                        devname, usbd_errstr(err));
 171                 goto bad;
 172         }
 173
 174         if (ugensa_lookup(uaa->vendor, uaa->product)->ugensa_flags & UNTESTED)
 175                 aprint_normal_dev(self, "WARNING: This device is marked as "
 176                     "untested. Please submit a report via send-pr(1).\n");
 177
 178         id = usbd_get_interface_descriptor(iface);
 179
 180         sc->sc_udev = dev;
 181         sc->sc_iface = iface;
 182
 183         uca.info = "Generic Serial Device";
 184         uca.ibufsize = UGENSA_BUFSIZE;
 185         uca.obufsize = UGENSA_BUFSIZE;
 186         uca.ibufsizepad = UGENSA_BUFSIZE;
 187         uca.portno = UCOM_UNK_PORTNO;
 188         uca.opkthdrlen = 0;
 189         uca.device = dev;
 190         uca.iface = iface;
 191         uca.methods = &ugensa_methods;
 192         uca.arg = sc;
 193
 194         usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
 195                            USBDEV(sc->sc_dev));
 196
 197         uca.bulkin = uca.bulkout = -1;
 198         for (i = 0; i < id->bNumEndpoints; i++) {
 199                 int addr, dir, attr;
 200
 201                 ed = usbd_interface2endpoint_descriptor(iface, i);
 202                 if (ed == NULL) {
 203                         aprint_error_dev(self,
 204                             "could not read endpoint descriptor: %s\n",
 205                             usbd_errstr(err));
 206                         goto bad;
 207                 }
 208
 209                 addr = ed->bEndpointAddress;
 210                 dir = UE_GET_DIR(ed->bEndpointAddress);
 211                 attr = ed->bmAttributes & UE_XFERTYPE;
 212                 if (attr == UE_BULK) {
 213                         if (uca.bulkin == -1 && dir == UE_DIR_IN) {
 214                                 DPRINTF(("%s: Bulk in %d\n", devname, i));
 215                                 uca.bulkin = addr;
 216                                 continue;
 217                         }
 218                         if (uca.bulkout == -1 && dir == UE_DIR_OUT) {
 219                                 DPRINTF(("%s: Bulk out %d\n", devname, i));
 220                                 uca.bulkout = addr;
 221                                 continue;
 222                         }
 223                 }
 224                 aprint_error_dev(self, "unexpected endpoint\n");
 225         }
 226         if (uca.bulkin == -1) {
 227                 aprint_error_dev(self, "Could not find data bulk in\n");
 228                 goto bad;
 229         }
 230         if (uca.bulkout == -1) {
 231                 aprint_error_dev(self, "Could not find data bulk out\n");
 232                 goto bad;
 233         }
 234
 235         DPRINTF(("ugensa: in=0x%x out=0x%x\n", uca.bulkin, uca.bulkout));
 236         sc->sc_subdev = config_found_sm_loc(self, "ucombus", NULL, &uca,
 237                                             ucomprint, ucomsubmatch);
 238
 239         if (!pmf_device_register(self, NULL, NULL))
 240                 aprint_error_dev(self, "couldn't establish power handler\n");
 241         USB_ATTACH_SUCCESS_RETURN;
 242
 243 bad:
 244         DPRINTF(("ugensa_attach: ATTACH ERROR\n"));
 245         sc->sc_dying = 1;
 246         USB_ATTACH_ERROR_RETURN;
 247 }
 248
 249 void
 250 ugensa_childdet(device_t self, device_t child)
 251 {
 252         struct ugensa_softc *sc = device_private(self);
 253
 254         KASSERT(sc->sc_subdev == child);
 255         sc->sc_subdev = NULL;
 256 }
 257
 258 int
 259 ugensa_activate(device_t self, enum devact act)
 260 {
 261         struct ugensa_softc *sc = device_private(self);
 262
 263         DPRINTF(("ugensa_activate: sc=%p\n", sc));
 264
 265         switch (act) {
 266         case DVACT_DEACTIVATE:
 267                 sc->sc_dying = 1;
 268                 return 0;
 269         default:
 270                 return EOPNOTSUPP;
 271         }
 272 }
 273
 274 USB_DETACH(ugensa)
 275 {
 276         USB_DETACH_START(ugensa, sc);
 277         int rv = 0;
 278
 279         DPRINTF(("ugensa_detach: sc=%p flags=%d\n", sc, flags));
 280
 281         sc->sc_dying = 1;
 282         pmf_device_deregister(self);
 283
 284         if (sc->sc_subdev != NULL)
 285                 rv = config_detach(sc->sc_subdev, flags);
 286
 287         usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
 288                            USBDEV(sc->sc_dev));
 289
 290         return (rv);
 291 }