root/dev/usb/ucycom.c

DEFINITIONS

1. ucycom_match
2. ucycom_attach
3. ucycom_get_status
4. ucycom_open
5. ucycom_close
6. ucycom_read
7. ucycom_write
8. ucycom_param
9. ucycom_intr
10. ucycom_set
11. ucycom_get_cfg
12. ucycom_detach
13. ucycom_activate

    1 /*      $OpenBSD: ucycom.c,v 1.11 2007/06/14 10:11:15 mbalmer Exp $     */
    2 /*      $NetBSD: ucycom.c,v 1.3 2005/08/05 07:27:47 skrll Exp $ */
    4 /*
    5  * Copyright (c) 2005 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by Nick Hudson
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. All advertising materials mentioning features or use of this software
   20  *    must display the following acknowledgement:
   21  *      This product includes software developed by the NetBSD
   22  *      Foundation, Inc. and its contributors.
   23  * 4. Neither the name of The NetBSD Foundation nor the names of its
   24  *    contributors may be used to endorse or promote products derived
   25  *    from this software without specific prior written permission.
   26  *
   27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   37  * POSSIBILITY OF SUCH DAMAGE.
   38  */
   39 /*
   40  * This code is based on the ucom driver.
   41  */
   43 /*
   44  * Device driver for Cypress CY7C637xx and CY7C640/1xx series USB to
   45  * RS232 bridges.
   46  */
   48 #include <sys/param.h>
   49 #include <sys/systm.h>
   50 #include <sys/conf.h>
   51 #include <sys/kernel.h>
   52 #include <sys/malloc.h>
   53 #include <sys/device.h>
   54 #include <sys/sysctl.h>
   55 #include <sys/tty.h>
   56 #include <sys/file.h>
   57 #include <sys/vnode.h>
   59 #include <dev/usb/usb.h>
   60 #include <dev/usb/usbhid.h>
   62 #include <dev/usb/usbdi.h>
   63 #include <dev/usb/usbdi_util.h>
   64 #include <dev/usb/usbdevs.h>
   65 #include <dev/usb/uhidev.h>
   66 #include <dev/usb/hid.h>
   68 #include <dev/usb/ucomvar.h>
   70 #ifdef UCYCOM_DEBUG
   71 #define DPRINTF(x)      if (ucycomdebug) printf x
   72 #define DPRINTFN(n, x)  if (ucycomdebug > (n)) printf x
   73 int     ucycomdebug = 200;
   74 #else
   75 #define DPRINTF(x)
   76 #define DPRINTFN(n,x)
   77 #endif
   79 /* Configuration Byte */
   80 #define UCYCOM_RESET            0x80
   81 #define UCYCOM_PARITY_TYPE_MASK 0x20
   82 #define  UCYCOM_PARITY_ODD       0x20
   83 #define  UCYCOM_PARITY_EVEN      0x00
   84 #define UCYCOM_PARITY_MASK      0x10
   85 #define  UCYCOM_PARITY_ON        0x10
   86 #define  UCYCOM_PARITY_OFF       0x00
   87 #define UCYCOM_STOP_MASK        0x08
   88 #define  UCYCOM_STOP_BITS_2      0x08
   89 #define  UCYCOM_STOP_BITS_1      0x00
   90 #define UCYCOM_DATA_MASK        0x03
   91 #define  UCYCOM_DATA_BITS_8      0x03
   92 #define  UCYCOM_DATA_BITS_7      0x02
   93 #define  UCYCOM_DATA_BITS_6      0x01
   94 #define  UCYCOM_DATA_BITS_5      0x00
   96 /* Modem (Input) status byte */
   97 #define UCYCOM_RI       0x80
   98 #define UCYCOM_DCD      0x40
   99 #define UCYCOM_DSR      0x20
  100 #define UCYCOM_CTS      0x10
  101 #define UCYCOM_ERROR    0x08
  102 #define UCYCOM_LMASK    0x07
  104 /* Modem (Output) control byte */
  105 #define UCYCOM_DTR      0x20
  106 #define UCYCOM_RTS      0x10
  107 #define UCYCOM_ORESET   0x08
  109 struct ucycom_softc {
  110         struct uhidev            sc_hdev;
usbd_device_handle       sc_udev;
  113         /* uhidev parameters */
size_t                   sc_flen;       /* feature report length */
size_t                   sc_ilen;       /* input report length */
size_t                   sc_olen;       /* output report length */
uint8_t                 *sc_obuf;
uint8_t                 *sc_ibuf;
uint32_t                 sc_icnt;
  123         /* settings */
uint32_t                 sc_baud;
uint8_t                  sc_cfg;        /* Data format */
uint8_t                  sc_mcr;        /* Modem control */
uint8_t                  sc_msr;        /* Modem status */
uint8_t                  sc_newmsr;     /* from HID intr */
  129         int                      sc_swflags;
  131         struct device           *sc_subdev;
  133         /* flags */
u_char                   sc_dying;
  135 };
  137 /* Callback routines */
  138 void    ucycom_set(void *, int, int, int);
  139 int     ucycom_param(void *, int, struct termios *);
  140 void    ucycom_get_status(void *, int, u_char *, u_char *);
  141 int     ucycom_open(void *, int);
  142 void    ucycom_close(void *, int);
  143 void    ucycom_write(void *, int, u_char *, u_char *, u_int32_t *);
  144 void    ucycom_read(void *, int, u_char **, u_int32_t *);
  146 struct ucom_methods ucycom_methods = {
NULL, /* ucycom_get_status, */
ucycom_set,
ucycom_param,
NULL,
ucycom_open,
ucycom_close,
ucycom_read,
ucycom_write,
  155 };
  157 void ucycom_intr(struct uhidev *, void *, u_int);
  159 void ucycom_get_cfg(struct ucycom_softc *);
  161 const struct usb_devno ucycom_devs[] = {
  162         { USB_VENDOR_CYPRESS, USB_PRODUCT_CYPRESS_USBRS232 },
  163         { USB_VENDOR_DELORME, USB_PRODUCT_DELORME_EMUSB },
  164         { USB_VENDOR_DELORME, USB_PRODUCT_DELORME_EMLT20 },
  165 };
  166 #define ucycom_lookup(v, p) usb_lookup(ucycom_devs, v, p)
  168 int ucycom_match(struct device *, void *, void *); 
  169 void ucycom_attach(struct device *, struct device *, void *); 
  170 int ucycom_detach(struct device *, int); 
  171 int ucycom_activate(struct device *, enum devact); 
  173 struct cfdriver ucycom_cd = { 
NULL, "ucycom", DV_DULL 
  175 }; 
  177 const struct cfattach ucycom_ca = { 
  178         sizeof(struct ucycom_softc), 
ucycom_match, 
ucycom_attach, 
ucycom_detach, 
ucycom_activate, 
  183 };
  185 int
ucycom_match(struct device *parent, void *match, void *aux)
  187 {
  188         struct uhidev_attach_arg *uha = aux;
DPRINTF(("ucycom match\n"));
  191         return (ucycom_lookup(uha->uaa->vendor, uha->uaa->product) != NULL ?
UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
  193 }
  195 void
ucycom_attach(struct device *parent, struct device *self, void *aux)
  197 {
  198         struct ucycom_softc *sc = (struct ucycom_softc *)self;
  199         struct usb_attach_arg *uaa = aux;
  200         struct uhidev_attach_arg *uha = (struct uhidev_attach_arg *)uaa;
usbd_device_handle dev = uha->parent->sc_udev;
  202         struct ucom_attach_args uca;
  203         int size, repid, err;
  204         void *desc;
sc->sc_hdev.sc_intr = ucycom_intr;
sc->sc_hdev.sc_parent = uha->parent;
sc->sc_hdev.sc_report_id = uha->reportid;
uhidev_get_report_desc(uha->parent, &desc, &size);
repid = uha->reportid;
sc->sc_ilen = hid_report_size(desc, size, hid_input, repid);
sc->sc_olen = hid_report_size(desc, size, hid_output, repid);
sc->sc_flen = hid_report_size(desc, size, hid_feature, repid);
DPRINTF(("ucycom_open: olen %d ilen %d flen %d\n", sc->sc_ilen,
sc->sc_olen, sc->sc_flen));
printf("\n");
sc->sc_udev = dev;
sc->sc_msr = sc->sc_mcr = 0;
err = uhidev_open(&sc->sc_hdev);
  226         if (err) {
DPRINTF(("ucycom_open: uhidev_open %d\n", err));
  228                 return;
  229         }
DPRINTF(("ucycom attach: sc %p opipe %p ipipe %p report_id %d\n",
sc, sc->sc_hdev.sc_parent->sc_opipe, sc->sc_hdev.sc_parent->sc_ipipe,
uha->reportid));
  235         /* bulkin, bulkout set above */
bzero(&uca, sizeof uca);
uca.bulkin = uca.bulkout = -1;
uca.uhidev = sc->sc_hdev.sc_parent;
uca.ibufsize = sc->sc_ilen - 1;
uca.obufsize = sc->sc_olen - 1;
uca.ibufsizepad = 1;
uca.opkthdrlen = 0;
uca.device = uaa->device;
uca.iface = uaa->iface;
uca.methods = &ucycom_methods;
uca.arg = sc;
uca.info = NULL;
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
  250                            &sc->sc_hdev.sc_dev);
sc->sc_subdev = config_found_sm(self, &uca, ucomprint, ucomsubmatch);
DPRINTF(("ucycom_attach: complete %p\n", sc->sc_subdev));
  254 }
  256 void
ucycom_get_status(void *addr, int portno, u_char *lsr, u_char *msr)
  258 {
  259         struct ucycom_softc *sc = addr;
DPRINTF(("ucycom_get_status:\n"));
  263 #if 0
  264         if (lsr != NULL)
  265                 *lsr = sc->sc_lsr;
  266 #endif
  267         if (msr != NULL)
  268                 *msr = sc->sc_msr;
  269 }
  271 int
ucycom_open(void *addr, int portno)
  273 {
  274         struct ucycom_softc *sc = addr;
  275         struct termios t;
  276         int err;
DPRINTF(("ucycom_open: complete\n"));
  280         if (sc->sc_dying)
  281                 return (EIO);
  283         /* Allocate an output report buffer */
sc->sc_obuf = malloc(sc->sc_olen, M_USBDEV, M_WAITOK);
  286         /* Allocate an input report buffer */
sc->sc_ibuf = malloc(sc->sc_ilen, M_USBDEV, M_WAITOK);
DPRINTF(("ucycom_open: sc->sc_ibuf=%p sc->sc_obuf=%p \n",
sc->sc_ibuf, sc->sc_obuf));
t.c_ospeed = 9600;
t.c_cflag = CSTOPB | CS8;
  294         (void)ucycom_param(sc, portno, &t);
sc->sc_mcr = UCYCOM_DTR | UCYCOM_RTS;
memset(sc->sc_obuf, 0, sc->sc_olen);
sc->sc_obuf[0] = sc->sc_mcr;
err = uhidev_write(sc->sc_hdev.sc_parent, sc->sc_obuf, sc->sc_olen);
  300         if (err) {
DPRINTF(("ucycom_open: set RTS err=%d\n", err));
  302                 return (EIO);
  303         }
  305         return (0);
  306 }
  308 void
ucycom_close(void *addr, int portno)
  310 {
  311         struct ucycom_softc *sc = addr;
  312         int s;
  314         if (sc->sc_dying)
  315                 return;
s = splusb();
  318         if (sc->sc_obuf != NULL) {
free(sc->sc_obuf, M_USBDEV);
sc->sc_obuf = NULL;
  321         }
  322         if (sc->sc_ibuf != NULL) {
free(sc->sc_ibuf, M_USBDEV);
sc->sc_ibuf = NULL;
  325         }
splx(s);
  327 }
  329 void
ucycom_read(void *addr, int portno, u_char **ptr, u_int32_t *count)
  331 {
  332         struct ucycom_softc *sc = addr;
  334         if (sc->sc_newmsr ^ sc->sc_msr) {
DPRINTF(("ucycom_read: msr %d new %d\n",
sc->sc_msr, sc->sc_newmsr));
sc->sc_msr = sc->sc_newmsr;
ucom_status_change((struct ucom_softc *)sc->sc_subdev);
  339         }
DPRINTF(("ucycom_read: buf %p chars %d\n", sc->sc_ibuf, sc->sc_icnt));
  342         *ptr = sc->sc_ibuf;
  343         *count = sc->sc_icnt;
  344 }
  346 void
ucycom_write(void *addr, int portno, u_char *to, u_char *data, u_int32_t *cnt)
  348 {
  349         struct ucycom_softc *sc = addr;
u_int32_t len;
  351 #ifdef UCYCOM_DEBUG
u_int32_t want = *cnt;
  353 #endif
  355         /*
  356          * The 8 byte output report uses byte 0 for control and byte
  357          * count.
  358          *
  359          * The 32 byte output report uses byte 0 for control. Byte 1
  360          * is used for byte count.
  361          */
len = sc->sc_olen;
memset(to, 0, len);
  364         switch (sc->sc_olen) {
  365         case 8:
to[0] = *cnt | sc->sc_mcr;
memcpy(&to[1], data, *cnt);
DPRINTF(("ucycomstart(8): to[0] = %d | %d = %d\n",
  369                     *cnt, sc->sc_mcr, to[0]));
  370                 break;
  372         case 32:
to[0] = sc->sc_mcr;
to[1] = *cnt;
memcpy(&to[2], data, *cnt);
DPRINTF(("ucycomstart(32): to[0] = %d\nto[1] = %d\n",
to[0], to[1]));
  378                 break;
  379         }
  381 #ifdef UCYCOM_DEBUG
  382         if (ucycomdebug > 5) {
  383                 int i;
  385                 if (len != 0) {
DPRINTF(("ucycomstart: to[0..%d) =", len-1));
  387                         for (i = 0; i < len; i++)
DPRINTF((" %02x", to[i]));
DPRINTF(("\n"));
  390                 }
  391         }
  392 #endif
  393         *cnt = len;
  395 #if 0
ucycom_get_cfg(sc);
  397 #endif
DPRINTFN(4,("ucycomstart: req %d chars did %d chars\n", want, len));
  399 }
  401 int
ucycom_param(void *addr, int portno, struct termios *t)
  403 {
  404         struct ucycom_softc *sc = addr;
uint8_t report[5];
uint32_t baud = 0;
uint8_t cfg;
  408         int err;
  410         if (sc->sc_dying)
  411                 return (EIO);
  413         switch (t->c_ospeed) {
  414         case 600:
  415         case 1200:
  416         case 2400:
  417         case 4800:
  418         case 9600:
  419         case 19200:
  420         case 38400:
  421         case 57600:
  422 #if 0
  423         /*
  424          * Stock chips only support standard baud rates in the 600 - 57600
  425          * range, but higher rates can be achieved using custom firmware.
  426          */
  427         case 115200:
  428         case 153600:
  429         case 192000:
  430 #endif
baud = t->c_ospeed;
  432                 break;
  433         default:
  434                 return (EINVAL);
  435         }
  437         if (t->c_cflag & CIGNORE) {
cfg = sc->sc_cfg;
  439         } else {
cfg = 0;
  441                 switch (t->c_cflag & CSIZE) {
  442                 case CS8:
cfg |= UCYCOM_DATA_BITS_8;
  444                         break;
  445                 case CS7:
cfg |= UCYCOM_DATA_BITS_7;
  447                         break;
  448                 case CS6:
cfg |= UCYCOM_DATA_BITS_6;
  450                         break;
  451                 case CS5:
cfg |= UCYCOM_DATA_BITS_5;
  453                         break;
  454                 default:
  455                         return (EINVAL);
  456                 }
cfg |= ISSET(t->c_cflag, CSTOPB) ?
UCYCOM_STOP_BITS_2 : UCYCOM_STOP_BITS_1;
cfg |= ISSET(t->c_cflag, PARENB) ?
UCYCOM_PARITY_ON : UCYCOM_PARITY_OFF;
cfg |= ISSET(t->c_cflag, PARODD) ?
UCYCOM_PARITY_ODD : UCYCOM_PARITY_EVEN;
  463         }
DPRINTF(("ucycom_param: setting %d baud, %d-%c-%d (%d)\n", baud,
  466             5 + (cfg & UCYCOM_DATA_MASK),
  467             (cfg & UCYCOM_PARITY_MASK) ?
  468                 ((cfg & UCYCOM_PARITY_TYPE_MASK) ? 'O' : 'E') : 'N',
  469             (cfg & UCYCOM_STOP_MASK) ? 2 : 1, cfg));
report[0] = baud & 0xff;
report[1] = (baud >> 8) & 0xff;
report[2] = (baud >> 16) & 0xff;
report[3] = (baud >> 24) & 0xff;
report[4] = cfg;
err = uhidev_set_report(&sc->sc_hdev, UHID_FEATURE_REPORT,
report, sc->sc_flen);
  478         if (err != 0) {
DPRINTF(("ucycom_param: uhidev_set_report %d %s\n",
err, usbd_errstr(err)));
  481                 return EIO;
  482         }
sc->sc_baud = baud;
  484         return (err);
  485 }
  487 void
ucycom_intr(struct uhidev *addr, void *ibuf, u_int len)
  489 {
  490         extern void ucomreadcb(usbd_xfer_handle, usbd_private_handle, usbd_status);
  491         struct ucycom_softc *sc = (struct ucycom_softc *)addr;
uint8_t *cp = ibuf;
  493         int n, st, s;
  495         /* not accepting data anymore.. */
  496         if (sc->sc_ibuf == NULL)
  497                 return;
  499         /* We understand 8 byte and 32 byte input records */
  500         switch (len) {
  501         case 8:
n = cp[0] & UCYCOM_LMASK;
st = cp[0] & ~UCYCOM_LMASK;
cp++;
  505                 break;
  507         case 32:
st = cp[0];
n = cp[1];
cp += 2;
  511                 break;
  513         default:
DPRINTFN(3,("ucycom_intr: Unknown input report length\n"));
  515                 return;
  516         }
  518 #ifdef UCYCOM_DEBUG
  519         if (ucycomdebug > 5) {
u_int32_t i;
  522                 if (n != 0) {
DPRINTF(("ucycom_intr: ibuf[0..%d) =", n));
  524                         for (i = 0; i < n; i++)
DPRINTF((" %02x", cp[i]));
DPRINTF(("\n"));
  527                 }
  528         }
  529 #endif
  531         if (n > 0 || st != sc->sc_msr) {
s = spltty();
sc->sc_newmsr = st;
bcopy(cp, sc->sc_ibuf, n);
sc->sc_icnt = n;
ucomreadcb(addr->sc_parent->sc_ixfer, sc->sc_subdev,
USBD_NORMAL_COMPLETION);
splx(s);
  539         }
  540 }
  542 void
ucycom_set(void *addr, int portno, int reg, int onoff)
  544 {
  545         struct ucycom_softc *sc = addr;
  546         int err;
  548         switch (reg) {
  549         case UCOM_SET_DTR:
  550                 if (onoff)
SET(sc->sc_mcr, UCYCOM_DTR);
  552                 else
CLR(sc->sc_mcr, UCYCOM_DTR);
  554                 break;
  555         case UCOM_SET_RTS:
  556                 if (onoff)
SET(sc->sc_mcr, UCYCOM_RTS);
  558                 else
CLR(sc->sc_mcr, UCYCOM_RTS);
  560                 break;
  561         case UCOM_SET_BREAK:
  562                 break;
  563         }
memset(sc->sc_obuf, 0, sc->sc_olen);
sc->sc_obuf[0] = sc->sc_mcr;
err = uhidev_write(sc->sc_hdev.sc_parent, sc->sc_obuf, sc->sc_olen);
  569         if (err)
DPRINTF(("ucycom_set_status: err=%d\n", err));
  571 }
  573 void
ucycom_get_cfg(struct ucycom_softc *sc)
  575 {
  576         int err, cfg, baud;
uint8_t report[5];
err = uhidev_get_report(&sc->sc_hdev, UHID_FEATURE_REPORT,
report, sc->sc_flen);
cfg = report[4];
baud = (report[3] << 24) + (report[2] << 16) + (report[1] << 8) + report[0];
DPRINTF(("ucycom_configure: device reports %d baud, %d-%c-%d (%d)\n", baud,
  584             5 + (cfg & UCYCOM_DATA_MASK),
  585             (cfg & UCYCOM_PARITY_MASK) ?
  586                 ((cfg & UCYCOM_PARITY_TYPE_MASK) ? 'O' : 'E') : 'N',
  587             (cfg & UCYCOM_STOP_MASK) ? 2 : 1, cfg));
  588 }
  590 int
ucycom_detach(struct device *self, int flags)
  592 {
  593         struct ucycom_softc *sc = (struct ucycom_softc *)self;
DPRINTF(("ucycom_detach: sc=%p flags=%d\n", sc, flags));
sc->sc_dying = 1;
  597         if (sc->sc_subdev != NULL) {
config_detach(sc->sc_subdev, flags);
sc->sc_subdev = NULL;
  600         }
  601         return (0);
  602 }
  604 int
ucycom_activate(struct device *self, enum devact act)
  606 {
  607         struct ucycom_softc *sc = (struct ucycom_softc *)self;
  608         int rv = 0;
DPRINTFN(5,("ucycom_activate: %d\n", act));
  612         switch (act) {
  613         case DVACT_ACTIVATE:
  614                 break;
  616         case DVACT_DEACTIVATE:
  617                 if (sc->sc_subdev != NULL)
rv = config_deactivate(sc->sc_subdev);
sc->sc_dying = 1;
  620                 break;
  621         }
  622         return (rv);
  623 }