root/dev/usb/uplcom.c

DEFINITIONS

1. uplcom_match
2. uplcom_attach
3. uplcom_detach
4. uplcom_activate
5. uplcom_reset
6. uplcom_set_line_state
7. uplcom_set
8. uplcom_dtr
9. uplcom_rts
10. uplcom_break
11. uplcom_set_crtscts
12. uplcom_set_line_coding
13. uplcom_param
14. uplcom_open
15. uplcom_close
16. uplcom_intr
17. uplcom_get_status
18. uplcom_ioctl

    1 /*      $OpenBSD: uplcom.c,v 1.43 2007/06/14 10:11:16 mbalmer Exp $     */
    2 /*      $NetBSD: uplcom.c,v 1.29 2002/09/23 05:51:23 simonb Exp $       */
    3 /*
    4  * Copyright (c) 2001 The NetBSD Foundation, Inc.
    5  * All rights reserved.
    6  *
    7  * This code is derived from software contributed to The NetBSD Foundation
    8  * by Ichiro FUKUHARA (ichiro@ichiro.org).
    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  */
   39 /*
   40  * Simple datasheet
   41  * http://www.prolific.com.tw/PDF/PL-2303%20Market%20Spec.pdf
   42  * http://www.hitachi-hitec.com/jyouhou/prolific/2303.pdf
   43  *      (english)
   44  *
   45  */
   47 #include <sys/param.h>
   48 #include <sys/systm.h>
   49 #include <sys/kernel.h>
   50 #include <sys/malloc.h>
   51 #include <sys/ioctl.h>
   52 #include <sys/conf.h>
   53 #include <sys/tty.h>
   54 #include <sys/file.h>
   55 #include <sys/selinfo.h>
   56 #include <sys/proc.h>
   57 #include <sys/vnode.h>
   58 #include <sys/device.h>
   59 #include <sys/poll.h>
   61 #include <dev/usb/usb.h>
   62 #include <dev/usb/usbcdc.h>
   64 #include <dev/usb/usbdi.h>
   65 #include <dev/usb/usbdi_util.h>
   66 #include <dev/usb/usbdevs.h>
   67 #include <dev/usb/usb_quirks.h>
   69 #include <dev/usb/usbdevs.h>
   70 #include <dev/usb/ucomvar.h>
   72 #ifdef UPLCOM_DEBUG
   73 #define DPRINTFN(n, x)  do { if (uplcomdebug > (n)) printf x; } while (0)
   74 int     uplcomdebug = 0;
   75 #else
   76 #define DPRINTFN(n, x)
   77 #endif
   78 #define DPRINTF(x) DPRINTFN(0, x)
   80 #define UPLCOM_CONFIG_INDEX     0
   81 #define UPLCOM_IFACE_INDEX      0
   82 #define UPLCOM_SECOND_IFACE_INDEX       1
   84 #define UPLCOM_SET_REQUEST      0x01
   85 #define UPLCOM_SET_CRTSCTS      0x41
   86 #define UPLCOM_HX_SET_CRTSCTS   0x61
   87 #define RSAQ_STATUS_CTS         0x80
   88 #define RSAQ_STATUS_DSR         0x02
   89 #define RSAQ_STATUS_DCD         0x01
   91 struct  uplcom_softc {
   92         struct device            sc_dev;        /* base device */
usbd_device_handle       sc_udev;       /* USB device */
usbd_interface_handle    sc_iface;      /* interface */
   95         int                      sc_iface_number;       /* interface number */
usbd_interface_handle    sc_intr_iface; /* interrupt interface */
   98         int                      sc_intr_number;        /* interrupt number */
usbd_pipe_handle         sc_intr_pipe;  /* interrupt pipe */
u_char                  *sc_intr_buf;   /* interrupt buffer */
  101         int                      sc_isize;
usb_cdc_line_state_t     sc_line_state; /* current line state */
  104         int                      sc_dtr;        /* current DTR state */
  105         int                      sc_rts;        /* current RTS state */
  107         struct device           *sc_subdev;     /* ucom device */
u_char                   sc_dying;      /* disconnecting */
u_char                   sc_lsr;        /* Local status register */
u_char                   sc_msr;        /* uplcom status register */
  113         int                      sc_type_hx;    /* HX variant */
  114 };
  116 /*
  117  * These are the maximum number of bytes transferred per frame.
  118  * The output buffer size cannot be increased due to the size encoding.
  119  */
  120 #define UPLCOMIBUFSIZE 256
  121 #define UPLCOMOBUFSIZE 256
usbd_status uplcom_reset(struct uplcom_softc *);
usbd_status uplcom_set_line_coding(struct uplcom_softc *sc,
usb_cdc_line_state_t *state);
usbd_status uplcom_set_crtscts(struct uplcom_softc *);
  127 void uplcom_intr(usbd_xfer_handle, usbd_private_handle, usbd_status);
  129 void uplcom_set(void *, int, int, int);
  130 void uplcom_dtr(struct uplcom_softc *, int);
  131 void uplcom_rts(struct uplcom_softc *, int);
  132 void uplcom_break(struct uplcom_softc *, int);
  133 void uplcom_set_line_state(struct uplcom_softc *);
  134 void uplcom_get_status(void *, int portno, u_char *lsr, u_char *msr);
  135 #if TODO
  136 int  uplcom_ioctl(void *, int, u_long, caddr_t, int, struct proc *);
  137 #endif
  138 int  uplcom_param(void *, int, struct termios *);
  139 int  uplcom_open(void *, int);
  140 void uplcom_close(void *, int);
  142 struct  ucom_methods uplcom_methods = {
uplcom_get_status,
uplcom_set,
uplcom_param,
NULL, /* uplcom_ioctl, TODO */
uplcom_open,
uplcom_close,
NULL,
NULL,
  151 };
  153 static const struct usb_devno uplcom_devs[] = {
  154         { USB_VENDOR_ALCATEL, USB_PRODUCT_ALCATEL_OT535 },
  155         { USB_VENDOR_ANCHOR, USB_PRODUCT_ANCHOR_SERIAL },
  156         { USB_VENDOR_ATEN, USB_PRODUCT_ATEN_UC232A },
  157         { USB_VENDOR_BELKIN, USB_PRODUCT_BELKIN_F5U257 },
  158         { USB_VENDOR_ELECOM, USB_PRODUCT_ELECOM_UCSGT },
  159         { USB_VENDOR_ELECOM, USB_PRODUCT_ELECOM_UCSGT0 },
  160         { USB_VENDOR_HAL, USB_PRODUCT_HAL_IMR001 },
  161         { USB_VENDOR_IODATA, USB_PRODUCT_IODATA_USBRSAQ },
  162         { USB_VENDOR_LEADTEK, USB_PRODUCT_LEADTEK_9531 },
  163         { USB_VENDOR_MOBILEACTION, USB_PRODUCT_MOBILEACTION_MA620 },
  164         { USB_VENDOR_NOKIA, USB_PRODUCT_NOKIA_CA42 },
  165         { USB_VENDOR_OTI, USB_PRODUCT_OTI_DKU5 },
  166         { USB_VENDOR_PLX, USB_PRODUCT_PLX_CA42 },
  167         { USB_VENDOR_PANASONIC, USB_PRODUCT_PANASONIC_TYTP50P6S },
  168         { USB_VENDOR_PROLIFIC, USB_PRODUCT_PROLIFIC_PL2303 },
  169         { USB_VENDOR_PROLIFIC, USB_PRODUCT_PROLIFIC_PL2303X },
  170         { USB_VENDOR_PROLIFIC, USB_PRODUCT_PROLIFIC_PL2303X2 },
  171         { USB_VENDOR_PROLIFIC, USB_PRODUCT_PROLIFIC_RSAQ2 },
  172         { USB_VENDOR_PROLIFIC2, USB_PRODUCT_PROLIFIC2_PL2303 },
  173         { USB_VENDOR_RADIOSHACK, USB_PRODUCT_RADIOSHACK_PL2303 },
  174         { USB_VENDOR_RATOC, USB_PRODUCT_RATOC_REXUSB60 },
  175         { USB_VENDOR_SAGEM, USB_PRODUCT_SAGEM_SERIAL },
  176         { USB_VENDOR_SAMSUNG2, USB_PRODUCT_SAMSUNG2_I330 },
  177         { USB_VENDOR_SIEMENS3, USB_PRODUCT_SIEMENS3_SX1 },
  178         { USB_VENDOR_SIEMENS3, USB_PRODUCT_SIEMENS3_X65 },
  179         { USB_VENDOR_SIEMENS3, USB_PRODUCT_SIEMENS3_X75 },
  180         { USB_VENDOR_SITECOM, USB_PRODUCT_SITECOM_CN104 },
  181         { USB_VENDOR_SOURCENEXT, USB_PRODUCT_SOURCENEXT_KEIKAI8 },
  182         { USB_VENDOR_SOURCENEXT, USB_PRODUCT_SOURCENEXT_KEIKAI8_CHG },
  183         { USB_VENDOR_SPEEDDRAGON, USB_PRODUCT_SPEEDDRAGON_MS3303H },
  184         { USB_VENDOR_SUSTEEN, USB_PRODUCT_SUSTEEN_DCU11 },
  185         { USB_VENDOR_SYNTECH, USB_PRODUCT_SYNTECH_SERIAL },
  186         { USB_VENDOR_TDK, USB_PRODUCT_TDK_UHA6400 },
  187         { USB_VENDOR_TDK, USB_PRODUCT_TDK_UPA9664 },
  188         { USB_VENDOR_TRIPPLITE, USB_PRODUCT_TRIPPLITE_U209 }
  189 };
  190 #define uplcom_lookup(v, p) usb_lookup(uplcom_devs, v, p)
  192 int uplcom_match(struct device *, void *, void *); 
  193 void uplcom_attach(struct device *, struct device *, void *); 
  194 int uplcom_detach(struct device *, int); 
  195 int uplcom_activate(struct device *, enum devact); 
  197 struct cfdriver uplcom_cd = { 
NULL, "uplcom", DV_DULL 
  199 }; 
  201 const struct cfattach uplcom_ca = { 
  202         sizeof(struct uplcom_softc), 
uplcom_match, 
uplcom_attach, 
uplcom_detach, 
uplcom_activate, 
  207 };
  209 int
uplcom_match(struct device *parent, void *match, void *aux)
  211 {
  212         struct usb_attach_arg *uaa = aux;
  214         if (uaa->iface != NULL)
  215                 return (UMATCH_NONE);
  217         return (uplcom_lookup(uaa->vendor, uaa->product) != NULL ?
UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
  219 }
  221 void
uplcom_attach(struct device *parent, struct device *self, void *aux)
  223 {
  224         struct uplcom_softc *sc = (struct uplcom_softc *)self;
  225         struct usb_attach_arg *uaa = aux;
usbd_device_handle dev = uaa->device;
usb_config_descriptor_t *cdesc;
usb_device_descriptor_t *ddesc;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
  232         char *devinfop;
  233         char *devname = sc->sc_dev.dv_xname;
usbd_status err;
  235         int i;
  236         struct ucom_attach_args uca;
devinfop = usbd_devinfo_alloc(dev, 0);
printf("\n%s: %s\n", devname, devinfop);
usbd_devinfo_free(devinfop);
sc->sc_udev = dev;
DPRINTF(("\n\nuplcom attach: sc=%p\n", sc));
  246         /* initialize endpoints */
uca.bulkin = uca.bulkout = -1;
sc->sc_intr_number = -1;
sc->sc_intr_pipe = NULL;
  251         /* Move the device into the configured state. */
err = usbd_set_config_index(dev, UPLCOM_CONFIG_INDEX, 1);
  253         if (err) {
printf("\n%s: failed to set configuration, err=%s\n",
devname, usbd_errstr(err));
sc->sc_dying = 1;
  257                 return;
  258         }
  260         /* get the config descriptor */
cdesc = usbd_get_config_descriptor(sc->sc_udev);
  263         if (cdesc == NULL) {
printf("%s: failed to get configuration descriptor\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
  267                 return;
  268         }
  270         /* get the device descriptor */
ddesc = usbd_get_device_descriptor(sc->sc_udev);
  272         if (ddesc == NULL) {
printf("%s: failed to get device descriptor\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
  276                 return;
  277         }
  279         /*
  280          * The Linux driver suggest this will only be true for the HX
  281          * variants. The datasheets disagree.
  282          */
  283         if (ddesc->bMaxPacketSize == 0x40) {
DPRINTF(("%s: Assuming HX variant\n", sc->sc_dev.dv_xname));
sc->sc_type_hx = 1;
  286         } else
sc->sc_type_hx = 0;
  289         /* get the (first/common) interface */
err = usbd_device2interface_handle(dev, UPLCOM_IFACE_INDEX,
  291                                                         &sc->sc_iface);
  292         if (err) {
printf("\n%s: failed to get interface, err=%s\n",
devname, usbd_errstr(err));
sc->sc_dying = 1;
  296                 return;
  297         }
  299         /* Find the interrupt endpoints */
id = usbd_get_interface_descriptor(sc->sc_iface);
sc->sc_iface_number = id->bInterfaceNumber;
  304         for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
  306                 if (ed == NULL) {
printf("%s: no endpoint descriptor for %d\n",
sc->sc_dev.dv_xname, i);
sc->sc_dying = 1;
  310                         return;
  311                 }
  313                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->sc_intr_number = ed->bEndpointAddress;
sc->sc_isize = UGETW(ed->wMaxPacketSize);
  317                 }
  318         }
  320         if (sc->sc_intr_number== -1) {
printf("%s: Could not find interrupt in\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
  324                 return;
  325         }
  327         /* keep interface for interrupt */
sc->sc_intr_iface = sc->sc_iface;
  330         /*
  331          * USB-RSAQ1 has two interface
  332          *
  333          *  USB-RSAQ1       | USB-RSAQ2
  334          * -----------------+-----------------
  335          * Interface 0      |Interface 0
  336          *  Interrupt(0x81) | Interrupt(0x81)
  337          * -----------------+ BulkIN(0x02)
  338          * Interface 1      | BulkOUT(0x83)
  339          *   BulkIN(0x02)   |
  340          *   BulkOUT(0x83)  |
  341          */
  342         if (cdesc->bNumInterface == 2) {
err = usbd_device2interface_handle(dev,
UPLCOM_SECOND_IFACE_INDEX, &sc->sc_iface);
  345                 if (err) {
printf("\n%s: failed to get second interface, err=%s\n",
devname, usbd_errstr(err));
sc->sc_dying = 1;
  349                         return;
  350                 }
  351         }
  353         /* Find the bulk{in,out} endpoints */
id = usbd_get_interface_descriptor(sc->sc_iface);
sc->sc_iface_number = id->bInterfaceNumber;
  358         for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
  360                 if (ed == NULL) {
printf("%s: no endpoint descriptor for %d\n",
sc->sc_dev.dv_xname, i);
sc->sc_dying = 1;
  364                         return;
  365                 }
  367                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
uca.bulkin = ed->bEndpointAddress;
  370                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
uca.bulkout = ed->bEndpointAddress;
  373                 }
  374         }
  376         if (uca.bulkin == -1) {
printf("%s: Could not find data bulk in\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
  380                 return;
  381         }
  383         if (uca.bulkout == -1) {
printf("%s: Could not find data bulk out\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
  387                 return;
  388         }
sc->sc_dtr = sc->sc_rts = -1;
uca.portno = UCOM_UNK_PORTNO;
  392         /* bulkin, bulkout set above */
uca.ibufsize = UPLCOMIBUFSIZE;
uca.obufsize = UPLCOMOBUFSIZE;
uca.ibufsizepad = UPLCOMIBUFSIZE;
uca.opkthdrlen = 0;
uca.device = dev;
uca.iface = sc->sc_iface;
uca.methods = &uplcom_methods;
uca.arg = sc;
uca.info = NULL;
err = uplcom_reset(sc);
  405         if (err) {
printf("%s: reset failed, %s\n", sc->sc_dev.dv_xname,
usbd_errstr(err));
sc->sc_dying = 1;
  409                 return;
  410         }
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
  413                            &sc->sc_dev);
DPRINTF(("uplcom: in=0x%x out=0x%x intr=0x%x\n",
uca.bulkin, uca.bulkout, sc->sc_intr_number ));
sc->sc_subdev = config_found_sm(self, &uca, ucomprint, ucomsubmatch);
  418 }
  420 int
uplcom_detach(struct device *self, int flags)
  422 {
  423         struct uplcom_softc *sc = (struct uplcom_softc *)self;
  424         int rv = 0;
DPRINTF(("uplcom_detach: sc=%p flags=%d\n", sc, flags));
  428         if (sc->sc_intr_pipe != NULL) {
usbd_abort_pipe(sc->sc_intr_pipe);
usbd_close_pipe(sc->sc_intr_pipe);
free(sc->sc_intr_buf, M_USBDEV);
sc->sc_intr_pipe = NULL;
  433         }
sc->sc_dying = 1;
  436         if (sc->sc_subdev != NULL) {
rv = config_detach(sc->sc_subdev, flags);
sc->sc_subdev = NULL;
  439         }
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
  442                            &sc->sc_dev);
  444         return (rv);
  445 }
  447 int
uplcom_activate(struct device *self, enum devact act)
  449 {
  450         struct uplcom_softc *sc = (struct uplcom_softc *)self;
  451         int rv = 0;
  453         switch (act) {
  454         case DVACT_ACTIVATE:
  455                 break;
  457         case DVACT_DEACTIVATE:
  458                 if (sc->sc_subdev != NULL)
rv = config_deactivate(sc->sc_subdev);
sc->sc_dying = 1;
  461                 break;
  462         }
  463         return (rv);
  464 }
usbd_status
uplcom_reset(struct uplcom_softc *sc)
  468 {
usb_device_request_t req;
usbd_status err;
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req.bRequest = UPLCOM_SET_REQUEST;
USETW(req.wValue, 0);
USETW(req.wIndex, sc->sc_iface_number);
USETW(req.wLength, 0);
err = usbd_do_request(sc->sc_udev, &req, 0);
  479         if (err)
  480                 return (EIO);
  482         return (0);
  483 }
  485 void
uplcom_set_line_state(struct uplcom_softc *sc)
  487 {
usb_device_request_t req;
  489         int ls;
  491         /* Make sure we have initialized state for sc_dtr and sc_rts */
  492         if (sc->sc_dtr == -1)
sc->sc_dtr = 0;
  494         if (sc->sc_rts == -1)
sc->sc_rts = 0;
ls = (sc->sc_dtr ? UCDC_LINE_DTR : 0) |
  498             (sc->sc_rts ? UCDC_LINE_RTS : 0);
req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req.bRequest = UCDC_SET_CONTROL_LINE_STATE;
USETW(req.wValue, ls);
USETW(req.wIndex, sc->sc_iface_number);
USETW(req.wLength, 0);
  506         (void)usbd_do_request(sc->sc_udev, &req, 0);
  508 }
  510 void
uplcom_set(void *addr, int portno, int reg, int onoff)
  512 {
  513         struct uplcom_softc *sc = addr;
  515         switch (reg) {
  516         case UCOM_SET_DTR:
uplcom_dtr(sc, onoff);
  518                 break;
  519         case UCOM_SET_RTS:
uplcom_rts(sc, onoff);
  521                 break;
  522         case UCOM_SET_BREAK:
uplcom_break(sc, onoff);
  524                 break;
  525         default:
  526                 break;
  527         }
  528 }
  530 void
uplcom_dtr(struct uplcom_softc *sc, int onoff)
  532 {
DPRINTF(("uplcom_dtr: onoff=%d\n", onoff));
  536         if (sc->sc_dtr != -1 && !sc->sc_dtr == !onoff)
  537                 return;
sc->sc_dtr = !!onoff;
uplcom_set_line_state(sc);
  542 }
  544 void
uplcom_rts(struct uplcom_softc *sc, int onoff)
  546 {
DPRINTF(("uplcom_rts: onoff=%d\n", onoff));
  549         if (sc->sc_rts == -1 && !sc->sc_rts == !onoff)
  550                 return;
sc->sc_rts = !!onoff;
uplcom_set_line_state(sc);
  555 }
  557 void
uplcom_break(struct uplcom_softc *sc, int onoff)
  559 {
usb_device_request_t req;
DPRINTF(("uplcom_break: onoff=%d\n", onoff));
req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req.bRequest = UCDC_SEND_BREAK;
USETW(req.wValue, onoff ? UCDC_BREAK_ON : UCDC_BREAK_OFF);
USETW(req.wIndex, sc->sc_iface_number);
USETW(req.wLength, 0);
  570         (void)usbd_do_request(sc->sc_udev, &req, 0);
  571 }
usbd_status
uplcom_set_crtscts(struct uplcom_softc *sc)
  575 {
usb_device_request_t req;
usbd_status err;
DPRINTF(("uplcom_set_crtscts: on\n"));
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req.bRequest = UPLCOM_SET_REQUEST;
USETW(req.wValue, 0);
USETW(req.wIndex,
  585             (sc->sc_type_hx ? UPLCOM_HX_SET_CRTSCTS : UPLCOM_SET_CRTSCTS));
USETW(req.wLength, 0);
err = usbd_do_request(sc->sc_udev, &req, 0);
  589         if (err) {
DPRINTF(("uplcom_set_crtscts: failed, err=%s\n",
usbd_errstr(err)));
  592                 return (err);
  593         }
  595         return (USBD_NORMAL_COMPLETION);
  596 }
usbd_status
uplcom_set_line_coding(struct uplcom_softc *sc, usb_cdc_line_state_t *state)
  600 {
usb_device_request_t req;
usbd_status err;
DPRINTF(("uplcom_set_line_coding: rate=%d fmt=%d parity=%d bits=%d\n",
UGETDW(state->dwDTERate), state->bCharFormat,
state->bParityType, state->bDataBits));
  608         if (memcmp(state, &sc->sc_line_state, UCDC_LINE_STATE_LENGTH) == 0) {
DPRINTF(("uplcom_set_line_coding: already set\n"));
  610                 return (USBD_NORMAL_COMPLETION);
  611         }
req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req.bRequest = UCDC_SET_LINE_CODING;
USETW(req.wValue, 0);
USETW(req.wIndex, sc->sc_iface_number);
USETW(req.wLength, UCDC_LINE_STATE_LENGTH);
err = usbd_do_request(sc->sc_udev, &req, state);
  620         if (err) {
DPRINTF(("uplcom_set_line_coding: failed, err=%s\n",
usbd_errstr(err)));
  623                 return (err);
  624         }
sc->sc_line_state = *state;
  628         return (USBD_NORMAL_COMPLETION);
  629 }
  631 int
uplcom_param(void *addr, int portno, struct termios *t)
  633 {
  634         struct uplcom_softc *sc = addr;
usbd_status err;
usb_cdc_line_state_t ls;
DPRINTF(("uplcom_param: sc=%p\n", sc));
USETDW(ls.dwDTERate, t->c_ospeed);
  641         if (ISSET(t->c_cflag, CSTOPB))
ls.bCharFormat = UCDC_STOP_BIT_2;
  643         else
ls.bCharFormat = UCDC_STOP_BIT_1;
  645         if (ISSET(t->c_cflag, PARENB)) {
  646                 if (ISSET(t->c_cflag, PARODD))
ls.bParityType = UCDC_PARITY_ODD;
  648                 else
ls.bParityType = UCDC_PARITY_EVEN;
  650         } else
ls.bParityType = UCDC_PARITY_NONE;
  652         switch (ISSET(t->c_cflag, CSIZE)) {
  653         case CS5:
ls.bDataBits = 5;
  655                 break;
  656         case CS6:
ls.bDataBits = 6;
  658                 break;
  659         case CS7:
ls.bDataBits = 7;
  661                 break;
  662         case CS8:
ls.bDataBits = 8;
  664                 break;
  665         }
err = uplcom_set_line_coding(sc, &ls);
  668         if (err) {
DPRINTF(("uplcom_param: err=%s\n", usbd_errstr(err)));
  670                 return (EIO);
  671         }
  673         if (ISSET(t->c_cflag, CRTSCTS))
uplcom_set_crtscts(sc);
  676         if (sc->sc_rts == -1 || sc->sc_dtr == -1)
uplcom_set_line_state(sc);
  679         if (err) {
DPRINTF(("uplcom_param: err=%s\n", usbd_errstr(err)));
  681                 return (EIO);
  682         }
  684         return (0);
  685 }
  687 int
uplcom_open(void *addr, int portno)
  689 {
  690         struct uplcom_softc *sc = addr;
usb_device_request_t req;
usbd_status uerr;
  693         int err;
  695         if (sc->sc_dying)
  696                 return (EIO);
DPRINTF(("uplcom_open: sc=%p\n", sc));
  700         if (sc->sc_intr_number != -1 && sc->sc_intr_pipe == NULL) {
sc->sc_intr_buf = malloc(sc->sc_isize, M_USBDEV, M_WAITOK);
err = usbd_open_pipe_intr(sc->sc_intr_iface, sc->sc_intr_number,
USBD_SHORT_XFER_OK, &sc->sc_intr_pipe, sc,
sc->sc_intr_buf, sc->sc_isize,
uplcom_intr, USBD_DEFAULT_INTERVAL);
  706                 if (err) {
DPRINTF(("%s: cannot open interrupt pipe (addr %d)\n",
sc->sc_dev.dv_xname, sc->sc_intr_number));
  709                                         return (EIO);
  710                 }
  711         }
  713         if (sc->sc_type_hx == 1) {
  714                 /*
  715                  * Undocumented (vendor unresponsive) - possibly changes
  716                  * flow control semantics. It is needed for HX variant devices.
  717                  */
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req.bRequest = UPLCOM_SET_REQUEST;
USETW(req.wValue, 2);
USETW(req.wIndex, 0x44);
USETW(req.wLength, 0);
uerr = usbd_do_request(sc->sc_udev, &req, 0);
  725                 if (uerr)
  726                         return (EIO);
  728                 /* Reset upstream data pipes */
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req.bRequest = UPLCOM_SET_REQUEST;
USETW(req.wValue, 8);
USETW(req.wIndex, 0);
USETW(req.wLength, 0);
uerr = usbd_do_request(sc->sc_udev, &req, 0);
  736                 if (uerr)
  737                         return (EIO);
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req.bRequest = UPLCOM_SET_REQUEST;
USETW(req.wValue, 9);
USETW(req.wIndex, 0);
USETW(req.wLength, 0);
uerr = usbd_do_request(sc->sc_udev, &req, 0);
  746                 if (uerr)
  747                         return (EIO);
  748         }
  750         return (0);
  751 }
  753 void
uplcom_close(void *addr, int portno)
  755 {
  756         struct uplcom_softc *sc = addr;
  757         int err;
  759         if (sc->sc_dying)
  760                 return;
DPRINTF(("uplcom_close: close\n"));
  764         if (sc->sc_intr_pipe != NULL) {
err = usbd_abort_pipe(sc->sc_intr_pipe);
  766                 if (err)
printf("%s: abort interrupt pipe failed: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
err = usbd_close_pipe(sc->sc_intr_pipe);
  770                 if (err)
printf("%s: close interrupt pipe failed: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
free(sc->sc_intr_buf, M_USBDEV);
sc->sc_intr_pipe = NULL;
  775         }
  776 }
  778 void
uplcom_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
  780 {
  781         struct uplcom_softc *sc = priv;
u_char *buf = sc->sc_intr_buf;
u_char pstatus;
  785         if (sc->sc_dying)
  786                 return;
  788         if (status != USBD_NORMAL_COMPLETION) {
  789                 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
  790                         return;
DPRINTF(("%s: abnormal status: %s\n", sc->sc_dev.dv_xname,
usbd_errstr(status)));
usbd_clear_endpoint_stall_async(sc->sc_intr_pipe);
  795                 return;
  796         }
DPRINTF(("%s: uplcom status = %02x\n", sc->sc_dev.dv_xname, buf[8]));
sc->sc_lsr = sc->sc_msr = 0;
pstatus = buf[8];
  802         if (ISSET(pstatus, RSAQ_STATUS_CTS))
sc->sc_msr |= UMSR_CTS;
  804         else
sc->sc_msr &= ~UMSR_CTS;
  806         if (ISSET(pstatus, RSAQ_STATUS_DSR))
sc->sc_msr |= UMSR_DSR;
  808         else
sc->sc_msr &= ~UMSR_DSR;
  810         if (ISSET(pstatus, RSAQ_STATUS_DCD))
sc->sc_msr |= UMSR_DCD;
  812         else
sc->sc_msr &= ~UMSR_DCD;
ucom_status_change((struct ucom_softc *) sc->sc_subdev);
  815 }
  817 void
uplcom_get_status(void *addr, int portno, u_char *lsr, u_char *msr)
  819 {
  820         struct uplcom_softc *sc = addr;
DPRINTF(("uplcom_get_status:\n"));
  824         if (lsr != NULL)
  825                 *lsr = sc->sc_lsr;
  826         if (msr != NULL)
  827                 *msr = sc->sc_msr;
  828 }
  830 #if TODO
  831 int
uplcom_ioctl(void *addr, int portno, u_long cmd, caddr_t data, int flag,
  833              struct proc *p)
  834 {
  835         struct uplcom_softc *sc = addr;
  836         int error = 0;
  838         if (sc->sc_dying)
  839                 return (EIO);
DPRINTF(("uplcom_ioctl: cmd=0x%08lx\n", cmd));
  843         switch (cmd) {
  844         case TIOCNOTTY:
  845         case TIOCMGET:
  846         case TIOCMSET:
  847         case USB_GET_CM_OVER_DATA:
  848         case USB_SET_CM_OVER_DATA:
  849                 break;
  851         default:
DPRINTF(("uplcom_ioctl: unknown\n"));
error = ENOTTY;
  854                 break;
  855         }
  857         return (error);
  858 }
  859 #endif