OpenSolaris_b135/uts/sun/io/zs_async.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Asynchronous protocol handler for Z8530 chips
* Handles normal UNIX support for terminals & modems
*/
#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/sysmacros.h>
#include <sys/signal.h>
#include <sys/kmem.h>
#include <sys/termios.h>
#include <sys/stropts.h>
#include <sys/stream.h>
#include <sys/strsun.h>
#include <sys/tty.h>
#include <sys/ptyvar.h>
#include <sys/cred.h>
#include <sys/user.h>
#include <sys/proc.h>
#include <sys/file.h>
#include <sys/uio.h>
#include <sys/buf.h>
#include <sys/mkdev.h>
#include <sys/cmn_err.h>
#include <sys/strtty.h>
#include <sys/consdev.h>
#include <sys/zsdev.h>
#include <sys/ser_async.h>
#include <sys/debug.h>
#include <sys/kbio.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/promif.h>
#include <sys/policy.h>
/*
* PPS (Pulse Per Second) support.
*/
extern void ddi_hardpps(struct timeval *, int);
static struct ppsclockev ppsclockev;
#ifdef PPSCLOCKLED
/* XXX Use these to observe PPS latencies and jitter on a scope */
#define LED_ON
#define LED_OFF
#else
#define LED_ON
#define LED_OFF
#endif
#define ZSA_RCV_SIZE 64
#define ZA_KICK_RCV_COUNT 3
#define ZSA_GRACE_MIN_FLOW_CONTROL 5
#define ZSA_GRACE_MAX_FLOW_CONTROL 20
int zsasoftdtr = 0; /* if nonzero, softcarrier raises dtr at attach */
int zsb134_weird = 0; /* if set, old weird B134 behavior */
int g_zsticks = 0; /* if set, becomes the global zsticks value */
int g_nocluster = 0; /* if set, disables clustering of received data */
unsigned int zsa_rstandby = ZSA_MIN_RSTANDBY;
unsigned int zsa_rdone = ZSA_RDONE_MIN;
unsigned int zsa_grace_flow_control = ZSA_GRACE_MIN_FLOW_CONTROL;
#define NSPEED 18 /* max # of speeds */
ushort_t zs_speeds[NSPEED] = {
0,
ZSPEED(50), /* 1 */
ZSPEED(75), /* 2 */
ZSPEED(110), /* 3 */
#ifdef lint
ZSPEED(134), /* 4 */
#else
ZSPEED(269/2), /* XXX - This is sleazy */
#endif
ZSPEED(150), /* 5 */
ZSPEED(200), /* 6 */
ZSPEED(300), /* 7 */
ZSPEED(600), /* 8 */
ZSPEED(1200), /* 9 */
ZSPEED(1800), /* 10 */
ZSPEED(2400), /* 11 */
ZSPEED(4800), /* 12 */
ZSPEED(9600), /* 13 */
ZSPEED(19200), /* 14 */
ZSPEED(38400), /* 15 */
ZSPEED(57680), /* 16 */
ZSPEED(76800) /* 17 */
};
ushort_t zsticks[NSPEED] = {
3, /* 0 */
3, /* 1 */
3, /* 2 */
3, /* 3 */
3, /* 4 */
3, /* 5 */
3, /* 6 */
3, /* 7 */
3, /* 8 */
3, /* 9 */
3, /* 10 */
3, /* 11 */
3, /* 12 */
3, /* 13 */
2, /* 14 */
1, /* 15 */
1, /* 16 */
1 /* 17 */
};
#define ztdelay(nsp) (zsdelay[(nsp)]*(hz/100))
ushort_t zsdelay[NSPEED] = {
0,
ZDELAY(50), /* 1 */
ZDELAY(75), /* 2 */
ZDELAY(110), /* 3 */
#ifdef lint
ZDELAY(134), /* 4 */
#else
ZDELAY(269/2),
#endif
ZDELAY(150), /* 5 */
ZDELAY(200), /* 6 */
ZDELAY(300), /* 7 */
ZDELAY(600), /* 8 */
ZDELAY(1200), /* 9 */
ZDELAY(1800), /* 10 */
ZDELAY(2400), /* 11 */
ZDELAY(4800), /* 12 */
ZDELAY(9600), /* 13 */
ZDELAY(19200), /* 14 */
ZDELAY(38400), /* 15 */
ZDELAY(57600), /* 16 */
ZDELAY(76800) /* 17 */
};
ushort_t zslowat[NSPEED] = {
3, /* 0 */
3, /* 1 */
3, /* 2 */
3, /* 3 */
3, /* 4 */
3, /* 5 */
3, /* 6 */
2, /* 7 */
2, /* 8 */
2, /* 9 */
2, /* 10 */
1, /* 11 */
1, /* 12 */
1, /* 13 */
1, /* 14 */
1, /* 15 */
1, /* 16 */
1 /* 17 */
};
ushort_t zshiwat[NSPEED] = {
0, /* 0 */
1, /* 1 */
1, /* 2 */
1, /* 3 */
1, /* 4 */
1, /* 5 */
1, /* 6 */
1, /* 7 */
1, /* 8 */
1, /* 9 */
1, /* 10 */
1, /* 11 */
1, /* 12 */
3, /* 13 */
3, /* 14 */
4, /* 15 */
4, /* 16 */
4 /* 17 */
};
#define SLAVIO_BUG /* this workaround required to fix bug 1102778 */
#define SPEED(cflag) \
((cflag) & CBAUDEXT) ? \
(((cflag) & 0x1) + CBAUD + 1) : ((cflag) & CBAUD)
/*
* Special macros to handle STREAMS operations.
* These are required to address memory leakage problems.
* WARNING : the macro do NOT call ZSSETSOFT
*/
/*
* Should be called holding only the adaptive (zs_excl) mutex.
*/
#define ZSA_GETBLOCK(zs, allocbcount) \
{ \
register int n = zsa_rstandby; \
while (--n >= 0 && allocbcount > 0) { \
if (!za->za_rstandby[n]) { \
if ((za->za_rstandby[n] = allocb(ZSA_RCV_SIZE, \
BPRI_MED)) == NULL) { \
if (za->za_bufcid == 0) { \
za->za_bufcid = bufcall(ZSA_RCV_SIZE, \
BPRI_MED, \
zsa_callback, zs); \
break; \
} \
} \
allocbcount--; \
} \
} \
if (za->za_ttycommon.t_cflag & CRTSXOFF) { \
mutex_enter(zs->zs_excl_hi); \
if (!(zs->zs_wreg[5] & ZSWR5_RTS)) { \
register int usedcnt = 0; \
for (n = 0; n < zsa_rstandby; n++) \
if (!za->za_rstandby[n]) \
usedcnt++; \
if ((ushort_t)usedcnt <= \
zslowat[SPEED(za->za_ttycommon.t_cflag)]) \
SCC_BIS(5, ZSWR5_RTS); \
} \
mutex_exit(zs->zs_excl_hi); \
} \
}
/*
* Should be called holding the spin (zs_excl_hi) mutex.
*/
#define ZSA_ALLOCB(mp) \
{ \
register int n = zsa_rstandby; \
while (--n >= 0) { \
if ((mp = za->za_rstandby[n]) != NULL) { \
za->za_rstandby[n] = NULL; \
break; \
} \
} \
if (za->za_ttycommon.t_cflag & CRTSXOFF) { \
if (!mp) { \
if (zs->zs_wreg[5] & ZSWR5_RTS) \
SCC_BIC(5, ZSWR5_RTS); \
cmn_err(CE_WARN, "zs%d: message lost\n", \
UNIT(za->za_dev)); \
} else if (zs->zs_wreg[5] & ZSWR5_RTS) { \
register int usedcnt = 0; \
for (n = 0; n < zsa_rstandby; n++) \
if (!za->za_rstandby[n]) \
usedcnt++; \
if ((ushort_t)usedcnt >= (zsa_rstandby - \
zshiwat[SPEED(za->za_ttycommon.t_cflag)])) \
SCC_BIC(5, ZSWR5_RTS); \
} \
} \
}
/*
* Should get the spin (zs_excl_hi) mutex.
*/
#define ZSA_QREPLY(q, mp) \
{ \
mutex_enter(zs->zs_excl_hi); \
ZSA_PUTQ(mp); \
ZSSETSOFT(zs); \
mutex_exit(zs->zs_excl_hi); \
}
/*
* Should be called holding the spin (zs_excl_hi) mutex.
*/
#define ZSA_PUTQ(mp) \
{ \
register int wptr, rptr; \
wptr = za->za_rdone_wptr; \
rptr = za->za_rdone_rptr; \
za->za_rdone[wptr] = mp; \
if ((wptr)+1 == zsa_rdone) { \
za->za_rdone_wptr = wptr = 0; \
} else \
za->za_rdone_wptr = ++wptr; \
if (wptr == rptr) { \
SCC_BIC(1, ZSWR1_INIT); \
cmn_err(CE_WARN, "zs%d disabled: input buffer overflow", \
UNIT(za->za_dev)); \
} \
}
/*
* Should be called holding the spin (zs_excl_hi) mutex.
*/
#define ZSA_KICK_RCV \
{ \
register mblk_t *mp = za->za_rcvblk; \
if (mp) { \
if (zs->zs_rd_cur) { /* M_DATA */ \
mp->b_wptr = zs->zs_rd_cur; \
zs->zs_rd_cur = NULL; \
zs->zs_rd_lim = NULL; \
} \
za->za_rcvblk = NULL; \
ZSA_PUTQ(mp); \
ZSSETSOFT(zs); \
} \
}
#define ZSA_SEEQ(mp) \
{ \
if (za->za_rdone_rptr != za->za_rdone_wptr) { \
mp = za->za_rdone[za->za_rdone_rptr]; \
} else { \
mp = NULL; \
} \
}
/*
* Should be called holding only the adaptive (zs_excl) mutex.
*/
#define ZSA_GETQ(mp) \
{ \
if (za->za_rdone_rptr != za->za_rdone_wptr) { \
mp = za->za_rdone[za->za_rdone_rptr]; \
za->za_rdone[za->za_rdone_rptr++] = NULL; \
if (za->za_rdone_rptr == zsa_rdone) \
za->za_rdone_rptr = 0; \
} else { \
mp = NULL; \
} \
}
/*
* Should be called holding only the adaptive (zs_excl) mutex.
*/
#define ZSA_FLUSHQ \
{ \
register mblk_t *tmp; \
for (;;) { \
ZSA_GETQ(tmp); \
if (!(tmp)) \
break; \
freemsg(tmp); \
} \
}
/*
* Logging definitions
*/
#ifdef ZSA_DEBUG
#ifdef ZS_DEBUG_ALL
extern char zs_h_log[];
extern int zs_h_log_n;
#define zsa_h_log_clear
#define zsa_h_log_add(c) \
{ \
if (zs_h_log_n >= ZS_H_LOG_MAX) \
zs_h_log_n = 0; \
zs_h_log[zs_h_log_n++] = 'A' + zs->zs_unit; \
zs_h_log[zs_h_log_n++] = c; \
zs_h_log[zs_h_log_n] = '\0'; \
}
#else /* ZS_DEBUG_ALL */
#define ZSA_H_LOG_MAX 0x4000
char zsa_h_log[40][ZSA_H_LOG_MAX +10];
int zsa_h_log_n[40];
#define zsa_h_log_add(c) \
{ \
if (zsa_h_log_n[zs->zs_unit] >= ZSA_H_LOG_MAX) \
zsa_h_log_n[zs->zs_unit] = 0; \
zsa_h_log[zs->zs_unit][zsa_h_log_n[zs->zs_unit]++] = c; \
zsa_h_log[zs->zs_unit][zsa_h_log_n[zs->zs_unit]] = '\0'; \
}
#define zsa_h_log_clear \
{ \
register char *p; \
for (p = &zsa_h_log[zs->zs_unit][ZSA_H_LOG_MAX]; \
p >= &zsa_h_log[zs->zs_unit][0]; /* null */) \
*p-- = '\0'; \
zsa_h_log_n[zs->zs_unit] = 0; \
}
#endif /* ZS_DEBUG_ALL */
#define ZSA_R0_LOG(r0) \
{ \
if (r0 & ZSRR0_RX_READY) zsa_h_log_add('R'); \
if (r0 & ZSRR0_TIMER) zsa_h_log_add('Z'); \
if (r0 & ZSRR0_TX_READY) zsa_h_log_add('T'); \
if (r0 & ZSRR0_CD) zsa_h_log_add('D'); \
if (r0 & ZSRR0_SYNC) zsa_h_log_add('S'); \
if (r0 & ZSRR0_CTS) zsa_h_log_add('C'); \
if (r0 & ZSRR0_TXUNDER) zsa_h_log_add('U'); \
if (r0 & ZSRR0_BREAK) zsa_h_log_add('B'); \
}
#else /* ZSA_DEBUG */
#define zsa_h_log_clear
#define zsa_h_log_add(c)
#define ZSA_R0_LOG(r0)
#endif /* ZSA_DEBUG */
static int zsa_open(queue_t *rq, dev_t *dev, int flag, int sflag, cred_t *cr);
static int zsa_close(queue_t *q, int flag);
static void zsa_wput(queue_t *q, mblk_t *mp);
static void zsa_rsrv(queue_t *q);
static struct module_info asyncm_info = {
0,
"zs",
0,
INFPSZ,
2048,
128
};
static struct qinit async_rinit = {
putq,
(int (*)())zsa_rsrv,
zsa_open,
zsa_close,
NULL,
&asyncm_info,
NULL
};
static struct qinit async_winit = {
(int (*)())zsa_wput,
NULL,
NULL,
NULL,
NULL,
&asyncm_info,
NULL
};
struct streamtab asynctab = {
&async_rinit,
&async_winit,
NULL,
NULL,
};
/*
* The async interrupt entry points.
*/
static void zsa_txint(struct zscom *zs);
static void zsa_xsint(struct zscom *zs);
static void zsa_rxint(struct zscom *zs);
static void zsa_srint(struct zscom *zs);
static int zsa_softint(struct zscom *zs);
static int zsa_suspend(struct zscom *zs);
static int zsa_resume(struct zscom *zs);
static void
zsa_null(struct zscom *zs)
{
/* LINTED */
register short c;
SCC_WRITE0(ZSWR0_RESET_TXINT);
SCC_WRITE0(ZSWR0_RESET_STATUS);
c = SCC_READDATA();
ZSDELAY();
SCC_WRITE0(ZSWR0_RESET_ERRORS);
}
/*ARGSUSED*/
static int
zsa_null_int(struct zscom *zs)
{
return (0);
}
struct zsops zsops_null_async = {
zsa_null,
zsa_null,
zsa_null,
zsa_null,
zsa_null_int,
zsa_null_int,
zsa_null_int
};
struct zsops zsops_async = {
zsa_txint,
zsa_xsint,
zsa_rxint,
zsa_srint,
zsa_softint,
zsa_suspend,
zsa_resume
};
static int dmtozs(int bits);
static int zstodm(int bits);
static void zsa_restart(void *);
static void zsa_reioctl(void *);
static void zsa_ioctl(struct asyncline *za, queue_t *q, mblk_t *mp);
static void zsa_program(struct asyncline *za, int setibaud);
static void zsa_start(struct zscom *zs);
static void zsa_kick_rcv(void *);
static void zsa_callback(void *);
static void zsa_set_za_rcv_flags_mask(struct asyncline *za);
int zsgetspeed(dev_t dev);
static boolean_t abort_charseq_recognize(uchar_t ch);
/* ARGSUSED */
int
zsc_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
void **result)
{
register dev_t dev = (dev_t)arg;
register int unit, error;
register struct zscom *zs;
if ((unit = UNIT(dev)) >= nzs)
return (DDI_FAILURE);
switch (infocmd) {
case DDI_INFO_DEVT2DEVINFO:
zs = &zscom[unit];
*result = zs->zs_dip;
error = DDI_SUCCESS;
break;
case DDI_INFO_DEVT2INSTANCE:
*result = (void *)(uintptr_t)(unit / 2);
error = DDI_SUCCESS;
break;
default:
error = DDI_FAILURE;
}
return (error);
}
/*
* The Asynchronous Driver.
*/
/*
* Determine if the zsminor device is in use as either a stdin or stdout
* device, so we can be careful about how we initialize the DUART, if
* it is, in fact, in use.
*
* Since this is expensive, we do it once and store away the answers,
* since this gets called a number of times per phyical zs device.
* Perhaps, this should be in a loadable module, so it can get thrown
* away after all the zs devices are attached?
*/
/*
* To determine if a given unit is being used by the PROM,
* we need to map stdin/stdout devices as known to the PROM
* to zs internal minor device numbers:
*
* PROM (real device) zs minor device
*
* "zs", 0, "a" 0 ttya
* "zs", 0, "b" 1 ttyb
* "zs", 1, "a" 2 keyboard
* "zs", 1, "b" 3 mouse
* "zs", 2, "a" 4 ttyc
* "zs", 2, "b" 5 ttyd
*
* The following value mapping lines assume that insource
* and outsink map as "screen, a, b, c, d, ...", and that
* zs minors are "a, b, kbd, mouse, c, d, ...".
*/
static int zsa_inuse; /* Strictly for debugging */
int
zsa_channel_is_active_in_rom(dev_info_t *dev, int zsminor)
{
char pathname[OBP_MAXPATHLEN];
char default_pathname[OBP_MAXPATHLEN];
char *stdioname;
char minordata[3];
/*
* Basically, get my name and compare it to stdio devnames
* and if we get a match, then the device is in use as either
* stdin or stdout device (console tip line or keyboard device).
*
* We get two forms of the pathname, one complete with the
* the channel number, and if the channel is 'a', then
* we also deal with the user's ability to default to
* channel 'a', by omitting the channel number option.
* We then compare these pathnames to both the stdin and
* stdout pathnames. If any of these match, then the channel
* is in use.
*/
(void) ddi_pathname(dev, pathname); /* device pathname */
default_pathname[0] = (char)0; /* default pathname if channel 'a' */
if ((zsminor & 1) == 0)
(void) strcpy(default_pathname, pathname);
minordata[0] = ':';
minordata[1] = (char)('a' + (zsminor & 1));
minordata[2] = (char)0;
(void) strcat(pathname, minordata);
stdioname = prom_stdinpath();
if (strcmp(pathname, stdioname) == 0) {
zsa_inuse |= (1 << zsminor);
return (1);
}
if (strcmp(default_pathname, stdioname) == 0) {
zsa_inuse |= (1 << zsminor);
return (1);
}
stdioname = prom_stdoutpath();
if (strcmp(pathname, stdioname) == 0) {
zsa_inuse |= (1 << zsminor);
return (1);
}
if (strcmp(default_pathname, stdioname) == 0) {
zsa_inuse |= (1 << zsminor);
return (1);
}
return (0);
}
/*
* Initialize zs
*/
void
zsa_init(struct zscom *zs)
{
/*
* This routine is called near the end of the zs module's attach
* process. It initializes the TTY protocol-private data for this
* channel that needs to be in place before interrupts are enabled.
*/
mutex_enter(zs->zs_excl);
mutex_enter(zs->zs_excl_hi);
/*
* Raise modem control lines on serial ports associated
* with the console and (optionally) softcarrier lines.
* Drop modem control lines on all others so that modems
* will not answer and portselectors will skip these
* lines until they are opened by a getty.
*/
if (zsa_channel_is_active_in_rom(zs->zs_dip, zs->zs_unit))
(void) zsmctl(zs, ZS_ON, DMSET); /* raise dtr */
else if (zsasoftdtr && (zssoftCAR[zs->zs_unit]))
(void) zsmctl(zs, ZS_ON, DMSET); /* raise dtr */
else
(void) zsmctl(zs, ZS_OFF, DMSET); /* drop dtr */
if (zsa_rstandby > ZSA_MAX_RSTANDBY)
zsa_rstandby = ZSA_MAX_RSTANDBY;
if (zsa_rdone > ZSA_RDONE_MAX)
zsa_rdone = ZSA_RDONE_MAX;
if (zsa_grace_flow_control > ZSA_GRACE_MAX_FLOW_CONTROL)
zsa_grace_flow_control = ZSA_GRACE_MAX_FLOW_CONTROL;
mutex_exit(zs->zs_excl_hi);
mutex_exit(zs->zs_excl);
}
/*
* Open routine.
*/
/*ARGSUSED*/
static int
zsa_open(queue_t *rq, dev_t *dev, int flag, int sflag, cred_t *cr)
{
register struct zscom *zs;
register struct asyncline *za;
register int speed, unit;
struct termios *termiosp;
int len;
register int allocbcount = zsa_rstandby;
boolean_t set_zsoptinit = B_FALSE;
unit = UNIT(*dev);
if (unit >= nzs)
return (ENXIO); /* unit not configured */
/* zscom is allocated by zsattach, and thus cannot be NULL here */
zs = &zscom[unit];
if (zs->zs_ops == NULL) {
return (ENXIO); /* device not found by autoconfig */
}
mutex_enter(zs->zs_ocexcl);
mutex_enter(zs->zs_excl);
again:
if ((zs->zs_ops != &zsops_null) &&
(zs->zs_ops != &zsops_async)) {
mutex_exit(zs->zs_excl);
mutex_exit(zs->zs_ocexcl);
return (EBUSY); /* another protocol got here first */
}
za = (struct asyncline *)&zs->zs_priv_str;
if (zs->zs_suspended) {
mutex_exit(zs->zs_excl);
mutex_exit(zs->zs_ocexcl);
(void) ddi_dev_is_needed(zs->zs_dip, 0, 1);
mutex_enter(zs->zs_ocexcl);
mutex_enter(zs->zs_excl);
}
/* Mark device as busy (for power management) */
(void) pm_busy_component(zs->zs_dip, unit%2+1);
if (zs->zs_ops == &zsops_null) {
bzero(za, sizeof (zs->zs_priv_str));
za->za_common = zs;
if (zssoftCAR[zs->zs_unit])
za->za_ttycommon.t_flags |= TS_SOFTCAR;
zsopinit(zs, &zsops_async);
set_zsoptinit = B_TRUE;
za->za_rdone_wptr = 0;
za->za_rdone_rptr = 0;
}
zs->zs_priv = (caddr_t)za;
/*
* Block waiting for carrier to come up,
* unless this is a no-delay open.
*/
mutex_enter(zs->zs_excl_hi);
if (!(za->za_flags & ZAS_ISOPEN)) {
/*
* Get the default termios settings (cflag).
* These are stored as a property in the
* "options" node.
*/
mutex_exit(zs->zs_excl_hi);
if (ddi_getlongprop(DDI_DEV_T_ANY,
ddi_root_node(), 0, "ttymodes",
(caddr_t)&termiosp, &len) == DDI_PROP_SUCCESS &&
len == sizeof (struct termios)) {
za->za_ttycommon.t_cflag = termiosp->c_cflag;
kmem_free(termiosp, len);
} else {
/*
* Gack! Whine about it.
*/
cmn_err(CE_WARN,
"zs: Couldn't get ttymodes property!");
}
mutex_enter(zs->zs_excl_hi);
if ((*dev == rconsdev) || (*dev == kbddev) ||
(*dev == stdindev)) {
speed = zsgetspeed(*dev);
za->za_ttycommon.t_cflag &= ~(CBAUD);
if (speed > CBAUD) {
za->za_ttycommon.t_cflag |= CBAUDEXT;
za->za_ttycommon.t_cflag |=
((speed - CBAUD - 1) & CBAUD);
} else {
za->za_ttycommon.t_cflag &= ~CBAUDEXT;
za->za_ttycommon.t_cflag |= (speed & CBAUD);
}
}
za->za_overrun = 0;
za->za_ttycommon.t_iflag = 0;
za->za_ttycommon.t_iocpending = NULL;
za->za_ttycommon.t_size.ws_row = 0;
za->za_ttycommon.t_size.ws_col = 0;
za->za_ttycommon.t_size.ws_xpixel = 0;
za->za_ttycommon.t_size.ws_ypixel = 0;
za->za_dev = *dev;
za->za_wbufcid = 0;
zsa_program(za, za->za_ttycommon.t_cflag & (CIBAUDEXT|CIBAUD));
zsa_set_za_rcv_flags_mask(za);
} else if ((za->za_ttycommon.t_flags & TS_XCLUDE) &&
secpolicy_excl_open(cr) != 0) {
mutex_exit(zs->zs_excl_hi);
if (set_zsoptinit && !(za->za_flags & ISOPEN))
zsopinit(zs, &zsops_null);
mutex_exit(zs->zs_excl);
mutex_exit(zs->zs_ocexcl);
return (EBUSY);
} else if ((*dev & OUTLINE) && !(za->za_flags & ZAS_OUT)) {
mutex_exit(zs->zs_excl_hi);
if (set_zsoptinit && !(za->za_flags & ISOPEN))
zsopinit(zs, &zsops_null);
mutex_exit(zs->zs_excl);
mutex_exit(zs->zs_ocexcl);
return (EBUSY);
}
if (*dev & OUTLINE)
za->za_flags |= ZAS_OUT;
(void) zsmctl(zs, ZS_ON, DMSET);
/*
* Check carrier.
*/
if ((za->za_ttycommon.t_flags & TS_SOFTCAR) ||
(zsmctl(zs, 0, DMGET) & ZSRR0_CD))
za->za_flags |= ZAS_CARR_ON;
mutex_exit(zs->zs_excl_hi);
/*
* If FNDELAY and FNONBLOCK are clear, block until carrier up.
* Quit on interrupt.
*/
if (!(flag & (FNDELAY|FNONBLOCK)) &&
!(za->za_ttycommon.t_cflag & CLOCAL)) {
if (!(za->za_flags & (ZAS_CARR_ON|ZAS_OUT)) ||
((za->za_flags & ZAS_OUT) && !(*dev & OUTLINE))) {
za->za_flags |= ZAS_WOPEN;
mutex_exit(zs->zs_excl);
if (cv_wait_sig(&zs->zs_flags_cv, zs->zs_ocexcl) == 0) {
mutex_enter(zs->zs_excl);
if (zs->zs_suspended) {
mutex_exit(zs->zs_excl);
mutex_exit(zs->zs_ocexcl);
(void) ddi_dev_is_needed(zs->zs_dip,
0, 1);
mutex_enter(zs->zs_ocexcl);
mutex_enter(zs->zs_excl);
}
za->za_flags &= ~ZAS_WOPEN;
if (set_zsoptinit && !(za->za_flags & ISOPEN))
zsopinit(zs, &zsops_null);
mutex_exit(zs->zs_excl);
mutex_exit(zs->zs_ocexcl);
return (EINTR);
}
mutex_enter(zs->zs_excl);
za->za_flags &= ~ZAS_WOPEN;
if ((zs->zs_ops == &zsops_null) ||
(zs->zs_ops == &zsops_async))
goto again;
else {
if (set_zsoptinit && !(za->za_flags & ISOPEN))
zsopinit(zs, &zsops_null);
mutex_exit(zs->zs_excl);
mutex_exit(zs->zs_ocexcl);
return (EBUSY);
}
}
} else if ((za->za_flags & ZAS_OUT) && !(*dev & OUTLINE)) {
if (set_zsoptinit && !(za->za_flags & ISOPEN))
zsopinit(zs, &zsops_null);
mutex_exit(zs->zs_excl);
mutex_exit(zs->zs_ocexcl);
return (EBUSY);
}
za->za_ttycommon.t_readq = rq;
za->za_ttycommon.t_writeq = WR(rq);
rq->q_ptr = WR(rq)->q_ptr = (caddr_t)za;
za->za_flags |= ZAS_ISOPEN;
ZSA_GETBLOCK(zs, allocbcount);
qprocson(rq);
mutex_exit(zs->zs_excl);
mutex_exit(zs->zs_ocexcl);
return (0);
}
static void
zs_progress_check(void *arg)
{
struct asyncline *za = arg;
struct zscom *zs = za->za_common;
mblk_t *bp;
/*
* We define "progress" as either waiting on a timed break or delay, or
* having had at least one transmitter interrupt. If none of these are
* true, then just terminate the output and wake up that close thread.
*/
mutex_enter(zs->zs_excl);
if (!(zs->zs_flags & ZS_PROGRESS) &&
!(za->za_flags & (ZAS_BREAK|ZAS_DELAY))) {
za->za_flags &= ~ZAS_BUSY;
mutex_enter(zs->zs_excl_hi);
za->za_rcv_flags_mask &= ~DO_RETRANSMIT;
zs->zs_wr_cur = NULL;
zs->zs_wr_lim = NULL;
bp = za->za_xmitblk;
za->za_xmitblk = NULL;
mutex_exit(zs->zs_excl_hi);
zs->zs_timer = 0;
mutex_exit(zs->zs_excl);
if (bp != NULL)
freeb(bp);
/*
* Since this timer is running, we know that we're in exit(2).
* That means that the user can't possibly be waiting on any
* valid ioctl(2) completion anymore, and we should just flush
* everything.
*/
flushq(za->za_ttycommon.t_writeq, FLUSHALL);
cv_broadcast(&zs->zs_flags_cv);
} else {
zs->zs_flags &= ~ZS_PROGRESS;
zs->zs_timer = timeout(zs_progress_check, za,
drv_usectohz(zs_drain_check));
mutex_exit(zs->zs_excl);
}
}
/*
* Close routine.
*
* Important locking note: the zs_ocexcl lock is not held at all in this
* routine. This is intentional. That lock is used to coordinate multiple
* simultaneous opens on a stream, and there's no such thing as multiple
* simultaneous closes on a stream.
*/
/*ARGSUSED*/
static int
zsa_close(queue_t *q, int flag)
{
struct asyncline *za;
struct zscom *zs;
int i;
mblk_t *bp;
timeout_id_t za_zsa_restart_id, za_kick_rcv_id;
bufcall_id_t za_bufcid, za_wbufcid;
int tmp;
za = q->q_ptr;
ASSERT(za != NULL);
zs = za->za_common;
mutex_enter(zs->zs_excl);
zs->zs_flags |= ZS_CLOSING;
/*
* There are two flavors of break -- timed (M_BREAK or TCSBRK) and
* untimed (TIOCSBRK). For the timed case, these are enqueued on our
* write queue and there's a timer running, so we don't have to worry
* about them. For the untimed case, though, the user obviously made a
* mistake, because these are handled immediately. We'll terminate the
* break now and honor his implicit request by discarding the rest of
* the data.
*/
if (!(za->za_flags & ZAS_BREAK) && (zs->zs_wreg[5] & ZSWR5_BREAK))
goto nodrain;
/*
* If the user told us not to delay the close ("non-blocking"), then
* don't bother trying to drain.
*
* If the user did M_STOP (ASYNC_STOPPED), there's no hope of ever
* getting an M_START (since these messages aren't enqueued), and the
* only other way to clear the stop condition is by loss of DCD, which
* would discard the queue data. Thus, we drop the output data if
* ASYNC_STOPPED is set.
*/
if ((flag & (FNDELAY|FNONBLOCK)) || (za->za_flags & ZAS_STOPPED))
goto nodrain;
/*
* If there's any pending output, then we have to try to drain it.
* There are two main cases to be handled:
* - called by close(2): need to drain until done or until
* a signal is received. No timeout.
* - called by exit(2): need to drain while making progress
* or until a timeout occurs. No signals.
*
* If we can't rely on receiving a signal to get us out of a hung
* session, then we have to use a timer. In this case, we set a timer
* to check for progress in sending the output data -- all that we ask
* (at each interval) is that there's been some progress made. Since
* the interrupt routine grabs buffers from the write queue, we can't
* trust changes in zs_wr_cur. Instead, we use a progress flag.
*
* Note that loss of carrier will cause the output queue to be flushed,
* and we'll wake up again and finish normally.
*/
if (!ddi_can_receive_sig() && zs_drain_check != 0) {
zs->zs_flags &= ~ZS_PROGRESS;
zs->zs_timer = timeout(zs_progress_check, za,
drv_usectohz(zs_drain_check));
}
while (zs->zs_wr_cur != NULL ||
za->za_ttycommon.t_writeq->q_first != NULL ||
(za->za_flags & (ZAS_BUSY|ZAS_DELAY|ZAS_BREAK))) {
if (cv_wait_sig(&zs->zs_flags_cv, zs->zs_excl) == 0)
break;
}
if (zs->zs_timer != 0) {
(void) untimeout(zs->zs_timer);
zs->zs_timer = 0;
}
nodrain:
/*
* If break is in progress, stop it.
*/
mutex_enter(zs->zs_excl_hi);
if (zs->zs_wreg[5] & ZSWR5_BREAK) {
SCC_BIC(5, ZSWR5_BREAK);
za->za_flags &= ~ZAS_BREAK;
}
za_wbufcid = za->za_wbufcid;
za_bufcid = za->za_bufcid;
za_zsa_restart_id = za->za_zsa_restart_id;
za_kick_rcv_id = za->za_kick_rcv_id;
za->za_wbufcid = za->za_bufcid = 0;
za->za_zsa_restart_id = za->za_kick_rcv_id = 0;
/*
* If line has HUPCL set or is incompletely opened,
* and it is not the console or the keyboard,
* fix up the modem lines.
*/
zsopinit(zs, &zsops_null_async);
/*
* Nobody, zsh or zs can now open this port until
* zsopinit(zs, &zsops_null);
*
*/
if ((za->za_dev != rconsdev) && (za->za_dev != kbddev) &&
(za->za_dev != stdindev) &&
(((za->za_flags & (ZAS_WOPEN|ZAS_ISOPEN)) != ZAS_ISOPEN) ||
(za->za_ttycommon.t_cflag & HUPCL))) {
/*
* If DTR is being held high by softcarrier,
* set up the ZS_ON set; if not, hang up.
*/
if (zsasoftdtr && (za->za_ttycommon.t_flags & TS_SOFTCAR))
(void) zsmctl(zs, ZS_ON, DMSET);
else
(void) zsmctl(zs, ZS_OFF, DMSET);
mutex_exit(zs->zs_excl_hi);
/*
* Don't let an interrupt in the middle of close
* bounce us back to the top; just continue
* closing as if nothing had happened.
*/
tmp = cv_reltimedwait_sig(&zs->zs_flags_cv, zs->zs_excl,
drv_usectohz(10000), TR_CLOCK_TICK);
if (zs->zs_suspended) {
mutex_exit(zs->zs_excl);
(void) ddi_dev_is_needed(zs->zs_dip, 0, 1);
mutex_enter(zs->zs_excl);
}
if (tmp == 0)
goto out;
mutex_enter(zs->zs_excl_hi);
}
/*
* If nobody's now using it, turn off receiver interrupts.
*/
if ((za->za_flags & (ZAS_ISOPEN|ZAS_WOPEN)) == 0)
SCC_BIC(1, ZSWR1_RIE);
mutex_exit(zs->zs_excl_hi);
out:
/*
* Clear out device state.
*/
ttycommon_close(&za->za_ttycommon);
za->za_ttycommon.t_readq = NULL;
za->za_ttycommon.t_writeq = NULL;
mutex_enter(zs->zs_excl_hi);
za->za_rcv_flags_mask &= ~DO_RETRANSMIT;
zs->zs_wr_cur = NULL;
zs->zs_wr_lim = NULL;
bp = za->za_xmitblk;
za->za_xmitblk = NULL;
mutex_exit(zs->zs_excl_hi);
if (bp)
freemsg(bp);
mutex_enter(zs->zs_excl_hi);
zs->zs_rd_cur = NULL;
zs->zs_rd_lim = NULL;
bp = za->za_rcvblk;
za->za_rcvblk = NULL;
mutex_exit(zs->zs_excl_hi);
if (bp)
freemsg(bp);
for (i = 0; i < zsa_rstandby; i++) {
mutex_enter(zs->zs_excl_hi);
bp = za->za_rstandby[i];
za->za_rstandby[i] = NULL;
mutex_exit(zs->zs_excl_hi);
if (bp)
freemsg(bp);
}
if (za->za_soft_active || za->za_kick_active) {
zs->zs_flags |= ZS_CLOSED;
while (za->za_soft_active || za->za_kick_active)
cv_wait(&zs->zs_flags_cv, zs->zs_excl);
}
if (zs->zs_suspended) {
mutex_exit(zs->zs_excl);
(void) ddi_dev_is_needed(zs->zs_dip, 0, 1);
mutex_enter(zs->zs_excl);
}
ZSA_FLUSHQ;
bzero(za, sizeof (struct asyncline));
qprocsoff(q);
mutex_exit(zs->zs_excl);
/*
* Cancel outstanding "bufcall" request.
*/
if (za_wbufcid)
unbufcall(za_wbufcid);
if (za_bufcid)
unbufcall(za_bufcid);
/*
* Cancel outstanding timeout.
*/
if (za_zsa_restart_id)
(void) untimeout(za_zsa_restart_id);
if (za_kick_rcv_id)
(void) untimeout(za_kick_rcv_id);
q->q_ptr = WR(q)->q_ptr = NULL;
zsopinit(zs, &zsops_null);
cv_broadcast(&zs->zs_flags_cv);
/* Mark device as available for power management */
(void) pm_idle_component(zs->zs_dip, zs->zs_unit%2+1);
return (0);
}
/*
* Put procedure for write queue.
* Respond to M_STOP, M_START, M_IOCTL, and M_FLUSH messages here;
* set the flow control character for M_STOPI and M_STARTI messages;
* queue up M_BREAK, M_DELAY, and M_DATA messages for processing
* by the start routine, and then call the start routine; discard
* everything else. Note that this driver does not incorporate any
* mechanism to negotiate to handle the canonicalization process.
* It expects that these functions are handled in upper module(s),
* as we do in ldterm.
*/
static void
zsa_wput(queue_t *q, mblk_t *mp)
{
register struct asyncline *za;
register struct zscom *zs;
register struct copyresp *resp;
register mblk_t *bp = NULL;
int error;
struct iocblk *iocp;
za = (struct asyncline *)q->q_ptr;
zs = za->za_common;
if (zs->zs_flags & ZS_NEEDSOFT) {
zs->zs_flags &= ~ZS_NEEDSOFT;
(void) zsa_softint(zs);
}
switch (mp->b_datap->db_type) {
case M_STOP:
/*
* Since we don't do real DMA, we can just let the
* chip coast to a stop after applying the brakes.
*/
mutex_enter(zs->zs_excl);
mutex_enter(zs->zs_excl_hi);
za->za_flags |= ZAS_STOPPED;
if ((zs->zs_wr_cur) != NULL) {
za->za_flags &= ~ZAS_BUSY;
za->za_rcv_flags_mask &= ~DO_RETRANSMIT;
bp = za->za_xmitblk;
bp->b_rptr = zs->zs_wr_cur;
zs->zs_wr_cur = NULL;
zs->zs_wr_lim = NULL;
za->za_xmitblk = NULL;
}
mutex_exit(zs->zs_excl_hi);
if (bp)
(void) putbq(q, bp);
freemsg(mp);
mutex_exit(zs->zs_excl);
break;
case M_START:
mutex_enter(zs->zs_excl);
if (za->za_flags & ZAS_STOPPED) {
za->za_flags &= ~ZAS_STOPPED;
/*
* If an output operation is in progress,
* resume it. Otherwise, prod the start
* routine.
*/
zsa_start(zs);
}
freemsg(mp);
mutex_exit(zs->zs_excl);
break;
case M_IOCTL:
mutex_enter(zs->zs_excl);
iocp = (struct iocblk *)mp->b_rptr;
switch (iocp->ioc_cmd) {
case TIOCGPPS:
/*
* Get PPS state.
*/
if (mp->b_cont != NULL)
freemsg(mp->b_cont);
mp->b_cont = allocb(sizeof (int), BPRI_HI);
if (mp->b_cont == NULL) {
mp->b_datap->db_type = M_IOCNAK;
iocp->ioc_error = ENOMEM;
ZSA_QREPLY(q, mp);
break;
}
if (za->za_pps)
*(int *)mp->b_cont->b_wptr = 1;
else
*(int *)mp->b_cont->b_wptr = 0;
mp->b_cont->b_wptr += sizeof (int);
mp->b_datap->db_type = M_IOCACK;
iocp->ioc_count = sizeof (int);
ZSA_QREPLY(q, mp);
break;
case TIOCSPPS:
/*
* Set PPS state.
*/
error = miocpullup(mp, sizeof (int));
if (error != 0) {
mp->b_datap->db_type = M_IOCNAK;
iocp->ioc_error = error;
ZSA_QREPLY(q, mp);
break;
}
za->za_pps = (*(int *)mp->b_cont->b_rptr != 0);
mp->b_datap->db_type = M_IOCACK;
ZSA_QREPLY(q, mp);
break;
case TIOCGPPSEV:
{
/*
* Get PPS event data.
*/
void *buf;
#ifdef _SYSCALL32_IMPL
struct ppsclockev32 p32;
#endif
if (mp->b_cont != NULL) {
freemsg(mp->b_cont);
mp->b_cont = NULL;
}
if (za->za_pps == NULL) {
mp->b_datap->db_type = M_IOCNAK;
iocp->ioc_error = ENXIO;
ZSA_QREPLY(q, mp);
break;
}
#ifdef _SYSCALL32_IMPL
if ((iocp->ioc_flag & IOC_MODELS) != IOC_NATIVE) {
TIMEVAL_TO_TIMEVAL32(&p32.tv, &ppsclockev.tv);
p32.serial = ppsclockev.serial;
buf = &p32;
iocp->ioc_count = sizeof (struct ppsclockev32);
} else
#endif
{
buf = &ppsclockev;
iocp->ioc_count = sizeof (struct ppsclockev);
}
if ((bp = allocb(iocp->ioc_count, BPRI_HI)) == NULL) {
mp->b_datap->db_type = M_IOCNAK;
iocp->ioc_error = ENOMEM;
ZSA_QREPLY(q, mp);
break;
}
mp->b_cont = bp;
bcopy(buf, bp->b_wptr, iocp->ioc_count);
bp->b_wptr += iocp->ioc_count;
mp->b_datap->db_type = M_IOCACK;
ZSA_QREPLY(q, mp);
break;
}
case TCSETSW:
case TCSETSF:
case TCSETAW:
case TCSETAF:
case TCSBRK:
/*
* The changes do not take effect until all
* output queued before them is drained.
* Put this message on the queue, so that
* "zsa_start" will see it when it's done
* with the output before it. Poke the
* start routine, just in case.
*/
(void) putq(q, mp);
zsa_start(zs);
break;
default:
/*
* Do it now.
*/
zsa_ioctl(za, q, mp);
break;
}
mutex_exit(zs->zs_excl);
break;
case M_IOCDATA:
mutex_enter(zs->zs_excl);
resp = (struct copyresp *)mp->b_rptr;
if (resp->cp_rval) {
/*
* Just free message on failure.
*/
freemsg(mp);
mutex_exit(zs->zs_excl);
break;
}
switch (resp->cp_cmd) {
case TIOCMSET:
mutex_enter(zs->zs_excl_hi);
(void) zsmctl(zs, dmtozs(*(int *)mp->b_cont->b_rptr),
DMSET);
mutex_exit(zs->zs_excl_hi);
mioc2ack(mp, NULL, 0, 0);
ZSA_QREPLY(q, mp);
break;
case TIOCMBIS:
mutex_enter(zs->zs_excl_hi);
(void) zsmctl(zs, dmtozs(*(int *)mp->b_cont->b_rptr),
DMBIS);
mutex_exit(zs->zs_excl_hi);
mioc2ack(mp, NULL, 0, 0);
ZSA_QREPLY(q, mp);
break;
case TIOCMBIC:
mutex_enter(zs->zs_excl_hi);
(void) zsmctl(zs, dmtozs(*(int *)mp->b_cont->b_rptr),
DMBIC);
mutex_exit(zs->zs_excl_hi);
mioc2ack(mp, NULL, 0, 0);
ZSA_QREPLY(q, mp);
break;
case TIOCMGET:
mioc2ack(mp, NULL, 0, 0);
ZSA_QREPLY(q, mp);
break;
default:
freemsg(mp);
}
mutex_exit(zs->zs_excl);
break;
case M_FLUSH:
mutex_enter(zs->zs_excl);
if (*mp->b_rptr & FLUSHW) {
/*
* Abort any output in progress.
*/
if (za->za_flags & ZAS_BUSY) {
za->za_flags &= ~ZAS_BUSY;
mutex_enter(zs->zs_excl_hi);
za->za_rcv_flags_mask &= ~DO_RETRANSMIT;
zs->zs_wr_cur = NULL;
zs->zs_wr_lim = NULL;
bp = za->za_xmitblk;
za->za_xmitblk = NULL;
mutex_exit(zs->zs_excl_hi);
if (bp)
freemsg(bp);
}
/*
* Flush our write queue.
*/
flushq(q, FLUSHDATA); /* XXX doesn't flush M_DELAY */
*mp->b_rptr &= ~FLUSHW; /* it has been flushed */
}
if (*mp->b_rptr & FLUSHR) {
/*
* Flush any data in the temporary receive buffer
*/
mutex_enter(zs->zs_excl_hi);
if ((za->za_ttycommon.t_flags & TS_SOFTCAR) ||
(SCC_READ0() & ZSRR0_CD)) {
ZSA_KICK_RCV;
} else {
ZSA_KICK_RCV;
if (!(SCC_READ0() & ZSRR0_RX_READY)) {
/*
* settle time for 1 character shift
*/
mutex_exit(zs->zs_excl_hi);
mutex_exit(zs->zs_excl);
delay(ztdelay(SPEED(
za->za_ttycommon.t_cflag))/3 + 1);
mutex_enter(zs->zs_excl);
mutex_enter(zs->zs_excl_hi);
if (!(SCC_READ0() & ZSRR0_CD))
ZSA_KICK_RCV;
}
while ((SCC_READ0() &
(ZSRR0_CD | ZSRR0_RX_READY)) ==
ZSRR0_RX_READY) {
/*
* Empty Receiver
*/
(void) SCC_READDATA();
}
}
mutex_exit(zs->zs_excl_hi);
flushq(RD(q), FLUSHDATA);
ZSA_QREPLY(q, mp);
/*
* give the read queues a crack at it
*/
} else
freemsg(mp);
/*
* We must make sure we process messages that survive the
* write-side flush. Without this call, the close protocol
* with ldterm can hang forever. (ldterm will have sent us a
* TCSBRK ioctl that it expects a response to.)
*/
zsa_start(zs);
mutex_exit(zs->zs_excl);
break;
case M_BREAK:
case M_DELAY:
case M_DATA:
mutex_enter(zs->zs_excl);
/*
* Queue the message up to be transmitted,
* and poke the start routine.
*/
(void) putq(q, mp);
zsa_start(zs);
mutex_exit(zs->zs_excl);
break;
case M_STOPI:
mutex_enter(zs->zs_excl);
mutex_enter(zs->zs_excl_hi);
za->za_flowc = za->za_ttycommon.t_stopc;
if ((zs->zs_wr_cur) != NULL) {
za->za_rcv_flags_mask &= ~DO_RETRANSMIT;
bp = za->za_xmitblk;
bp->b_rptr = zs->zs_wr_cur;
zs->zs_wr_cur = NULL;
zs->zs_wr_lim = NULL;
za->za_xmitblk = NULL;
}
mutex_exit(zs->zs_excl_hi);
if (bp)
(void) putbq(q, bp);
else
zsa_start(zs); /* poke the start routine */
freemsg(mp);
mutex_exit(zs->zs_excl);
break;
case M_STARTI:
mutex_enter(zs->zs_excl);
mutex_enter(zs->zs_excl_hi);
za->za_flowc = za->za_ttycommon.t_startc;
if ((zs->zs_wr_cur) != NULL) {
za->za_rcv_flags_mask &= ~DO_RETRANSMIT;
bp = za->za_xmitblk;
bp->b_rptr = zs->zs_wr_cur;
zs->zs_wr_cur = NULL;
zs->zs_wr_lim = NULL;
za->za_xmitblk = NULL;
}
mutex_exit(zs->zs_excl_hi);
if (bp)
(void) putbq(q, bp);
else
zsa_start(zs); /* poke the start routine */
freemsg(mp);
mutex_exit(zs->zs_excl);
break;
case M_CTL:
if (MBLKL(mp) >= sizeof (struct iocblk) &&
((struct iocblk *)mp->b_rptr)->ioc_cmd == MC_POSIXQUERY) {
((struct iocblk *)mp->b_rptr)->ioc_cmd = MC_HAS_POSIX;
qreply(q, mp);
} else {
/*
* These MC_SERVICE type messages are used by upper
* modules to tell this driver to send input up
* immediately, or that it can wait for normal
* processing that may or may not be done. Sun
* requires these for the mouse module.
*/
mutex_enter(zs->zs_excl);
switch (*mp->b_rptr) {
case MC_SERVICEIMM:
mutex_enter(zs->zs_excl_hi);
za->za_flags |= ZAS_SERVICEIMM;
mutex_exit(zs->zs_excl_hi);
break;
case MC_SERVICEDEF:
mutex_enter(zs->zs_excl_hi);
za->za_flags &= ~ZAS_SERVICEIMM;
mutex_exit(zs->zs_excl_hi);
break;
}
freemsg(mp);
mutex_exit(zs->zs_excl);
}
break;
default:
/*
* "No, I don't want a subscription to Chain Store Age,
* thank you anyway."
*/
freemsg(mp);
break;
}
}
/*
* zs read service procedure
*/
static void
zsa_rsrv(queue_t *q)
{
struct asyncline *za;
struct zscom *zs;
if (((za = (struct asyncline *)q->q_ptr) != NULL) &&
(za->za_ttycommon.t_cflag & CRTSXOFF)) {
zs = za->za_common;
mutex_enter(zs->zs_excl_hi);
ZSSETSOFT(zs);
mutex_exit(zs->zs_excl_hi);
}
}
/*
* Transmitter interrupt service routine.
* If there's more data to transmit in the current pseudo-DMA block,
* and the transmitter is ready, send the next character if output
* is not stopped or draining.
* Otherwise, queue up a soft interrupt.
*/
static void
zsa_txint(struct zscom *zs)
{
register struct asyncline *za = (struct asyncline *)&zs->zs_priv_str;
register uchar_t *wr_cur;
register uchar_t s0;
s0 = SCC_READ0();
if ((wr_cur = zs->zs_wr_cur) != NULL) {
if (wr_cur < zs->zs_wr_lim) {
if ((za->za_ttycommon.t_cflag & CRTSCTS) &&
!(s0 & ZSRR0_CTS)) {
SCC_WRITE0(ZSWR0_RESET_TXINT);
za->za_rcv_flags_mask |= DO_RETRANSMIT;
return;
}
SCC_WRITEDATA(*wr_cur++);
#ifdef ZSA_DEBUG
za->za_wr++;
#endif
zs->zs_wr_cur = wr_cur;
zs->zs_flags |= ZS_PROGRESS;
return;
} else {
zs->zs_wr_cur = NULL;
zs->zs_wr_lim = NULL;
/*
* Use the rcv_flags_mask as it is set and
* test while holding the zs_excl_hi mutex
*/
za->za_rcv_flags_mask |= DO_TRANSMIT;
SCC_WRITE0(ZSWR0_RESET_TXINT);
ZSSETSOFT(zs);
return;
}
}
if (za->za_flowc != '\0' && (!(za->za_flags & ZAS_DRAINING))) {
if ((za->za_ttycommon.t_cflag & CRTSCTS) &&
!(s0 & ZSRR0_CTS)) {
SCC_WRITE0(ZSWR0_RESET_TXINT);
return;
}
SCC_WRITEDATA(za->za_flowc);
za->za_flowc = '\0';
return;
}
SCC_WRITE0(ZSWR0_RESET_TXINT);
/*
* Set DO_TRANSMIT bit so that the soft interrupt can
* test it and unset the ZAS_BUSY in za_flags while holding
* the mutex zs_excl and zs_excl_hi
*/
za->za_rcv_flags_mask |= DO_TRANSMIT;
ZSSETSOFT(zs);
}
/*
* External/Status interrupt.
*/
static void
zsa_xsint(struct zscom *zs)
{
register struct asyncline *za = (struct asyncline *)&zs->zs_priv_str;
register uchar_t s0, x0;
s0 = SCC_READ0();
ZSA_R0_LOG(s0);
x0 = s0 ^ za->za_rr0;
za->za_rr0 = s0;
SCC_WRITE0(ZSWR0_RESET_STATUS);
/*
* PPS (Pulse Per Second) support.
*/
if (za->za_pps && (x0 & ZSRR0_CD) && (s0 & ZSRR0_CD)) {
/*
* This code captures a timestamp at the designated
* transition of the PPS signal (CD asserted). The
* code provides a pointer to the timestamp, as well
* as the hardware counter value at the capture.
*
* Note: the kernel has nano based time values while
* NTP requires micro based, an in-line fast algorithm
* to convert nsec to usec is used here -- see hrt2ts()
* in common/os/timers.c for a full description.
*/
struct timeval *tvp = &ppsclockev.tv;
timespec_t ts;
int nsec, usec;
LED_OFF;
gethrestime(&ts);
LED_ON;
nsec = ts.tv_nsec;
usec = nsec + (nsec >> 2);
usec = nsec + (usec >> 1);
usec = nsec + (usec >> 2);
usec = nsec + (usec >> 4);
usec = nsec - (usec >> 3);
usec = nsec + (usec >> 2);
usec = nsec + (usec >> 3);
usec = nsec + (usec >> 4);
usec = nsec + (usec >> 1);
usec = nsec + (usec >> 6);
tvp->tv_usec = usec >> 10;
tvp->tv_sec = ts.tv_sec;
++ppsclockev.serial;
/*
* Because the kernel keeps a high-resolution time, pass the
* current highres timestamp in tvp and zero in usec.
*/
ddi_hardpps(tvp, 0);
}
ZSA_KICK_RCV;
if ((x0 & ZSRR0_BREAK) && (s0 & ZSRR0_BREAK) == 0) {
#ifdef SLAVIO_BUG
/*
* ZSRR0_BREAK turned off. This means that the break sequence
* has completed (i.e., the stop bit finally arrived).
*/
if ((s0 & ZSRR0_RX_READY) == 0) {
/*
* SLAVIO will generate a separate STATUS change
* interrupt when the break sequence completes.
* SCC will combine both, taking the higher priority
* one, the receive. Should still see the ext/stat.
* bit in REG3 on SCC. If no ext/stat, it must be
* a SLAVIO.
*/
za->za_breakoff = 1;
} else {
/*
* The NUL character in the receiver is part of the
* break sequence; it is discarded.
*/
(void) SCC_READDATA(); /* swallow null */
}
#else /* SLAVIO_BUG */
/*
* ZSRR0_BREAK turned off. This means that the break sequence
* has completed (i.e., the stop bit finally arrived). The NUL
* character in the receiver is part of the break sequence;
* it is discarded.
*/
(void) SCC_READDATA(); /* swallow null */
#endif /* SLAVIO_BUG */
SCC_WRITE0(ZSWR0_RESET_ERRORS);
/*
* Note: this will cause an abort if a break occurs on
* the "keyboard device", regardless of whether the
* "keyboard device" is a real keyboard or just a
* terminal on a serial line. This permits you to
* abort a workstation by unplugging the keyboard,
* even if the normal abort key sequence isn't working.
*/
if ((za->za_dev == kbddev) ||
((za->za_dev == rconsdev) || (za->za_dev == stdindev)) &&
(abort_enable != KIOCABORTALTERNATE)) {
abort_sequence_enter((char *)NULL);
/*
* We just broke into the monitor or debugger,
* ignore the break in this case so whatever
* random program that was running doesn't get
* a SIGINT.
*/
return;
}
za->za_break = 1;
}
/*
* If hardware flow control is enabled, (re)start output
* when CTS is reasserted.
*/
if ((za->za_ttycommon.t_cflag & CRTSCTS) &&
(x0 & ZSRR0_CTS) && (s0 & ZSRR0_CTS) &&
(za->za_rcv_flags_mask & DO_RETRANSMIT))
za->za_rcv_flags_mask |= DO_TRANSMIT;
za->za_ext = 1;
ZSSETSOFT(zs);
}
/*
* Receive Interrupt
*/
static void
zsa_rxint(struct zscom *zs)
{
register struct asyncline *za = (struct asyncline *)&zs->zs_priv_str;
register uchar_t c;
register uchar_t *rd_cur = zs->zs_rd_cur;
register uchar_t *rd_lim = zs->zs_rd_lim;
register mblk_t *bp;
register uint_t fm = za->za_rcv_flags_mask;
#ifdef ZSA_DEBUG
za->za_rd++;
#endif
c = (fm >> 16) & (SCC_READDATA());
/*
* Check for character break sequence
*/
if ((abort_enable == KIOCABORTALTERNATE) && (za->za_dev == rconsdev)) {
if (abort_charseq_recognize(c))
abort_sequence_enter((char *)NULL);
}
if (!rd_cur) {
#ifdef SLAVIO_BUG
/*
* SLAVIO generates FE for the start of break and
* during break when parity is set. End of break is
* detected when the first character is received.
* This character is always garbage and is thrown away.
*/
if (za->za_slav_break) {
za->za_slav_break = 0;
za->za_rr0 |= ZSRR0_BREAK;
zsa_xsint(zs);
return;
}
#endif /* SLAVIO_BUG */
if (c == 0 && (za->za_rr0 & ZSRR0_BREAK)) {
/*
* A break sequence was under way, and a NUL character
* was received. Discard the NUL character, as it is
* part of the break sequence; if ZSRR0_BREAK turned
* off, indicating that the break sequence has com-
* pleted, call "zsa_xsint" to properly handle the
* error. It would appear that External/Status
* interrupts get lost occasionally, so this ensures
* that one is delivered.
*/
c = SCC_READ0();
if (!(c & ZSRR0_BREAK))
zsa_xsint(zs);
return;
}
#ifdef SLAVIO_BUG
if (c == 0 && za->za_breakoff) {
/*
* A break sequence completed, but SLAVIO generates
* the NULL character interrupt late, so we throw the
* NULL away now.
*/
return;
}
/*
* make sure it gets cleared.
*/
za->za_breakoff = 0;
#endif /* SLAVIO_BUG */
ZSA_KICK_RCV; /* We can have M_BREAK msg */
ZSA_ALLOCB(bp);
if (!bp) {
za->za_sw_overrun++;
ZSSETSOFT(zs);
return;
}
za->za_rcvblk = bp;
zs->zs_rd_cur = rd_cur = bp->b_wptr;
zs->zs_rd_lim = rd_lim = bp->b_datap->db_lim;
if (za->za_kick_rcv_id == 0)
ZSSETSOFT(zs);
}
if (c == 0377 && (fm & DO_ESC)) {
if (rd_lim < rd_cur + 2) {
ZSA_ALLOCB(bp);
ZSA_KICK_RCV;
if (!bp) {
za->za_sw_overrun++;
return;
}
za->za_rcvblk = bp;
zs->zs_rd_cur = rd_cur = bp->b_wptr;
zs->zs_rd_lim = rd_lim = bp->b_datap->db_lim;
}
*rd_cur++ = c;
}
*rd_cur++ = c;
zs->zs_rd_cur = rd_cur;
if (rd_cur == rd_lim) {
ZSA_KICK_RCV;
} else if ((fm & DO_STOPC) && (c == (fm & 0xff))) {
za->za_do_kick_rcv_in_softint = 1;
ZSSETSOFT(zs);
}
if ((za->za_flags & ZAS_SERVICEIMM) || g_nocluster) {
/*
* Send the data up immediately
*/
ZSA_KICK_RCV;
}
}
/*
* Special receive condition interrupt handler.
*/
static void
zsa_srint(struct zscom *zs)
{
register struct asyncline *za = (struct asyncline *)&zs->zs_priv_str;
register short s1;
register uchar_t c;
register uchar_t c1;
register mblk_t *bp = za->za_rcvblk;
register uchar_t *rd_cur = zs->zs_rd_cur;
SCC_READ(1, s1);
if (s1 & (ZSRR1_FE | ZSRR1_PE | ZSRR1_DO)) {
c = SCC_READDATA(); /* swallow bad character */
}
#ifdef SLAVIO_BUG
/*
* SLAVIO does not handle breaks properly when parity is enabled.
*
* In general, if a null character is received when a framing
* error occurs then it is a break condition and not a real
* framing error. The null character must be limited to the
* number of bits including the parity bit. For example, a 6
* bit character with parity would be null if the lower 7 bits
* read from the receive fifo were 0. (The higher order bits are
* padded with 1 and/or the stop bits.) The only exception to this
* general rule would be an 8 bit null character with parity being
* a 1 in the parity bit and a framing error. This exception
* can be determined by examining the parity error bit in RREG 1.
*
* A null character, even parity, 8 bits, no parity error,
* (0 0000 0000) with framing error is a break condition.
*
* A null character, even parity, 8 bits, parity error,
* (1 0000 0000) with framing error is a framing error.
*
* A null character, odd parity, 8 bits, parity error
* (0 0000 0000) with framing error is a break condition.
*
* A null character, odd parity, 8 bits, no parity error,
* (1 0000 0000) with framing error is a framing error.
*/
if (za->za_ttycommon.t_cflag & PARENB) {
switch (za->za_ttycommon.t_cflag & CSIZE) {
case CS5:
c1 = c & 0x3f;
break;
case CS6:
c1 = c & 0x7f;
break;
case CS7:
c1 = c & 0xff;
break;
case CS8:
if ((za->za_ttycommon.t_cflag & PARODD) &&
!(s1 & ZSRR1_PE))
c1 = 0xff;
else if (!(za->za_ttycommon.t_cflag & PARODD) &&
(s1 & ZSRR1_PE))
c1 = 0xff;
else
c1 = c;
break;
}
/*
* We fake start of break condition.
*/
if ((s1 & ZSRR1_FE) && c1 == 0) {
za->za_slav_break = 1;
return;
}
}
#endif /* SLAVIO_BUG */
if (s1 & ZSRR1_PE) {
/*
* Mark the parity error so zsa_process will
* notice it and send it up in an M_BREAK
* message; ldterm will do the actual parity error
* processing
*/
if (bp && zs->zs_rd_cur) { /* M_DATA msg */
ZSA_KICK_RCV;
bp = NULL;
}
if (!bp)
ZSA_ALLOCB(bp);
if (!bp) {
za->za_sw_overrun++;
ZSSETSOFT(zs);
} else {
za->za_rcvblk = bp;
zs->zs_rd_cur = rd_cur = bp->b_wptr;
zs->zs_rd_lim = bp->b_datap->db_lim;
*rd_cur++ = c;
zs->zs_rd_cur = rd_cur;
bp->b_datap->db_type = M_BREAK;
if (bp->b_datap->db_lim <= rd_cur)
ZSA_KICK_RCV;
za->za_do_kick_rcv_in_softint = 1;
ZSSETSOFT(zs);
}
}
SCC_WRITE0(ZSWR0_RESET_ERRORS);
if (s1 & ZSRR1_DO) {
za->za_hw_overrun++;
ZSSETSOFT(zs);
}
}
/*
* Process software interrupts (or poll)
* Crucial points:
* 3. BUG - breaks are handled "out-of-band" - their relative position
* among input events is lost, as well as multiple breaks together.
* This is probably not a problem in practice.
*/
static int
zsa_softint(struct zscom *zs)
{
register struct asyncline *za = (struct asyncline *)&zs->zs_priv_str;
register uchar_t r0;
register uchar_t za_kick_active;
register int m_error;
register int allocbcount = 0;
register int do_ttycommon_qfull = 0;
boolean_t hangup = B_FALSE, unhangup = B_FALSE;
boolean_t m_break = B_FALSE, wakeup = B_FALSE;
register queue_t *q;
register mblk_t *bp;
register mblk_t *head = NULL, *tail = NULL;
mutex_enter(zs->zs_excl);
if (zs->zs_suspended || (zs->zs_flags & ZS_CLOSED)) {
mutex_exit(zs->zs_excl);
return (0);
}
q = za->za_ttycommon.t_readq;
if (za->za_flags & ZAS_WOPEN && !q) {
if (za->za_ext) {
mutex_enter(zs->zs_excl_hi);
r0 = SCC_READ0();
za->za_ext = 0;
mutex_exit(zs->zs_excl_hi);
/*
* carrier up?
*/
if ((r0 & ZSRR0_CD) ||
(za->za_ttycommon.t_flags & TS_SOFTCAR)) {
/*
* carrier present
*/
if ((za->za_flags & ZAS_CARR_ON) == 0) {
za->za_flags |= ZAS_CARR_ON;
mutex_exit(zs->zs_excl);
cv_broadcast(&zs->zs_flags_cv);
return (0);
}
}
}
mutex_exit(zs->zs_excl);
return (0);
}
q = za->za_ttycommon.t_readq;
if (!q) {
mutex_exit(zs->zs_excl);
return (0);
}
m_error = za->za_m_error;
za->za_m_error = 0;
if (za->za_do_kick_rcv_in_softint) {
mutex_enter(zs->zs_excl_hi);
ZSA_KICK_RCV;
za->za_do_kick_rcv_in_softint = 0;
mutex_exit(zs->zs_excl_hi);
}
za_kick_active = za->za_kick_active;
while (!za_kick_active) {
ZSA_SEEQ(bp);
if (!bp)
break;
allocbcount++;
if (bp->b_datap->db_type <= QPCTL) {
if (!(canputnext(q))) {
if (za->za_grace_flow_control >=
zsa_grace_flow_control) {
if (za->za_ttycommon.t_cflag &
CRTSXOFF) {
allocbcount--;
break;
}
ZSA_GETQ(bp);
freemsg(bp);
do_ttycommon_qfull = 1;
continue;
} else
za->za_grace_flow_control++;
} else
za->za_grace_flow_control = 0;
}
ZSA_GETQ(bp);
if (!head) {
head = bp;
} else {
if (!tail)
tail = head;
tail->b_next = bp;
tail = bp;
}
}
if (allocbcount)
ZSA_GETBLOCK(zs, allocbcount);
if (za->za_ext) {
mutex_enter(zs->zs_excl_hi);
r0 = SCC_READ0();
za->za_ext = 0;
/*
* carrier up?
*/
if ((r0 & ZSRR0_CD) ||
(za->za_ttycommon.t_flags & TS_SOFTCAR)) {
/*
* carrier present
*/
if ((za->za_flags & ZAS_CARR_ON) == 0) {
za->za_flags |= ZAS_CARR_ON;
unhangup = B_TRUE;
wakeup = B_TRUE;
}
} else {
if ((za->za_flags & ZAS_CARR_ON) &&
!(za->za_ttycommon.t_cflag & CLOCAL)) {
/*
* Carrier went away.
* Drop DTR, abort any output in progress,
* indicate that output is not stopped, and
* send a hangup notification upstream.
*/
(void) zsmctl(zs, ZSWR5_DTR, DMBIC);
if ((za->za_flags & ZAS_BUSY) &&
(zs->zs_wr_cur != NULL)) {
zs->zs_wr_cur = NULL;
zs->zs_wr_lim = NULL;
}
hangup = B_TRUE;
wakeup = B_TRUE;
za->za_flags &= ~(ZAS_STOPPED | ZAS_CARR_ON |
ZAS_BUSY);
za->za_rcv_flags_mask &= ~(DO_TRANSMIT |
DO_RETRANSMIT);
}
}
mutex_exit(zs->zs_excl_hi);
if (hangup && (bp = za->za_xmitblk) != NULL) {
za->za_xmitblk = NULL;
freeb(bp);
}
}
if (za->za_break != 0) {
mutex_enter(zs->zs_excl_hi);
r0 = SCC_READ0();
mutex_exit(zs->zs_excl_hi);
if ((r0 & ZSRR0_BREAK) == 0) {
za->za_break = 0;
m_break = B_TRUE;
}
}
/*
* If a transmission has finished, indicate that it's
* finished, and start that line up again.
*/
mutex_enter(zs->zs_excl_hi);
if (za->za_rcv_flags_mask & DO_TRANSMIT) {
za->za_rcv_flags_mask &= ~DO_TRANSMIT;
za->za_flags &= ~ZAS_BUSY;
if ((za->za_ttycommon.t_cflag & CRTSCTS) &&
(za->za_rcv_flags_mask & DO_RETRANSMIT) &&
zs->zs_wr_cur)
bp = NULL;
else {
za->za_rcv_flags_mask &= ~DO_RETRANSMIT;
bp = za->za_xmitblk;
za->za_xmitblk = 0;
}
mutex_exit(zs->zs_excl_hi);
if (bp)
freemsg(bp);
zsa_start(zs);
/* if we didn't start anything, then notify waiters */
if (!(za->za_flags & ZAS_BUSY))
wakeup = B_TRUE;
} else {
mutex_exit(zs->zs_excl_hi);
}
/*
* A note about these overrun bits: all they do is *tell* someone
* about an error- They do not track multiple errors. In fact,
* you could consider them latched register bits if you like.
* We are only interested in printing the error message once for
* any cluster of overrun errrors.
*/
if ((!za->za_kick_rcv_id) && (zs->zs_rd_cur || za_kick_active)) {
if (g_zsticks)
za->za_kick_rcv_id = timeout(zsa_kick_rcv, zs,
g_zsticks);
else
za->za_kick_rcv_id = timeout(zsa_kick_rcv, zs,
zsticks[SPEED(za->za_ttycommon.t_cflag)]);
za->za_kick_rcv_count = ZA_KICK_RCV_COUNT;
}
za->za_soft_active = 1;
mutex_exit(zs->zs_excl);
if (!hangup && do_ttycommon_qfull) {
ttycommon_qfull(&za->za_ttycommon, q);
mutex_enter(zs->zs_excl);
zsa_start(zs);
mutex_exit(zs->zs_excl);
}
if (za->za_hw_overrun > 10) {
cmn_err(CE_NOTE, "zs%d: silo overflow\n", UNIT(za->za_dev));
za->za_hw_overrun = 0;
}
if (za->za_sw_overrun > 10) {
cmn_err(CE_NOTE, "zs%d:ring buffer overflow\n",
UNIT(za->za_dev));
za->za_sw_overrun = 0;
}
if (unhangup)
(void) putnextctl(q, M_UNHANGUP);
if (m_break)
(void) putnextctl(q, M_BREAK);
while (head) {
if (!tail) {
putnext(q, head);
break;
}
bp = head;
head = head->b_next;
bp->b_next = NULL;
putnext(q, bp);
}
if (hangup) {
int flushflag;
/*
* If we're in the midst of close, then flush everything. Don't
* leave stale ioctls lying about.
*/
flushflag = (zs->zs_flags & ZS_CLOSING) ? FLUSHALL : FLUSHDATA;
flushq(za->za_ttycommon.t_writeq, flushflag);
(void) putnextctl(q, M_HANGUP);
}
if (m_error)
(void) putnextctl1(q, M_ERROR, m_error);
za->za_soft_active = 0;
if (wakeup || (zs->zs_flags & ZS_CLOSED))
cv_broadcast(&zs->zs_flags_cv);
return (0);
}
/*
* Start output on a line, unless it's busy, frozen, or otherwise.
*/
static void
zsa_start(struct zscom *zs)
{
register struct asyncline *za = (struct asyncline *)&zs->zs_priv_str;
register int cc;
register queue_t *q;
register mblk_t *bp;
uchar_t *rptr, *wptr;
/*
* If the chip is busy (i.e., we're waiting for a break timeout
* to expire, or for the current transmission to finish, or for
* output to finish draining from chip), don't grab anything new.
*/
if ((za->za_flags & (ZAS_BREAK|ZAS_BUSY|ZAS_DRAINING)) ||
zs->zs_suspended)
return;
if (za->za_ttycommon.t_cflag & CRTSCTS) {
mutex_enter(zs->zs_excl_hi);
if (za->za_rcv_flags_mask & DO_RETRANSMIT) {
rptr = zs->zs_wr_cur;
wptr = zs->zs_wr_lim;
goto zsa_start_retransmit;
}
mutex_exit(zs->zs_excl_hi);
}
/*
* If we have a flow-control character to transmit, do it now.
*/
if (za->za_flowc != '\0') {
mutex_enter(zs->zs_excl_hi);
if (za->za_ttycommon.t_cflag & CRTSCTS) {
if ((SCC_READ0() & (ZSRR0_CTS|ZSRR0_TX_READY)) !=
(ZSRR0_CTS|ZSRR0_TX_READY)) {
mutex_exit(zs->zs_excl_hi);
return;
}
} else if (!(SCC_READ0() & ZSRR0_TX_READY)) {
mutex_exit(zs->zs_excl_hi);
return;
}
ZSDELAY();
SCC_WRITEDATA(za->za_flowc);
za->za_flowc = '\0';
mutex_exit(zs->zs_excl_hi);
return;
}
/*
* If we're waiting for a delay timeout to expire, don't grab
* anything new.
*/
if (za->za_flags & ZAS_DELAY)
return;
if ((q = za->za_ttycommon.t_writeq) == NULL)
return; /* not attached to a stream */
zsa_start_again:
for (;;) {
if ((bp = getq(q)) == NULL)
return; /* no data to transmit */
/*
* We have a message block to work on.
* Check whether it's a break, a delay, or an ioctl (the latter
* occurs if the ioctl in question was waiting for the output
* to drain). If it's one of those, process it immediately.
*/
switch (bp->b_datap->db_type) {
case M_BREAK:
/*
* Set the break bit, and arrange for "zsa_restart"
* to be called in 1/4 second; it will turn the
* break bit off, and call "zsa_start" to grab
* the next message.
*/
mutex_enter(zs->zs_excl_hi);
SCC_BIS(5, ZSWR5_BREAK);
mutex_exit(zs->zs_excl_hi);
if (!za->za_zsa_restart_id) {
za->za_zsa_restart_id =
timeout(zsa_restart, zs, hz/4);
}
za->za_flags |= ZAS_BREAK;
freemsg(bp);
return; /* wait for this to finish */
case M_DELAY:
/*
* Arrange for "zsa_restart" to be called when the
* delay expires; it will turn MTS_DELAY off,
* and call "zsa_start" to grab the next message.
*/
if (! za->za_zsa_restart_id) {
za->za_zsa_restart_id = timeout(zsa_restart,
zs,
(int)(*(unsigned char *)bp->b_rptr + 6));
}
za->za_flags |= ZAS_DELAY;
freemsg(bp);
return; /* wait for this to finish */
case M_IOCTL:
/*
* This ioctl was waiting for the output ahead of
* it to drain; obviously, it has. Do it, and
* then grab the next message after it.
*/
zsa_ioctl(za, q, bp);
continue;
default: /* M_DATA */
goto zsa_start_transmit;
}
}
zsa_start_transmit:
/*
* We have data to transmit. If output is stopped, put
* it back and try again later.
*/
if (za->za_flags & ZAS_STOPPED) {
(void) putbq(q, bp);
return;
}
za->za_xmitblk = bp;
rptr = bp->b_rptr;
wptr = bp->b_wptr;
cc = wptr - rptr;
bp = bp->b_cont;
if (bp != NULL) {
za->za_xmitblk->b_cont = NULL;
(void) putbq(q, bp); /* not done with this message yet */
}
if (rptr >= wptr) {
freeb(za->za_xmitblk);
za->za_xmitblk = NULL;
goto zsa_start_again;
}
/*
* In 5-bit mode, the high order bits are used
* to indicate character sizes less than five,
* so we need to explicitly mask before transmitting
*/
if ((za->za_ttycommon.t_cflag & CSIZE) == CS5) {
register unsigned char *p = rptr;
register int cnt = cc;
while (cnt--)
*p++ &= (unsigned char) 0x1f;
}
/*
* Set up this block for pseudo-DMA.
*/
mutex_enter(zs->zs_excl_hi);
zs->zs_wr_cur = rptr;
zs->zs_wr_lim = wptr;
zsa_start_retransmit:
za->za_rcv_flags_mask &= ~DO_TRANSMIT;
if (za->za_ttycommon.t_cflag & CRTSCTS) {
if ((SCC_READ0() & (ZSRR0_CTS|ZSRR0_TX_READY)) !=
(ZSRR0_CTS|ZSRR0_TX_READY)) {
za->za_rcv_flags_mask |= DO_RETRANSMIT;
za->za_flags |= ZAS_BUSY;
mutex_exit(zs->zs_excl_hi);
return;
}
za->za_rcv_flags_mask &= ~DO_RETRANSMIT;
} else {
if (!(SCC_READ0() & ZSRR0_TX_READY)) {
za->za_flags |= ZAS_BUSY;
mutex_exit(zs->zs_excl_hi);
return;
}
}
/*
* If the transmitter is ready, shove the first
* character out.
*/
ZSDELAY();
SCC_WRITEDATA(*rptr++);
#ifdef ZSA_DEBUG
za->za_wr++;
#endif
zs->zs_wr_cur = rptr;
za->za_flags |= ZAS_BUSY;
zs->zs_flags |= ZS_PROGRESS;
mutex_exit(zs->zs_excl_hi);
}
/*
* Restart output on a line after a delay or break timer expired.
*/
static void
zsa_restart(void *arg)
{
struct zscom *zs = arg;
struct asyncline *za = (struct asyncline *)&zs->zs_priv_str;
/*
* If break timer expired, turn off the break bit.
*/
mutex_enter(zs->zs_excl);
if (!za->za_zsa_restart_id) {
mutex_exit(zs->zs_excl);
return;
}
za->za_zsa_restart_id = 0;
if (za->za_flags & ZAS_BREAK) {
mutex_enter(zs->zs_excl_hi);
SCC_BIC(5, ZSWR5_BREAK);
mutex_exit(zs->zs_excl_hi);
}
za->za_flags &= ~(ZAS_DELAY|ZAS_BREAK);
if (za->za_ttycommon.t_writeq != NULL)
zsa_start(zs);
mutex_exit(zs->zs_excl);
cv_broadcast(&zs->zs_flags_cv);
}
/*
* See if the receiver has any data after zs_tick delay
*/
static void
zsa_kick_rcv(void *arg)
{
struct zscom *zs = arg;
struct asyncline *za = (struct asyncline *)&zs->zs_priv_str;
queue_t *q;
int tmp;
mblk_t *mp;
uchar_t za_soft_active, za_kick_active;
int allocbcount = 0;
int do_ttycommon_qfull = 0;
mblk_t *head = NULL, *tail = NULL;
mutex_enter(zs->zs_excl);
if (za->za_kick_rcv_id == 0 || (zs->zs_flags & ZS_CLOSED)) {
mutex_exit(zs->zs_excl);
return;
}
za_soft_active = za->za_soft_active;
za_kick_active = za->za_kick_active;
q = za->za_ttycommon.t_readq;
if (!q) {
mutex_exit(zs->zs_excl);
return;
}
mutex_enter(zs->zs_excl_hi);
if (zs->zs_rd_cur) {
ZSA_KICK_RCV;
za->za_kick_rcv_count = tmp = ZA_KICK_RCV_COUNT;
} else
tmp = --za->za_kick_rcv_count;
if (tmp > 0 || za_soft_active || za_kick_active) {
mutex_exit(zs->zs_excl_hi);
if (g_zsticks)
za->za_kick_rcv_id = timeout(zsa_kick_rcv,
zs, g_zsticks);
else
za->za_kick_rcv_id = timeout(zsa_kick_rcv,
zs, zsticks[SPEED(za->za_ttycommon.t_cflag)]);
if (za_soft_active || za_kick_active) {
mutex_exit(zs->zs_excl);
return;
}
} else {
za->za_kick_rcv_id = 0;
mutex_exit(zs->zs_excl_hi);
}
for (;;) {
ZSA_SEEQ(mp);
if (!mp)
break;
allocbcount++;
if (mp->b_datap->db_type <= QPCTL) {
if (!(canputnext(q))) {
if (za->za_grace_flow_control >=
zsa_grace_flow_control) {
if (za->za_ttycommon.t_cflag &
CRTSXOFF) {
allocbcount--;
break;
}
ZSA_GETQ(mp);
freemsg(mp);
do_ttycommon_qfull = 1;
continue;
} else
za->za_grace_flow_control++;
} else
za->za_grace_flow_control = 0;
}
ZSA_GETQ(mp);
if (!head) {
head = mp;
} else {
if (!tail)
tail = head;
tail->b_next = mp;
tail = mp;
}
}
if (allocbcount)
ZSA_GETBLOCK(zs, allocbcount);
za->za_kick_active = 1;
mutex_exit(zs->zs_excl);
if (do_ttycommon_qfull) {
ttycommon_qfull(&za->za_ttycommon, q);
mutex_enter(zs->zs_excl);
zsa_start(zs);
mutex_exit(zs->zs_excl);
}
while (head) {
if (!tail) {
putnext(q, head);
break;
}
mp = head;
head = head->b_next;
mp->b_next = NULL;
putnext(q, mp);
}
za->za_kick_active = 0;
if (zs->zs_flags & ZS_CLOSED)
cv_broadcast(&zs->zs_flags_cv);
}
/*
* Retry an "ioctl", now that "bufcall" claims we may be able to allocate
* the buffer we need.
*/
static void
zsa_reioctl(void *arg)
{
struct asyncline *za = arg;
struct zscom *zs = za->za_common;
queue_t *q;
mblk_t *mp;
/*
* The bufcall is no longer pending.
*/
mutex_enter(zs->zs_excl);
if (!za->za_wbufcid) {
mutex_exit(zs->zs_excl);
return;
}
za->za_wbufcid = 0;
if ((q = za->za_ttycommon.t_writeq) == NULL) {
mutex_exit(zs->zs_excl);
return;
}
if ((mp = za->za_ttycommon.t_iocpending) != NULL) {
/*
* not pending any more
*/
za->za_ttycommon.t_iocpending = NULL;
zsa_ioctl(za, q, mp);
}
mutex_exit(zs->zs_excl);
}
/*
* Process an "ioctl" message sent down to us.
* Note that we don't need to get any locks until we are ready to access
* the hardware. Nothing we access until then is going to be altered
* outside of the STREAMS framework, so we should be safe.
*/
static void
zsa_ioctl(struct asyncline *za, queue_t *wq, mblk_t *mp)
{
register struct zscom *zs = za->za_common;
register struct iocblk *iocp;
register unsigned datasize;
int error;
register mblk_t *tmp;
if (za->za_ttycommon.t_iocpending != NULL) {
/*
* We were holding an "ioctl" response pending the
* availability of an "mblk" to hold data to be passed up;
* another "ioctl" came through, which means that "ioctl"
* must have timed out or been aborted.
*/
freemsg(za->za_ttycommon.t_iocpending);
za->za_ttycommon.t_iocpending = NULL;
}
iocp = (struct iocblk *)mp->b_rptr;
/*
* The only way in which "ttycommon_ioctl" can fail is if the "ioctl"
* requires a response containing data to be returned to the user,
* and no mblk could be allocated for the data.
* No such "ioctl" alters our state. Thus, we always go ahead and
* do any state-changes the "ioctl" calls for. If we couldn't allocate
* the data, "ttycommon_ioctl" has stashed the "ioctl" away safely, so
* we just call "bufcall" to request that we be called back when we
* stand a better chance of allocating the data.
*/
mutex_exit(zs->zs_excl);
datasize = ttycommon_ioctl(&za->za_ttycommon, wq, mp, &error);
mutex_enter(zs->zs_excl);
if (za->za_ttycommon.t_flags & TS_SOFTCAR)
zssoftCAR[zs->zs_unit] = 1;
else
zssoftCAR[zs->zs_unit] = 0;
if (datasize != 0) {
if (za->za_wbufcid)
unbufcall(za->za_wbufcid);
za->za_wbufcid = bufcall(datasize, BPRI_HI, zsa_reioctl, za);
return;
}
if (error == 0) {
/*
* "ttycommon_ioctl" did most of the work; we just use the
* data it set up.
*/
switch (iocp->ioc_cmd) {
case TCSETS:
case TCSETSW:
case TCSETSF:
case TCSETA:
case TCSETAW:
case TCSETAF:
mutex_enter(zs->zs_excl_hi);
zsa_program(za, 1);
zsa_set_za_rcv_flags_mask(za);
mutex_exit(zs->zs_excl_hi);
break;
}
} else if (error < 0) {
/*
* "ttycommon_ioctl" didn't do anything; we process it here.
*/
error = 0;
switch (iocp->ioc_cmd) {
case TCSBRK:
error = miocpullup(mp, sizeof (int));
if (error != 0)
break;
if (*(int *)mp->b_cont->b_rptr == 0) {
/*
* The delay ensures that a 3 byte transmit
* fifo is empty.
*/
mutex_exit(zs->zs_excl);
delay(ztdelay(SPEED(za->za_ttycommon.t_cflag)));
mutex_enter(zs->zs_excl);
/*
* Set the break bit, and arrange for
* "zsa_restart" to be called in 1/4 second;
* it will turn the break bit off, and call
* "zsa_start" to grab the next message.
*/
mutex_enter(zs->zs_excl_hi);
SCC_BIS(5, ZSWR5_BREAK);
if (!za->za_zsa_restart_id) {
mutex_exit(zs->zs_excl_hi);
za->za_zsa_restart_id =
timeout(zsa_restart, zs, hz / 4);
mutex_enter(zs->zs_excl_hi);
}
za->za_flags |= ZAS_BREAK;
mutex_exit(zs->zs_excl_hi);
}
break;
case TIOCSBRK:
mutex_enter(zs->zs_excl_hi);
SCC_BIS(5, ZSWR5_BREAK);
mutex_exit(zs->zs_excl_hi);
mioc2ack(mp, NULL, 0, 0);
break;
case TIOCCBRK:
mutex_enter(zs->zs_excl_hi);
SCC_BIC(5, ZSWR5_BREAK);
mutex_exit(zs->zs_excl_hi);
mioc2ack(mp, NULL, 0, 0);
break;
case TIOCMSET:
case TIOCMBIS:
case TIOCMBIC: {
int mlines;
if (iocp->ioc_count == TRANSPARENT) {
mcopyin(mp, NULL, sizeof (int), NULL);
break;
}
error = miocpullup(mp, sizeof (int));
if (error != 0)
break;
mlines = *(int *)mp->b_cont->b_rptr;
mutex_enter(zs->zs_excl_hi);
switch (iocp->ioc_cmd) {
case TIOCMSET:
(void) zsmctl(zs, dmtozs(mlines), DMSET);
break;
case TIOCMBIS:
(void) zsmctl(zs, dmtozs(mlines), DMBIS);
break;
case TIOCMBIC:
(void) zsmctl(zs, dmtozs(mlines), DMBIC);
break;
}
mutex_exit(zs->zs_excl_hi);
mioc2ack(mp, NULL, 0, 0);
break;
}
case TIOCMGET:
tmp = allocb(sizeof (int), BPRI_MED);
if (tmp == NULL) {
error = EAGAIN;
break;
}
if (iocp->ioc_count != TRANSPARENT)
mioc2ack(mp, tmp, sizeof (int), 0);
else
mcopyout(mp, NULL, sizeof (int), NULL, tmp);
mutex_enter(zs->zs_excl_hi);
*(int *)mp->b_cont->b_rptr =
zstodm(zsmctl(zs, 0, DMGET));
mutex_exit(zs->zs_excl_hi);
/*
* qreply done below
*/
break;
default:
/*
* If we don't understand it, it's an error. NAK it.
*/
error = EINVAL;
break;
}
}
if (error != 0) {
iocp->ioc_error = error;
mp->b_datap->db_type = M_IOCNAK;
}
ZSA_QREPLY(wq, mp);
}
static int
dmtozs(int bits)
{
register int b = 0;
if (bits & TIOCM_CAR)
b |= ZSRR0_CD;
if (bits & TIOCM_CTS)
b |= ZSRR0_CTS;
if (bits & TIOCM_RTS)
b |= ZSWR5_RTS;
if (bits & TIOCM_DTR)
b |= ZSWR5_DTR;
return (b);
}
static int
zstodm(int bits)
{
register int b;
b = 0;
if (bits & ZSRR0_CD)
b |= TIOCM_CAR;
if (bits & ZSRR0_CTS)
b |= TIOCM_CTS;
if (bits & ZSWR5_RTS)
b |= TIOCM_RTS;
if (bits & ZSWR5_DTR)
b |= TIOCM_DTR;
return (b);
}
/*
* Assemble registers and flags necessary to program the port to our liking.
* For async operation, most of this is based on the values of
* the "c_iflag" and "c_cflag" fields supplied to us.
*/
static void
zsa_program(struct asyncline *za, int setibaud)
{
register struct zscom *zs = za->za_common;
register struct zs_prog *zspp;
register int wr3, wr4, wr5, wr15, speed, baudrate, flags = 0;
if ((baudrate = SPEED(za->za_ttycommon.t_cflag)) == 0) {
/*
* Hang up line.
*/
(void) zsmctl(zs, ZS_OFF, DMSET);
return;
}
/*
* set input speed same as output, as split speed not supported
*/
if (setibaud) {
za->za_ttycommon.t_cflag &= ~(CIBAUD);
if (baudrate > CBAUD) {
za->za_ttycommon.t_cflag |= CIBAUDEXT;
za->za_ttycommon.t_cflag |=
(((baudrate - CBAUD - 1) << IBSHIFT) & CIBAUD);
} else {
za->za_ttycommon.t_cflag &= ~CIBAUDEXT;
za->za_ttycommon.t_cflag |=
((baudrate << IBSHIFT) & CIBAUD);
}
}
/*
* Do not allow the console/keyboard device to have its receiver
* disabled; doing that would mean you couldn't type an abort
* sequence.
*/
if ((za->za_dev == rconsdev) || (za->za_dev == kbddev) ||
(za->za_dev == stdindev) || (za->za_ttycommon.t_cflag & CREAD))
wr3 = ZSWR3_RX_ENABLE;
else
wr3 = 0;
wr4 = ZSWR4_X16_CLK;
wr5 = (zs->zs_wreg[5] & (ZSWR5_RTS|ZSWR5_DTR)) | ZSWR5_TX_ENABLE;
if (zsb134_weird && baudrate == B134) { /* what a joke! */
/*
* XXX - should B134 set all this crap in the compatibility
* module, leaving this stuff fairly clean?
*/
flags |= ZSP_PARITY_SPECIAL;
wr3 |= ZSWR3_RX_6;
wr4 |= ZSWR4_PARITY_ENABLE | ZSWR4_PARITY_EVEN;
wr4 |= ZSWR4_1_5_STOP;
wr5 |= ZSWR5_TX_6;
} else {
switch (za->za_ttycommon.t_cflag & CSIZE) {
case CS5:
wr3 |= ZSWR3_RX_5;
wr5 |= ZSWR5_TX_5;
break;
case CS6:
wr3 |= ZSWR3_RX_6;
wr5 |= ZSWR5_TX_6;
break;
case CS7:
wr3 |= ZSWR3_RX_7;
wr5 |= ZSWR5_TX_7;
break;
case CS8:
wr3 |= ZSWR3_RX_8;
wr5 |= ZSWR5_TX_8;
break;
}
if (za->za_ttycommon.t_cflag & PARENB) {
/*
* The PARITY_SPECIAL bit causes a special rx
* interrupt on parity errors. Turn it on if
* we're checking the parity of characters.
*/
if (za->za_ttycommon.t_iflag & INPCK)
flags |= ZSP_PARITY_SPECIAL;
wr4 |= ZSWR4_PARITY_ENABLE;
if (!(za->za_ttycommon.t_cflag & PARODD))
wr4 |= ZSWR4_PARITY_EVEN;
}
wr4 |= (za->za_ttycommon.t_cflag & CSTOPB) ?
ZSWR4_2_STOP : ZSWR4_1_STOP;
}
#if 0
/*
* The AUTO_CD_CTS flag enables the hardware flow control feature of
* the 8530, which allows the state of CTS and DCD to control the
* enabling of the transmitter and receiver, respectively. The
* receiver and transmitter still must have their enable bits set in
* WR3 and WR5, respectively, for CTS and DCD to be monitored this way.
* Hardware flow control can thus be implemented with no help from
* software.
*/
if (za->za_ttycommon.t_cflag & CRTSCTS)
wr3 |= ZSWR3_AUTO_CD_CTS;
#endif
if (za->za_ttycommon.t_cflag & CRTSCTS)
wr15 = ZSR15_BREAK | ZSR15_TX_UNDER | ZSR15_CD | ZSR15_CTS;
else
wr15 = ZSR15_BREAK | ZSR15_TX_UNDER | ZSR15_CD;
speed = zs->zs_wreg[12] + (zs->zs_wreg[13] << 8);
/*
* Here we assemble a set of changes to be passed to zs_program.
* Note: Write Register 15 must be set to enable BREAK and UNDERrun
* interrupts. It must also enable CD interrupts which, although
* not processed by the hardware interrupt handler, will be processed
* by zsa_process, indirectly resulting in a SIGHUP being delivered
* to the controlling process if CD drops. CTS interrupts must NOT
* be enabled. We don't use them at all, and they will hang IPC/IPX
* systems at boot time if synchronous modems that supply transmit
* clock are attached to any of their serial ports.
*/
if (((zs->zs_wreg[1] & ZSWR1_PARITY_SPECIAL) &&
!(flags & ZSP_PARITY_SPECIAL)) ||
(!(zs->zs_wreg[1] & ZSWR1_PARITY_SPECIAL) &&
(flags & ZSP_PARITY_SPECIAL)) ||
wr3 != zs->zs_wreg[3] || wr4 != zs->zs_wreg[4] ||
wr5 != zs->zs_wreg[5] || wr15 != zs->zs_wreg[15] ||
speed != zs_speeds[baudrate]) {
za->za_flags |= ZAS_DRAINING;
zspp = &zs_prog[zs->zs_unit];
zspp->zs = zs;
zspp->flags = (uchar_t)flags;
zspp->wr4 = (uchar_t)wr4;
zspp->wr11 = (uchar_t)(ZSWR11_TXCLK_BAUD | ZSWR11_RXCLK_BAUD);
speed = zs_speeds[baudrate];
zspp->wr12 = (uchar_t)(speed & 0xff);
zspp->wr13 = (uchar_t)((speed >> 8) & 0xff);
zspp->wr3 = (uchar_t)wr3;
zspp->wr5 = (uchar_t)wr5;
zspp->wr15 = (uchar_t)wr15;
zs_program(zspp);
za->za_flags &= ~ZAS_DRAINING;
}
}
/*
* Get the current speed of the console and turn it into something
* UNIX knows about - used to preserve console speed when UNIX comes up.
*/
int
zsgetspeed(dev_t dev)
{
register struct zscom *zs;
register int uspeed, zspeed;
register uchar_t rr;
zs = &zscom[UNIT(dev)];
SCC_READ(12, zspeed);
SCC_READ(13, rr);
zspeed |= rr << 8;
for (uspeed = 0; uspeed < NSPEED; uspeed++)
if (zs_speeds[uspeed] == zspeed)
return (uspeed);
/*
* 9600 baud if we can't figure it out
*/
return (ISPEED);
}
/*
* callback routine when enough memory is available.
*/
static void
zsa_callback(void *arg)
{
struct zscom *zs = arg;
struct asyncline *za = (struct asyncline *)&zs->zs_priv_str;
int allocbcount = zsa_rstandby;
mutex_enter(zs->zs_excl);
if (za->za_bufcid) {
za->za_bufcid = 0;
ZSA_GETBLOCK(zs, allocbcount);
}
mutex_exit(zs->zs_excl);
}
/*
* Set the receiver flags
*/
static void
zsa_set_za_rcv_flags_mask(struct asyncline *za)
{
register uint_t mask;
za->za_rcv_flags_mask &= ~0xFF;
switch (za->za_ttycommon.t_cflag & CSIZE) {
case CS5:
mask = 0x1f;
break;
case CS6:
mask = 0x3f;
break;
case CS7:
mask = 0x7f;
break;
default:
mask = 0xff;
}
za->za_rcv_flags_mask &= ~(0xFF << 16);
za->za_rcv_flags_mask |= mask << 16;
if ((za->za_ttycommon.t_iflag & PARMRK) &&
!(za->za_ttycommon.t_iflag & (IGNPAR|ISTRIP))) {
za->za_rcv_flags_mask |= DO_ESC;
} else
za->za_rcv_flags_mask &= ~DO_ESC;
if (za->za_ttycommon.t_iflag & IXON) {
za->za_rcv_flags_mask |= DO_STOPC;
za->za_rcv_flags_mask &= ~0xFF;
za->za_rcv_flags_mask |= za->za_ttycommon.t_stopc;
} else
za->za_rcv_flags_mask &= ~DO_STOPC;
}
static int
zsa_suspend(struct zscom *zs)
{
struct asyncline *za;
queue_t *q;
mblk_t *bp = NULL;
timeout_id_t restart_id, kick_rcv_id;
struct zs_prog *zspp;
za = (struct asyncline *)&zs->zs_priv_str;
mutex_enter(zs->zs_excl);
if (zs->zs_suspended) {
mutex_exit(zs->zs_excl);
return (DDI_SUCCESS);
}
zs->zs_suspended = 1;
/*
* Turn off interrupts and get any bytes in receiver
*/
mutex_enter(zs->zs_excl_hi);
SCC_BIC(1, ZSWR1_INIT);
ZSA_KICK_RCV;
restart_id = za->za_zsa_restart_id;
za->za_zsa_restart_id = 0;
kick_rcv_id = za->za_kick_rcv_id;
za->za_kick_rcv_id = 0;
mutex_exit(zs->zs_excl_hi);
mutex_exit(zs->zs_excl);
/*
* Cancel any timeouts
*/
if (restart_id)
(void) untimeout(restart_id);
if (kick_rcv_id)
(void) untimeout(kick_rcv_id);
/*
* Since we have turned off interrupts, zsa_txint will not be called
* and no new chars will given to the chip. We just wait for the
* current character(s) to drain.
*/
delay(ztdelay(za->za_ttycommon.t_cflag & CBAUD));
/*
* Return remains of partially sent message to queue
*/
mutex_enter(zs->zs_excl);
if ((q = za->za_ttycommon.t_writeq) != NULL) {
mutex_enter(zs->zs_excl_hi);
if ((zs->zs_wr_cur) != NULL) {
za->za_flags &= ~ZAS_BUSY;
za->za_rcv_flags_mask &= ~DO_RETRANSMIT;
bp = za->za_xmitblk;
bp->b_rptr = zs->zs_wr_cur;
zs->zs_wr_cur = NULL;
zs->zs_wr_lim = NULL;
za->za_xmitblk = NULL;
}
mutex_exit(zs->zs_excl_hi);
if (bp)
(void) putbq(q, bp);
}
/*
* Stop any breaks in progress.
*/
mutex_enter(zs->zs_excl_hi);
if (zs->zs_wreg[5] & ZSWR5_BREAK) {
SCC_BIC(5, ZSWR5_BREAK);
za->za_flags &= ~ZAS_BREAK;
}
/*
* Now get a copy of current registers setting.
*/
zspp = &zs_prog[zs->zs_unit];
zspp->zs = zs;
zspp->flags = 0;
zspp->wr3 = zs->zs_wreg[3];
zspp->wr4 = zs->zs_wreg[4];
zspp->wr5 = zs->zs_wreg[5];
zspp->wr11 = zs->zs_wreg[11];
zspp->wr12 = zs->zs_wreg[12];
zspp->wr13 = zs->zs_wreg[13];
zspp->wr15 = zs->zs_wreg[15];
mutex_exit(zs->zs_excl_hi);
mutex_exit(zs->zs_excl);
/*
* We do this on the off chance that zsa_close is waiting on a timed
* break to complete and nothing else.
*/
cv_broadcast(&zs->zs_flags_cv);
return (DDI_SUCCESS);
}
static int
zsa_resume(struct zscom *zs)
{
register struct asyncline *za;
struct zs_prog *zspp;
za = (struct asyncline *)&zs->zs_priv_str;
mutex_enter(zs->zs_excl);
if (!(zs->zs_suspended)) {
mutex_exit(zs->zs_excl);
return (DDI_SUCCESS);
}
/*
* Restore H/W state
*/
mutex_enter(zs->zs_excl_hi);
zspp = &zs_prog[zs->zs_unit];
zs_program(zspp);
/*
* Enable all interrupts for this chip and delay to let chip settle
*/
SCC_WRITE(9, ZSWR9_MASTER_IE | ZSWR9_VECTOR_INCL_STAT);
DELAY(4000);
/*
* Restart receiving and transmitting
*/
zs->zs_suspended = 0;
za->za_rcv_flags_mask |= DO_TRANSMIT;
za->za_ext = 1;
ZSSETSOFT(zs);
mutex_exit(zs->zs_excl_hi);
mutex_exit(zs->zs_excl);
return (DDI_SUCCESS);
}
#ifdef ZSA_DEBUG
static void
zsa_print_info(struct zscom *zs)
{
register struct asyncline *za = (struct asyncline *)&zs->zs_priv_str;
register queue_t *q = za->za_ttycommon.t_writeq;
printf(" next q=%s\n", (RD(q))->q_next->q_qinfo->qi_minfo->mi_idname);
printf("unit=%d\n", zs->zs_unit);
printf("tflag:\n");
if (za->za_ttycommon.t_flags & TS_SOFTCAR) printf(" t_fl:TS_SOFTCAR");
if (za->za_ttycommon.t_flags & TS_XCLUDE) printf(" t_fl:TS_XCLUDE");
if (za->za_ttycommon.t_iflag & IGNBRK) printf(" t_ifl:IGNBRK");
if (za->za_ttycommon.t_iflag & BRKINT) printf(" t_ifl:BRKINT");
if (za->za_ttycommon.t_iflag & IGNPAR) printf(" t_ifl:IGNPAR");
if (za->za_ttycommon.t_iflag & PARMRK) printf(" t_ifl:PARMRK");
if (za->za_ttycommon.t_iflag & INPCK) printf(" t_ifl:INPCK");
if (za->za_ttycommon.t_iflag & ISTRIP) printf(" t_ifl:ISTRIP");
if (za->za_ttycommon.t_iflag & INLCR) printf(" t_ifl:INLCR");
if (za->za_ttycommon.t_iflag & IGNCR) printf(" t_ifl:IGNCR");
if (za->za_ttycommon.t_iflag & ICRNL) printf(" t_ifl:ICRNL");
if (za->za_ttycommon.t_iflag & IUCLC) printf(" t_ifl:IUCLC");
if (za->za_ttycommon.t_iflag & IXON) printf(" t_ifl:IXON");
if (za->za_ttycommon.t_iflag & IXOFF) printf(" t_ifl:IXOFF");
printf("\n");
if (za->za_ttycommon.t_cflag & CSIZE == CS5) printf(" t_cfl:CS5");
if (za->za_ttycommon.t_cflag & CSIZE == CS6) printf(" t_cfl:CS6");
if (za->za_ttycommon.t_cflag & CSIZE == CS7) printf(" t_cfl:CS7");
if (za->za_ttycommon.t_cflag & CSIZE == CS8) printf(" t_cfl:CS8");
if (za->za_ttycommon.t_cflag & CSTOPB) printf(" t_cfl:CSTOPB");
if (za->za_ttycommon.t_cflag & CREAD) printf(" t_cfl:CREAD");
if (za->za_ttycommon.t_cflag & PARENB) printf(" t_cfl:PARENB");
if (za->za_ttycommon.t_cflag & PARODD) printf(" t_cfl:PARODD");
if (za->za_ttycommon.t_cflag & HUPCL) printf(" t_cfl:HUPCL");
if (za->za_ttycommon.t_cflag & CLOCAL) printf(" t_cfl:CLOCAL");
printf(" t_stopc=%x", za->za_ttycommon.t_stopc);
printf("\n");
}
#endif
/*
* Check for abort character sequence
*/
static boolean_t
abort_charseq_recognize(uchar_t ch)
{
static int state = 0;
#define CNTRL(c) ((c)&037)
static char sequence[] = { '\r', '~', CNTRL('b') };
if (ch == sequence[state]) {
if (++state >= sizeof (sequence)) {
state = 0;
return (B_TRUE);
}
} else {
state = (ch == sequence[0]) ? 1 : 0;
}
return (B_FALSE);
}