sys/dev/usb/serial/u3g.c

   1 /*
   2  * Copyright (c) 2008 AnyWi Technologies
   3  * Author: Andrea Guzzo <aguzzo@anywi.com>
   4  * * based on uark.c 1.1 2006/08/14 08:30:22 jsg *
   5  * * parts from ubsa.c 183348 2008-09-25 12:00:56Z phk *
   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  * $FreeBSD$
  20  */
  21
  22 /*
  23  * NOTE:
  24  *
  25  * - The detour through the tty layer is ridiculously expensive wrt
  26  *   buffering due to the high speeds.
  27  *
  28  *   We should consider adding a simple r/w device which allows
  29  *   attaching of PPP in a more efficient way.
  30  *
  31  */
  32
  33 #include "usbdevs.h"
  34 #include <dev/usb/usb.h>
  35 #include <dev/usb/usb_mfunc.h>
  36 #include <dev/usb/usb_error.h>
  37
  38 #define USB_DEBUG_VAR u3g_debug
  39
  40 #include <dev/usb/usb_core.h>
  41 #include <dev/usb/usb_debug.h>
  42 #include <dev/usb/usb_process.h>
  43 #include <dev/usb/usb_request.h>
  44 #include <dev/usb/usb_lookup.h>
  45 #include <dev/usb/usb_util.h>
  46 #include <dev/usb/usb_busdma.h>
  47 #include <dev/usb/usb_msctest.h>
  48 #include <dev/usb/usb_dynamic.h>
  49 #include <dev/usb/usb_device.h>
  50
  51 #include <dev/usb/serial/usb_serial.h>
  52
  53 #if USB_DEBUG
  54 static int u3g_debug = 0;
  55
  56 SYSCTL_NODE(_hw_usb, OID_AUTO, u3g, CTLFLAG_RW, 0, "USB 3g");
  57 SYSCTL_INT(_hw_usb_u3g, OID_AUTO, debug, CTLFLAG_RW,
  58     &u3g_debug, 0, "Debug level");
  59 #endif
  60
  61 #define U3G_MAXPORTS            8
  62 #define U3G_CONFIG_INDEX        0
  63 #define U3G_BSIZE               2048
  64
  65 #define U3GSP_GPRS              0
  66 #define U3GSP_EDGE              1
  67 #define U3GSP_CDMA              2
  68 #define U3GSP_UMTS              3
  69 #define U3GSP_HSDPA             4
  70 #define U3GSP_HSUPA             5
  71 #define U3GSP_HSPA              6
  72 #define U3GSP_MAX               7
  73
  74 #define U3GFL_HUAWEI_INIT       0x0001  /* Init command required */
  75 #define U3GFL_SCSI_EJECT        0x0002  /* SCSI eject command required */
  76 #define U3GFL_SIERRA_INIT       0x0004  /* Init command required */
  77 #define U3GFL_SAEL_M460_INIT    0x0008  /* Init device */
  78
  79 enum {
  80         U3G_BULK_WR,
  81         U3G_BULK_RD,
  82         U3G_N_TRANSFER,
  83 };
  84
  85 struct u3g_softc {
  86         struct usb2_com_super_softc sc_super_ucom;
  87         struct usb2_com_softc sc_ucom[U3G_MAXPORTS];
  88
  89         struct usb2_xfer *sc_xfer[U3G_MAXPORTS][U3G_N_TRANSFER];
  90         struct usb2_device *sc_udev;
  91         struct mtx sc_mtx;
  92
  93         uint8_t sc_lsr;                 /* local status register */
  94         uint8_t sc_msr;                 /* U3G status register */
  95         uint8_t sc_numports;
  96 };
  97
  98 static device_probe_t u3g_probe;
  99 static device_attach_t u3g_attach;
 100 static device_detach_t u3g_detach;
 101
 102 static usb2_callback_t u3g_write_callback;
 103 static usb2_callback_t u3g_read_callback;
 104
 105 static void u3g_start_read(struct usb2_com_softc *ucom);
 106 static void u3g_stop_read(struct usb2_com_softc *ucom);
 107 static void u3g_start_write(struct usb2_com_softc *ucom);
 108 static void u3g_stop_write(struct usb2_com_softc *ucom);
 109
 110 static int u3g_driver_loaded(struct module *mod, int what, void *arg);
 111
 112 static const struct usb2_config u3g_config[U3G_N_TRANSFER] = {
 113
 114         [U3G_BULK_WR] = {
 115                 .type = UE_BULK,
 116                 .endpoint = UE_ADDR_ANY,
 117                 .direction = UE_DIR_OUT,
 118                 .bufsize = U3G_BSIZE,/* bytes */
 119                 .flags = {.pipe_bof = 1,.force_short_xfer = 1,},
 120                 .callback = &u3g_write_callback,
 121         },
 122
 123         [U3G_BULK_RD] = {
 124                 .type = UE_BULK,
 125                 .endpoint = UE_ADDR_ANY,
 126                 .direction = UE_DIR_IN,
 127                 .bufsize = U3G_BSIZE,/* bytes */
 128                 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
 129                 .callback = &u3g_read_callback,
 130         },
 131 };
 132
 133 static const struct usb2_com_callback u3g_callback = {
 134         .usb2_com_start_read = &u3g_start_read,
 135         .usb2_com_stop_read = &u3g_stop_read,
 136         .usb2_com_start_write = &u3g_start_write,
 137         .usb2_com_stop_write = &u3g_stop_write,
 138 };
 139
 140 static device_method_t u3g_methods[] = {
 141         DEVMETHOD(device_probe, u3g_probe),
 142         DEVMETHOD(device_attach, u3g_attach),
 143         DEVMETHOD(device_detach, u3g_detach),
 144         {0, 0}
 145 };
 146
 147 static devclass_t u3g_devclass;
 148
 149 static driver_t u3g_driver = {
 150         .name = "u3g",
 151         .methods = u3g_methods,
 152         .size = sizeof(struct u3g_softc),
 153 };
 154
 155 DRIVER_MODULE(u3g, uhub, u3g_driver, u3g_devclass, u3g_driver_loaded, 0);
 156 MODULE_DEPEND(u3g, ucom, 1, 1, 1);
 157 MODULE_DEPEND(u3g, usb, 1, 1, 1);
 158
 159 static const struct usb2_device_id u3g_devs[] = {
 160 #define U3G_DEV(v,p,i) { USB_VPI(USB_VENDOR_##v, USB_PRODUCT_##v##_##p, i) }
 161         /* OEM: Option */
 162         U3G_DEV(OPTION, GT3G, 0),
 163         U3G_DEV(OPTION, GT3GQUAD, 0),
 164         U3G_DEV(OPTION, GT3GPLUS, 0),
 165         U3G_DEV(OPTION, GTMAX36, 0),
 166         U3G_DEV(OPTION, GTMAXHSUPA, 0),
 167         U3G_DEV(OPTION, VODAFONEMC3G, 0),
 168         /* OEM: Qualcomm, Inc. */
 169         U3G_DEV(QUALCOMMINC, ZTE_STOR, U3GFL_SCSI_EJECT),
 170         U3G_DEV(QUALCOMMINC, CDMA_MSM, U3GFL_SCSI_EJECT),
 171         /* OEM: Huawei */
 172         U3G_DEV(HUAWEI, MOBILE, U3GFL_HUAWEI_INIT),
 173         U3G_DEV(HUAWEI, E220, U3GFL_HUAWEI_INIT),
 174         /* OEM: Novatel */
 175         U3G_DEV(NOVATEL, CDMA_MODEM, 0),
 176         U3G_DEV(NOVATEL, ES620, 0),
 177         U3G_DEV(NOVATEL, MC950D, 0),
 178         U3G_DEV(NOVATEL, U720, 0),
 179         U3G_DEV(NOVATEL, U727, 0),
 180         U3G_DEV(NOVATEL, U740, 0),
 181         U3G_DEV(NOVATEL, U740_2, 0),
 182         U3G_DEV(NOVATEL, U870, 0),
 183         U3G_DEV(NOVATEL, V620, 0),
 184         U3G_DEV(NOVATEL, V640, 0),
 185         U3G_DEV(NOVATEL, V720, 0),
 186         U3G_DEV(NOVATEL, V740, 0),
 187         U3G_DEV(NOVATEL, X950D, 0),
 188         U3G_DEV(NOVATEL, XU870, 0),
 189         U3G_DEV(NOVATEL, ZEROCD, U3GFL_SCSI_EJECT),
 190         U3G_DEV(DELL, U740, 0),
 191         /* OEM: Merlin */
 192         U3G_DEV(MERLIN, V620, 0),
 193         /* OEM: Sierra Wireless: */
 194         U3G_DEV(SIERRA, AIRCARD580, 0),
 195         U3G_DEV(SIERRA, AIRCARD595, 0),
 196         U3G_DEV(SIERRA, AC595U, 0),
 197         U3G_DEV(SIERRA, AC597E, 0),
 198         U3G_DEV(SIERRA, C597, 0),
 199         U3G_DEV(SIERRA, AC880, 0),
 200         U3G_DEV(SIERRA, AC880E, 0),
 201         U3G_DEV(SIERRA, AC880U, 0),
 202         U3G_DEV(SIERRA, AC881, 0),
 203         U3G_DEV(SIERRA, AC881E, 0),
 204         U3G_DEV(SIERRA, AC881U, 0),
 205         U3G_DEV(SIERRA, AC885U, 0),
 206         U3G_DEV(SIERRA, EM5625, 0),
 207         U3G_DEV(SIERRA, MC5720, 0),
 208         U3G_DEV(SIERRA, MC5720_2, 0),
 209         U3G_DEV(SIERRA, MC5725, 0),
 210         U3G_DEV(SIERRA, MINI5725, 0),
 211         U3G_DEV(SIERRA, AIRCARD875, 0),
 212         U3G_DEV(SIERRA, MC8755, 0),
 213         U3G_DEV(SIERRA, MC8755_2, 0),
 214         U3G_DEV(SIERRA, MC8755_3, 0),
 215         U3G_DEV(SIERRA, MC8765, 0),
 216         U3G_DEV(SIERRA, AC875U, 0),
 217         U3G_DEV(SIERRA, MC8775_2, 0),
 218         U3G_DEV(SIERRA, MC8780, 0),
 219         U3G_DEV(SIERRA, MC8781, 0),
 220         U3G_DEV(HP, HS2300, 0),
 221         /* Sierra TruInstaller device ID */
 222         U3G_DEV(SIERRA, TRUINSTALL, U3GFL_SIERRA_INIT),
 223         /* PRUEBA SILABS */
 224         U3G_DEV(SILABS, SAEL, U3GFL_SAEL_M460_INIT),
 225 };
 226
 227 static void
 228 u3g_sierra_init(struct usb2_device *udev)
 229 {
 230         struct usb2_device_request req;
 231
 232         DPRINTFN(0, "\n");
 233
 234         req.bmRequestType = UT_VENDOR;
 235         req.bRequest = UR_SET_INTERFACE;
 236         USETW(req.wValue, UF_DEVICE_REMOTE_WAKEUP);
 237         USETW(req.wIndex, UHF_PORT_CONNECTION);
 238         USETW(req.wLength, 0);
 239
 240         if (usb2_do_request_flags(udev, NULL, &req,
 241             NULL, 0, NULL, USB_MS_HZ)) {
 242                 /* ignore any errors */
 243         }
 244         return;
 245 }
 246
 247 static void
 248 u3g_huawei_init(struct usb2_device *udev)
 249 {
 250         struct usb2_device_request req;
 251
 252         DPRINTFN(0, "\n");
 253
 254         req.bmRequestType = UT_WRITE_DEVICE;
 255         req.bRequest = UR_SET_FEATURE;
 256         USETW(req.wValue, UF_DEVICE_REMOTE_WAKEUP);
 257         USETW(req.wIndex, UHF_PORT_SUSPEND);
 258         USETW(req.wLength, 0);
 259
 260         if (usb2_do_request_flags(udev, NULL, &req,
 261             NULL, 0, NULL, USB_MS_HZ)) {
 262                 /* ignore any errors */
 263         }
 264         return;
 265 }
 266
 267 static void
 268 u3g_sael_m460_init(struct usb2_device *udev)
 269 {
 270         static const uint8_t setup[][24] = {
 271              { 0x41, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 272              { 0x41, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 },
 273              { 0x41, 0x13, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
 274                0x01, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
 275                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 276              { 0xc1, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x40, 0x02 },
 277              { 0xc1, 0x08, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00 },
 278              { 0x41, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 },
 279              { 0xc1, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 },
 280              { 0x41, 0x01, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00 },
 281              { 0x41, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 },
 282              { 0x41, 0x03, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 },
 283              { 0x41, 0x19, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00,
 284                0x00, 0x00, 0x00, 0x00, 0x11, 0x13 },
 285              { 0x41, 0x13, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
 286                0x09, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
 287                0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00 },
 288              { 0x41, 0x12, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00 },
 289              { 0x41, 0x01, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00 },
 290              { 0x41, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 },
 291              { 0x41, 0x03, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 },
 292              { 0x41, 0x19, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00,
 293                0x00, 0x00, 0x00, 0x00, 0x11, 0x13 },
 294              { 0x41, 0x13, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
 295                0x09, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
 296                0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00 },
 297              { 0x41, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 },
 298         };
 299
 300         struct usb2_device_request req;
 301         usb2_error_t err;
 302         uint16_t len;
 303         uint8_t buf[0x300];
 304         uint8_t n;
 305
 306         DPRINTFN(1, "\n");
 307
 308         if (usb2_req_set_alt_interface_no(udev, NULL, 0, 0)) {
 309                 DPRINTFN(0, "Alt setting 0 failed\n");
 310                 return;
 311         }
 312
 313         for (n = 0; n != (sizeof(setup)/sizeof(setup[0])); n++) {
 314
 315                 memcpy(&req, setup[n], sizeof(req));
 316
 317                 len = UGETW(req.wLength);
 318                 if (req.bmRequestType & UE_DIR_IN) {
 319                         if (len > sizeof(buf)) {
 320                                 DPRINTFN(0, "too small buffer\n");
 321                                 continue;
 322                         }
 323                         err = usb2_do_request(udev, NULL, &req, buf);
 324                 } else {
 325                         if (len > (sizeof(setup[0]) - 8)) {
 326                                 DPRINTFN(0, "too small buffer\n");
 327                                 continue;
 328                         }
 329                         err = usb2_do_request(udev, NULL, &req,
 330                             __DECONST(uint8_t *, &setup[n][8]));
 331                 }
 332                 if (err) {
 333                         DPRINTFN(1, "request %u failed\n",
 334                             (unsigned int)n);
 335                         /*
 336                          * Some of the requests will fail. Stop doing
 337                          * requests when we are getting timeouts so
 338                          * that we don't block the explore/attach
 339                          * thread forever.
 340                          */
 341                         if (err == USB_ERR_TIMEOUT)
 342                                 break;
 343                 }
 344         }
 345 }
 346
 347 static int
 348 u3g_lookup_huawei(struct usb2_attach_arg *uaa)
 349 {
 350         /* Calling the lookup function will also set the driver info! */
 351         return (usb2_lookup_id_by_uaa(u3g_devs, sizeof(u3g_devs), uaa));
 352 }
 353
 354 /*
 355  * The following function handles 3G modem devices (E220, Mobile,
 356  * etc.) with auto-install flash disks for Windows/MacOSX on the first
 357  * interface.  After some command or some delay they change appearance
 358  * to a modem.
 359  */
 360 static usb2_error_t
 361 u3g_test_huawei_autoinst(struct usb2_device *udev,
 362     struct usb2_attach_arg *uaa)
 363 {
 364         struct usb2_interface *iface;
 365         struct usb2_interface_descriptor *id;
 366         uint32_t flags;
 367
 368         if (udev == NULL) {
 369                 return (USB_ERR_INVAL);
 370         }
 371         iface = usb2_get_iface(udev, 0);
 372         if (iface == NULL) {
 373                 return (USB_ERR_INVAL);
 374         }
 375         id = iface->idesc;
 376         if (id == NULL) {
 377                 return (USB_ERR_INVAL);
 378         }
 379         if (id->bInterfaceClass != UICLASS_MASS) {
 380                 return (USB_ERR_INVAL);
 381         }
 382         if (u3g_lookup_huawei(uaa)) {
 383                 /* no device match */
 384                 return (USB_ERR_INVAL);
 385         }
 386         flags = USB_GET_DRIVER_INFO(uaa);
 387
 388         if (flags & U3GFL_HUAWEI_INIT) {
 389                 u3g_huawei_init(udev);
 390         } else if (flags & U3GFL_SCSI_EJECT) {
 391                 return (usb2_test_autoinstall(udev, 0, 1));
 392         } else if (flags & U3GFL_SIERRA_INIT) {
 393                 u3g_sierra_init(udev);
 394         } else {
 395                 /* no quirks */
 396                 return (USB_ERR_INVAL);
 397         }
 398         return (0);                     /* success */
 399 }
 400
 401 static int
 402 u3g_driver_loaded(struct module *mod, int what, void *arg)
 403 {
 404         switch (what) {
 405         case MOD_LOAD:
 406                 /* register our autoinstall handler */
 407                 usb2_test_huawei_autoinst_p = &u3g_test_huawei_autoinst;
 408                 break;
 409         case MOD_UNLOAD:
 410                 usb2_test_huawei_unload(NULL);
 411                 break;
 412         default:
 413                 return (EOPNOTSUPP);
 414         }
 415         return (0);
 416 }
 417
 418 static int
 419 u3g_probe(device_t self)
 420 {
 421         struct usb2_attach_arg *uaa = device_get_ivars(self);
 422
 423         if (uaa->usb_mode != USB_MODE_HOST) {
 424                 return (ENXIO);
 425         }
 426         if (uaa->info.bConfigIndex != U3G_CONFIG_INDEX) {
 427                 return (ENXIO);
 428         }
 429         if (uaa->info.bInterfaceClass != UICLASS_VENDOR) {
 430                 return (ENXIO);
 431         }
 432         return (u3g_lookup_huawei(uaa));
 433 }
 434
 435 static int
 436 u3g_attach(device_t dev)
 437 {
 438         struct usb2_config u3g_config_tmp[U3G_N_TRANSFER];
 439         struct usb2_attach_arg *uaa = device_get_ivars(dev);
 440         struct u3g_softc *sc = device_get_softc(dev);
 441         struct usb2_interface *iface;
 442         struct usb2_interface_descriptor *id;
 443         uint32_t iface_valid;
 444         int error, flags, nports;
 445         int ep, n;
 446         uint8_t i;
 447
 448         DPRINTF("sc=%p\n", sc);
 449
 450         flags = USB_GET_DRIVER_INFO(uaa);
 451
 452         if (flags & U3GFL_SAEL_M460_INIT)
 453                 u3g_sael_m460_init(uaa->device);
 454
 455         /* copy in USB config */
 456         for (n = 0; n != U3G_N_TRANSFER; n++)
 457                 u3g_config_tmp[n] = u3g_config[n];
 458
 459         device_set_usb2_desc(dev);
 460         mtx_init(&sc->sc_mtx, "u3g", NULL, MTX_DEF);
 461
 462         sc->sc_udev = uaa->device;
 463
 464         /* Claim all interfaces on the device */
 465         iface_valid = 0;
 466         for (i = uaa->info.bIfaceIndex; i < USB_IFACE_MAX; i++) {
 467                 iface = usb2_get_iface(uaa->device, i);
 468                 if (iface == NULL)
 469                         break;
 470                 id = usb2_get_interface_descriptor(iface);
 471                 if (id == NULL || id->bInterfaceClass != UICLASS_VENDOR)
 472                         continue;
 473                 usb2_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex);
 474                 iface_valid |= (1<<i);
 475         }
 476
 477         i = 0;          /* interface index */
 478         ep = 0;         /* endpoint index */
 479         nports = 0;     /* number of ports */
 480         while (i < USB_IFACE_MAX) {
 481                 if ((iface_valid & (1<<i)) == 0) {
 482                         i++;
 483                         continue;
 484                 }
 485
 486                 /* update BULK endpoint index */
 487                 for (n = 0; n < U3G_N_TRANSFER; n++)
 488                         u3g_config_tmp[n].ep_index = ep;
 489
 490                 /* try to allocate a set of BULK endpoints */
 491                 error = usb2_transfer_setup(uaa->device, &i,
 492                     sc->sc_xfer[nports], u3g_config_tmp, U3G_N_TRANSFER,
 493                     &sc->sc_ucom[nports], &sc->sc_mtx);
 494                 if (error) {
 495                         /* next interface */
 496                         i++;
 497                         ep = 0;
 498                         continue;
 499                 }
 500
 501                 /* set stall by default */
 502                 mtx_lock(&sc->sc_mtx);
 503                 usb2_transfer_set_stall(sc->sc_xfer[nports][U3G_BULK_WR]);
 504                 usb2_transfer_set_stall(sc->sc_xfer[nports][U3G_BULK_RD]);
 505                 mtx_unlock(&sc->sc_mtx);
 506
 507                 nports++;       /* found one port */
 508                 ep++;
 509                 if (nports == U3G_MAXPORTS)
 510                         break;
 511         }
 512         if (nports == 0) {
 513                 device_printf(dev, "no ports found\n");
 514                 goto detach;
 515         }
 516         sc->sc_numports = nports;
 517
 518         error = usb2_com_attach(&sc->sc_super_ucom, sc->sc_ucom,
 519             sc->sc_numports, sc, &u3g_callback, &sc->sc_mtx);
 520         if (error) {
 521                 DPRINTF("usb2_com_attach failed\n");
 522                 goto detach;
 523         }
 524         if (sc->sc_numports > 1)
 525                 device_printf(dev, "Found %u ports.\n", sc->sc_numports);
 526         return (0);
 527
 528 detach:
 529         u3g_detach(dev);
 530         return (ENXIO);
 531 }
 532
 533 static int
 534 u3g_detach(device_t dev)
 535 {
 536         struct u3g_softc *sc = device_get_softc(dev);
 537         uint8_t m;
 538
 539         DPRINTF("sc=%p\n", sc);
 540
 541         /* NOTE: It is not dangerous to detach more ports than attached! */
 542         usb2_com_detach(&sc->sc_super_ucom, sc->sc_ucom, U3G_MAXPORTS);
 543
 544         for (m = 0; m != U3G_MAXPORTS; m++)
 545                 usb2_transfer_unsetup(sc->sc_xfer[m], U3G_N_TRANSFER);
 546         mtx_destroy(&sc->sc_mtx);
 547
 548         return (0);
 549 }
 550
 551 static void
 552 u3g_start_read(struct usb2_com_softc *ucom)
 553 {
 554         struct u3g_softc *sc = ucom->sc_parent;
 555
 556         /* start read endpoint */
 557         usb2_transfer_start(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_RD]);
 558         return;
 559 }
 560
 561 static void
 562 u3g_stop_read(struct usb2_com_softc *ucom)
 563 {
 564         struct u3g_softc *sc = ucom->sc_parent;
 565
 566         /* stop read endpoint */
 567         usb2_transfer_stop(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_RD]);
 568         return;
 569 }
 570
 571 static void
 572 u3g_start_write(struct usb2_com_softc *ucom)
 573 {
 574         struct u3g_softc *sc = ucom->sc_parent;
 575
 576         usb2_transfer_start(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_WR]);
 577         return;
 578 }
 579
 580 static void
 581 u3g_stop_write(struct usb2_com_softc *ucom)
 582 {
 583         struct u3g_softc *sc = ucom->sc_parent;
 584
 585         usb2_transfer_stop(sc->sc_xfer[ucom->sc_local_unit][U3G_BULK_WR]);
 586         return;
 587 }
 588
 589 static void
 590 u3g_write_callback(struct usb2_xfer *xfer)
 591 {
 592         struct usb2_com_softc *ucom = xfer->priv_sc;
 593         uint32_t actlen;
 594
 595         switch (USB_GET_STATE(xfer)) {
 596         case USB_ST_TRANSFERRED:
 597         case USB_ST_SETUP:
 598 tr_setup:
 599                 if (usb2_com_get_data(ucom, xfer->frbuffers, 0,
 600                     U3G_BSIZE, &actlen)) {
 601                         xfer->frlengths[0] = actlen;
 602                         usb2_start_hardware(xfer);
 603                 }
 604                 break;
 605
 606         default:                        /* Error */
 607                 if (xfer->error != USB_ERR_CANCELLED) {
 608                         /* do a builtin clear-stall */
 609                         xfer->flags.stall_pipe = 1;
 610                         goto tr_setup;
 611                 }
 612                 break;
 613         }
 614         return;
 615 }
 616
 617 static void
 618 u3g_read_callback(struct usb2_xfer *xfer)
 619 {
 620         struct usb2_com_softc *ucom = xfer->priv_sc;
 621
 622         switch (USB_GET_STATE(xfer)) {
 623         case USB_ST_TRANSFERRED:
 624                 usb2_com_put_data(ucom, xfer->frbuffers, 0, xfer->actlen);
 625
 626         case USB_ST_SETUP:
 627 tr_setup:
 628                 xfer->frlengths[0] = xfer->max_data_length;
 629                 usb2_start_hardware(xfer);
 630                 break;
 631
 632         default:                        /* Error */
 633                 if (xfer->error != USB_ERR_CANCELLED) {
 634                         /* do a builtin clear-stall */
 635                         xfer->flags.stall_pipe = 1;
 636                         goto tr_setup;
 637                 }
 638                 break;
 639         }
 640         return;
 641 }