Split the umodem driver into two parts: the part that emulates a tty over
two bulk pipes, and the setup and status fiddling goo. This allows the former part to be shared by other drivers that need to look like a tty.
This commit is contained in:
augustss
parent
509c38cc44
commit
a2b1ac707a
|
|
@ -1,4 +1,4 @@
|
|||
# $NetBSD: files.usb,v 1.13 2000/01/16 09:40:07 augustss Exp $
|
||||
# $NetBSD: files.usb,v 1.14 2000/01/25 08:12:58 augustss Exp $
|
||||
#
|
||||
# Config file and device description for machine-independent USB code.
|
||||
# Included by ports that need it. Ports that use it must provide
|
||||
|
|
@ -24,11 +24,19 @@ file dev/usb/uhub.c usb
|
|||
|
||||
attach uhub at uhub with uhub_uhub
|
||||
|
||||
# Modem and com serial port "bus"
|
||||
define ucombus {[ portno = -1 ]}
|
||||
|
||||
# Audio devices
|
||||
device uaudio: audio, auconv, mulaw
|
||||
attach uaudio at uhub
|
||||
file dev/usb/uaudio.c uaudio
|
||||
|
||||
# Modem and com serial port
|
||||
device ucom
|
||||
attach ucom at ucombus
|
||||
file dev/usb/ucom.c ucom needs-flag
|
||||
|
||||
# Generic devices
|
||||
device ugen
|
||||
attach ugen at uhub
|
||||
|
|
@ -56,9 +64,9 @@ attach umass at uhub
|
|||
file dev/usb/umass.c umass
|
||||
|
||||
# Modems
|
||||
device umodem
|
||||
device umodem: ucombus
|
||||
attach umodem at uhub
|
||||
file dev/usb/umodem.c umodem needs-flag
|
||||
file dev/usb/umodem.c umodem
|
||||
|
||||
# Mice
|
||||
device ums: wsmousedev
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $NetBSD: ucom.c,v 1.11 1999/11/12 00:34:57 augustss Exp $ */
|
||||
/* $NetBSD: ucom.c,v 1.12 2000/01/25 08:12:58 augustss Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1998 The NetBSD Foundation, Inc.
|
||||
|
|
@ -40,84 +40,947 @@
|
|||
#include <sys/param.h>
|
||||
#include <sys/systm.h>
|
||||
#include <sys/kernel.h>
|
||||
#include <sys/malloc.h>
|
||||
#if defined(__NetBSD__)
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/device.h>
|
||||
#elif defined(__FreeBSD__)
|
||||
#include <sys/module.h>
|
||||
#include <sys/bus.h>
|
||||
#include <sys/ioccom.h>
|
||||
#include <sys/conf.h>
|
||||
#endif
|
||||
#include <sys/tty.h>
|
||||
#include <sys/file.h>
|
||||
#include <sys/select.h>
|
||||
#include <sys/proc.h>
|
||||
#include <sys/vnode.h>
|
||||
#include <sys/device.h>
|
||||
#include <sys/poll.h>
|
||||
|
||||
#include <dev/usb/usb.h>
|
||||
#include <dev/usb/usbhid.h>
|
||||
|
||||
#include <dev/usb/usbdi.h>
|
||||
#include <dev/usb/usbdi_util.h>
|
||||
#include <dev/usb/usbdevs.h>
|
||||
#include <dev/usb/usb_quirks.h>
|
||||
#include <dev/usb/hid.h>
|
||||
|
||||
#ifdef USB_DEBUG
|
||||
#define DPRINTF(x) if (ucomdebug) logprintf x
|
||||
#define DPRINTFN(n,x) if (ucomdebug>(n)) logprintf x
|
||||
int ucomdebug = 0;
|
||||
#include <dev/usb/ucomvar.h>
|
||||
|
||||
#ifdef UCOM_DEBUG
|
||||
#define DPRINTFN(n, x) if (ucomdebug > (n)) logprintf x
|
||||
int ucomdebug = 0;
|
||||
#else
|
||||
#define DPRINTF(x)
|
||||
#define DPRINTFN(n,x)
|
||||
#define DPRINTFN(n, x)
|
||||
#endif
|
||||
#define DPRINTF(x) DPRINTFN(0, x)
|
||||
|
||||
#define UCOMUNIT_MASK 0x3ffff
|
||||
#define UCOMDIALOUT_MASK 0x80000
|
||||
#define UCOMCALLUNIT_MASK 0x40000
|
||||
|
||||
#define UCOMUNIT(x) (minor(x) & UCOMUNIT_MASK)
|
||||
#define UCOMDIALOUT(x) (minor(x) & UCOMDIALOUT_MASK)
|
||||
#define UCOMCALLUNIT(x) (minor(x) & UCOMCALLUNIT_MASK)
|
||||
|
||||
/*
|
||||
* These are the maximum number of bytes transferred per frame.
|
||||
* If some really high speed devices should use this driver they
|
||||
* may need to be increased, but this is good enough for modems.
|
||||
*/
|
||||
#define UCOMIBUFSIZE 64
|
||||
#define UCOMOBUFSIZE 256
|
||||
|
||||
struct ucom_softc {
|
||||
bdevice sc_dev; /* base device */
|
||||
usbd_interface_handle sc_iface; /* interface */
|
||||
USBBASEDEVICE sc_dev; /* base device */
|
||||
|
||||
usbd_device_handle sc_udev; /* USB device */
|
||||
|
||||
usbd_interface_handle sc_iface; /* data interface */
|
||||
|
||||
int sc_bulkin_no; /* bulk in endpoint address */
|
||||
usbd_pipe_handle sc_bulkin_pipe; /* bulk in pipe */
|
||||
usbd_xfer_handle sc_ixfer; /* read request */
|
||||
u_char *sc_ibuf; /* read buffer */
|
||||
|
||||
int sc_bulkout_no; /* bulk out endpoint address */
|
||||
usbd_pipe_handle sc_bulkout_pipe;/* bulk out pipe */
|
||||
usbd_xfer_handle sc_oxfer; /* write request */
|
||||
u_char *sc_obuf; /* write buffer */
|
||||
|
||||
struct ucom_methods *sc_methods;
|
||||
void *sc_parent;
|
||||
int sc_portno;
|
||||
|
||||
struct tty *sc_tty; /* our tty */
|
||||
u_char sc_lsr;
|
||||
u_char sc_msr;
|
||||
u_char sc_mcr;
|
||||
u_char sc_tx_stopped;
|
||||
int sc_swflags;
|
||||
|
||||
u_char sc_opening; /* lock during open */
|
||||
u_char sc_dying; /* disconnecting */
|
||||
};
|
||||
|
||||
void ucom_intr __P((usbd_xfer_handle, usbd_private_handle, usbd_status));
|
||||
void ucom_disco __P((void *));
|
||||
cdev_decl(ucom);
|
||||
|
||||
static void ucom_cleanup __P((struct ucom_softc *));
|
||||
static void ucom_hwiflow __P((struct ucom_softc *));
|
||||
static int ucomparam __P((struct tty *, struct termios *));
|
||||
static void ucomstart __P((struct tty *));
|
||||
static void ucom_shutdown __P((struct ucom_softc *));
|
||||
static void ucom_dtr __P((struct ucom_softc *, int));
|
||||
static void ucom_rts __P((struct ucom_softc *, int));
|
||||
static void ucom_break __P((struct ucom_softc *, int));
|
||||
static usbd_status ucomstartread __P((struct ucom_softc *));
|
||||
static void ucomreadcb __P((usbd_xfer_handle, usbd_private_handle,
|
||||
usbd_status status));
|
||||
static void ucomwritecb __P((usbd_xfer_handle, usbd_private_handle,
|
||||
usbd_status status));
|
||||
static void tiocm_to_ucom __P((struct ucom_softc *, int, int));
|
||||
static int ucom_to_tiocm __P((struct ucom_softc *));
|
||||
|
||||
USB_DECLARE_DRIVER(ucom);
|
||||
|
||||
USB_MATCH(ucom)
|
||||
{
|
||||
USB_MATCH_START(ucom, uaa);
|
||||
usb_interface_descriptor_t *id;
|
||||
|
||||
if (!uaa->iface)
|
||||
return (UMATCH_NONE);
|
||||
id = usbd_get_interface_descriptor(uaa->iface);
|
||||
if (id &&
|
||||
id->bInterfaceClass != UCLASS_CDC ||
|
||||
id->bInterfaceSubClass != USUBCLASS_ABSTRACT_CONTROL_MODEL)
|
||||
return (UMATCH_NONE);
|
||||
return (UMATCH_IFACECLASS_IFACESUBCLASS);
|
||||
return (1);
|
||||
}
|
||||
|
||||
USB_ATTACH(ucom)
|
||||
{
|
||||
USB_ATTACH_START(ucom, sc, uaa);
|
||||
usbd_interface_handle iface = uaa->iface;
|
||||
usb_interface_descriptor_t *id;
|
||||
char devinfo[1024];
|
||||
|
||||
sc->sc_iface = iface;
|
||||
id = usbd_get_interface_descriptor(iface);
|
||||
usbd_devinfo(uaa->device, 0, devinfo);
|
||||
USB_ATTACH_SETUP;
|
||||
printf("%s: %s, iclass %d/%d\n", USBDEVNAME(sc->sc_dev),
|
||||
devinfo, id->bInterfaceClass, id->bInterfaceSubClass);
|
||||
struct ucom_softc *sc = (struct ucom_softc *)self;
|
||||
struct ucom_attach_args *uca = aux;
|
||||
struct tty *tp;
|
||||
|
||||
if (uca->portno != UCOM_UNK_PORTNO)
|
||||
printf(": portno %d", uca->portno);
|
||||
printf("\n");
|
||||
|
||||
sc->sc_udev = uca->device;
|
||||
sc->sc_iface = uca->iface;
|
||||
sc->sc_bulkout_no = uca->bulkout;
|
||||
sc->sc_bulkin_no = uca->bulkin;
|
||||
sc->sc_methods = uca->methods;
|
||||
sc->sc_parent = uca->arg;
|
||||
sc->sc_portno = uca->portno;
|
||||
|
||||
tp = ttymalloc();
|
||||
tp->t_oproc = ucomstart;
|
||||
tp->t_param = ucomparam;
|
||||
sc->sc_tty = tp;
|
||||
|
||||
DPRINTF(("ucom_attach: tty_attach %p\n", tp));
|
||||
tty_attach(tp);
|
||||
|
||||
USB_ATTACH_SUCCESS_RETURN;
|
||||
}
|
||||
|
||||
#if defined(__FreeBSD__)
|
||||
DRIVER_MODULE(ucom, usb, ucom_driver, ucom_devclass, usbd_driver_load, 0);
|
||||
USB_DETACH(ucom)
|
||||
{
|
||||
struct ucom_softc *sc = (struct ucom_softc *)self;
|
||||
int maj, mn;
|
||||
|
||||
DPRINTF(("ucom_detach: sc=%p flags=%d tp=%p\n",
|
||||
sc, flags, sc->sc_tty));
|
||||
|
||||
sc->sc_dying = 1;
|
||||
|
||||
#ifdef DIAGNOSTIC
|
||||
if (sc->sc_tty == NULL) {
|
||||
DPRINTF(("ucom_detach: no tty\n"));
|
||||
return (0);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* XXX Use reference count? */
|
||||
|
||||
/* locate the major number */
|
||||
for (maj = 0; maj < nchrdev; maj++)
|
||||
if (cdevsw[maj].d_open == ucomopen)
|
||||
break;
|
||||
|
||||
/* Nuke the vnodes for any open instances. */
|
||||
mn = self->dv_unit;
|
||||
vdevgone(maj, mn, mn, VCHR);
|
||||
vdevgone(maj, mn, mn | UCOMDIALOUT_MASK, VCHR);
|
||||
vdevgone(maj, mn, mn | UCOMCALLUNIT_MASK, VCHR);
|
||||
|
||||
/* Detach and free the tty. */
|
||||
tty_detach(sc->sc_tty);
|
||||
ttyfree(sc->sc_tty);
|
||||
sc->sc_tty = 0;
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
#if defined(__NetBSD__) || defined(__OpenBSD__)
|
||||
int
|
||||
ucom_activate(self, act)
|
||||
device_ptr_t self;
|
||||
enum devact act;
|
||||
{
|
||||
struct ucom_softc *sc = (struct ucom_softc *)self;
|
||||
|
||||
switch (act) {
|
||||
case DVACT_ACTIVATE:
|
||||
return (EOPNOTSUPP);
|
||||
break;
|
||||
|
||||
case DVACT_DEACTIVATE:
|
||||
sc->sc_dying = 1;
|
||||
break;
|
||||
}
|
||||
return (0);
|
||||
}
|
||||
#endif
|
||||
|
||||
void
|
||||
ucom_shutdown(sc)
|
||||
struct ucom_softc *sc;
|
||||
{
|
||||
struct tty *tp = sc->sc_tty;
|
||||
|
||||
DPRINTF(("ucom_shutdown\n"));
|
||||
/*
|
||||
* Hang up if necessary. Wait a bit, so the other side has time to
|
||||
* notice even if we immediately open the port again.
|
||||
*/
|
||||
if (ISSET(tp->t_cflag, HUPCL)) {
|
||||
ucom_dtr(sc, 0);
|
||||
(void)tsleep(sc, TTIPRI, ttclos, hz);
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
ucomopen(dev, flag, mode, p)
|
||||
dev_t dev;
|
||||
int flag, mode;
|
||||
struct proc *p;
|
||||
{
|
||||
int unit = UCOMUNIT(dev);
|
||||
usbd_status err;
|
||||
struct ucom_softc *sc;
|
||||
struct tty *tp;
|
||||
int s;
|
||||
int error;
|
||||
|
||||
if (unit >= ucom_cd.cd_ndevs)
|
||||
return (ENXIO);
|
||||
sc = ucom_cd.cd_devs[unit];
|
||||
if (sc == NULL)
|
||||
return (ENXIO);
|
||||
|
||||
if (sc->sc_dying)
|
||||
return (EIO);
|
||||
|
||||
if (ISSET(sc->sc_dev.dv_flags, DVF_ACTIVE) == 0)
|
||||
return (ENXIO);
|
||||
|
||||
tp = sc->sc_tty;
|
||||
|
||||
DPRINTF(("ucomopen: unit=%d, tp=%p\n", unit, tp));
|
||||
|
||||
if (ISSET(tp->t_state, TS_ISOPEN) &&
|
||||
ISSET(tp->t_state, TS_XCLUDE) &&
|
||||
p->p_ucred->cr_uid != 0)
|
||||
return (EBUSY);
|
||||
|
||||
s = spltty();
|
||||
|
||||
/*
|
||||
* Do the following iff this is a first open.
|
||||
*/
|
||||
while (sc->sc_opening)
|
||||
tsleep(&sc->sc_opening, PRIBIO, "ucomop", 0);
|
||||
sc->sc_opening = 1;
|
||||
|
||||
if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
|
||||
struct termios t;
|
||||
|
||||
tp->t_dev = dev;
|
||||
|
||||
ucom_status_change(sc);
|
||||
|
||||
/*
|
||||
* Initialize the termios status to the defaults. Add in the
|
||||
* sticky bits from TIOCSFLAGS.
|
||||
*/
|
||||
t.c_ispeed = 0;
|
||||
t.c_ospeed = TTYDEF_SPEED;
|
||||
t.c_cflag = TTYDEF_CFLAG;
|
||||
if (ISSET(sc->sc_swflags, TIOCFLAG_CLOCAL))
|
||||
SET(t.c_cflag, CLOCAL);
|
||||
if (ISSET(sc->sc_swflags, TIOCFLAG_CRTSCTS))
|
||||
SET(t.c_cflag, CRTSCTS);
|
||||
if (ISSET(sc->sc_swflags, TIOCFLAG_MDMBUF))
|
||||
SET(t.c_cflag, MDMBUF);
|
||||
/* Make sure ucomparam() will do something. */
|
||||
tp->t_ospeed = 0;
|
||||
(void) ucomparam(tp, &t);
|
||||
tp->t_iflag = TTYDEF_IFLAG;
|
||||
tp->t_oflag = TTYDEF_OFLAG;
|
||||
tp->t_lflag = TTYDEF_LFLAG;
|
||||
ttychars(tp);
|
||||
ttsetwater(tp);
|
||||
|
||||
/*
|
||||
* Turn on DTR. We must always do this, even if carrier is not
|
||||
* present, because otherwise we'd have to use TIOCSDTR
|
||||
* immediately after setting CLOCAL, which applications do not
|
||||
* expect. We always assert DTR while the device is open
|
||||
* unless explicitly requested to deassert it.
|
||||
*/
|
||||
ucom_dtr(sc, 1);
|
||||
|
||||
// XXX CLR(sc->sc_rx_flags, RX_ANY_BLOCK);
|
||||
ucom_hwiflow(sc);
|
||||
|
||||
DPRINTF(("ucomopen: open pipes in=%d out=%d\n",
|
||||
sc->sc_bulkin_no, sc->sc_bulkout_no));
|
||||
|
||||
/* Open the bulk pipes */
|
||||
err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkin_no, 0,
|
||||
&sc->sc_bulkin_pipe);
|
||||
if (err) {
|
||||
DPRINTF(("%s: open bulk out error (addr %d), err=%s\n",
|
||||
USBDEVNAME(sc->sc_dev), sc->sc_bulkin_no,
|
||||
usbd_errstr(err)));
|
||||
return (EIO);
|
||||
}
|
||||
err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkout_no,
|
||||
USBD_EXCLUSIVE_USE, &sc->sc_bulkout_pipe);
|
||||
if (err) {
|
||||
DPRINTF(("%s: open bulk in error (addr %d), err=%s\n",
|
||||
USBDEVNAME(sc->sc_dev), sc->sc_bulkout_no,
|
||||
usbd_errstr(err)));
|
||||
usbd_close_pipe(sc->sc_bulkin_pipe);
|
||||
return (EIO);
|
||||
}
|
||||
|
||||
/* Allocate a request and an input buffer and start reading. */
|
||||
sc->sc_ixfer = usbd_alloc_xfer(sc->sc_udev);
|
||||
if (sc->sc_ixfer == NULL) {
|
||||
usbd_close_pipe(sc->sc_bulkin_pipe);
|
||||
usbd_close_pipe(sc->sc_bulkout_pipe);
|
||||
return (ENOMEM);
|
||||
}
|
||||
sc->sc_ibuf = usbd_alloc_buffer(sc->sc_ixfer, UCOMIBUFSIZE);
|
||||
if (sc->sc_ibuf == NULL) {
|
||||
usbd_free_xfer(sc->sc_ixfer);
|
||||
usbd_close_pipe(sc->sc_bulkin_pipe);
|
||||
usbd_close_pipe(sc->sc_bulkout_pipe);
|
||||
return (ENOMEM);
|
||||
}
|
||||
|
||||
sc->sc_oxfer = usbd_alloc_xfer(sc->sc_udev);
|
||||
if (sc->sc_oxfer == NULL) {
|
||||
usbd_free_xfer(sc->sc_ixfer);
|
||||
usbd_close_pipe(sc->sc_bulkin_pipe);
|
||||
usbd_close_pipe(sc->sc_bulkout_pipe);
|
||||
return (ENOMEM);
|
||||
}
|
||||
sc->sc_obuf = usbd_alloc_buffer(sc->sc_oxfer, UCOMOBUFSIZE);
|
||||
if (sc->sc_obuf == NULL) {
|
||||
usbd_free_xfer(sc->sc_oxfer);
|
||||
usbd_free_xfer(sc->sc_ixfer);
|
||||
usbd_close_pipe(sc->sc_bulkin_pipe);
|
||||
usbd_close_pipe(sc->sc_bulkout_pipe);
|
||||
return (ENOMEM);
|
||||
}
|
||||
|
||||
ucomstartread(sc);
|
||||
}
|
||||
sc->sc_opening = 0;
|
||||
wakeup(&sc->sc_opening);
|
||||
splx(s);
|
||||
|
||||
error = ttyopen(tp, UCOMDIALOUT(dev), ISSET(flag, O_NONBLOCK));
|
||||
if (error)
|
||||
goto bad;
|
||||
|
||||
error = (*linesw[tp->t_line].l_open)(dev, tp);
|
||||
if (error)
|
||||
goto bad;
|
||||
|
||||
return (0);
|
||||
|
||||
bad:
|
||||
if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
|
||||
/*
|
||||
* We failed to open the device, and nobody else had it opened.
|
||||
* Clean up the state as appropriate.
|
||||
*/
|
||||
ucom_cleanup(sc);
|
||||
}
|
||||
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
ucomclose(dev, flag, mode, p)
|
||||
dev_t dev;
|
||||
int flag, mode;
|
||||
struct proc *p;
|
||||
{
|
||||
struct ucom_softc *sc = ucom_cd.cd_devs[UCOMUNIT(dev)];
|
||||
struct tty *tp = sc->sc_tty;
|
||||
|
||||
DPRINTF(("ucomclose: unit=%d\n", UCOMUNIT(dev)));
|
||||
if (!ISSET(tp->t_state, TS_ISOPEN))
|
||||
return (0);
|
||||
|
||||
(*linesw[tp->t_line].l_close)(tp, flag);
|
||||
ttyclose(tp);
|
||||
|
||||
if (sc->sc_dying)
|
||||
return (0);
|
||||
|
||||
if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
|
||||
/*
|
||||
* Although we got a last close, the device may still be in
|
||||
* use; e.g. if this was the dialout node, and there are still
|
||||
* processes waiting for carrier on the non-dialout node.
|
||||
*/
|
||||
ucom_cleanup(sc);
|
||||
}
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
int
|
||||
ucomread(dev, uio, flag)
|
||||
dev_t dev;
|
||||
struct uio *uio;
|
||||
int flag;
|
||||
{
|
||||
struct ucom_softc *sc = ucom_cd.cd_devs[UCOMUNIT(dev)];
|
||||
struct tty *tp = sc->sc_tty;
|
||||
|
||||
if (sc->sc_dying)
|
||||
return (EIO);
|
||||
|
||||
return ((*linesw[tp->t_line].l_read)(tp, uio, flag));
|
||||
}
|
||||
|
||||
int
|
||||
ucomwrite(dev, uio, flag)
|
||||
dev_t dev;
|
||||
struct uio *uio;
|
||||
int flag;
|
||||
{
|
||||
struct ucom_softc *sc = ucom_cd.cd_devs[UCOMUNIT(dev)];
|
||||
struct tty *tp = sc->sc_tty;
|
||||
|
||||
if (sc->sc_dying)
|
||||
return (EIO);
|
||||
|
||||
return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
|
||||
}
|
||||
|
||||
struct tty *
|
||||
ucomtty(dev)
|
||||
dev_t dev;
|
||||
{
|
||||
struct ucom_softc *sc = ucom_cd.cd_devs[UCOMUNIT(dev)];
|
||||
struct tty *tp = sc->sc_tty;
|
||||
|
||||
return (tp);
|
||||
}
|
||||
|
||||
int
|
||||
ucomioctl(dev, cmd, data, flag, p)
|
||||
dev_t dev;
|
||||
u_long cmd;
|
||||
caddr_t data;
|
||||
int flag;
|
||||
struct proc *p;
|
||||
{
|
||||
struct ucom_softc *sc = ucom_cd.cd_devs[UCOMUNIT(dev)];
|
||||
struct tty *tp = sc->sc_tty;
|
||||
int error;
|
||||
int s;
|
||||
|
||||
if (sc->sc_dying)
|
||||
return (EIO);
|
||||
|
||||
DPRINTF(("ucomioctl: cmd=0x%08lx\n", cmd));
|
||||
|
||||
error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
|
||||
if (error >= 0)
|
||||
return (error);
|
||||
|
||||
error = ttioctl(tp, cmd, data, flag, p);
|
||||
if (error >= 0)
|
||||
return (error);
|
||||
|
||||
if (sc->sc_methods->ucom_ioctl != NULL) {
|
||||
error = sc->sc_methods->ucom_ioctl(sc->sc_parent,
|
||||
sc->sc_portno, cmd, data, flag, p);
|
||||
if (error >= 0)
|
||||
return (error);
|
||||
}
|
||||
|
||||
error = 0;
|
||||
|
||||
DPRINTF(("ucomioctl: our cmd=0x%08lx\n", cmd));
|
||||
s = spltty();
|
||||
|
||||
switch (cmd) {
|
||||
case TIOCSBRK:
|
||||
ucom_break(sc, 1);
|
||||
break;
|
||||
|
||||
case TIOCCBRK:
|
||||
ucom_break(sc, 0);
|
||||
break;
|
||||
|
||||
case TIOCSDTR:
|
||||
ucom_dtr(sc, 1);
|
||||
break;
|
||||
|
||||
case TIOCCDTR:
|
||||
ucom_dtr(sc, 0);
|
||||
break;
|
||||
|
||||
case TIOCGFLAGS:
|
||||
*(int *)data = sc->sc_swflags;
|
||||
break;
|
||||
|
||||
case TIOCSFLAGS:
|
||||
error = suser(p->p_ucred, &p->p_acflag);
|
||||
if (error)
|
||||
break;
|
||||
sc->sc_swflags = *(int *)data;
|
||||
break;
|
||||
|
||||
case TIOCMSET:
|
||||
case TIOCMBIS:
|
||||
case TIOCMBIC:
|
||||
tiocm_to_ucom(sc, cmd, *(int *)data);
|
||||
break;
|
||||
|
||||
case TIOCMGET:
|
||||
*(int *)data = ucom_to_tiocm(sc);
|
||||
break;
|
||||
|
||||
default:
|
||||
error = ENOTTY;
|
||||
break;
|
||||
}
|
||||
|
||||
splx(s);
|
||||
|
||||
return (error);
|
||||
}
|
||||
|
||||
void
|
||||
tiocm_to_ucom(sc, how, ttybits)
|
||||
struct ucom_softc *sc;
|
||||
int how, ttybits;
|
||||
{
|
||||
u_char combits;
|
||||
|
||||
combits = 0;
|
||||
if (ISSET(ttybits, TIOCM_DTR))
|
||||
SET(combits, UMCR_DTR);
|
||||
if (ISSET(ttybits, TIOCM_RTS))
|
||||
SET(combits, UMCR_RTS);
|
||||
|
||||
switch (how) {
|
||||
case TIOCMBIC:
|
||||
CLR(sc->sc_mcr, combits);
|
||||
break;
|
||||
|
||||
case TIOCMBIS:
|
||||
SET(sc->sc_mcr, combits);
|
||||
break;
|
||||
|
||||
case TIOCMSET:
|
||||
CLR(sc->sc_mcr, UMCR_DTR | UMCR_RTS);
|
||||
SET(sc->sc_mcr, combits);
|
||||
break;
|
||||
}
|
||||
|
||||
ucom_dtr(sc, (sc->sc_mcr & UMCR_DTR) != 0);
|
||||
ucom_rts(sc, (sc->sc_mcr & UMCR_RTS) != 0);
|
||||
}
|
||||
|
||||
int
|
||||
ucom_to_tiocm(sc)
|
||||
struct ucom_softc *sc;
|
||||
{
|
||||
u_char combits;
|
||||
int ttybits = 0;
|
||||
|
||||
combits = sc->sc_mcr;
|
||||
if (ISSET(combits, UMCR_DTR))
|
||||
SET(ttybits, TIOCM_DTR);
|
||||
if (ISSET(combits, UMCR_RTS))
|
||||
SET(ttybits, TIOCM_RTS);
|
||||
|
||||
combits = sc->sc_msr;
|
||||
if (ISSET(combits, UMSR_DCD))
|
||||
SET(ttybits, TIOCM_CD);
|
||||
if (ISSET(combits, UMSR_CTS))
|
||||
SET(ttybits, TIOCM_CTS);
|
||||
if (ISSET(combits, UMSR_DSR))
|
||||
SET(ttybits, TIOCM_DSR);
|
||||
if (ISSET(combits, UMSR_RI | UMSR_TERI))
|
||||
SET(ttybits, TIOCM_RI);
|
||||
|
||||
#if 0
|
||||
XXX;
|
||||
if (sc->sc_ier != 0)
|
||||
SET(ttybits, TIOCM_LE);
|
||||
#endif
|
||||
|
||||
return (ttybits);
|
||||
}
|
||||
|
||||
void
|
||||
ucom_break(sc, onoff)
|
||||
struct ucom_softc *sc;
|
||||
int onoff;
|
||||
{
|
||||
DPRINTF(("ucom_break: onoff=%d\n", onoff));
|
||||
|
||||
sc->sc_methods->ucom_set(sc->sc_parent, sc->sc_portno,
|
||||
UCOM_SET_BREAK, onoff);
|
||||
}
|
||||
|
||||
void
|
||||
ucom_dtr(sc, onoff)
|
||||
struct ucom_softc *sc;
|
||||
int onoff;
|
||||
{
|
||||
DPRINTF(("ucom_dtr: onoff=%d\n", onoff));
|
||||
|
||||
sc->sc_methods->ucom_set(sc->sc_parent, sc->sc_portno,
|
||||
UCOM_SET_DTR, onoff);
|
||||
}
|
||||
|
||||
void
|
||||
ucom_rts(sc, onoff)
|
||||
struct ucom_softc *sc;
|
||||
int onoff;
|
||||
{
|
||||
DPRINTF(("ucom_rts: onoff=%d\n", onoff));
|
||||
|
||||
sc->sc_methods->ucom_set(sc->sc_parent, sc->sc_portno,
|
||||
UCOM_SET_RTS, onoff);
|
||||
}
|
||||
|
||||
void
|
||||
ucom_status_change(sc)
|
||||
struct ucom_softc *sc;
|
||||
{
|
||||
sc->sc_methods->ucom_get_status(sc->sc_parent, sc->sc_portno,
|
||||
&sc->sc_lsr, &sc->sc_msr);
|
||||
}
|
||||
|
||||
int
|
||||
ucomparam(tp, t)
|
||||
struct tty *tp;
|
||||
struct termios *t;
|
||||
{
|
||||
struct ucom_softc *sc = ucom_cd.cd_devs[UCOMUNIT(tp->t_dev)];
|
||||
|
||||
if (sc->sc_dying)
|
||||
return (EIO);
|
||||
|
||||
/* Check requested parameters. */
|
||||
if (t->c_ispeed && t->c_ispeed != t->c_ospeed)
|
||||
return (EINVAL);
|
||||
|
||||
/*
|
||||
* For the console, always force CLOCAL and !HUPCL, so that the port
|
||||
* is always active.
|
||||
*/
|
||||
if (ISSET(sc->sc_swflags, TIOCFLAG_SOFTCAR)) {
|
||||
SET(t->c_cflag, CLOCAL);
|
||||
CLR(t->c_cflag, HUPCL);
|
||||
}
|
||||
|
||||
/*
|
||||
* If there were no changes, don't do anything. This avoids dropping
|
||||
* input and improves performance when all we did was frob things like
|
||||
* VMIN and VTIME.
|
||||
*/
|
||||
if (tp->t_ospeed == t->c_ospeed &&
|
||||
tp->t_cflag == t->c_cflag)
|
||||
return (0);
|
||||
|
||||
//XXX lcr = ISSET(sc->sc_lcr, LCR_SBREAK) | cflag2lcr(t->c_cflag);
|
||||
|
||||
/* And copy to tty. */
|
||||
tp->t_ispeed = 0;
|
||||
tp->t_ospeed = t->c_ospeed;
|
||||
tp->t_cflag = t->c_cflag;
|
||||
|
||||
sc->sc_methods->ucom_param(sc->sc_parent, sc->sc_portno, t);
|
||||
|
||||
// XXX worry about CHWFLOW
|
||||
|
||||
/*
|
||||
* Update the tty layer's idea of the carrier bit, in case we changed
|
||||
* CLOCAL or MDMBUF. We don't hang up here; we only do that by
|
||||
* explicit request.
|
||||
*/
|
||||
DPRINTF(("ucomparam: l_modem\n"));
|
||||
(void) (*linesw[tp->t_line].l_modem)(tp, 1 /* XXX carrier */ );
|
||||
|
||||
#if 0
|
||||
XXX what if the hardware is not open
|
||||
if (!ISSET(t->c_cflag, CHWFLOW)) {
|
||||
if (sc->sc_tx_stopped) {
|
||||
sc->sc_tx_stopped = 0;
|
||||
ucomstart(tp);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* (un)block input via hw flowcontrol
|
||||
*/
|
||||
void
|
||||
ucom_hwiflow(sc)
|
||||
struct ucom_softc *sc;
|
||||
{
|
||||
#if 0
|
||||
XXX
|
||||
bus_space_tag_t iot = sc->sc_iot;
|
||||
bus_space_handle_t ioh = sc->sc_ioh;
|
||||
|
||||
if (sc->sc_mcr_rts == 0)
|
||||
return;
|
||||
|
||||
if (ISSET(sc->sc_rx_flags, RX_ANY_BLOCK)) {
|
||||
CLR(sc->sc_mcr, sc->sc_mcr_rts);
|
||||
CLR(sc->sc_mcr_active, sc->sc_mcr_rts);
|
||||
} else {
|
||||
SET(sc->sc_mcr, sc->sc_mcr_rts);
|
||||
SET(sc->sc_mcr_active, sc->sc_mcr_rts);
|
||||
}
|
||||
bus_space_write_1(iot, ioh, com_mcr, sc->sc_mcr_active);
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
ucomstart(tp)
|
||||
struct tty *tp;
|
||||
{
|
||||
struct ucom_softc *sc = ucom_cd.cd_devs[UCOMUNIT(tp->t_dev)];
|
||||
usbd_status err;
|
||||
int s;
|
||||
u_char *data;
|
||||
int cnt;
|
||||
|
||||
if (sc->sc_dying)
|
||||
return;
|
||||
|
||||
s = spltty();
|
||||
if (ISSET(tp->t_state, TS_BUSY | TS_TIMEOUT | TS_TTSTOP)) {
|
||||
DPRINTFN(4,("ucomstart: stopped\n"));
|
||||
goto out;
|
||||
}
|
||||
if (sc->sc_tx_stopped)
|
||||
goto out;
|
||||
|
||||
if (tp->t_outq.c_cc <= tp->t_lowat) {
|
||||
if (ISSET(tp->t_state, TS_ASLEEP)) {
|
||||
CLR(tp->t_state, TS_ASLEEP);
|
||||
wakeup(&tp->t_outq);
|
||||
}
|
||||
selwakeup(&tp->t_wsel);
|
||||
if (tp->t_outq.c_cc == 0)
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* Grab the first contiguous region of buffer space. */
|
||||
data = tp->t_outq.c_cf;
|
||||
cnt = ndqb(&tp->t_outq, 0);
|
||||
|
||||
if (cnt == 0) {
|
||||
DPRINTF(("ucomstart: cnt==0\n"));
|
||||
goto out;
|
||||
}
|
||||
|
||||
SET(tp->t_state, TS_BUSY);
|
||||
|
||||
if (cnt > UCOMOBUFSIZE) {
|
||||
DPRINTF(("ucomstart: big buffer %d chars\n", cnt));
|
||||
cnt = UCOMOBUFSIZE;
|
||||
}
|
||||
memcpy(sc->sc_obuf, data, cnt);
|
||||
|
||||
DPRINTFN(4,("ucomstart: %d chars\n", cnt));
|
||||
usbd_setup_xfer(sc->sc_oxfer, sc->sc_bulkout_pipe,
|
||||
(usbd_private_handle)sc, sc->sc_obuf, cnt,
|
||||
USBD_NO_COPY, USBD_NO_TIMEOUT, ucomwritecb);
|
||||
/* What can we do on error? */
|
||||
err = usbd_transfer(sc->sc_oxfer);
|
||||
#ifdef DIAGNOSTIC
|
||||
if (err != USBD_IN_PROGRESS)
|
||||
printf("ucomstart: err=%s\n", usbd_errstr(err));
|
||||
#endif
|
||||
|
||||
out:
|
||||
splx(s);
|
||||
}
|
||||
|
||||
void
|
||||
ucomstop(tp, flag)
|
||||
struct tty *tp;
|
||||
int flag;
|
||||
{
|
||||
struct ucom_softc *sc = ucom_cd.cd_devs[UCOMUNIT(tp->t_dev)];
|
||||
int s;
|
||||
|
||||
DPRINTF(("ucomstop: %d\n", flag));
|
||||
s = spltty();
|
||||
if (ISSET(tp->t_state, TS_BUSY)) {
|
||||
DPRINTF(("ucomstop: XXX\n"));
|
||||
sc->sc_tx_stopped = 1;
|
||||
if (!ISSET(tp->t_state, TS_TTSTOP))
|
||||
SET(tp->t_state, TS_FLUSH);
|
||||
}
|
||||
splx(s);
|
||||
}
|
||||
|
||||
void
|
||||
ucomwritecb(xfer, p, status)
|
||||
usbd_xfer_handle xfer;
|
||||
usbd_private_handle p;
|
||||
usbd_status status;
|
||||
{
|
||||
struct ucom_softc *sc = (struct ucom_softc *)p;
|
||||
struct tty *tp = sc->sc_tty;
|
||||
u_int32_t cc;
|
||||
int s;
|
||||
|
||||
DPRINTFN(5,("ucomwritecb: status=%d\n", status));
|
||||
|
||||
if (status == USBD_CANCELLED)
|
||||
return;
|
||||
|
||||
if (status) {
|
||||
DPRINTF(("ucomwritecb: status=%d\n", status));
|
||||
usbd_clear_endpoint_stall_async(sc->sc_bulkin_pipe);
|
||||
/* XXX we should restart after some delay. */
|
||||
return;
|
||||
}
|
||||
|
||||
usbd_get_xfer_status(xfer, 0, 0, &cc, 0);
|
||||
DPRINTFN(5,("ucomwritecb: cc=%d\n", cc));
|
||||
|
||||
s = spltty();
|
||||
CLR(tp->t_state, TS_BUSY);
|
||||
if (ISSET(tp->t_state, TS_FLUSH))
|
||||
CLR(tp->t_state, TS_FLUSH);
|
||||
else
|
||||
ndflush(&tp->t_outq, cc);
|
||||
(*linesw[tp->t_line].l_start)(tp);
|
||||
splx(s);
|
||||
}
|
||||
|
||||
usbd_status
|
||||
ucomstartread(sc)
|
||||
struct ucom_softc *sc;
|
||||
{
|
||||
usbd_status err;
|
||||
|
||||
DPRINTFN(5,("ucomstartread: start\n"));
|
||||
usbd_setup_xfer(sc->sc_ixfer, sc->sc_bulkin_pipe,
|
||||
(usbd_private_handle)sc,
|
||||
sc->sc_ibuf, UCOMIBUFSIZE,
|
||||
USBD_SHORT_XFER_OK | USBD_NO_COPY,
|
||||
USBD_NO_TIMEOUT, ucomreadcb);
|
||||
err = usbd_transfer(sc->sc_ixfer);
|
||||
if (err != USBD_IN_PROGRESS) {
|
||||
DPRINTF(("ucomstartread: err=%s\n", usbd_errstr(err)));
|
||||
return (err);
|
||||
}
|
||||
return (USBD_NORMAL_COMPLETION);
|
||||
}
|
||||
|
||||
void
|
||||
ucomreadcb(xfer, p, status)
|
||||
usbd_xfer_handle xfer;
|
||||
usbd_private_handle p;
|
||||
usbd_status status;
|
||||
{
|
||||
struct ucom_softc *sc = (struct ucom_softc *)p;
|
||||
struct tty *tp = sc->sc_tty;
|
||||
int (*rint) __P((int c, struct tty *tp)) = linesw[tp->t_line].l_rint;
|
||||
usbd_status err;
|
||||
u_int32_t cc;
|
||||
u_char *cp;
|
||||
int s;
|
||||
|
||||
if (status == USBD_CANCELLED)
|
||||
return;
|
||||
|
||||
if (status) {
|
||||
DPRINTF(("ucomreadcb: status=%d\n", status));
|
||||
usbd_clear_endpoint_stall_async(sc->sc_bulkin_pipe);
|
||||
/* XXX we should restart after some delay. */
|
||||
return;
|
||||
}
|
||||
|
||||
usbd_get_xfer_status(xfer, 0, (void **)&cp, &cc, 0);
|
||||
DPRINTFN(5,("ucomreadcb: got %d chars, tp=%p\n", cc, tp));
|
||||
s = spltty();
|
||||
/* Give characters to tty layer. */
|
||||
while (cc-- > 0) {
|
||||
DPRINTFN(7,("ucomreadcb: char=0x%02x\n", *cp));
|
||||
if ((*rint)(*cp++, tp) == -1) {
|
||||
/* XXX what should we do? */
|
||||
break;
|
||||
}
|
||||
}
|
||||
splx(s);
|
||||
|
||||
err = ucomstartread(sc);
|
||||
if (err) {
|
||||
printf("%s: read start failed\n", USBDEVNAME(sc->sc_dev));
|
||||
/* XXX what should we dow now? */
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
ucom_cleanup(sc)
|
||||
struct ucom_softc *sc;
|
||||
{
|
||||
DPRINTF(("ucom_cleanup: closing pipes\n"));
|
||||
|
||||
ucom_shutdown(sc);
|
||||
usbd_abort_pipe(sc->sc_bulkin_pipe);
|
||||
usbd_close_pipe(sc->sc_bulkin_pipe);
|
||||
usbd_abort_pipe(sc->sc_bulkout_pipe);
|
||||
usbd_close_pipe(sc->sc_bulkout_pipe);
|
||||
usbd_free_xfer(sc->sc_ixfer);
|
||||
usbd_free_xfer(sc->sc_oxfer);
|
||||
}
|
||||
|
||||
int
|
||||
ucomprint(aux, pnp)
|
||||
void *aux;
|
||||
const char *pnp;
|
||||
{
|
||||
|
||||
if (pnp)
|
||||
printf("ucom at %s\n", pnp);
|
||||
return (UNCONF);
|
||||
}
|
||||
|
||||
int
|
||||
ucomsubmatch(parent, cf, aux)
|
||||
struct device *parent;
|
||||
struct cfdata *cf;
|
||||
void *aux;
|
||||
{
|
||||
struct ucom_attach_args *uca = aux;
|
||||
|
||||
if (uca->portno != UCOM_UNK_PORTNO &&
|
||||
cf->ucomcf_portno != UCOM_UNK_PORTNO &&
|
||||
cf->ucomcf_portno != uca->portno)
|
||||
return (0);
|
||||
return ((*cf->cf_attach->ca_match)(parent, cf, aux));
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue