Home | History | Annotate | Line # | Download | only in usb
uvscom.c revision 1.21.8.1
      1 /*	$NetBSD: uvscom.c,v 1.21.8.1 2008/06/04 02:05:21 yamt Exp $	*/
      2 /*-
      3  * Copyright (c) 2001-2002, Shunsuke Akiyama <akiyama (at) jp.FreeBSD.org>.
      4  * All rights reserved.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      9  * 1. Redistributions of source code must retain the above copyright
     10  *    notice, this list of conditions and the following disclaimer.
     11  * 2. Redistributions in binary form must reproduce the above copyright
     12  *    notice, this list of conditions and the following disclaimer in the
     13  *    documentation and/or other materials provided with the distribution.
     14  *
     15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
     16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     25  * SUCH DAMAGE.
     26  *
     27  * $FreeBSD: src/sys/dev/usb/uvscom.c,v 1.1 2002/03/18 18:23:39 joe Exp $
     28  */
     29 
     30 /*
     31  * uvscom: SUNTAC Slipper U VS-10U driver.
     32  * Slipper U is a PC card to USB converter for data communication card
     33  * adapter.  It supports DDI Pocket's Air H" C@rd, C@rd H" 64, NTT's P-in,
     34  * P-in m@ater and various data communication card adapters.
     35  */
     36 
     37 #include <sys/cdefs.h>
     38 __KERNEL_RCSID(0, "$NetBSD: uvscom.c,v 1.21.8.1 2008/06/04 02:05:21 yamt Exp $");
     39 
     40 #include <sys/param.h>
     41 #include <sys/systm.h>
     42 #include <sys/kernel.h>
     43 #include <sys/malloc.h>
     44 #include <sys/fcntl.h>
     45 #include <sys/conf.h>
     46 #include <sys/tty.h>
     47 #include <sys/file.h>
     48 #if defined(__FreeBSD__)
     49 #include <sys/bus.h>
     50 #include <sys/ioccom.h>
     51 #if __FreeBSD_version >= 500014
     52 #include <sys/selinfo.h>
     53 #else
     54 #include <sys/select.h>
     55 #endif
     56 #else
     57 #include <sys/ioctl.h>
     58 #include <sys/device.h>
     59 #endif
     60 #include <sys/proc.h>
     61 #include <sys/poll.h>
     62 
     63 #include <dev/usb/usb.h>
     64 #include <dev/usb/usbcdc.h>
     65 
     66 #include <dev/usb/usbdi.h>
     67 #include <dev/usb/usbdi_util.h>
     68 #include <dev/usb/usbdevs.h>
     69 #include <dev/usb/usb_quirks.h>
     70 
     71 #include <dev/usb/ucomvar.h>
     72 
     73 #ifdef UVSCOM_DEBUG
     74 static int	uvscomdebug = 1;
     75 
     76 #if defined(__FreeBSD__)
     77 #include <sys/sysctl.h>
     78 
     79 SYSCTL_DECL(_debug_usb);
     80 SYSCTL_INT(_debug_usb, OID_AUTO, uvscom, CTLFLAG_RW,
     81 	   &uvscomdebug, 0, "uvscom debug level");
     82 
     83 #endif
     84 
     85 #define DPRINTFN(n, x)  do { \
     86 				if (uvscomdebug > (n)) \
     87 					logprintf x; \
     88 			} while (0)
     89 #else
     90 #define DPRINTFN(n, x)
     91 #endif
     92 #define DPRINTF(x) DPRINTFN(0, x)
     93 
     94 #if defined(__FreeBSD__)
     95 #define UVSCOM_MODVER		1	/* module version */
     96 #endif
     97 
     98 #define	UVSCOM_CONFIG_INDEX	0
     99 #define	UVSCOM_IFACE_INDEX	0
    100 
    101 #define UVSCOM_INTR_INTERVAL	100	/* mS */
    102 
    103 #define UVSCOM_UNIT_WAIT	5
    104 
    105 /* Request */
    106 #define UVSCOM_SET_SPEED	0x10
    107 #define UVSCOM_LINE_CTL		0x11
    108 #define UVSCOM_SET_PARAM	0x12
    109 #define UVSCOM_READ_STATUS	0xd0
    110 #define UVSCOM_SHUTDOWN		0xe0
    111 
    112 /* UVSCOM_SET_SPEED parameters */
    113 #define UVSCOM_SPEED_150BPS	0x00
    114 #define UVSCOM_SPEED_300BPS	0x01
    115 #define UVSCOM_SPEED_600BPS	0x02
    116 #define UVSCOM_SPEED_1200BPS	0x03
    117 #define UVSCOM_SPEED_2400BPS	0x04
    118 #define UVSCOM_SPEED_4800BPS	0x05
    119 #define UVSCOM_SPEED_9600BPS	0x06
    120 #define UVSCOM_SPEED_19200BPS	0x07
    121 #define UVSCOM_SPEED_38400BPS	0x08
    122 #define UVSCOM_SPEED_57600BPS	0x09
    123 #define UVSCOM_SPEED_115200BPS	0x0a
    124 
    125 /* UVSCOM_LINE_CTL parameters */
    126 #define UVSCOM_BREAK		0x40
    127 #define UVSCOM_RTS		0x02
    128 #define UVSCOM_DTR		0x01
    129 #define UVSCOM_LINE_INIT	0x08
    130 
    131 /* UVSCOM_SET_PARAM parameters */
    132 #define UVSCOM_DATA_MASK	0x03
    133 #define UVSCOM_DATA_BIT_8	0x03
    134 #define UVSCOM_DATA_BIT_7	0x02
    135 #define UVSCOM_DATA_BIT_6	0x01
    136 #define UVSCOM_DATA_BIT_5	0x00
    137 
    138 #define UVSCOM_STOP_MASK	0x04
    139 #define UVSCOM_STOP_BIT_2	0x04
    140 #define UVSCOM_STOP_BIT_1	0x00
    141 
    142 #define UVSCOM_PARITY_MASK	0x18
    143 #define UVSCOM_PARITY_EVEN	0x18
    144 #if 0
    145 #define UVSCOM_PARITY_UNK	0x10
    146 #endif
    147 #define UVSCOM_PARITY_ODD	0x08
    148 #define UVSCOM_PARITY_NONE	0x00
    149 
    150 /* Status bits */
    151 #define UVSCOM_TXRDY		0x04
    152 #define UVSCOM_RXRDY		0x01
    153 
    154 #define UVSCOM_DCD		0x08
    155 #define UVSCOM_NOCARD		0x04
    156 #define UVSCOM_DSR		0x02
    157 #define UVSCOM_CTS		0x01
    158 #define UVSCOM_USTAT_MASK	(UVSCOM_NOCARD | UVSCOM_DSR | UVSCOM_CTS)
    159 
    160 struct	uvscom_softc {
    161 	USBBASEDEVICE		sc_dev;		/* base device */
    162 	usbd_device_handle	sc_udev;	/* USB device */
    163 	usbd_interface_handle	sc_iface;	/* interface */
    164 	int			sc_iface_number;/* interface number */
    165 
    166 	usbd_interface_handle	sc_intr_iface;	/* interrupt interface */
    167 	int			sc_intr_number;	/* interrupt number */
    168 	usbd_pipe_handle	sc_intr_pipe;	/* interrupt pipe */
    169 	u_char			*sc_intr_buf;	/* interrupt buffer */
    170 	int			sc_isize;
    171 
    172 	u_char			sc_dtr;		/* current DTR state */
    173 	u_char			sc_rts;		/* current RTS state */
    174 
    175 	u_char			sc_lsr;		/* Local status register */
    176 	u_char			sc_msr;		/* uvscom status register */
    177 
    178 	uint16_t		sc_lcr;		/* Line control */
    179 	u_char			sc_usr;		/* unit status */
    180 
    181 	device_ptr_t		sc_subdev;	/* ucom device */
    182 	u_char			sc_dying;	/* disconnecting */
    183 };
    184 
    185 /*
    186  * These are the maximum number of bytes transferred per frame.
    187  * The output buffer size cannot be increased due to the size encoding.
    188  */
    189 #define UVSCOMIBUFSIZE 512
    190 #define UVSCOMOBUFSIZE 64
    191 
    192 Static	usbd_status uvscom_readstat(struct uvscom_softc *);
    193 Static	usbd_status uvscom_shutdown(struct uvscom_softc *);
    194 Static	usbd_status uvscom_reset(struct uvscom_softc *);
    195 Static	usbd_status uvscom_set_line_coding(struct uvscom_softc *,
    196 					   uint16_t, uint16_t);
    197 Static	usbd_status uvscom_set_line(struct uvscom_softc *, uint16_t);
    198 Static	usbd_status uvscom_set_crtscts(struct uvscom_softc *);
    199 Static	void uvscom_get_status(void *, int, u_char *, u_char *);
    200 Static	void uvscom_dtr(struct uvscom_softc *, int);
    201 Static	void uvscom_rts(struct uvscom_softc *, int);
    202 Static	void uvscom_break(struct uvscom_softc *, int);
    203 
    204 Static	void uvscom_set(void *, int, int, int);
    205 Static	void uvscom_intr(usbd_xfer_handle, usbd_private_handle, usbd_status);
    206 Static	int  uvscom_param(void *, int, struct termios *);
    207 Static	int  uvscom_open(void *, int);
    208 Static	void uvscom_close(void *, int);
    209 
    210 struct ucom_methods uvscom_methods = {
    211 	uvscom_get_status,
    212 	uvscom_set,
    213 	uvscom_param,
    214 	NULL, /* uvscom_ioctl, TODO */
    215 	uvscom_open,
    216 	uvscom_close,
    217 	NULL,
    218 	NULL
    219 };
    220 
    221 static const struct usb_devno uvscom_devs [] = {
    222 	/* SUNTAC U-Cable type A4 */
    223 	{ USB_VENDOR_SUNTAC, USB_PRODUCT_SUNTAC_AS144L4 },
    224 	/* SUNTAC U-Cable type D2 */
    225 	{ USB_VENDOR_SUNTAC, USB_PRODUCT_SUNTAC_DS96L },
    226 	/* SUNTAC U-Cable type P1 */
    227 	{ USB_VENDOR_SUNTAC, USB_PRODUCT_SUNTAC_PS64P1 },
    228 	/* SUNTAC Slipper U  */
    229 	{ USB_VENDOR_SUNTAC, USB_PRODUCT_SUNTAC_VS10U },
    230 	/* SUNTAC Ir-Trinity */
    231 	{ USB_VENDOR_SUNTAC, USB_PRODUCT_SUNTAC_IS96U },
    232 };
    233 #define uvscom_lookup(v, p) usb_lookup(uvscom_devs, v, p)
    234 
    235 int uvscom_match(device_t, cfdata_t, void *);
    236 void uvscom_attach(device_t, device_t, void *);
    237 void uvscom_childdet(device_t, device_t);
    238 int uvscom_detach(device_t, int);
    239 int uvscom_activate(device_t, enum devact);
    240 extern struct cfdriver uvscom_cd;
    241 CFATTACH_DECL2_NEW(uvscom, sizeof(struct uvscom_softc), uvscom_match,
    242     uvscom_attach, uvscom_detach, uvscom_activate, NULL, uvscom_childdet);
    243 
    244 USB_MATCH(uvscom)
    245 {
    246 	USB_MATCH_START(uvscom, uaa);
    247 
    248 	return (uvscom_lookup(uaa->vendor, uaa->product) != NULL ?
    249 		UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
    250 }
    251 
    252 USB_ATTACH(uvscom)
    253 {
    254 	USB_ATTACH_START(uvscom, sc, uaa);
    255 	usbd_device_handle dev = uaa->device;
    256 	usb_config_descriptor_t *cdesc;
    257 	usb_interface_descriptor_t *id;
    258 	usb_endpoint_descriptor_t *ed;
    259 	char *devinfop;
    260 	usbd_status err;
    261 	int i;
    262 	struct ucom_attach_args uca;
    263 
    264 	devinfop = usbd_devinfo_alloc(dev, 0);
    265         USB_ATTACH_SETUP;
    266         aprint_normal_dev(self, "%s\n", devinfop);
    267 	usbd_devinfo_free(devinfop);
    268 
    269 	sc->sc_dev = self;
    270         sc->sc_udev = dev;
    271 
    272 	DPRINTF(("uvscom attach: sc = %p\n", sc));
    273 
    274 	/* initialize endpoints */
    275 	uca.bulkin = uca.bulkout = -1;
    276 	sc->sc_intr_number = -1;
    277 	sc->sc_intr_pipe = NULL;
    278 
    279 	/* Move the device into the configured state. */
    280 	err = usbd_set_config_index(dev, UVSCOM_CONFIG_INDEX, 1);
    281 	if (err) {
    282 		aprint_error_dev(self, "failed to set configuration, err=%s\n",
    283 		    usbd_errstr(err));
    284 		sc->sc_dying = 1;
    285 		USB_ATTACH_ERROR_RETURN;
    286 	}
    287 
    288 	/* get the config descriptor */
    289 	cdesc = usbd_get_config_descriptor(sc->sc_udev);
    290 
    291 	if (cdesc == NULL) {
    292 		aprint_error_dev(self,
    293 		    "failed to get configuration descriptor\n");
    294 		sc->sc_dying = 1;
    295 		USB_ATTACH_ERROR_RETURN;
    296 	}
    297 
    298 	/* get the common interface */
    299 	err = usbd_device2interface_handle(dev, UVSCOM_IFACE_INDEX,
    300 					   &sc->sc_iface);
    301 	if (err) {
    302 		aprint_error_dev(self, "failed to get interface, err=%s\n",
    303 		    usbd_errstr(err));
    304 		sc->sc_dying = 1;
    305 		USB_ATTACH_ERROR_RETURN;
    306 	}
    307 
    308 	id = usbd_get_interface_descriptor(sc->sc_iface);
    309 	sc->sc_iface_number = id->bInterfaceNumber;
    310 
    311 	/* Find endpoints */
    312 	for (i = 0; i < id->bNumEndpoints; i++) {
    313 		ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
    314 		if (ed == NULL) {
    315 			aprint_error_dev(self,
    316 			    "no endpoint descriptor for %d\n", i);
    317 			sc->sc_dying = 1;
    318 			USB_ATTACH_ERROR_RETURN;
    319 		}
    320 
    321 		if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
    322 		    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
    323 			uca.bulkin = ed->bEndpointAddress;
    324 		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
    325 			   UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
    326 			uca.bulkout = ed->bEndpointAddress;
    327 		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
    328 			   UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
    329 			sc->sc_intr_number = ed->bEndpointAddress;
    330 			sc->sc_isize = UGETW(ed->wMaxPacketSize);
    331 		}
    332 	}
    333 
    334 	if (uca.bulkin == -1) {
    335 		aprint_error_dev(self, "Could not find data bulk in\n");
    336 		sc->sc_dying = 1;
    337 		USB_ATTACH_ERROR_RETURN;
    338 	}
    339 	if (uca.bulkout == -1) {
    340 		aprint_error_dev(self, "Could not find data bulk out\n");
    341 		sc->sc_dying = 1;
    342 		USB_ATTACH_ERROR_RETURN;
    343 	}
    344 	if (sc->sc_intr_number == -1) {
    345 		aprint_error_dev(self, "Could not find interrupt in\n");
    346 		sc->sc_dying = 1;
    347 		USB_ATTACH_ERROR_RETURN;
    348 	}
    349 
    350 	sc->sc_dtr = sc->sc_rts = 0;
    351 	sc->sc_lcr = UVSCOM_LINE_INIT;
    352 
    353 	uca.portno = UCOM_UNK_PORTNO;
    354 	/* bulkin, bulkout set above */
    355 	uca.ibufsize = UVSCOMIBUFSIZE;
    356 	uca.obufsize = UVSCOMOBUFSIZE;
    357 	uca.ibufsizepad = UVSCOMIBUFSIZE;
    358 	uca.opkthdrlen = 0;
    359 	uca.device = dev;
    360 	uca.iface = sc->sc_iface;
    361 	uca.methods = &uvscom_methods;
    362 	uca.arg = sc;
    363 	uca.info = NULL;
    364 
    365 	err = uvscom_reset(sc);
    366 
    367 	if (err) {
    368 		aprint_error_dev(self, "reset failed, %s\n", usbd_errstr(err));
    369 		sc->sc_dying = 1;
    370 		USB_ATTACH_ERROR_RETURN;
    371 	}
    372 
    373 	DPRINTF(("uvscom: in = 0x%x out = 0x%x intr = 0x%x\n",
    374 		 uca.bulkin, uca.bulkout, sc->sc_intr_number));
    375 
    376 	usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
    377 			   USBDEV(sc->sc_dev));
    378 
    379 	DPRINTF(("uplcom: in=0x%x out=0x%x intr=0x%x\n",
    380 			uca.bulkin, uca.bulkout, sc->sc_intr_number ));
    381 	sc->sc_subdev = config_found_sm_loc(self, "ucombus", NULL, &uca,
    382 					    ucomprint, ucomsubmatch);
    383 
    384 	USB_ATTACH_SUCCESS_RETURN;
    385 }
    386 
    387 void
    388 uvscom_childdet(device_t self, device_t child)
    389 {
    390 	struct uvscom_softc *sc = device_private(self);
    391 
    392 	KASSERT(sc->sc_subdev == child);
    393 	sc->sc_subdev = NULL;
    394 }
    395 
    396 USB_DETACH(uvscom)
    397 {
    398 	USB_DETACH_START(uvscom, sc);
    399 	int rv = 0;
    400 
    401 	DPRINTF(("uvscom_detach: sc = %p\n", sc));
    402 
    403 	sc->sc_dying = 1;
    404 
    405 	if (sc->sc_intr_pipe != NULL) {
    406 		usbd_abort_pipe(sc->sc_intr_pipe);
    407 		usbd_close_pipe(sc->sc_intr_pipe);
    408 		free(sc->sc_intr_buf, M_USBDEV);
    409 		sc->sc_intr_pipe = NULL;
    410 	}
    411 
    412 	sc->sc_dying = 1;
    413 	if (sc->sc_subdev != NULL)
    414 		rv = config_detach(sc->sc_subdev, flags);
    415 
    416 	usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
    417 			   USBDEV(sc->sc_dev));
    418 
    419 	return (rv);
    420 }
    421 
    422 int
    423 uvscom_activate(device_t self, enum devact act)
    424 {
    425 	struct uvscom_softc *sc = device_private(self);
    426 	int rv = 0;
    427 
    428 	switch (act) {
    429 	case DVACT_ACTIVATE:
    430 		return (EOPNOTSUPP);
    431 
    432 	case DVACT_DEACTIVATE:
    433 		if (sc->sc_subdev != NULL)
    434 			rv = config_deactivate(sc->sc_subdev);
    435 		sc->sc_dying = 1;
    436 		break;
    437 	}
    438 	return (rv);
    439 }
    440 
    441 Static usbd_status
    442 uvscom_readstat(struct uvscom_softc *sc)
    443 {
    444 	usb_device_request_t req;
    445 	usbd_status err;
    446 	uint16_t r;
    447 
    448 	DPRINTF(("%s: send readstat\n", USBDEVNAME(sc->sc_dev)));
    449 
    450 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
    451 	req.bRequest = UVSCOM_READ_STATUS;
    452 	USETW(req.wValue, 0);
    453 	USETW(req.wIndex, 0);
    454 	USETW(req.wLength, 2);
    455 
    456 	err = usbd_do_request(sc->sc_udev, &req, &r);
    457 	if (err) {
    458 		aprint_error_dev(sc->sc_dev, "uvscom_readstat: %s\n",
    459 		    usbd_errstr(err));
    460 		return (err);
    461 	}
    462 
    463 	DPRINTF(("%s: uvscom_readstat: r = %d\n",
    464 		 USBDEVNAME(sc->sc_dev), r));
    465 
    466 	return (USBD_NORMAL_COMPLETION);
    467 }
    468 
    469 Static usbd_status
    470 uvscom_shutdown(struct uvscom_softc *sc)
    471 {
    472 	usb_device_request_t req;
    473 	usbd_status err;
    474 
    475 	DPRINTF(("%s: send shutdown\n", USBDEVNAME(sc->sc_dev)));
    476 
    477 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
    478 	req.bRequest = UVSCOM_SHUTDOWN;
    479 	USETW(req.wValue, 0);
    480 	USETW(req.wIndex, 0);
    481 	USETW(req.wLength, 0);
    482 
    483 	err = usbd_do_request(sc->sc_udev, &req, NULL);
    484 	if (err) {
    485 		aprint_error_dev(sc->sc_dev, "uvscom_shutdown: %s\n",
    486 		   usbd_errstr(err));
    487 		return (err);
    488 	}
    489 
    490 	return (USBD_NORMAL_COMPLETION);
    491 }
    492 
    493 Static usbd_status
    494 uvscom_reset(struct uvscom_softc *sc)
    495 {
    496 	DPRINTF(("%s: uvscom_reset\n", USBDEVNAME(sc->sc_dev)));
    497 
    498 	return (USBD_NORMAL_COMPLETION);
    499 }
    500 
    501 Static usbd_status
    502 uvscom_set_crtscts(struct uvscom_softc *sc)
    503 {
    504 	DPRINTF(("%s: uvscom_set_crtscts\n", USBDEVNAME(sc->sc_dev)));
    505 
    506 	return (USBD_NORMAL_COMPLETION);
    507 }
    508 
    509 Static usbd_status
    510 uvscom_set_line(struct uvscom_softc *sc, uint16_t line)
    511 {
    512 	usb_device_request_t req;
    513 	usbd_status err;
    514 
    515 	DPRINTF(("%s: uvscom_set_line: %04x\n",
    516 		 USBDEVNAME(sc->sc_dev), line));
    517 
    518 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
    519 	req.bRequest = UVSCOM_LINE_CTL;
    520 	USETW(req.wValue, line);
    521 	USETW(req.wIndex, 0);
    522 	USETW(req.wLength, 0);
    523 
    524 	err = usbd_do_request(sc->sc_udev, &req, NULL);
    525 	if (err) {
    526 		aprint_error_dev(sc->sc_dev, "uvscom_set_line: %s\n",
    527 		    usbd_errstr(err));
    528 		return (err);
    529 	}
    530 
    531 	return (USBD_NORMAL_COMPLETION);
    532 }
    533 
    534 Static usbd_status
    535 uvscom_set_line_coding(struct uvscom_softc *sc, uint16_t lsp, uint16_t ls)
    536 {
    537 	usb_device_request_t req;
    538 	usbd_status err;
    539 
    540 	DPRINTF(("%s: uvscom_set_line_coding: %02x %02x\n",
    541 		 USBDEVNAME(sc->sc_dev), lsp, ls));
    542 
    543 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
    544 	req.bRequest = UVSCOM_SET_SPEED;
    545 	USETW(req.wValue, lsp);
    546 	USETW(req.wIndex, 0);
    547 	USETW(req.wLength, 0);
    548 
    549 	err = usbd_do_request(sc->sc_udev, &req, NULL);
    550 	if (err) {
    551 		aprint_error_dev(sc->sc_dev, "uvscom_set_line_coding: %s\n",
    552 		   usbd_errstr(err));
    553 		return (err);
    554 	}
    555 
    556 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
    557 	req.bRequest = UVSCOM_SET_PARAM;
    558 	USETW(req.wValue, ls);
    559 	USETW(req.wIndex, 0);
    560 	USETW(req.wLength, 0);
    561 
    562 	err = usbd_do_request(sc->sc_udev, &req, NULL);
    563 	if (err) {
    564 		aprint_error_dev(sc->sc_dev, "uvscom_set_line_coding: %s\n",
    565 		   usbd_errstr(err));
    566 		return (err);
    567 	}
    568 
    569 	return (USBD_NORMAL_COMPLETION);
    570 }
    571 
    572 Static void
    573 uvscom_dtr(struct uvscom_softc *sc, int onoff)
    574 {
    575 	DPRINTF(("%s: uvscom_dtr: onoff = %d\n",
    576 		 USBDEVNAME(sc->sc_dev), onoff));
    577 
    578 	if (sc->sc_dtr == onoff)
    579 		return;			/* no change */
    580 
    581 	sc->sc_dtr = onoff;
    582 
    583 	if (onoff)
    584 		SET(sc->sc_lcr, UVSCOM_DTR);
    585 	else
    586 		CLR(sc->sc_lcr, UVSCOM_DTR);
    587 
    588 	uvscom_set_line(sc, sc->sc_lcr);
    589 }
    590 
    591 Static void
    592 uvscom_rts(struct uvscom_softc *sc, int onoff)
    593 {
    594 	DPRINTF(("%s: uvscom_rts: onoff = %d\n",
    595 		 USBDEVNAME(sc->sc_dev), onoff));
    596 
    597 	if (sc->sc_rts == onoff)
    598 		return;			/* no change */
    599 
    600 	sc->sc_rts = onoff;
    601 
    602 	if (onoff)
    603 		SET(sc->sc_lcr, UVSCOM_RTS);
    604 	else
    605 		CLR(sc->sc_lcr, UVSCOM_RTS);
    606 
    607 	uvscom_set_line(sc, sc->sc_lcr);
    608 }
    609 
    610 Static void
    611 uvscom_break(struct uvscom_softc *sc, int onoff)
    612 {
    613 	DPRINTF(("%s: uvscom_break: onoff = %d\n",
    614 		 USBDEVNAME(sc->sc_dev), onoff));
    615 
    616 	if (onoff)
    617 		uvscom_set_line(sc, SET(sc->sc_lcr, UVSCOM_BREAK));
    618 }
    619 
    620 Static void
    621 uvscom_set(void *addr, int portno, int reg, int onoff)
    622 {
    623 	struct uvscom_softc *sc = addr;
    624 
    625 	switch (reg) {
    626 	case UCOM_SET_DTR:
    627 		uvscom_dtr(sc, onoff);
    628 		break;
    629 	case UCOM_SET_RTS:
    630 		uvscom_rts(sc, onoff);
    631 		break;
    632 	case UCOM_SET_BREAK:
    633 		uvscom_break(sc, onoff);
    634 		break;
    635 	default:
    636 		break;
    637 	}
    638 }
    639 
    640 Static int
    641 uvscom_param(void *addr, int portno, struct termios *t)
    642 {
    643 	struct uvscom_softc *sc = addr;
    644 	usbd_status err;
    645 	uint16_t lsp;
    646 	uint16_t ls;
    647 
    648 	DPRINTF(("%s: uvscom_param: sc = %p\n",
    649 		 USBDEVNAME(sc->sc_dev), sc));
    650 
    651 	ls = 0;
    652 
    653 	switch (t->c_ospeed) {
    654 	case B150:
    655 		lsp = UVSCOM_SPEED_150BPS;
    656 		break;
    657 	case B300:
    658 		lsp = UVSCOM_SPEED_300BPS;
    659 		break;
    660 	case B600:
    661 		lsp = UVSCOM_SPEED_600BPS;
    662 		break;
    663 	case B1200:
    664 		lsp = UVSCOM_SPEED_1200BPS;
    665 		break;
    666 	case B2400:
    667 		lsp = UVSCOM_SPEED_2400BPS;
    668 		break;
    669 	case B4800:
    670 		lsp = UVSCOM_SPEED_4800BPS;
    671 		break;
    672 	case B9600:
    673 		lsp = UVSCOM_SPEED_9600BPS;
    674 		break;
    675 	case B19200:
    676 		lsp = UVSCOM_SPEED_19200BPS;
    677 		break;
    678 	case B38400:
    679 		lsp = UVSCOM_SPEED_38400BPS;
    680 		break;
    681 	case B57600:
    682 		lsp = UVSCOM_SPEED_57600BPS;
    683 		break;
    684 	case B115200:
    685 		lsp = UVSCOM_SPEED_115200BPS;
    686 		break;
    687 	default:
    688 		return (EIO);
    689 	}
    690 
    691 	if (ISSET(t->c_cflag, CSTOPB))
    692 		SET(ls, UVSCOM_STOP_BIT_2);
    693 	else
    694 		SET(ls, UVSCOM_STOP_BIT_1);
    695 
    696 	if (ISSET(t->c_cflag, PARENB)) {
    697 		if (ISSET(t->c_cflag, PARODD))
    698 			SET(ls, UVSCOM_PARITY_ODD);
    699 		else
    700 			SET(ls, UVSCOM_PARITY_EVEN);
    701 	} else
    702 		SET(ls, UVSCOM_PARITY_NONE);
    703 
    704 	switch (ISSET(t->c_cflag, CSIZE)) {
    705 	case CS5:
    706 		SET(ls, UVSCOM_DATA_BIT_5);
    707 		break;
    708 	case CS6:
    709 		SET(ls, UVSCOM_DATA_BIT_6);
    710 		break;
    711 	case CS7:
    712 		SET(ls, UVSCOM_DATA_BIT_7);
    713 		break;
    714 	case CS8:
    715 		SET(ls, UVSCOM_DATA_BIT_8);
    716 		break;
    717 	default:
    718 		return (EIO);
    719 	}
    720 
    721 	err = uvscom_set_line_coding(sc, lsp, ls);
    722 	if (err)
    723 		return (EIO);
    724 
    725 	if (ISSET(t->c_cflag, CRTSCTS)) {
    726 		err = uvscom_set_crtscts(sc);
    727 		if (err)
    728 			return (EIO);
    729 	}
    730 
    731 	return (0);
    732 }
    733 
    734 Static int
    735 uvscom_open(void *addr, int portno)
    736 {
    737 	struct uvscom_softc *sc = addr;
    738 	int err;
    739 	int i;
    740 
    741 	if (sc->sc_dying)
    742 		return (EIO);
    743 
    744 	DPRINTF(("uvscom_open: sc = %p\n", sc));
    745 
    746 	if (sc->sc_intr_number != -1 && sc->sc_intr_pipe == NULL) {
    747 		DPRINTF(("uvscom_open: open interrupt pipe.\n"));
    748 
    749 		sc->sc_usr = 0;		/* clear unit status */
    750 
    751 		err = uvscom_readstat(sc);
    752 		if (err) {
    753 			DPRINTF(("%s: uvscom_open: readstat faild\n",
    754 				 USBDEVNAME(sc->sc_dev)));
    755 			return (EIO);
    756 		}
    757 
    758 		sc->sc_intr_buf = malloc(sc->sc_isize, M_USBDEV, M_WAITOK);
    759 		err = usbd_open_pipe_intr(sc->sc_iface,
    760 					  sc->sc_intr_number,
    761 					  USBD_SHORT_XFER_OK,
    762 					  &sc->sc_intr_pipe,
    763 					  sc,
    764 					  sc->sc_intr_buf,
    765 					  sc->sc_isize,
    766 					  uvscom_intr,
    767 					  UVSCOM_INTR_INTERVAL);
    768 		if (err) {
    769 			aprint_error_dev(sc->sc_dev,
    770 			    "cannot open interrupt pipe (addr %d)\n",
    771 				 sc->sc_intr_number);
    772 			return (EIO);
    773 		}
    774 	} else {
    775 		DPRINTF(("uvscom_open: did not open interrupt pipe.\n"));
    776 	}
    777 
    778 	if ((sc->sc_usr & UVSCOM_USTAT_MASK) == 0) {
    779 		/* unit is not ready */
    780 
    781 		for (i = UVSCOM_UNIT_WAIT; i > 0; --i) {
    782 			tsleep(&err, TTIPRI, "uvsop", hz);	/* XXX */
    783 			if (ISSET(sc->sc_usr, UVSCOM_USTAT_MASK))
    784 				break;
    785 		}
    786 		if (i == 0) {
    787 			DPRINTF(("%s: unit is not ready\n",
    788 				 USBDEVNAME(sc->sc_dev)));
    789 			return (EIO);
    790 		}
    791 
    792 		/* check PC card was inserted */
    793 		if (ISSET(sc->sc_usr, UVSCOM_NOCARD)) {
    794 			DPRINTF(("%s: no card\n",
    795 				 USBDEVNAME(sc->sc_dev)));
    796 			return (EIO);
    797 		}
    798 	}
    799 
    800 	return (0);
    801 }
    802 
    803 Static void
    804 uvscom_close(void *addr, int portno)
    805 {
    806 	struct uvscom_softc *sc = addr;
    807 	int err;
    808 
    809 	if (sc->sc_dying)
    810 		return;
    811 
    812 	DPRINTF(("uvscom_close: close\n"));
    813 
    814 	uvscom_shutdown(sc);
    815 
    816 	if (sc->sc_intr_pipe != NULL) {
    817 		err = usbd_abort_pipe(sc->sc_intr_pipe);
    818 		if (err)
    819 			aprint_error_dev(sc->sc_dev,
    820 			    "abort interrupt pipe failed: %s\n",
    821 			    usbd_errstr(err));
    822 		err = usbd_close_pipe(sc->sc_intr_pipe);
    823 		if (err)
    824 			aprint_error_dev(sc->sc_dev,
    825 			    "lose interrupt pipe failed: %s\n",
    826 			    usbd_errstr(err));
    827 		free(sc->sc_intr_buf, M_USBDEV);
    828 		sc->sc_intr_pipe = NULL;
    829 	}
    830 }
    831 
    832 Static void
    833 uvscom_intr(usbd_xfer_handle xfer, usbd_private_handle priv,
    834     usbd_status status)
    835 {
    836 	struct uvscom_softc *sc = priv;
    837 	u_char *buf = sc->sc_intr_buf;
    838 	u_char pstatus;
    839 
    840 	if (sc->sc_dying)
    841 		return;
    842 
    843 	if (status != USBD_NORMAL_COMPLETION) {
    844 		if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
    845 			return;
    846 
    847 		aprint_error_dev(sc->sc_dev,
    848 		    "uvscom_intr: abnormal status: %s\n",
    849 		    usbd_errstr(status));
    850 		usbd_clear_endpoint_stall_async(sc->sc_intr_pipe);
    851 		return;
    852 	}
    853 
    854 	DPRINTFN(2, ("%s: uvscom status = %02x %02x\n",
    855 		 USBDEVNAME(sc->sc_dev), buf[0], buf[1]));
    856 
    857 	sc->sc_lsr = sc->sc_msr = 0;
    858 	sc->sc_usr = buf[1];
    859 
    860 	pstatus = buf[0];
    861 	if (ISSET(pstatus, UVSCOM_TXRDY))
    862 		SET(sc->sc_lsr, ULSR_TXRDY);
    863 	if (ISSET(pstatus, UVSCOM_RXRDY))
    864 		SET(sc->sc_lsr, ULSR_RXRDY);
    865 
    866 	pstatus = buf[1];
    867 	if (ISSET(pstatus, UVSCOM_CTS))
    868 		SET(sc->sc_msr, UMSR_CTS);
    869 	if (ISSET(pstatus, UVSCOM_DSR))
    870 		SET(sc->sc_msr, UMSR_DSR);
    871 	if (ISSET(pstatus, UVSCOM_DCD))
    872 		SET(sc->sc_msr, UMSR_DCD);
    873 
    874 	ucom_status_change(device_private(sc->sc_subdev));
    875 }
    876 
    877 Static void
    878 uvscom_get_status(void *addr, int portno, u_char *lsr, u_char *msr)
    879 {
    880 	struct uvscom_softc *sc = addr;
    881 
    882 	if (lsr != NULL)
    883 		*lsr = sc->sc_lsr;
    884 	if (msr != NULL)
    885 		*msr = sc->sc_msr;
    886 }
    887 
    888