u3g.c revision 186730
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: head/sys/dev/usb2/serial/u3g2.c 186730 2009-01-04 00:12:01Z alfred $ 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 * NOTE: 32 * 33 * - The device ID's are stored in "core/usb2_msctest.c" 34 */ 35 36#include <dev/usb2/include/usb2_devid.h> 37#include <dev/usb2/include/usb2_standard.h> 38#include <dev/usb2/include/usb2_mfunc.h> 39#include <dev/usb2/include/usb2_error.h> 40#include <dev/usb2/include/usb2_defs.h> 41 42#define USB_DEBUG_VAR u3g_debug 43 44#include <dev/usb2/core/usb2_core.h> 45#include <dev/usb2/core/usb2_debug.h> 46#include <dev/usb2/core/usb2_process.h> 47#include <dev/usb2/core/usb2_config_td.h> 48#include <dev/usb2/core/usb2_request.h> 49#include <dev/usb2/core/usb2_lookup.h> 50#include <dev/usb2/core/usb2_util.h> 51#include <dev/usb2/core/usb2_busdma.h> 52#include <dev/usb2/core/usb2_msctest.h> 53#include <dev/usb2/core/usb2_dynamic.h> 54#include <dev/usb2/core/usb2_device.h> 55 56#include <dev/usb2/serial/usb2_serial.h> 57 58#if USB_DEBUG 59static int u3g_debug = 0; 60 61SYSCTL_NODE(_hw_usb2, OID_AUTO, u3g, CTLFLAG_RW, 0, "USB u3g"); 62SYSCTL_INT(_hw_usb2_u3g, OID_AUTO, debug, CTLFLAG_RW, 63 &u3g_debug, 0, "u3g debug level"); 64#endif 65 66#define U3G_N_TRANSFER 2 67#define U3G_MAXPORTS 4 68#define U3G_CONFIG_INDEX 0 69#define U3G_BSIZE 2048 70 71#define U3GSP_GPRS 0 72#define U3GSP_EDGE 1 73#define U3GSP_CDMA 2 74#define U3GSP_UMTS 3 75#define U3GSP_HSDPA 4 76#define U3GSP_HSUPA 5 77#define U3GSP_HSPA 6 78#define U3GSP_MAX 7 79 80#define U3GFL_NONE 0x00 /* No flags */ 81#define U3GFL_HUAWEI_INIT 0x01 /* Init command required */ 82#define U3GFL_SCSI_EJECT 0x02 /* SCSI eject command required */ 83#define U3GFL_SIERRA_INIT 0x04 /* Init command required */ 84 85struct u3g_speeds_s { 86 uint32_t ispeed; 87 uint32_t ospeed; 88}; 89 90struct u3g_softc { 91 struct usb2_com_super_softc sc_super_ucom; 92 struct usb2_com_softc sc_ucom; 93 94 struct usb2_xfer *sc_xfer[U3G_N_TRANSFER]; 95 struct usb2_device *sc_udev; 96 97 uint8_t sc_iface_no; /* interface number */ 98 uint8_t sc_iface_index; /* interface index */ 99 uint8_t sc_lsr; /* local status register */ 100 uint8_t sc_msr; /* U3G status register */ 101 struct u3g_speeds_s sc_speed; 102 uint8_t sc_numports; 103}; 104 105static device_probe_t u3g_probe; 106static device_attach_t u3g_attach; 107static device_detach_t u3g_detach; 108 109static usb2_callback_t u3g_write_callback; 110static usb2_callback_t u3g_read_callback; 111 112static void u3g_start_read(struct usb2_com_softc *ucom); 113static void u3g_stop_read(struct usb2_com_softc *ucom); 114static void u3g_start_write(struct usb2_com_softc *ucom); 115static void u3g_stop_write(struct usb2_com_softc *ucom); 116 117static int u3g_driver_loaded(struct module *mod, int what, void *arg); 118 119static const struct usb2_config u3g_config[U3G_N_TRANSFER] = { 120 121 [0] = { 122 .type = UE_BULK, 123 .endpoint = UE_ADDR_ANY, 124 .direction = UE_DIR_OUT, 125 .mh.bufsize = U3G_BSIZE,/* bytes */ 126 .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, 127 .mh.callback = &u3g_write_callback, 128 }, 129 130 [1] = { 131 .type = UE_BULK, 132 .endpoint = UE_ADDR_ANY, 133 .direction = UE_DIR_IN, 134 .mh.bufsize = U3G_BSIZE,/* bytes */ 135 .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 136 .mh.callback = &u3g_read_callback, 137 }, 138}; 139 140static const struct usb2_com_callback u3g_callback = { 141 .usb2_com_start_read = &u3g_start_read, 142 .usb2_com_stop_read = &u3g_stop_read, 143 .usb2_com_start_write = &u3g_start_write, 144 .usb2_com_stop_write = &u3g_stop_write, 145}; 146 147static const struct u3g_speeds_s u3g_speeds[U3GSP_MAX] = { 148 [U3GSP_GPRS] = {64000, 64000}, 149 [U3GSP_EDGE] = {384000, 64000}, 150 [U3GSP_CDMA] = {384000, 64000}, 151 [U3GSP_UMTS] = {384000, 64000}, 152 [U3GSP_HSDPA] = {1200000, 384000}, 153 [U3GSP_HSUPA] = {1200000, 384000}, 154 [U3GSP_HSPA] = {7200000, 384000}, 155}; 156 157static device_method_t u3g_methods[] = { 158 DEVMETHOD(device_probe, u3g_probe), 159 DEVMETHOD(device_attach, u3g_attach), 160 DEVMETHOD(device_detach, u3g_detach), 161 {0, 0} 162}; 163 164static devclass_t u3g_devclass; 165 166static driver_t u3g_driver = { 167 .name = "u3g", 168 .methods = u3g_methods, 169 .size = sizeof(struct u3g_softc), 170}; 171 172DRIVER_MODULE(u3g, ushub, u3g_driver, u3g_devclass, u3g_driver_loaded, 0); 173MODULE_DEPEND(u3g, usb2_serial, 1, 1, 1); 174MODULE_DEPEND(u3g, usb2_core, 1, 1, 1); 175 176/* Huawei specific defines */ 177 178#define U3GINFO(flag,speed) ((flag)|((speed) * 256)) 179#define U3G_GET_SPEED(uaa) (USB_GET_DRIVER_INFO(uaa) / 256) 180 181/* 182 * NOTE: The entries marked with XXX should be checked for the correct 183 * speed indication to set the buffer sizes. 184 */ 185static const struct usb2_device_id u3g_devs[] = { 186 /* OEM: Option */ 187 {USB_VPI(USB_VENDOR_OPTION, USB_PRODUCT_OPTION_GT3G, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, 188 {USB_VPI(USB_VENDOR_OPTION, USB_PRODUCT_OPTION_GT3GQUAD, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, 189 {USB_VPI(USB_VENDOR_OPTION, USB_PRODUCT_OPTION_GT3GPLUS, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, 190 {USB_VPI(USB_VENDOR_OPTION, USB_PRODUCT_OPTION_GTMAX36, U3GINFO(U3GSP_HSDPA, U3GFL_NONE))}, 191 {USB_VPI(USB_VENDOR_OPTION, USB_PRODUCT_OPTION_GTMAXHSUPA, U3GINFO(U3GSP_HSDPA, U3GFL_NONE))}, 192 {USB_VPI(USB_VENDOR_OPTION, USB_PRODUCT_OPTION_VODAFONEMC3G, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, 193 /* OEM: Qualcomm, Inc. */ 194 {USB_VPI(USB_VENDOR_QUALCOMMINC, USB_PRODUCT_QUALCOMMINC_ZTE_STOR, U3GINFO(U3GSP_CDMA, U3GFL_SCSI_EJECT))}, 195 {USB_VPI(USB_VENDOR_QUALCOMMINC, USB_PRODUCT_QUALCOMMINC_CDMA_MSM, U3GINFO(U3GSP_CDMA, U3GFL_SCSI_EJECT))}, 196 /* OEM: Huawei */ 197 {USB_VPI(USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_MOBILE, U3GINFO(U3GSP_HSDPA, U3GFL_HUAWEI_INIT))}, 198 {USB_VPI(USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_E220, U3GINFO(U3GSP_HSPA, U3GFL_HUAWEI_INIT))}, 199 /* OEM: Novatel */ 200 {USB_VPI(USB_VENDOR_NOVATEL, USB_PRODUCT_NOVATEL_CDMA_MODEM, U3GINFO(U3GSP_CDMA, U3GFL_SCSI_EJECT))}, 201 {USB_VPI(USB_VENDOR_NOVATEL, USB_PRODUCT_NOVATEL_ES620, U3GINFO(U3GSP_UMTS, U3GFL_SCSI_EJECT))}, /* XXX */ 202 {USB_VPI(USB_VENDOR_NOVATEL, USB_PRODUCT_NOVATEL_MC950D, U3GINFO(U3GSP_HSUPA, U3GFL_SCSI_EJECT))}, 203 {USB_VPI(USB_VENDOR_NOVATEL, USB_PRODUCT_NOVATEL_U720, U3GINFO(U3GSP_UMTS, U3GFL_SCSI_EJECT))}, /* XXX */ 204 {USB_VPI(USB_VENDOR_NOVATEL, USB_PRODUCT_NOVATEL_U727, U3GINFO(U3GSP_UMTS, U3GFL_SCSI_EJECT))}, /* XXX */ 205 {USB_VPI(USB_VENDOR_NOVATEL, USB_PRODUCT_NOVATEL_U740, U3GINFO(U3GSP_HSDPA, U3GFL_SCSI_EJECT))}, 206 {USB_VPI(USB_VENDOR_NOVATEL, USB_PRODUCT_NOVATEL_U740_2, U3GINFO(U3GSP_HSDPA, U3GFL_SCSI_EJECT))}, 207 {USB_VPI(USB_VENDOR_NOVATEL, USB_PRODUCT_NOVATEL_U870, U3GINFO(U3GSP_UMTS, U3GFL_SCSI_EJECT))}, /* XXX */ 208 {USB_VPI(USB_VENDOR_NOVATEL, USB_PRODUCT_NOVATEL_V620, U3GINFO(U3GSP_UMTS, U3GFL_SCSI_EJECT))}, /* XXX */ 209 {USB_VPI(USB_VENDOR_NOVATEL, USB_PRODUCT_NOVATEL_V640, U3GINFO(U3GSP_UMTS, U3GFL_SCSI_EJECT))}, /* XXX */ 210 {USB_VPI(USB_VENDOR_NOVATEL, USB_PRODUCT_NOVATEL_V720, U3GINFO(U3GSP_UMTS, U3GFL_SCSI_EJECT))}, /* XXX */ 211 {USB_VPI(USB_VENDOR_NOVATEL, USB_PRODUCT_NOVATEL_V740, U3GINFO(U3GSP_HSDPA, U3GFL_SCSI_EJECT))}, 212 {USB_VPI(USB_VENDOR_NOVATEL, USB_PRODUCT_NOVATEL_X950D, U3GINFO(U3GSP_HSUPA, U3GFL_SCSI_EJECT))}, 213 {USB_VPI(USB_VENDOR_NOVATEL, USB_PRODUCT_NOVATEL_XU870, U3GINFO(U3GSP_HSDPA, U3GFL_SCSI_EJECT))}, 214 {USB_VPI(USB_VENDOR_NOVATEL, USB_PRODUCT_NOVATEL_ZEROCD, U3GINFO(U3GSP_HSUPA, U3GFL_SCSI_EJECT))}, 215 {USB_VPI(USB_VENDOR_DELL, USB_PRODUCT_DELL_U740, U3GINFO(U3GSP_HSDPA, U3GFL_SCSI_EJECT))}, 216 /* OEM: Merlin */ 217 {USB_VPI(USB_VENDOR_MERLIN, USB_PRODUCT_MERLIN_V620, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 218 /* OEM: Sierra Wireless: */ 219 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AIRCARD580, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 220 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AIRCARD595, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 221 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC595U, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 222 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC597E, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 223 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_C597, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 224 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC880, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 225 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC880E, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 226 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC880U, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 227 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC881, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 228 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC881E, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 229 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC881U, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 230 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_EM5625, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 231 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC5720, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 232 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC5720_2, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 233 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC5725, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 234 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MINI5725, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 235 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AIRCARD875, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 236 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8755, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 237 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8755_2, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 238 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8755_3, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 239 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8765, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 240 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC875U, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 241 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8775_2, U3GINFO(U3GSP_HSDPA, U3GFL_NONE))}, /* XXX */ 242 {USB_VPI(USB_VENDOR_HP, USB_PRODUCT_HP_HS2300, U3GINFO(U3GSP_HSDPA, U3GFL_NONE))}, 243 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8780, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 244 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8781, U3GINFO(U3GSP_UMTS, U3GFL_NONE))}, /* XXX */ 245 {USB_VPI(USB_VENDOR_HP, USB_PRODUCT_HP_HS2300, U3GINFO(U3GSP_HSPA, U3GFL_NONE))}, /* XXX */ 246 /* Sierra TruInstaller device ID */ 247 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_TRUINSTALL, U3GINFO(U3GSP_UMTS, U3GFL_SIERRA_INIT))}, 248}; 249 250static void 251u3g_sierra_init(struct usb2_device *udev) 252{ 253 struct usb2_device_request req; 254 255 DPRINTFN(0, "\n"); 256 257 req.bmRequestType = UT_VENDOR; 258 req.bRequest = UR_SET_INTERFACE; 259 USETW(req.wValue, UF_DEVICE_REMOTE_WAKEUP); 260 USETW(req.wIndex, UHF_PORT_CONNECTION); 261 USETW(req.wLength, 0); 262 263 if (usb2_do_request_flags(udev, NULL, &req, 264 NULL, 0, NULL, USB_MS_HZ)) { 265 /* ignore any errors */ 266 } 267 return; 268} 269 270static void 271u3g_huawei_init(struct usb2_device *udev) 272{ 273 struct usb2_device_request req; 274 275 DPRINTFN(0, "\n"); 276 277 req.bmRequestType = UT_WRITE_DEVICE; 278 req.bRequest = UR_SET_FEATURE; 279 USETW(req.wValue, UF_DEVICE_REMOTE_WAKEUP); 280 USETW(req.wIndex, UHF_PORT_SUSPEND); 281 USETW(req.wLength, 0); 282 283 if (usb2_do_request_flags(udev, NULL, &req, 284 NULL, 0, NULL, USB_MS_HZ)) { 285 /* ignore any errors */ 286 } 287 return; 288} 289 290static int 291u3g_lookup_huawei(struct usb2_attach_arg *uaa) 292{ 293 /* Calling the lookup function will also set the driver info! */ 294 return (usb2_lookup_id_by_uaa(u3g_devs, sizeof(u3g_devs), uaa)); 295} 296 297/* 298 * The following function handles 3G modem devices (E220, Mobile, 299 * etc.) with auto-install flash disks for Windows/MacOSX on the first 300 * interface. After some command or some delay they change appearance 301 * to a modem. 302 */ 303static usb2_error_t 304u3g_test_huawei_autoinst(struct usb2_device *udev, 305 struct usb2_attach_arg *uaa) 306{ 307 struct usb2_interface *iface; 308 struct usb2_interface_descriptor *id; 309 uint32_t flags; 310 311 if (udev == NULL) { 312 return (USB_ERR_INVAL); 313 } 314 iface = usb2_get_iface(udev, 0); 315 if (iface == NULL) { 316 return (USB_ERR_INVAL); 317 } 318 id = iface->idesc; 319 if (id == NULL) { 320 return (USB_ERR_INVAL); 321 } 322 if (id->bInterfaceClass != UICLASS_MASS) { 323 return (USB_ERR_INVAL); 324 } 325 if (u3g_lookup_huawei(uaa)) { 326 /* no device match */ 327 return (USB_ERR_INVAL); 328 } 329 flags = USB_GET_DRIVER_INFO(uaa); 330 331 if (flags & U3GFL_HUAWEI_INIT) { 332 u3g_huawei_init(udev); 333 } else if (flags & U3GFL_SCSI_EJECT) { 334 return (usb2_test_autoinstall(udev, 0, 1)); 335 } else if (flags & U3GFL_SIERRA_INIT) { 336 u3g_sierra_init(udev); 337 } else { 338 /* no quirks */ 339 return (USB_ERR_INVAL); 340 } 341 return (0); /* success */ 342} 343 344static int 345u3g_driver_loaded(struct module *mod, int what, void *arg) 346{ 347 switch (what) { 348 case MOD_LOAD: 349 /* register our autoinstall handler */ 350 usb2_test_huawei_autoinst_p = &u3g_test_huawei_autoinst; 351 break; 352 case MOD_UNLOAD: 353 usb2_test_huawei_unload(NULL); 354 break; 355 default: 356 return (EOPNOTSUPP); 357 } 358 return (0); 359} 360 361static int 362u3g_probe(device_t self) 363{ 364 struct usb2_attach_arg *uaa = device_get_ivars(self); 365 366 if (uaa->usb2_mode != USB_MODE_HOST) { 367 return (ENXIO); 368 } 369 if (uaa->info.bConfigIndex != U3G_CONFIG_INDEX) { 370 return (ENXIO); 371 } 372 if (uaa->info.bInterfaceClass != UICLASS_VENDOR) { 373 return (ENXIO); 374 } 375 return (u3g_lookup_huawei(uaa)); 376} 377 378static int 379u3g_attach(device_t dev) 380{ 381 struct usb2_attach_arg *uaa = device_get_ivars(dev); 382 struct u3g_softc *sc = device_get_softc(dev); 383 int error; 384 385 DPRINTF("sc=%p\n", sc); 386 387 if (sc == NULL) { 388 return (ENOMEM); 389 } 390 device_set_usb2_desc(dev); 391 392 sc->sc_udev = uaa->device; 393 sc->sc_iface_no = uaa->info.bIfaceNum; 394 sc->sc_iface_index = uaa->info.bIfaceIndex; 395 sc->sc_speed = u3g_speeds[U3G_GET_SPEED(uaa)]; 396 397 error = usb2_transfer_setup(uaa->device, &sc->sc_iface_index, 398 sc->sc_xfer, u3g_config, U3G_N_TRANSFER, sc, &Giant); 399 400 if (error) { 401 DPRINTF("could not allocate all pipes\n"); 402 goto detach; 403 } 404 /* set stall by default */ 405 usb2_transfer_set_stall(sc->sc_xfer[0]); 406 usb2_transfer_set_stall(sc->sc_xfer[1]); 407 408 error = usb2_com_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, 409 &u3g_callback, &Giant); 410 if (error) { 411 DPRINTF("usb2_com_attach failed\n"); 412 goto detach; 413 } 414 return (0); 415 416detach: 417 u3g_detach(dev); 418 return (ENXIO); 419} 420 421static int 422u3g_detach(device_t dev) 423{ 424 struct u3g_softc *sc = device_get_softc(dev); 425 426 DPRINTF("sc=%p\n", sc); 427 428 usb2_com_detach(&sc->sc_super_ucom, &sc->sc_ucom, 1); 429 430 usb2_transfer_unsetup(sc->sc_xfer, U3G_N_TRANSFER); 431 432 return (0); 433} 434 435static void 436u3g_start_read(struct usb2_com_softc *ucom) 437{ 438 struct u3g_softc *sc = ucom->sc_parent; 439 440 /* start read endpoint */ 441 usb2_transfer_start(sc->sc_xfer[1]); 442 return; 443} 444 445static void 446u3g_stop_read(struct usb2_com_softc *ucom) 447{ 448 struct u3g_softc *sc = ucom->sc_parent; 449 450 /* stop read endpoint */ 451 usb2_transfer_stop(sc->sc_xfer[1]); 452 return; 453} 454 455static void 456u3g_start_write(struct usb2_com_softc *ucom) 457{ 458 struct u3g_softc *sc = ucom->sc_parent; 459 460 usb2_transfer_start(sc->sc_xfer[0]); 461 return; 462} 463 464static void 465u3g_stop_write(struct usb2_com_softc *ucom) 466{ 467 struct u3g_softc *sc = ucom->sc_parent; 468 469 usb2_transfer_stop(sc->sc_xfer[0]); 470 return; 471} 472 473static void 474u3g_write_callback(struct usb2_xfer *xfer) 475{ 476 struct u3g_softc *sc = xfer->priv_sc; 477 uint32_t actlen; 478 479 switch (USB_GET_STATE(xfer)) { 480 case USB_ST_TRANSFERRED: 481 case USB_ST_SETUP: 482tr_setup: 483 if (usb2_com_get_data(&sc->sc_ucom, xfer->frbuffers, 0, 484 U3G_BSIZE, &actlen)) { 485 xfer->frlengths[0] = actlen; 486 usb2_start_hardware(xfer); 487 } 488 break; 489 490 default: /* Error */ 491 if (xfer->error != USB_ERR_CANCELLED) { 492 /* do a builtin clear-stall */ 493 xfer->flags.stall_pipe = 1; 494 goto tr_setup; 495 } 496 break; 497 } 498 return; 499} 500 501static void 502u3g_read_callback(struct usb2_xfer *xfer) 503{ 504 struct u3g_softc *sc = xfer->priv_sc; 505 506 switch (USB_GET_STATE(xfer)) { 507 case USB_ST_TRANSFERRED: 508 usb2_com_put_data(&sc->sc_ucom, xfer->frbuffers, 0, xfer->actlen); 509 510 case USB_ST_SETUP: 511tr_setup: 512 xfer->frlengths[0] = xfer->max_data_length; 513 usb2_start_hardware(xfer); 514 break; 515 516 default: /* Error */ 517 if (xfer->error != USB_ERR_CANCELLED) { 518 /* do a builtin clear-stall */ 519 xfer->flags.stall_pipe = 1; 520 goto tr_setup; 521 } 522 break; 523 } 524 return; 525} 526