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

1646 lines
39 KiB
C
Raw Blame History

/*
* 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.4 1994/02/09 21:13:43 mycroft 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
#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/pio.h>
#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 (!)
*/
#undef 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 */
#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? */
#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);
void DELAY(int delay);
extern unsigned int delaycount; /* calibrated 1 ms cpu-spin delay */
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];
struct tty *cy_tty[NCY*PORTS_PER_CYCLOM];
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 >= PORTS_PER_CYCLOM)
return (ENXIO);
infop = info[unit];
base = infop->base_addr;
if (!cy_tty[unit])
infop->tty = cy_tty[unit] = ttymalloc();
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(caddr_t 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 */
static void
cytimeout(caddr_t 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, p);
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
if (cflag & CCTS_OFLOW)
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)
{
struct tty *tp = info[UNIT(dev)]->tty;
int s = spltty();
int nread;
switch (rw) {
case FREAD:
nread = ttnread(tp);
if (nread > 0 ||
((tp->t_cflag&CLOCAL) == 0 && (tp->t_state&TS_CARR_ON) == 0))
goto win;
selrecord(p, &tp->t_rsel);
break;
case FWRITE:
if (tp->t_outq.c_cc <= tp->t_lowat)
goto win;
selrecord(p, &tp->t_wsel);
break;
}
splx(s);
return (0);
win:
splx(s);
return (1);
} /* 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)
{
unsigned maxwait = delaycount * 5; /* 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",
delaycount * 5);
*(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 > PORTS_PER_CYCLOM) {
printf("bad unit number %d\n", unit);
return;
}
cy_tty[unit]->t_param = active ? cyparam : cyparam_dummy;
}
/* 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 */
Reference in New Issue View Git Blame Copy Permalink