Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/dev/usb/uftdi.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /* $NetBSD: uftdi.c,v 1.13 2002/09/23 05:51:23 simonb Exp $ */ 2 3 /*- 4 * Copyright (c) 2000 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Lennart Augustsson (lennart@augustsson.net). 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include <sys/cdefs.h> 40 __FBSDID("$FreeBSD: releng/7.3/sys/dev/usb/uftdi.c 170987 2007-06-22 05:53:05Z imp $"); 41 42 /* 43 * FTDI FT8U100AX serial adapter driver 44 */ 45 46 #include <sys/cdefs.h> 47 48 #include <sys/param.h> 49 #include <sys/systm.h> 50 #include <sys/kernel.h> 51 #include <sys/malloc.h> 52 #include <sys/module.h> 53 #include <sys/bus.h> 54 #include <sys/ioccom.h> 55 #include <sys/fcntl.h> 56 #include <sys/conf.h> 57 #include <sys/tty.h> 58 #include <sys/file.h> 59 60 #include <sys/selinfo.h> 61 62 #include <sys/sysctl.h> 63 64 #include <dev/usb/usb.h> 65 #include <dev/usb/usbhid.h> 66 67 #include <dev/usb/usbdi.h> 68 #include <dev/usb/usbdi_util.h> 69 #include "usbdevs.h" 70 71 #include <dev/usb/ucomvar.h> 72 73 #include <dev/usb/uftdireg.h> 74 75 #ifdef USB_DEBUG 76 static int uftdidebug = 0; 77 SYSCTL_NODE(_hw_usb, OID_AUTO, uftdi, CTLFLAG_RW, 0, "USB uftdi"); 78 SYSCTL_INT(_hw_usb_uftdi, OID_AUTO, debug, CTLFLAG_RW, 79 &uftdidebug, 0, "uftdi debug level"); 80 #define DPRINTF(x) do { \ 81 if (uftdidebug) \ 82 printf x; \ 83 } while (0) 84 85 #define DPRINTFN(n, x) do { \ 86 if (uftdidebug > (n)) \ 87 printf x; \ 88 } while (0) 89 90 #else 91 #define DPRINTF(x) 92 #define DPRINTFN(n,x) 93 #endif 94 95 #define UFTDI_CONFIG_INDEX 0 96 #define UFTDI_IFACE_INDEX 0 97 98 99 /* 100 * These are the maximum number of bytes transferred per frame. 101 * The output buffer size cannot be increased due to the size encoding. 102 */ 103 #define UFTDIIBUFSIZE 64 104 #define UFTDIOBUFSIZE 64 105 106 struct uftdi_softc { 107 struct ucom_softc sc_ucom; 108 usbd_interface_handle sc_iface; /* interface */ 109 enum uftdi_type sc_type; 110 u_int sc_hdrlen; 111 u_char sc_msr; 112 u_char sc_lsr; 113 u_int last_lcr; 114 }; 115 116 static void uftdi_get_status(void *, int portno, u_char *lsr, u_char *msr); 117 static void uftdi_set(void *, int, int, int); 118 static int uftdi_param(void *, int, struct termios *); 119 static int uftdi_open(void *sc, int portno); 120 static void uftdi_read(void *sc, int portno, u_char **ptr,u_int32_t *count); 121 static void uftdi_write(void *sc, int portno, u_char *to, u_char *from, 122 u_int32_t *count); 123 static void uftdi_break(void *sc, int portno, int onoff); 124 125 struct ucom_callback uftdi_callback = { 126 uftdi_get_status, 127 uftdi_set, 128 uftdi_param, 129 NULL, 130 uftdi_open, 131 NULL, 132 uftdi_read, 133 uftdi_write, 134 }; 135 136 static int 137 uftdi_match(device_t self) 138 { 139 struct usb_attach_arg *uaa = device_get_ivars(self); 140 141 if (uaa->iface != NULL) { 142 if (uaa->vendor == USB_VENDOR_FTDI && 143 (uaa->product == USB_PRODUCT_FTDI_SERIAL_2232C)) 144 return (UMATCH_VENDOR_IFACESUBCLASS); 145 return (UMATCH_NONE); 146 } 147 148 DPRINTFN(20,("uftdi: vendor=0x%x, product=0x%x\n", 149 uaa->vendor, uaa->product)); 150 151 if (uaa->vendor == USB_VENDOR_FTDI && 152 (uaa->product == USB_PRODUCT_FTDI_SERIAL_8U100AX || 153 uaa->product == USB_PRODUCT_FTDI_SERIAL_8U232AM || 154 uaa->product == USB_PRODUCT_FTDI_SEMC_DSS20 || 155 uaa->product == USB_PRODUCT_FTDI_CFA_631 || 156 uaa->product == USB_PRODUCT_FTDI_CFA_632 || 157 uaa->product == USB_PRODUCT_FTDI_CFA_633 || 158 uaa->product == USB_PRODUCT_FTDI_CFA_634 || 159 uaa->product == USB_PRODUCT_FTDI_CFA_635 || 160 uaa->product == USB_PRODUCT_FTDI_USBSERIAL || 161 uaa->product == USB_PRODUCT_FTDI_MX2_3 || 162 uaa->product == USB_PRODUCT_FTDI_MX4_5 || 163 uaa->product == USB_PRODUCT_FTDI_LK202 || 164 uaa->product == USB_PRODUCT_FTDI_LK204 || 165 uaa->product == USB_PRODUCT_FTDI_TACTRIX_OPENPORT_13M || 166 uaa->product == USB_PRODUCT_FTDI_TACTRIX_OPENPORT_13S || 167 uaa->product == USB_PRODUCT_FTDI_TACTRIX_OPENPORT_13U || 168 uaa->product == USB_PRODUCT_FTDI_EISCOU || 169 uaa->product == USB_PRODUCT_FTDI_UOPTBR || 170 uaa->product == USB_PRODUCT_FTDI_EMCU2D || 171 uaa->product == USB_PRODUCT_FTDI_PCMSFU || 172 uaa->product == USB_PRODUCT_FTDI_EMCU2H )) 173 return (UMATCH_VENDOR_PRODUCT); 174 if (uaa->vendor == USB_VENDOR_SIIG2 && 175 (uaa->product == USB_PRODUCT_SIIG2_US2308)) 176 return (UMATCH_VENDOR_PRODUCT); 177 if (uaa->vendor == USB_VENDOR_INTREPIDCS && 178 (uaa->product == USB_PRODUCT_INTREPIDCS_VALUECAN || 179 uaa->product == USB_PRODUCT_INTREPIDCS_NEOVI)) 180 return (UMATCH_VENDOR_PRODUCT); 181 if (uaa->vendor == USB_VENDOR_BBELECTRONICS && 182 (uaa->product == USB_PRODUCT_BBELECTRONICS_USOTL4)) 183 return (UMATCH_VENDOR_PRODUCT); 184 if (uaa->vendor == USB_VENDOR_MELCO && 185 (uaa->product == USB_PRODUCT_MELCO_PCOPRS1)) 186 return (UMATCH_VENDOR_PRODUCT); 187 188 return (UMATCH_NONE); 189 } 190 191 static int 192 uftdi_attach(device_t self) 193 { 194 struct uftdi_softc *sc = device_get_softc(self); 195 struct usb_attach_arg *uaa = device_get_ivars(self); 196 usbd_device_handle dev = uaa->device; 197 usbd_interface_handle iface; 198 usb_interface_descriptor_t *id; 199 usb_endpoint_descriptor_t *ed; 200 int i; 201 usbd_status err; 202 struct ucom_softc *ucom = &sc->sc_ucom; 203 DPRINTFN(10,("\nuftdi_attach: sc=%p\n", sc)); 204 205 ucom->sc_dev = self; 206 ucom->sc_udev = dev; 207 208 if (uaa->iface == NULL) { 209 /* Move the device into the configured state. */ 210 err = usbd_set_config_index(dev, UFTDI_CONFIG_INDEX, 1); 211 if (err) { 212 device_printf(ucom->sc_dev, 213 "failed to set configuration, err=%s\n", 214 usbd_errstr(err)); 215 goto bad; 216 } 217 218 err = usbd_device2interface_handle(dev, UFTDI_IFACE_INDEX, &iface); 219 if (err) { 220 device_printf(ucom->sc_dev, 221 "failed to get interface, err=%s\n", usbd_errstr(err)); 222 goto bad; 223 } 224 } else { 225 iface = uaa->iface; 226 } 227 228 id = usbd_get_interface_descriptor(iface); 229 ucom->sc_iface = iface; 230 switch( uaa->vendor ){ 231 case USB_VENDOR_FTDI: 232 switch( uaa->product ){ 233 case USB_PRODUCT_FTDI_SERIAL_8U100AX: 234 sc->sc_type = UFTDI_TYPE_SIO; 235 sc->sc_hdrlen = 1; 236 break; 237 case USB_PRODUCT_FTDI_SEMC_DSS20: 238 case USB_PRODUCT_FTDI_SERIAL_8U232AM: 239 case USB_PRODUCT_FTDI_SERIAL_2232C: 240 case USB_PRODUCT_FTDI_CFA_631: 241 case USB_PRODUCT_FTDI_CFA_632: 242 case USB_PRODUCT_FTDI_CFA_633: 243 case USB_PRODUCT_FTDI_CFA_634: 244 case USB_PRODUCT_FTDI_CFA_635: 245 case USB_PRODUCT_FTDI_USBSERIAL: 246 case USB_PRODUCT_FTDI_MX2_3: 247 case USB_PRODUCT_FTDI_MX4_5: 248 case USB_PRODUCT_FTDI_LK202: 249 case USB_PRODUCT_FTDI_LK204: 250 case USB_PRODUCT_FTDI_TACTRIX_OPENPORT_13M: 251 case USB_PRODUCT_FTDI_TACTRIX_OPENPORT_13S: 252 case USB_PRODUCT_FTDI_TACTRIX_OPENPORT_13U: 253 case USB_PRODUCT_FTDI_EISCOU: 254 case USB_PRODUCT_FTDI_UOPTBR: 255 case USB_PRODUCT_FTDI_EMCU2D: 256 case USB_PRODUCT_FTDI_PCMSFU: 257 case USB_PRODUCT_FTDI_EMCU2H: 258 sc->sc_type = UFTDI_TYPE_8U232AM; 259 sc->sc_hdrlen = 0; 260 break; 261 262 default: /* Can't happen */ 263 goto bad; 264 } 265 break; 266 267 case USB_VENDOR_INTREPIDCS: 268 switch( uaa->product ){ 269 case USB_PRODUCT_INTREPIDCS_VALUECAN: 270 case USB_PRODUCT_INTREPIDCS_NEOVI: 271 sc->sc_type = UFTDI_TYPE_8U232AM; 272 sc->sc_hdrlen = 0; 273 break; 274 275 default: /* Can't happen */ 276 goto bad; 277 } 278 break; 279 280 case USB_VENDOR_SIIG2: 281 switch( uaa->product ){ 282 case USB_PRODUCT_SIIG2_US2308: 283 sc->sc_type = UFTDI_TYPE_8U232AM; 284 sc->sc_hdrlen = 0; 285 break; 286 287 default: /* Can't happen */ 288 goto bad; 289 } 290 break; 291 292 case USB_VENDOR_BBELECTRONICS: 293 switch( uaa->product ){ 294 case USB_PRODUCT_BBELECTRONICS_USOTL4: 295 sc->sc_type = UFTDI_TYPE_8U232AM; 296 sc->sc_hdrlen = 0; 297 break; 298 299 default: /* Can't happen */ 300 goto bad; 301 } 302 break; 303 304 case USB_VENDOR_MELCO: 305 switch( uaa->product ){ 306 case USB_PRODUCT_MELCO_PCOPRS1: 307 sc->sc_type = UFTDI_TYPE_8U232AM; 308 sc->sc_hdrlen = 0; 309 break; 310 311 default: /* Can't happen */ 312 goto bad; 313 } 314 break; 315 316 default: /* Can't happen */ 317 goto bad; 318 } 319 320 ucom->sc_bulkin_no = ucom->sc_bulkout_no = -1; 321 322 for (i = 0; i < id->bNumEndpoints; i++) { 323 int addr, dir, attr; 324 ed = usbd_interface2endpoint_descriptor(iface, i); 325 if (ed == NULL) { 326 device_printf(ucom->sc_dev, 327 "could not read endpoint descriptor\n"); 328 goto bad; 329 } 330 331 addr = ed->bEndpointAddress; 332 dir = UE_GET_DIR(ed->bEndpointAddress); 333 attr = ed->bmAttributes & UE_XFERTYPE; 334 if (dir == UE_DIR_IN && attr == UE_BULK) 335 ucom->sc_bulkin_no = addr; 336 else if (dir == UE_DIR_OUT && attr == UE_BULK) 337 ucom->sc_bulkout_no = addr; 338 else { 339 device_printf(ucom->sc_dev, "unexpected endpoint\n"); 340 goto bad; 341 } 342 } 343 if (ucom->sc_bulkin_no == -1) { 344 device_printf(ucom->sc_dev, "Could not find data bulk in\n"); 345 goto bad; 346 } 347 if (ucom->sc_bulkout_no == -1) { 348 device_printf(ucom->sc_dev, "Could not find data bulk out\n"); 349 goto bad; 350 } 351 ucom->sc_parent = sc; 352 if (uaa->iface == NULL) 353 ucom->sc_portno = FTDI_PIT_SIOA; 354 else 355 ucom->sc_portno = FTDI_PIT_SIOA + id->bInterfaceNumber; 356 /* bulkin, bulkout set above */ 357 358 ucom->sc_ibufsize = UFTDIIBUFSIZE; 359 ucom->sc_obufsize = UFTDIOBUFSIZE - sc->sc_hdrlen; 360 ucom->sc_ibufsizepad = UFTDIIBUFSIZE; 361 ucom->sc_opkthdrlen = sc->sc_hdrlen; 362 363 364 ucom->sc_callback = &uftdi_callback; 365 #if 0 366 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, ucom->sc_udev, 367 ucom->sc_dev); 368 #endif 369 DPRINTF(("uftdi: in=0x%x out=0x%x\n", ucom->sc_bulkin_no, ucom->sc_bulkout_no)); 370 ucom_attach(&sc->sc_ucom); 371 return 0; 372 373 bad: 374 DPRINTF(("uftdi_attach: ATTACH ERROR\n")); 375 ucom->sc_dying = 1; 376 return ENXIO; 377 } 378 #if 0 379 int 380 uftdi_activate(device_t self, enum devact act) 381 { 382 struct uftdi_softc *sc = (struct uftdi_softc *)self; 383 int rv = 0; 384 385 switch (act) { 386 case DVACT_ACTIVATE: 387 return (EOPNOTSUPP); 388 389 case DVACT_DEACTIVATE: 390 if (sc->sc_subdev != NULL) 391 rv = config_deactivate(sc->sc_subdev); 392 sc->sc_ucom.sc_dying = 1; 393 break; 394 } 395 return (rv); 396 } 397 #endif 398 399 static int 400 uftdi_detach(device_t self) 401 { 402 struct uftdi_softc *sc = device_get_softc(self); 403 404 int rv = 0; 405 406 DPRINTF(("uftdi_detach: sc=%p\n", sc)); 407 sc->sc_ucom.sc_dying = 1; 408 rv = ucom_detach(&sc->sc_ucom); 409 410 return rv; 411 } 412 413 static int 414 uftdi_open(void *vsc, int portno) 415 { 416 struct uftdi_softc *sc = vsc; 417 struct ucom_softc *ucom = &sc->sc_ucom; 418 usb_device_request_t req; 419 usbd_status err; 420 struct termios t; 421 422 DPRINTF(("uftdi_open: sc=%p\n", sc)); 423 424 if (ucom->sc_dying) 425 return (EIO); 426 427 /* Perform a full reset on the device */ 428 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 429 req.bRequest = FTDI_SIO_RESET; 430 USETW(req.wValue, FTDI_SIO_RESET_SIO); 431 USETW(req.wIndex, portno); 432 USETW(req.wLength, 0); 433 err = usbd_do_request(ucom->sc_udev, &req, NULL); 434 if (err) 435 return (EIO); 436 437 /* Set 9600 baud, 2 stop bits, no parity, 8 bits */ 438 t.c_ospeed = 9600; 439 t.c_cflag = CSTOPB | CS8; 440 (void)uftdi_param(sc, portno, &t); 441 442 /* Turn on RTS/CTS flow control */ 443 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 444 req.bRequest = FTDI_SIO_SET_FLOW_CTRL; 445 USETW(req.wValue, 0); 446 USETW2(req.wIndex, FTDI_SIO_RTS_CTS_HS, portno); 447 USETW(req.wLength, 0); 448 err = usbd_do_request(ucom->sc_udev, &req, NULL); 449 if (err) 450 return (EIO); 451 452 return (0); 453 } 454 455 static void 456 uftdi_read(void *vsc, int portno, u_char **ptr, u_int32_t *count) 457 { 458 struct uftdi_softc *sc = vsc; 459 u_char msr, lsr; 460 461 DPRINTFN(15,("uftdi_read: sc=%p, port=%d count=%d\n", sc, portno, 462 *count)); 463 464 msr = FTDI_GET_MSR(*ptr); 465 lsr = FTDI_GET_LSR(*ptr); 466 467 #ifdef USB_DEBUG 468 if (*count != 2) 469 DPRINTFN(10,("uftdi_read: sc=%p, port=%d count=%d data[0]=" 470 "0x%02x\n", sc, portno, *count, (*ptr)[2])); 471 #endif 472 473 if (sc->sc_msr != msr || 474 (sc->sc_lsr & FTDI_LSR_MASK) != (lsr & FTDI_LSR_MASK)) { 475 DPRINTF(("uftdi_read: status change msr=0x%02x(0x%02x) " 476 "lsr=0x%02x(0x%02x)\n", msr, sc->sc_msr, 477 lsr, sc->sc_lsr)); 478 sc->sc_msr = msr; 479 sc->sc_lsr = lsr; 480 ucom_status_change(&sc->sc_ucom); 481 } 482 483 /* Pick up status and adjust data part. */ 484 *ptr += 2; 485 *count -= 2; 486 } 487 488 static void 489 uftdi_write(void *vsc, int portno, u_char *to, u_char *from, u_int32_t *count) 490 { 491 struct uftdi_softc *sc = vsc; 492 493 DPRINTFN(10,("uftdi_write: sc=%p, port=%d count=%u data[0]=0x%02x\n", 494 vsc, portno, *count, from[0])); 495 496 /* Make length tag and copy data */ 497 if (sc->sc_hdrlen > 0) 498 *to = FTDI_OUT_TAG(*count, portno); 499 500 memcpy(to + sc->sc_hdrlen, from, *count); 501 *count += sc->sc_hdrlen; 502 } 503 504 static void 505 uftdi_set(void *vsc, int portno, int reg, int onoff) 506 { 507 struct uftdi_softc *sc = vsc; 508 struct ucom_softc *ucom = vsc; 509 usb_device_request_t req; 510 int ctl; 511 512 DPRINTF(("uftdi_set: sc=%p, port=%d reg=%d onoff=%d\n", vsc, portno, 513 reg, onoff)); 514 515 switch (reg) { 516 case UCOM_SET_DTR: 517 ctl = onoff ? FTDI_SIO_SET_DTR_HIGH : FTDI_SIO_SET_DTR_LOW; 518 break; 519 case UCOM_SET_RTS: 520 ctl = onoff ? FTDI_SIO_SET_RTS_HIGH : FTDI_SIO_SET_RTS_LOW; 521 break; 522 case UCOM_SET_BREAK: 523 uftdi_break(sc, portno, onoff); 524 return; 525 default: 526 return; 527 } 528 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 529 req.bRequest = FTDI_SIO_MODEM_CTRL; 530 USETW(req.wValue, ctl); 531 USETW(req.wIndex, portno); 532 USETW(req.wLength, 0); 533 DPRINTFN(2,("uftdi_set: reqtype=0x%02x req=0x%02x value=0x%04x " 534 "index=0x%04x len=%d\n", req.bmRequestType, req.bRequest, 535 UGETW(req.wValue), UGETW(req.wIndex), UGETW(req.wLength))); 536 (void)usbd_do_request(ucom->sc_udev, &req, NULL); 537 } 538 539 static int 540 uftdi_param(void *vsc, int portno, struct termios *t) 541 { 542 struct uftdi_softc *sc = vsc; 543 struct ucom_softc *ucom = &sc->sc_ucom; 544 usb_device_request_t req; 545 usbd_status err; 546 int rate=0, data, flow; 547 548 DPRINTF(("uftdi_param: sc=%p\n", sc)); 549 550 if (ucom->sc_dying) 551 return (EIO); 552 553 switch (sc->sc_type) { 554 case UFTDI_TYPE_SIO: 555 switch (t->c_ospeed) { 556 case 300: rate = ftdi_sio_b300; break; 557 case 600: rate = ftdi_sio_b600; break; 558 case 1200: rate = ftdi_sio_b1200; break; 559 case 2400: rate = ftdi_sio_b2400; break; 560 case 4800: rate = ftdi_sio_b4800; break; 561 case 9600: rate = ftdi_sio_b9600; break; 562 case 19200: rate = ftdi_sio_b19200; break; 563 case 38400: rate = ftdi_sio_b38400; break; 564 case 57600: rate = ftdi_sio_b57600; break; 565 case 115200: rate = ftdi_sio_b115200; break; 566 default: 567 return (EINVAL); 568 } 569 break; 570 571 case UFTDI_TYPE_8U232AM: 572 switch(t->c_ospeed) { 573 case 300: rate = ftdi_8u232am_b300; break; 574 case 600: rate = ftdi_8u232am_b600; break; 575 case 1200: rate = ftdi_8u232am_b1200; break; 576 case 2400: rate = ftdi_8u232am_b2400; break; 577 case 4800: rate = ftdi_8u232am_b4800; break; 578 case 9600: rate = ftdi_8u232am_b9600; break; 579 case 19200: rate = ftdi_8u232am_b19200; break; 580 case 38400: rate = ftdi_8u232am_b38400; break; 581 case 57600: rate = ftdi_8u232am_b57600; break; 582 case 115200: rate = ftdi_8u232am_b115200; break; 583 case 230400: rate = ftdi_8u232am_b230400; break; 584 case 460800: rate = ftdi_8u232am_b460800; break; 585 case 921600: rate = ftdi_8u232am_b921600; break; 586 case 2000000: rate = ftdi_8u232am_b2000000; break; 587 case 3000000: rate = ftdi_8u232am_b3000000; break; 588 default: 589 return (EINVAL); 590 } 591 break; 592 } 593 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 594 req.bRequest = FTDI_SIO_SET_BAUD_RATE; 595 USETW(req.wValue, rate); 596 USETW(req.wIndex, portno); 597 USETW(req.wLength, 0); 598 DPRINTFN(2,("uftdi_param: reqtype=0x%02x req=0x%02x value=0x%04x " 599 "index=0x%04x len=%d\n", req.bmRequestType, req.bRequest, 600 UGETW(req.wValue), UGETW(req.wIndex), UGETW(req.wLength))); 601 err = usbd_do_request(ucom->sc_udev, &req, NULL); 602 if (err) 603 return (EIO); 604 605 if (ISSET(t->c_cflag, CSTOPB)) 606 data = FTDI_SIO_SET_DATA_STOP_BITS_2; 607 else 608 data = FTDI_SIO_SET_DATA_STOP_BITS_1; 609 if (ISSET(t->c_cflag, PARENB)) { 610 if (ISSET(t->c_cflag, PARODD)) 611 data |= FTDI_SIO_SET_DATA_PARITY_ODD; 612 else 613 data |= FTDI_SIO_SET_DATA_PARITY_EVEN; 614 } else 615 data |= FTDI_SIO_SET_DATA_PARITY_NONE; 616 switch (ISSET(t->c_cflag, CSIZE)) { 617 case CS5: 618 data |= FTDI_SIO_SET_DATA_BITS(5); 619 break; 620 case CS6: 621 data |= FTDI_SIO_SET_DATA_BITS(6); 622 break; 623 case CS7: 624 data |= FTDI_SIO_SET_DATA_BITS(7); 625 break; 626 case CS8: 627 data |= FTDI_SIO_SET_DATA_BITS(8); 628 break; 629 } 630 sc->last_lcr = data; 631 632 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 633 req.bRequest = FTDI_SIO_SET_DATA; 634 USETW(req.wValue, data); 635 USETW(req.wIndex, portno); 636 USETW(req.wLength, 0); 637 DPRINTFN(2,("uftdi_param: reqtype=0x%02x req=0x%02x value=0x%04x " 638 "index=0x%04x len=%d\n", req.bmRequestType, req.bRequest, 639 UGETW(req.wValue), UGETW(req.wIndex), UGETW(req.wLength))); 640 err = usbd_do_request(ucom->sc_udev, &req, NULL); 641 if (err) 642 return (EIO); 643 644 if (ISSET(t->c_cflag, CRTSCTS)) { 645 flow = FTDI_SIO_RTS_CTS_HS; 646 USETW(req.wValue, 0); 647 } else if (ISSET(t->c_iflag, IXON|IXOFF)) { 648 flow = FTDI_SIO_XON_XOFF_HS; 649 USETW2(req.wValue, t->c_cc[VSTOP], t->c_cc[VSTART]); 650 } else { 651 flow = FTDI_SIO_DISABLE_FLOW_CTRL; 652 USETW(req.wValue, 0); 653 } 654 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 655 req.bRequest = FTDI_SIO_SET_FLOW_CTRL; 656 USETW2(req.wIndex, flow, portno); 657 USETW(req.wLength, 0); 658 err = usbd_do_request(ucom->sc_udev, &req, NULL); 659 if (err) 660 return (EIO); 661 662 return (0); 663 } 664 665 void 666 uftdi_get_status(void *vsc, int portno, u_char *lsr, u_char *msr) 667 { 668 struct uftdi_softc *sc = vsc; 669 670 DPRINTF(("uftdi_status: msr=0x%02x lsr=0x%02x\n", 671 sc->sc_msr, sc->sc_lsr)); 672 673 if (msr != NULL) 674 *msr = sc->sc_msr; 675 if (lsr != NULL) 676 *lsr = sc->sc_lsr; 677 } 678 679 void 680 uftdi_break(void *vsc, int portno, int onoff) 681 { 682 struct uftdi_softc *sc = vsc; 683 struct ucom_softc *ucom = vsc; 684 685 usb_device_request_t req; 686 int data; 687 688 DPRINTF(("uftdi_break: sc=%p, port=%d onoff=%d\n", vsc, portno, 689 onoff)); 690 691 if (onoff) { 692 data = sc->last_lcr | FTDI_SIO_SET_BREAK; 693 } else { 694 data = sc->last_lcr; 695 } 696 697 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 698 req.bRequest = FTDI_SIO_SET_DATA; 699 USETW(req.wValue, data); 700 USETW(req.wIndex, portno); 701 USETW(req.wLength, 0); 702 (void)usbd_do_request(ucom->sc_udev, &req, NULL); 703 } 704 705 static device_method_t uftdi_methods[] = { 706 /* Device interface */ 707 DEVMETHOD(device_probe, uftdi_match), 708 DEVMETHOD(device_attach, uftdi_attach), 709 DEVMETHOD(device_detach, uftdi_detach), 710 711 { 0, 0 } 712 }; 713 714 static driver_t uftdi_driver = { 715 "ucom", 716 uftdi_methods, 717 sizeof (struct uftdi_softc) 718 }; 719 720 DRIVER_MODULE(uftdi, uhub, uftdi_driver, ucom_devclass, usbd_driver_load, 0); 721 MODULE_DEPEND(uftdi, usb, 1, 1, 1); 722 MODULE_DEPEND(uftdi, ucom,UCOM_MINVER, UCOM_PREFVER, UCOM_MAXVER);
Cache object: ef53fa295e0e3f58dbf03108ece8a447
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]