1 /* $NetBSD: u3g.c,v 1.17 2011/03/10 00:13:56 scw Exp $ */ 2 3 /*- 4 * Copyright (c) 2009 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 19 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 20 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 21 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 22 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28 * POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 /* 32 * Copyright (c) 2008 AnyWi Technologies 33 * Author: Andrea Guzzo <aguzzo@anywi.com> 34 * * based on uark.c 1.1 2006/08/14 08:30:22 jsg * 35 * * parts from ubsa.c 183348 2008-09-25 12:00:56Z phk * 36 * 37 * Permission to use, copy, modify, and distribute this software for any 38 * purpose with or without fee is hereby granted, provided that the above 39 * copyright notice and this permission notice appear in all copies. 40 * 41 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 42 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 43 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 44 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 45 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 46 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 47 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 48 * 49 * $FreeBSD$ 50 */ 51 52 #include <sys/cdefs.h> 53 __KERNEL_RCSID(0, "$NetBSD: u3g.c,v 1.17 2011/03/10 00:13:56 scw Exp $"); 54 55 #include <sys/param.h> 56 #include <sys/systm.h> 57 #include <sys/kernel.h> 58 #include <sys/malloc.h> 59 #include <sys/bus.h> 60 #include <sys/conf.h> 61 #include <sys/tty.h> 62 63 #include <dev/usb/usb.h> 64 #include <dev/usb/usbdi.h> 65 #include <dev/usb/usbdivar.h> 66 #include <dev/usb/usbdi_util.h> 67 68 #include <dev/usb/ucomvar.h> 69 70 #include "usbdevs.h" 71 72 /* 73 * We read/write data from/to the device in 4KB chunks to maximise 74 * performance. 75 */ 76 #define U3G_BUFF_SIZE 4096 77 78 /* 79 * Some 3G devices (the Huawei E160/E220 springs to mind here) buffer up 80 * data internally even when the USB pipes are closed. So on first open, 81 * we can receive a large chunk of stale data. 82 * 83 * This causes a real problem because the default TTYDEF_LFLAG (applied 84 * on first open) has the ECHO flag set, resulting in all the stale data 85 * being echoed straight back to the device by the tty(4) layer. Some 86 * devices (again, the Huawei E160/E220 for example) react to this spew 87 * by going catatonic. 88 * 89 * All this happens before the application gets a chance to disable ECHO. 90 * 91 * We work around this by ignoring all data received from the device for 92 * a period of two seconds, or until the application starts sending data - 93 * whichever comes first. 94 */ 95 #define U3G_PURGE_SECS 2 96 97 /* 98 * Define bits for the virtual modem control pins. 99 * The input pin states are reported via the interrupt pipe on some devices. 100 */ 101 #define U3G_OUTPIN_DTR (1u << 0) 102 #define U3G_OUTPIN_RTS (1u << 1) 103 #define U3G_INPIN_DCD (1u << 0) 104 #define U3G_INPIN_DSR (1u << 1) 105 #define U3G_INPIN_RI (1u << 3) 106 107 /* 108 * USB request to set the output pin status 109 */ 110 #define U3G_SET_PIN 0x22 111 112 struct u3g_softc { 113 device_t sc_dev; 114 usbd_device_handle sc_udev; 115 bool sc_dying; /* We're going away */ 116 117 device_t sc_ucom; /* Child ucom(4) handle */ 118 int sc_ifaceno; /* Device interface number */ 119 120 bool sc_open; /* Device is in use */ 121 bool sc_purging; /* Purging stale data */ 122 struct timeval sc_purge_start; /* Control duration of purge */ 123 124 u_char sc_msr; /* Emulated 'msr' */ 125 uint16_t sc_outpins; /* Output pin state */ 126 127 usbd_pipe_handle sc_intr_pipe; /* Interrupt pipe */ 128 u_char *sc_intr_buff; /* Interrupt buffer */ 129 }; 130 131 /* 132 * The device driver has two personalities. The first uses the 'usbdevif' 133 * interface attribute so that a match will claim the entire USB device 134 * for itself. This is used for when a device needs to be mode-switched 135 * and ensures any other interfaces present cannot be claimed by other 136 * drivers while the mode-switch is in progress. 137 * 138 * The second personality uses the 'usbifif' interface attribute so that 139 * it can claim the 3G modem interfaces for itself, leaving others (such 140 * as the mass storage interfaces on some devices) for other drivers. 141 */ 142 static int u3ginit_match(device_t, cfdata_t, void *); 143 static void u3ginit_attach(device_t, device_t, void *); 144 static int u3ginit_detach(device_t, int); 145 146 CFATTACH_DECL2_NEW(u3ginit, 0, u3ginit_match, 147 u3ginit_attach, u3ginit_detach, NULL, NULL, NULL); 148 149 150 static int u3g_match(device_t, cfdata_t, void *); 151 static void u3g_attach(device_t, device_t, void *); 152 static int u3g_detach(device_t, int); 153 static int u3g_activate(device_t, enum devact); 154 static void u3g_childdet(device_t, device_t); 155 156 CFATTACH_DECL2_NEW(u3g, sizeof(struct u3g_softc), u3g_match, 157 u3g_attach, u3g_detach, u3g_activate, NULL, u3g_childdet); 158 159 160 static void u3g_intr(usbd_xfer_handle, usbd_private_handle, usbd_status); 161 static void u3g_get_status(void *, int, u_char *, u_char *); 162 static void u3g_set(void *, int, int, int); 163 static int u3g_open(void *, int); 164 static void u3g_close(void *, int); 165 static void u3g_read(void *, int, u_char **, uint32_t *); 166 static void u3g_write(void *, int, u_char *, u_char *, u_int32_t *); 167 168 struct ucom_methods u3g_methods = { 169 u3g_get_status, 170 u3g_set, 171 NULL, 172 NULL, 173 u3g_open, 174 u3g_close, 175 u3g_read, 176 u3g_write, 177 }; 178 179 /* 180 * Allegedly supported devices 181 */ 182 static const struct usb_devno u3g_devs[] = { 183 { USB_VENDOR_DELL, USB_PRODUCT_DELL_W5500 }, 184 /* OEM: Huawei */ 185 { USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_E220 }, 186 { USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_K3765 }, 187 { USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_MOBILE }, 188 /* OEM: Merlin */ 189 { USB_VENDOR_MERLIN, USB_PRODUCT_MERLIN_V620 }, 190 /* OEM: Novatel */ 191 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_ES620 }, 192 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_MC950D }, 193 #if 0 194 /* These are matched in u3ginit_match() */ 195 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_MC950D_DRIVER }, 196 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_U760_DRIVER }, 197 #endif 198 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_MERLINU740 }, 199 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_MERLINV620 }, 200 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_S720 }, 201 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_U720 }, 202 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_U727 }, 203 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_U740_2 }, 204 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_U760 }, 205 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_U870 }, 206 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_V740 }, 207 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_X950D }, 208 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_XU870 }, 209 /* OEM: Option N.V. */ 210 { USB_VENDOR_OPTIONNV, USB_PRODUCT_OPTIONNV_QUADPLUSUMTS }, 211 { USB_VENDOR_OPTIONNV, USB_PRODUCT_OPTIONNV_HSDPA }, 212 { USB_VENDOR_OPTIONNV, USB_PRODUCT_OPTIONNV_GTMAXHSUPA }, 213 /* OEM: Qualcomm, Inc. */ 214 { USB_VENDOR_QUALCOMMINC, USB_PRODUCT_QUALCOMMINC_CDMA_MSM }, 215 { USB_VENDOR_QUALCOMMINC, USB_PRODUCT_QUALCOMMINC_ZTE_MF626 }, 216 217 /* OEM: Sierra Wireless: */ 218 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC595U }, 219 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC597E }, 220 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC875U }, 221 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC880 }, 222 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC880E }, 223 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC880U }, 224 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC881 }, 225 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC881E }, 226 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC881U }, 227 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AIRCARD580 }, 228 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AIRCARD595 }, 229 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AIRCARD875 }, 230 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_C597 }, 231 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_EM5625 }, 232 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC5720 }, 233 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC5720_2 }, 234 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC5725 }, 235 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8755 }, 236 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8755_2 }, 237 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8755_3 }, 238 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8765 }, 239 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8775_2 }, 240 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8780 }, 241 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8781 }, 242 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MINI5725 }, 243 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_USB305 }, 244 245 /* Toshiba */ 246 { USB_VENDOR_TOSHIBA, USB_PRODUCT_TOSHIBA_HSDPA_MODEM_EU870DT1 }, 247 }; 248 249 static int 250 send_bulkmsg(usbd_device_handle dev, char *cmd, size_t cmdlen) 251 { 252 usbd_interface_handle iface; 253 usb_interface_descriptor_t *id; 254 usb_endpoint_descriptor_t *ed; 255 usbd_pipe_handle pipe; 256 usbd_xfer_handle xfer; 257 int err, i; 258 259 /* Move the device into the configured state. */ 260 err = usbd_set_config_index(dev, 0, 0); 261 if (err) { 262 aprint_error("u3g: failed to set configuration index\n"); 263 return UMATCH_NONE; 264 } 265 266 err = usbd_device2interface_handle(dev, 0, &iface); 267 if (err != 0) { 268 aprint_error("u3ginit: failed to get interface\n"); 269 return UMATCH_NONE; 270 } 271 272 id = usbd_get_interface_descriptor(iface); 273 ed = NULL; 274 for (i = 0 ; i < id->bNumEndpoints ; i++) { 275 ed = usbd_interface2endpoint_descriptor(iface, i); 276 if (ed == NULL) 277 continue; 278 if (UE_GET_DIR(ed->bEndpointAddress) != UE_DIR_OUT) 279 continue; 280 if ((ed->bmAttributes & UE_XFERTYPE) == UE_BULK) 281 break; 282 } 283 284 if (i == id->bNumEndpoints) 285 return UMATCH_NONE; 286 287 err = usbd_open_pipe(iface, ed->bEndpointAddress, 288 USBD_EXCLUSIVE_USE, &pipe); 289 if (err != 0) { 290 aprint_error("u3ginit: failed to open bulk transfer pipe %d\n", 291 ed->bEndpointAddress); 292 return UMATCH_NONE; 293 } 294 295 xfer = usbd_alloc_xfer(dev); 296 if (xfer != NULL) { 297 usbd_setup_xfer(xfer, pipe, NULL, cmd, cmdlen, 298 USBD_SYNCHRONOUS, USBD_DEFAULT_TIMEOUT, NULL); 299 300 err = usbd_transfer(xfer); 301 302 #if 0 /* XXXpooka: at least my huawei "fails" this always, but still detaches */ 303 if (err) 304 aprint_error("u3ginit: transfer failed\n"); 305 #else 306 err = 0; 307 #endif 308 usbd_free_xfer(xfer); 309 } else { 310 aprint_error("u3ginit: failed to allocate xfer\n"); 311 err = USBD_NOMEM; 312 } 313 314 usbd_abort_pipe(pipe); 315 usbd_close_pipe(pipe); 316 317 return (err == USBD_NORMAL_COMPLETION ? UMATCH_HIGHEST : UMATCH_NONE); 318 } 319 320 static int 321 u3g_novatel_reinit(usbd_device_handle dev) 322 { 323 unsigned char cmd[31]; 324 325 memset(cmd, 0, sizeof(cmd)); 326 /* Byte 0..3: Command Block Wrapper (CBW) signature */ 327 cmd[0] = 0x55; 328 cmd[1] = 0x53; 329 cmd[2] = 0x42; 330 cmd[3] = 0x43; 331 /* 4..7: CBW Tag, has to unique, but only a single transfer used. */ 332 cmd[4] = 0x01; 333 /* 8..11: CBW Transfer Length, no data here */ 334 /* 12: CBW Flag: output, so 0 */ 335 /* 13: CBW Lun: 0 */ 336 /* 14: CBW Length */ 337 cmd[14] = 0x06; 338 /* Rest is the SCSI payload */ 339 /* 0: SCSI START/STOP opcode */ 340 cmd[15] = 0x1b; 341 /* 1..3 unused */ 342 /* 4 Load/Eject command */ 343 cmd[19] = 0x02; 344 /* 5: unused */ 345 346 return send_bulkmsg(dev, cmd, sizeof(cmd)); 347 } 348 349 static int 350 u3g_huawei_reinit(usbd_device_handle dev) 351 { 352 /* 353 * The Huawei device presents itself as a umass device with Windows 354 * drivers on it. After installation of the driver, it reinits into a 355 * 3G serial device. 356 */ 357 usb_device_request_t req; 358 usb_config_descriptor_t *cdesc; 359 360 /* Get the config descriptor */ 361 cdesc = usbd_get_config_descriptor(dev); 362 if (cdesc == NULL) { 363 usb_device_descriptor_t dd; 364 365 if (usbd_get_device_desc(dev, &dd) != 0) 366 return (UMATCH_NONE); 367 368 if (dd.bNumConfigurations != 1) 369 return (UMATCH_NONE); 370 371 if (usbd_set_config_index(dev, 0, 1) != 0) 372 return (UMATCH_NONE); 373 374 cdesc = usbd_get_config_descriptor(dev); 375 376 if (cdesc == NULL) 377 return (UMATCH_NONE); 378 } 379 380 /* 381 * One iface means umass mode, more than 1 (4 usually) means 3G mode. 382 * 383 * XXX: We should check the first interface's device class just to be 384 * sure. If it's a mass storage device, then we can be fairly certain 385 * it needs a mode-switch. 386 */ 387 if (cdesc->bNumInterface > 1) 388 return (UMATCH_NONE); 389 390 req.bmRequestType = UT_WRITE_DEVICE; 391 req.bRequest = UR_SET_FEATURE; 392 USETW(req.wValue, UF_DEVICE_REMOTE_WAKEUP); 393 USETW(req.wIndex, UHF_PORT_SUSPEND); 394 USETW(req.wLength, 0); 395 396 (void) usbd_do_request(dev, &req, 0); 397 398 return (UMATCH_HIGHEST); /* Prevent umass from attaching */ 399 } 400 401 static int 402 u3g_huawei_k3765_reinit(usbd_device_handle dev) 403 { 404 unsigned char cmd[31]; 405 406 /* magic string adapted from some webpage */ 407 memset(cmd, 0, sizeof(cmd)); 408 cmd[0] = 0x55; 409 cmd[1] = 0x53; 410 cmd[2] = 0x42; 411 cmd[3] = 0x43; 412 cmd[15]= 0x11; 413 cmd[16]= 0x06; 414 415 return send_bulkmsg(dev, cmd, sizeof(cmd)); 416 } 417 418 static int 419 u3g_sierra_reinit(usbd_device_handle dev) 420 { 421 /* Some Sierra devices presents themselves as a umass device with 422 * Windows drivers on it. After installation of the driver, it 423 * reinits into a * 3G serial device. 424 */ 425 usb_device_request_t req; 426 427 req.bmRequestType = UT_VENDOR; 428 req.bRequest = UR_SET_INTERFACE; 429 USETW(req.wValue, UF_DEVICE_REMOTE_WAKEUP); 430 USETW(req.wIndex, UHF_PORT_CONNECTION); 431 USETW(req.wLength, 0); 432 433 (void) usbd_do_request(dev, &req, 0); 434 435 return (UMATCH_HIGHEST); /* Match to prevent umass from attaching */ 436 } 437 438 /* 439 * First personality: 440 * 441 * Claim the entire device if a mode-switch is required. 442 */ 443 444 static int 445 u3ginit_match(device_t parent, cfdata_t match, void *aux) 446 { 447 struct usb_attach_arg *uaa = aux; 448 449 /* 450 * Huawei changes product when it is configured as a modem. 451 */ 452 switch (uaa->vendor) { 453 case USB_VENDOR_HUAWEI: 454 if (uaa->product == USB_PRODUCT_HUAWEI_K3765) 455 return UMATCH_NONE; 456 457 switch (uaa->product) { 458 case USB_PRODUCT_HUAWEI_E1750INIT: 459 case USB_PRODUCT_HUAWEI_K3765INIT: 460 return u3g_huawei_k3765_reinit(uaa->device); 461 break; 462 default: 463 return u3g_huawei_reinit(uaa->device); 464 break; 465 } 466 break; 467 468 case USB_VENDOR_NOVATEL2: 469 switch (uaa->product){ 470 case USB_PRODUCT_NOVATEL2_MC950D_DRIVER: 471 case USB_PRODUCT_NOVATEL2_U760_DRIVER: 472 return u3g_novatel_reinit(uaa->device); 473 break; 474 default: 475 break; 476 } 477 break; 478 479 case USB_VENDOR_SIERRA: 480 if (uaa->product == USB_PRODUCT_SIERRA_INSTALLER) 481 return u3g_sierra_reinit(uaa->device); 482 break; 483 484 case USB_VENDOR_QUALCOMMINC: 485 if (uaa->product == USB_PRODUCT_QUALCOMMINC_ZTE_STOR) 486 return u3g_novatel_reinit(uaa->device); 487 break; 488 489 default: 490 break; 491 } 492 493 return UMATCH_NONE; 494 } 495 496 static void 497 u3ginit_attach(device_t parent, device_t self, void *aux) 498 { 499 struct usb_attach_arg *uaa = aux; 500 501 aprint_naive("\n"); 502 aprint_normal(": Switching to 3G mode\n"); 503 504 if (uaa->vendor == USB_VENDOR_NOVATEL2) { 505 switch (uaa->product) { 506 case USB_PRODUCT_NOVATEL2_MC950D_DRIVER: 507 case USB_PRODUCT_NOVATEL2_U760_DRIVER: 508 /* About to disappear... */ 509 return; 510 break; 511 default: 512 break; 513 } 514 } 515 516 /* Move the device into the configured state. */ 517 (void) usbd_set_config_index(uaa->device, 0, 1); 518 } 519 520 static int 521 u3ginit_detach(device_t self, int flags) 522 { 523 524 return (0); 525 } 526 527 528 /* 529 * Second personality: 530 * 531 * Claim only those interfaces required for 3G modem operation. 532 */ 533 534 static int 535 u3g_match(device_t parent, cfdata_t match, void *aux) 536 { 537 struct usbif_attach_arg *uaa = aux; 538 usbd_interface_handle iface; 539 usb_interface_descriptor_t *id; 540 usbd_status error; 541 542 if (!usb_lookup(u3g_devs, uaa->vendor, uaa->product)) 543 return (UMATCH_NONE); 544 545 error = usbd_device2interface_handle(uaa->device, uaa->ifaceno, &iface); 546 if (error) { 547 printf("u3g_match: failed to get interface, err=%s\n", 548 usbd_errstr(error)); 549 return (UMATCH_NONE); 550 } 551 552 id = usbd_get_interface_descriptor(iface); 553 if (id == NULL) { 554 printf("u3g_match: failed to get interface descriptor\n"); 555 return (UMATCH_NONE); 556 } 557 558 /* 559 * 3G modems generally report vendor-specific class 560 * 561 * XXX: this may be too generalised. 562 */ 563 return ((id->bInterfaceClass == UICLASS_VENDOR) ? 564 UMATCH_VENDOR_PRODUCT : UMATCH_NONE); 565 } 566 567 static void 568 u3g_attach(device_t parent, device_t self, void *aux) 569 { 570 struct u3g_softc *sc = device_private(self); 571 struct usbif_attach_arg *uaa = aux; 572 usbd_device_handle dev = uaa->device; 573 usbd_interface_handle iface; 574 usb_interface_descriptor_t *id; 575 usb_endpoint_descriptor_t *ed; 576 struct ucom_attach_args uca; 577 usbd_status error; 578 int n, intr_address, intr_size; 579 580 aprint_naive("\n"); 581 aprint_normal("\n"); 582 583 sc->sc_dev = self; 584 sc->sc_dying = false; 585 sc->sc_udev = dev; 586 587 error = usbd_device2interface_handle(dev, uaa->ifaceno, &iface); 588 if (error) { 589 aprint_error_dev(self, "failed to get interface, err=%s\n", 590 usbd_errstr(error)); 591 return; 592 } 593 594 id = usbd_get_interface_descriptor(iface); 595 596 uca.info = "3G Modem"; 597 uca.ibufsize = U3G_BUFF_SIZE; 598 uca.obufsize = U3G_BUFF_SIZE; 599 uca.ibufsizepad = U3G_BUFF_SIZE; 600 uca.portno = uaa->ifaceno; 601 uca.opkthdrlen = 0; 602 uca.device = dev; 603 uca.iface = iface; 604 uca.methods = &u3g_methods; 605 uca.arg = sc; 606 uca.bulkin = uca.bulkout = -1; 607 608 sc->sc_outpins = 0; 609 sc->sc_msr = UMSR_DSR | UMSR_CTS | UMSR_DCD; 610 sc->sc_ifaceno = uaa->ifaceno; 611 sc->sc_open = false; 612 sc->sc_purging = false; 613 614 intr_address = -1; 615 intr_size = 0; 616 617 for (n = 0; n < id->bNumEndpoints; n++) { 618 ed = usbd_interface2endpoint_descriptor(iface, n); 619 if (ed == NULL) { 620 aprint_error_dev(self, "no endpoint descriptor " 621 "for %d (interface: %d)\n", n, sc->sc_ifaceno); 622 sc->sc_dying = true; 623 return; 624 } 625 626 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 627 UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) { 628 intr_address = ed->bEndpointAddress; 629 intr_size = UGETW(ed->wMaxPacketSize); 630 } else 631 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 632 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 633 uca.bulkin = ed->bEndpointAddress; 634 } else 635 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT && 636 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 637 uca.bulkout = ed->bEndpointAddress; 638 } 639 } 640 641 if (uca.bulkin == -1) { 642 aprint_error_dev(self, "Missing bulk in for interface %d\n", 643 sc->sc_ifaceno); 644 sc->sc_dying = true; 645 return; 646 } 647 648 if (uca.bulkout == -1) { 649 aprint_error_dev(self, "Missing bulk out for interface %d\n", 650 sc->sc_ifaceno); 651 sc->sc_dying = true; 652 return; 653 } 654 655 sc->sc_ucom = config_found_sm_loc(self, "ucombus", 656 NULL, &uca, ucomprint, ucomsubmatch); 657 658 /* 659 * If the interface has an interrupt pipe, open it immediately so 660 * that we can track input pin state changes regardless of whether 661 * the tty(4) device is open or not. 662 */ 663 if (intr_address != -1) { 664 sc->sc_intr_buff = malloc(intr_size, M_USBDEV, M_WAITOK); 665 error = usbd_open_pipe_intr(iface, intr_address, 666 USBD_SHORT_XFER_OK, &sc->sc_intr_pipe, sc, sc->sc_intr_buff, 667 intr_size, u3g_intr, 100); 668 if (error) { 669 aprint_error_dev(self, "cannot open interrupt pipe " 670 "(addr %d)\n", intr_address); 671 return; 672 } 673 } else { 674 sc->sc_intr_pipe = NULL; 675 sc->sc_intr_buff = NULL; 676 } 677 678 if (!pmf_device_register(self, NULL, NULL)) 679 aprint_error_dev(self, "couldn't establish power handler\n"); 680 } 681 682 static int 683 u3g_detach(device_t self, int flags) 684 { 685 struct u3g_softc *sc = device_private(self); 686 int rv; 687 688 if (sc->sc_dying) 689 return 0; 690 691 pmf_device_deregister(self); 692 693 if (sc->sc_ucom != NULL) { 694 rv = config_detach(sc->sc_ucom, flags); 695 if (rv != 0) { 696 aprint_verbose_dev(self, "Can't deallocate " 697 "port (%d)", rv); 698 } 699 } 700 701 if (sc->sc_intr_pipe != NULL) { 702 (void) usbd_abort_pipe(sc->sc_intr_pipe); 703 (void) usbd_close_pipe(sc->sc_intr_pipe); 704 sc->sc_intr_pipe = NULL; 705 } 706 if (sc->sc_intr_buff != NULL) { 707 free(sc->sc_intr_buff, M_USBDEV); 708 sc->sc_intr_buff = NULL; 709 } 710 711 return (0); 712 } 713 714 static void 715 u3g_childdet(device_t self, device_t child) 716 { 717 struct u3g_softc *sc = device_private(self); 718 719 if (sc->sc_ucom == child) 720 sc->sc_ucom = NULL; 721 } 722 723 static int 724 u3g_activate(device_t self, enum devact act) 725 { 726 struct u3g_softc *sc = device_private(self); 727 int rv; 728 729 switch (act) { 730 case DVACT_DEACTIVATE: 731 if (sc->sc_ucom != NULL && config_deactivate(sc->sc_ucom)) 732 rv = -1; 733 else 734 rv = 0; 735 break; 736 737 default: 738 rv = 0; 739 break; 740 } 741 742 return (rv); 743 } 744 745 static void 746 u3g_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) 747 { 748 struct u3g_softc *sc = (struct u3g_softc *)priv; 749 u_char *buf; 750 751 if (sc->sc_dying) 752 return; 753 754 if (status != USBD_NORMAL_COMPLETION) { 755 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) 756 return; 757 usbd_clear_endpoint_stall_async(sc->sc_intr_pipe); 758 return; 759 } 760 761 buf = sc->sc_intr_buff; 762 if (buf[0] == 0xa1 && buf[1] == 0x20) { 763 u_char msr; 764 765 msr = sc->sc_msr & ~(UMSR_DCD | UMSR_DSR | UMSR_RI); 766 767 if (buf[8] & U3G_INPIN_DCD) 768 msr |= UMSR_DCD; 769 770 if (buf[8] & U3G_INPIN_DSR) 771 msr |= UMSR_DSR; 772 773 if (buf[8] & U3G_INPIN_RI) 774 msr |= UMSR_RI; 775 776 if (msr != sc->sc_msr) { 777 sc->sc_msr = msr; 778 if (sc->sc_open) 779 ucom_status_change(device_private(sc->sc_ucom)); 780 } 781 } 782 } 783 784 /*ARGSUSED*/ 785 static void 786 u3g_get_status(void *arg, int portno, u_char *lsr, u_char *msr) 787 { 788 struct u3g_softc *sc = arg; 789 790 if (lsr != NULL) 791 *lsr = 0; /* LSR isn't supported */ 792 if (msr != NULL) 793 *msr = sc->sc_msr; 794 } 795 796 /*ARGSUSED*/ 797 static void 798 u3g_set(void *arg, int portno, int reg, int onoff) 799 { 800 struct u3g_softc *sc = arg; 801 usb_device_request_t req; 802 uint16_t mask, new_state; 803 usbd_status err; 804 805 if (sc->sc_dying) 806 return; 807 808 switch (reg) { 809 case UCOM_SET_DTR: 810 mask = U3G_OUTPIN_DTR; 811 break; 812 case UCOM_SET_RTS: 813 mask = U3G_OUTPIN_RTS; 814 break; 815 default: 816 return; 817 } 818 819 new_state = sc->sc_outpins & ~mask; 820 if (onoff) 821 new_state |= mask; 822 823 if (new_state == sc->sc_outpins) 824 return; 825 826 sc->sc_outpins = new_state; 827 828 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 829 req.bRequest = U3G_SET_PIN; 830 USETW(req.wValue, new_state); 831 USETW(req.wIndex, sc->sc_ifaceno); 832 USETW(req.wLength, 0); 833 834 err = usbd_do_request(sc->sc_udev, &req, 0); 835 if (err == USBD_STALLED) 836 usbd_clear_endpoint_stall(sc->sc_udev->default_pipe); 837 } 838 839 /*ARGSUSED*/ 840 static int 841 u3g_open(void *arg, int portno) 842 { 843 struct u3g_softc *sc = arg; 844 usb_device_request_t req; 845 usb_endpoint_descriptor_t *ed; 846 usb_interface_descriptor_t *id; 847 usbd_interface_handle ih; 848 usbd_status err; 849 int i; 850 851 if (sc->sc_dying) 852 return (0); 853 854 err = usbd_device2interface_handle(sc->sc_udev, portno, &ih); 855 if (err) 856 return (EIO); 857 858 id = usbd_get_interface_descriptor(ih); 859 860 for (i = 0; i < id->bNumEndpoints; i++) { 861 ed = usbd_interface2endpoint_descriptor(ih, i); 862 if (ed == NULL) 863 return (EIO); 864 865 if (UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 866 /* Issue ENDPOINT_HALT request */ 867 req.bmRequestType = UT_WRITE_ENDPOINT; 868 req.bRequest = UR_CLEAR_FEATURE; 869 USETW(req.wValue, UF_ENDPOINT_HALT); 870 USETW(req.wIndex, ed->bEndpointAddress); 871 USETW(req.wLength, 0); 872 err = usbd_do_request(sc->sc_udev, &req, 0); 873 if (err) 874 return (EIO); 875 } 876 } 877 878 sc->sc_open = true; 879 sc->sc_purging = true; 880 getmicrotime(&sc->sc_purge_start); 881 882 return (0); 883 } 884 885 /*ARGSUSED*/ 886 static void 887 u3g_close(void *arg, int portno) 888 { 889 struct u3g_softc *sc = arg; 890 891 sc->sc_open = false; 892 } 893 894 /*ARGSUSED*/ 895 static void 896 u3g_read(void *arg, int portno, u_char **cpp, uint32_t *ccp) 897 { 898 struct u3g_softc *sc = arg; 899 struct timeval curr_tv, diff_tv; 900 901 /* 902 * If we're not purging input data following first open, do nothing. 903 */ 904 if (sc->sc_purging == false) 905 return; 906 907 /* 908 * Otherwise check if the purge timeout has expired 909 */ 910 getmicrotime(&curr_tv); 911 timersub(&curr_tv, &sc->sc_purge_start, &diff_tv); 912 913 if (diff_tv.tv_sec >= U3G_PURGE_SECS) { 914 /* Timeout expired. */ 915 sc->sc_purging = false; 916 } else { 917 /* Still purging. Adjust the caller's byte count. */ 918 *ccp = 0; 919 } 920 } 921 922 /*ARGSUSED*/ 923 static void 924 u3g_write(void *arg, int portno, u_char *to, u_char *from, u_int32_t *count) 925 { 926 struct u3g_softc *sc = arg; 927 928 /* 929 * Stop purging as soon as the first data is written to the device. 930 */ 931 sc->sc_purging = false; 932 memcpy(to, from, *count); 933 } 934