src/sys/dev/usbmisc/uftdi/uftdi.c - view

File: [DragonFly] / src / sys / dev / usbmisc / uftdi / uftdi.c
Revision 1.7: download - view: text, annotated - select for diffs
Mon Mar 15 02:27:56 2004 UTC (9 years, 2 months ago) by dillon
Branches: MAIN
CVS tags: HEAD, DragonFly_Stable, DragonFly_Snap29Sep2004, DragonFly_Snap13Sep2004, DragonFly_RELEASE_1_6_Slip, DragonFly_RELEASE_1_6, DragonFly_RELEASE_1_4_Slip, DragonFly_RELEASE_1_4, DragonFly_RELEASE_1_2_Slip, DragonFly_RELEASE_1_2, DragonFly_1_0_REL, DragonFly_1_0_RC1, DragonFly_1_0A_REL

Do some M_WAITOK<->M_INTWAIT cleanups.  Code entered from userland, such as
device open and device ioctl, generally use M_WAITOK, while low level
structures such as the capacity structure are allocated using M_INTWAIT.

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