uhmodem.c revision 1.15
1 /* $NetBSD: uhmodem.c,v 1.15 2016/11/25 12:56:29 skrll Exp $ */ 2 3 /* 4 * Copyright (c) 2008 Yojiro UO <yuo (at) nui.org>. 5 * All rights reserved. 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 MIND, USE, DATA OR PROFITS, WHETHER IN 16 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT 17 * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 /*- 20 * Copyright (c) 2002, Alexander Kabaev <kan.FreeBSD.org>. 21 * All rights reserved. 22 * 23 * Redistribution and use in source and binary forms, with or without 24 * modification, are permitted provided that the following conditions 25 * are met: 26 * 1. Redistributions of source code must retain the above copyright 27 * notice, this list of conditions and the following disclaimer. 28 * 2. Redistributions in binary form must reproduce the above copyright 29 * notice, this list of conditions and the following disclaimer in the 30 * documentation and/or other materials provided with the distribution. 31 * 32 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 33 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 34 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 35 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 36 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 40 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 41 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 42 * SUCH DAMAGE. 43 */ 44 /* 45 * Copyright (c) 2001 The NetBSD Foundation, Inc. 46 * All rights reserved. 47 * 48 * This code is derived from software contributed to The NetBSD Foundation 49 * by Ichiro FUKUHARA (ichiro (at) ichiro.org). 50 * 51 * Redistribution and use in source and binary forms, with or without 52 * modification, are permitted provided that the following conditions 53 * are met: 54 * 1. Redistributions of source code must retain the above copyright 55 * notice, this list of conditions and the following disclaimer. 56 * 2. Redistributions in binary form must reproduce the above copyright 57 * notice, this list of conditions and the following disclaimer in the 58 * documentation and/or other materials provided with the distribution. 59 * 60 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 61 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 62 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 63 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 64 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 65 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 66 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 67 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 68 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 69 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 70 * POSSIBILITY OF SUCH DAMAGE. 71 */ 72 73 #include <sys/cdefs.h> 74 __KERNEL_RCSID(0, "$NetBSD: uhmodem.c,v 1.15 2016/11/25 12:56:29 skrll Exp $"); 75 76 #ifdef _KERNEL_OPT 77 #include "opt_usb.h" 78 #endif 79 80 #include <sys/param.h> 81 #include <sys/systm.h> 82 #include <sys/kernel.h> 83 #include <sys/kmem.h> 84 #include <sys/ioccom.h> 85 #include <sys/fcntl.h> 86 #include <sys/conf.h> 87 #include <sys/tty.h> 88 #include <sys/file.h> 89 #include <sys/select.h> 90 #include <sys/proc.h> 91 #include <sys/device.h> 92 #include <sys/poll.h> 93 #include <sys/sysctl.h> 94 #include <sys/bus.h> 95 96 #include <dev/usb/usb.h> 97 #include <dev/usb/usbdi.h> 98 #include <dev/usb/usbdi_util.h> 99 #include <dev/usb/usbdivar.h> 100 101 #include <dev/usb/usbcdc.h> 102 #include <dev/usb/usbdevs.h> 103 #include <dev/usb/usb_quirks.h> 104 #include <dev/usb/ucomvar.h> 105 #include <dev/usb/ubsavar.h> 106 107 /* vendor specific bRequest */ 108 #define UHMODEM_REGWRITE 0x20 109 #define UHMODEM_REGREAD 0x21 110 #define UHMODEM_SETUP 0x22 111 112 #define UHMODEMIBUFSIZE 4096 113 #define UHMODEMOBUFSIZE 4096 114 115 #ifdef UHMODEM_DEBUG 116 Static int uhmodemdebug = 0; 117 #define DPRINTFN(n, x) do { \ 118 if (uhmodemdebug > (n)) \ 119 printf x; \ 120 } while (0) 121 #else 122 #define DPRINTFN(n, x) 123 #endif 124 #define DPRINTF(x) DPRINTFN(0, x) 125 126 Static int uhmodem_open(void *, int); 127 Static usbd_status e220_modechange_request(struct usbd_device *); 128 Static usbd_status uhmodem_endpointhalt(struct ubsa_softc *, int); 129 Static usbd_status uhmodem_regwrite(struct usbd_device *, uint8_t *, size_t); 130 Static usbd_status uhmodem_regread(struct usbd_device *, uint8_t *, size_t); 131 Static usbd_status a2502_init(struct usbd_device *); 132 #if 0 133 Static usbd_status uhmodem_regsetup(struct usbd_device *, uint16_t); 134 Static usbd_status e220_init(struct usbd_device *); 135 #endif 136 137 struct uhmodem_softc { 138 struct ubsa_softc sc_ubsa; 139 }; 140 141 struct ucom_methods uhmodem_methods = { 142 .ucom_get_status = ubsa_get_status, 143 .ucom_set = ubsa_set, 144 .ucom_param = ubsa_param, 145 .ucom_ioctl = NULL, 146 .ucom_open = uhmodem_open, 147 .ucom_close = ubsa_close, 148 .ucom_read = NULL, 149 .ucom_write = NULL 150 }; 151 152 struct uhmodem_type { 153 struct usb_devno uhmodem_dev; 154 uint16_t uhmodem_coms; /* number of serial interfaces on the device */ 155 uint16_t uhmodem_flags; 156 #define E220 0x0001 157 #define A2502 0x0002 158 #define E620 0x0004 /* XXX */ 159 /* Whether or not it is a device different from E220 is not clear. */ 160 }; 161 162 Static const struct uhmodem_type uhmodem_devs[] = { 163 /* HUAWEI E220 / Emobile D0[12]HW */ 164 {{ USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_E220 }, 2, E220}, 165 /* ANYDATA / NTT DoCoMo A2502 */ 166 {{ USB_VENDOR_ANYDATA, USB_PRODUCT_ANYDATA_A2502 }, 3, A2502}, 167 /* HUAWEI E620 */ 168 {{ USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_MOBILE }, 3, E620}, 169 }; 170 #define uhmodem_lookup(v, p) ((const struct uhmodem_type *)usb_lookup(uhmodem_devs, v, p)) 171 172 int uhmodem_match(device_t, cfdata_t, void *); 173 void uhmodem_attach(device_t, device_t, void *); 174 void uhmodem_childdet(device_t, device_t); 175 int uhmodem_detach(device_t, int); 176 int uhmodem_activate(device_t, enum devact); 177 extern struct cfdriver uhmodem_cd; 178 CFATTACH_DECL2_NEW(uhmodem, sizeof(struct uhmodem_softc), uhmodem_match, 179 uhmodem_attach, uhmodem_detach, uhmodem_activate, NULL, uhmodem_childdet); 180 181 int 182 uhmodem_match(device_t parent, cfdata_t match, void *aux) 183 { 184 struct usbif_attach_arg *uiaa = aux; 185 186 if (uhmodem_lookup(uiaa->uiaa_vendor, uiaa->uiaa_product) != NULL) 187 /* XXX interface# 0,1 provide modem function, but this driver 188 handles all modem in single device. */ 189 if (uiaa->uiaa_ifaceno == 0) 190 return UMATCH_VENDOR_PRODUCT; 191 return UMATCH_NONE; 192 } 193 194 void 195 uhmodem_attach(device_t parent, device_t self, void *aux) 196 { 197 struct uhmodem_softc *sc = device_private(self); 198 struct usbif_attach_arg *uiaa = aux; 199 struct usbd_device *dev = uiaa->uiaa_device; 200 usb_config_descriptor_t *cdesc; 201 usb_interface_descriptor_t *id; 202 usb_endpoint_descriptor_t *ed; 203 char *devinfop; 204 usbd_status err; 205 struct ucom_attach_args ucaa; 206 int i; 207 int j; 208 char comname[16]; 209 210 aprint_naive("\n"); 211 aprint_normal("\n"); 212 213 devinfop = usbd_devinfo_alloc(dev, 0); 214 aprint_normal_dev(self, "%s\n", devinfop); 215 usbd_devinfo_free(devinfop); 216 217 sc->sc_ubsa.sc_dev = self; 218 sc->sc_ubsa.sc_udev = dev; 219 sc->sc_ubsa.sc_config_index = UBSA_DEFAULT_CONFIG_INDEX; 220 sc->sc_ubsa.sc_numif = 1; /* defaut device has one interface */ 221 222 /* Hauwei E220 need special request to change its mode to modem */ 223 if ((uiaa->uiaa_ifaceno == 0) && (uiaa->uiaa_class != 255)) { 224 err = e220_modechange_request(dev); 225 if (err) { 226 aprint_error_dev(self, "failed to change mode: %s\n", 227 usbd_errstr(err)); 228 sc->sc_ubsa.sc_dying = 1; 229 goto error; 230 } 231 aprint_error_dev(self, 232 "mass storage only mode, reattach to enable modem\n"); 233 sc->sc_ubsa.sc_dying = 1; 234 goto error; 235 } 236 237 /* 238 * initialize rts, dtr variables to something 239 * different from boolean 0, 1 240 */ 241 sc->sc_ubsa.sc_dtr = -1; 242 sc->sc_ubsa.sc_rts = -1; 243 244 sc->sc_ubsa.sc_quadumts = 1; 245 sc->sc_ubsa.sc_config_index = 0; 246 sc->sc_ubsa.sc_numif = uhmodem_lookup(uiaa->uiaa_vendor, uiaa->uiaa_product)->uhmodem_coms; 247 sc->sc_ubsa.sc_devflags = uhmodem_lookup(uiaa->uiaa_vendor, uiaa->uiaa_product)->uhmodem_flags; 248 249 DPRINTF(("uhmodem attach: sc = %p\n", sc)); 250 251 /* Move the device into the configured state. */ 252 err = usbd_set_config_index(dev, sc->sc_ubsa.sc_config_index, 1); 253 if (err) { 254 aprint_error_dev(self, "failed to set configuration: %s\n", 255 usbd_errstr(err)); 256 sc->sc_ubsa.sc_dying = 1; 257 goto error; 258 } 259 260 /* get the config descriptor */ 261 cdesc = usbd_get_config_descriptor(sc->sc_ubsa.sc_udev); 262 if (cdesc == NULL) { 263 aprint_error_dev(self, 264 "failed to get configuration descriptor\n"); 265 sc->sc_ubsa.sc_dying = 1; 266 goto error; 267 } 268 269 sc->sc_ubsa.sc_intr_number = -1; 270 sc->sc_ubsa.sc_intr_pipe = NULL; 271 272 /* get the interfaces */ 273 for (i = 0; i < sc->sc_ubsa.sc_numif; i++) { 274 err = usbd_device2interface_handle(dev, UBSA_IFACE_INDEX_OFFSET+i, 275 &sc->sc_ubsa.sc_iface[i]); 276 if (err) { 277 if (i == 0){ 278 /* can not get main interface */ 279 sc->sc_ubsa.sc_dying = 1; 280 goto error; 281 } else 282 break; 283 } 284 285 /* Find the endpoints */ 286 id = usbd_get_interface_descriptor(sc->sc_ubsa.sc_iface[i]); 287 sc->sc_ubsa.sc_iface_number[i] = id->bInterfaceNumber; 288 289 /* initialize endpoints */ 290 ucaa.ucaa_bulkin = ucaa.ucaa_bulkout = -1; 291 292 for (j = 0; j < id->bNumEndpoints; j++) { 293 ed = usbd_interface2endpoint_descriptor( 294 sc->sc_ubsa.sc_iface[i], j); 295 if (ed == NULL) { 296 aprint_error_dev(self, 297 "no endpoint descriptor for %d " 298 "(interface: %d)\n", j, i); 299 break; 300 } 301 302 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 303 UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) { 304 sc->sc_ubsa.sc_intr_number = ed->bEndpointAddress; 305 sc->sc_ubsa.sc_isize = UGETW(ed->wMaxPacketSize); 306 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 307 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 308 ucaa.ucaa_bulkin = ed->bEndpointAddress; 309 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT && 310 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 311 ucaa.ucaa_bulkout = ed->bEndpointAddress; 312 } 313 } /* end of Endpoint loop */ 314 315 if (sc->sc_ubsa.sc_intr_number == -1) { 316 aprint_error_dev(self, "HUAWEI E220 need to re-attach " 317 "to enable modem function\n"); 318 if (i == 0) { 319 /* could not get intr for main tty */ 320 sc->sc_ubsa.sc_dying = 1; 321 goto error; 322 } else 323 break; 324 } 325 if (ucaa.ucaa_bulkin == -1) { 326 aprint_error_dev(self, 327 "Could not find data bulk in\n"); 328 sc->sc_ubsa.sc_dying = 1; 329 goto error; 330 } 331 332 if (ucaa.ucaa_bulkout == -1) { 333 aprint_error_dev(self, 334 "Could not find data bulk out\n"); 335 sc->sc_ubsa.sc_dying = 1; 336 goto error; 337 } 338 339 switch (i) { 340 case 0: 341 snprintf(comname, sizeof(comname), "modem"); 342 break; 343 case 1: 344 snprintf(comname, sizeof(comname), "alt#1"); 345 break; 346 case 2: 347 snprintf(comname, sizeof(comname), "alt#2"); 348 break; 349 default: 350 snprintf(comname, sizeof(comname), "int#%d", i); 351 break; 352 } 353 354 ucaa.ucaa_portno = i; 355 /* ucaa_bulkin, ucaa_bulkout set above */ 356 ucaa.ucaa_ibufsize = UHMODEMIBUFSIZE; 357 ucaa.ucaa_obufsize = UHMODEMOBUFSIZE; 358 ucaa.ucaa_ibufsizepad = UHMODEMIBUFSIZE; 359 ucaa.ucaa_opkthdrlen = 0; 360 ucaa.ucaa_device = dev; 361 ucaa.ucaa_iface = sc->sc_ubsa.sc_iface[i]; 362 ucaa.ucaa_methods = &uhmodem_methods; 363 ucaa.ucaa_arg = &sc->sc_ubsa; 364 ucaa.ucaa_info = comname; 365 DPRINTF(("uhmodem: int#=%d, in = 0x%x, out = 0x%x, intr = 0x%x\n", 366 i, ucaa.ucaa_bulkin, ucaa.ucaa_bulkout, 367 sc->sc_ubsa.sc_intr_number)); 368 sc->sc_ubsa.sc_subdevs[i] = config_found_sm_loc(self, "ucombus", NULL, 369 &ucaa, ucomprint, ucomsubmatch); 370 371 /* issue endpoint halt to each interface */ 372 err = uhmodem_endpointhalt(&sc->sc_ubsa, i); 373 if (err) 374 aprint_error("%s: endpointhalt fail\n", __func__); 375 else 376 usbd_delay_ms(sc->sc_ubsa.sc_udev, 50); 377 } /* end of Interface loop */ 378 379 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_ubsa.sc_udev, 380 sc->sc_ubsa.sc_dev); 381 382 return; 383 384 error: 385 return; 386 } 387 388 void 389 uhmodem_childdet(device_t self, device_t child) 390 { 391 int i; 392 struct uhmodem_softc *sc = device_private(self); 393 394 for (i = 0; i < sc->sc_ubsa.sc_numif; i++) { 395 if (sc->sc_ubsa.sc_subdevs[i] == child) 396 break; 397 } 398 KASSERT(i < sc->sc_ubsa.sc_numif); 399 sc->sc_ubsa.sc_subdevs[i] = NULL; 400 } 401 402 int 403 uhmodem_detach(device_t self, int flags) 404 { 405 struct uhmodem_softc *sc = device_private(self); 406 int i; 407 int rv = 0; 408 409 DPRINTF(("uhmodem_detach: sc = %p\n", sc)); 410 411 if (sc->sc_ubsa.sc_intr_pipe != NULL) { 412 usbd_abort_pipe(sc->sc_ubsa.sc_intr_pipe); 413 usbd_close_pipe(sc->sc_ubsa.sc_intr_pipe); 414 kmem_free(sc->sc_ubsa.sc_intr_buf, sc->sc_ubsa.sc_isize); 415 sc->sc_ubsa.sc_intr_pipe = NULL; 416 } 417 418 sc->sc_ubsa.sc_dying = 1; 419 for (i = 0; i < sc->sc_ubsa.sc_numif; i++) { 420 if (sc->sc_ubsa.sc_subdevs[i] != NULL) 421 rv |= config_detach(sc->sc_ubsa.sc_subdevs[i], flags); 422 } 423 424 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_ubsa.sc_udev, 425 sc->sc_ubsa.sc_dev); 426 427 return rv; 428 } 429 430 int 431 uhmodem_activate(device_t self, enum devact act) 432 { 433 struct uhmodem_softc *sc = device_private(self); 434 435 switch (act) { 436 case DVACT_DEACTIVATE: 437 sc->sc_ubsa.sc_dying = 1; 438 return 0; 439 default: 440 return EOPNOTSUPP; 441 } 442 } 443 444 Static int 445 uhmodem_open(void *addr, int portno) 446 { 447 struct ubsa_softc *sc = addr; 448 usbd_status err; 449 450 if (sc->sc_dying) 451 return ENXIO; 452 453 DPRINTF(("%s: sc = %p\n", __func__, sc)); 454 455 err = uhmodem_endpointhalt(sc, 0); 456 if (err) 457 aprint_error("%s: endpointhalt fail\n", __func__); 458 else 459 usbd_delay_ms(sc->sc_udev, 50); 460 461 if (sc->sc_devflags & A2502) { 462 err = a2502_init(sc->sc_udev); 463 if (err) 464 aprint_error("%s: a2502init fail\n", __func__); 465 else 466 usbd_delay_ms(sc->sc_udev, 50); 467 } 468 #if 0 /* currently disabled */ 469 if (sc->sc_devflags & E220) { 470 err = e220_init(sc->sc_udev); 471 if (err) 472 aprint_error("%s: e220init fail\n", __func__); 473 else 474 usbd_delay_ms(sc->sc_udev, 50); 475 } 476 #endif 477 if (sc->sc_intr_number != -1 && sc->sc_intr_pipe == NULL) { 478 sc->sc_intr_buf = kmem_alloc(sc->sc_isize, KM_SLEEP); 479 /* XXX only iface# = 0 has intr line */ 480 /* XXX E220 specific? need to check */ 481 err = usbd_open_pipe_intr(sc->sc_iface[0], 482 sc->sc_intr_number, 483 USBD_SHORT_XFER_OK, 484 &sc->sc_intr_pipe, 485 sc, 486 sc->sc_intr_buf, 487 sc->sc_isize, 488 ubsa_intr, 489 UBSA_INTR_INTERVAL); 490 if (err) { 491 aprint_error_dev(sc->sc_dev, 492 "cannot open interrupt pipe (addr %d)\n", 493 sc->sc_intr_number); 494 return EIO; 495 } 496 } 497 498 return 0; 499 } 500 501 /* 502 * Hauwei E220 needs special request to enable modem function. 503 * -- DEVICE_REMOTE_WAKEUP ruquest to endpoint 2. 504 */ 505 Static usbd_status 506 e220_modechange_request(struct usbd_device *dev) 507 { 508 #define E220_MODE_CHANGE_REQUEST 0x2 509 usb_device_request_t req; 510 usbd_status err; 511 512 req.bmRequestType = UT_WRITE_DEVICE; 513 req.bRequest = UR_SET_FEATURE; 514 USETW(req.wValue, UF_DEVICE_REMOTE_WAKEUP); 515 USETW(req.wIndex, E220_MODE_CHANGE_REQUEST); 516 USETW(req.wLength, 0); 517 518 DPRINTF(("%s: send e220 mode change request\n", __func__)); 519 err = usbd_do_request(dev, &req, 0); 520 if (err) { 521 DPRINTF(("%s: E220 mode change fail\n", __func__)); 522 return EIO; 523 } 524 525 return 0; 526 #undef E220_MODE_CHANGE_REQUEST 527 } 528 529 Static usbd_status 530 uhmodem_endpointhalt(struct ubsa_softc *sc, int iface) 531 { 532 usb_device_request_t req; 533 usb_endpoint_descriptor_t *ed; 534 usb_interface_descriptor_t *id; 535 usbd_status err; 536 int i; 537 538 /* Find the endpoints */ 539 id = usbd_get_interface_descriptor(sc->sc_iface[iface]); 540 541 for (i = 0; i < id->bNumEndpoints; i++) { 542 ed = usbd_interface2endpoint_descriptor(sc->sc_iface[iface], i); 543 if (ed == NULL) 544 return EIO; 545 546 if (UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { 547 /* issue ENDPOINT_HALT request */ 548 req.bmRequestType = UT_WRITE_ENDPOINT; 549 req.bRequest = UR_CLEAR_FEATURE; 550 USETW(req.wValue, UF_ENDPOINT_HALT); 551 USETW(req.wIndex, ed->bEndpointAddress); 552 USETW(req.wLength, 0); 553 err = usbd_do_request(sc->sc_udev, &req, 0); 554 if (err) { 555 DPRINTF(("%s: ENDPOINT_HALT to EP:%d fail\n", 556 __func__, ed->bEndpointAddress)); 557 return EIO; 558 } 559 560 } 561 } /* end of Endpoint loop */ 562 563 return 0; 564 } 565 566 Static usbd_status 567 uhmodem_regwrite(struct usbd_device *dev, uint8_t *data, size_t len) 568 { 569 usb_device_request_t req; 570 usbd_status err; 571 572 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 573 req.bRequest = UHMODEM_REGWRITE; 574 USETW(req.wValue, 0x0000); 575 USETW(req.wIndex, 0x0000); 576 USETW(req.wLength, len); 577 err = usbd_do_request(dev, &req, data); 578 if (err) 579 return err; 580 581 return 0; 582 } 583 584 Static usbd_status 585 uhmodem_regread(struct usbd_device *dev, uint8_t *data, size_t len) 586 { 587 usb_device_request_t req; 588 usbd_status err; 589 590 req.bmRequestType = UT_READ_CLASS_INTERFACE; 591 req.bRequest = UHMODEM_REGREAD; 592 USETW(req.wValue, 0x0000); 593 USETW(req.wIndex, 0x0000); 594 USETW(req.wLength, len); 595 err = usbd_do_request(dev, &req, data); 596 597 if (err) 598 return err; 599 600 return 0; 601 } 602 603 #if 0 604 Static usbd_status 605 uhmodem_regsetup(struct usbd_device *dev, uint16_t cmd) 606 { 607 usb_device_request_t req; 608 usbd_status err; 609 610 req.bmRequestType = UT_READ_CLASS_INTERFACE; 611 req.bRequest = UHMODEM_SETUP; 612 USETW(req.wValue, cmd); 613 USETW(req.wIndex, 0x0000); 614 USETW(req.wLength, 0); 615 err = usbd_do_request(dev, &req, 0); 616 617 if (err) 618 return err; 619 620 return 0; 621 } 622 #endif 623 624 Static usbd_status 625 a2502_init(struct usbd_device *dev) 626 { 627 uint8_t data[8]; 628 static uint8_t init_cmd[] = {0x00, 0xE1, 0x00, 0x00, 0x00, 0x00, 0x08}; 629 #ifdef UHMODEM_DEBUG 630 int i; 631 #endif 632 if (uhmodem_regread(dev, data, 7)) { 633 DPRINTF(("%s: read fail\n", __func__)); 634 return EIO; 635 } 636 #ifdef UHMODEM_DEBUG 637 printf("%s: readdata: ", __func__); 638 for (i = 0; i < 7; i++) 639 printf("0x%x ", data[i]); 640 #endif 641 if (uhmodem_regwrite(dev, init_cmd, sizeof(init_cmd)) ) { 642 DPRINTF(("%s: write fail\n", __func__)); 643 return EIO; 644 } 645 646 if (uhmodem_regread(dev, data, 7)) { 647 DPRINTF(("%s: read fail\n", __func__)); 648 return EIO; 649 } 650 #ifdef UHMODEM_DEBUG 651 printf("%s: readdata: ", __func__); 652 printf(" => "); 653 for (i = 0; i < 7; i++) 654 printf("0x%x ", data[i]); 655 printf("\n"); 656 #endif 657 return 0; 658 } 659 660 661 #if 0 662 /* 663 * Windows device driver send these sequens of USB requests. 664 * However currently I can't understand what the messege is, 665 * disable this code when I get more information about it. 666 */ 667 Static usbd_status 668 e220_init(struct usbd_device *dev) 669 { 670 uint8_t data[8]; 671 usb_device_request_t req; 672 int i; 673 674 /* vendor specific unknown request */ 675 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 676 req.bRequest = 0x02; 677 USETW(req.wValue, 0x0001); 678 USETW(req.wIndex, 0x0000); 679 USETW(req.wLength, 2); 680 data[0] = 0x0; 681 data[1] = 0x0; 682 if (usbd_do_request(dev, &req, data)) 683 goto error; 684 685 /* vendor specific unknown sequence */ 686 if(uhmodem_regsetup(dev, 0x1)) 687 goto error; 688 689 if (uhmodem_regread(dev, data, 7)) 690 goto error; 691 692 data[1] = 0x8; 693 data[2] = 0x7; 694 if (uhmodem_regwrite(dev, data, sizeof(data)) ) 695 goto error; 696 697 if (uhmodem_regread(dev, data, 7)) 698 goto error; 699 /* XXX should verify the read data ? */ 700 701 if (uhmodem_regsetup(dev, 0x3)) 702 goto error; 703 704 return 0; 705 error: 706 DPRINTF(("%s: E220 init request fail\n", __func__)); 707 return EIO; 708 } 709 #endif 710 711
Indexes created Fri Sep 26 20:09:58 GMT 2025