ae5e131ac8
when ttselect() is improved. This requires using an array of tty structs and not using ttymalloc(). Fix an off by 1 error. Some caclulations seem to be off by a factor of NCY. NCY defaults to 16, which gives 256 tty structs occupying 0xd000 bytes. The minor number encoding only allows 16 ttys. Update the types of timeout functions to 2.0.
1671 lines
40 KiB
C
1671 lines
40 KiB
C
/*
|
|
* cyclades cyclom-y serial driver
|
|
* Andrew Herbert <andrew@werple.apana.org.au>, 17 August 1993
|
|
*
|
|
* Copyright (c) 1993 Andrew Herbert.
|
|
* All rights reserved.
|
|
*
|
|
* 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.
|
|
* 3. The name Andrew Herbert may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY ``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 I 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.
|
|
*
|
|
* $Id: cy.c,v 1.1 1995/02/09 09:47:27 jkh Exp $
|
|
*/
|
|
|
|
/*
|
|
* Device minor number encoding:
|
|
*
|
|
* c c x x u u u u - bits in the minor device number
|
|
*
|
|
* bits meaning
|
|
* ---- -------
|
|
* uuuu physical serial line (i.e. unit) to use
|
|
* 0-7 on a cyclom-8Y, 0-15 on a cyclom-16Y
|
|
* xx unused
|
|
* cc carrier control mode
|
|
* 00 complete hardware carrier control of the tty.
|
|
* DCD must be high for the open(2) to complete.
|
|
* 01 dialin pseudo-device (not yet implemented)
|
|
* 10 carrier ignored until a high->low transition
|
|
* 11 carrier completed ignored
|
|
*/
|
|
|
|
/*
|
|
* Known deficiencies:
|
|
*
|
|
* * no BREAK handling - breaks are ignored, and can't be sent either
|
|
* * no support for bad-char reporting, except via PARMRK
|
|
* * no support for dialin + dialout devices
|
|
*/
|
|
|
|
#include "cy.h"
|
|
#if NCY > 0
|
|
|
|
/* This disgusing hack because we actually have 16 units on one controller */
|
|
#if NCY < 2
|
|
#undef NCY
|
|
#define NCY (16)
|
|
#endif
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/tty.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/user.h>
|
|
#include <sys/conf.h>
|
|
#include <sys/file.h>
|
|
#include <sys/uio.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/syslog.h>
|
|
|
|
#include <machine/cpu.h>
|
|
#ifdef NetBSD
|
|
#include <machine/pio.h>
|
|
#endif
|
|
#include <machine/cpufunc.h>
|
|
|
|
#include <i386/isa/isa_device.h>
|
|
#include <i386/isa/ic/cd1400.h>
|
|
|
|
#define RxFifoThreshold 3 /* 3 characters (out of 12) in the receive
|
|
* FIFO before an interrupt is generated
|
|
*/
|
|
#define FastRawInput /* bypass the regular char-by-char canonical input
|
|
* processing whenever possible
|
|
*/
|
|
#define PollMode /* use polling-based irq service routine, not the
|
|
* hardware svcack lines. Must be defined for
|
|
* cyclom-16y boards.
|
|
*
|
|
* XXX cyclom-8y doesn't work without this defined
|
|
* either (!)
|
|
*/
|
|
#define LogOverruns /* log receive fifo overruns */
|
|
#undef TxBuffer /* buffer driver output, to be slightly more
|
|
* efficient
|
|
*
|
|
* XXX presently buggy
|
|
*/
|
|
#undef Smarts /* enable slightly more CD1400 intelligence. Mainly
|
|
* the output CR/LF processing, plus we can avoid a
|
|
* few checks usually done in ttyinput().
|
|
*
|
|
* XXX not yet implemented, and not particularly
|
|
* worthwhile either.
|
|
*/
|
|
#define CyDebug /* include debugging code (minimal effect on
|
|
* performance)
|
|
*/
|
|
|
|
#define CY_RX_BUFS 2 /* two receive buffers per port */
|
|
#define CY_RX_BUF_SIZE 256 /* bytes per receive buffer */
|
|
#define CY_TX_BUF_SIZE 512 /* bytes per transmit buffer */
|
|
|
|
/* #define CD1400s_PER_CYCLOM 1 */ /* cyclom-4y */
|
|
/* #define CD1400s_PER_CYCLOM 2 */ /* cyclom-8y */
|
|
#define CD1400s_PER_CYCLOM 4 /* cyclom-16y */
|
|
|
|
/* FreeBSD's getty doesn't know option for setting RTS/CTS handshake. Its
|
|
getty, like a lot of other old cruft, should be replaced with something
|
|
which used POSIX tty interfaces which at least allow enabling it. In the
|
|
meantime, use the force. */
|
|
#define ALWAYS_RTS_CTS 1
|
|
|
|
#if CD1400s_PER_CYCLOM < 4
|
|
#define CD1400_MEMSIZE 0x400 /* 4*256 bytes per chip: cyclom-[48]y */
|
|
#else
|
|
#define CD1400_MEMSIZE 0x100 /* 256 bytes per chip: cyclom-16y */
|
|
/* XXX or is it 0x400 like the rest? */
|
|
#define CYCLOM_16 1 /* This is a cyclom-16Y */
|
|
#endif
|
|
|
|
#define PORTS_PER_CYCLOM (CD1400_NO_OF_CHANNELS * CD1400s_PER_CYCLOM)
|
|
#define CYCLOM_RESET_16 0x1400 /* cyclom-16y reset */
|
|
#define CYCLOM_CLEAR_INTR 0x1800 /* intr ack address */
|
|
#define CYCLOM_CLOCK 25000000 /* baud rate clock */
|
|
|
|
#define CY_UNITMASK 0x0f
|
|
#define CY_CARRIERMASK 0xC0
|
|
#define CY_CARRIERSHIFT 6
|
|
|
|
#define UNIT(x) (minor(x) & CY_UNITMASK)
|
|
#define CARRIER_MODE(x) ((minor(x) & CY_CARRIERMASK) >> CY_CARRIERSHIFT)
|
|
|
|
typedef u_char * volatile cy_addr;
|
|
|
|
int cyprobe(struct isa_device *dev);
|
|
int cyattach(struct isa_device *isdp);
|
|
void cystart(struct tty *tp);
|
|
int cyparam(struct tty *tp, struct termios *t);
|
|
int cyspeed(int speed, int *prescaler_io);
|
|
static void cy_channel_init(dev_t dev, int reset);
|
|
static void cd1400_channel_cmd(cy_addr base, u_char cmd);
|
|
|
|
/* hsu@clinet.fi: sigh */
|
|
#ifdef __NetBSD__
|
|
#define DELAY(foo) delay(foo)
|
|
void delay(int delay);
|
|
#endif
|
|
|
|
/* Better get rid of this until the core people agree on kernel interfaces.
|
|
At least it will then compile on both WhichBSDs.
|
|
*/
|
|
#if 0
|
|
extern unsigned int delaycount; /* calibrated 1 ms cpu-spin delay */
|
|
#endif
|
|
|
|
struct isa_driver cydriver = {
|
|
cyprobe, cyattach, "cy"
|
|
};
|
|
|
|
/* low-level ping-pong buffer structure */
|
|
|
|
struct cy_buf {
|
|
u_char *next_char; /* location of next char to write */
|
|
u_int free; /* free chars remaining in buffer */
|
|
struct cy_buf *next_buf; /* circular, you know */
|
|
u_char buf[CY_RX_BUF_SIZE]; /* start of the buffer */
|
|
};
|
|
|
|
/* low-level ring buffer */
|
|
|
|
#ifdef TxBuffer
|
|
struct cy_ring {
|
|
u_char buf[CY_TX_BUF_SIZE];
|
|
u_char *head;
|
|
u_char *tail; /* next pos. to insert char */
|
|
u_char *endish; /* physical end of buf */
|
|
u_int used; /* no. of chars in queue */
|
|
};
|
|
#endif
|
|
|
|
|
|
/*
|
|
* define a structure to keep track of each serial line
|
|
*/
|
|
|
|
struct cy {
|
|
cy_addr base_addr; /* base address of this port's cd1400 */
|
|
struct tty *tty;
|
|
u_int dtrwait; /* time (in ticks) to hold dtr low after close */
|
|
u_int recv_exception; /* exception chars received */
|
|
u_int recv_normal; /* normal chars received */
|
|
u_int xmit; /* chars transmitted */
|
|
u_int mdm; /* modem signal changes */
|
|
#ifdef CyDebug
|
|
u_int start_count; /* no. of calls to cystart() */
|
|
u_int start_real; /* no. of calls that did something */
|
|
#endif
|
|
u_char carrier_mode; /* hardware carrier handling mode */
|
|
/*
|
|
* 0 = always use
|
|
* 1 = always use (dialin port)
|
|
* 2 = ignore during open, then use it
|
|
* 3 = ignore completely
|
|
*/
|
|
u_char carrier_delta; /* true if carrier has changed state */
|
|
u_char fifo_overrun; /* true if cd1400 receive fifo has... */
|
|
u_char rx_buf_overrun; /* true if low-level buf overflow */
|
|
u_char intr_enable; /* CD1400 SRER shadow */
|
|
u_char modem_sig; /* CD1400 modem signal shadow */
|
|
u_char channel_control;/* CD1400 CCR control command shadow */
|
|
u_char cor[3]; /* CD1400 COR1-3 shadows */
|
|
#ifdef Smarts
|
|
u_char spec_char[4]; /* CD1400 SCHR1-4 shadows */
|
|
#endif
|
|
struct cy_buf *rx_buf; /* current receive buffer */
|
|
struct cy_buf rx_buf_pool[CY_RX_BUFS];/* receive ping-pong buffers */
|
|
#ifdef TxBuffer
|
|
struct cy_ring tx_buf; /* transmit buffer */
|
|
#endif
|
|
};
|
|
|
|
int cydefaultrate = TTYDEF_SPEED;
|
|
cy_addr cyclom_base; /* base address of the card */
|
|
static struct cy *info[NCY*PORTS_PER_CYCLOM];
|
|
#ifdef __FreeBSD__ /* XXX actually only temporarily for 2.1-Development */
|
|
struct tty cy_tty[NCY*PORTS_PER_CYCLOM];
|
|
#else
|
|
struct tty *cy_tty[NCY*PORTS_PER_CYCLOM];
|
|
#endif
|
|
static volatile u_char timeout_scheduled = 0; /* true if a timeout has been scheduled */
|
|
|
|
#ifdef CyDebug
|
|
u_int cy_svrr_probes = 0; /* debugging */
|
|
u_int cy_timeouts = 0;
|
|
u_int cy_timeout_req = 0;
|
|
#endif
|
|
|
|
/**********************************************************************/
|
|
|
|
int
|
|
cyprobe(struct isa_device *dev)
|
|
{
|
|
int i, j;
|
|
u_char version = 0; /* firmware version */
|
|
|
|
/* Cyclom-16Y hardware reset (Cyclom-8Ys don't care) */
|
|
i = *(cy_addr)(dev->id_maddr + CYCLOM_RESET_16);
|
|
|
|
DELAY(500); /* wait for the board to get its act together (500 us) */
|
|
|
|
for (i = 0; i < CD1400s_PER_CYCLOM; i++) {
|
|
cy_addr base = dev->id_maddr + i * CD1400_MEMSIZE;
|
|
|
|
/* wait for chip to become ready for new command */
|
|
for (j = 0; j < 100; j += 50) {
|
|
DELAY(50); /* wait 50 us */
|
|
|
|
if (!*(base + CD1400_CCR))
|
|
break;
|
|
}
|
|
|
|
/* clear the GFRCR register */
|
|
*(base + CD1400_GFRCR) = 0;
|
|
|
|
/* issue a reset command */
|
|
*(base + CD1400_CCR) = CD1400_CMD_RESET;
|
|
|
|
/* wait for the CD1400 to initialise itself */
|
|
for (j = 0; j < 1000; j += 50) {
|
|
DELAY(50); /* wait 50 us */
|
|
|
|
/* retrieve firmware version */
|
|
version = *(base + CD1400_GFRCR);
|
|
if (version)
|
|
break;
|
|
}
|
|
|
|
/* anything in the 40-4f range is fine */
|
|
if ((version & 0xf0) != 0x40) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 1; /* found */
|
|
}
|
|
|
|
|
|
int
|
|
cyattach(struct isa_device *isdp)
|
|
{
|
|
/* u_char unit = UNIT(isdp->id_unit); */
|
|
int i, j, k;
|
|
|
|
/* global variable used various routines */
|
|
cyclom_base = (cy_addr)isdp->id_maddr;
|
|
|
|
for (i = 0, k = 0; i < CD1400s_PER_CYCLOM; i++) {
|
|
cy_addr base = cyclom_base + i * CD1400_MEMSIZE;
|
|
|
|
/* setup a 1ms clock tick */
|
|
*(base + CD1400_PPR) = CD1400_CLOCK_25_1MS;
|
|
|
|
for (j = 0; j < CD1400_NO_OF_CHANNELS; j++, k++) {
|
|
struct cy *ip;
|
|
|
|
/*
|
|
* grab some space. it'd be more polite to do this in cyopen(),
|
|
* but hey.
|
|
*/
|
|
info[k] = ip = malloc(sizeof(struct cy), M_DEVBUF, M_WAITOK);
|
|
|
|
/* clear all sorts of junk */
|
|
bzero(ip, sizeof(struct cy));
|
|
|
|
ip->base_addr = base;
|
|
|
|
/* initialise the channel, without resetting it first */
|
|
cy_channel_init(k, 0);
|
|
}
|
|
}
|
|
|
|
/* clear interrupts */
|
|
*(cyclom_base + CYCLOM_CLEAR_INTR) = (u_char)0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
int
|
|
cyopen(dev_t dev, int flag, int mode, struct proc *p)
|
|
{
|
|
u_int unit = UNIT(dev);
|
|
struct cy *infop;
|
|
cy_addr base;
|
|
struct tty *tp;
|
|
int error = 0;
|
|
u_char carrier;
|
|
|
|
if (unit >= /* NCY * ? */ PORTS_PER_CYCLOM)
|
|
return (ENXIO);
|
|
|
|
infop = info[unit];
|
|
base = infop->base_addr;
|
|
#ifdef __FreeBSD__
|
|
infop->tty = &cy_tty[unit];
|
|
#else
|
|
if (!cy_tty[unit])
|
|
infop->tty = cy_tty[unit] = ttymalloc();
|
|
#endif
|
|
tp = infop->tty;
|
|
|
|
tp->t_oproc = cystart;
|
|
tp->t_param = cyparam;
|
|
tp->t_dev = dev;
|
|
if (!(tp->t_state & TS_ISOPEN)) {
|
|
tp->t_state |= TS_WOPEN;
|
|
ttychars(tp);
|
|
if (tp->t_ispeed == 0) {
|
|
tp->t_iflag = TTYDEF_IFLAG;
|
|
tp->t_oflag = TTYDEF_OFLAG;
|
|
tp->t_cflag = TTYDEF_CFLAG;
|
|
tp->t_lflag = TTYDEF_LFLAG;
|
|
tp->t_ispeed = tp->t_ospeed = cydefaultrate;
|
|
}
|
|
|
|
(void) spltty();
|
|
cy_channel_init(unit, 1); /* reset the hardware */
|
|
|
|
/*
|
|
* raise dtr and generally set things up correctly. this
|
|
* has the side-effect of selecting the appropriate cd1400
|
|
* channel, to help us with subsequent channel control stuff
|
|
*/
|
|
cyparam(tp, &tp->t_termios);
|
|
|
|
/* check carrier, and set t_state's TS_CARR_ON flag accordingly */
|
|
infop->modem_sig = *(base + CD1400_MSVR);
|
|
carrier = infop->modem_sig & CD1400_MSVR_CD;
|
|
|
|
if (carrier || (infop->carrier_mode >= 2))
|
|
tp->t_state |= TS_CARR_ON;
|
|
else
|
|
tp->t_state &=~ TS_CARR_ON;
|
|
|
|
/*
|
|
* enable modem & rx interrupts - relies on cyparam()
|
|
* having selected the appropriate cd1400 channel
|
|
*/
|
|
infop->intr_enable = (1 << 7) | (1 << 4);
|
|
*(base + CD1400_SRER) = infop->intr_enable;
|
|
|
|
ttsetwater(tp);
|
|
} else if (tp->t_state & TS_XCLUDE && p->p_ucred->cr_uid != 0)
|
|
return (EBUSY);
|
|
|
|
if (!(flag & O_NONBLOCK))
|
|
while (!(tp->t_cflag & CLOCAL) &&
|
|
!(tp->t_state & TS_CARR_ON) && !error)
|
|
error = ttysleep(tp, (caddr_t)&tp->t_rawq,
|
|
TTIPRI|PCATCH, ttopen, 0);
|
|
(void) spl0();
|
|
|
|
if (!error)
|
|
error = (*linesw[(u_char)tp->t_line].l_open)(dev, tp);
|
|
return (error);
|
|
} /* end of cyopen() */
|
|
|
|
|
|
void
|
|
cyclose_wakeup(void *arg)
|
|
{
|
|
wakeup(arg);
|
|
} /* end of cyclose_wakeup() */
|
|
|
|
|
|
int
|
|
cyclose(dev_t dev, int flag, int mode, struct proc *p)
|
|
{
|
|
u_int unit = UNIT(dev);
|
|
struct cy *infop = info[unit];
|
|
struct tty *tp = infop->tty;
|
|
cy_addr base = infop->base_addr;
|
|
int s;
|
|
|
|
(*linesw[(u_char)tp->t_line].l_close)(tp, flag);
|
|
|
|
s = spltty();
|
|
/* select the appropriate channel on the CD1400 */
|
|
*(base + CD1400_CAR) = (u_char)(unit & 0x03);
|
|
|
|
/* disable this channel and lower DTR */
|
|
infop->intr_enable = 0;
|
|
*(base + CD1400_SRER) = (u_char)0; /* no intrs */
|
|
*(base + CD1400_DTR) = (u_char)CD1400_DTR_CLEAR; /* no DTR */
|
|
infop->modem_sig &= ~CD1400_MSVR_DTR;
|
|
|
|
/* disable receiver (leave transmitter enabled) */
|
|
infop->channel_control = (1 << 4) | (1 << 3) | 1;
|
|
cd1400_channel_cmd(base, infop->channel_control);
|
|
splx(s);
|
|
|
|
ttyclose(tp);
|
|
#ifdef broken /* session holds a ref to the tty; can't deallocate */
|
|
ttyfree(tp);
|
|
infop->tty = cy_tty[unit] = (struct tty *)NULL;
|
|
#endif
|
|
|
|
if (infop->dtrwait) {
|
|
int error;
|
|
|
|
timeout(cyclose_wakeup, (caddr_t)&infop->dtrwait, infop->dtrwait);
|
|
do {
|
|
error = tsleep((caddr_t)&infop->dtrwait,
|
|
TTIPRI|PCATCH, "cyclose", 0);
|
|
} while (error == ERESTART);
|
|
}
|
|
|
|
return 0;
|
|
} /* end of cyclose() */
|
|
|
|
|
|
int
|
|
cyread(dev_t dev, struct uio *uio, int flag)
|
|
{
|
|
u_int unit = UNIT(dev);
|
|
struct tty *tp = info[unit]->tty;
|
|
|
|
return (*linesw[(u_char)tp->t_line].l_read)(tp, uio, flag);
|
|
} /* end of cyread() */
|
|
|
|
|
|
int
|
|
cywrite(dev_t dev, struct uio *uio, int flag)
|
|
{
|
|
u_int unit = UNIT(dev);
|
|
struct tty *tp = info[unit]->tty;
|
|
|
|
#ifdef Smarts
|
|
/* XXX duplicate ttwrite(), but without so much output processing on
|
|
* CR & LF chars. Hardly worth the effort, given that high-throughput
|
|
* sessions are raw anyhow.
|
|
*/
|
|
#else
|
|
return (*linesw[(u_char)tp->t_line].l_write)(tp, uio, flag);
|
|
#endif
|
|
} /* end of cywrite() */
|
|
|
|
|
|
#ifdef Smarts
|
|
/* standard line discipline input routine */
|
|
int
|
|
cyinput(int c, struct tty *tp)
|
|
{
|
|
/* XXX duplicate ttyinput(), but without the IXOFF/IXON/ISTRIP/IPARMRK
|
|
* bits, as they are done by the CD1400. Hardly worth the effort,
|
|
* given that high-throughput sessions are raw anyhow.
|
|
*/
|
|
} /* end of cyinput() */
|
|
#endif /* Smarts */
|
|
|
|
|
|
inline static void
|
|
service_upper_rx(int unit)
|
|
{
|
|
struct cy *ip = info[unit];
|
|
struct tty *tp = ip->tty;
|
|
struct cy_buf *buf;
|
|
int i;
|
|
u_char *ch;
|
|
|
|
buf = ip->rx_buf;
|
|
|
|
/* give service_rx() a new one */
|
|
disable_intr(); /* faster than spltty() */
|
|
ip->rx_buf = buf->next_buf;
|
|
enable_intr();
|
|
|
|
if (tp->t_state & TS_ISOPEN) {
|
|
ch = buf->buf;
|
|
i = buf->next_char - buf->buf;
|
|
|
|
#ifdef FastRawInput
|
|
/* try to avoid calling the line discipline stuff if we can */
|
|
if ((tp->t_line == 0) &&
|
|
!(tp->t_iflag & (ICRNL | IMAXBEL | INLCR)) &&
|
|
!(tp->t_lflag & (ECHO | ECHONL | ICANON | IEXTEN |
|
|
ISIG | PENDIN)) &&
|
|
!(tp->t_state & (TS_CNTTB | TS_LNCH))) {
|
|
|
|
i = b_to_q(ch, i, &tp->t_rawq);
|
|
if (i) {
|
|
/*
|
|
* we have no RTS flow control support on cy-8
|
|
* boards, so this is really just tough luck
|
|
*/
|
|
|
|
log(LOG_WARNING, "cy%d: tty input queue overflow\n",
|
|
unit);
|
|
}
|
|
|
|
ttwakeup(tp); /* notify any readers */
|
|
}
|
|
else
|
|
#endif /* FastRawInput */
|
|
{
|
|
while (i--)
|
|
(*linesw[(u_char)tp->t_line].l_rint)((int)*ch++, tp);
|
|
}
|
|
}
|
|
|
|
/* clear the buffer we've just processed */
|
|
buf->next_char = buf->buf;
|
|
buf->free = CY_RX_BUF_SIZE;
|
|
} /* end of service_upper_rx() */
|
|
|
|
|
|
#ifdef TxBuffer
|
|
static void
|
|
service_upper_tx(int unit)
|
|
{
|
|
struct cy *ip = info[unit];
|
|
struct tty *tp = ip->tty;
|
|
|
|
tp->t_state &=~ (TS_BUSY|TS_FLUSH);
|
|
|
|
if (tp->t_outq.c_cc <= tp->t_lowat) {
|
|
if (tp->t_state&TS_ASLEEP) {
|
|
tp->t_state &= ~TS_ASLEEP;
|
|
wakeup((caddr_t)&tp->t_outq);
|
|
}
|
|
selwakeup(&tp->t_wsel);
|
|
}
|
|
|
|
if (tp->t_outq.c_cc > 0) {
|
|
struct cy_ring *txq = &ip->tx_buf;
|
|
int free_count = CY_TX_BUF_SIZE - ip->tx_buf.used;
|
|
u_char *cp = txq->tail;
|
|
int count;
|
|
int chars_done;
|
|
|
|
tp->t_state |= TS_BUSY;
|
|
|
|
/* find the largest contig. copy we can do */
|
|
count = ((txq->endish - cp) > free_count) ?
|
|
free_count : txq->endish - cp;
|
|
|
|
count = ((cp + free_count) > txq->endish) ?
|
|
txq->endish - cp : free_count;
|
|
|
|
/* copy the first slab */
|
|
chars_done = q_to_b(&tp->t_outq, cp, count);
|
|
|
|
/* check for wrap-around time */
|
|
cp += chars_done;
|
|
if (cp == txq->endish)
|
|
cp = txq->buf; /* back to the start */
|
|
|
|
/* copy anything else, after we've wrapped around */
|
|
if ((chars_done == count) && (count != free_count)) {
|
|
/* copy the second slab */
|
|
count = q_to_b(&tp->t_outq, cp, free_count - count);
|
|
cp += count;
|
|
chars_done += count;
|
|
}
|
|
|
|
/*
|
|
* update queue, protecting ourselves from any rampant
|
|
* lower-layers
|
|
*/
|
|
disable_intr();
|
|
txq->tail = cp;
|
|
txq->used += chars_done;
|
|
enable_intr();
|
|
}
|
|
|
|
if (!tp->t_outq.c_cc)
|
|
tp->t_state &=~ TS_BUSY;
|
|
} /* end of service_upper_tx() */
|
|
#endif /* TxBuffer */
|
|
|
|
|
|
inline static void
|
|
service_upper_mdm(int unit)
|
|
{
|
|
struct cy *ip = info[unit];
|
|
|
|
if (ip->carrier_delta) {
|
|
int carrier = ip->modem_sig & CD1400_MSVR_CD;
|
|
struct tty *tp = ip->tty;
|
|
|
|
if (!(*linesw[(u_char)tp->t_line].l_modem)(tp, carrier)) {
|
|
cy_addr base = ip->base_addr;
|
|
|
|
/* clear DTR */
|
|
disable_intr();
|
|
*(base + CD1400_CAR) = (u_char)(unit & 0x03);
|
|
*(base + CD1400_DTR) = (u_char)CD1400_DTR_CLEAR;
|
|
ip->modem_sig &= ~CD1400_MSVR_DTR;
|
|
ip->carrier_delta = 0;
|
|
enable_intr();
|
|
}
|
|
else {
|
|
disable_intr();
|
|
ip->carrier_delta = 0;
|
|
enable_intr();
|
|
}
|
|
}
|
|
} /* end of service_upper_mdm() */
|
|
|
|
|
|
/* upper level character processing routine */
|
|
void
|
|
cytimeout(void *ptr)
|
|
{
|
|
int unit;
|
|
|
|
timeout_scheduled = 0;
|
|
|
|
#ifdef CyDebug
|
|
cy_timeouts++;
|
|
#endif
|
|
|
|
/* check each port in turn */
|
|
for (unit = 0; unit < NCY*PORTS_PER_CYCLOM; unit++) {
|
|
struct cy *ip = info[unit];
|
|
#ifndef TxBuffer
|
|
struct tty *tp = ip->tty;
|
|
#endif
|
|
|
|
/* ignore anything that is not open */
|
|
if (!ip->tty)
|
|
continue;
|
|
|
|
/*
|
|
* any received chars to handle? (doesn't matter if intr routine
|
|
* kicks in while we're testing this)
|
|
*/
|
|
if (ip->rx_buf->free != CY_RX_BUF_SIZE)
|
|
service_upper_rx(unit);
|
|
|
|
#ifdef TxBuffer
|
|
/* anything to add to the transmit buffer (low-water mark)? */
|
|
if (ip->tx_buf.used < CY_TX_BUF_SIZE/2)
|
|
service_upper_tx(unit);
|
|
#else
|
|
if (tp->t_outq.c_cc <= tp->t_lowat) {
|
|
if (tp->t_state&TS_ASLEEP) {
|
|
tp->t_state &= ~TS_ASLEEP;
|
|
wakeup((caddr_t)&tp->t_outq);
|
|
}
|
|
selwakeup(&tp->t_wsel);
|
|
}
|
|
#endif
|
|
|
|
/* anything modem signals altered? */
|
|
service_upper_mdm(unit);
|
|
|
|
/* any overruns to log? */
|
|
#ifdef LogOverruns
|
|
if (ip->fifo_overrun) {
|
|
/*
|
|
* turn off the alarm - not important enough to bother
|
|
* with interrupt protection.
|
|
*/
|
|
ip->fifo_overrun = 0;
|
|
|
|
log(LOG_WARNING, "cy%d: receive fifo overrun\n", unit);
|
|
}
|
|
#endif
|
|
if (ip->rx_buf_overrun) {
|
|
/*
|
|
* turn off the alarm - not important enough to bother
|
|
* with interrupt protection.
|
|
*/
|
|
ip->rx_buf_overrun = 0;
|
|
|
|
log(LOG_WARNING, "cy%d: receive buffer full\n", unit);
|
|
}
|
|
}
|
|
} /* cytimeout() */
|
|
|
|
|
|
inline static void
|
|
schedule_upper_service(void)
|
|
{
|
|
#ifdef CyDebug
|
|
cy_timeout_req++;
|
|
#endif
|
|
|
|
if (!timeout_scheduled) {
|
|
timeout(cytimeout, (caddr_t)0, 1); /* call next tick */
|
|
timeout_scheduled = 1;
|
|
}
|
|
} /* end of schedule_upper_service() */
|
|
|
|
|
|
/* initialise a channel on the cyclom board */
|
|
|
|
static void
|
|
cy_channel_init(dev_t dev, int reset)
|
|
{
|
|
u_int unit = UNIT(dev);
|
|
int carrier_mode = CARRIER_MODE(dev);
|
|
struct cy *ip = info[unit];
|
|
cy_addr base = ip->base_addr;
|
|
struct tty *tp = ip->tty;
|
|
struct cy_buf *buf, *next_buf;
|
|
int i;
|
|
#ifndef PollMode
|
|
u_char cd1400_unit;
|
|
#endif
|
|
|
|
/* clear the structure and refill it */
|
|
bzero(ip, sizeof(struct cy));
|
|
ip->base_addr = base;
|
|
ip->tty = tp;
|
|
ip->carrier_mode = carrier_mode;
|
|
|
|
/* select channel of the CD1400 */
|
|
*(base + CD1400_CAR) = (u_char)(unit & 0x03);
|
|
|
|
if (reset)
|
|
cd1400_channel_cmd(base, 0x80); /* reset the channel */
|
|
|
|
/* set LIVR to 0 - intr routines depend on this */
|
|
*(base + CD1400_LIVR) = 0;
|
|
|
|
#ifndef PollMode
|
|
/* set top four bits of {R,T,M}ICR to the cd1400
|
|
* number, cd1400_unit
|
|
*/
|
|
cd1400_unit = unit / CD1400_NO_OF_CHANNELS;
|
|
*(base + CD1400_RICR) = (u_char)(cd1400_unit << 4);
|
|
*(base + CD1400_TICR) = (u_char)(cd1400_unit << 4);
|
|
*(base + CD1400_MICR) = (u_char)(cd1400_unit << 4);
|
|
#endif
|
|
|
|
ip->dtrwait = hz/4; /* quarter of a second */
|
|
|
|
/* setup low-level buffers */
|
|
i = CY_RX_BUFS;
|
|
ip->rx_buf = next_buf = &ip->rx_buf_pool[0];
|
|
while (i--) {
|
|
buf = &ip->rx_buf_pool[i];
|
|
|
|
buf->next_char = buf->buf; /* first char to use */
|
|
buf->free = CY_RX_BUF_SIZE; /* i.e. empty */
|
|
buf->next_buf = next_buf; /* where to go next */
|
|
next_buf = buf;
|
|
}
|
|
|
|
#ifdef TxBuffer
|
|
ip->tx_buf.endish = ip->tx_buf.buf + CY_TX_BUF_SIZE;
|
|
|
|
/* clear the low-level tx buffer */
|
|
ip->tx_buf.head = ip->tx_buf.tail = ip->tx_buf.buf;
|
|
ip->tx_buf.used = 0;
|
|
#endif
|
|
|
|
/* clear the low-level rx buffer */
|
|
ip->rx_buf->next_char = ip->rx_buf->buf; /* first char to use */
|
|
ip->rx_buf->free = CY_RX_BUF_SIZE; /* completely empty */
|
|
} /* end of cy_channel_init() */
|
|
|
|
|
|
/* service a receive interrupt */
|
|
inline static void
|
|
service_rx(int cd, caddr_t base)
|
|
{
|
|
struct cy *infop;
|
|
unsigned count;
|
|
int ch;
|
|
u_char serv_type, channel;
|
|
#ifdef PollMode
|
|
u_char save_rir, save_car;
|
|
#endif
|
|
|
|
/* setup */
|
|
#ifdef PollMode
|
|
save_rir = *(base + CD1400_RIR);
|
|
channel = cd * CD1400_NO_OF_CHANNELS + (save_rir & 0x3);
|
|
save_car = *(base + CD1400_CAR);
|
|
*(base + CD1400_CAR) = save_rir; /* enter modem service */
|
|
serv_type = *(base + CD1400_RIVR);
|
|
#else
|
|
serv_type = *(base + CD1400_SVCACKR); /* ack receive service */
|
|
channel = ((u_char)*(base + CD1400_RICR)) >> 2; /* get cyclom channel # */
|
|
|
|
#ifdef CyDebug
|
|
if (channel >= PORTS_PER_CYCLOM) {
|
|
printf("cy: service_rx - channel %02x\n", channel);
|
|
panic("cy: service_rx - bad channel");
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
infop = info[channel];
|
|
|
|
/* read those chars */
|
|
if (serv_type & CD1400_RIVR_EXCEPTION) {
|
|
/* read the exception status */
|
|
u_char status = *(base + CD1400_RDSR);
|
|
|
|
/* XXX is it a break? Do something if it is! */
|
|
|
|
/* XXX is IGNPAR not set? Store a null in the buffer. */
|
|
|
|
#ifdef LogOverruns
|
|
if (status & CD1400_RDSR_OVERRUN) {
|
|
#if 0
|
|
ch |= TTY_PE; /* for SLIP */
|
|
#endif
|
|
infop->fifo_overrun++;
|
|
}
|
|
#endif
|
|
infop->recv_exception++;
|
|
}
|
|
else {
|
|
struct cy_buf *buf = infop->rx_buf;
|
|
|
|
count = (u_char)*(base + CD1400_RDCR); /* how many to read? */
|
|
infop->recv_normal += count;
|
|
if (buf->free < count) {
|
|
infop->rx_buf_overrun += count;
|
|
|
|
/* read & discard everything */
|
|
while (count--)
|
|
ch = (u_char)*(base + CD1400_RDSR);
|
|
}
|
|
else {
|
|
/* slurp it into our low-level buffer */
|
|
buf->free -= count;
|
|
while (count--) {
|
|
ch = (u_char)*(base + CD1400_RDSR); /* read the char */
|
|
*(buf->next_char++) = ch;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef PollMode
|
|
*(base + CD1400_RIR) = (u_char)(save_rir & 0x3f); /* terminate service context */
|
|
#else
|
|
*(base + CD1400_EOSRR) = (u_char)0; /* terminate service context */
|
|
#endif
|
|
} /* end of service_rx */
|
|
|
|
|
|
/* service a transmit interrupt */
|
|
inline static void
|
|
service_tx(int cd, caddr_t base)
|
|
{
|
|
struct cy *ip;
|
|
#ifdef TxBuffer
|
|
struct cy_ring *txq;
|
|
#else
|
|
struct tty *tp;
|
|
#endif
|
|
u_char channel;
|
|
#ifdef PollMode
|
|
u_char save_tir, save_car;
|
|
#else
|
|
u_char vector;
|
|
#endif
|
|
|
|
/* setup */
|
|
#ifdef PollMode
|
|
save_tir = *(base + CD1400_TIR);
|
|
channel = cd * CD1400_NO_OF_CHANNELS + (save_tir & 0x3);
|
|
save_car = *(base + CD1400_CAR);
|
|
*(base + CD1400_CAR) = save_tir; /* enter tx service */
|
|
#else
|
|
vector = *(base + CD1400_SVCACKT); /* ack transmit service */
|
|
channel = ((u_char)*(base + CD1400_TICR)) >> 2; /* get cyclom channel # */
|
|
|
|
#ifdef CyDebug
|
|
if (channel >= PORTS_PER_CYCLOM) {
|
|
printf("cy: service_tx - channel %02x\n", channel);
|
|
panic("cy: service_tx - bad channel");
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
ip = info[channel];
|
|
#ifdef TxBuffer
|
|
txq = &ip->tx_buf;
|
|
|
|
if (txq->used > 0) {
|
|
cy_addr base = ip->base_addr;
|
|
int count = min(CD1400_FIFOSIZE, txq->used);
|
|
int chars_done = count;
|
|
u_char *cp = txq->head;
|
|
u_char *buf_end = txq->endish;
|
|
|
|
/* ip->state |= CY_BUSY; */
|
|
while (count--) {
|
|
*(base + CD1400_TDR) = *cp++;
|
|
if (cp >= buf_end)
|
|
cp = txq->buf;
|
|
};
|
|
txq->head = cp;
|
|
txq->used -= chars_done; /* important that this is atomic */
|
|
ip->xmit += chars_done;
|
|
}
|
|
|
|
/*
|
|
* disable tx intrs if no more chars to send. we re-enable
|
|
* them in cystart()
|
|
*/
|
|
if (!txq->used) {
|
|
ip->intr_enable &=~ (1 << 2);
|
|
*(base + CD1400_SRER) = ip->intr_enable;
|
|
/* ip->state &= ~CY_BUSY; */
|
|
}
|
|
#else
|
|
tp = ip->tty;
|
|
|
|
if (!(tp->t_state & TS_TTSTOP) && (tp->t_outq.c_cc > 0)) {
|
|
cy_addr base = ip->base_addr;
|
|
int count = min(CD1400_FIFOSIZE, tp->t_outq.c_cc);
|
|
|
|
ip->xmit += count;
|
|
tp->t_state |= TS_BUSY;
|
|
while (count--)
|
|
*(base + CD1400_TDR) = getc(&tp->t_outq);
|
|
}
|
|
|
|
/*
|
|
* disable tx intrs if no more chars to send. we re-enable them
|
|
* in cystart()
|
|
*/
|
|
if (!tp->t_outq.c_cc) {
|
|
ip->intr_enable &=~ (1 << 2);
|
|
*(base + CD1400_SRER) = ip->intr_enable;
|
|
tp->t_state &= ~TS_BUSY;
|
|
}
|
|
#endif
|
|
|
|
#ifdef PollMode
|
|
*(base + CD1400_TIR) = (u_char)(save_tir & 0x3f); /* terminate service context */
|
|
#else
|
|
*(base + CD1400_EOSRR) = (u_char)0; /* terminate service context */
|
|
#endif
|
|
} /* end of service_tx */
|
|
|
|
|
|
/* service a modem status interrupt */
|
|
inline static void
|
|
service_mdm(int cd, caddr_t base)
|
|
{
|
|
struct cy *infop;
|
|
u_char channel, deltas;
|
|
#ifdef PollMode
|
|
u_char save_mir, save_car;
|
|
#else
|
|
u_char vector;
|
|
#endif
|
|
|
|
/* setup */
|
|
#ifdef PollMode
|
|
save_mir = *(base + CD1400_MIR);
|
|
channel = cd * CD1400_NO_OF_CHANNELS + (save_mir & 0x3);
|
|
save_car = *(base + CD1400_CAR);
|
|
*(base + CD1400_CAR) = save_mir; /* enter modem service */
|
|
#else
|
|
vector = *(base + CD1400_SVCACKM); /* ack modem service */
|
|
channel = ((u_char)*(base + CD1400_MICR)) >> 2; /* get cyclom channel # */
|
|
|
|
#ifdef CyDebug
|
|
if (channel >= PORTS_PER_CYCLOM) {
|
|
printf("cy: service_mdm - channel %02x\n", channel);
|
|
panic("cy: service_mdm - bad channel");
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
infop = info[channel];
|
|
|
|
/* read the siggies and see what's changed */
|
|
infop->modem_sig = (u_char)*(base + CD1400_MSVR);
|
|
deltas = (u_char)*(base + CD1400_MISR);
|
|
|
|
if ((infop->carrier_mode <= 2) && (deltas & CD1400_MISR_CDd))
|
|
/* something for the upper layer to deal with */
|
|
infop->carrier_delta = 1;
|
|
|
|
infop->mdm++;
|
|
|
|
/* terminate service context */
|
|
#ifdef PollMode
|
|
*(base + CD1400_MIR) = (u_char)(save_mir & 0x3f);
|
|
#else
|
|
*(base + CD1400_EOSRR) = (u_char)0;
|
|
#endif
|
|
} /* end of service_mdm */
|
|
|
|
|
|
int
|
|
cyintr(int unit)
|
|
{
|
|
int cd;
|
|
u_char status;
|
|
|
|
/* check each CD1400 in turn */
|
|
for (cd = 0; cd < CD1400s_PER_CYCLOM; cd++) {
|
|
cy_addr base = cyclom_base + cd*CD1400_MEMSIZE;
|
|
|
|
/* poll to see if it has any work */
|
|
while (status = (u_char)*(base + CD1400_SVRR)) {
|
|
#ifdef CyDebug
|
|
cy_svrr_probes++;
|
|
#endif
|
|
/* service requests as appropriate, giving priority to RX */
|
|
if (status & CD1400_SVRR_RX)
|
|
service_rx(cd, base);
|
|
if (status & CD1400_SVRR_TX)
|
|
service_tx(cd, base);
|
|
if (status & CD1400_SVRR_MDM)
|
|
service_mdm(cd, base);
|
|
}
|
|
}
|
|
|
|
/* request upper level service to deal with whatever happened */
|
|
schedule_upper_service();
|
|
|
|
/* re-enable interrupts on the cyclom */
|
|
*(cyclom_base + CYCLOM_CLEAR_INTR) = (u_char)0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
int
|
|
cyioctl(dev_t dev, int cmd, caddr_t data, int flag, struct proc *p)
|
|
{
|
|
int unit = UNIT(dev);
|
|
struct cy *infop = info[unit];
|
|
struct tty *tp = infop->tty;
|
|
int error;
|
|
|
|
error = (*linesw[(u_char)tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
|
|
if (error >= 0)
|
|
return (error);
|
|
error = ttioctl(tp, cmd, data, flag
|
|
#ifdef NetBSD
|
|
, p
|
|
#endif
|
|
);
|
|
if (error >= 0)
|
|
return (error);
|
|
|
|
switch (cmd) {
|
|
#ifdef notyet /* sigh - more junk to do XXX */
|
|
case TIOCSBRK:
|
|
break;
|
|
case TIOCCBRK:
|
|
break;
|
|
case TIOCSDTR:
|
|
break;
|
|
case TIOCCDTR:
|
|
break;
|
|
|
|
case TIOCMSET:
|
|
break;
|
|
case TIOCMBIS:
|
|
break;
|
|
case TIOCMBIC:
|
|
break;
|
|
#endif /* notyet */
|
|
|
|
case TIOCMGET: {
|
|
int bits = 0;
|
|
u_char status = infop->modem_sig;
|
|
|
|
if (status & CD1400_MSVR_DTR) bits |= TIOCM_DTR | TIOCM_RTS;
|
|
if (status & CD1400_MSVR_CD) bits |= TIOCM_CD;
|
|
if (status & CD1400_MSVR_CTS) bits |= TIOCM_CTS;
|
|
if (status & CD1400_MSVR_DSR) bits |= TIOCM_DSR;
|
|
#ifdef CYCLOM_16
|
|
if (status & CD1400_MSVR_RI) bits |= TIOCM_RI;
|
|
#endif
|
|
if (infop->channel_control & 0x02) bits |= TIOCM_LE;
|
|
*(int *)data = bits;
|
|
break;
|
|
}
|
|
|
|
#ifdef TIOCMSBIDIR
|
|
case TIOCMSBIDIR:
|
|
return (ENOTTY);
|
|
#endif /* TIOCMSBIDIR */
|
|
|
|
#ifdef TIOCMGBIDIR
|
|
case TIOCMGBIDIR:
|
|
return (ENOTTY);
|
|
#endif /* TIOCMGBIDIR */
|
|
|
|
#ifdef TIOCMSDTRWAIT
|
|
case TIOCMSDTRWAIT:
|
|
/* must be root to set dtr delay */
|
|
if (p->p_ucred->cr_uid != 0)
|
|
return(EPERM);
|
|
|
|
infop->dtrwait = *(u_int *)data;
|
|
break;
|
|
#endif /* TIOCMSDTRWAIT */
|
|
|
|
#ifdef TIOCMGDTRWAIT
|
|
case TIOCMGDTRWAIT:
|
|
*(u_int *)data = infop->dtrwait;
|
|
break;
|
|
#endif /* TIOCMGDTRWAIT */
|
|
|
|
default:
|
|
return (ENOTTY);
|
|
}
|
|
|
|
return 0;
|
|
} /* end of cyioctl() */
|
|
|
|
|
|
int
|
|
cyparam(struct tty *tp, struct termios *t)
|
|
{
|
|
u_char unit = UNIT(tp->t_dev);
|
|
struct cy *infop = info[unit];
|
|
cy_addr base = infop->base_addr;
|
|
int cflag = t->c_cflag;
|
|
int iflag = t->c_iflag;
|
|
int ispeed, ospeed;
|
|
int itimeout;
|
|
int iprescaler, oprescaler;
|
|
int s;
|
|
u_char cor_change = 0;
|
|
u_char opt;
|
|
|
|
if (!t->c_ispeed)
|
|
t->c_ispeed = t->c_ospeed;
|
|
|
|
s = spltty();
|
|
|
|
/* select the appropriate channel on the CD1400 */
|
|
*(base + CD1400_CAR) = unit & 0x03;
|
|
|
|
/* handle DTR drop on speed == 0 trick */
|
|
if (t->c_ospeed == 0) {
|
|
*(base + CD1400_DTR) = CD1400_DTR_CLEAR;
|
|
infop->modem_sig &= ~CD1400_MSVR_DTR;
|
|
}
|
|
else {
|
|
*(base + CD1400_DTR) = CD1400_DTR_SET;
|
|
infop->modem_sig |= CD1400_MSVR_DTR;
|
|
}
|
|
|
|
/* set baud rates if they've changed from last time */
|
|
|
|
if ((ospeed = cyspeed(t->c_ospeed, &oprescaler)) < 0)
|
|
return EINVAL;
|
|
*(base + CD1400_TBPR) = (u_char)ospeed;
|
|
*(base + CD1400_TCOR) = (u_char)oprescaler;
|
|
|
|
if ((ispeed = cyspeed(t->c_ispeed, &iprescaler)) < 0)
|
|
return EINVAL;
|
|
*(base + CD1400_RBPR) = (u_char)ispeed;
|
|
*(base + CD1400_RCOR) = (u_char)iprescaler;
|
|
|
|
/*
|
|
* set receive time-out period
|
|
* generate a rx interrupt if no new chars are received in
|
|
* this many ticks
|
|
* don't bother comparing old & new VMIN, VTIME and ispeed - it
|
|
* can't be much worse just to calculate and set it each time!
|
|
* certainly less hassle. :-)
|
|
*/
|
|
|
|
/*
|
|
* calculate minimum timeout period:
|
|
* 5 ms or the time it takes to receive 1 char, rounded up to the
|
|
* next ms, whichever is greater
|
|
*/
|
|
if (t->c_ispeed > 0) {
|
|
itimeout = (t->c_ispeed > 2200) ? 5 : (10000/t->c_ispeed + 1);
|
|
|
|
/* if we're using VTIME as an inter-char timeout, and it is set to
|
|
* be longer than the minimum calculated above, go for it
|
|
*/
|
|
if (t->c_cc[VMIN] && t->c_cc[VTIME] && t->c_cc[VTIME]*10 > itimeout)
|
|
itimeout = t->c_cc[VTIME]*10;
|
|
|
|
/* store it, taking care not to overflow the byte-sized register */
|
|
*(base + CD1400_RTPR) = (u_char)((itimeout <= 255) ? itimeout : 255);
|
|
}
|
|
|
|
|
|
/*
|
|
* channel control
|
|
* receiver enable
|
|
* transmitter enable (always set)
|
|
*/
|
|
opt = (1 << 4) | (1 << 3) | ((cflag & CREAD) ? (1 << 1) : 1);
|
|
if (opt != infop->channel_control) {
|
|
infop->channel_control = opt;
|
|
cd1400_channel_cmd(base, opt);
|
|
}
|
|
|
|
#ifdef Smarts
|
|
/* set special chars */
|
|
if (t->c_cc[VSTOP] != _POSIX_VDISABLE &&
|
|
(t->c_cc[VSTOP] != infop->spec_char[0])) {
|
|
*(base + CD1400_SCHR1) = infop->spec_char[0] = t->c_cc[VSTOP];
|
|
}
|
|
if (t->c_cc[VSTART] != _POSIX_VDISABLE &&
|
|
(t->c_cc[VSTART] != infop->spec_char[1])) {
|
|
*(base + CD1400_SCHR2) = infop->spec_char[0] = t->c_cc[VSTART];
|
|
}
|
|
if (t->c_cc[VINTR] != _POSIX_VDISABLE &&
|
|
(t->c_cc[VINTR] != infop->spec_char[2])) {
|
|
*(base + CD1400_SCHR3) = infop->spec_char[0] = t->c_cc[VINTR];
|
|
}
|
|
if (t->c_cc[VSUSP] != _POSIX_VDISABLE &&
|
|
(t->c_cc[VSUSP] != infop->spec_char[3])) {
|
|
*(base + CD1400_SCHR4) = infop->spec_char[0] = t->c_cc[VSUSP];
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* set channel option register 1 -
|
|
* parity mode
|
|
* stop bits
|
|
* char length
|
|
*/
|
|
opt = 0;
|
|
/* parity */
|
|
if (cflag & PARENB) {
|
|
if (cflag & PARODD)
|
|
opt |= 1 << 7;
|
|
opt |= 2 << 5; /* normal parity mode */
|
|
}
|
|
if (!(iflag & INPCK))
|
|
opt |= 1 << 4; /* ignore parity */
|
|
/* stop bits */
|
|
if (cflag & CSTOPB)
|
|
opt |= 2 << 2;
|
|
/* char length */
|
|
opt |= (cflag & CSIZE) >> 8; /* nasty, but fast */
|
|
if (opt != infop->cor[0]) {
|
|
cor_change |= 1 << 1;
|
|
*(base + CD1400_COR1) = opt;
|
|
}
|
|
|
|
/*
|
|
* set channel option register 2 -
|
|
* flow control
|
|
*/
|
|
opt = 0;
|
|
#ifdef Smarts
|
|
if (iflag & IXANY)
|
|
opt |= 1 << 7; /* auto output restart on any char after XOFF */
|
|
if (iflag & IXOFF)
|
|
opt |= 1 << 6; /* auto XOFF output flow-control */
|
|
#endif
|
|
#ifndef ALWAYS_RTS_CTS
|
|
if (cflag & CCTS_OFLOW)
|
|
#endif
|
|
opt |= 1 << 1; /* auto CTS flow-control */
|
|
|
|
if (opt != infop->cor[1]) {
|
|
cor_change |= 1 << 2;
|
|
*(base + CD1400_COR2) = opt;
|
|
}
|
|
|
|
/*
|
|
* set channel option register 3 -
|
|
* receiver FIFO interrupt threshold
|
|
* flow control
|
|
*/
|
|
opt = RxFifoThreshold; /* rx fifo threshold */
|
|
#ifdef Smarts
|
|
if (t->c_lflag & ICANON)
|
|
opt |= 1 << 6; /* detect INTR & SUSP chars */
|
|
if (iflag & IXOFF)
|
|
opt |= (1 << 5) | (1 << 4); /* transparent in-band flow control */
|
|
#endif
|
|
if (opt != infop->cor[2]) {
|
|
cor_change |= 1 << 3;
|
|
*(base + CD1400_COR3) = opt;
|
|
}
|
|
|
|
|
|
/* notify the CD1400 if COR1-3 have changed */
|
|
if (cor_change) {
|
|
cor_change |= 1 << 6; /* COR change flag */
|
|
cd1400_channel_cmd(base, cor_change);
|
|
}
|
|
|
|
/*
|
|
* set channel option register 4 -
|
|
* CR/NL processing
|
|
* break processing
|
|
* received exception processing
|
|
*/
|
|
opt = 0;
|
|
if (iflag & IGNCR)
|
|
opt |= 1 << 7;
|
|
#ifdef Smarts
|
|
/*
|
|
* we need a new ttyinput() for this, as we don't want to
|
|
* have ICRNL && INLCR being done in both layers, or to have
|
|
* synchronisation problems
|
|
*/
|
|
if (iflag & ICRNL)
|
|
opt |= 1 << 6;
|
|
if (iflag & INLCR)
|
|
opt |= 1 << 5;
|
|
#endif
|
|
if (iflag & IGNBRK)
|
|
opt |= 1 << 4;
|
|
if (!(iflag & BRKINT))
|
|
opt |= 1 << 3;
|
|
if (iflag & IGNPAR)
|
|
#ifdef LogOverruns
|
|
opt |= 0; /* broken chars cause receive exceptions */
|
|
#else
|
|
opt |= 2; /* discard broken chars */
|
|
#endif
|
|
else {
|
|
if (iflag & PARMRK)
|
|
opt |= 4; /* precede broken chars with 0xff 0x0 */
|
|
else
|
|
#ifdef LogOverruns
|
|
opt |= 0; /* broken chars cause receive exceptions */
|
|
#else
|
|
opt |= 3; /* convert framing/parity errs to nulls */
|
|
#endif
|
|
}
|
|
*(base + CD1400_COR4) = opt;
|
|
|
|
/*
|
|
* set channel option register 5 -
|
|
*/
|
|
opt = 0;
|
|
if (iflag & ISTRIP)
|
|
opt |= 1 << 7;
|
|
if (t->c_iflag & IEXTEN) {
|
|
opt |= 1 << 6; /* enable LNEXT (e.g. ctrl-v quoting) handling */
|
|
}
|
|
#ifdef Smarts
|
|
if (t->c_oflag & ONLCR)
|
|
opt |= 1 << 1;
|
|
if (t->c_oflag & OCRNL)
|
|
opt |= 1;
|
|
#endif
|
|
*(base + CD1400_COR5) = opt;
|
|
|
|
/*
|
|
* set modem change option register 1
|
|
* generate modem interrupts on which 1 -> 0 input transitions
|
|
* also controls auto-DTR output flow-control, which we don't use
|
|
*/
|
|
opt = (cflag & CLOCAL) ? 0 : 1 << 4; /* CD */
|
|
*(base + CD1400_MCOR1) = opt;
|
|
|
|
/*
|
|
* set modem change option register 2
|
|
* generate modem interrupts on specific 0 -> 1 input transitions
|
|
*/
|
|
opt = (cflag & CLOCAL) ? 0 : 1 << 4; /* CD */
|
|
*(base + CD1400_MCOR2) = opt;
|
|
|
|
splx(s);
|
|
|
|
return 0;
|
|
} /* end of cyparam */
|
|
|
|
|
|
void
|
|
cystart(struct tty *tp)
|
|
{
|
|
u_char unit = UNIT(tp->t_dev);
|
|
struct cy *infop = info[unit];
|
|
cy_addr base = infop->base_addr;
|
|
int s;
|
|
|
|
#ifdef CyDebug
|
|
infop->start_count++;
|
|
#endif
|
|
|
|
/* check the flow-control situation */
|
|
if (tp->t_state & (TS_TIMEOUT | TS_TTSTOP))
|
|
return;
|
|
|
|
if (tp->t_outq.c_cc <= tp->t_lowat) {
|
|
if (tp->t_state&TS_ASLEEP) {
|
|
tp->t_state &= ~TS_ASLEEP;
|
|
wakeup((caddr_t)&tp->t_outq);
|
|
}
|
|
selwakeup(&tp->t_wsel);
|
|
}
|
|
|
|
#ifdef TxBuffer
|
|
service_upper_tx(unit); /* feed the monster */
|
|
#endif
|
|
|
|
s = spltty();
|
|
|
|
if (!(infop->intr_enable & (1 << 2))) {
|
|
/* select the channel */
|
|
*(base + CD1400_CAR) = unit & (u_char)3;
|
|
|
|
/* (re)enable interrupts to set things in motion */
|
|
infop->intr_enable |= (1 << 2);
|
|
*(base + CD1400_SRER) = infop->intr_enable;
|
|
|
|
infop->start_real++;
|
|
}
|
|
|
|
splx(s);
|
|
} /* end of cystart() */
|
|
|
|
|
|
int
|
|
cystop(struct tty *tp, int flag)
|
|
{
|
|
u_char unit = UNIT(tp->t_dev);
|
|
struct cy *ip = info[unit];
|
|
cy_addr base = ip->base_addr;
|
|
int s;
|
|
|
|
s = spltty();
|
|
|
|
/* select the channel */
|
|
*(base + CD1400_CAR) = unit & 3;
|
|
|
|
/* halt output by disabling transmit interrupts */
|
|
ip->intr_enable &=~ (1 << 2);
|
|
*(base + CD1400_SRER) = ip->intr_enable;
|
|
|
|
splx(s);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
cyselect(dev_t dev, int rw, struct proc *p)
|
|
{
|
|
return (ttselect(UNIT(dev), rw, p));
|
|
} /* end of cyselect() */
|
|
|
|
|
|
int
|
|
cyspeed(int speed, int *prescaler_io)
|
|
{
|
|
int actual;
|
|
int error;
|
|
int divider;
|
|
int prescaler;
|
|
int prescaler_unit;
|
|
|
|
if (speed == 0)
|
|
return 0;
|
|
|
|
if (speed < 0 || speed > 150000)
|
|
return -1;
|
|
|
|
/* determine which prescaler to use */
|
|
for (prescaler_unit = 4, prescaler = 2048; prescaler_unit;
|
|
prescaler_unit--, prescaler >>= 2) {
|
|
if (CYCLOM_CLOCK/prescaler/speed > 63)
|
|
break;
|
|
}
|
|
|
|
divider = (CYCLOM_CLOCK/prescaler*2/speed + 1)/2; /* round off */
|
|
if (divider > 255)
|
|
divider = 255;
|
|
actual = CYCLOM_CLOCK/prescaler/divider;
|
|
error = ((actual-speed)*2000/speed +1)/2; /* percentage */
|
|
|
|
/* 3.0% max error tolerance */
|
|
if (error < -30 || error > 30)
|
|
return -1;
|
|
|
|
#if 0
|
|
printf("prescaler = %d (%d)\n", prescaler, prescaler_unit);
|
|
printf("divider = %d (%x)\n", divider, divider);
|
|
printf("actual = %d\n", actual);
|
|
printf("error = %d\n", error);
|
|
#endif
|
|
|
|
*prescaler_io = prescaler_unit;
|
|
return divider;
|
|
} /* end of cyspeed() */
|
|
|
|
|
|
static void
|
|
cd1400_channel_cmd(cy_addr base, u_char cmd)
|
|
{
|
|
/* XXX hsu@clinet.fi: This is always more dependent on ISA bus speed,
|
|
as the card is probed every round? Replaced delaycount with 8k.
|
|
Either delaycount has to be implemented in FreeBSD or more sensible
|
|
way of doing these should be implemented. DELAY isn't enough here.
|
|
*/
|
|
unsigned maxwait = 5 * 8 * 1024; /* approx. 5 ms */
|
|
|
|
/* wait for processing of previous command to complete */
|
|
while (*(base + CD1400_CCR) && maxwait--)
|
|
;
|
|
|
|
if (!maxwait)
|
|
log(LOG_ERR, "cy: channel command timeout (%d loops) - arrgh\n",
|
|
5 * 8 * 1024);
|
|
|
|
*(base + CD1400_CCR) = cmd;
|
|
} /* end of cd1400_channel_cmd() */
|
|
|
|
|
|
#ifdef CyDebug
|
|
/* useful in ddb */
|
|
void
|
|
cyclear(void)
|
|
{
|
|
/* clear the timeout request */
|
|
disable_intr();
|
|
timeout_scheduled = 0;
|
|
enable_intr();
|
|
}
|
|
|
|
void
|
|
cyclearintr(void)
|
|
{
|
|
/* clear interrupts */
|
|
*(cyclom_base + CYCLOM_CLEAR_INTR) = (u_char)0;
|
|
}
|
|
|
|
int
|
|
cyparam_dummy(struct tty *tp, struct termios *t)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
cyset(int unit, int active)
|
|
{
|
|
if (unit < 0 || unit >= /* NCY *? */ PORTS_PER_CYCLOM) {
|
|
printf("bad unit number %d\n", unit);
|
|
return;
|
|
}
|
|
#ifdef __FreeBSD__
|
|
cy_tty[unit].t_param = active ? cyparam : cyparam_dummy;
|
|
#else
|
|
cy_tty[unit]->t_param = active ? cyparam : cyparam_dummy;
|
|
#endif
|
|
}
|
|
|
|
|
|
/* useful in ddb */
|
|
void
|
|
cystatus(int unit)
|
|
{
|
|
struct cy *infop = info[unit];
|
|
struct tty *tp = infop->tty;
|
|
cy_addr base = infop->base_addr;
|
|
|
|
printf("info for channel %d\n", unit);
|
|
printf("------------------\n");
|
|
|
|
printf("cd1400 base address:\t0x%x\n", (int)infop->base_addr);
|
|
|
|
/* select the port */
|
|
*(base + CD1400_CAR) = (u_char)unit;
|
|
|
|
printf("saved channel_control:\t%02x\n", infop->channel_control);
|
|
printf("saved cor1:\t\t%02x\n", infop->cor[0]);
|
|
printf("service request enable reg:\t%02x (%02x cached)\n",
|
|
(u_char)*(base + CD1400_SRER), infop->intr_enable);
|
|
printf("service request register:\t%02x\n",
|
|
(u_char)*(base + CD1400_SVRR));
|
|
printf("\n");
|
|
printf("modem status:\t\t\t%02x (%02x cached)\n",
|
|
(u_char)*(base + CD1400_MSVR), infop->modem_sig);
|
|
printf("rx/tx/mdm interrupt registers:\t%02x %02x %02x\n",
|
|
(u_char)*(base + CD1400_RIR), (u_char)*(base + CD1400_TIR),
|
|
(u_char)*(base + CD1400_MIR));
|
|
printf("\n");
|
|
if (tp) {
|
|
printf("tty state:\t\t\t%04x\n", tp->t_state);
|
|
printf("upper layer queue lengths:\t%d raw, %d canon, %d output\n",
|
|
tp->t_rawq.c_cc, tp->t_canq.c_cc, tp->t_outq.c_cc);
|
|
}
|
|
else
|
|
printf("tty state:\t\t\tclosed\n");
|
|
printf("\n");
|
|
|
|
printf("calls to cystart():\t\t%d (%d useful)\n",
|
|
infop->start_count, infop->start_real);
|
|
printf("\n");
|
|
printf("total cyclom service probes:\t%d\n", cy_svrr_probes);
|
|
printf("calls to upper layer:\t\t%d\n", cy_timeouts);
|
|
printf("rx buffer chars free:\t\t%d\n", infop->rx_buf->free);
|
|
#ifdef TxBuffer
|
|
printf("tx buffer chars used:\t\t%d\n", infop->tx_buf.used);
|
|
#endif
|
|
printf("received chars:\t\t\t%d good, %d exception\n",
|
|
infop->recv_normal, infop->recv_exception);
|
|
printf("transmitted chars:\t\t%d\n", infop->xmit);
|
|
printf("modem signal deltas:\t\t%d\n", infop->mdm);
|
|
printf("\n");
|
|
} /* end of cystatus() */
|
|
#endif
|
|
#endif /* NCY > 0 */
|