Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sys/dev/usb/u3g.c

959 lines
25 KiB
C
Raw Blame History

/* $NetBSD: u3g.c,v 1.24 2011/12/23 00:51:44 jakllsch Exp $ */
/*-
* Copyright (c) 2009 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*
* Copyright (c) 2008 AnyWi Technologies
* Author: Andrea Guzzo <aguzzo@anywi.com>
* * based on uark.c 1.1 2006/08/14 08:30:22 jsg *
* * parts from ubsa.c 183348 2008-09-25 12:00:56Z phk *
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* $FreeBSD$
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: u3g.c,v 1.24 2011/12/23 00:51:44 jakllsch Exp $");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/bus.h>
#include <sys/conf.h>
#include <sys/tty.h>
#include <dev/usb/usb.h>
#include <dev/usb/usbdi.h>
#include <dev/usb/usbdivar.h>
#include <dev/usb/usbdi_util.h>
#include <dev/usb/ucomvar.h>
#include "usbdevs.h"
/*
* We read/write data from/to the device in 4KB chunks to maximise
* performance.
*/
#define U3G_BUFF_SIZE 4096
/*
* Some 3G devices (the Huawei E160/E220 springs to mind here) buffer up
* data internally even when the USB pipes are closed. So on first open,
* we can receive a large chunk of stale data.
*
* This causes a real problem because the default TTYDEF_LFLAG (applied
* on first open) has the ECHO flag set, resulting in all the stale data
* being echoed straight back to the device by the tty(4) layer. Some
* devices (again, the Huawei E160/E220 for example) react to this spew
* by going catatonic.
*
* All this happens before the application gets a chance to disable ECHO.
*
* We work around this by ignoring all data received from the device for
* a period of two seconds, or until the application starts sending data -
* whichever comes first.
*/
#define U3G_PURGE_SECS 2
/*
* Define bits for the virtual modem control pins.
* The input pin states are reported via the interrupt pipe on some devices.
*/
#define U3G_OUTPIN_DTR (1u << 0)
#define U3G_OUTPIN_RTS (1u << 1)
#define U3G_INPIN_DCD (1u << 0)
#define U3G_INPIN_DSR (1u << 1)
#define U3G_INPIN_RI (1u << 3)
/*
* USB request to set the output pin status
*/
#define U3G_SET_PIN 0x22
struct u3g_softc {
device_t sc_dev;
usbd_device_handle sc_udev;
bool sc_dying; /* We're going away */
device_t sc_ucom; /* Child ucom(4) handle */
int sc_ifaceno; /* Device interface number */
bool sc_open; /* Device is in use */
bool sc_purging; /* Purging stale data */
struct timeval sc_purge_start; /* Control duration of purge */
u_char sc_msr; /* Emulated 'msr' */
uint16_t sc_outpins; /* Output pin state */
usbd_pipe_handle sc_intr_pipe; /* Interrupt pipe */
u_char *sc_intr_buff; /* Interrupt buffer */
};
/*
* The device driver has two personalities. The first uses the 'usbdevif'
* interface attribute so that a match will claim the entire USB device
* for itself. This is used for when a device needs to be mode-switched
* and ensures any other interfaces present cannot be claimed by other
* drivers while the mode-switch is in progress.
*
* The second personality uses the 'usbifif' interface attribute so that
* it can claim the 3G modem interfaces for itself, leaving others (such
* as the mass storage interfaces on some devices) for other drivers.
*/
static int u3ginit_match(device_t, cfdata_t, void *);
static void u3ginit_attach(device_t, device_t, void *);
static int u3ginit_detach(device_t, int);
CFATTACH_DECL2_NEW(u3ginit, 0, u3ginit_match,
u3ginit_attach, u3ginit_detach, NULL, NULL, NULL);
static int u3g_match(device_t, cfdata_t, void *);
static void u3g_attach(device_t, device_t, void *);
static int u3g_detach(device_t, int);
static int u3g_activate(device_t, enum devact);
static void u3g_childdet(device_t, device_t);
CFATTACH_DECL2_NEW(u3g, sizeof(struct u3g_softc), u3g_match,
u3g_attach, u3g_detach, u3g_activate, NULL, u3g_childdet);
static void u3g_intr(usbd_xfer_handle, usbd_private_handle, usbd_status);
static void u3g_get_status(void *, int, u_char *, u_char *);
static void u3g_set(void *, int, int, int);
static int u3g_open(void *, int);
static void u3g_close(void *, int);
static void u3g_read(void *, int, u_char **, uint32_t *);
static void u3g_write(void *, int, u_char *, u_char *, u_int32_t *);
struct ucom_methods u3g_methods = {
u3g_get_status,
u3g_set,
NULL,
NULL,
u3g_open,
u3g_close,
u3g_read,
u3g_write,
};
/*
* Allegedly supported devices
*/
static const struct usb_devno u3g_devs[] = {
{ USB_VENDOR_DELL, USB_PRODUCT_DELL_W5500 },
/* OEM: Huawei */
{ USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_E1750 },
{ USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_E1820 },
{ USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_E220 },
{ USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_K3765 },
{ USB_VENDOR_HUAWEI, USB_PRODUCT_HUAWEI_MOBILE },
/* OEM: Merlin */
{ USB_VENDOR_MERLIN, USB_PRODUCT_MERLIN_V620 },
/* OEM: Novatel */
{ USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_ES620 },
{ USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_EU8X0D },
{ USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_MC950D },
#if 0
/* These are matched in u3ginit_match() */
{ USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_MC950D_DRIVER },
{ USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_U760_DRIVER },
#endif
{ USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_MERLINU740 },
{ USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_MERLINV620 },
{ USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_S720 },
{ USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_U720 },
{ USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_U727 },
{ USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_U740_2 },
{ USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_U760 },
{ USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_U870 },
{ USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_V740 },
{ USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_X950D },
{ USB_VENDOR_NOVATEL2, USB_PRODUCT_NOVATEL2_XU870 },
/* OEM: Option N.V. */
{ USB_VENDOR_OPTIONNV, USB_PRODUCT_OPTIONNV_QUADPLUSUMTS },
{ USB_VENDOR_OPTIONNV, USB_PRODUCT_OPTIONNV_HSDPA },
{ USB_VENDOR_OPTIONNV, USB_PRODUCT_OPTIONNV_GTMAXHSUPA },
/* OEM: Qualcomm, Inc. */
{ USB_VENDOR_QUALCOMMINC, USB_PRODUCT_QUALCOMMINC_CDMA_MSM },
{ USB_VENDOR_QUALCOMMINC, USB_PRODUCT_QUALCOMMINC_ZTE_MF626 },
/* OEM: Sierra Wireless: */
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC595U },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC597E },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC875U },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC880 },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC880E },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC880U },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC881 },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC881E },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AC881U },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AIRCARD580 },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AIRCARD595 },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_AIRCARD875 },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_C597 },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_EM5625 },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC5720 },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC5720_2 },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC5725 },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8755 },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8755_2 },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8755_3 },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8765 },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8775_2 },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8780 },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC8781 },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MINI5725 },
{ USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_USB305 },
/* Toshiba */
{ USB_VENDOR_TOSHIBA, USB_PRODUCT_TOSHIBA_HSDPA_MODEM_EU870DT1 },
/* 4G Systems */
{ USB_VENDOR_4GSYSTEMS, USB_PRODUCT_4GSYSTEMS_XSSTICK_P14 },
};
static int
send_bulkmsg(usbd_device_handle dev, void *cmd, size_t cmdlen)
{
usbd_interface_handle iface;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
usbd_pipe_handle pipe;
usbd_xfer_handle xfer;
int err, i;
/* Move the device into the configured state. */
err = usbd_set_config_index(dev, 0, 0);
if (err) {
aprint_error("u3g: failed to set configuration index\n");
return UMATCH_NONE;
}
err = usbd_device2interface_handle(dev, 0, &iface);
if (err != 0) {
aprint_error("u3ginit: failed to get interface\n");
return UMATCH_NONE;
}
id = usbd_get_interface_descriptor(iface);
ed = NULL;
for (i = 0 ; i < id->bNumEndpoints ; i++) {
ed = usbd_interface2endpoint_descriptor(iface, i);
if (ed == NULL)
continue;
if (UE_GET_DIR(ed->bEndpointAddress) != UE_DIR_OUT)
continue;
if ((ed->bmAttributes & UE_XFERTYPE) == UE_BULK)
break;
}
if (i == id->bNumEndpoints)
return UMATCH_NONE;
err = usbd_open_pipe(iface, ed->bEndpointAddress,
USBD_EXCLUSIVE_USE, &pipe);
if (err != 0) {
aprint_error("u3ginit: failed to open bulk transfer pipe %d\n",
ed->bEndpointAddress);
return UMATCH_NONE;
}
xfer = usbd_alloc_xfer(dev);
if (xfer != NULL) {
usbd_setup_xfer(xfer, pipe, NULL, cmd, cmdlen,
USBD_SYNCHRONOUS, USBD_DEFAULT_TIMEOUT, NULL);
err = usbd_transfer(xfer);
#if 0 /* XXXpooka: at least my huawei "fails" this always, but still detaches */
if (err)
aprint_error("u3ginit: transfer failed\n");
#else
err = 0;
#endif
usbd_free_xfer(xfer);
} else {
aprint_error("u3ginit: failed to allocate xfer\n");
err = USBD_NOMEM;
}
usbd_abort_pipe(pipe);
usbd_close_pipe(pipe);
return (err == USBD_NORMAL_COMPLETION ? UMATCH_HIGHEST : UMATCH_NONE);
}
static int
u3g_novatel_reinit(usbd_device_handle dev)
{
unsigned char cmd[31];
memset(cmd, 0, sizeof(cmd));
/* Byte 0..3: Command Block Wrapper (CBW) signature */
cmd[0] = 0x55;
cmd[1] = 0x53;
cmd[2] = 0x42;
cmd[3] = 0x43;
/* 4..7: CBW Tag, has to unique, but only a single transfer used. */
cmd[4] = 0x01;
/* 8..11: CBW Transfer Length, no data here */
/* 12: CBW Flag: output, so 0 */
/* 13: CBW Lun: 0 */
/* 14: CBW Length */
cmd[14] = 0x06;
/* Rest is the SCSI payload */
/* 0: SCSI START/STOP opcode */
cmd[15] = 0x1b;
/* 1..3 unused */
/* 4 Load/Eject command */
cmd[19] = 0x02;
/* 5: unused */
return send_bulkmsg(dev, cmd, sizeof(cmd));
}
static int
u3g_huawei_reinit(usbd_device_handle dev)
{
/*
* The Huawei device presents itself as a umass device with Windows
* drivers on it. After installation of the driver, it reinits into a
* 3G serial device.
*/
usb_device_request_t req;
usb_config_descriptor_t *cdesc;
/* Get the config descriptor */
cdesc = usbd_get_config_descriptor(dev);
if (cdesc == NULL) {
usb_device_descriptor_t dd;
if (usbd_get_device_desc(dev, &dd) != 0)
return (UMATCH_NONE);
if (dd.bNumConfigurations != 1)
return (UMATCH_NONE);
if (usbd_set_config_index(dev, 0, 1) != 0)
return (UMATCH_NONE);
cdesc = usbd_get_config_descriptor(dev);
if (cdesc == NULL)
return (UMATCH_NONE);
}
/*
* One iface means umass mode, more than 1 (4 usually) means 3G mode.
*
* XXX: We should check the first interface's device class just to be
* sure. If it's a mass storage device, then we can be fairly certain
* it needs a mode-switch.
*/
if (cdesc->bNumInterface > 1)
return (UMATCH_NONE);
req.bmRequestType = UT_WRITE_DEVICE;
req.bRequest = UR_SET_FEATURE;
USETW(req.wValue, UF_DEVICE_REMOTE_WAKEUP);
USETW(req.wIndex, UHF_PORT_SUSPEND);
USETW(req.wLength, 0);
(void) usbd_do_request(dev, &req, 0);
return (UMATCH_HIGHEST); /* Prevent umass from attaching */
}
static int
u3g_huawei_k3765_reinit(usbd_device_handle dev)
{
unsigned char cmd[31];
/* magic string adapted from some webpage */
memset(cmd, 0, sizeof(cmd));
cmd[0] = 0x55;
cmd[1] = 0x53;
cmd[2] = 0x42;
cmd[3] = 0x43;
cmd[15]= 0x11;
cmd[16]= 0x06;
return send_bulkmsg(dev, cmd, sizeof(cmd));
}
static int
u3g_sierra_reinit(usbd_device_handle dev)
{
/* Some Sierra devices presents themselves as a umass device with
* Windows drivers on it. After installation of the driver, it
* reinits into a * 3G serial device.
*/
usb_device_request_t req;
req.bmRequestType = UT_VENDOR;
req.bRequest = UR_SET_INTERFACE;
USETW(req.wValue, UF_DEVICE_REMOTE_WAKEUP);
USETW(req.wIndex, UHF_PORT_CONNECTION);
USETW(req.wLength, 0);
(void) usbd_do_request(dev, &req, 0);
return (UMATCH_HIGHEST); /* Match to prevent umass from attaching */
}
static int
u3g_4gsystems_reinit(usbd_device_handle dev)
{
/* magic string adapted from usb_modeswitch database */
static unsigned char cmd[31] = {
0x55, 0x53, 0x42, 0x43, 0x12, 0x34, 0x56, 0x78, 0x80, 0x00,
0x00, 0x00, 0x80, 0x00, 0x06, 0x06, 0xf5, 0x04, 0x02, 0x52,
0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00
};
return send_bulkmsg(dev, cmd, sizeof(cmd));
}
/*
* First personality:
*
* Claim the entire device if a mode-switch is required.
*/
static int
u3ginit_match(device_t parent, cfdata_t match, void *aux)
{
struct usb_attach_arg *uaa = aux;
/*
* Huawei changes product when it is configured as a modem.
*/
switch (uaa->vendor) {
case USB_VENDOR_HUAWEI:
if (uaa->product == USB_PRODUCT_HUAWEI_K3765)
return UMATCH_NONE;
switch (uaa->product) {
case USB_PRODUCT_HUAWEI_E1750INIT:
case USB_PRODUCT_HUAWEI_K3765INIT:
return u3g_huawei_k3765_reinit(uaa->device);
break;
default:
return u3g_huawei_reinit(uaa->device);
break;
}
break;
case USB_VENDOR_NOVATEL2:
switch (uaa->product){
case USB_PRODUCT_NOVATEL2_MC950D_DRIVER:
case USB_PRODUCT_NOVATEL2_U760_DRIVER:
return u3g_novatel_reinit(uaa->device);
break;
default:
break;
}
break;
case USB_VENDOR_SIERRA:
if (uaa->product == USB_PRODUCT_SIERRA_INSTALLER)
return u3g_sierra_reinit(uaa->device);
break;
case USB_VENDOR_QUALCOMMINC:
if (uaa->product == USB_PRODUCT_QUALCOMMINC_ZTE_STOR)
return u3g_novatel_reinit(uaa->device);
break;
case USB_VENDOR_4GSYSTEMS:
if (uaa->product == USB_PRODUCT_4GSYSTEMS_XSSTICK_P14_INSTALLER)
return u3g_4gsystems_reinit(uaa->device);
break;
default:
break;
}
return UMATCH_NONE;
}
static void
u3ginit_attach(device_t parent, device_t self, void *aux)
{
struct usb_attach_arg *uaa = aux;
aprint_naive("\n");
aprint_normal(": Switching to 3G mode\n");
if (uaa->vendor == USB_VENDOR_NOVATEL2) {
switch (uaa->product) {
case USB_PRODUCT_NOVATEL2_MC950D_DRIVER:
case USB_PRODUCT_NOVATEL2_U760_DRIVER:
/* About to disappear... */
return;
break;
default:
break;
}
}
/* Move the device into the configured state. */
(void) usbd_set_config_index(uaa->device, 0, 1);
}
static int
u3ginit_detach(device_t self, int flags)
{
return (0);
}
/*
* Second personality:
*
* Claim only those interfaces required for 3G modem operation.
*/
static int
u3g_match(device_t parent, cfdata_t match, void *aux)
{
struct usbif_attach_arg *uaa = aux;
usbd_interface_handle iface;
usb_interface_descriptor_t *id;
usbd_status error;
if (!usb_lookup(u3g_devs, uaa->vendor, uaa->product))
return (UMATCH_NONE);
error = usbd_device2interface_handle(uaa->device, uaa->ifaceno, &iface);
if (error) {
printf("u3g_match: failed to get interface, err=%s\n",
usbd_errstr(error));
return (UMATCH_NONE);
}
id = usbd_get_interface_descriptor(iface);
if (id == NULL) {
printf("u3g_match: failed to get interface descriptor\n");
return (UMATCH_NONE);
}
/*
* 3G modems generally report vendor-specific class
*
* XXX: this may be too generalised.
*/
return ((id->bInterfaceClass == UICLASS_VENDOR) ?
UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
}
static void
u3g_attach(device_t parent, device_t self, void *aux)
{
struct u3g_softc *sc = device_private(self);
struct usbif_attach_arg *uaa = aux;
usbd_device_handle dev = uaa->device;
usbd_interface_handle iface;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
struct ucom_attach_args uca;
usbd_status error;
int n, intr_address, intr_size;
aprint_naive("\n");
aprint_normal("\n");
sc->sc_dev = self;
sc->sc_dying = false;
sc->sc_udev = dev;
error = usbd_device2interface_handle(dev, uaa->ifaceno, &iface);
if (error) {
aprint_error_dev(self, "failed to get interface, err=%s\n",
usbd_errstr(error));
return;
}
id = usbd_get_interface_descriptor(iface);
uca.info = "3G Modem";
uca.ibufsize = U3G_BUFF_SIZE;
uca.obufsize = U3G_BUFF_SIZE;
uca.ibufsizepad = U3G_BUFF_SIZE;
uca.portno = uaa->ifaceno;
uca.opkthdrlen = 0;
uca.device = dev;
uca.iface = iface;
uca.methods = &u3g_methods;
uca.arg = sc;
uca.bulkin = uca.bulkout = -1;
sc->sc_outpins = 0;
sc->sc_msr = UMSR_DSR | UMSR_CTS | UMSR_DCD;
sc->sc_ifaceno = uaa->ifaceno;
sc->sc_open = false;
sc->sc_purging = false;
intr_address = -1;
intr_size = 0;
for (n = 0; n < id->bNumEndpoints; n++) {
ed = usbd_interface2endpoint_descriptor(iface, n);
if (ed == NULL) {
aprint_error_dev(self, "no endpoint descriptor "
"for %d (interface: %d)\n", n, sc->sc_ifaceno);
sc->sc_dying = true;
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
intr_address = ed->bEndpointAddress;
intr_size = UGETW(ed->wMaxPacketSize);
} else
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
uca.bulkin = ed->bEndpointAddress;
} else
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
uca.bulkout = ed->bEndpointAddress;
}
}
if (uca.bulkin == -1) {
aprint_error_dev(self, "Missing bulk in for interface %d\n",
sc->sc_ifaceno);
sc->sc_dying = true;
return;
}
if (uca.bulkout == -1) {
aprint_error_dev(self, "Missing bulk out for interface %d\n",
sc->sc_ifaceno);
sc->sc_dying = true;
return;
}
sc->sc_ucom = config_found_sm_loc(self, "ucombus",
NULL, &uca, ucomprint, ucomsubmatch);
/*
* If the interface has an interrupt pipe, open it immediately so
* that we can track input pin state changes regardless of whether
* the tty(4) device is open or not.
*/
if (intr_address != -1) {
sc->sc_intr_buff = malloc(intr_size, M_USBDEV, M_WAITOK);
error = usbd_open_pipe_intr(iface, intr_address,
USBD_SHORT_XFER_OK, &sc->sc_intr_pipe, sc, sc->sc_intr_buff,
intr_size, u3g_intr, 100);
if (error) {
aprint_error_dev(self, "cannot open interrupt pipe "
"(addr %d)\n", intr_address);
return;
}
} else {
sc->sc_intr_pipe = NULL;
sc->sc_intr_buff = NULL;
}
if (!pmf_device_register(self, NULL, NULL))
aprint_error_dev(self, "couldn't establish power handler\n");
}
static int
u3g_detach(device_t self, int flags)
{
struct u3g_softc *sc = device_private(self);
int rv;
if (sc->sc_dying)
return 0;
pmf_device_deregister(self);
if (sc->sc_ucom != NULL) {
rv = config_detach(sc->sc_ucom, flags);
if (rv != 0) {
aprint_verbose_dev(self, "Can't deallocate "
"port (%d)", rv);
}
}
if (sc->sc_intr_pipe != NULL) {
(void) usbd_abort_pipe(sc->sc_intr_pipe);
(void) usbd_close_pipe(sc->sc_intr_pipe);
sc->sc_intr_pipe = NULL;
}
if (sc->sc_intr_buff != NULL) {
free(sc->sc_intr_buff, M_USBDEV);
sc->sc_intr_buff = NULL;
}
return (0);
}
static void
u3g_childdet(device_t self, device_t child)
{
struct u3g_softc *sc = device_private(self);
if (sc->sc_ucom == child)
sc->sc_ucom = NULL;
}
static int
u3g_activate(device_t self, enum devact act)
{
struct u3g_softc *sc = device_private(self);
int rv;
switch (act) {
case DVACT_DEACTIVATE:
if (sc->sc_ucom != NULL && config_deactivate(sc->sc_ucom))
rv = -1;
else
rv = 0;
break;
default:
rv = 0;
break;
}
return (rv);
}
static void
u3g_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
{
struct u3g_softc *sc = (struct u3g_softc *)priv;
u_char *buf;
if (sc->sc_dying)
return;
if (status != USBD_NORMAL_COMPLETION) {
if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
return;
usbd_clear_endpoint_stall_async(sc->sc_intr_pipe);
return;
}
buf = sc->sc_intr_buff;
if (buf[0] == 0xa1 && buf[1] == 0x20) {
u_char msr;
msr = sc->sc_msr & ~(UMSR_DCD | UMSR_DSR | UMSR_RI);
if (buf[8] & U3G_INPIN_DCD)
msr |= UMSR_DCD;
if (buf[8] & U3G_INPIN_DSR)
msr |= UMSR_DSR;
if (buf[8] & U3G_INPIN_RI)
msr |= UMSR_RI;
if (msr != sc->sc_msr) {
sc->sc_msr = msr;
if (sc->sc_open)
ucom_status_change(device_private(sc->sc_ucom));
}
}
}
/*ARGSUSED*/
static void
u3g_get_status(void *arg, int portno, u_char *lsr, u_char *msr)
{
struct u3g_softc *sc = arg;
if (lsr != NULL)
*lsr = 0; /* LSR isn't supported */
if (msr != NULL)
*msr = sc->sc_msr;
}
/*ARGSUSED*/
static void
u3g_set(void *arg, int portno, int reg, int onoff)
{
struct u3g_softc *sc = arg;
usb_device_request_t req;
uint16_t mask, new_state;
usbd_status err;
if (sc->sc_dying)
return;
switch (reg) {
case UCOM_SET_DTR:
mask = U3G_OUTPIN_DTR;
break;
case UCOM_SET_RTS:
mask = U3G_OUTPIN_RTS;
break;
default:
return;
}
new_state = sc->sc_outpins & ~mask;
if (onoff)
new_state |= mask;
if (new_state == sc->sc_outpins)
return;
sc->sc_outpins = new_state;
req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
req.bRequest = U3G_SET_PIN;
USETW(req.wValue, new_state);
USETW(req.wIndex, sc->sc_ifaceno);
USETW(req.wLength, 0);
err = usbd_do_request(sc->sc_udev, &req, 0);
if (err == USBD_STALLED)
usbd_clear_endpoint_stall(sc->sc_udev->default_pipe);
}
/*ARGSUSED*/
static int
u3g_open(void *arg, int portno)
{
struct u3g_softc *sc = arg;
usb_device_request_t req;
usb_endpoint_descriptor_t *ed;
usb_interface_descriptor_t *id;
usbd_interface_handle ih;
usbd_status err;
int i;
if (sc->sc_dying)
return (0);
err = usbd_device2interface_handle(sc->sc_udev, portno, &ih);
if (err)
return (EIO);
id = usbd_get_interface_descriptor(ih);
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(ih, i);
if (ed == NULL)
return (EIO);
if (UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
/* Issue ENDPOINT_HALT request */
req.bmRequestType = UT_WRITE_ENDPOINT;
req.bRequest = UR_CLEAR_FEATURE;
USETW(req.wValue, UF_ENDPOINT_HALT);
USETW(req.wIndex, ed->bEndpointAddress);
USETW(req.wLength, 0);
err = usbd_do_request(sc->sc_udev, &req, 0);
if (err)
return (EIO);
}
}
sc->sc_open = true;
sc->sc_purging = true;
getmicrotime(&sc->sc_purge_start);
return (0);
}
/*ARGSUSED*/
static void
u3g_close(void *arg, int portno)
{
struct u3g_softc *sc = arg;
sc->sc_open = false;
}
/*ARGSUSED*/
static void
u3g_read(void *arg, int portno, u_char **cpp, uint32_t *ccp)
{
struct u3g_softc *sc = arg;
struct timeval curr_tv, diff_tv;
/*
* If we're not purging input data following first open, do nothing.
*/
if (sc->sc_purging == false)
return;
/*
* Otherwise check if the purge timeout has expired
*/
getmicrotime(&curr_tv);
timersub(&curr_tv, &sc->sc_purge_start, &diff_tv);
if (diff_tv.tv_sec >= U3G_PURGE_SECS) {
/* Timeout expired. */
sc->sc_purging = false;
} else {
/* Still purging. Adjust the caller's byte count. */
*ccp = 0;
}
}
/*ARGSUSED*/
static void
u3g_write(void *arg, int portno, u_char *to, u_char *from, u_int32_t *count)
{
struct u3g_softc *sc = arg;
/*
* Stop purging as soon as the first data is written to the device.
*/
sc->sc_purging = false;
memcpy(to, from, *count);
}
Reference in New Issue View Git Blame Copy Permalink