1184610Salfred/* $NetBSD: uplcom.c,v 1.21 2001/11/13 06:24:56 lukem Exp $ */ 2184610Salfred 3184610Salfred#include <sys/cdefs.h> 4184610Salfred__FBSDID("$FreeBSD: releng/11.0/sys/dev/usb/serial/uplcom.c 298300 2016-04-19 22:07:36Z pfg $"); 5184610Salfred 6184610Salfred/*- 7184610Salfred * Copyright (c) 2001-2003, 2005 Shunsuke Akiyama <akiyama@jp.FreeBSD.org>. 8184610Salfred * All rights reserved. 9184610Salfred * 10184610Salfred * Redistribution and use in source and binary forms, with or without 11184610Salfred * modification, are permitted provided that the following conditions 12184610Salfred * are met: 13184610Salfred * 1. Redistributions of source code must retain the above copyright 14184610Salfred * notice, this list of conditions and the following disclaimer. 15184610Salfred * 2. Redistributions in binary form must reproduce the above copyright 16184610Salfred * notice, this list of conditions and the following disclaimer in the 17184610Salfred * documentation and/or other materials provided with the distribution. 18184610Salfred * 19184610Salfred * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20184610Salfred * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21184610Salfred * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22184610Salfred * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 23184610Salfred * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24184610Salfred * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25184610Salfred * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26184610Salfred * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27184610Salfred * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28184610Salfred * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29184610Salfred * SUCH DAMAGE. 30184610Salfred */ 31184610Salfred 32184610Salfred/*- 33184610Salfred * Copyright (c) 2001 The NetBSD Foundation, Inc. 34184610Salfred * All rights reserved. 35184610Salfred * 36184610Salfred * This code is derived from software contributed to The NetBSD Foundation 37184610Salfred * by Ichiro FUKUHARA (ichiro@ichiro.org). 38184610Salfred * 39184610Salfred * Redistribution and use in source and binary forms, with or without 40184610Salfred * modification, are permitted provided that the following conditions 41184610Salfred * are met: 42184610Salfred * 1. Redistributions of source code must retain the above copyright 43184610Salfred * notice, this list of conditions and the following disclaimer. 44184610Salfred * 2. Redistributions in binary form must reproduce the above copyright 45184610Salfred * notice, this list of conditions and the following disclaimer in the 46184610Salfred * documentation and/or other materials provided with the distribution. 47184610Salfred * 48184610Salfred * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 49184610Salfred * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 50184610Salfred * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 51184610Salfred * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 52184610Salfred * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 53184610Salfred * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 54184610Salfred * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 55184610Salfred * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 56184610Salfred * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 57184610Salfred * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 58184610Salfred * POSSIBILITY OF SUCH DAMAGE. 59184610Salfred */ 60184610Salfred 61184610Salfred/* 62184610Salfred * This driver supports several USB-to-RS232 serial adapters driven by 63184610Salfred * Prolific PL-2303, PL-2303X and probably PL-2303HX USB-to-RS232 64184610Salfred * bridge chip. The adapters are sold under many different brand 65184610Salfred * names. 66184610Salfred * 67184610Salfred * Datasheets are available at Prolific www site at 68184610Salfred * http://www.prolific.com.tw. The datasheets don't contain full 69184610Salfred * programming information for the chip. 70184610Salfred * 71184610Salfred * PL-2303HX is probably programmed the same as PL-2303X. 72184610Salfred * 73184610Salfred * There are several differences between PL-2303 and PL-2303(H)X. 74184610Salfred * PL-2303(H)X can do higher bitrate in bulk mode, has _probably_ 75184610Salfred * different command for controlling CRTSCTS and needs special 76184610Salfred * sequence of commands for initialization which aren't also 77184610Salfred * documented in the datasheet. 78184610Salfred */ 79184610Salfred 80194677Sthompsa#include <sys/stdint.h> 81194677Sthompsa#include <sys/stddef.h> 82194677Sthompsa#include <sys/param.h> 83194677Sthompsa#include <sys/queue.h> 84194677Sthompsa#include <sys/types.h> 85194677Sthompsa#include <sys/systm.h> 86194677Sthompsa#include <sys/kernel.h> 87194677Sthompsa#include <sys/bus.h> 88194677Sthompsa#include <sys/module.h> 89194677Sthompsa#include <sys/lock.h> 90194677Sthompsa#include <sys/mutex.h> 91194677Sthompsa#include <sys/condvar.h> 92194677Sthompsa#include <sys/sysctl.h> 93194677Sthompsa#include <sys/sx.h> 94194677Sthompsa#include <sys/unistd.h> 95194677Sthompsa#include <sys/callout.h> 96194677Sthompsa#include <sys/malloc.h> 97194677Sthompsa#include <sys/priv.h> 98194677Sthompsa 99188942Sthompsa#include <dev/usb/usb.h> 100194677Sthompsa#include <dev/usb/usbdi.h> 101194677Sthompsa#include <dev/usb/usbdi_util.h> 102188942Sthompsa#include <dev/usb/usb_cdc.h> 103194677Sthompsa#include "usbdevs.h" 104184610Salfred 105184610Salfred#define USB_DEBUG_VAR uplcom_debug 106188942Sthompsa#include <dev/usb/usb_debug.h> 107188942Sthompsa#include <dev/usb/usb_process.h> 108184610Salfred 109188942Sthompsa#include <dev/usb/serial/usb_serial.h> 110184610Salfred 111207077Sthompsa#ifdef USB_DEBUG 112184610Salfredstatic int uplcom_debug = 0; 113184610Salfred 114227309Sedstatic SYSCTL_NODE(_hw_usb, OID_AUTO, uplcom, CTLFLAG_RW, 0, "USB uplcom"); 115276701ShselaskySYSCTL_INT(_hw_usb_uplcom, OID_AUTO, debug, CTLFLAG_RWTUN, 116184610Salfred &uplcom_debug, 0, "Debug level"); 117184610Salfred#endif 118184610Salfred 119184610Salfred#define UPLCOM_MODVER 1 /* module version */ 120184610Salfred 121184610Salfred#define UPLCOM_CONFIG_INDEX 0 122184610Salfred#define UPLCOM_IFACE_INDEX 0 123184610Salfred#define UPLCOM_SECOND_IFACE_INDEX 1 124184610Salfred 125184610Salfred#ifndef UPLCOM_INTR_INTERVAL 126184610Salfred#define UPLCOM_INTR_INTERVAL 0 /* default */ 127184610Salfred#endif 128184610Salfred 129184610Salfred#define UPLCOM_BULK_BUF_SIZE 1024 /* bytes */ 130184610Salfred 131184610Salfred#define UPLCOM_SET_REQUEST 0x01 132184610Salfred#define UPLCOM_SET_CRTSCTS 0x41 133184610Salfred#define UPLCOM_SET_CRTSCTS_PL2303X 0x61 134184610Salfred#define RSAQ_STATUS_CTS 0x80 135184610Salfred#define RSAQ_STATUS_DSR 0x02 136184610Salfred#define RSAQ_STATUS_DCD 0x01 137184610Salfred 138184610Salfred#define TYPE_PL2303 0 139211111Sgavin#define TYPE_PL2303HX 1 140184610Salfred 141187259Sthompsaenum { 142187259Sthompsa UPLCOM_BULK_DT_WR, 143187259Sthompsa UPLCOM_BULK_DT_RD, 144187259Sthompsa UPLCOM_INTR_DT_RD, 145188413Sthompsa UPLCOM_N_TRANSFER, 146187259Sthompsa}; 147187259Sthompsa 148184610Salfredstruct uplcom_softc { 149192984Sthompsa struct ucom_super_softc sc_super_ucom; 150192984Sthompsa struct ucom_softc sc_ucom; 151184610Salfred 152192984Sthompsa struct usb_xfer *sc_xfer[UPLCOM_N_TRANSFER]; 153192984Sthompsa struct usb_device *sc_udev; 154189265Sthompsa struct mtx sc_mtx; 155184610Salfred 156184610Salfred uint16_t sc_line; 157184610Salfred 158184610Salfred uint8_t sc_lsr; /* local status register */ 159184610Salfred uint8_t sc_msr; /* uplcom status register */ 160184610Salfred uint8_t sc_chiptype; /* type of chip */ 161184610Salfred uint8_t sc_ctrl_iface_no; 162184610Salfred uint8_t sc_data_iface_no; 163184610Salfred uint8_t sc_iface_index[2]; 164184610Salfred}; 165184610Salfred 166184610Salfred/* prototypes */ 167184610Salfred 168193045Sthompsastatic usb_error_t uplcom_reset(struct uplcom_softc *, struct usb_device *); 169211111Sgavinstatic usb_error_t uplcom_pl2303_do(struct usb_device *, int8_t, uint8_t, 170211111Sgavin uint16_t, uint16_t, uint16_t); 171211111Sgavinstatic int uplcom_pl2303_init(struct usb_device *, uint8_t); 172239180Shselaskystatic void uplcom_free(struct ucom_softc *); 173192984Sthompsastatic void uplcom_cfg_set_dtr(struct ucom_softc *, uint8_t); 174192984Sthompsastatic void uplcom_cfg_set_rts(struct ucom_softc *, uint8_t); 175192984Sthompsastatic void uplcom_cfg_set_break(struct ucom_softc *, uint8_t); 176192984Sthompsastatic int uplcom_pre_param(struct ucom_softc *, struct termios *); 177192984Sthompsastatic void uplcom_cfg_param(struct ucom_softc *, struct termios *); 178192984Sthompsastatic void uplcom_start_read(struct ucom_softc *); 179192984Sthompsastatic void uplcom_stop_read(struct ucom_softc *); 180192984Sthompsastatic void uplcom_start_write(struct ucom_softc *); 181192984Sthompsastatic void uplcom_stop_write(struct ucom_softc *); 182192984Sthompsastatic void uplcom_cfg_get_status(struct ucom_softc *, uint8_t *, 183185948Sthompsa uint8_t *); 184197570Sthompsastatic void uplcom_poll(struct ucom_softc *ucom); 185184610Salfred 186184610Salfredstatic device_probe_t uplcom_probe; 187184610Salfredstatic device_attach_t uplcom_attach; 188184610Salfredstatic device_detach_t uplcom_detach; 189239299Shselaskystatic void uplcom_free_softc(struct uplcom_softc *); 190184610Salfred 191193045Sthompsastatic usb_callback_t uplcom_intr_callback; 192193045Sthompsastatic usb_callback_t uplcom_write_callback; 193193045Sthompsastatic usb_callback_t uplcom_read_callback; 194184610Salfred 195192984Sthompsastatic const struct usb_config uplcom_config_data[UPLCOM_N_TRANSFER] = { 196184610Salfred 197187259Sthompsa [UPLCOM_BULK_DT_WR] = { 198184610Salfred .type = UE_BULK, 199184610Salfred .endpoint = UE_ADDR_ANY, 200184610Salfred .direction = UE_DIR_OUT, 201190734Sthompsa .bufsize = UPLCOM_BULK_BUF_SIZE, 202190734Sthompsa .flags = {.pipe_bof = 1,.force_short_xfer = 1,}, 203190734Sthompsa .callback = &uplcom_write_callback, 204184610Salfred .if_index = 0, 205184610Salfred }, 206184610Salfred 207187259Sthompsa [UPLCOM_BULK_DT_RD] = { 208184610Salfred .type = UE_BULK, 209184610Salfred .endpoint = UE_ADDR_ANY, 210184610Salfred .direction = UE_DIR_IN, 211190734Sthompsa .bufsize = UPLCOM_BULK_BUF_SIZE, 212190734Sthompsa .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 213190734Sthompsa .callback = &uplcom_read_callback, 214184610Salfred .if_index = 0, 215184610Salfred }, 216184610Salfred 217187259Sthompsa [UPLCOM_INTR_DT_RD] = { 218184610Salfred .type = UE_INTERRUPT, 219184610Salfred .endpoint = UE_ADDR_ANY, 220184610Salfred .direction = UE_DIR_IN, 221190734Sthompsa .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 222190734Sthompsa .bufsize = 0, /* use wMaxPacketSize */ 223190734Sthompsa .callback = &uplcom_intr_callback, 224184610Salfred .if_index = 1, 225184610Salfred }, 226184610Salfred}; 227184610Salfred 228194099Sthompsastatic struct ucom_callback uplcom_callback = { 229194228Sthompsa .ucom_cfg_get_status = &uplcom_cfg_get_status, 230194228Sthompsa .ucom_cfg_set_dtr = &uplcom_cfg_set_dtr, 231194228Sthompsa .ucom_cfg_set_rts = &uplcom_cfg_set_rts, 232194228Sthompsa .ucom_cfg_set_break = &uplcom_cfg_set_break, 233194228Sthompsa .ucom_cfg_param = &uplcom_cfg_param, 234194228Sthompsa .ucom_pre_param = &uplcom_pre_param, 235194228Sthompsa .ucom_start_read = &uplcom_start_read, 236194228Sthompsa .ucom_stop_read = &uplcom_stop_read, 237194228Sthompsa .ucom_start_write = &uplcom_start_write, 238194228Sthompsa .ucom_stop_write = &uplcom_stop_write, 239197570Sthompsa .ucom_poll = &uplcom_poll, 240239180Shselasky .ucom_free = &uplcom_free, 241184610Salfred}; 242184610Salfred 243211111Sgavin#define UPLCOM_DEV(v,p) \ 244211111Sgavin { USB_VENDOR(USB_VENDOR_##v), USB_PRODUCT(USB_PRODUCT_##v##_##p) } 245184610Salfred 246223486Shselaskystatic const STRUCT_USB_HOST_ID uplcom_devs[] = { 247211153Sgavin UPLCOM_DEV(ACERP, S81), /* BenQ S81 phone */ 248211153Sgavin UPLCOM_DEV(ADLINK, ND6530), /* ADLINK ND-6530 USB-Serial */ 249211153Sgavin UPLCOM_DEV(ALCATEL, OT535), /* Alcatel One Touch 535/735 */ 250211153Sgavin UPLCOM_DEV(ALCOR, AU9720), /* Alcor AU9720 USB 2.0-RS232 */ 251211153Sgavin UPLCOM_DEV(ANCHOR, SERIAL), /* Anchor Serial adapter */ 252211111Sgavin UPLCOM_DEV(ATEN, UC232A), /* PLANEX USB-RS232 URS-03 */ 253217274Sgavin UPLCOM_DEV(BELKIN, F5U257), /* Belkin F5U257 USB to Serial */ 254211111Sgavin UPLCOM_DEV(COREGA, CGUSBRS232R), /* Corega CG-USBRS232R */ 255211153Sgavin UPLCOM_DEV(EPSON, CRESSI_EDY), /* Cressi Edy diving computer */ 256217202Sgavin UPLCOM_DEV(EPSON, N2ITION3), /* Zeagle N2iTion3 diving computer */ 257217274Sgavin UPLCOM_DEV(ELECOM, UCSGT), /* ELECOM UC-SGT Serial Adapter */ 258217274Sgavin UPLCOM_DEV(ELECOM, UCSGT0), /* ELECOM UC-SGT Serial Adapter */ 259211111Sgavin UPLCOM_DEV(HAL, IMR001), /* HAL Corporation Crossam2+USB */ 260211153Sgavin UPLCOM_DEV(HP, LD220), /* HP LD220 POS Display */ 261211111Sgavin UPLCOM_DEV(IODATA, USBRSAQ), /* I/O DATA USB-RSAQ */ 262211111Sgavin UPLCOM_DEV(IODATA, USBRSAQ5), /* I/O DATA USB-RSAQ5 */ 263211153Sgavin UPLCOM_DEV(ITEGNO, WM1080A), /* iTegno WM1080A GSM/GFPRS modem */ 264211153Sgavin UPLCOM_DEV(ITEGNO, WM2080A), /* iTegno WM2080A CDMA modem */ 265211153Sgavin UPLCOM_DEV(LEADTEK, 9531), /* Leadtek 9531 GPS */ 266211153Sgavin UPLCOM_DEV(MICROSOFT, 700WX), /* Microsoft Palm 700WX */ 267211111Sgavin UPLCOM_DEV(MOBILEACTION, MA620), /* Mobile Action MA-620 Infrared Adapter */ 268211153Sgavin UPLCOM_DEV(NETINDEX, WS002IN), /* Willcom W-S002IN */ 269211153Sgavin UPLCOM_DEV(NOKIA2, CA42), /* Nokia CA-42 cable */ 270211153Sgavin UPLCOM_DEV(OTI, DKU5), /* OTI DKU-5 cable */ 271211153Sgavin UPLCOM_DEV(PANASONIC, TYTP50P6S), /* Panasonic TY-TP50P6-S flat screen */ 272211153Sgavin UPLCOM_DEV(PLX, CA42), /* PLX CA-42 clone cable */ 273211153Sgavin UPLCOM_DEV(PROLIFIC, ALLTRONIX_GPRS), /* Alltronix ACM003U00 modem */ 274211153Sgavin UPLCOM_DEV(PROLIFIC, ALDIGA_AL11U), /* AlDiga AL-11U modem */ 275211153Sgavin UPLCOM_DEV(PROLIFIC, DCU11), /* DCU-11 Phone Cable */ 276211153Sgavin UPLCOM_DEV(PROLIFIC, HCR331), /* HCR331 Card Reader */ 277211153Sgavin UPLCOM_DEV(PROLIFIC, MICROMAX_610U), /* Micromax 610U modem */ 278238766Sgavin UPLCOM_DEV(PROLIFIC, MOTOROLA), /* Motorola cable */ 279211111Sgavin UPLCOM_DEV(PROLIFIC, PHAROS), /* Prolific Pharos */ 280211153Sgavin UPLCOM_DEV(PROLIFIC, PL2303), /* Generic adapter */ 281211111Sgavin UPLCOM_DEV(PROLIFIC, RSAQ2), /* I/O DATA USB-RSAQ2 */ 282211111Sgavin UPLCOM_DEV(PROLIFIC, RSAQ3), /* I/O DATA USB-RSAQ3 */ 283217061Sgavin UPLCOM_DEV(PROLIFIC, UIC_MSR206), /* UIC MSR206 Card Reader */ 284211153Sgavin UPLCOM_DEV(PROLIFIC2, PL2303), /* Prolific adapter */ 285217274Sgavin UPLCOM_DEV(RADIOSHACK, USBCABLE), /* Radio Shack USB Adapter */ 286211111Sgavin UPLCOM_DEV(RATOC, REXUSB60), /* RATOC REX-USB60 */ 287211111Sgavin UPLCOM_DEV(SAGEM, USBSERIAL), /* Sagem USB-Serial Controller */ 288211153Sgavin UPLCOM_DEV(SAMSUNG, I330), /* Samsung I330 phone cradle */ 289211153Sgavin UPLCOM_DEV(SANWA, KB_USB2), /* Sanwa KB-USB2 Multimeter cable */ 290217274Sgavin UPLCOM_DEV(SIEMENS3, EF81), /* Siemens EF81 */ 291217274Sgavin UPLCOM_DEV(SIEMENS3, SX1), /* Siemens SX1 */ 292217274Sgavin UPLCOM_DEV(SIEMENS3, X65), /* Siemens X65 */ 293217274Sgavin UPLCOM_DEV(SIEMENS3, X75), /* Siemens X75 */ 294211111Sgavin UPLCOM_DEV(SITECOM, SERIAL), /* Sitecom USB to Serial */ 295217274Sgavin UPLCOM_DEV(SMART, PL2303), /* SMART Technologies USB to Serial */ 296211153Sgavin UPLCOM_DEV(SONY, QN3), /* Sony QN3 phone cable */ 297211153Sgavin UPLCOM_DEV(SONYERICSSON, DATAPILOT), /* Sony Ericsson Datapilot */ 298211153Sgavin UPLCOM_DEV(SONYERICSSON, DCU10), /* Sony Ericsson DCU-10 Cable */ 299211111Sgavin UPLCOM_DEV(SOURCENEXT, KEIKAI8), /* SOURCENEXT KeikaiDenwa 8 */ 300211111Sgavin UPLCOM_DEV(SOURCENEXT, KEIKAI8_CHG), /* SOURCENEXT KeikaiDenwa 8 with charger */ 301211153Sgavin UPLCOM_DEV(SPEEDDRAGON, MS3303H), /* Speed Dragon USB-Serial */ 302211153Sgavin UPLCOM_DEV(SYNTECH, CPT8001C), /* Syntech CPT-8001C Barcode scanner */ 303211111Sgavin UPLCOM_DEV(TDK, UHA6400), /* TDK USB-PHS Adapter UHA6400 */ 304211153Sgavin UPLCOM_DEV(TDK, UPA9664), /* TDK USB-PHS Adapter UPA9664 */ 305217274Sgavin UPLCOM_DEV(TRIPPLITE, U209), /* Tripp-Lite U209-000-R USB to Serial */ 306211153Sgavin UPLCOM_DEV(YCCABLE, PL2303), /* YC Cable USB-Serial */ 307184610Salfred}; 308201028Sthompsa#undef UPLCOM_DEV 309184610Salfred 310184610Salfredstatic device_method_t uplcom_methods[] = { 311184610Salfred DEVMETHOD(device_probe, uplcom_probe), 312184610Salfred DEVMETHOD(device_attach, uplcom_attach), 313184610Salfred DEVMETHOD(device_detach, uplcom_detach), 314239180Shselasky DEVMETHOD_END 315184610Salfred}; 316184610Salfred 317184610Salfredstatic devclass_t uplcom_devclass; 318184610Salfred 319184610Salfredstatic driver_t uplcom_driver = { 320184610Salfred .name = "uplcom", 321184610Salfred .methods = uplcom_methods, 322184610Salfred .size = sizeof(struct uplcom_softc), 323184610Salfred}; 324184610Salfred 325189275SthompsaDRIVER_MODULE(uplcom, uhub, uplcom_driver, uplcom_devclass, NULL, 0); 326188942SthompsaMODULE_DEPEND(uplcom, ucom, 1, 1, 1); 327188942SthompsaMODULE_DEPEND(uplcom, usb, 1, 1, 1); 328184610SalfredMODULE_VERSION(uplcom, UPLCOM_MODVER); 329292080SimpUSB_PNP_HOST_INFO(uplcom_devs); 330184610Salfred 331184610Salfredstatic int 332184610Salfreduplcom_probe(device_t dev) 333184610Salfred{ 334192984Sthompsa struct usb_attach_arg *uaa = device_get_ivars(dev); 335184610Salfred 336184610Salfred DPRINTFN(11, "\n"); 337184610Salfred 338192499Sthompsa if (uaa->usb_mode != USB_MODE_HOST) { 339184610Salfred return (ENXIO); 340184610Salfred } 341184610Salfred if (uaa->info.bConfigIndex != UPLCOM_CONFIG_INDEX) { 342184610Salfred return (ENXIO); 343184610Salfred } 344184610Salfred if (uaa->info.bIfaceIndex != UPLCOM_IFACE_INDEX) { 345184610Salfred return (ENXIO); 346184610Salfred } 347194228Sthompsa return (usbd_lookup_id_by_uaa(uplcom_devs, sizeof(uplcom_devs), uaa)); 348184610Salfred} 349184610Salfred 350184610Salfredstatic int 351184610Salfreduplcom_attach(device_t dev) 352184610Salfred{ 353192984Sthompsa struct usb_attach_arg *uaa = device_get_ivars(dev); 354184610Salfred struct uplcom_softc *sc = device_get_softc(dev); 355192984Sthompsa struct usb_interface *iface; 356192984Sthompsa struct usb_interface_descriptor *id; 357211111Sgavin struct usb_device_descriptor *dd; 358184610Salfred int error; 359184610Salfred 360184610Salfred DPRINTFN(11, "\n"); 361184610Salfred 362194228Sthompsa device_set_usb_desc(dev); 363189265Sthompsa mtx_init(&sc->sc_mtx, "uplcom", NULL, MTX_DEF); 364239180Shselasky ucom_ref(&sc->sc_super_ucom); 365184610Salfred 366184610Salfred DPRINTF("sc = %p\n", sc); 367184610Salfred 368184610Salfred sc->sc_udev = uaa->device; 369184610Salfred 370211111Sgavin /* Determine the chip type. This algorithm is taken from Linux. */ 371211111Sgavin dd = usbd_get_device_descriptor(sc->sc_udev); 372211111Sgavin if (dd->bDeviceClass == 0x02) 373211111Sgavin sc->sc_chiptype = TYPE_PL2303; 374211111Sgavin else if (dd->bMaxPacketSize == 0x40) 375211111Sgavin sc->sc_chiptype = TYPE_PL2303HX; 376211111Sgavin else 377211111Sgavin sc->sc_chiptype = TYPE_PL2303; 378211111Sgavin 379184610Salfred DPRINTF("chiptype: %s\n", 380211111Sgavin (sc->sc_chiptype == TYPE_PL2303HX) ? 381184610Salfred "2303X" : "2303"); 382184610Salfred 383184610Salfred /* 384184610Salfred * USB-RSAQ1 has two interface 385184610Salfred * 386184610Salfred * USB-RSAQ1 | USB-RSAQ2 387184610Salfred * -----------------+----------------- 388184610Salfred * Interface 0 |Interface 0 389184610Salfred * Interrupt(0x81) | Interrupt(0x81) 390184610Salfred * -----------------+ BulkIN(0x02) 391184610Salfred * Interface 1 | BulkOUT(0x83) 392184610Salfred * BulkIN(0x02) | 393184610Salfred * BulkOUT(0x83) | 394184610Salfred */ 395184610Salfred 396184610Salfred sc->sc_ctrl_iface_no = uaa->info.bIfaceNum; 397184610Salfred sc->sc_iface_index[1] = UPLCOM_IFACE_INDEX; 398184610Salfred 399194228Sthompsa iface = usbd_get_iface(uaa->device, UPLCOM_SECOND_IFACE_INDEX); 400184610Salfred if (iface) { 401194228Sthompsa id = usbd_get_interface_descriptor(iface); 402184610Salfred if (id == NULL) { 403199816Sthompsa device_printf(dev, "no interface descriptor (2)\n"); 404184610Salfred goto detach; 405184610Salfred } 406184610Salfred sc->sc_data_iface_no = id->bInterfaceNumber; 407184610Salfred sc->sc_iface_index[0] = UPLCOM_SECOND_IFACE_INDEX; 408194228Sthompsa usbd_set_parent_iface(uaa->device, 409184610Salfred UPLCOM_SECOND_IFACE_INDEX, uaa->info.bIfaceIndex); 410184610Salfred } else { 411184610Salfred sc->sc_data_iface_no = sc->sc_ctrl_iface_no; 412184610Salfred sc->sc_iface_index[0] = UPLCOM_IFACE_INDEX; 413184610Salfred } 414184610Salfred 415194228Sthompsa error = usbd_transfer_setup(uaa->device, 416184610Salfred sc->sc_iface_index, sc->sc_xfer, uplcom_config_data, 417189265Sthompsa UPLCOM_N_TRANSFER, sc, &sc->sc_mtx); 418184610Salfred if (error) { 419184610Salfred DPRINTF("one or more missing USB endpoints, " 420194228Sthompsa "error=%s\n", usbd_errstr(error)); 421184610Salfred goto detach; 422184610Salfred } 423184610Salfred error = uplcom_reset(sc, uaa->device); 424184610Salfred if (error) { 425184610Salfred device_printf(dev, "reset failed, error=%s\n", 426194228Sthompsa usbd_errstr(error)); 427184610Salfred goto detach; 428184610Salfred } 429184610Salfred 430243380Shselasky if (sc->sc_chiptype != TYPE_PL2303HX) { 431243380Shselasky /* HX variants seem to lock up after a clear stall request. */ 432243380Shselasky mtx_lock(&sc->sc_mtx); 433243380Shselasky usbd_xfer_set_stall(sc->sc_xfer[UPLCOM_BULK_DT_WR]); 434243380Shselasky usbd_xfer_set_stall(sc->sc_xfer[UPLCOM_BULK_DT_RD]); 435243380Shselasky mtx_unlock(&sc->sc_mtx); 436243380Shselasky } else { 437243380Shselasky if (uplcom_pl2303_do(sc->sc_udev, UT_WRITE_VENDOR_DEVICE, 438243380Shselasky UPLCOM_SET_REQUEST, 8, 0, 0) || 439243380Shselasky uplcom_pl2303_do(sc->sc_udev, UT_WRITE_VENDOR_DEVICE, 440243380Shselasky UPLCOM_SET_REQUEST, 9, 0, 0)) { 441243380Shselasky goto detach; 442243380Shselasky } 443243380Shselasky } 444243380Shselasky 445194228Sthompsa error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc, 446189265Sthompsa &uplcom_callback, &sc->sc_mtx); 447184610Salfred if (error) { 448184610Salfred goto detach; 449184610Salfred } 450184610Salfred /* 451184610Salfred * do the initialization during attach so that the system does not 452184610Salfred * sleep during open: 453184610Salfred */ 454211111Sgavin if (uplcom_pl2303_init(uaa->device, sc->sc_chiptype)) { 455211111Sgavin device_printf(dev, "init failed\n"); 456211111Sgavin goto detach; 457184610Salfred } 458214843Sn_hibma ucom_set_pnpinfo_usb(&sc->sc_super_ucom, dev); 459214843Sn_hibma 460184610Salfred return (0); 461184610Salfred 462184610Salfreddetach: 463184610Salfred uplcom_detach(dev); 464184610Salfred return (ENXIO); 465184610Salfred} 466184610Salfred 467184610Salfredstatic int 468184610Salfreduplcom_detach(device_t dev) 469184610Salfred{ 470184610Salfred struct uplcom_softc *sc = device_get_softc(dev); 471184610Salfred 472184610Salfred DPRINTF("sc=%p\n", sc); 473184610Salfred 474214761Sn_hibma ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom); 475194228Sthompsa usbd_transfer_unsetup(sc->sc_xfer, UPLCOM_N_TRANSFER); 476184610Salfred 477239299Shselasky device_claim_softc(dev); 478239299Shselasky 479239299Shselasky uplcom_free_softc(sc); 480239299Shselasky 481184610Salfred return (0); 482184610Salfred} 483184610Salfred 484239180ShselaskyUCOM_UNLOAD_DRAIN(uplcom); 485239180Shselasky 486239180Shselaskystatic void 487239299Shselaskyuplcom_free_softc(struct uplcom_softc *sc) 488239180Shselasky{ 489239180Shselasky if (ucom_unref(&sc->sc_super_ucom)) { 490239299Shselasky mtx_destroy(&sc->sc_mtx); 491239299Shselasky device_free_softc(sc); 492239180Shselasky } 493239180Shselasky} 494239180Shselasky 495239180Shselaskystatic void 496239180Shselaskyuplcom_free(struct ucom_softc *ucom) 497239180Shselasky{ 498239299Shselasky uplcom_free_softc(ucom->sc_parent); 499239180Shselasky} 500239180Shselasky 501193045Sthompsastatic usb_error_t 502192984Sthompsauplcom_reset(struct uplcom_softc *sc, struct usb_device *udev) 503184610Salfred{ 504192984Sthompsa struct usb_device_request req; 505184610Salfred 506184610Salfred req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 507184610Salfred req.bRequest = UPLCOM_SET_REQUEST; 508184610Salfred USETW(req.wValue, 0); 509184610Salfred req.wIndex[0] = sc->sc_data_iface_no; 510184610Salfred req.wIndex[1] = 0; 511184610Salfred USETW(req.wLength, 0); 512184610Salfred 513194228Sthompsa return (usbd_do_request(udev, NULL, &req, NULL)); 514184610Salfred} 515184610Salfred 516211111Sgavinstatic usb_error_t 517211111Sgavinuplcom_pl2303_do(struct usb_device *udev, int8_t req_type, uint8_t request, 518211111Sgavin uint16_t value, uint16_t index, uint16_t length) 519184610Salfred{ 520192984Sthompsa struct usb_device_request req; 521193045Sthompsa usb_error_t err; 522184610Salfred uint8_t buf[4]; 523184610Salfred 524211111Sgavin req.bmRequestType = req_type; 525211111Sgavin req.bRequest = request; 526211111Sgavin USETW(req.wValue, value); 527211111Sgavin USETW(req.wIndex, index); 528211111Sgavin USETW(req.wLength, length); 529184610Salfred 530211111Sgavin err = usbd_do_request(udev, NULL, &req, buf); 531211111Sgavin if (err) { 532211111Sgavin DPRINTF("error=%s\n", usbd_errstr(err)); 533211111Sgavin return (1); 534184610Salfred } 535184610Salfred return (0); 536184610Salfred} 537184610Salfred 538211111Sgavinstatic int 539211111Sgavinuplcom_pl2303_init(struct usb_device *udev, uint8_t chiptype) 540211111Sgavin{ 541211111Sgavin int err; 542211111Sgavin 543211111Sgavin if (uplcom_pl2303_do(udev, UT_READ_VENDOR_DEVICE, UPLCOM_SET_REQUEST, 0x8484, 0, 1) 544211111Sgavin || uplcom_pl2303_do(udev, UT_WRITE_VENDOR_DEVICE, UPLCOM_SET_REQUEST, 0x0404, 0, 0) 545211111Sgavin || uplcom_pl2303_do(udev, UT_READ_VENDOR_DEVICE, UPLCOM_SET_REQUEST, 0x8484, 0, 1) 546211111Sgavin || uplcom_pl2303_do(udev, UT_READ_VENDOR_DEVICE, UPLCOM_SET_REQUEST, 0x8383, 0, 1) 547211111Sgavin || uplcom_pl2303_do(udev, UT_READ_VENDOR_DEVICE, UPLCOM_SET_REQUEST, 0x8484, 0, 1) 548211111Sgavin || uplcom_pl2303_do(udev, UT_WRITE_VENDOR_DEVICE, UPLCOM_SET_REQUEST, 0x0404, 1, 0) 549211111Sgavin || uplcom_pl2303_do(udev, UT_READ_VENDOR_DEVICE, UPLCOM_SET_REQUEST, 0x8484, 0, 1) 550211111Sgavin || uplcom_pl2303_do(udev, UT_READ_VENDOR_DEVICE, UPLCOM_SET_REQUEST, 0x8383, 0, 1) 551211111Sgavin || uplcom_pl2303_do(udev, UT_WRITE_VENDOR_DEVICE, UPLCOM_SET_REQUEST, 0, 1, 0) 552211111Sgavin || uplcom_pl2303_do(udev, UT_WRITE_VENDOR_DEVICE, UPLCOM_SET_REQUEST, 1, 0, 0)) 553211111Sgavin return (EIO); 554211111Sgavin 555211111Sgavin if (chiptype == TYPE_PL2303HX) 556211111Sgavin err = uplcom_pl2303_do(udev, UT_WRITE_VENDOR_DEVICE, UPLCOM_SET_REQUEST, 2, 0x44, 0); 557211111Sgavin else 558211111Sgavin err = uplcom_pl2303_do(udev, UT_WRITE_VENDOR_DEVICE, UPLCOM_SET_REQUEST, 2, 0x24, 0); 559211111Sgavin if (err) 560211111Sgavin return (EIO); 561211111Sgavin 562211111Sgavin return (0); 563211111Sgavin} 564211111Sgavin 565184610Salfredstatic void 566192984Sthompsauplcom_cfg_set_dtr(struct ucom_softc *ucom, uint8_t onoff) 567184610Salfred{ 568184610Salfred struct uplcom_softc *sc = ucom->sc_parent; 569192984Sthompsa struct usb_device_request req; 570184610Salfred 571184610Salfred DPRINTF("onoff = %d\n", onoff); 572184610Salfred 573184610Salfred if (onoff) 574184610Salfred sc->sc_line |= UCDC_LINE_DTR; 575184610Salfred else 576184610Salfred sc->sc_line &= ~UCDC_LINE_DTR; 577184610Salfred 578184610Salfred req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 579184610Salfred req.bRequest = UCDC_SET_CONTROL_LINE_STATE; 580184610Salfred USETW(req.wValue, sc->sc_line); 581184610Salfred req.wIndex[0] = sc->sc_data_iface_no; 582184610Salfred req.wIndex[1] = 0; 583184610Salfred USETW(req.wLength, 0); 584184610Salfred 585194228Sthompsa ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 586188413Sthompsa &req, NULL, 0, 1000); 587184610Salfred} 588184610Salfred 589184610Salfredstatic void 590192984Sthompsauplcom_cfg_set_rts(struct ucom_softc *ucom, uint8_t onoff) 591184610Salfred{ 592184610Salfred struct uplcom_softc *sc = ucom->sc_parent; 593192984Sthompsa struct usb_device_request req; 594184610Salfred 595184610Salfred DPRINTF("onoff = %d\n", onoff); 596184610Salfred 597184610Salfred if (onoff) 598184610Salfred sc->sc_line |= UCDC_LINE_RTS; 599184610Salfred else 600184610Salfred sc->sc_line &= ~UCDC_LINE_RTS; 601184610Salfred 602184610Salfred req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 603184610Salfred req.bRequest = UCDC_SET_CONTROL_LINE_STATE; 604184610Salfred USETW(req.wValue, sc->sc_line); 605184610Salfred req.wIndex[0] = sc->sc_data_iface_no; 606184610Salfred req.wIndex[1] = 0; 607184610Salfred USETW(req.wLength, 0); 608184610Salfred 609194228Sthompsa ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 610188413Sthompsa &req, NULL, 0, 1000); 611184610Salfred} 612184610Salfred 613184610Salfredstatic void 614192984Sthompsauplcom_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff) 615184610Salfred{ 616184610Salfred struct uplcom_softc *sc = ucom->sc_parent; 617192984Sthompsa struct usb_device_request req; 618184610Salfred uint16_t temp; 619184610Salfred 620184610Salfred DPRINTF("onoff = %d\n", onoff); 621184610Salfred 622184610Salfred temp = (onoff ? UCDC_BREAK_ON : UCDC_BREAK_OFF); 623184610Salfred 624184610Salfred req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 625184610Salfred req.bRequest = UCDC_SEND_BREAK; 626184610Salfred USETW(req.wValue, temp); 627184610Salfred req.wIndex[0] = sc->sc_data_iface_no; 628184610Salfred req.wIndex[1] = 0; 629184610Salfred USETW(req.wLength, 0); 630184610Salfred 631194228Sthompsa ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 632188413Sthompsa &req, NULL, 0, 1000); 633184610Salfred} 634184610Salfred 635233774Shselaskystatic const uint32_t uplcom_rates[] = { 636184610Salfred 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600, 14400, 637184610Salfred 19200, 28800, 38400, 57600, 115200, 638184610Salfred /* 639184610Salfred * Higher speeds are probably possible. PL2303X supports up to 640184610Salfred * 6Mb and can set any rate 641184610Salfred */ 642184610Salfred 230400, 460800, 614400, 921600, 1228800 643184610Salfred}; 644184610Salfred 645298300Spfg#define N_UPLCOM_RATES nitems(uplcom_rates) 646184610Salfred 647184610Salfredstatic int 648192984Sthompsauplcom_pre_param(struct ucom_softc *ucom, struct termios *t) 649184610Salfred{ 650211083Sgavin struct uplcom_softc *sc = ucom->sc_parent; 651184610Salfred uint8_t i; 652184610Salfred 653184610Salfred DPRINTF("\n"); 654184610Salfred 655211083Sgavin /** 656211083Sgavin * Check requested baud rate. 657211083Sgavin * 658211083Sgavin * The PL2303 can only set specific baud rates, up to 1228800 baud. 659211083Sgavin * The PL2303X can set any baud rate up to 6Mb. 660211083Sgavin * The PL2303HX rev. D can set any baud rate up to 12Mb. 661211083Sgavin * 662211083Sgavin * XXX: We currently cannot identify the PL2303HX rev. D, so treat 663211083Sgavin * it the same as the PL2303X. 664211083Sgavin */ 665211111Sgavin if (sc->sc_chiptype != TYPE_PL2303HX) { 666211083Sgavin for (i = 0; i < N_UPLCOM_RATES; i++) { 667211083Sgavin if (uplcom_rates[i] == t->c_ospeed) 668211083Sgavin return (0); 669184610Salfred } 670211083Sgavin } else { 671211083Sgavin if (t->c_ospeed <= 6000000) 672211083Sgavin return (0); 673184610Salfred } 674184610Salfred 675211083Sgavin DPRINTF("uplcom_param: bad baud rate (%d)\n", t->c_ospeed); 676211083Sgavin return (EIO); 677184610Salfred} 678184610Salfred 679184610Salfredstatic void 680192984Sthompsauplcom_cfg_param(struct ucom_softc *ucom, struct termios *t) 681184610Salfred{ 682184610Salfred struct uplcom_softc *sc = ucom->sc_parent; 683192984Sthompsa struct usb_cdc_line_state ls; 684192984Sthompsa struct usb_device_request req; 685184610Salfred 686184610Salfred DPRINTF("sc = %p\n", sc); 687184610Salfred 688227461Shselasky memset(&ls, 0, sizeof(ls)); 689184610Salfred 690184610Salfred USETDW(ls.dwDTERate, t->c_ospeed); 691184610Salfred 692184610Salfred if (t->c_cflag & CSTOPB) { 693184610Salfred ls.bCharFormat = UCDC_STOP_BIT_2; 694184610Salfred } else { 695184610Salfred ls.bCharFormat = UCDC_STOP_BIT_1; 696184610Salfred } 697184610Salfred 698184610Salfred if (t->c_cflag & PARENB) { 699184610Salfred if (t->c_cflag & PARODD) { 700184610Salfred ls.bParityType = UCDC_PARITY_ODD; 701184610Salfred } else { 702184610Salfred ls.bParityType = UCDC_PARITY_EVEN; 703184610Salfred } 704184610Salfred } else { 705184610Salfred ls.bParityType = UCDC_PARITY_NONE; 706184610Salfred } 707184610Salfred 708184610Salfred switch (t->c_cflag & CSIZE) { 709184610Salfred case CS5: 710184610Salfred ls.bDataBits = 5; 711184610Salfred break; 712184610Salfred case CS6: 713184610Salfred ls.bDataBits = 6; 714184610Salfred break; 715184610Salfred case CS7: 716184610Salfred ls.bDataBits = 7; 717184610Salfred break; 718184610Salfred case CS8: 719184610Salfred ls.bDataBits = 8; 720184610Salfred break; 721184610Salfred } 722184610Salfred 723184610Salfred DPRINTF("rate=%d fmt=%d parity=%d bits=%d\n", 724184610Salfred UGETDW(ls.dwDTERate), ls.bCharFormat, 725184610Salfred ls.bParityType, ls.bDataBits); 726184610Salfred 727184610Salfred req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 728184610Salfred req.bRequest = UCDC_SET_LINE_CODING; 729184610Salfred USETW(req.wValue, 0); 730184610Salfred req.wIndex[0] = sc->sc_data_iface_no; 731184610Salfred req.wIndex[1] = 0; 732184610Salfred USETW(req.wLength, UCDC_LINE_STATE_LENGTH); 733184610Salfred 734194228Sthompsa ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 735188413Sthompsa &req, &ls, 0, 1000); 736184610Salfred 737184610Salfred if (t->c_cflag & CRTSCTS) { 738184610Salfred 739184610Salfred DPRINTF("crtscts = on\n"); 740184610Salfred 741184610Salfred req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 742184610Salfred req.bRequest = UPLCOM_SET_REQUEST; 743184610Salfred USETW(req.wValue, 0); 744211111Sgavin if (sc->sc_chiptype == TYPE_PL2303HX) 745184610Salfred USETW(req.wIndex, UPLCOM_SET_CRTSCTS_PL2303X); 746184610Salfred else 747184610Salfred USETW(req.wIndex, UPLCOM_SET_CRTSCTS); 748184610Salfred USETW(req.wLength, 0); 749184610Salfred 750194228Sthompsa ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 751188413Sthompsa &req, NULL, 0, 1000); 752184610Salfred } else { 753184610Salfred req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 754184610Salfred req.bRequest = UPLCOM_SET_REQUEST; 755184610Salfred USETW(req.wValue, 0); 756184610Salfred USETW(req.wIndex, 0); 757184610Salfred USETW(req.wLength, 0); 758194228Sthompsa ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom, 759188413Sthompsa &req, NULL, 0, 1000); 760184610Salfred } 761184610Salfred} 762184610Salfred 763184610Salfredstatic void 764192984Sthompsauplcom_start_read(struct ucom_softc *ucom) 765184610Salfred{ 766184610Salfred struct uplcom_softc *sc = ucom->sc_parent; 767184610Salfred 768184610Salfred /* start interrupt endpoint */ 769194228Sthompsa usbd_transfer_start(sc->sc_xfer[UPLCOM_INTR_DT_RD]); 770184610Salfred 771184610Salfred /* start read endpoint */ 772194228Sthompsa usbd_transfer_start(sc->sc_xfer[UPLCOM_BULK_DT_RD]); 773184610Salfred} 774184610Salfred 775184610Salfredstatic void 776192984Sthompsauplcom_stop_read(struct ucom_softc *ucom) 777184610Salfred{ 778184610Salfred struct uplcom_softc *sc = ucom->sc_parent; 779184610Salfred 780184610Salfred /* stop interrupt endpoint */ 781194228Sthompsa usbd_transfer_stop(sc->sc_xfer[UPLCOM_INTR_DT_RD]); 782184610Salfred 783184610Salfred /* stop read endpoint */ 784194228Sthompsa usbd_transfer_stop(sc->sc_xfer[UPLCOM_BULK_DT_RD]); 785184610Salfred} 786184610Salfred 787184610Salfredstatic void 788192984Sthompsauplcom_start_write(struct ucom_softc *ucom) 789184610Salfred{ 790184610Salfred struct uplcom_softc *sc = ucom->sc_parent; 791184610Salfred 792194228Sthompsa usbd_transfer_start(sc->sc_xfer[UPLCOM_BULK_DT_WR]); 793184610Salfred} 794184610Salfred 795184610Salfredstatic void 796192984Sthompsauplcom_stop_write(struct ucom_softc *ucom) 797184610Salfred{ 798184610Salfred struct uplcom_softc *sc = ucom->sc_parent; 799184610Salfred 800194228Sthompsa usbd_transfer_stop(sc->sc_xfer[UPLCOM_BULK_DT_WR]); 801184610Salfred} 802184610Salfred 803184610Salfredstatic void 804192984Sthompsauplcom_cfg_get_status(struct ucom_softc *ucom, uint8_t *lsr, uint8_t *msr) 805184610Salfred{ 806184610Salfred struct uplcom_softc *sc = ucom->sc_parent; 807184610Salfred 808184610Salfred DPRINTF("\n"); 809184610Salfred 810184610Salfred *lsr = sc->sc_lsr; 811184610Salfred *msr = sc->sc_msr; 812184610Salfred} 813184610Salfred 814184610Salfredstatic void 815194677Sthompsauplcom_intr_callback(struct usb_xfer *xfer, usb_error_t error) 816184610Salfred{ 817194677Sthompsa struct uplcom_softc *sc = usbd_xfer_softc(xfer); 818194677Sthompsa struct usb_page_cache *pc; 819184610Salfred uint8_t buf[9]; 820194677Sthompsa int actlen; 821184610Salfred 822194677Sthompsa usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 823194677Sthompsa 824184610Salfred switch (USB_GET_STATE(xfer)) { 825184610Salfred case USB_ST_TRANSFERRED: 826184610Salfred 827194677Sthompsa DPRINTF("actlen = %u\n", actlen); 828184610Salfred 829194677Sthompsa if (actlen >= 9) { 830184610Salfred 831194677Sthompsa pc = usbd_xfer_get_frame(xfer, 0); 832194677Sthompsa usbd_copy_out(pc, 0, buf, sizeof(buf)); 833184610Salfred 834184610Salfred DPRINTF("status = 0x%02x\n", buf[8]); 835184610Salfred 836184610Salfred sc->sc_lsr = 0; 837184610Salfred sc->sc_msr = 0; 838184610Salfred 839184610Salfred if (buf[8] & RSAQ_STATUS_CTS) { 840184610Salfred sc->sc_msr |= SER_CTS; 841184610Salfred } 842184610Salfred if (buf[8] & RSAQ_STATUS_DSR) { 843184610Salfred sc->sc_msr |= SER_DSR; 844184610Salfred } 845184610Salfred if (buf[8] & RSAQ_STATUS_DCD) { 846184610Salfred sc->sc_msr |= SER_DCD; 847184610Salfred } 848194228Sthompsa ucom_status_change(&sc->sc_ucom); 849184610Salfred } 850184610Salfred case USB_ST_SETUP: 851188413Sthompsatr_setup: 852194677Sthompsa usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 853194228Sthompsa usbd_transfer_submit(xfer); 854184610Salfred return; 855184610Salfred 856184610Salfred default: /* Error */ 857194677Sthompsa if (error != USB_ERR_CANCELLED) { 858188413Sthompsa /* try to clear stall first */ 859194677Sthompsa usbd_xfer_set_stall(xfer); 860188413Sthompsa goto tr_setup; 861184610Salfred } 862184610Salfred return; 863184610Salfred } 864184610Salfred} 865184610Salfred 866184610Salfredstatic void 867194677Sthompsauplcom_write_callback(struct usb_xfer *xfer, usb_error_t error) 868184610Salfred{ 869194677Sthompsa struct uplcom_softc *sc = usbd_xfer_softc(xfer); 870194677Sthompsa struct usb_page_cache *pc; 871184610Salfred uint32_t actlen; 872184610Salfred 873184610Salfred switch (USB_GET_STATE(xfer)) { 874184610Salfred case USB_ST_SETUP: 875184610Salfred case USB_ST_TRANSFERRED: 876188413Sthompsatr_setup: 877194677Sthompsa pc = usbd_xfer_get_frame(xfer, 0); 878194677Sthompsa if (ucom_get_data(&sc->sc_ucom, pc, 0, 879184610Salfred UPLCOM_BULK_BUF_SIZE, &actlen)) { 880184610Salfred 881184610Salfred DPRINTF("actlen = %d\n", actlen); 882184610Salfred 883194677Sthompsa usbd_xfer_set_frame_len(xfer, 0, actlen); 884194228Sthompsa usbd_transfer_submit(xfer); 885184610Salfred } 886184610Salfred return; 887184610Salfred 888184610Salfred default: /* Error */ 889194677Sthompsa if (error != USB_ERR_CANCELLED) { 890188413Sthompsa /* try to clear stall first */ 891194677Sthompsa usbd_xfer_set_stall(xfer); 892188413Sthompsa goto tr_setup; 893184610Salfred } 894184610Salfred return; 895184610Salfred } 896184610Salfred} 897184610Salfred 898184610Salfredstatic void 899194677Sthompsauplcom_read_callback(struct usb_xfer *xfer, usb_error_t error) 900184610Salfred{ 901194677Sthompsa struct uplcom_softc *sc = usbd_xfer_softc(xfer); 902194677Sthompsa struct usb_page_cache *pc; 903194677Sthompsa int actlen; 904184610Salfred 905194677Sthompsa usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL); 906194677Sthompsa 907184610Salfred switch (USB_GET_STATE(xfer)) { 908184610Salfred case USB_ST_TRANSFERRED: 909194677Sthompsa pc = usbd_xfer_get_frame(xfer, 0); 910194677Sthompsa ucom_put_data(&sc->sc_ucom, pc, 0, actlen); 911184610Salfred 912184610Salfred case USB_ST_SETUP: 913188413Sthompsatr_setup: 914194677Sthompsa usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer)); 915194228Sthompsa usbd_transfer_submit(xfer); 916184610Salfred return; 917184610Salfred 918184610Salfred default: /* Error */ 919194677Sthompsa if (error != USB_ERR_CANCELLED) { 920188413Sthompsa /* try to clear stall first */ 921194677Sthompsa usbd_xfer_set_stall(xfer); 922188413Sthompsa goto tr_setup; 923184610Salfred } 924184610Salfred return; 925184610Salfred } 926184610Salfred} 927197570Sthompsa 928197570Sthompsastatic void 929197570Sthompsauplcom_poll(struct ucom_softc *ucom) 930197570Sthompsa{ 931197570Sthompsa struct uplcom_softc *sc = ucom->sc_parent; 932197570Sthompsa usbd_transfer_poll(sc->sc_xfer, UPLCOM_N_TRANSFER); 933197570Sthompsa} 934