u3g.c revision 1.34.2.1
1 /* $NetBSD: u3g.c,v 1.34.2.1 2020/02/27 14:32:31 martin 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 (at) 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.34.2.1 2020/02/27 14:32:31 martin Exp $"); 54 55 #include <sys/param.h> 56 #include <sys/systm.h> 57 #include <sys/kernel.h> 58 #include <sys/kmem.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 struct usbd_device * sc_udev; 115 bool sc_dying; /* We're going away */ 116 int sc_ifaceno; /* Device interface number */ 117 118 struct u3g_com { 119 device_t c_dev; /* Child ucom(4) handle */ 120 121 bool c_open; /* Device is in use */ 122 bool c_purging; /* Purging stale data */ 123 struct timeval c_purge_start; /* Control duration of purge */ 124 125 u_char c_msr; /* Emulated 'msr' */ 126 uint16_t c_outpins; /* Output pin state */ 127 } sc_com[10]; 128 size_t sc_ncom; 129 130 struct usbd_pipe * sc_intr_pipe; /* Interrupt pipe */ 131 u_char *sc_intr_buff; /* Interrupt buffer */ 132 size_t sc_intr_size; /* buffer size */ 133 }; 134 135 /* 136 * The device driver has two personalities. The first uses the 'usbdevif' 137 * interface attribute so that a match will claim the entire USB device 138 * for itself. This is used for when a device needs to be mode-switched 139 * and ensures any other interfaces present cannot be claimed by other 140 * drivers while the mode-switch is in progress. This is implemented by 141 * the umodeswitch driver. 142 * 143 * The second personality uses the 'usbifif' interface attribute so that 144 * it can claim the 3G modem interfaces for itself, leaving others (such 145 * as the mass storage interfaces on some devices) for other drivers. 146 */ 147 148 static int u3g_match(device_t, cfdata_t, void *); 149 static void u3g_attach(device_t, device_t, void *); 150 static int u3g_detach(device_t, int); 151 static int u3g_activate(device_t, enum devact); 152 static void u3g_childdet(device_t, device_t); 153 154 CFATTACH_DECL2_NEW(u3g, sizeof(struct u3g_softc), u3g_match, 155 u3g_attach, u3g_detach, u3g_activate, NULL, u3g_childdet); 156 157 158 static void u3g_intr(struct usbd_xfer *, void *, usbd_status); 159 static void u3g_get_status(void *, int, u_char *, u_char *); 160 static void u3g_set(void *, int, int, int); 161 static int u3g_open(void *, int); 162 static void u3g_close(void *, int); 163 static void u3g_read(void *, int, u_char **, uint32_t *); 164 static void u3g_write(void *, int, u_char *, u_char *, uint32_t *); 165 166 struct ucom_methods u3g_methods = { 167 .ucom_get_status = u3g_get_status, 168 .ucom_set = u3g_set, 169 .ucom_param = NULL, 170 .ucom_ioctl = NULL, 171 .ucom_open = u3g_open, 172 .ucom_close = u3g_close, 173 .ucom_read = u3g_read, 174 .ucom_write = u3g_write, 175 }; 176 177 /* 178 * Allegedly supported devices 179 */ 180 static const struct usb_devno u3g_devs[] = { 181 { USB_VENDOR_DELL, USB_PRODUCT_DELL_W5500 }, 182 { USB_VENDOR_HP, USB_PRODUCT_HP_UN2430 }, 183 /* OEM: Huawei */ 184 { USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_E1750 }, 185 { USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_E1820 }, 186 { USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_E220 }, 187 { USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_EM770W }, 188 { USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_K3765 }, 189 { USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_MOBILE }, 190 { USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_E171 }, 191 { USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_E353 }, 192 /* OEM: Merlin */ 193 { USB_VENDOR_MERLIN, USB_PRODUCT_MERLIN_V620 }, 194 /* OEM: Novatel */ 195 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_ES620 }, 196 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_EU8X0D }, 197 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_MC950D }, 198 #if 0 199 /* These are matched in u3ginit_match() */ 200 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_MC950D_DRIVER }, 201 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_U760_DRIVER }, 202 #endif 203 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_MERLINU740 }, 204 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_MERLINV620 }, 205 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_S720 }, 206 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_U720 }, 207 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_U727 }, 208 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_U740_2 }, 209 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_U760 }, 210 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_U870 }, 211 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_V740 }, 212 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_X950D }, 213 { USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_XU870 }, 214 /* OEM: Option N.V. */ 215 { USB_VENDOR_OPTIONNV, USB_PRODUCT_OPTIONNV_QUADPLUSUMTS }, 216 { USB_VENDOR_OPTIONNV, USB_PRODUCT_OPTIONNV_HSDPA }, 217 { USB_VENDOR_OPTIONNV, USB_PRODUCT_OPTIONNV_GTMAXHSUPA }, 218 /* OEM: Qualcomm, Inc. */ 219 { USB_VENDOR_QUALCOMM, USB_PRODUCT_QUALCOMM_NTT_DOCOMO_L02C_MODEM }, 220 221 /* OEM: Sierra Wireless: */ 222 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC595U }, 223 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC597E }, 224 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC875U }, 225 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC880 }, 226 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC880E }, 227 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC880U }, 228 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC881 }, 229 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC881E }, 230 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC881U }, 231 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AIRCARD580 }, 232 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AIRCARD595 }, 233 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AIRCARD875 }, 234 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_C597 }, 235 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_EM5625 }, 236 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC5720 }, 237 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC5720_2 }, 238 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC5725 }, 239 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8755 }, 240 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8755_2 }, 241 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8755_3 }, 242 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8765 }, 243 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8775_2 }, 244 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8780 }, 245 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8781 }, 246 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MINI5725 }, 247 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_USB305 }, 248 { USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_250U }, 249 /* Toshiba */ 250 { USB_VENDOR_TOSHIBA, USB_PRODUCT_TOSHIBA_HSDPA_MODEM_EU870DT1 }, 251 252 /* ZTE */ 253 { USB_VENDOR_ZTE, USB_PRODUCT_ZTE_MF622 }, 254 { USB_VENDOR_ZTE, USB_PRODUCT_ZTE_MF626 }, 255 { USB_VENDOR_ZTE, USB_PRODUCT_ZTE_MF628 }, 256 { USB_VENDOR_ZTE, USB_PRODUCT_ZTE_MF820D }, 257 258 /* 4G Systems */ 259 { USB_VENDOR_4GSYSTEMS, USB_PRODUCT_4GSYSTEMS_XSSTICK_P14 }, 260 { USB_VENDOR_4GSYSTEMS, USB_PRODUCT_4GSYSTEMS_XSSTICK_W14 }, 261 262 /* DLink */ 263 { USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DWM157 }, 264 { USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DWM157E }, 265 }; 266 267 /* 268 * Second personality: 269 * 270 * Claim only those interfaces required for 3G modem operation. 271 */ 272 273 static int 274 u3g_match(device_t parent, cfdata_t match, void *aux) 275 { 276 struct usbif_attach_arg *uiaa = aux; 277 struct usbd_interface *iface; 278 usb_interface_descriptor_t *id; 279 usbd_status error; 280 281 if (!usb_lookup(u3g_devs, uiaa->uiaa_vendor, uiaa->uiaa_product)) 282 return UMATCH_NONE; 283 284 error = usbd_device2interface_handle(uiaa->uiaa_device, 285 uiaa->uiaa_ifaceno, &iface); 286 if (error) { 287 printf("u3g_match: failed to get interface, err=%s\n", 288 usbd_errstr(error)); 289 return UMATCH_NONE; 290 } 291 292 id = usbd_get_interface_descriptor(iface); 293 if (id == NULL) { 294 printf("u3g_match: failed to get interface descriptor\n"); 295 return UMATCH_NONE; 296 } 297 298 /* 299 * Huawei modems use the vendor-specific class for all interfaces, 300 * both tty and CDC NCM, which we should avoid attaching to. 301 */ 302 if (uiaa->uiaa_vendor == USB_VENDOR_HUAWEI && 303 id->bInterfaceSubClass == 2 && 304 (id->bInterfaceProtocol & 0xf) == 6) /* 0x16, 0x46, 0x76 */ 305 return UMATCH_NONE; 306 307 /* 308 * 3G modems generally report vendor-specific class 309 * 310 * XXX: this may be too generalised. 311 */ 312 return id->bInterfaceClass == UICLASS_VENDOR ? 313 UMATCH_VENDOR_PRODUCT : UMATCH_NONE; 314 } 315 316 static void 317 u3g_attach(device_t parent, device_t self, void *aux) 318 { 319 struct u3g_softc *sc = device_private(self); 320 struct usbif_attach_arg *uiaa = aux; 321 struct usbd_device *dev = uiaa->uiaa_device; 322 struct usbd_interface *iface; 323 usb_interface_descriptor_t *id; 324 usb_endpoint_descriptor_t *ed; 325 struct ucom_attach_args ucaa; 326 usbd_status error; 327 int n, intr_address, intr_size; 328 329 aprint_naive("\n"); 330 aprint_normal("\n"); 331 332 sc->sc_dev = self; 333 sc->sc_dying = false; 334 sc->sc_udev = dev; 335 336 error = usbd_device2interface_handle(dev, uiaa->uiaa_ifaceno, &iface); 337 if (error) { 338 aprint_error_dev(self, "failed to get interface, err=%s\n", 339 usbd_errstr(error)); 340 return; 341 } 342 343 id = usbd_get_interface_descriptor(iface); 344 345 ucaa.ucaa_info = "3G Modem"; 346 ucaa.ucaa_ibufsize = U3G_BUFF_SIZE; 347 ucaa.ucaa_obufsize = U3G_BUFF_SIZE; 348 ucaa.ucaa_ibufsizepad = U3G_BUFF_SIZE; 349 ucaa.ucaa_opkthdrlen = 0; 350 ucaa.ucaa_device = dev; 351 ucaa.ucaa_iface = iface; 352 ucaa.ucaa_methods = &u3g_methods; 353 ucaa.ucaa_arg = sc; 354 ucaa.ucaa_portno = -1; 355 ucaa.ucaa_bulkin = ucaa.ucaa_bulkout = -1; 356 357 358 sc->sc_ifaceno = uiaa->uiaa_ifaceno; 359 intr_address = -1; 360 intr_size = 0; 361 362 for (n = 0; n < id->bNumEndpoints; n++) { 363 ed = usbd_interface2endpoint_descriptor(iface, n); 364 if (ed == NULL) { 365 aprint_error_dev(self, "no endpoint descriptor " 366 "for %d (interface: %d)\n", n, sc->sc_ifaceno); 367 sc->sc_dying = true; 368 return; 369 } 370 371 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 372 UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) { 373 intr_address = ed->bEndpointAddress; 374 intr_size = UGETW(ed->wMaxPacketSize); 375 } else 376 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 377 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 378 ucaa.ucaa_bulkin = ed->bEndpointAddress; 379 } else 380 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT && 381 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 382 ucaa.ucaa_bulkout = ed->bEndpointAddress; 383 } 384 if (ucaa.ucaa_bulkin != -1 && ucaa.ucaa_bulkout != -1) { 385 struct u3g_com *com; 386 if (sc->sc_ncom == __arraycount(sc->sc_com)) { 387 aprint_error_dev(self, "Need to configure " 388 "more than %zu ttys", sc->sc_ncom); 389 continue; 390 } 391 ucaa.ucaa_portno = sc->sc_ncom++; 392 com = &sc->sc_com[ucaa.ucaa_portno]; 393 com->c_outpins = 0; 394 com->c_msr = UMSR_DSR | UMSR_CTS | UMSR_DCD; 395 com->c_open = false; 396 com->c_purging = false; 397 com->c_dev = config_found_sm_loc(self, "ucombus", 398 NULL, &ucaa, ucomprint, ucomsubmatch); 399 ucaa.ucaa_bulkin = -1; 400 ucaa.ucaa_bulkout = -1; 401 } 402 } 403 404 if (sc->sc_ncom == 0) { 405 aprint_error_dev(self, "Missing bulk in/out for interface %d\n", 406 sc->sc_ifaceno); 407 sc->sc_dying = true; 408 return; 409 } 410 411 /* 412 * If the interface has an interrupt pipe, open it immediately so 413 * that we can track input pin state changes regardless of whether 414 * the tty(4) device is open or not. 415 */ 416 if (intr_address != -1) { 417 sc->sc_intr_size = intr_size; 418 sc->sc_intr_buff = kmem_alloc(intr_size, KM_SLEEP); 419 error = usbd_open_pipe_intr(iface, intr_address, 420 USBD_SHORT_XFER_OK, &sc->sc_intr_pipe, sc, sc->sc_intr_buff, 421 intr_size, u3g_intr, 100); 422 if (error) { 423 aprint_error_dev(self, "cannot open interrupt pipe " 424 "(addr %d)\n", intr_address); 425 return; 426 } 427 } else { 428 sc->sc_intr_pipe = NULL; 429 sc->sc_intr_buff = NULL; 430 } 431 432 if (!pmf_device_register(self, NULL, NULL)) 433 aprint_error_dev(self, "couldn't establish power handler\n"); 434 } 435 436 static int 437 u3g_detach(device_t self, int flags) 438 { 439 struct u3g_softc *sc = device_private(self); 440 int rv; 441 442 if (sc->sc_dying) 443 return 0; 444 445 pmf_device_deregister(self); 446 447 for (size_t i = 0; i < sc->sc_ncom; i++) 448 if (sc->sc_com[i].c_dev != NULL) { 449 rv = config_detach(sc->sc_com[i].c_dev, flags); 450 if (rv != 0) { 451 aprint_verbose_dev(self, "Can't deallocate " 452 "port (%d)", rv); 453 } 454 } 455 456 if (sc->sc_intr_pipe != NULL) { 457 (void) usbd_abort_pipe(sc->sc_intr_pipe); 458 (void) usbd_close_pipe(sc->sc_intr_pipe); 459 sc->sc_intr_pipe = NULL; 460 } 461 if (sc->sc_intr_buff != NULL) { 462 kmem_free(sc->sc_intr_buff, sc->sc_intr_size); 463 sc->sc_intr_buff = NULL; 464 } 465 466 return 0; 467 } 468 469 static void 470 u3g_childdet(device_t self, device_t child) 471 { 472 struct u3g_softc *sc = device_private(self); 473 474 for (size_t i = 0; i < sc->sc_ncom; i++) 475 if (sc->sc_com[i].c_dev == child) 476 sc->sc_com[i].c_dev = NULL; 477 } 478 479 static int 480 u3g_activate(device_t self, enum devact act) 481 { 482 struct u3g_softc *sc = device_private(self); 483 int rv = 0; 484 485 switch (act) { 486 case DVACT_DEACTIVATE: 487 for (size_t i = 0; i < sc->sc_ncom; i++) 488 if (sc->sc_com[i].c_dev != NULL && 489 config_deactivate(sc->sc_com[i].c_dev) && rv == 0) 490 rv = -1; 491 else 492 rv = 0; 493 break; 494 495 default: 496 break; 497 } 498 499 return rv; 500 } 501 502 static void 503 u3g_intr(struct usbd_xfer *xfer, void *priv, usbd_status status) 504 { 505 struct u3g_softc *sc = (struct u3g_softc *)priv; 506 u_char *buf; 507 int portno = 0; /* XXX */ 508 struct u3g_com *com = &sc->sc_com[portno]; 509 510 if (sc->sc_dying) 511 return; 512 513 if (status != USBD_NORMAL_COMPLETION) { 514 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) 515 return; 516 usbd_clear_endpoint_stall_async(sc->sc_intr_pipe); 517 return; 518 } 519 520 buf = sc->sc_intr_buff; 521 if (buf[0] == 0xa1 && buf[1] == 0x20) { 522 u_char msr; 523 524 msr = com->c_msr & ~(UMSR_DCD | UMSR_DSR | UMSR_RI); 525 526 if (buf[8] & U3G_INPIN_DCD) 527 msr |= UMSR_DCD; 528 529 if (buf[8] & U3G_INPIN_DSR) 530 msr |= UMSR_DSR; 531 532 if (buf[8] & U3G_INPIN_RI) 533 msr |= UMSR_RI; 534 535 if (msr != com->c_msr) { 536 com->c_msr = msr; 537 if (com->c_open) 538 ucom_status_change(device_private(com->c_dev)); 539 } 540 } 541 } 542 543 /*ARGSUSED*/ 544 static void 545 u3g_get_status(void *arg, int portno, u_char *lsr, u_char *msr) 546 { 547 struct u3g_softc *sc = arg; 548 549 if (lsr != NULL) 550 *lsr = 0; /* LSR isn't supported */ 551 if (msr != NULL) 552 *msr = sc->sc_com[portno].c_msr; 553 } 554 555 /*ARGSUSED*/ 556 static void 557 u3g_set(void *arg, int portno, int reg, int onoff) 558 { 559 struct u3g_softc *sc = arg; 560 usb_device_request_t req; 561 uint16_t mask, new_state; 562 usbd_status err; 563 struct u3g_com *com = &sc->sc_com[portno]; 564 565 if (sc->sc_dying) 566 return; 567 568 switch (reg) { 569 case UCOM_SET_DTR: 570 mask = U3G_OUTPIN_DTR; 571 break; 572 case UCOM_SET_RTS: 573 mask = U3G_OUTPIN_RTS; 574 break; 575 default: 576 return; 577 } 578 579 new_state = com->c_outpins & ~mask; 580 if (onoff) 581 new_state |= mask; 582 583 if (new_state == com->c_outpins) 584 return; 585 586 com->c_outpins = new_state; 587 588 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 589 req.bRequest = U3G_SET_PIN; 590 USETW(req.wValue, new_state); 591 USETW(req.wIndex, sc->sc_ifaceno); 592 USETW(req.wLength, 0); 593 594 err = usbd_do_request(sc->sc_udev, &req, 0); 595 if (err == USBD_STALLED) 596 usbd_clear_endpoint_stall(sc->sc_udev->ud_pipe0); 597 } 598 599 /*ARGSUSED*/ 600 static int 601 u3g_open(void *arg, int portno) 602 { 603 struct u3g_softc *sc = arg; 604 usb_device_request_t req; 605 usb_endpoint_descriptor_t *ed; 606 usb_interface_descriptor_t *id; 607 struct usbd_interface *ih; 608 usbd_status err; 609 struct u3g_com *com = &sc->sc_com[portno]; 610 int i, nin; 611 612 if (sc->sc_dying) 613 return 0; 614 615 err = usbd_device2interface_handle(sc->sc_udev, sc->sc_ifaceno, &ih); 616 if (err) 617 return EIO; 618 619 id = usbd_get_interface_descriptor(ih); 620 621 for (nin = i = 0; i < id->bNumEndpoints; i++) { 622 ed = usbd_interface2endpoint_descriptor(ih, i); 623 if (ed == NULL) 624 return EIO; 625 626 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 627 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK && 628 nin++ == portno) { 629 /* Issue ENDPOINT_HALT request */ 630 req.bmRequestType = UT_WRITE_ENDPOINT; 631 req.bRequest = UR_CLEAR_FEATURE; 632 USETW(req.wValue, UF_ENDPOINT_HALT); 633 USETW(req.wIndex, ed->bEndpointAddress); 634 USETW(req.wLength, 0); 635 err = usbd_do_request(sc->sc_udev, &req, 0); 636 if (err) 637 return EIO; 638 } 639 } 640 641 com->c_open = true; 642 com->c_purging = true; 643 getmicrotime(&com->c_purge_start); 644 645 return 0; 646 } 647 648 /*ARGSUSED*/ 649 static void 650 u3g_close(void *arg, int portno) 651 { 652 struct u3g_softc *sc = arg; 653 struct u3g_com *com = &sc->sc_com[portno]; 654 655 com->c_open = false; 656 } 657 658 /*ARGSUSED*/ 659 static void 660 u3g_read(void *arg, int portno, u_char **cpp, uint32_t *ccp) 661 { 662 struct u3g_softc *sc = arg; 663 struct timeval curr_tv, diff_tv; 664 struct u3g_com *com = &sc->sc_com[portno]; 665 666 /* 667 * If we're not purging input data following first open, do nothing. 668 */ 669 if (com->c_purging == false) 670 return; 671 672 /* 673 * Otherwise check if the purge timeout has expired 674 */ 675 getmicrotime(&curr_tv); 676 timersub(&curr_tv, &com->c_purge_start, &diff_tv); 677 678 if (diff_tv.tv_sec >= U3G_PURGE_SECS) { 679 /* Timeout expired. */ 680 com->c_purging = false; 681 } else { 682 /* Still purging. Adjust the caller's byte count. */ 683 *ccp = 0; 684 } 685 } 686 687 /*ARGSUSED*/ 688 static void 689 u3g_write(void *arg, int portno, u_char *to, u_char *from, uint32_t *count) 690 { 691 struct u3g_softc *sc = arg; 692 struct u3g_com *com = &sc->sc_com[portno]; 693 694 /* 695 * Stop purging as soon as the first data is written to the device. 696 */ 697 com->c_purging = false; 698 memcpy(to, from, *count); 699 } 700
Indexes created Tue Oct 14 01:09:49 GMT 2025