17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate * CDDL HEADER START
37c478bd9Sstevel@tonic-gate *
47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the
54ab75253Smrj * Common Development and Distribution License (the "License").
64ab75253Smrj * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate *
87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate * and limitations under the License.
127c478bd9Sstevel@tonic-gate *
137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate *
197c478bd9Sstevel@tonic-gate * CDDL HEADER END
207c478bd9Sstevel@tonic-gate */
214ab75253Smrj
227c478bd9Sstevel@tonic-gate /* Copyright (c) 1990, 1991 UNIX System Laboratories, Inc. */
237c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T */
247c478bd9Sstevel@tonic-gate /* All Rights Reserved */
257c478bd9Sstevel@tonic-gate
267c478bd9Sstevel@tonic-gate /*
27cd43c54aSZach Kissel * Copyright (c) 1992, 2010, Oracle and/or its affiliates. All rights reserved.
28b97d6ca7SMilan Jurik * Copyright 2012 Milan Jurik. All rights reserved.
2948bbca81SDaniel Hoffman * Copyright (c) 2016 by Delphix. All rights reserved.
3085fe9a71SAndy Fiddaman * Copyright 2023 Oxide Computer Company
317c478bd9Sstevel@tonic-gate */
327c478bd9Sstevel@tonic-gate
337c478bd9Sstevel@tonic-gate
347c478bd9Sstevel@tonic-gate /*
357c478bd9Sstevel@tonic-gate * Serial I/O driver for 8250/16450/16550A/16650/16750 chips.
367c478bd9Sstevel@tonic-gate */
377c478bd9Sstevel@tonic-gate
387c478bd9Sstevel@tonic-gate #include <sys/param.h>
397c478bd9Sstevel@tonic-gate #include <sys/types.h>
407c478bd9Sstevel@tonic-gate #include <sys/signal.h>
417c478bd9Sstevel@tonic-gate #include <sys/stream.h>
427c478bd9Sstevel@tonic-gate #include <sys/termio.h>
437c478bd9Sstevel@tonic-gate #include <sys/errno.h>
447c478bd9Sstevel@tonic-gate #include <sys/file.h>
457c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h>
467c478bd9Sstevel@tonic-gate #include <sys/stropts.h>
477c478bd9Sstevel@tonic-gate #include <sys/strsubr.h>
487c478bd9Sstevel@tonic-gate #include <sys/strtty.h>
497c478bd9Sstevel@tonic-gate #include <sys/debug.h>
507c478bd9Sstevel@tonic-gate #include <sys/kbio.h>
517c478bd9Sstevel@tonic-gate #include <sys/cred.h>
527c478bd9Sstevel@tonic-gate #include <sys/stat.h>
537c478bd9Sstevel@tonic-gate #include <sys/consdev.h>
547c478bd9Sstevel@tonic-gate #include <sys/mkdev.h>
557c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
567c478bd9Sstevel@tonic-gate #include <sys/cred.h>
577c478bd9Sstevel@tonic-gate #include <sys/strsun.h>
587c478bd9Sstevel@tonic-gate #ifdef DEBUG
597c478bd9Sstevel@tonic-gate #include <sys/promif.h>
607c478bd9Sstevel@tonic-gate #endif
617c478bd9Sstevel@tonic-gate #include <sys/modctl.h>
627c478bd9Sstevel@tonic-gate #include <sys/ddi.h>
637c478bd9Sstevel@tonic-gate #include <sys/sunddi.h>
6456001103Smyers #include <sys/pci.h>
657c478bd9Sstevel@tonic-gate #include <sys/asy.h>
667c478bd9Sstevel@tonic-gate #include <sys/policy.h>
677c478bd9Sstevel@tonic-gate
687c478bd9Sstevel@tonic-gate /*
697c478bd9Sstevel@tonic-gate * set the RX FIFO trigger_level to half the RX FIFO size for now
707c478bd9Sstevel@tonic-gate * we may want to make this configurable later.
717c478bd9Sstevel@tonic-gate */
727c478bd9Sstevel@tonic-gate static int asy_trig_level = FIFO_TRIG_8;
737c478bd9Sstevel@tonic-gate
747c478bd9Sstevel@tonic-gate int asy_drain_check = 15000000; /* tunable: exit drain check time */
757c478bd9Sstevel@tonic-gate int asy_min_dtr_low = 500000; /* tunable: minimum DTR down time */
767c478bd9Sstevel@tonic-gate int asy_min_utbrk = 100000; /* tunable: minumum untimed brk time */
777c478bd9Sstevel@tonic-gate
787c478bd9Sstevel@tonic-gate int asymaxchip = ASY16750; /* tunable: limit chip support we look for */
797c478bd9Sstevel@tonic-gate
807c478bd9Sstevel@tonic-gate /*
817c478bd9Sstevel@tonic-gate * Just in case someone has a chip with broken loopback mode, we provide a
827c478bd9Sstevel@tonic-gate * means to disable the loopback test. By default, we only loopback test
837c478bd9Sstevel@tonic-gate * UARTs which look like they have FIFOs bigger than 16 bytes.
847c478bd9Sstevel@tonic-gate * Set to 0 to suppress test, or to 2 to enable test on any size FIFO.
857c478bd9Sstevel@tonic-gate */
867c478bd9Sstevel@tonic-gate int asy_fifo_test = 1; /* tunable: set to 0, 1, or 2 */
877c478bd9Sstevel@tonic-gate
887c478bd9Sstevel@tonic-gate /*
897c478bd9Sstevel@tonic-gate * Allow ability to switch off testing of the scratch register.
907c478bd9Sstevel@tonic-gate * Some UART emulators might not have it. This will also disable the test
917c478bd9Sstevel@tonic-gate * for Exar/Startech ST16C650, as that requires use of the SCR register.
927c478bd9Sstevel@tonic-gate */
937c478bd9Sstevel@tonic-gate int asy_scr_test = 1; /* tunable: set to 0 to disable SCR reg test */
947c478bd9Sstevel@tonic-gate
957c478bd9Sstevel@tonic-gate /*
967c478bd9Sstevel@tonic-gate * As we don't yet support on-chip flow control, it's a bad idea to put a
977c478bd9Sstevel@tonic-gate * large number of characters in the TX FIFO, since if other end tells us
987c478bd9Sstevel@tonic-gate * to stop transmitting, we can only stop filling the TX FIFO, but it will
997c478bd9Sstevel@tonic-gate * still carry on draining by itself, so remote end still gets what's left
1007c478bd9Sstevel@tonic-gate * in the FIFO.
1017c478bd9Sstevel@tonic-gate */
1027c478bd9Sstevel@tonic-gate int asy_max_tx_fifo = 16; /* tunable: max fill of TX FIFO */
1037c478bd9Sstevel@tonic-gate
1047c478bd9Sstevel@tonic-gate #define async_stopc async_ttycommon.t_stopc
1057c478bd9Sstevel@tonic-gate #define async_startc async_ttycommon.t_startc
1067c478bd9Sstevel@tonic-gate
1077c478bd9Sstevel@tonic-gate #define ASY_INIT 1
1087c478bd9Sstevel@tonic-gate #define ASY_NOINIT 0
1097c478bd9Sstevel@tonic-gate
1107c478bd9Sstevel@tonic-gate /* enum value for sw and hw flow control action */
1117c478bd9Sstevel@tonic-gate typedef enum {
1127c478bd9Sstevel@tonic-gate FLOW_CHECK,
1137c478bd9Sstevel@tonic-gate FLOW_STOP,
1147c478bd9Sstevel@tonic-gate FLOW_START
1157c478bd9Sstevel@tonic-gate } async_flowc_action;
1167c478bd9Sstevel@tonic-gate
1177c478bd9Sstevel@tonic-gate #ifdef DEBUG
1187c478bd9Sstevel@tonic-gate #define ASY_DEBUG_INIT 0x0001 /* Output msgs during driver initialization. */
1197c478bd9Sstevel@tonic-gate #define ASY_DEBUG_INPUT 0x0002 /* Report characters received during int. */
1207c478bd9Sstevel@tonic-gate #define ASY_DEBUG_EOT 0x0004 /* Output msgs when wait for xmit to finish. */
1217c478bd9Sstevel@tonic-gate #define ASY_DEBUG_CLOSE 0x0008 /* Output msgs when driver open/close called */
1227c478bd9Sstevel@tonic-gate #define ASY_DEBUG_HFLOW 0x0010 /* Output msgs when H/W flowcontrol is active */
1237c478bd9Sstevel@tonic-gate #define ASY_DEBUG_PROCS 0x0020 /* Output each proc name as it is entered. */
1247c478bd9Sstevel@tonic-gate #define ASY_DEBUG_STATE 0x0040 /* Output value of Interrupt Service Reg. */
1257c478bd9Sstevel@tonic-gate #define ASY_DEBUG_INTR 0x0080 /* Output value of Interrupt Service Reg. */
1267c478bd9Sstevel@tonic-gate #define ASY_DEBUG_OUT 0x0100 /* Output msgs about output events. */
1277c478bd9Sstevel@tonic-gate #define ASY_DEBUG_BUSY 0x0200 /* Output msgs when xmit is enabled/disabled */
1287c478bd9Sstevel@tonic-gate #define ASY_DEBUG_MODEM 0x0400 /* Output msgs about modem status & control. */
1297c478bd9Sstevel@tonic-gate #define ASY_DEBUG_MODM2 0x0800 /* Output msgs about modem status & control. */
1307c478bd9Sstevel@tonic-gate #define ASY_DEBUG_IOCTL 0x1000 /* Output msgs about ioctl messages. */
1317c478bd9Sstevel@tonic-gate #define ASY_DEBUG_CHIP 0x2000 /* Output msgs about chip identification. */
1327c478bd9Sstevel@tonic-gate #define ASY_DEBUG_SFLOW 0x4000 /* Output msgs when S/W flowcontrol is active */
1337c478bd9Sstevel@tonic-gate #define ASY_DEBUG(x) (debug & (x))
1347c478bd9Sstevel@tonic-gate static int debug = 0;
1357c478bd9Sstevel@tonic-gate #else
1367c478bd9Sstevel@tonic-gate #define ASY_DEBUG(x) B_FALSE
1377c478bd9Sstevel@tonic-gate #endif
1387c478bd9Sstevel@tonic-gate
1397c478bd9Sstevel@tonic-gate /* pnpISA compressed device ids */
1407c478bd9Sstevel@tonic-gate #define pnpMTS0219 0xb6930219 /* Multitech MT5634ZTX modem */
1417c478bd9Sstevel@tonic-gate
1427c478bd9Sstevel@tonic-gate /*
1437c478bd9Sstevel@tonic-gate * PPS (Pulse Per Second) support.
1447c478bd9Sstevel@tonic-gate */
145b97d6ca7SMilan Jurik void ddi_hardpps(struct timeval *, int);
1467c478bd9Sstevel@tonic-gate /*
1477c478bd9Sstevel@tonic-gate * This is protected by the asy_excl_hi of the port on which PPS event
1487c478bd9Sstevel@tonic-gate * handling is enabled. Note that only one port should have this enabled at
1497c478bd9Sstevel@tonic-gate * any one time. Enabling PPS handling on multiple ports will result in
1507c478bd9Sstevel@tonic-gate * unpredictable (but benign) results.
1517c478bd9Sstevel@tonic-gate */
1527c478bd9Sstevel@tonic-gate static struct ppsclockev asy_ppsev;
1537c478bd9Sstevel@tonic-gate
1547c478bd9Sstevel@tonic-gate #ifdef PPSCLOCKLED
1557c478bd9Sstevel@tonic-gate /* XXX Use these to observe PPS latencies and jitter on a scope */
1567c478bd9Sstevel@tonic-gate #define LED_ON
1577c478bd9Sstevel@tonic-gate #define LED_OFF
1587c478bd9Sstevel@tonic-gate #else
1597c478bd9Sstevel@tonic-gate #define LED_ON
1607c478bd9Sstevel@tonic-gate #define LED_OFF
1617c478bd9Sstevel@tonic-gate #endif
1627c478bd9Sstevel@tonic-gate
1637c478bd9Sstevel@tonic-gate static int max_asy_instance = -1;
1647c478bd9Sstevel@tonic-gate
1657c478bd9Sstevel@tonic-gate static uint_t asysoftintr(caddr_t intarg);
1667c478bd9Sstevel@tonic-gate static uint_t asyintr(caddr_t argasy);
1677c478bd9Sstevel@tonic-gate
1687c478bd9Sstevel@tonic-gate static boolean_t abort_charseq_recognize(uchar_t ch);
1697c478bd9Sstevel@tonic-gate
1707c478bd9Sstevel@tonic-gate /* The async interrupt entry points */
1717c478bd9Sstevel@tonic-gate static void async_txint(struct asycom *asy);
1727c478bd9Sstevel@tonic-gate static void async_rxint(struct asycom *asy, uchar_t lsr);
1737c478bd9Sstevel@tonic-gate static void async_msint(struct asycom *asy);
1747c478bd9Sstevel@tonic-gate static void async_softint(struct asycom *asy);
1757c478bd9Sstevel@tonic-gate
1767c478bd9Sstevel@tonic-gate static void async_ioctl(struct asyncline *async, queue_t *q, mblk_t *mp);
1777c478bd9Sstevel@tonic-gate static void async_reioctl(void *unit);
1787c478bd9Sstevel@tonic-gate static void async_iocdata(queue_t *q, mblk_t *mp);
1797c478bd9Sstevel@tonic-gate static void async_restart(void *arg);
1807c478bd9Sstevel@tonic-gate static void async_start(struct asyncline *async);
1817c478bd9Sstevel@tonic-gate static void async_nstart(struct asyncline *async, int mode);
1827c478bd9Sstevel@tonic-gate static void async_resume(struct asyncline *async);
1837c478bd9Sstevel@tonic-gate static void asy_program(struct asycom *asy, int mode);
1847c478bd9Sstevel@tonic-gate static void asyinit(struct asycom *asy);
1857c478bd9Sstevel@tonic-gate static void asy_waiteot(struct asycom *asy);
186281f0747Slt200341 static void asyputchar(cons_polledio_arg_t, uchar_t c);
187281f0747Slt200341 static int asygetchar(cons_polledio_arg_t);
188281f0747Slt200341 static boolean_t asyischar(cons_polledio_arg_t);
1897c478bd9Sstevel@tonic-gate
1907c478bd9Sstevel@tonic-gate static int asymctl(struct asycom *, int, int);
1917c478bd9Sstevel@tonic-gate static int asytodm(int, int);
1927c478bd9Sstevel@tonic-gate static int dmtoasy(int);
1937c478bd9Sstevel@tonic-gate /*PRINTFLIKE2*/
1947c478bd9Sstevel@tonic-gate static void asyerror(int level, const char *fmt, ...) __KPRINTFLIKE(2);
1957c478bd9Sstevel@tonic-gate static void asy_parse_mode(dev_info_t *devi, struct asycom *asy);
1967c478bd9Sstevel@tonic-gate static void asy_soft_state_free(struct asycom *);
1977c478bd9Sstevel@tonic-gate static char *asy_hw_name(struct asycom *asy);
1987c478bd9Sstevel@tonic-gate static void async_hold_utbrk(void *arg);
1997c478bd9Sstevel@tonic-gate static void async_resume_utbrk(struct asyncline *async);
2007c478bd9Sstevel@tonic-gate static void async_dtr_free(struct asyncline *async);
2017c478bd9Sstevel@tonic-gate static int asy_identify_chip(dev_info_t *devi, struct asycom *asy);
2027c478bd9Sstevel@tonic-gate static void asy_reset_fifo(struct asycom *asy, uchar_t flags);
2037c478bd9Sstevel@tonic-gate static int asy_getproperty(dev_info_t *devi, struct asycom *asy,
2047c478bd9Sstevel@tonic-gate const char *property);
2057c478bd9Sstevel@tonic-gate static boolean_t async_flowcontrol_sw_input(struct asycom *asy,
2067c478bd9Sstevel@tonic-gate async_flowc_action onoff, int type);
2077c478bd9Sstevel@tonic-gate static void async_flowcontrol_sw_output(struct asycom *asy,
2087c478bd9Sstevel@tonic-gate async_flowc_action onoff);
2097c478bd9Sstevel@tonic-gate static void async_flowcontrol_hw_input(struct asycom *asy,
2107c478bd9Sstevel@tonic-gate async_flowc_action onoff, int type);
2117c478bd9Sstevel@tonic-gate static void async_flowcontrol_hw_output(struct asycom *asy,
2127c478bd9Sstevel@tonic-gate async_flowc_action onoff);
2137c478bd9Sstevel@tonic-gate
2147c478bd9Sstevel@tonic-gate #define GET_PROP(devi, pname, pflag, pval, plen) \
2157c478bd9Sstevel@tonic-gate (ddi_prop_op(DDI_DEV_T_ANY, (devi), PROP_LEN_AND_VAL_BUF, \
2167c478bd9Sstevel@tonic-gate (pflag), (pname), (caddr_t)(pval), (plen)))
2177c478bd9Sstevel@tonic-gate
2187c478bd9Sstevel@tonic-gate kmutex_t asy_glob_lock; /* lock protecting global data manipulation */
2197c478bd9Sstevel@tonic-gate void *asy_soft_state;
2207c478bd9Sstevel@tonic-gate
2217c478bd9Sstevel@tonic-gate /* Standard COM port I/O addresses */
2227c478bd9Sstevel@tonic-gate static const int standard_com_ports[] = {
2237c478bd9Sstevel@tonic-gate COM1_IOADDR, COM2_IOADDR, COM3_IOADDR, COM4_IOADDR
2247c478bd9Sstevel@tonic-gate };
2257c478bd9Sstevel@tonic-gate
2267c478bd9Sstevel@tonic-gate static int *com_ports;
2277c478bd9Sstevel@tonic-gate static uint_t num_com_ports;
2287c478bd9Sstevel@tonic-gate
2292df1fe9cSrandyf #ifdef DEBUG
2302df1fe9cSrandyf /*
2312df1fe9cSrandyf * Set this to true to make the driver pretend to do a suspend. Useful
2322df1fe9cSrandyf * for debugging suspend/resume code with a serial debugger.
2332df1fe9cSrandyf */
2342df1fe9cSrandyf boolean_t asy_nosuspend = B_FALSE;
2352df1fe9cSrandyf #endif
2362df1fe9cSrandyf
2372df1fe9cSrandyf
2387c478bd9Sstevel@tonic-gate /*
2397c478bd9Sstevel@tonic-gate * Baud rate table. Indexed by #defines found in sys/termios.h
2407c478bd9Sstevel@tonic-gate */
2417c478bd9Sstevel@tonic-gate ushort_t asyspdtab[] = {
2427c478bd9Sstevel@tonic-gate 0, /* 0 baud rate */
2437c478bd9Sstevel@tonic-gate 0x900, /* 50 baud rate */
2447c478bd9Sstevel@tonic-gate 0x600, /* 75 baud rate */
2457c478bd9Sstevel@tonic-gate 0x417, /* 110 baud rate (%0.026) */
2467c478bd9Sstevel@tonic-gate 0x359, /* 134 baud rate (%0.058) */
2477c478bd9Sstevel@tonic-gate 0x300, /* 150 baud rate */
2487c478bd9Sstevel@tonic-gate 0x240, /* 200 baud rate */
2497c478bd9Sstevel@tonic-gate 0x180, /* 300 baud rate */
2507c478bd9Sstevel@tonic-gate 0x0c0, /* 600 baud rate */
2517c478bd9Sstevel@tonic-gate 0x060, /* 1200 baud rate */
2527c478bd9Sstevel@tonic-gate 0x040, /* 1800 baud rate */
2537c478bd9Sstevel@tonic-gate 0x030, /* 2400 baud rate */
2547c478bd9Sstevel@tonic-gate 0x018, /* 4800 baud rate */
2557c478bd9Sstevel@tonic-gate 0x00c, /* 9600 baud rate */
2567c478bd9Sstevel@tonic-gate 0x006, /* 19200 baud rate */
2577c478bd9Sstevel@tonic-gate 0x003, /* 38400 baud rate */
2587c478bd9Sstevel@tonic-gate
2597c478bd9Sstevel@tonic-gate 0x002, /* 57600 baud rate */
2607c478bd9Sstevel@tonic-gate 0x0, /* 76800 baud rate not supported */
2617c478bd9Sstevel@tonic-gate 0x001, /* 115200 baud rate */
2627c478bd9Sstevel@tonic-gate 0x0, /* 153600 baud rate not supported */
2637c478bd9Sstevel@tonic-gate 0x0, /* 0x8002 (SMC chip) 230400 baud rate not supported */
2647c478bd9Sstevel@tonic-gate 0x0, /* 307200 baud rate not supported */
2657c478bd9Sstevel@tonic-gate 0x0, /* 0x8001 (SMC chip) 460800 baud rate not supported */
266d9c3e05cSJoshua M. Clulow 0x0, /* 921600 baud rate not supported */
267d9c3e05cSJoshua M. Clulow 0x0, /* 1000000 baud rate not supported */
268d9c3e05cSJoshua M. Clulow 0x0, /* 1152000 baud rate not supported */
269d9c3e05cSJoshua M. Clulow 0x0, /* 1500000 baud rate not supported */
270d9c3e05cSJoshua M. Clulow 0x0, /* 2000000 baud rate not supported */
271d9c3e05cSJoshua M. Clulow 0x0, /* 2500000 baud rate not supported */
272d9c3e05cSJoshua M. Clulow 0x0, /* 3000000 baud rate not supported */
273d9c3e05cSJoshua M. Clulow 0x0, /* 3500000 baud rate not supported */
274d9c3e05cSJoshua M. Clulow 0x0, /* 4000000 baud rate not supported */
2757c478bd9Sstevel@tonic-gate };
2767c478bd9Sstevel@tonic-gate
2777c478bd9Sstevel@tonic-gate static int asyrsrv(queue_t *q);
2787c478bd9Sstevel@tonic-gate static int asyopen(queue_t *rq, dev_t *dev, int flag, int sflag, cred_t *cr);
2797c478bd9Sstevel@tonic-gate static int asyclose(queue_t *q, int flag, cred_t *credp);
2802df1fe9cSrandyf static int asywputdo(queue_t *q, mblk_t *mp, boolean_t);
2817c478bd9Sstevel@tonic-gate static int asywput(queue_t *q, mblk_t *mp);
2827c478bd9Sstevel@tonic-gate
2837c478bd9Sstevel@tonic-gate struct module_info asy_info = {
2847c478bd9Sstevel@tonic-gate 0,
2857c478bd9Sstevel@tonic-gate "asy",
2867c478bd9Sstevel@tonic-gate 0,
2877c478bd9Sstevel@tonic-gate INFPSZ,
2887c478bd9Sstevel@tonic-gate 4096,
2897c478bd9Sstevel@tonic-gate 128
2907c478bd9Sstevel@tonic-gate };
2917c478bd9Sstevel@tonic-gate
2927c478bd9Sstevel@tonic-gate static struct qinit asy_rint = {
2937c478bd9Sstevel@tonic-gate putq,
2947c478bd9Sstevel@tonic-gate asyrsrv,
2957c478bd9Sstevel@tonic-gate asyopen,
2967c478bd9Sstevel@tonic-gate asyclose,
2977c478bd9Sstevel@tonic-gate NULL,
2987c478bd9Sstevel@tonic-gate &asy_info,
2997c478bd9Sstevel@tonic-gate NULL
3007c478bd9Sstevel@tonic-gate };
3017c478bd9Sstevel@tonic-gate
3027c478bd9Sstevel@tonic-gate static struct qinit asy_wint = {
3037c478bd9Sstevel@tonic-gate asywput,
3047c478bd9Sstevel@tonic-gate NULL,
3057c478bd9Sstevel@tonic-gate NULL,
3067c478bd9Sstevel@tonic-gate NULL,
3077c478bd9Sstevel@tonic-gate NULL,
3087c478bd9Sstevel@tonic-gate &asy_info,
3097c478bd9Sstevel@tonic-gate NULL
3107c478bd9Sstevel@tonic-gate };
3117c478bd9Sstevel@tonic-gate
3127c478bd9Sstevel@tonic-gate struct streamtab asy_str_info = {
3137c478bd9Sstevel@tonic-gate &asy_rint,
3147c478bd9Sstevel@tonic-gate &asy_wint,
3157c478bd9Sstevel@tonic-gate NULL,
3167c478bd9Sstevel@tonic-gate NULL
3177c478bd9Sstevel@tonic-gate };
3187c478bd9Sstevel@tonic-gate
3197c478bd9Sstevel@tonic-gate static int asyinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
3207c478bd9Sstevel@tonic-gate void **result);
3217c478bd9Sstevel@tonic-gate static int asyprobe(dev_info_t *);
3227c478bd9Sstevel@tonic-gate static int asyattach(dev_info_t *, ddi_attach_cmd_t);
3237c478bd9Sstevel@tonic-gate static int asydetach(dev_info_t *, ddi_detach_cmd_t);
32419397407SSherry Moore static int asyquiesce(dev_info_t *);
3257c478bd9Sstevel@tonic-gate
3267c478bd9Sstevel@tonic-gate static struct cb_ops cb_asy_ops = {
3277c478bd9Sstevel@tonic-gate nodev, /* cb_open */
3287c478bd9Sstevel@tonic-gate nodev, /* cb_close */
3297c478bd9Sstevel@tonic-gate nodev, /* cb_strategy */
3307c478bd9Sstevel@tonic-gate nodev, /* cb_print */
3317c478bd9Sstevel@tonic-gate nodev, /* cb_dump */
3327c478bd9Sstevel@tonic-gate nodev, /* cb_read */
3337c478bd9Sstevel@tonic-gate nodev, /* cb_write */
3347c478bd9Sstevel@tonic-gate nodev, /* cb_ioctl */
3357c478bd9Sstevel@tonic-gate nodev, /* cb_devmap */
3367c478bd9Sstevel@tonic-gate nodev, /* cb_mmap */
3377c478bd9Sstevel@tonic-gate nodev, /* cb_segmap */
3387c478bd9Sstevel@tonic-gate nochpoll, /* cb_chpoll */
3397c478bd9Sstevel@tonic-gate ddi_prop_op, /* cb_prop_op */
3407c478bd9Sstevel@tonic-gate &asy_str_info, /* cb_stream */
3417c478bd9Sstevel@tonic-gate D_MP /* cb_flag */
3427c478bd9Sstevel@tonic-gate };
3437c478bd9Sstevel@tonic-gate
3447c478bd9Sstevel@tonic-gate struct dev_ops asy_ops = {
3457c478bd9Sstevel@tonic-gate DEVO_REV, /* devo_rev */
3467c478bd9Sstevel@tonic-gate 0, /* devo_refcnt */
3477c478bd9Sstevel@tonic-gate asyinfo, /* devo_getinfo */
3487c478bd9Sstevel@tonic-gate nulldev, /* devo_identify */
3497c478bd9Sstevel@tonic-gate asyprobe, /* devo_probe */
3507c478bd9Sstevel@tonic-gate asyattach, /* devo_attach */
3517c478bd9Sstevel@tonic-gate asydetach, /* devo_detach */
3527c478bd9Sstevel@tonic-gate nodev, /* devo_reset */
3537c478bd9Sstevel@tonic-gate &cb_asy_ops, /* devo_cb_ops */
35419397407SSherry Moore NULL, /* devo_bus_ops */
35519397407SSherry Moore NULL, /* power */
35619397407SSherry Moore asyquiesce, /* quiesce */
3577c478bd9Sstevel@tonic-gate };
3587c478bd9Sstevel@tonic-gate
3597c478bd9Sstevel@tonic-gate static struct modldrv modldrv = {
3607c478bd9Sstevel@tonic-gate &mod_driverops, /* Type of module. This one is a driver */
36119397407SSherry Moore "ASY driver",
3627c478bd9Sstevel@tonic-gate &asy_ops, /* driver ops */
3637c478bd9Sstevel@tonic-gate };
3647c478bd9Sstevel@tonic-gate
3657c478bd9Sstevel@tonic-gate static struct modlinkage modlinkage = {
3667c478bd9Sstevel@tonic-gate MODREV_1,
3677c478bd9Sstevel@tonic-gate (void *)&modldrv,
3687c478bd9Sstevel@tonic-gate NULL
3697c478bd9Sstevel@tonic-gate };
3707c478bd9Sstevel@tonic-gate
3717c478bd9Sstevel@tonic-gate int
_init(void)3727c478bd9Sstevel@tonic-gate _init(void)
3737c478bd9Sstevel@tonic-gate {
3747c478bd9Sstevel@tonic-gate int i;
3757c478bd9Sstevel@tonic-gate
3767c478bd9Sstevel@tonic-gate i = ddi_soft_state_init(&asy_soft_state, sizeof (struct asycom), 2);
3777c478bd9Sstevel@tonic-gate if (i == 0) {
3787c478bd9Sstevel@tonic-gate mutex_init(&asy_glob_lock, NULL, MUTEX_DRIVER, NULL);
3797c478bd9Sstevel@tonic-gate if ((i = mod_install(&modlinkage)) != 0) {
3807c478bd9Sstevel@tonic-gate mutex_destroy(&asy_glob_lock);
3817c478bd9Sstevel@tonic-gate ddi_soft_state_fini(&asy_soft_state);
3827c478bd9Sstevel@tonic-gate } else {
3837c478bd9Sstevel@tonic-gate DEBUGCONT2(ASY_DEBUG_INIT, "%s, debug = %x\n",
3847c478bd9Sstevel@tonic-gate modldrv.drv_linkinfo, debug);
3857c478bd9Sstevel@tonic-gate }
3867c478bd9Sstevel@tonic-gate }
3877c478bd9Sstevel@tonic-gate return (i);
3887c478bd9Sstevel@tonic-gate }
3897c478bd9Sstevel@tonic-gate
3907c478bd9Sstevel@tonic-gate int
_fini(void)3917c478bd9Sstevel@tonic-gate _fini(void)
3927c478bd9Sstevel@tonic-gate {
3937c478bd9Sstevel@tonic-gate int i;
3947c478bd9Sstevel@tonic-gate
3957c478bd9Sstevel@tonic-gate if ((i = mod_remove(&modlinkage)) == 0) {
3967c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_INIT, "%s unloading\n",
3977c478bd9Sstevel@tonic-gate modldrv.drv_linkinfo);
3987c478bd9Sstevel@tonic-gate ASSERT(max_asy_instance == -1);
3997c478bd9Sstevel@tonic-gate mutex_destroy(&asy_glob_lock);
4007c478bd9Sstevel@tonic-gate /* free "motherboard-serial-ports" property if allocated */
4017c478bd9Sstevel@tonic-gate if (com_ports != NULL && com_ports != (int *)standard_com_ports)
4027c478bd9Sstevel@tonic-gate ddi_prop_free(com_ports);
4037c478bd9Sstevel@tonic-gate com_ports = NULL;
4047c478bd9Sstevel@tonic-gate ddi_soft_state_fini(&asy_soft_state);
4057c478bd9Sstevel@tonic-gate }
4067c478bd9Sstevel@tonic-gate return (i);
4077c478bd9Sstevel@tonic-gate }
4087c478bd9Sstevel@tonic-gate
4097c478bd9Sstevel@tonic-gate int
_info(struct modinfo * modinfop)4107c478bd9Sstevel@tonic-gate _info(struct modinfo *modinfop)
4117c478bd9Sstevel@tonic-gate {
4127c478bd9Sstevel@tonic-gate return (mod_info(&modlinkage, modinfop));
4137c478bd9Sstevel@tonic-gate }
4147c478bd9Sstevel@tonic-gate
4152df1fe9cSrandyf void
async_put_suspq(struct asycom * asy,mblk_t * mp)4162df1fe9cSrandyf async_put_suspq(struct asycom *asy, mblk_t *mp)
4172df1fe9cSrandyf {
4182df1fe9cSrandyf struct asyncline *async = asy->asy_priv;
4192df1fe9cSrandyf
4202df1fe9cSrandyf ASSERT(mutex_owned(&asy->asy_excl));
4212df1fe9cSrandyf
4222df1fe9cSrandyf if (async->async_suspqf == NULL)
4232df1fe9cSrandyf async->async_suspqf = mp;
4242df1fe9cSrandyf else
4252df1fe9cSrandyf async->async_suspqb->b_next = mp;
4262df1fe9cSrandyf
4272df1fe9cSrandyf async->async_suspqb = mp;
4282df1fe9cSrandyf }
4292df1fe9cSrandyf
4302df1fe9cSrandyf static mblk_t *
async_get_suspq(struct asycom * asy)4312df1fe9cSrandyf async_get_suspq(struct asycom *asy)
4322df1fe9cSrandyf {
4332df1fe9cSrandyf struct asyncline *async = asy->asy_priv;
4342df1fe9cSrandyf mblk_t *mp;
4352df1fe9cSrandyf
4362df1fe9cSrandyf ASSERT(mutex_owned(&asy->asy_excl));
4372df1fe9cSrandyf
4382df1fe9cSrandyf if ((mp = async->async_suspqf) != NULL) {
4392df1fe9cSrandyf async->async_suspqf = mp->b_next;
4402df1fe9cSrandyf mp->b_next = NULL;
4412df1fe9cSrandyf } else {
4422df1fe9cSrandyf async->async_suspqb = NULL;
4432df1fe9cSrandyf }
4442df1fe9cSrandyf return (mp);
4452df1fe9cSrandyf }
4462df1fe9cSrandyf
4472df1fe9cSrandyf static void
async_process_suspq(struct asycom * asy)4482df1fe9cSrandyf async_process_suspq(struct asycom *asy)
4492df1fe9cSrandyf {
4502df1fe9cSrandyf struct asyncline *async = asy->asy_priv;
4512df1fe9cSrandyf mblk_t *mp;
4522df1fe9cSrandyf
4532df1fe9cSrandyf ASSERT(mutex_owned(&asy->asy_excl));
4542df1fe9cSrandyf
4552df1fe9cSrandyf while ((mp = async_get_suspq(asy)) != NULL) {
4562df1fe9cSrandyf queue_t *q;
4572df1fe9cSrandyf
4582df1fe9cSrandyf q = async->async_ttycommon.t_writeq;
4592df1fe9cSrandyf ASSERT(q != NULL);
4602df1fe9cSrandyf mutex_exit(&asy->asy_excl);
4612df1fe9cSrandyf (void) asywputdo(q, mp, B_FALSE);
4622df1fe9cSrandyf mutex_enter(&asy->asy_excl);
4632df1fe9cSrandyf }
4642df1fe9cSrandyf async->async_flags &= ~ASYNC_DDI_SUSPENDED;
4652df1fe9cSrandyf cv_broadcast(&async->async_flags_cv);
4662df1fe9cSrandyf }
4672df1fe9cSrandyf
4687c478bd9Sstevel@tonic-gate static int
asy_get_bus_type(dev_info_t * devinfo)46956001103Smyers asy_get_bus_type(dev_info_t *devinfo)
47056001103Smyers {
47156001103Smyers char parent_type[16];
47256001103Smyers int parentlen;
47356001103Smyers
47456001103Smyers parentlen = sizeof (parent_type);
47556001103Smyers
47656001103Smyers if (ddi_prop_op(DDI_DEV_T_ANY, devinfo, PROP_LEN_AND_VAL_BUF, 0,
47756001103Smyers "device_type", (caddr_t)parent_type, &parentlen)
47856001103Smyers != DDI_PROP_SUCCESS && ddi_prop_op(DDI_DEV_T_ANY, devinfo,
47956001103Smyers PROP_LEN_AND_VAL_BUF, 0, "bus-type", (caddr_t)parent_type,
48056001103Smyers &parentlen) != DDI_PROP_SUCCESS) {
48156001103Smyers cmn_err(CE_WARN,
48256001103Smyers "asy: can't figure out device type for"
48356001103Smyers " parent \"%s\"",
48456001103Smyers ddi_get_name(ddi_get_parent(devinfo)));
48556001103Smyers return (ASY_BUS_UNKNOWN);
48656001103Smyers }
48756001103Smyers if (strcmp(parent_type, "isa") == 0)
48856001103Smyers return (ASY_BUS_ISA);
48956001103Smyers else if (strcmp(parent_type, "pci") == 0)
49056001103Smyers return (ASY_BUS_PCI);
49156001103Smyers else
49256001103Smyers return (ASY_BUS_UNKNOWN);
49356001103Smyers }
49456001103Smyers
49556001103Smyers static int
asy_get_io_regnum_pci(dev_info_t * devi,struct asycom * asy)49656001103Smyers asy_get_io_regnum_pci(dev_info_t *devi, struct asycom *asy)
49756001103Smyers {
49856001103Smyers int reglen, nregs;
49956001103Smyers int regnum, i;
50056001103Smyers uint64_t size;
50156001103Smyers struct pci_phys_spec *reglist;
50256001103Smyers
50356001103Smyers if (ddi_getlongprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
50456001103Smyers "reg", (caddr_t)®list, ®len) != DDI_PROP_SUCCESS) {
50556001103Smyers cmn_err(CE_WARN, "asy_get_io_regnum_pci: reg property"
50656001103Smyers " not found in devices property list");
50756001103Smyers return (-1);
50856001103Smyers }
50956001103Smyers
51056001103Smyers /*
51156001103Smyers * PCI devices are assumed to not have broken FIFOs;
51256001103Smyers * Agere/Lucent Venus PCI modem chipsets are an example
51356001103Smyers */
51456001103Smyers if (asy)
51556001103Smyers asy->asy_flags2 |= ASY2_NO_LOOPBACK;
51656001103Smyers
51756001103Smyers regnum = -1;
51856001103Smyers nregs = reglen / sizeof (*reglist);
51956001103Smyers for (i = 0; i < nregs; i++) {
52056001103Smyers switch (reglist[i].pci_phys_hi & PCI_ADDR_MASK) {
52156001103Smyers case PCI_ADDR_IO: /* I/O bus reg property */
52256001103Smyers if (regnum == -1) /* use only the first one */
52356001103Smyers regnum = i;
52456001103Smyers break;
52556001103Smyers
52656001103Smyers default:
52756001103Smyers break;
52856001103Smyers }
52956001103Smyers }
53056001103Smyers
53156001103Smyers /* check for valid count of registers */
53256001103Smyers if (regnum >= 0) {
53356001103Smyers size = ((uint64_t)reglist[regnum].pci_size_low) |
53456001103Smyers ((uint64_t)reglist[regnum].pci_size_hi) << 32;
53556001103Smyers if (size < 8)
53656001103Smyers regnum = -1;
53756001103Smyers }
53856001103Smyers kmem_free(reglist, reglen);
53956001103Smyers return (regnum);
54056001103Smyers }
54156001103Smyers
54256001103Smyers static int
asy_get_io_regnum_isa(dev_info_t * devi,struct asycom * asy)54356001103Smyers asy_get_io_regnum_isa(dev_info_t *devi, struct asycom *asy)
54456001103Smyers {
54556001103Smyers int reglen, nregs;
54656001103Smyers int regnum, i;
54756001103Smyers struct {
54856001103Smyers uint_t bustype;
54956001103Smyers int base;
55056001103Smyers int size;
55156001103Smyers } *reglist;
55256001103Smyers
55356001103Smyers if (ddi_getlongprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
55456001103Smyers "reg", (caddr_t)®list, ®len) != DDI_PROP_SUCCESS) {
55556001103Smyers cmn_err(CE_WARN, "asy_get_io_regnum: reg property not found "
55656001103Smyers "in devices property list");
55756001103Smyers return (-1);
55856001103Smyers }
55956001103Smyers
56056001103Smyers regnum = -1;
56156001103Smyers nregs = reglen / sizeof (*reglist);
56256001103Smyers for (i = 0; i < nregs; i++) {
56356001103Smyers switch (reglist[i].bustype) {
56456001103Smyers case 1: /* I/O bus reg property */
56556001103Smyers if (regnum == -1) /* only use the first one */
56656001103Smyers regnum = i;
56756001103Smyers break;
56856001103Smyers
56956001103Smyers case pnpMTS0219: /* Multitech MT5634ZTX modem */
57056001103Smyers /* Venus chipset can't do loopback test */
57156001103Smyers if (asy)
57256001103Smyers asy->asy_flags2 |= ASY2_NO_LOOPBACK;
57356001103Smyers break;
57456001103Smyers
57556001103Smyers default:
57656001103Smyers break;
57756001103Smyers }
57856001103Smyers }
57956001103Smyers
58056001103Smyers /* check for valid count of registers */
58156001103Smyers if ((regnum < 0) || (reglist[regnum].size < 8))
58256001103Smyers regnum = -1;
58356001103Smyers kmem_free(reglist, reglen);
58456001103Smyers return (regnum);
58556001103Smyers }
58656001103Smyers
58756001103Smyers static int
asy_get_io_regnum(dev_info_t * devinfo,struct asycom * asy)58856001103Smyers asy_get_io_regnum(dev_info_t *devinfo, struct asycom *asy)
58956001103Smyers {
59056001103Smyers switch (asy_get_bus_type(devinfo)) {
59156001103Smyers case ASY_BUS_ISA:
59256001103Smyers return (asy_get_io_regnum_isa(devinfo, asy));
59356001103Smyers case ASY_BUS_PCI:
59456001103Smyers return (asy_get_io_regnum_pci(devinfo, asy));
59556001103Smyers default:
59656001103Smyers return (-1);
59756001103Smyers }
59856001103Smyers }
59956001103Smyers
60056001103Smyers static int
asydetach(dev_info_t * devi,ddi_detach_cmd_t cmd)6017c478bd9Sstevel@tonic-gate asydetach(dev_info_t *devi, ddi_detach_cmd_t cmd)
6027c478bd9Sstevel@tonic-gate {
6037c478bd9Sstevel@tonic-gate int instance;
6047c478bd9Sstevel@tonic-gate struct asycom *asy;
6057c478bd9Sstevel@tonic-gate struct asyncline *async;
6067c478bd9Sstevel@tonic-gate
6077c478bd9Sstevel@tonic-gate instance = ddi_get_instance(devi); /* find out which unit */
6087c478bd9Sstevel@tonic-gate
6097c478bd9Sstevel@tonic-gate asy = ddi_get_soft_state(asy_soft_state, instance);
6107c478bd9Sstevel@tonic-gate if (asy == NULL)
6117c478bd9Sstevel@tonic-gate return (DDI_FAILURE);
6127c478bd9Sstevel@tonic-gate async = asy->asy_priv;
6137c478bd9Sstevel@tonic-gate
6142df1fe9cSrandyf switch (cmd) {
6152df1fe9cSrandyf case DDI_DETACH:
6167c478bd9Sstevel@tonic-gate DEBUGNOTE2(ASY_DEBUG_INIT, "asy%d: %s shutdown.",
6177c478bd9Sstevel@tonic-gate instance, asy_hw_name(asy));
6187c478bd9Sstevel@tonic-gate
6197c478bd9Sstevel@tonic-gate /* cancel DTR hold timeout */
6207c478bd9Sstevel@tonic-gate if (async->async_dtrtid != 0) {
6217c478bd9Sstevel@tonic-gate (void) untimeout(async->async_dtrtid);
6227c478bd9Sstevel@tonic-gate async->async_dtrtid = 0;
6237c478bd9Sstevel@tonic-gate }
6247c478bd9Sstevel@tonic-gate
6257c478bd9Sstevel@tonic-gate /* remove all minor device node(s) for this device */
6267c478bd9Sstevel@tonic-gate ddi_remove_minor_node(devi, NULL);
6277c478bd9Sstevel@tonic-gate
6287c478bd9Sstevel@tonic-gate mutex_destroy(&asy->asy_excl);
6297c478bd9Sstevel@tonic-gate mutex_destroy(&asy->asy_excl_hi);
6307c478bd9Sstevel@tonic-gate cv_destroy(&async->async_flags_cv);
6317c478bd9Sstevel@tonic-gate ddi_remove_intr(devi, 0, asy->asy_iblock);
6327c478bd9Sstevel@tonic-gate ddi_regs_map_free(&asy->asy_iohandle);
633cd43c54aSZach Kissel ddi_remove_softintr(asy->asy_softintr_id);
634cd43c54aSZach Kissel mutex_destroy(&asy->asy_soft_lock);
6357c478bd9Sstevel@tonic-gate asy_soft_state_free(asy);
6362df1fe9cSrandyf DEBUGNOTE1(ASY_DEBUG_INIT, "asy%d: shutdown complete",
6372df1fe9cSrandyf instance);
6382df1fe9cSrandyf break;
6392df1fe9cSrandyf case DDI_SUSPEND:
6402df1fe9cSrandyf {
6412df1fe9cSrandyf unsigned i;
6422df1fe9cSrandyf uchar_t lsr;
6432df1fe9cSrandyf
6442df1fe9cSrandyf #ifdef DEBUG
6452df1fe9cSrandyf if (asy_nosuspend)
6462df1fe9cSrandyf return (DDI_SUCCESS);
6472df1fe9cSrandyf #endif
6482df1fe9cSrandyf mutex_enter(&asy->asy_excl);
6492df1fe9cSrandyf
6502df1fe9cSrandyf ASSERT(async->async_ops >= 0);
6512df1fe9cSrandyf while (async->async_ops > 0)
6522df1fe9cSrandyf cv_wait(&async->async_ops_cv, &asy->asy_excl);
6532df1fe9cSrandyf
6542df1fe9cSrandyf async->async_flags |= ASYNC_DDI_SUSPENDED;
6552df1fe9cSrandyf
6562df1fe9cSrandyf /* Wait for timed break and delay to complete */
6572df1fe9cSrandyf while ((async->async_flags & (ASYNC_BREAK|ASYNC_DELAY))) {
6582df1fe9cSrandyf if (cv_wait_sig(&async->async_flags_cv, &asy->asy_excl)
6592df1fe9cSrandyf == 0) {
6602df1fe9cSrandyf async_process_suspq(asy);
6612df1fe9cSrandyf mutex_exit(&asy->asy_excl);
6622df1fe9cSrandyf return (DDI_FAILURE);
6632df1fe9cSrandyf }
6642df1fe9cSrandyf }
6652df1fe9cSrandyf
6662df1fe9cSrandyf /* Clear untimed break */
6672df1fe9cSrandyf if (async->async_flags & ASYNC_OUT_SUSPEND)
6682df1fe9cSrandyf async_resume_utbrk(async);
6692df1fe9cSrandyf
6702df1fe9cSrandyf mutex_exit(&asy->asy_excl);
6712df1fe9cSrandyf
6722df1fe9cSrandyf mutex_enter(&asy->asy_soft_sr);
6732df1fe9cSrandyf mutex_enter(&asy->asy_excl);
6742df1fe9cSrandyf if (async->async_wbufcid != 0) {
6752df1fe9cSrandyf bufcall_id_t bcid = async->async_wbufcid;
6762df1fe9cSrandyf async->async_wbufcid = 0;
6772df1fe9cSrandyf async->async_flags |= ASYNC_RESUME_BUFCALL;
6782df1fe9cSrandyf mutex_exit(&asy->asy_excl);
6792df1fe9cSrandyf unbufcall(bcid);
6802df1fe9cSrandyf mutex_enter(&asy->asy_excl);
6812df1fe9cSrandyf }
6822df1fe9cSrandyf mutex_enter(&asy->asy_excl_hi);
6832df1fe9cSrandyf
6842df1fe9cSrandyf /* Disable interrupts from chip */
6852df1fe9cSrandyf ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
6862df1fe9cSrandyf asy->asy_flags |= ASY_DDI_SUSPENDED;
6872df1fe9cSrandyf
68857ec6c03SZach Kissel /*
68957ec6c03SZach Kissel * Hardware interrupts are disabled we can drop our high level
69057ec6c03SZach Kissel * lock and proceed.
69157ec6c03SZach Kissel */
69257ec6c03SZach Kissel mutex_exit(&asy->asy_excl_hi);
69357ec6c03SZach Kissel
6942df1fe9cSrandyf /* Process remaining RX characters and RX errors, if any */
6952df1fe9cSrandyf lsr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR);
6962df1fe9cSrandyf async_rxint(asy, lsr);
6972df1fe9cSrandyf
6982df1fe9cSrandyf /* Wait for TX to drain */
6992df1fe9cSrandyf for (i = 1000; i > 0; i--) {
7002df1fe9cSrandyf lsr = ddi_get8(asy->asy_iohandle,
7012df1fe9cSrandyf asy->asy_ioaddr + LSR);
7022df1fe9cSrandyf if ((lsr & (XSRE | XHRE)) == (XSRE | XHRE))
7032df1fe9cSrandyf break;
7042df1fe9cSrandyf delay(drv_usectohz(10000));
7052df1fe9cSrandyf }
7062df1fe9cSrandyf if (i == 0)
7072df1fe9cSrandyf cmn_err(CE_WARN,
7082df1fe9cSrandyf "asy: transmitter wasn't drained before "
7092df1fe9cSrandyf "driver was suspended");
7102df1fe9cSrandyf
7112df1fe9cSrandyf mutex_exit(&asy->asy_excl);
7122df1fe9cSrandyf mutex_exit(&asy->asy_soft_sr);
7132df1fe9cSrandyf break;
7142df1fe9cSrandyf }
7152df1fe9cSrandyf default:
7162df1fe9cSrandyf return (DDI_FAILURE);
7172df1fe9cSrandyf }
7182df1fe9cSrandyf
7197c478bd9Sstevel@tonic-gate return (DDI_SUCCESS);
7207c478bd9Sstevel@tonic-gate }
7217c478bd9Sstevel@tonic-gate
7227c478bd9Sstevel@tonic-gate /*
7237c478bd9Sstevel@tonic-gate * asyprobe
7247c478bd9Sstevel@tonic-gate * We don't bother probing for the hardware, as since Solaris 2.6, device
7257c478bd9Sstevel@tonic-gate * nodes are only created for auto-detected hardware or nodes explicitly
7267c478bd9Sstevel@tonic-gate * created by the user, e.g. via the DCA. However, we should check the
7277c478bd9Sstevel@tonic-gate * device node is at least vaguely usable, i.e. we have a block of 8 i/o
7287c478bd9Sstevel@tonic-gate * ports. This prevents attempting to attach to bogus serial ports which
7297c478bd9Sstevel@tonic-gate * some BIOSs still partially report when they are disabled in the BIOS.
7307c478bd9Sstevel@tonic-gate */
7317c478bd9Sstevel@tonic-gate static int
asyprobe(dev_info_t * devi)7327c478bd9Sstevel@tonic-gate asyprobe(dev_info_t *devi)
7337c478bd9Sstevel@tonic-gate {
73456001103Smyers return ((asy_get_io_regnum(devi, NULL) < 0) ?
73556001103Smyers DDI_PROBE_FAILURE : DDI_PROBE_DONTCARE);
7367c478bd9Sstevel@tonic-gate }
7377c478bd9Sstevel@tonic-gate
7387c478bd9Sstevel@tonic-gate static int
asyattach(dev_info_t * devi,ddi_attach_cmd_t cmd)7397c478bd9Sstevel@tonic-gate asyattach(dev_info_t *devi, ddi_attach_cmd_t cmd)
7407c478bd9Sstevel@tonic-gate {
7417c478bd9Sstevel@tonic-gate int instance;
7427c478bd9Sstevel@tonic-gate int mcr;
7437c478bd9Sstevel@tonic-gate int ret;
7447c478bd9Sstevel@tonic-gate int regnum = 0;
7457c478bd9Sstevel@tonic-gate int i;
7467c478bd9Sstevel@tonic-gate struct asycom *asy;
74756001103Smyers char name[ASY_MINOR_LEN];
7487c478bd9Sstevel@tonic-gate int status;
7497c478bd9Sstevel@tonic-gate static ddi_device_acc_attr_t ioattr = {
7507c478bd9Sstevel@tonic-gate DDI_DEVICE_ATTR_V0,
7517c478bd9Sstevel@tonic-gate DDI_NEVERSWAP_ACC,
7527c478bd9Sstevel@tonic-gate DDI_STRICTORDER_ACC,
7537c478bd9Sstevel@tonic-gate };
7547c478bd9Sstevel@tonic-gate
7552df1fe9cSrandyf instance = ddi_get_instance(devi); /* find out which unit */
7562df1fe9cSrandyf
7572df1fe9cSrandyf switch (cmd) {
7582df1fe9cSrandyf case DDI_ATTACH:
7592df1fe9cSrandyf break;
7602df1fe9cSrandyf case DDI_RESUME:
7612df1fe9cSrandyf {
7622df1fe9cSrandyf struct asyncline *async;
7632df1fe9cSrandyf
7642df1fe9cSrandyf #ifdef DEBUG
7652df1fe9cSrandyf if (asy_nosuspend)
7662df1fe9cSrandyf return (DDI_SUCCESS);
7672df1fe9cSrandyf #endif
7682df1fe9cSrandyf asy = ddi_get_soft_state(asy_soft_state, instance);
7692df1fe9cSrandyf if (asy == NULL)
7707c478bd9Sstevel@tonic-gate return (DDI_FAILURE);
7717c478bd9Sstevel@tonic-gate
7722df1fe9cSrandyf mutex_enter(&asy->asy_soft_sr);
7732df1fe9cSrandyf mutex_enter(&asy->asy_excl);
7742df1fe9cSrandyf mutex_enter(&asy->asy_excl_hi);
7752df1fe9cSrandyf
7762df1fe9cSrandyf async = asy->asy_priv;
7772df1fe9cSrandyf /* Disable interrupts */
7782df1fe9cSrandyf ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
7792df1fe9cSrandyf if (asy_identify_chip(devi, asy) != DDI_SUCCESS) {
7802df1fe9cSrandyf mutex_exit(&asy->asy_excl_hi);
7812df1fe9cSrandyf mutex_exit(&asy->asy_excl);
7822df1fe9cSrandyf mutex_exit(&asy->asy_soft_sr);
78351cc66a5SKevin Crowe cmn_err(CE_WARN, "!Cannot identify UART chip at %p\n",
7842df1fe9cSrandyf (void *)asy->asy_ioaddr);
7852df1fe9cSrandyf return (DDI_FAILURE);
7862df1fe9cSrandyf }
7872df1fe9cSrandyf asy->asy_flags &= ~ASY_DDI_SUSPENDED;
7882df1fe9cSrandyf if (async->async_flags & ASYNC_ISOPEN) {
7892df1fe9cSrandyf asy_program(asy, ASY_INIT);
7902df1fe9cSrandyf /* Kick off output */
7912df1fe9cSrandyf if (async->async_ocnt > 0) {
7922df1fe9cSrandyf async_resume(async);
7932df1fe9cSrandyf } else {
7942df1fe9cSrandyf mutex_exit(&asy->asy_excl_hi);
7952df1fe9cSrandyf if (async->async_xmitblk)
7962df1fe9cSrandyf freeb(async->async_xmitblk);
7972df1fe9cSrandyf async->async_xmitblk = NULL;
7982df1fe9cSrandyf async_start(async);
7992df1fe9cSrandyf mutex_enter(&asy->asy_excl_hi);
8002df1fe9cSrandyf }
8012df1fe9cSrandyf ASYSETSOFT(asy);
8022df1fe9cSrandyf }
8032df1fe9cSrandyf mutex_exit(&asy->asy_excl_hi);
8042df1fe9cSrandyf mutex_exit(&asy->asy_excl);
8052df1fe9cSrandyf mutex_exit(&asy->asy_soft_sr);
8062df1fe9cSrandyf
8072df1fe9cSrandyf mutex_enter(&asy->asy_excl);
8082df1fe9cSrandyf if (async->async_flags & ASYNC_RESUME_BUFCALL) {
8092df1fe9cSrandyf async->async_wbufcid = bufcall(async->async_wbufcds,
8102df1fe9cSrandyf BPRI_HI, (void (*)(void *)) async_reioctl,
8112df1fe9cSrandyf (void *)(intptr_t)async->async_common->asy_unit);
8122df1fe9cSrandyf async->async_flags &= ~ASYNC_RESUME_BUFCALL;
8132df1fe9cSrandyf }
8142df1fe9cSrandyf async_process_suspq(asy);
8152df1fe9cSrandyf mutex_exit(&asy->asy_excl);
8162df1fe9cSrandyf return (DDI_SUCCESS);
8172df1fe9cSrandyf }
8182df1fe9cSrandyf default:
8192df1fe9cSrandyf return (DDI_FAILURE);
8202df1fe9cSrandyf }
8212df1fe9cSrandyf
8227c478bd9Sstevel@tonic-gate ret = ddi_soft_state_zalloc(asy_soft_state, instance);
8237c478bd9Sstevel@tonic-gate if (ret != DDI_SUCCESS)
8247c478bd9Sstevel@tonic-gate return (DDI_FAILURE);
8257c478bd9Sstevel@tonic-gate asy = ddi_get_soft_state(asy_soft_state, instance);
8267c478bd9Sstevel@tonic-gate ASSERT(asy != NULL); /* can't fail - we only just allocated it */
8277c478bd9Sstevel@tonic-gate asy->asy_unit = instance;
8287c478bd9Sstevel@tonic-gate mutex_enter(&asy_glob_lock);
8297c478bd9Sstevel@tonic-gate if (instance > max_asy_instance)
8307c478bd9Sstevel@tonic-gate max_asy_instance = instance;
8317c478bd9Sstevel@tonic-gate mutex_exit(&asy_glob_lock);
8327c478bd9Sstevel@tonic-gate
83356001103Smyers regnum = asy_get_io_regnum(devi, asy);
8347c478bd9Sstevel@tonic-gate
8357c478bd9Sstevel@tonic-gate if (regnum < 0 ||
8367c478bd9Sstevel@tonic-gate ddi_regs_map_setup(devi, regnum, (caddr_t *)&asy->asy_ioaddr,
8377c478bd9Sstevel@tonic-gate (offset_t)0, (offset_t)0, &ioattr, &asy->asy_iohandle)
8387c478bd9Sstevel@tonic-gate != DDI_SUCCESS) {
8397c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "asy%d: could not map UART registers @ %p",
8407c478bd9Sstevel@tonic-gate instance, (void *)asy->asy_ioaddr);
8417c478bd9Sstevel@tonic-gate
8427c478bd9Sstevel@tonic-gate asy_soft_state_free(asy);
8437c478bd9Sstevel@tonic-gate return (DDI_FAILURE);
8447c478bd9Sstevel@tonic-gate }
8457c478bd9Sstevel@tonic-gate
8467c478bd9Sstevel@tonic-gate DEBUGCONT2(ASY_DEBUG_INIT, "asy%dattach: UART @ %p\n",
8477c478bd9Sstevel@tonic-gate instance, (void *)asy->asy_ioaddr);
8487c478bd9Sstevel@tonic-gate
8497c478bd9Sstevel@tonic-gate mutex_enter(&asy_glob_lock);
8507c478bd9Sstevel@tonic-gate if (com_ports == NULL) { /* need to initialize com_ports */
8517c478bd9Sstevel@tonic-gate if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, devi, 0,
8527c478bd9Sstevel@tonic-gate "motherboard-serial-ports", &com_ports, &num_com_ports) !=
8537c478bd9Sstevel@tonic-gate DDI_PROP_SUCCESS) {
8547c478bd9Sstevel@tonic-gate /* Use our built-in COM[1234] values */
8557c478bd9Sstevel@tonic-gate com_ports = (int *)standard_com_ports;
8567c478bd9Sstevel@tonic-gate num_com_ports = sizeof (standard_com_ports) /
8577c478bd9Sstevel@tonic-gate sizeof (standard_com_ports[0]);
8587c478bd9Sstevel@tonic-gate }
8597c478bd9Sstevel@tonic-gate if (num_com_ports > 10) {
8607c478bd9Sstevel@tonic-gate /* We run out of single digits for device properties */
8617c478bd9Sstevel@tonic-gate num_com_ports = 10;
8627c478bd9Sstevel@tonic-gate cmn_err(CE_WARN,
8637c478bd9Sstevel@tonic-gate "More than %d motherboard-serial-ports",
8647c478bd9Sstevel@tonic-gate num_com_ports);
8657c478bd9Sstevel@tonic-gate }
8667c478bd9Sstevel@tonic-gate }
8677c478bd9Sstevel@tonic-gate mutex_exit(&asy_glob_lock);
8687c478bd9Sstevel@tonic-gate
8697c478bd9Sstevel@tonic-gate /*
8707c478bd9Sstevel@tonic-gate * Lookup the i/o address to see if this is a standard COM port
8717c478bd9Sstevel@tonic-gate * in which case we assign it the correct tty[a-d] to match the
8727c478bd9Sstevel@tonic-gate * COM port number, or some other i/o address in which case it
8737c478bd9Sstevel@tonic-gate * will be assigned /dev/term/[0123...] in some rather arbitrary
8747c478bd9Sstevel@tonic-gate * fashion.
8757c478bd9Sstevel@tonic-gate */
8767c478bd9Sstevel@tonic-gate
8777c478bd9Sstevel@tonic-gate for (i = 0; i < num_com_ports; i++) {
8787c478bd9Sstevel@tonic-gate if (asy->asy_ioaddr == (uint8_t *)(uintptr_t)com_ports[i]) {
8797c478bd9Sstevel@tonic-gate asy->asy_com_port = i + 1;
8807c478bd9Sstevel@tonic-gate break;
8817c478bd9Sstevel@tonic-gate }
8827c478bd9Sstevel@tonic-gate }
8837c478bd9Sstevel@tonic-gate
8847c478bd9Sstevel@tonic-gate /*
8857c478bd9Sstevel@tonic-gate * It appears that there was async hardware that on reset
8867c478bd9Sstevel@tonic-gate * did not clear ICR. Hence when we get to
8877c478bd9Sstevel@tonic-gate * ddi_get_iblock_cookie below, this hardware would cause
8887c478bd9Sstevel@tonic-gate * the system to hang if there was input available.
8897c478bd9Sstevel@tonic-gate */
8907c478bd9Sstevel@tonic-gate
8914ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0x00);
8927c478bd9Sstevel@tonic-gate
8937c478bd9Sstevel@tonic-gate /* establish default usage */
8947c478bd9Sstevel@tonic-gate asy->asy_mcr |= RTS|DTR; /* do use RTS/DTR after open */
8957c478bd9Sstevel@tonic-gate asy->asy_lcr = STOP1|BITS8; /* default to 1 stop 8 bits */
8967c478bd9Sstevel@tonic-gate asy->asy_bidx = B9600; /* default to 9600 */
8977c478bd9Sstevel@tonic-gate #ifdef DEBUG
8987c478bd9Sstevel@tonic-gate asy->asy_msint_cnt = 0; /* # of times in async_msint */
8997c478bd9Sstevel@tonic-gate #endif
9007c478bd9Sstevel@tonic-gate mcr = 0; /* don't enable until open */
9017c478bd9Sstevel@tonic-gate
9027c478bd9Sstevel@tonic-gate if (asy->asy_com_port != 0) {
9037c478bd9Sstevel@tonic-gate /*
9047c478bd9Sstevel@tonic-gate * For motherboard ports, emulate tty eeprom properties.
9057c478bd9Sstevel@tonic-gate * Actually, we can't tell if a port is motherboard or not,
9067c478bd9Sstevel@tonic-gate * so for "motherboard ports", read standard DOS COM ports.
9077c478bd9Sstevel@tonic-gate */
9087c478bd9Sstevel@tonic-gate switch (asy_getproperty(devi, asy, "ignore-cd")) {
9097c478bd9Sstevel@tonic-gate case 0: /* *-ignore-cd=False */
9107c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_MODEM,
9117c478bd9Sstevel@tonic-gate "asy%dattach: clear ASY_IGNORE_CD\n", instance);
9127c478bd9Sstevel@tonic-gate asy->asy_flags &= ~ASY_IGNORE_CD; /* wait for cd */
9137c478bd9Sstevel@tonic-gate break;
9147c478bd9Sstevel@tonic-gate case 1: /* *-ignore-cd=True */
9157c478bd9Sstevel@tonic-gate /*FALLTHRU*/
9167c478bd9Sstevel@tonic-gate default: /* *-ignore-cd not defined */
9177c478bd9Sstevel@tonic-gate /*
9187c478bd9Sstevel@tonic-gate * We set rather silly defaults of soft carrier on
9197c478bd9Sstevel@tonic-gate * and DTR/RTS raised here because it might be that
9207c478bd9Sstevel@tonic-gate * one of the motherboard ports is the system console.
9217c478bd9Sstevel@tonic-gate */
9227c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_MODEM,
9237c478bd9Sstevel@tonic-gate "asy%dattach: set ASY_IGNORE_CD, set RTS & DTR\n",
9247c478bd9Sstevel@tonic-gate instance);
9257c478bd9Sstevel@tonic-gate mcr = asy->asy_mcr; /* rts/dtr on */
9267c478bd9Sstevel@tonic-gate asy->asy_flags |= ASY_IGNORE_CD; /* ignore cd */
9277c478bd9Sstevel@tonic-gate break;
9287c478bd9Sstevel@tonic-gate }
9297c478bd9Sstevel@tonic-gate
9307c478bd9Sstevel@tonic-gate /* Property for not raising DTR/RTS */
9317c478bd9Sstevel@tonic-gate switch (asy_getproperty(devi, asy, "rts-dtr-off")) {
9327c478bd9Sstevel@tonic-gate case 0: /* *-rts-dtr-off=False */
9337c478bd9Sstevel@tonic-gate asy->asy_flags |= ASY_RTS_DTR_OFF; /* OFF */
9347c478bd9Sstevel@tonic-gate mcr = asy->asy_mcr; /* rts/dtr on */
9357c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_MODEM, "asy%dattach: "
9367c478bd9Sstevel@tonic-gate "ASY_RTS_DTR_OFF set and DTR & RTS set\n",
9377c478bd9Sstevel@tonic-gate instance);
9387c478bd9Sstevel@tonic-gate break;
9397c478bd9Sstevel@tonic-gate case 1: /* *-rts-dtr-off=True */
9407c478bd9Sstevel@tonic-gate /*FALLTHRU*/
9417c478bd9Sstevel@tonic-gate default: /* *-rts-dtr-off undefined */
9427c478bd9Sstevel@tonic-gate break;
9437c478bd9Sstevel@tonic-gate }
9447c478bd9Sstevel@tonic-gate
9457c478bd9Sstevel@tonic-gate /* Parse property for tty modes */
9467c478bd9Sstevel@tonic-gate asy_parse_mode(devi, asy);
9477c478bd9Sstevel@tonic-gate } else {
9487c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_MODEM,
9497c478bd9Sstevel@tonic-gate "asy%dattach: clear ASY_IGNORE_CD, clear RTS & DTR\n",
9507c478bd9Sstevel@tonic-gate instance);
9517c478bd9Sstevel@tonic-gate asy->asy_flags &= ~ASY_IGNORE_CD; /* wait for cd */
9527c478bd9Sstevel@tonic-gate }
9537c478bd9Sstevel@tonic-gate
9547c478bd9Sstevel@tonic-gate /*
9557c478bd9Sstevel@tonic-gate * Initialize the port with default settings.
9567c478bd9Sstevel@tonic-gate */
9577c478bd9Sstevel@tonic-gate
9587c478bd9Sstevel@tonic-gate asy->asy_fifo_buf = 1;
9597c478bd9Sstevel@tonic-gate asy->asy_use_fifo = FIFO_OFF;
9607c478bd9Sstevel@tonic-gate
9617c478bd9Sstevel@tonic-gate /*
9627c478bd9Sstevel@tonic-gate * Get icookie for mutexes initialization
9637c478bd9Sstevel@tonic-gate */
9647c478bd9Sstevel@tonic-gate if ((ddi_get_iblock_cookie(devi, 0, &asy->asy_iblock) !=
9657c478bd9Sstevel@tonic-gate DDI_SUCCESS) ||
9667c478bd9Sstevel@tonic-gate (ddi_get_soft_iblock_cookie(devi, DDI_SOFTINT_MED,
967cd43c54aSZach Kissel &asy->asy_soft_iblock) != DDI_SUCCESS)) {
9687c478bd9Sstevel@tonic-gate ddi_regs_map_free(&asy->asy_iohandle);
9697c478bd9Sstevel@tonic-gate cmn_err(CE_CONT,
9707c478bd9Sstevel@tonic-gate "asy%d: could not hook interrupt for UART @ %p\n",
9717c478bd9Sstevel@tonic-gate instance, (void *)asy->asy_ioaddr);
9727c478bd9Sstevel@tonic-gate asy_soft_state_free(asy);
9737c478bd9Sstevel@tonic-gate return (DDI_FAILURE);
9747c478bd9Sstevel@tonic-gate }
9757c478bd9Sstevel@tonic-gate
9767c478bd9Sstevel@tonic-gate /*
9777c478bd9Sstevel@tonic-gate * Initialize mutexes before accessing the hardware
9787c478bd9Sstevel@tonic-gate */
979cd43c54aSZach Kissel mutex_init(&asy->asy_soft_lock, NULL, MUTEX_DRIVER,
980cd43c54aSZach Kissel (void *)asy->asy_soft_iblock);
981cd43c54aSZach Kissel mutex_init(&asy->asy_excl, NULL, MUTEX_DRIVER, NULL);
9827c478bd9Sstevel@tonic-gate mutex_init(&asy->asy_excl_hi, NULL, MUTEX_DRIVER,
9837c478bd9Sstevel@tonic-gate (void *)asy->asy_iblock);
984cd43c54aSZach Kissel mutex_init(&asy->asy_soft_sr, NULL, MUTEX_DRIVER,
985cd43c54aSZach Kissel (void *)asy->asy_soft_iblock);
9867c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
9877c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
9887c478bd9Sstevel@tonic-gate
9897c478bd9Sstevel@tonic-gate if (asy_identify_chip(devi, asy) != DDI_SUCCESS) {
9907c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
9917c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
992cd43c54aSZach Kissel mutex_destroy(&asy->asy_soft_lock);
9937c478bd9Sstevel@tonic-gate mutex_destroy(&asy->asy_excl);
9947c478bd9Sstevel@tonic-gate mutex_destroy(&asy->asy_excl_hi);
9952df1fe9cSrandyf mutex_destroy(&asy->asy_soft_sr);
9967c478bd9Sstevel@tonic-gate ddi_regs_map_free(&asy->asy_iohandle);
99751cc66a5SKevin Crowe cmn_err(CE_CONT, "!Cannot identify UART chip at %p\n",
9987c478bd9Sstevel@tonic-gate (void *)asy->asy_ioaddr);
9997c478bd9Sstevel@tonic-gate asy_soft_state_free(asy);
10007c478bd9Sstevel@tonic-gate return (DDI_FAILURE);
10017c478bd9Sstevel@tonic-gate }
10027c478bd9Sstevel@tonic-gate
10037c478bd9Sstevel@tonic-gate /* disable all interrupts */
10044ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
10057c478bd9Sstevel@tonic-gate /* select baud rate generator */
10064ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, DLAB);
10077c478bd9Sstevel@tonic-gate /* Set the baud rate to 9600 */
10084ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + (DAT+DLL),
10097c478bd9Sstevel@tonic-gate asyspdtab[asy->asy_bidx] & 0xff);
10104ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + (DAT+DLH),
10117c478bd9Sstevel@tonic-gate (asyspdtab[asy->asy_bidx] >> 8) & 0xff);
10122df1fe9cSrandyf ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, asy->asy_lcr);
10134ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR, mcr);
10147c478bd9Sstevel@tonic-gate
10157c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
10167c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
10177c478bd9Sstevel@tonic-gate
10187c478bd9Sstevel@tonic-gate /*
10197c478bd9Sstevel@tonic-gate * Set up the other components of the asycom structure for this port.
10207c478bd9Sstevel@tonic-gate */
10217c478bd9Sstevel@tonic-gate asy->asy_dip = devi;
10227c478bd9Sstevel@tonic-gate
1023cd43c54aSZach Kissel /*
1024cd43c54aSZach Kissel * Install per instance software interrupt handler.
1025cd43c54aSZach Kissel */
10267c478bd9Sstevel@tonic-gate if (ddi_add_softintr(devi, DDI_SOFTINT_MED,
1027cd43c54aSZach Kissel &(asy->asy_softintr_id), NULL, 0, asysoftintr,
1028cd43c54aSZach Kissel (caddr_t)asy) != DDI_SUCCESS) {
1029cd43c54aSZach Kissel mutex_destroy(&asy->asy_soft_lock);
10307c478bd9Sstevel@tonic-gate mutex_destroy(&asy->asy_excl);
10317c478bd9Sstevel@tonic-gate mutex_destroy(&asy->asy_excl_hi);
10327c478bd9Sstevel@tonic-gate ddi_regs_map_free(&asy->asy_iohandle);
10337c478bd9Sstevel@tonic-gate cmn_err(CE_CONT,
10347c478bd9Sstevel@tonic-gate "Can not set soft interrupt for ASY driver\n");
10357c478bd9Sstevel@tonic-gate asy_soft_state_free(asy);
10367c478bd9Sstevel@tonic-gate return (DDI_FAILURE);
10377c478bd9Sstevel@tonic-gate }
10387c478bd9Sstevel@tonic-gate
10397c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
10407c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
10417c478bd9Sstevel@tonic-gate
10427c478bd9Sstevel@tonic-gate /*
10437c478bd9Sstevel@tonic-gate * Install interrupt handler for this device.
10447c478bd9Sstevel@tonic-gate */
10457c478bd9Sstevel@tonic-gate if (ddi_add_intr(devi, 0, NULL, 0, asyintr,
10467c478bd9Sstevel@tonic-gate (caddr_t)asy) != DDI_SUCCESS) {
10477c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
10487c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
1049cd43c54aSZach Kissel ddi_remove_softintr(asy->asy_softintr_id);
1050cd43c54aSZach Kissel mutex_destroy(&asy->asy_soft_lock);
10517c478bd9Sstevel@tonic-gate mutex_destroy(&asy->asy_excl);
10527c478bd9Sstevel@tonic-gate mutex_destroy(&asy->asy_excl_hi);
10537c478bd9Sstevel@tonic-gate ddi_regs_map_free(&asy->asy_iohandle);
10547c478bd9Sstevel@tonic-gate cmn_err(CE_CONT,
10557c478bd9Sstevel@tonic-gate "Can not set device interrupt for ASY driver\n");
10567c478bd9Sstevel@tonic-gate asy_soft_state_free(asy);
10577c478bd9Sstevel@tonic-gate return (DDI_FAILURE);
10587c478bd9Sstevel@tonic-gate }
10597c478bd9Sstevel@tonic-gate
10607c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
10617c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
10627c478bd9Sstevel@tonic-gate
10637c478bd9Sstevel@tonic-gate asyinit(asy); /* initialize the asyncline structure */
10647c478bd9Sstevel@tonic-gate
10657c478bd9Sstevel@tonic-gate /* create minor device nodes for this device */
10667c478bd9Sstevel@tonic-gate if (asy->asy_com_port != 0) {
10677c478bd9Sstevel@tonic-gate /*
10687c478bd9Sstevel@tonic-gate * For DOS COM ports, add letter suffix so
10697c478bd9Sstevel@tonic-gate * devfsadm can create correct link names.
10707c478bd9Sstevel@tonic-gate */
10717c478bd9Sstevel@tonic-gate name[0] = asy->asy_com_port + 'a' - 1;
10727c478bd9Sstevel@tonic-gate name[1] = '\0';
10737c478bd9Sstevel@tonic-gate } else {
10747c478bd9Sstevel@tonic-gate /*
107556001103Smyers * asy port which isn't a standard DOS COM
107656001103Smyers * port gets a numeric name based on instance
10777c478bd9Sstevel@tonic-gate */
107856001103Smyers (void) snprintf(name, ASY_MINOR_LEN, "%d", instance);
10797c478bd9Sstevel@tonic-gate }
10807c478bd9Sstevel@tonic-gate status = ddi_create_minor_node(devi, name, S_IFCHR, instance,
10819b4d666eSToomas Soome asy->asy_com_port != 0 ? DDI_NT_SERIAL_MB : DDI_NT_SERIAL, 0);
10827c478bd9Sstevel@tonic-gate if (status == DDI_SUCCESS) {
10837c478bd9Sstevel@tonic-gate (void) strcat(name, ",cu");
10847c478bd9Sstevel@tonic-gate status = ddi_create_minor_node(devi, name, S_IFCHR,
10857c478bd9Sstevel@tonic-gate OUTLINE | instance,
10867c478bd9Sstevel@tonic-gate asy->asy_com_port != 0 ? DDI_NT_SERIAL_MB_DO :
10879b4d666eSToomas Soome DDI_NT_SERIAL_DO, 0);
10887c478bd9Sstevel@tonic-gate }
10897c478bd9Sstevel@tonic-gate
10907c478bd9Sstevel@tonic-gate if (status != DDI_SUCCESS) {
10917c478bd9Sstevel@tonic-gate struct asyncline *async = asy->asy_priv;
10927c478bd9Sstevel@tonic-gate
10937c478bd9Sstevel@tonic-gate ddi_remove_minor_node(devi, NULL);
10947c478bd9Sstevel@tonic-gate ddi_remove_intr(devi, 0, asy->asy_iblock);
1095cd43c54aSZach Kissel ddi_remove_softintr(asy->asy_softintr_id);
1096cd43c54aSZach Kissel mutex_destroy(&asy->asy_soft_lock);
10977c478bd9Sstevel@tonic-gate mutex_destroy(&asy->asy_excl);
10987c478bd9Sstevel@tonic-gate mutex_destroy(&asy->asy_excl_hi);
10997c478bd9Sstevel@tonic-gate cv_destroy(&async->async_flags_cv);
11007c478bd9Sstevel@tonic-gate ddi_regs_map_free(&asy->asy_iohandle);
11017c478bd9Sstevel@tonic-gate asy_soft_state_free(asy);
11027c478bd9Sstevel@tonic-gate return (DDI_FAILURE);
11037c478bd9Sstevel@tonic-gate }
11047c478bd9Sstevel@tonic-gate
11057c478bd9Sstevel@tonic-gate /*
11067c478bd9Sstevel@tonic-gate * Fill in the polled I/O structure.
11077c478bd9Sstevel@tonic-gate */
11087c478bd9Sstevel@tonic-gate asy->polledio.cons_polledio_version = CONSPOLLEDIO_V0;
1109281f0747Slt200341 asy->polledio.cons_polledio_argument = (cons_polledio_arg_t)asy;
11107c478bd9Sstevel@tonic-gate asy->polledio.cons_polledio_putchar = asyputchar;
11117c478bd9Sstevel@tonic-gate asy->polledio.cons_polledio_getchar = asygetchar;
11127c478bd9Sstevel@tonic-gate asy->polledio.cons_polledio_ischar = asyischar;
11137c478bd9Sstevel@tonic-gate asy->polledio.cons_polledio_enter = NULL;
11147c478bd9Sstevel@tonic-gate asy->polledio.cons_polledio_exit = NULL;
11157c478bd9Sstevel@tonic-gate
11167c478bd9Sstevel@tonic-gate ddi_report_dev(devi);
11177c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_INIT, "asy%dattach: done\n", instance);
11187c478bd9Sstevel@tonic-gate return (DDI_SUCCESS);
11197c478bd9Sstevel@tonic-gate }
11207c478bd9Sstevel@tonic-gate
11217c478bd9Sstevel@tonic-gate /*ARGSUSED*/
11227c478bd9Sstevel@tonic-gate static int
asyinfo(dev_info_t * dip,ddi_info_cmd_t infocmd,void * arg,void ** result)11237c478bd9Sstevel@tonic-gate asyinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
11247c478bd9Sstevel@tonic-gate void **result)
11257c478bd9Sstevel@tonic-gate {
11267c478bd9Sstevel@tonic-gate dev_t dev = (dev_t)arg;
11277c478bd9Sstevel@tonic-gate int instance, error;
11287c478bd9Sstevel@tonic-gate struct asycom *asy;
11297c478bd9Sstevel@tonic-gate
11307c478bd9Sstevel@tonic-gate instance = UNIT(dev);
11317c478bd9Sstevel@tonic-gate
11327c478bd9Sstevel@tonic-gate switch (infocmd) {
11337c478bd9Sstevel@tonic-gate case DDI_INFO_DEVT2DEVINFO:
113470796907Scth asy = ddi_get_soft_state(asy_soft_state, instance);
113570796907Scth if ((asy == NULL) || (asy->asy_dip == NULL))
11367c478bd9Sstevel@tonic-gate error = DDI_FAILURE;
11377c478bd9Sstevel@tonic-gate else {
11387c478bd9Sstevel@tonic-gate *result = (void *) asy->asy_dip;
11397c478bd9Sstevel@tonic-gate error = DDI_SUCCESS;
11407c478bd9Sstevel@tonic-gate }
11417c478bd9Sstevel@tonic-gate break;
11427c478bd9Sstevel@tonic-gate case DDI_INFO_DEVT2INSTANCE:
11437c478bd9Sstevel@tonic-gate *result = (void *)(intptr_t)instance;
11447c478bd9Sstevel@tonic-gate error = DDI_SUCCESS;
11457c478bd9Sstevel@tonic-gate break;
11467c478bd9Sstevel@tonic-gate default:
11477c478bd9Sstevel@tonic-gate error = DDI_FAILURE;
11487c478bd9Sstevel@tonic-gate }
11497c478bd9Sstevel@tonic-gate return (error);
11507c478bd9Sstevel@tonic-gate }
11517c478bd9Sstevel@tonic-gate
11527c478bd9Sstevel@tonic-gate /* asy_getproperty -- walk through all name variants until we find a match */
11537c478bd9Sstevel@tonic-gate
11547c478bd9Sstevel@tonic-gate static int
asy_getproperty(dev_info_t * devi,struct asycom * asy,const char * property)11557c478bd9Sstevel@tonic-gate asy_getproperty(dev_info_t *devi, struct asycom *asy, const char *property)
11567c478bd9Sstevel@tonic-gate {
11577c478bd9Sstevel@tonic-gate int len;
11587c478bd9Sstevel@tonic-gate int ret;
11597c478bd9Sstevel@tonic-gate char letter = asy->asy_com_port + 'a' - 1; /* for ttya */
11607c478bd9Sstevel@tonic-gate char number = asy->asy_com_port + '0'; /* for COM1 */
11617c478bd9Sstevel@tonic-gate char val[40];
11627c478bd9Sstevel@tonic-gate char name[40];
11637c478bd9Sstevel@tonic-gate
11647c478bd9Sstevel@tonic-gate /* Property for ignoring DCD */
11657c478bd9Sstevel@tonic-gate (void) sprintf(name, "tty%c-%s", letter, property);
11667c478bd9Sstevel@tonic-gate len = sizeof (val);
11677c478bd9Sstevel@tonic-gate ret = GET_PROP(devi, name, DDI_PROP_CANSLEEP, val, &len);
11687c478bd9Sstevel@tonic-gate if (ret != DDI_PROP_SUCCESS) {
11697c478bd9Sstevel@tonic-gate (void) sprintf(name, "com%c-%s", number, property);
11707c478bd9Sstevel@tonic-gate len = sizeof (val);
11712df1fe9cSrandyf ret = GET_PROP(devi, name, DDI_PROP_CANSLEEP, val, &len);
11727c478bd9Sstevel@tonic-gate }
11737c478bd9Sstevel@tonic-gate if (ret != DDI_PROP_SUCCESS) {
11747c478bd9Sstevel@tonic-gate (void) sprintf(name, "tty0%c-%s", number, property);
11757c478bd9Sstevel@tonic-gate len = sizeof (val);
11762df1fe9cSrandyf ret = GET_PROP(devi, name, DDI_PROP_CANSLEEP, val, &len);
11777c478bd9Sstevel@tonic-gate }
11787c478bd9Sstevel@tonic-gate if (ret != DDI_PROP_SUCCESS) {
11797c478bd9Sstevel@tonic-gate (void) sprintf(name, "port-%c-%s", letter, property);
11807c478bd9Sstevel@tonic-gate len = sizeof (val);
11812df1fe9cSrandyf ret = GET_PROP(devi, name, DDI_PROP_CANSLEEP, val, &len);
11827c478bd9Sstevel@tonic-gate }
11837c478bd9Sstevel@tonic-gate if (ret != DDI_PROP_SUCCESS)
11847c478bd9Sstevel@tonic-gate return (-1); /* property non-existant */
11857c478bd9Sstevel@tonic-gate if (val[0] == 'f' || val[0] == 'F' || val[0] == '0')
11867c478bd9Sstevel@tonic-gate return (0); /* property false/0 */
11877c478bd9Sstevel@tonic-gate return (1); /* property true/!0 */
11887c478bd9Sstevel@tonic-gate }
11897c478bd9Sstevel@tonic-gate
11907c478bd9Sstevel@tonic-gate /* asy_soft_state_free - local wrapper for ddi_soft_state_free(9F) */
11917c478bd9Sstevel@tonic-gate
11927c478bd9Sstevel@tonic-gate static void
asy_soft_state_free(struct asycom * asy)11937c478bd9Sstevel@tonic-gate asy_soft_state_free(struct asycom *asy)
11947c478bd9Sstevel@tonic-gate {
11957c478bd9Sstevel@tonic-gate mutex_enter(&asy_glob_lock);
11967c478bd9Sstevel@tonic-gate /* If we were the max_asy_instance, work out new value */
11977c478bd9Sstevel@tonic-gate if (asy->asy_unit == max_asy_instance) {
11987c478bd9Sstevel@tonic-gate while (--max_asy_instance >= 0) {
11997c478bd9Sstevel@tonic-gate if (ddi_get_soft_state(asy_soft_state,
12007c478bd9Sstevel@tonic-gate max_asy_instance) != NULL)
12017c478bd9Sstevel@tonic-gate break;
12027c478bd9Sstevel@tonic-gate }
12037c478bd9Sstevel@tonic-gate }
12047c478bd9Sstevel@tonic-gate mutex_exit(&asy_glob_lock);
12057c478bd9Sstevel@tonic-gate
12067c478bd9Sstevel@tonic-gate if (asy->asy_priv != NULL) {
12077c478bd9Sstevel@tonic-gate kmem_free(asy->asy_priv, sizeof (struct asyncline));
12087c478bd9Sstevel@tonic-gate asy->asy_priv = NULL;
12097c478bd9Sstevel@tonic-gate }
12107c478bd9Sstevel@tonic-gate ddi_soft_state_free(asy_soft_state, asy->asy_unit);
12117c478bd9Sstevel@tonic-gate }
12127c478bd9Sstevel@tonic-gate
12137c478bd9Sstevel@tonic-gate static char *
asy_hw_name(struct asycom * asy)12147c478bd9Sstevel@tonic-gate asy_hw_name(struct asycom *asy)
12157c478bd9Sstevel@tonic-gate {
12167c478bd9Sstevel@tonic-gate switch (asy->asy_hwtype) {
12177c478bd9Sstevel@tonic-gate case ASY8250A:
12187c478bd9Sstevel@tonic-gate return ("8250A/16450");
12197c478bd9Sstevel@tonic-gate case ASY16550:
12207c478bd9Sstevel@tonic-gate return ("16550");
12217c478bd9Sstevel@tonic-gate case ASY16550A:
12227c478bd9Sstevel@tonic-gate return ("16550A");
12237c478bd9Sstevel@tonic-gate case ASY16650:
12247c478bd9Sstevel@tonic-gate return ("16650");
12257c478bd9Sstevel@tonic-gate case ASY16750:
12267c478bd9Sstevel@tonic-gate return ("16750");
12277c478bd9Sstevel@tonic-gate default:
12287c478bd9Sstevel@tonic-gate DEBUGNOTE2(ASY_DEBUG_INIT,
12297c478bd9Sstevel@tonic-gate "asy%d: asy_hw_name: unknown asy_hwtype: %d",
12307c478bd9Sstevel@tonic-gate asy->asy_unit, asy->asy_hwtype);
12317c478bd9Sstevel@tonic-gate return ("?");
12327c478bd9Sstevel@tonic-gate }
12337c478bd9Sstevel@tonic-gate }
12347c478bd9Sstevel@tonic-gate
12357c478bd9Sstevel@tonic-gate static int
asy_identify_chip(dev_info_t * devi,struct asycom * asy)12367c478bd9Sstevel@tonic-gate asy_identify_chip(dev_info_t *devi, struct asycom *asy)
12377c478bd9Sstevel@tonic-gate {
12387c478bd9Sstevel@tonic-gate int ret;
12397c478bd9Sstevel@tonic-gate int mcr;
12407c478bd9Sstevel@tonic-gate dev_t dev;
12417c478bd9Sstevel@tonic-gate uint_t hwtype;
12427c478bd9Sstevel@tonic-gate
12437c478bd9Sstevel@tonic-gate if (asy_scr_test) {
12447c478bd9Sstevel@tonic-gate /* Check scratch register works. */
12457c478bd9Sstevel@tonic-gate
12467c478bd9Sstevel@tonic-gate /* write to scratch register */
12474ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + SCR, SCRTEST);
12487c478bd9Sstevel@tonic-gate /* make sure that pattern doesn't just linger on the bus */
12494ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + FIFOR, 0x00);
12507c478bd9Sstevel@tonic-gate /* read data back from scratch register */
12514ab75253Smrj ret = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + SCR);
12527c478bd9Sstevel@tonic-gate if (ret != SCRTEST) {
12537c478bd9Sstevel@tonic-gate /*
12547c478bd9Sstevel@tonic-gate * Scratch register not working.
12557c478bd9Sstevel@tonic-gate * Probably not an async chip.
12567c478bd9Sstevel@tonic-gate * 8250 and 8250B don't have scratch registers,
12577c478bd9Sstevel@tonic-gate * but only worked in ancient PC XT's anyway.
12587c478bd9Sstevel@tonic-gate */
125951cc66a5SKevin Crowe cmn_err(CE_CONT, "!asy%d: UART @ %p "
12607c478bd9Sstevel@tonic-gate "scratch register: expected 0x5a, got 0x%02x\n",
12617c478bd9Sstevel@tonic-gate asy->asy_unit, (void *)asy->asy_ioaddr, ret);
12627c478bd9Sstevel@tonic-gate return (DDI_FAILURE);
12637c478bd9Sstevel@tonic-gate }
12647c478bd9Sstevel@tonic-gate }
12657c478bd9Sstevel@tonic-gate /*
12667c478bd9Sstevel@tonic-gate * Use 16550 fifo reset sequence specified in NS application
12677c478bd9Sstevel@tonic-gate * note. Disable fifos until chip is initialized.
12687c478bd9Sstevel@tonic-gate */
12694ab75253Smrj ddi_put8(asy->asy_iohandle,
12707c478bd9Sstevel@tonic-gate asy->asy_ioaddr + FIFOR, 0x00); /* clear */
12714ab75253Smrj ddi_put8(asy->asy_iohandle,
12727c478bd9Sstevel@tonic-gate asy->asy_ioaddr + FIFOR, FIFO_ON); /* enable */
12734ab75253Smrj ddi_put8(asy->asy_iohandle,
12747c478bd9Sstevel@tonic-gate asy->asy_ioaddr + FIFOR, FIFO_ON | FIFORXFLSH);
12757c478bd9Sstevel@tonic-gate /* reset */
12767c478bd9Sstevel@tonic-gate if (asymaxchip >= ASY16650 && asy_scr_test) {
12777c478bd9Sstevel@tonic-gate /*
12787c478bd9Sstevel@tonic-gate * Reset 16650 enhanced regs also, in case we have one of these
12797c478bd9Sstevel@tonic-gate */
12804ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
12817c478bd9Sstevel@tonic-gate EFRACCESS);
12824ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + EFR,
12837c478bd9Sstevel@tonic-gate 0);
12844ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
12857c478bd9Sstevel@tonic-gate STOP1|BITS8);
12867c478bd9Sstevel@tonic-gate }
12877c478bd9Sstevel@tonic-gate
12887c478bd9Sstevel@tonic-gate /*
12897c478bd9Sstevel@tonic-gate * See what sort of FIFO we have.
12907c478bd9Sstevel@tonic-gate * Try enabling it and see what chip makes of this.
12917c478bd9Sstevel@tonic-gate */
12927c478bd9Sstevel@tonic-gate
12937c478bd9Sstevel@tonic-gate asy->asy_fifor = 0;
12947c478bd9Sstevel@tonic-gate asy->asy_hwtype = asymaxchip; /* just for asy_reset_fifo() */
12957c478bd9Sstevel@tonic-gate if (asymaxchip >= ASY16550A)
12967c478bd9Sstevel@tonic-gate asy->asy_fifor |=
12977c478bd9Sstevel@tonic-gate FIFO_ON | FIFODMA | (asy_trig_level & 0xff);
12987c478bd9Sstevel@tonic-gate if (asymaxchip >= ASY16650)
12997c478bd9Sstevel@tonic-gate asy->asy_fifor |= FIFOEXTRA1 | FIFOEXTRA2;
13007c478bd9Sstevel@tonic-gate
13017c478bd9Sstevel@tonic-gate asy_reset_fifo(asy, FIFOTXFLSH | FIFORXFLSH);
13027c478bd9Sstevel@tonic-gate
13034ab75253Smrj mcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MCR);
13044ab75253Smrj ret = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + ISR);
13057c478bd9Sstevel@tonic-gate DEBUGCONT4(ASY_DEBUG_CHIP,
13067c478bd9Sstevel@tonic-gate "asy%d: probe fifo FIFOR=0x%02x ISR=0x%02x MCR=0x%02x\n",
13077c478bd9Sstevel@tonic-gate asy->asy_unit, asy->asy_fifor | FIFOTXFLSH | FIFORXFLSH,
13087c478bd9Sstevel@tonic-gate ret, mcr);
13097c478bd9Sstevel@tonic-gate switch (ret & 0xf0) {
13107c478bd9Sstevel@tonic-gate case 0x40:
13117c478bd9Sstevel@tonic-gate hwtype = ASY16550; /* 16550 with broken FIFO */
13127c478bd9Sstevel@tonic-gate asy->asy_fifor = 0;
13137c478bd9Sstevel@tonic-gate break;
13147c478bd9Sstevel@tonic-gate case 0xc0:
13157c478bd9Sstevel@tonic-gate hwtype = ASY16550A;
13167c478bd9Sstevel@tonic-gate asy->asy_fifo_buf = 16;
13177c478bd9Sstevel@tonic-gate asy->asy_use_fifo = FIFO_ON;
13187c478bd9Sstevel@tonic-gate asy->asy_fifor &= ~(FIFOEXTRA1 | FIFOEXTRA2);
13197c478bd9Sstevel@tonic-gate break;
13207c478bd9Sstevel@tonic-gate case 0xe0:
13217c478bd9Sstevel@tonic-gate hwtype = ASY16650;
13227c478bd9Sstevel@tonic-gate asy->asy_fifo_buf = 32;
13237c478bd9Sstevel@tonic-gate asy->asy_use_fifo = FIFO_ON;
13247c478bd9Sstevel@tonic-gate asy->asy_fifor &= ~(FIFOEXTRA1);
13257c478bd9Sstevel@tonic-gate break;
13267c478bd9Sstevel@tonic-gate case 0xf0:
13277c478bd9Sstevel@tonic-gate /*
13287c478bd9Sstevel@tonic-gate * Note we get 0xff if chip didn't return us anything,
13297c478bd9Sstevel@tonic-gate * e.g. if there's no chip there.
13307c478bd9Sstevel@tonic-gate */
13317c478bd9Sstevel@tonic-gate if (ret == 0xff) {
13327c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "asy%d: UART @ %p "
13337c478bd9Sstevel@tonic-gate "interrupt register: got 0xff\n",
13347c478bd9Sstevel@tonic-gate asy->asy_unit, (void *)asy->asy_ioaddr);
13357c478bd9Sstevel@tonic-gate return (DDI_FAILURE);
13367c478bd9Sstevel@tonic-gate }
13377c478bd9Sstevel@tonic-gate /*FALLTHRU*/
13387c478bd9Sstevel@tonic-gate case 0xd0:
13397c478bd9Sstevel@tonic-gate hwtype = ASY16750;
13407c478bd9Sstevel@tonic-gate asy->asy_fifo_buf = 64;
13417c478bd9Sstevel@tonic-gate asy->asy_use_fifo = FIFO_ON;
13427c478bd9Sstevel@tonic-gate break;
13437c478bd9Sstevel@tonic-gate default:
13447c478bd9Sstevel@tonic-gate hwtype = ASY8250A; /* No FIFO */
13457c478bd9Sstevel@tonic-gate asy->asy_fifor = 0;
13467c478bd9Sstevel@tonic-gate }
13477c478bd9Sstevel@tonic-gate
13487c478bd9Sstevel@tonic-gate if (hwtype > asymaxchip) {
13497c478bd9Sstevel@tonic-gate cmn_err(CE_CONT, "asy%d: UART @ %p "
13507c478bd9Sstevel@tonic-gate "unexpected probe result: "
13517c478bd9Sstevel@tonic-gate "FIFOR=0x%02x ISR=0x%02x MCR=0x%02x\n",
13527c478bd9Sstevel@tonic-gate asy->asy_unit, (void *)asy->asy_ioaddr,
13537c478bd9Sstevel@tonic-gate asy->asy_fifor | FIFOTXFLSH | FIFORXFLSH, ret, mcr);
13547c478bd9Sstevel@tonic-gate return (DDI_FAILURE);
13557c478bd9Sstevel@tonic-gate }
13567c478bd9Sstevel@tonic-gate
13577c478bd9Sstevel@tonic-gate /*
13587c478bd9Sstevel@tonic-gate * Now reset the FIFO operation appropriate for the chip type.
13597c478bd9Sstevel@tonic-gate * Note we must call asy_reset_fifo() before any possible
13607c478bd9Sstevel@tonic-gate * downgrade of the asy->asy_hwtype, or it may not disable
13617c478bd9Sstevel@tonic-gate * the more advanced features we specifically want downgraded.
13627c478bd9Sstevel@tonic-gate */
13637c478bd9Sstevel@tonic-gate asy_reset_fifo(asy, 0);
13647c478bd9Sstevel@tonic-gate asy->asy_hwtype = hwtype;
13657c478bd9Sstevel@tonic-gate
13667c478bd9Sstevel@tonic-gate /*
13677c478bd9Sstevel@tonic-gate * Check for Exar/Startech ST16C650, which will still look like a
13687c478bd9Sstevel@tonic-gate * 16550A until we enable its enhanced mode.
13697c478bd9Sstevel@tonic-gate */
13707c478bd9Sstevel@tonic-gate if (asy->asy_hwtype == ASY16550A && asymaxchip >= ASY16650 &&
13717c478bd9Sstevel@tonic-gate asy_scr_test) {
13727c478bd9Sstevel@tonic-gate /* Enable enhanced mode register access */
13734ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
13747c478bd9Sstevel@tonic-gate EFRACCESS);
13757c478bd9Sstevel@tonic-gate /* zero scratch register (not scratch register if enhanced) */
13764ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + SCR, 0);
13777c478bd9Sstevel@tonic-gate /* Disable enhanced mode register access */
13784ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
13797c478bd9Sstevel@tonic-gate STOP1|BITS8);
13807c478bd9Sstevel@tonic-gate /* read back scratch register */
13814ab75253Smrj ret = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + SCR);
13827c478bd9Sstevel@tonic-gate if (ret == SCRTEST) {
13837c478bd9Sstevel@tonic-gate /* looks like we have an ST16650 -- enable it */
13844ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
13857c478bd9Sstevel@tonic-gate EFRACCESS);
13864ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + EFR,
13877c478bd9Sstevel@tonic-gate ENHENABLE);
13884ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
13897c478bd9Sstevel@tonic-gate STOP1|BITS8);
13907c478bd9Sstevel@tonic-gate asy->asy_hwtype = ASY16650;
13917c478bd9Sstevel@tonic-gate asy->asy_fifo_buf = 32;
13927c478bd9Sstevel@tonic-gate asy->asy_fifor |= 0x10; /* 24 byte txfifo trigger */
13937c478bd9Sstevel@tonic-gate asy_reset_fifo(asy, 0);
13947c478bd9Sstevel@tonic-gate }
13957c478bd9Sstevel@tonic-gate }
13967c478bd9Sstevel@tonic-gate
13977c478bd9Sstevel@tonic-gate /*
13987c478bd9Sstevel@tonic-gate * If we think we might have a FIFO larger than 16 characters,
13997c478bd9Sstevel@tonic-gate * measure FIFO size and check it against expected.
14007c478bd9Sstevel@tonic-gate */
14017c478bd9Sstevel@tonic-gate if (asy_fifo_test > 0 &&
14027c478bd9Sstevel@tonic-gate !(asy->asy_flags2 & ASY2_NO_LOOPBACK) &&
14037c478bd9Sstevel@tonic-gate (asy->asy_fifo_buf > 16 ||
14047c478bd9Sstevel@tonic-gate (asy_fifo_test > 1 && asy->asy_use_fifo == FIFO_ON) ||
14057c478bd9Sstevel@tonic-gate ASY_DEBUG(ASY_DEBUG_CHIP))) {
14067c478bd9Sstevel@tonic-gate int i;
14077c478bd9Sstevel@tonic-gate
14087c478bd9Sstevel@tonic-gate /* Set baud rate to 57600 (fairly arbitrary choice) */
14094ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
14107c478bd9Sstevel@tonic-gate DLAB);
14114ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT,
14127c478bd9Sstevel@tonic-gate asyspdtab[B57600] & 0xff);
14134ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR,
14147c478bd9Sstevel@tonic-gate (asyspdtab[B57600] >> 8) & 0xff);
14157c478bd9Sstevel@tonic-gate /* Set 8 bits, 1 stop bit */
14164ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
14177c478bd9Sstevel@tonic-gate STOP1|BITS8);
14187c478bd9Sstevel@tonic-gate /* Set loopback mode */
14194ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
14207c478bd9Sstevel@tonic-gate DTR | RTS | ASY_LOOP | OUT1 | OUT2);
14217c478bd9Sstevel@tonic-gate
14227c478bd9Sstevel@tonic-gate /* Overfill fifo */
14237c478bd9Sstevel@tonic-gate for (i = 0; i < asy->asy_fifo_buf * 2; i++) {
14244ab75253Smrj ddi_put8(asy->asy_iohandle,
14257c478bd9Sstevel@tonic-gate asy->asy_ioaddr + DAT, i);
14267c478bd9Sstevel@tonic-gate }
14277c478bd9Sstevel@tonic-gate /*
14287c478bd9Sstevel@tonic-gate * Now there's an interesting question here about which
14297c478bd9Sstevel@tonic-gate * FIFO we're testing the size of, RX or TX. We just
14307c478bd9Sstevel@tonic-gate * filled the TX FIFO much faster than it can empty,
14317c478bd9Sstevel@tonic-gate * although it is possible one or two characters may
14327c478bd9Sstevel@tonic-gate * have gone from it to the TX shift register.
14337c478bd9Sstevel@tonic-gate * We wait for enough time for all the characters to
14347c478bd9Sstevel@tonic-gate * move into the RX FIFO and any excess characters to
14357c478bd9Sstevel@tonic-gate * have been lost, and then read all the RX FIFO. So
14367c478bd9Sstevel@tonic-gate * the answer we finally get will be the size which is
14377c478bd9Sstevel@tonic-gate * the MIN(RX FIFO,(TX FIFO + 1 or 2)). The critical
14387c478bd9Sstevel@tonic-gate * one is actually the TX FIFO, because if we overfill
14397c478bd9Sstevel@tonic-gate * it in normal operation, the excess characters are
14407c478bd9Sstevel@tonic-gate * lost with no warning.
14417c478bd9Sstevel@tonic-gate */
14427c478bd9Sstevel@tonic-gate /*
14437c478bd9Sstevel@tonic-gate * Wait for characters to move into RX FIFO.
14447c478bd9Sstevel@tonic-gate * In theory, 200 * asy->asy_fifo_buf * 2 should be
14457c478bd9Sstevel@tonic-gate * enough. However, in practice it isn't always, so we
14467c478bd9Sstevel@tonic-gate * increase to 400 so some slow 16550A's finish, and we
14477c478bd9Sstevel@tonic-gate * increase to 3 so we spot more characters coming back
14487c478bd9Sstevel@tonic-gate * than we sent, in case that should ever happen.
14497c478bd9Sstevel@tonic-gate */
14507c478bd9Sstevel@tonic-gate delay(drv_usectohz(400 * asy->asy_fifo_buf * 3));
14517c478bd9Sstevel@tonic-gate
14527c478bd9Sstevel@tonic-gate /* Now see how many characters we can read back */
14537c478bd9Sstevel@tonic-gate for (i = 0; i < asy->asy_fifo_buf * 3; i++) {
14544ab75253Smrj ret = ddi_get8(asy->asy_iohandle,
14557c478bd9Sstevel@tonic-gate asy->asy_ioaddr + LSR);
14567c478bd9Sstevel@tonic-gate if (!(ret & RCA))
14577c478bd9Sstevel@tonic-gate break; /* FIFO emptied */
14584ab75253Smrj (void) ddi_get8(asy->asy_iohandle,
14597c478bd9Sstevel@tonic-gate asy->asy_ioaddr + DAT); /* lose another */
14607c478bd9Sstevel@tonic-gate }
14617c478bd9Sstevel@tonic-gate
14627c478bd9Sstevel@tonic-gate DEBUGCONT3(ASY_DEBUG_CHIP,
14637c478bd9Sstevel@tonic-gate "asy%d FIFO size: expected=%d, measured=%d\n",
14647c478bd9Sstevel@tonic-gate asy->asy_unit, asy->asy_fifo_buf, i);
14657c478bd9Sstevel@tonic-gate
14667c478bd9Sstevel@tonic-gate hwtype = asy->asy_hwtype;
14677c478bd9Sstevel@tonic-gate if (i < asy->asy_fifo_buf) {
14687c478bd9Sstevel@tonic-gate /*
14697c478bd9Sstevel@tonic-gate * FIFO is somewhat smaller than we anticipated.
14707c478bd9Sstevel@tonic-gate * If we have 16 characters usable, then this
14717c478bd9Sstevel@tonic-gate * UART will probably work well enough in
14727c478bd9Sstevel@tonic-gate * 16550A mode. If less than 16 characters,
14737c478bd9Sstevel@tonic-gate * then we'd better not use it at all.
14747c478bd9Sstevel@tonic-gate * UARTs with busted FIFOs do crop up.
14757c478bd9Sstevel@tonic-gate */
14767c478bd9Sstevel@tonic-gate if (i >= 16 && asy->asy_fifo_buf >= 16) {
14777c478bd9Sstevel@tonic-gate /* fall back to a 16550A */
14787c478bd9Sstevel@tonic-gate hwtype = ASY16550A;
14797c478bd9Sstevel@tonic-gate asy->asy_fifo_buf = 16;
14807c478bd9Sstevel@tonic-gate asy->asy_fifor &= ~(FIFOEXTRA1 | FIFOEXTRA2);
14817c478bd9Sstevel@tonic-gate } else {
14827c478bd9Sstevel@tonic-gate /* fall back to no FIFO at all */
14837c478bd9Sstevel@tonic-gate hwtype = ASY16550;
14847c478bd9Sstevel@tonic-gate asy->asy_fifo_buf = 1;
14857c478bd9Sstevel@tonic-gate asy->asy_use_fifo = FIFO_OFF;
14867c478bd9Sstevel@tonic-gate asy->asy_fifor &=
14877c478bd9Sstevel@tonic-gate ~(FIFO_ON | FIFOEXTRA1 | FIFOEXTRA2);
14887c478bd9Sstevel@tonic-gate }
14897c478bd9Sstevel@tonic-gate }
14907c478bd9Sstevel@tonic-gate /*
14917c478bd9Sstevel@tonic-gate * We will need to reprogram the FIFO if we changed
14927c478bd9Sstevel@tonic-gate * our mind about how to drive it above, and in any
14937c478bd9Sstevel@tonic-gate * case, it would be a good idea to flush any garbage
14947c478bd9Sstevel@tonic-gate * out incase the loopback test left anything behind.
14957c478bd9Sstevel@tonic-gate * Again as earlier above, we must call asy_reset_fifo()
14967c478bd9Sstevel@tonic-gate * before any possible downgrade of asy->asy_hwtype.
14977c478bd9Sstevel@tonic-gate */
14987c478bd9Sstevel@tonic-gate if (asy->asy_hwtype >= ASY16650 && hwtype < ASY16650) {
14997c478bd9Sstevel@tonic-gate /* Disable 16650 enhanced mode */
15004ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
15017c478bd9Sstevel@tonic-gate EFRACCESS);
15024ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + EFR,
15037c478bd9Sstevel@tonic-gate 0);
15044ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
15057c478bd9Sstevel@tonic-gate STOP1|BITS8);
15067c478bd9Sstevel@tonic-gate }
15077c478bd9Sstevel@tonic-gate asy_reset_fifo(asy, FIFOTXFLSH | FIFORXFLSH);
15087c478bd9Sstevel@tonic-gate asy->asy_hwtype = hwtype;
15097c478bd9Sstevel@tonic-gate
15107c478bd9Sstevel@tonic-gate /* Clear loopback mode and restore DTR/RTS */
15114ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR, mcr);
15127c478bd9Sstevel@tonic-gate }
15137c478bd9Sstevel@tonic-gate
15147c478bd9Sstevel@tonic-gate DEBUGNOTE3(ASY_DEBUG_CHIP, "asy%d %s @ %p",
15157c478bd9Sstevel@tonic-gate asy->asy_unit, asy_hw_name(asy), (void *)asy->asy_ioaddr);
15167c478bd9Sstevel@tonic-gate
15177c478bd9Sstevel@tonic-gate /* Make UART type visible in device tree for prtconf, etc */
15187c478bd9Sstevel@tonic-gate dev = makedevice(DDI_MAJOR_T_UNKNOWN, asy->asy_unit);
15197c478bd9Sstevel@tonic-gate (void) ddi_prop_update_string(dev, devi, "uart", asy_hw_name(asy));
15207c478bd9Sstevel@tonic-gate
15217c478bd9Sstevel@tonic-gate if (asy->asy_hwtype == ASY16550) /* for broken 16550's, */
15227c478bd9Sstevel@tonic-gate asy->asy_hwtype = ASY8250A; /* drive them as 8250A */
15237c478bd9Sstevel@tonic-gate
15247c478bd9Sstevel@tonic-gate return (DDI_SUCCESS);
15257c478bd9Sstevel@tonic-gate }
15267c478bd9Sstevel@tonic-gate
15277c478bd9Sstevel@tonic-gate /*
15287c478bd9Sstevel@tonic-gate * asyinit() initializes the TTY protocol-private data for this channel
15297c478bd9Sstevel@tonic-gate * before enabling the interrupts.
15307c478bd9Sstevel@tonic-gate */
15317c478bd9Sstevel@tonic-gate static void
asyinit(struct asycom * asy)15327c478bd9Sstevel@tonic-gate asyinit(struct asycom *asy)
15337c478bd9Sstevel@tonic-gate {
15347c478bd9Sstevel@tonic-gate struct asyncline *async;
15357c478bd9Sstevel@tonic-gate
15367c478bd9Sstevel@tonic-gate asy->asy_priv = kmem_zalloc(sizeof (struct asyncline), KM_SLEEP);
15377c478bd9Sstevel@tonic-gate async = asy->asy_priv;
15387c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
15397c478bd9Sstevel@tonic-gate async->async_common = asy;
15407c478bd9Sstevel@tonic-gate cv_init(&async->async_flags_cv, NULL, CV_DRIVER, NULL);
15417c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
15427c478bd9Sstevel@tonic-gate }
15437c478bd9Sstevel@tonic-gate
15447c478bd9Sstevel@tonic-gate /*ARGSUSED3*/
15457c478bd9Sstevel@tonic-gate static int
asyopen(queue_t * rq,dev_t * dev,int flag,int sflag,cred_t * cr)15467c478bd9Sstevel@tonic-gate asyopen(queue_t *rq, dev_t *dev, int flag, int sflag, cred_t *cr)
15477c478bd9Sstevel@tonic-gate {
15487c478bd9Sstevel@tonic-gate struct asycom *asy;
15497c478bd9Sstevel@tonic-gate struct asyncline *async;
15507c478bd9Sstevel@tonic-gate int mcr;
15517c478bd9Sstevel@tonic-gate int unit;
15527c478bd9Sstevel@tonic-gate int len;
15537c478bd9Sstevel@tonic-gate struct termios *termiosp;
15547c478bd9Sstevel@tonic-gate
15557c478bd9Sstevel@tonic-gate unit = UNIT(*dev);
15567c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_CLOSE, "asy%dopen\n", unit);
15577c478bd9Sstevel@tonic-gate asy = ddi_get_soft_state(asy_soft_state, unit);
15587c478bd9Sstevel@tonic-gate if (asy == NULL)
15597c478bd9Sstevel@tonic-gate return (ENXIO); /* unit not configured */
15607c478bd9Sstevel@tonic-gate async = asy->asy_priv;
15617c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
15627c478bd9Sstevel@tonic-gate
15637c478bd9Sstevel@tonic-gate again:
15647c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
15657c478bd9Sstevel@tonic-gate
15667c478bd9Sstevel@tonic-gate /*
15677c478bd9Sstevel@tonic-gate * Block waiting for carrier to come up, unless this is a no-delay open.
15687c478bd9Sstevel@tonic-gate */
15697c478bd9Sstevel@tonic-gate if (!(async->async_flags & ASYNC_ISOPEN)) {
15707c478bd9Sstevel@tonic-gate /*
15717c478bd9Sstevel@tonic-gate * Set the default termios settings (cflag).
15727c478bd9Sstevel@tonic-gate * Others are set in ldterm.
15737c478bd9Sstevel@tonic-gate */
15747c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
15757c478bd9Sstevel@tonic-gate
15767c478bd9Sstevel@tonic-gate if (ddi_getlongprop(DDI_DEV_T_ANY, ddi_root_node(),
15777c478bd9Sstevel@tonic-gate 0, "ttymodes",
15787c478bd9Sstevel@tonic-gate (caddr_t)&termiosp, &len) == DDI_PROP_SUCCESS &&
15797c478bd9Sstevel@tonic-gate len == sizeof (struct termios)) {
15807c478bd9Sstevel@tonic-gate async->async_ttycommon.t_cflag = termiosp->c_cflag;
15817c478bd9Sstevel@tonic-gate kmem_free(termiosp, len);
15827c478bd9Sstevel@tonic-gate } else
15837c478bd9Sstevel@tonic-gate cmn_err(CE_WARN,
15847c478bd9Sstevel@tonic-gate "asy: couldn't get ttymodes property!");
15857c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
15867c478bd9Sstevel@tonic-gate
15877c478bd9Sstevel@tonic-gate /* eeprom mode support - respect properties */
15887c478bd9Sstevel@tonic-gate if (asy->asy_cflag)
15897c478bd9Sstevel@tonic-gate async->async_ttycommon.t_cflag = asy->asy_cflag;
15907c478bd9Sstevel@tonic-gate
15917c478bd9Sstevel@tonic-gate async->async_ttycommon.t_iflag = 0;
15927c478bd9Sstevel@tonic-gate async->async_ttycommon.t_iocpending = NULL;
15937c478bd9Sstevel@tonic-gate async->async_ttycommon.t_size.ws_row = 0;
15947c478bd9Sstevel@tonic-gate async->async_ttycommon.t_size.ws_col = 0;
15957c478bd9Sstevel@tonic-gate async->async_ttycommon.t_size.ws_xpixel = 0;
15967c478bd9Sstevel@tonic-gate async->async_ttycommon.t_size.ws_ypixel = 0;
15977c478bd9Sstevel@tonic-gate async->async_dev = *dev;
15987c478bd9Sstevel@tonic-gate async->async_wbufcid = 0;
15997c478bd9Sstevel@tonic-gate
16007c478bd9Sstevel@tonic-gate async->async_startc = CSTART;
16017c478bd9Sstevel@tonic-gate async->async_stopc = CSTOP;
16027c478bd9Sstevel@tonic-gate asy_program(asy, ASY_INIT);
16032df1fe9cSrandyf } else
16042df1fe9cSrandyf if ((async->async_ttycommon.t_flags & TS_XCLUDE) &&
16057c478bd9Sstevel@tonic-gate secpolicy_excl_open(cr) != 0) {
16067c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
16077c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
16087c478bd9Sstevel@tonic-gate return (EBUSY);
16097c478bd9Sstevel@tonic-gate } else if ((*dev & OUTLINE) && !(async->async_flags & ASYNC_OUT)) {
16107c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
16117c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
16127c478bd9Sstevel@tonic-gate return (EBUSY);
16137c478bd9Sstevel@tonic-gate }
16147c478bd9Sstevel@tonic-gate
16157c478bd9Sstevel@tonic-gate if (*dev & OUTLINE)
16167c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_OUT;
16177c478bd9Sstevel@tonic-gate
16187c478bd9Sstevel@tonic-gate /* Raise DTR on every open, but delay if it was just lowered. */
16197c478bd9Sstevel@tonic-gate while (async->async_flags & ASYNC_DTR_DELAY) {
16207c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_MODEM,
16217c478bd9Sstevel@tonic-gate "asy%dopen: waiting for the ASYNC_DTR_DELAY to be clear\n",
16227c478bd9Sstevel@tonic-gate unit);
16237c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
16247c478bd9Sstevel@tonic-gate if (cv_wait_sig(&async->async_flags_cv,
16257c478bd9Sstevel@tonic-gate &asy->asy_excl) == 0) {
16267c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_MODEM,
16277c478bd9Sstevel@tonic-gate "asy%dopen: interrupted by signal, exiting\n",
16287c478bd9Sstevel@tonic-gate unit);
16297c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
16307c478bd9Sstevel@tonic-gate return (EINTR);
16317c478bd9Sstevel@tonic-gate }
16327c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
16337c478bd9Sstevel@tonic-gate }
16347c478bd9Sstevel@tonic-gate
16354ab75253Smrj mcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MCR);
16364ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
16377c478bd9Sstevel@tonic-gate mcr|(asy->asy_mcr&DTR));
16387c478bd9Sstevel@tonic-gate
16397c478bd9Sstevel@tonic-gate DEBUGCONT3(ASY_DEBUG_INIT,
16407c478bd9Sstevel@tonic-gate "asy%dopen: \"Raise DTR on every open\": make mcr = %x, "
16417c478bd9Sstevel@tonic-gate "make TS_SOFTCAR = %s\n",
16427c478bd9Sstevel@tonic-gate unit, mcr|(asy->asy_mcr&DTR),
16437c478bd9Sstevel@tonic-gate (asy->asy_flags & ASY_IGNORE_CD) ? "ON" : "OFF");
16442df1fe9cSrandyf
16457c478bd9Sstevel@tonic-gate if (asy->asy_flags & ASY_IGNORE_CD) {
16467c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_MODEM,
16477c478bd9Sstevel@tonic-gate "asy%dopen: ASY_IGNORE_CD set, set TS_SOFTCAR\n",
16487c478bd9Sstevel@tonic-gate unit);
16497c478bd9Sstevel@tonic-gate async->async_ttycommon.t_flags |= TS_SOFTCAR;
16507c478bd9Sstevel@tonic-gate }
16517c478bd9Sstevel@tonic-gate else
16527c478bd9Sstevel@tonic-gate async->async_ttycommon.t_flags &= ~TS_SOFTCAR;
16537c478bd9Sstevel@tonic-gate
16547c478bd9Sstevel@tonic-gate /*
16557c478bd9Sstevel@tonic-gate * Check carrier.
16567c478bd9Sstevel@tonic-gate */
16574ab75253Smrj asy->asy_msr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MSR);
16587c478bd9Sstevel@tonic-gate DEBUGCONT3(ASY_DEBUG_INIT, "asy%dopen: TS_SOFTCAR is %s, "
16597c478bd9Sstevel@tonic-gate "MSR & DCD is %s\n",
16607c478bd9Sstevel@tonic-gate unit,
16617c478bd9Sstevel@tonic-gate (async->async_ttycommon.t_flags & TS_SOFTCAR) ? "set" : "clear",
16627c478bd9Sstevel@tonic-gate (asy->asy_msr & DCD) ? "set" : "clear");
16632df1fe9cSrandyf
16647c478bd9Sstevel@tonic-gate if (asy->asy_msr & DCD)
16657c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_CARR_ON;
16667c478bd9Sstevel@tonic-gate else
16677c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_CARR_ON;
16687c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
16697c478bd9Sstevel@tonic-gate
16707c478bd9Sstevel@tonic-gate /*
16717c478bd9Sstevel@tonic-gate * If FNDELAY and FNONBLOCK are clear, block until carrier up.
16727c478bd9Sstevel@tonic-gate * Quit on interrupt.
16737c478bd9Sstevel@tonic-gate */
16747c478bd9Sstevel@tonic-gate if (!(flag & (FNDELAY|FNONBLOCK)) &&
16757c478bd9Sstevel@tonic-gate !(async->async_ttycommon.t_cflag & CLOCAL)) {
16767c478bd9Sstevel@tonic-gate if ((!(async->async_flags & (ASYNC_CARR_ON|ASYNC_OUT)) &&
16777c478bd9Sstevel@tonic-gate !(async->async_ttycommon.t_flags & TS_SOFTCAR)) ||
16787c478bd9Sstevel@tonic-gate ((async->async_flags & ASYNC_OUT) &&
16797c478bd9Sstevel@tonic-gate !(*dev & OUTLINE))) {
16807c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_WOPEN;
16817c478bd9Sstevel@tonic-gate if (cv_wait_sig(&async->async_flags_cv,
16827c478bd9Sstevel@tonic-gate &asy->asy_excl) == B_FALSE) {
16837c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_WOPEN;
16847c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
16857c478bd9Sstevel@tonic-gate return (EINTR);
16867c478bd9Sstevel@tonic-gate }
16877c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_WOPEN;
16887c478bd9Sstevel@tonic-gate goto again;
16897c478bd9Sstevel@tonic-gate }
16907c478bd9Sstevel@tonic-gate } else if ((async->async_flags & ASYNC_OUT) && !(*dev & OUTLINE)) {
16917c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
16927c478bd9Sstevel@tonic-gate return (EBUSY);
16937c478bd9Sstevel@tonic-gate }
16947c478bd9Sstevel@tonic-gate
16957c478bd9Sstevel@tonic-gate async->async_ttycommon.t_readq = rq;
16967c478bd9Sstevel@tonic-gate async->async_ttycommon.t_writeq = WR(rq);
16977c478bd9Sstevel@tonic-gate rq->q_ptr = WR(rq)->q_ptr = (caddr_t)async;
16987c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
16997c478bd9Sstevel@tonic-gate /*
17007c478bd9Sstevel@tonic-gate * Caution here -- qprocson sets the pointers that are used by canput
17017c478bd9Sstevel@tonic-gate * called by async_softint. ASYNC_ISOPEN must *not* be set until those
17027c478bd9Sstevel@tonic-gate * pointers are valid.
17037c478bd9Sstevel@tonic-gate */
17047c478bd9Sstevel@tonic-gate qprocson(rq);
17057c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_ISOPEN;
17067c478bd9Sstevel@tonic-gate async->async_polltid = 0;
17077c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_INIT, "asy%dopen: done\n", unit);
17087c478bd9Sstevel@tonic-gate return (0);
17097c478bd9Sstevel@tonic-gate }
17107c478bd9Sstevel@tonic-gate
17117c478bd9Sstevel@tonic-gate static void
async_progress_check(void * arg)17127c478bd9Sstevel@tonic-gate async_progress_check(void *arg)
17137c478bd9Sstevel@tonic-gate {
17147c478bd9Sstevel@tonic-gate struct asyncline *async = arg;
17157c478bd9Sstevel@tonic-gate struct asycom *asy = async->async_common;
17167c478bd9Sstevel@tonic-gate mblk_t *bp;
17177c478bd9Sstevel@tonic-gate
17187c478bd9Sstevel@tonic-gate /*
17197c478bd9Sstevel@tonic-gate * We define "progress" as either waiting on a timed break or delay, or
17207c478bd9Sstevel@tonic-gate * having had at least one transmitter interrupt. If none of these are
17217c478bd9Sstevel@tonic-gate * true, then just terminate the output and wake up that close thread.
17227c478bd9Sstevel@tonic-gate */
17237c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
17247c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
17257c478bd9Sstevel@tonic-gate if (!(async->async_flags & (ASYNC_BREAK|ASYNC_DELAY|ASYNC_PROGRESS))) {
17267c478bd9Sstevel@tonic-gate async->async_ocnt = 0;
17277c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_BUSY;
17287c478bd9Sstevel@tonic-gate async->async_timer = 0;
17297c478bd9Sstevel@tonic-gate bp = async->async_xmitblk;
17307c478bd9Sstevel@tonic-gate async->async_xmitblk = NULL;
17317c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
17327c478bd9Sstevel@tonic-gate if (bp != NULL)
17337c478bd9Sstevel@tonic-gate freeb(bp);
17347c478bd9Sstevel@tonic-gate /*
17357c478bd9Sstevel@tonic-gate * Since this timer is running, we know that we're in exit(2).
17367c478bd9Sstevel@tonic-gate * That means that the user can't possibly be waiting on any
17377c478bd9Sstevel@tonic-gate * valid ioctl(2) completion anymore, and we should just flush
17387c478bd9Sstevel@tonic-gate * everything.
17397c478bd9Sstevel@tonic-gate */
17407c478bd9Sstevel@tonic-gate flushq(async->async_ttycommon.t_writeq, FLUSHALL);
17417c478bd9Sstevel@tonic-gate cv_broadcast(&async->async_flags_cv);
17427c478bd9Sstevel@tonic-gate } else {
17437c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_PROGRESS;
17447c478bd9Sstevel@tonic-gate async->async_timer = timeout(async_progress_check, async,
17457c478bd9Sstevel@tonic-gate drv_usectohz(asy_drain_check));
17467c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
17477c478bd9Sstevel@tonic-gate }
17487c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
17497c478bd9Sstevel@tonic-gate }
17507c478bd9Sstevel@tonic-gate
17517c478bd9Sstevel@tonic-gate /*
17527c478bd9Sstevel@tonic-gate * Release DTR so that asyopen() can raise it.
17537c478bd9Sstevel@tonic-gate */
17547c478bd9Sstevel@tonic-gate static void
async_dtr_free(struct asyncline * async)17557c478bd9Sstevel@tonic-gate async_dtr_free(struct asyncline *async)
17567c478bd9Sstevel@tonic-gate {
17577c478bd9Sstevel@tonic-gate struct asycom *asy = async->async_common;
17587c478bd9Sstevel@tonic-gate
17597c478bd9Sstevel@tonic-gate DEBUGCONT0(ASY_DEBUG_MODEM,
17607c478bd9Sstevel@tonic-gate "async_dtr_free, clearing ASYNC_DTR_DELAY\n");
17617c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
17627c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_DTR_DELAY;
17637c478bd9Sstevel@tonic-gate async->async_dtrtid = 0;
17647c478bd9Sstevel@tonic-gate cv_broadcast(&async->async_flags_cv);
17657c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
17667c478bd9Sstevel@tonic-gate }
17677c478bd9Sstevel@tonic-gate
17687c478bd9Sstevel@tonic-gate /*
17697c478bd9Sstevel@tonic-gate * Close routine.
17707c478bd9Sstevel@tonic-gate */
17717c478bd9Sstevel@tonic-gate /*ARGSUSED2*/
17727c478bd9Sstevel@tonic-gate static int
asyclose(queue_t * q,int flag,cred_t * credp)17737c478bd9Sstevel@tonic-gate asyclose(queue_t *q, int flag, cred_t *credp)
17747c478bd9Sstevel@tonic-gate {
17757c478bd9Sstevel@tonic-gate struct asyncline *async;
17767c478bd9Sstevel@tonic-gate struct asycom *asy;
17777c478bd9Sstevel@tonic-gate int icr, lcr;
17787c478bd9Sstevel@tonic-gate #ifdef DEBUG
17797c478bd9Sstevel@tonic-gate int instance;
17807c478bd9Sstevel@tonic-gate #endif
17817c478bd9Sstevel@tonic-gate
17827c478bd9Sstevel@tonic-gate async = (struct asyncline *)q->q_ptr;
17837c478bd9Sstevel@tonic-gate ASSERT(async != NULL);
17847c478bd9Sstevel@tonic-gate #ifdef DEBUG
17857c478bd9Sstevel@tonic-gate instance = UNIT(async->async_dev);
17867c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_CLOSE, "asy%dclose\n", instance);
17877c478bd9Sstevel@tonic-gate #endif
17887c478bd9Sstevel@tonic-gate asy = async->async_common;
17897c478bd9Sstevel@tonic-gate
17907c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
17917c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_CLOSING;
17927c478bd9Sstevel@tonic-gate
17937c478bd9Sstevel@tonic-gate /*
17947c478bd9Sstevel@tonic-gate * Turn off PPS handling early to avoid events occuring during
17957c478bd9Sstevel@tonic-gate * close. Also reset the DCD edge monitoring bit.
17967c478bd9Sstevel@tonic-gate */
17977c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
17987c478bd9Sstevel@tonic-gate asy->asy_flags &= ~(ASY_PPS | ASY_PPS_EDGE);
17997c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
18007c478bd9Sstevel@tonic-gate
18017c478bd9Sstevel@tonic-gate /*
18027c478bd9Sstevel@tonic-gate * There are two flavors of break -- timed (M_BREAK or TCSBRK) and
18037c478bd9Sstevel@tonic-gate * untimed (TIOCSBRK). For the timed case, these are enqueued on our
18047c478bd9Sstevel@tonic-gate * write queue and there's a timer running, so we don't have to worry
18057c478bd9Sstevel@tonic-gate * about them. For the untimed case, though, the user obviously made a
18067c478bd9Sstevel@tonic-gate * mistake, because these are handled immediately. We'll terminate the
180748bbca81SDaniel Hoffman * break now and honor their implicit request by discarding the rest of
18087c478bd9Sstevel@tonic-gate * the data.
18097c478bd9Sstevel@tonic-gate */
18107c478bd9Sstevel@tonic-gate if (async->async_flags & ASYNC_OUT_SUSPEND) {
18117c478bd9Sstevel@tonic-gate if (async->async_utbrktid != 0) {
18127c478bd9Sstevel@tonic-gate (void) untimeout(async->async_utbrktid);
18137c478bd9Sstevel@tonic-gate async->async_utbrktid = 0;
18147c478bd9Sstevel@tonic-gate }
18157c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
18164ab75253Smrj lcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
18174ab75253Smrj ddi_put8(asy->asy_iohandle,
18187c478bd9Sstevel@tonic-gate asy->asy_ioaddr + LCR, (lcr & ~SETBREAK));
18197c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
18207c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_OUT_SUSPEND;
18217c478bd9Sstevel@tonic-gate goto nodrain;
18227c478bd9Sstevel@tonic-gate }
18237c478bd9Sstevel@tonic-gate
18247c478bd9Sstevel@tonic-gate /*
18257c478bd9Sstevel@tonic-gate * If the user told us not to delay the close ("non-blocking"), then
18267c478bd9Sstevel@tonic-gate * don't bother trying to drain.
18277c478bd9Sstevel@tonic-gate *
18287c478bd9Sstevel@tonic-gate * If the user did M_STOP (ASYNC_STOPPED), there's no hope of ever
18297c478bd9Sstevel@tonic-gate * getting an M_START (since these messages aren't enqueued), and the
18307c478bd9Sstevel@tonic-gate * only other way to clear the stop condition is by loss of DCD, which
18317c478bd9Sstevel@tonic-gate * would discard the queue data. Thus, we drop the output data if
18327c478bd9Sstevel@tonic-gate * ASYNC_STOPPED is set.
18337c478bd9Sstevel@tonic-gate */
18347c478bd9Sstevel@tonic-gate if ((flag & (FNDELAY|FNONBLOCK)) ||
18357c478bd9Sstevel@tonic-gate (async->async_flags & ASYNC_STOPPED)) {
18367c478bd9Sstevel@tonic-gate goto nodrain;
18377c478bd9Sstevel@tonic-gate }
18387c478bd9Sstevel@tonic-gate
18397c478bd9Sstevel@tonic-gate /*
18407c478bd9Sstevel@tonic-gate * If there's any pending output, then we have to try to drain it.
18417c478bd9Sstevel@tonic-gate * There are two main cases to be handled:
18427c478bd9Sstevel@tonic-gate * - called by close(2): need to drain until done or until
18437c478bd9Sstevel@tonic-gate * a signal is received. No timeout.
18447c478bd9Sstevel@tonic-gate * - called by exit(2): need to drain while making progress
18457c478bd9Sstevel@tonic-gate * or until a timeout occurs. No signals.
18467c478bd9Sstevel@tonic-gate *
18477c478bd9Sstevel@tonic-gate * If we can't rely on receiving a signal to get us out of a hung
18487c478bd9Sstevel@tonic-gate * session, then we have to use a timer. In this case, we set a timer
18497c478bd9Sstevel@tonic-gate * to check for progress in sending the output data -- all that we ask
18507c478bd9Sstevel@tonic-gate * (at each interval) is that there's been some progress made. Since
18517c478bd9Sstevel@tonic-gate * the interrupt routine grabs buffers from the write queue, we can't
18527c478bd9Sstevel@tonic-gate * trust changes in async_ocnt. Instead, we use a progress flag.
18537c478bd9Sstevel@tonic-gate *
18547c478bd9Sstevel@tonic-gate * Note that loss of carrier will cause the output queue to be flushed,
18557c478bd9Sstevel@tonic-gate * and we'll wake up again and finish normally.
18567c478bd9Sstevel@tonic-gate */
18577c478bd9Sstevel@tonic-gate if (!ddi_can_receive_sig() && asy_drain_check != 0) {
18587c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_PROGRESS;
18597c478bd9Sstevel@tonic-gate async->async_timer = timeout(async_progress_check, async,
18607c478bd9Sstevel@tonic-gate drv_usectohz(asy_drain_check));
18617c478bd9Sstevel@tonic-gate }
18627c478bd9Sstevel@tonic-gate while (async->async_ocnt > 0 ||
18637c478bd9Sstevel@tonic-gate async->async_ttycommon.t_writeq->q_first != NULL ||
18647c478bd9Sstevel@tonic-gate (async->async_flags & (ASYNC_BUSY|ASYNC_BREAK|ASYNC_DELAY))) {
18657c478bd9Sstevel@tonic-gate if (cv_wait_sig(&async->async_flags_cv, &asy->asy_excl) == 0)
18667c478bd9Sstevel@tonic-gate break;
18677c478bd9Sstevel@tonic-gate }
18687c478bd9Sstevel@tonic-gate if (async->async_timer != 0) {
18697c478bd9Sstevel@tonic-gate (void) untimeout(async->async_timer);
18707c478bd9Sstevel@tonic-gate async->async_timer = 0;
18717c478bd9Sstevel@tonic-gate }
18727c478bd9Sstevel@tonic-gate
18737c478bd9Sstevel@tonic-gate nodrain:
18747c478bd9Sstevel@tonic-gate async->async_ocnt = 0;
18757c478bd9Sstevel@tonic-gate if (async->async_xmitblk != NULL)
18767c478bd9Sstevel@tonic-gate freeb(async->async_xmitblk);
18777c478bd9Sstevel@tonic-gate async->async_xmitblk = NULL;
18787c478bd9Sstevel@tonic-gate
18797c478bd9Sstevel@tonic-gate /*
18807c478bd9Sstevel@tonic-gate * If line has HUPCL set or is incompletely opened fix up the modem
18817c478bd9Sstevel@tonic-gate * lines.
18827c478bd9Sstevel@tonic-gate */
18832df1fe9cSrandyf DEBUGCONT1(ASY_DEBUG_MODEM, "asy%dclose: next check HUPCL flag\n",
18842df1fe9cSrandyf instance);
18857c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
18867c478bd9Sstevel@tonic-gate if ((async->async_ttycommon.t_cflag & HUPCL) ||
18877c478bd9Sstevel@tonic-gate (async->async_flags & ASYNC_WOPEN)) {
18887c478bd9Sstevel@tonic-gate DEBUGCONT3(ASY_DEBUG_MODEM,
18897c478bd9Sstevel@tonic-gate "asy%dclose: HUPCL flag = %x, ASYNC_WOPEN flag = %x\n",
18907c478bd9Sstevel@tonic-gate instance,
18917c478bd9Sstevel@tonic-gate async->async_ttycommon.t_cflag & HUPCL,
18927c478bd9Sstevel@tonic-gate async->async_ttycommon.t_cflag & ASYNC_WOPEN);
18937c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_DTR_DELAY;
18947c478bd9Sstevel@tonic-gate
18957c478bd9Sstevel@tonic-gate /* turn off DTR, RTS but NOT interrupt to 386 */
18967c478bd9Sstevel@tonic-gate if (asy->asy_flags & (ASY_IGNORE_CD|ASY_RTS_DTR_OFF)) {
18977c478bd9Sstevel@tonic-gate DEBUGCONT3(ASY_DEBUG_MODEM,
18987c478bd9Sstevel@tonic-gate "asy%dclose: ASY_IGNORE_CD flag = %x, "
18997c478bd9Sstevel@tonic-gate "ASY_RTS_DTR_OFF flag = %x\n",
19007c478bd9Sstevel@tonic-gate instance,
19017c478bd9Sstevel@tonic-gate asy->asy_flags & ASY_IGNORE_CD,
19027c478bd9Sstevel@tonic-gate asy->asy_flags & ASY_RTS_DTR_OFF);
19032df1fe9cSrandyf
19042df1fe9cSrandyf ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
19052df1fe9cSrandyf asy->asy_mcr|OUT2);
19067c478bd9Sstevel@tonic-gate } else {
19077c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_MODEM,
19087c478bd9Sstevel@tonic-gate "asy%dclose: Dropping DTR and RTS\n", instance);
19092df1fe9cSrandyf ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
19102df1fe9cSrandyf OUT2);
19117c478bd9Sstevel@tonic-gate }
19127c478bd9Sstevel@tonic-gate async->async_dtrtid =
19137c478bd9Sstevel@tonic-gate timeout((void (*)())async_dtr_free,
19147c478bd9Sstevel@tonic-gate (caddr_t)async, drv_usectohz(asy_min_dtr_low));
19157c478bd9Sstevel@tonic-gate }
19167c478bd9Sstevel@tonic-gate /*
19177c478bd9Sstevel@tonic-gate * If nobody's using it now, turn off receiver interrupts.
19187c478bd9Sstevel@tonic-gate */
19197c478bd9Sstevel@tonic-gate if ((async->async_flags & (ASYNC_WOPEN|ASYNC_ISOPEN)) == 0) {
19202df1fe9cSrandyf icr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + ICR);
19214ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR,
19227c478bd9Sstevel@tonic-gate (icr & ~RIEN));
19237c478bd9Sstevel@tonic-gate }
19247c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
19257c478bd9Sstevel@tonic-gate out:
19267c478bd9Sstevel@tonic-gate ttycommon_close(&async->async_ttycommon);
19277c478bd9Sstevel@tonic-gate
19287c478bd9Sstevel@tonic-gate /*
19297c478bd9Sstevel@tonic-gate * Cancel outstanding "bufcall" request.
19307c478bd9Sstevel@tonic-gate */
19317c478bd9Sstevel@tonic-gate if (async->async_wbufcid != 0) {
19327c478bd9Sstevel@tonic-gate unbufcall(async->async_wbufcid);
19337c478bd9Sstevel@tonic-gate async->async_wbufcid = 0;
19347c478bd9Sstevel@tonic-gate }
19357c478bd9Sstevel@tonic-gate
19367c478bd9Sstevel@tonic-gate /* Note that qprocsoff can't be done until after interrupts are off */
19377c478bd9Sstevel@tonic-gate qprocsoff(q);
19387c478bd9Sstevel@tonic-gate q->q_ptr = WR(q)->q_ptr = NULL;
19397c478bd9Sstevel@tonic-gate async->async_ttycommon.t_readq = NULL;
19407c478bd9Sstevel@tonic-gate async->async_ttycommon.t_writeq = NULL;
19417c478bd9Sstevel@tonic-gate
19427c478bd9Sstevel@tonic-gate /*
19437c478bd9Sstevel@tonic-gate * Clear out device state, except persistant device property flags.
19447c478bd9Sstevel@tonic-gate */
19457c478bd9Sstevel@tonic-gate async->async_flags &= (ASYNC_DTR_DELAY|ASY_RTS_DTR_OFF);
19467c478bd9Sstevel@tonic-gate cv_broadcast(&async->async_flags_cv);
19477c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
19487c478bd9Sstevel@tonic-gate
19497c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_CLOSE, "asy%dclose: done\n", instance);
19507c478bd9Sstevel@tonic-gate return (0);
19517c478bd9Sstevel@tonic-gate }
19527c478bd9Sstevel@tonic-gate
19537c478bd9Sstevel@tonic-gate static boolean_t
asy_isbusy(struct asycom * asy)19547c478bd9Sstevel@tonic-gate asy_isbusy(struct asycom *asy)
19557c478bd9Sstevel@tonic-gate {
19567c478bd9Sstevel@tonic-gate struct asyncline *async;
19577c478bd9Sstevel@tonic-gate
19587c478bd9Sstevel@tonic-gate DEBUGCONT0(ASY_DEBUG_EOT, "asy_isbusy\n");
19597c478bd9Sstevel@tonic-gate async = asy->asy_priv;
19607c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&asy->asy_excl));
19617c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&asy->asy_excl_hi));
19622df1fe9cSrandyf /*
19632df1fe9cSrandyf * XXXX this should be recoded
19642df1fe9cSrandyf */
19657c478bd9Sstevel@tonic-gate return ((async->async_ocnt > 0) ||
19664ab75253Smrj ((ddi_get8(asy->asy_iohandle,
19677c478bd9Sstevel@tonic-gate asy->asy_ioaddr + LSR) & (XSRE|XHRE)) == 0));
19687c478bd9Sstevel@tonic-gate }
19697c478bd9Sstevel@tonic-gate
19707c478bd9Sstevel@tonic-gate static void
asy_waiteot(struct asycom * asy)19717c478bd9Sstevel@tonic-gate asy_waiteot(struct asycom *asy)
19727c478bd9Sstevel@tonic-gate {
19737c478bd9Sstevel@tonic-gate /*
19747c478bd9Sstevel@tonic-gate * Wait for the current transmission block and the
19757c478bd9Sstevel@tonic-gate * current fifo data to transmit. Once this is done
19767c478bd9Sstevel@tonic-gate * we may go on.
19777c478bd9Sstevel@tonic-gate */
19787c478bd9Sstevel@tonic-gate DEBUGCONT0(ASY_DEBUG_EOT, "asy_waiteot\n");
19797c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&asy->asy_excl));
19807c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&asy->asy_excl_hi));
19817c478bd9Sstevel@tonic-gate while (asy_isbusy(asy)) {
19827c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
19837c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
19847c478bd9Sstevel@tonic-gate drv_usecwait(10000); /* wait .01 */
19857c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
19867c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
19877c478bd9Sstevel@tonic-gate }
19887c478bd9Sstevel@tonic-gate }
19897c478bd9Sstevel@tonic-gate
19907c478bd9Sstevel@tonic-gate /* asy_reset_fifo -- flush fifos and [re]program fifo control register */
19917c478bd9Sstevel@tonic-gate static void
asy_reset_fifo(struct asycom * asy,uchar_t flush)19927c478bd9Sstevel@tonic-gate asy_reset_fifo(struct asycom *asy, uchar_t flush)
19937c478bd9Sstevel@tonic-gate {
1994278de290SToomas Soome uchar_t lcr = 0;
19957c478bd9Sstevel@tonic-gate
19967c478bd9Sstevel@tonic-gate /* On a 16750, we have to set DLAB in order to set FIFOEXTRA. */
19977c478bd9Sstevel@tonic-gate
19987c478bd9Sstevel@tonic-gate if (asy->asy_hwtype >= ASY16750) {
19994ab75253Smrj lcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
20004ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
20017c478bd9Sstevel@tonic-gate lcr | DLAB);
20027c478bd9Sstevel@tonic-gate }
20037c478bd9Sstevel@tonic-gate
20044ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + FIFOR,
20057c478bd9Sstevel@tonic-gate asy->asy_fifor | flush);
20067c478bd9Sstevel@tonic-gate
20077c478bd9Sstevel@tonic-gate /* Clear DLAB */
20087c478bd9Sstevel@tonic-gate
20097c478bd9Sstevel@tonic-gate if (asy->asy_hwtype >= ASY16750) {
20104ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, lcr);
20117c478bd9Sstevel@tonic-gate }
20127c478bd9Sstevel@tonic-gate }
20137c478bd9Sstevel@tonic-gate
20147c478bd9Sstevel@tonic-gate /*
20157c478bd9Sstevel@tonic-gate * Program the ASY port. Most of the async operation is based on the values
20167c478bd9Sstevel@tonic-gate * of 'c_iflag' and 'c_cflag'.
20177c478bd9Sstevel@tonic-gate */
20187c478bd9Sstevel@tonic-gate
20197c478bd9Sstevel@tonic-gate #define BAUDINDEX(cflg) (((cflg) & CBAUDEXT) ? \
20207c478bd9Sstevel@tonic-gate (((cflg) & CBAUD) + CBAUD + 1) : ((cflg) & CBAUD))
20217c478bd9Sstevel@tonic-gate
20227c478bd9Sstevel@tonic-gate static void
asy_program(struct asycom * asy,int mode)20237c478bd9Sstevel@tonic-gate asy_program(struct asycom *asy, int mode)
20247c478bd9Sstevel@tonic-gate {
20257c478bd9Sstevel@tonic-gate struct asyncline *async;
20267c478bd9Sstevel@tonic-gate int baudrate, c_flag;
20277c478bd9Sstevel@tonic-gate int icr, lcr;
20287c478bd9Sstevel@tonic-gate int flush_reg;
20297c478bd9Sstevel@tonic-gate int ocflags;
20307c478bd9Sstevel@tonic-gate #ifdef DEBUG
20317c478bd9Sstevel@tonic-gate int instance;
20327c478bd9Sstevel@tonic-gate #endif
20337c478bd9Sstevel@tonic-gate
20347c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&asy->asy_excl));
20357c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&asy->asy_excl_hi));
20367c478bd9Sstevel@tonic-gate
20377c478bd9Sstevel@tonic-gate async = asy->asy_priv;
20387c478bd9Sstevel@tonic-gate #ifdef DEBUG
20397c478bd9Sstevel@tonic-gate instance = UNIT(async->async_dev);
20407c478bd9Sstevel@tonic-gate DEBUGCONT2(ASY_DEBUG_PROCS,
20417c478bd9Sstevel@tonic-gate "asy%d_program: mode = 0x%08X, enter\n", instance, mode);
20427c478bd9Sstevel@tonic-gate #endif
20437c478bd9Sstevel@tonic-gate
20447c478bd9Sstevel@tonic-gate baudrate = BAUDINDEX(async->async_ttycommon.t_cflag);
20457c478bd9Sstevel@tonic-gate
20467c478bd9Sstevel@tonic-gate async->async_ttycommon.t_cflag &= ~(CIBAUD);
20477c478bd9Sstevel@tonic-gate
20487c478bd9Sstevel@tonic-gate if (baudrate > CBAUD) {
20497c478bd9Sstevel@tonic-gate async->async_ttycommon.t_cflag |= CIBAUDEXT;
20507c478bd9Sstevel@tonic-gate async->async_ttycommon.t_cflag |=
20517c478bd9Sstevel@tonic-gate (((baudrate - CBAUD - 1) << IBSHIFT) & CIBAUD);
20527c478bd9Sstevel@tonic-gate } else {
20537c478bd9Sstevel@tonic-gate async->async_ttycommon.t_cflag &= ~CIBAUDEXT;
20547c478bd9Sstevel@tonic-gate async->async_ttycommon.t_cflag |=
20557c478bd9Sstevel@tonic-gate ((baudrate << IBSHIFT) & CIBAUD);
20567c478bd9Sstevel@tonic-gate }
20577c478bd9Sstevel@tonic-gate
20587c478bd9Sstevel@tonic-gate c_flag = async->async_ttycommon.t_cflag &
20597c478bd9Sstevel@tonic-gate (CLOCAL|CREAD|CSTOPB|CSIZE|PARENB|PARODD|CBAUD|CBAUDEXT);
20607c478bd9Sstevel@tonic-gate
20617c478bd9Sstevel@tonic-gate /* disable interrupts */
20624ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
20637c478bd9Sstevel@tonic-gate
20647c478bd9Sstevel@tonic-gate ocflags = asy->asy_ocflag;
20657c478bd9Sstevel@tonic-gate
20667c478bd9Sstevel@tonic-gate /* flush/reset the status registers */
20674ab75253Smrj (void) ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + ISR);
20684ab75253Smrj (void) ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR);
20694ab75253Smrj asy->asy_msr = flush_reg = ddi_get8(asy->asy_iohandle,
20707c478bd9Sstevel@tonic-gate asy->asy_ioaddr + MSR);
20717c478bd9Sstevel@tonic-gate /*
20727c478bd9Sstevel@tonic-gate * The device is programmed in the open sequence, if we
20737c478bd9Sstevel@tonic-gate * have to hardware handshake, then this is a good time
20747c478bd9Sstevel@tonic-gate * to check if the device can receive any data.
20757c478bd9Sstevel@tonic-gate */
20767c478bd9Sstevel@tonic-gate
20777c478bd9Sstevel@tonic-gate if ((CRTSCTS & async->async_ttycommon.t_cflag) && !(flush_reg & CTS)) {
20787c478bd9Sstevel@tonic-gate async_flowcontrol_hw_output(asy, FLOW_STOP);
20797c478bd9Sstevel@tonic-gate } else {
20807c478bd9Sstevel@tonic-gate /*
20817c478bd9Sstevel@tonic-gate * We can not use async_flowcontrol_hw_output(asy, FLOW_START)
20827c478bd9Sstevel@tonic-gate * here, because if CRTSCTS is clear, we need clear
20837c478bd9Sstevel@tonic-gate * ASYNC_HW_OUT_FLW bit.
20847c478bd9Sstevel@tonic-gate */
20857c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_HW_OUT_FLW;
20867c478bd9Sstevel@tonic-gate }
20877c478bd9Sstevel@tonic-gate
20887c478bd9Sstevel@tonic-gate /*
20897c478bd9Sstevel@tonic-gate * If IXON is not set, clear ASYNC_SW_OUT_FLW;
20907c478bd9Sstevel@tonic-gate * If IXON is set, no matter what IXON flag is before this
20917c478bd9Sstevel@tonic-gate * function call to asy_program,
20927c478bd9Sstevel@tonic-gate * we will use the old ASYNC_SW_OUT_FLW status.
20937c478bd9Sstevel@tonic-gate * Because of handling IXON in the driver, we also should re-calculate
20947c478bd9Sstevel@tonic-gate * the value of ASYNC_OUT_FLW_RESUME bit, but in fact,
20957c478bd9Sstevel@tonic-gate * the TCSET* commands which call asy_program
20967c478bd9Sstevel@tonic-gate * are put into the write queue, so there is no output needed to
20977c478bd9Sstevel@tonic-gate * be resumed at this point.
20987c478bd9Sstevel@tonic-gate */
20997c478bd9Sstevel@tonic-gate if (!(IXON & async->async_ttycommon.t_iflag))
21007c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_SW_OUT_FLW;
21017c478bd9Sstevel@tonic-gate
21027c478bd9Sstevel@tonic-gate /* manually flush receive buffer or fifo (workaround for buggy fifos) */
21037c478bd9Sstevel@tonic-gate if (mode == ASY_INIT)
21047c478bd9Sstevel@tonic-gate if (asy->asy_use_fifo == FIFO_ON) {
21057c478bd9Sstevel@tonic-gate for (flush_reg = asy->asy_fifo_buf; flush_reg-- > 0; ) {
21064ab75253Smrj (void) ddi_get8(asy->asy_iohandle,
21077c478bd9Sstevel@tonic-gate asy->asy_ioaddr + DAT);
21087c478bd9Sstevel@tonic-gate }
21097c478bd9Sstevel@tonic-gate } else {
21104ab75253Smrj flush_reg = ddi_get8(asy->asy_iohandle,
21117c478bd9Sstevel@tonic-gate asy->asy_ioaddr + DAT);
21127c478bd9Sstevel@tonic-gate }
21137c478bd9Sstevel@tonic-gate
21147c478bd9Sstevel@tonic-gate if (ocflags != (c_flag & ~CLOCAL) || mode == ASY_INIT) {
21157c478bd9Sstevel@tonic-gate /* Set line control */
21162df1fe9cSrandyf lcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
21177c478bd9Sstevel@tonic-gate lcr &= ~(WLS0|WLS1|STB|PEN|EPS);
21187c478bd9Sstevel@tonic-gate
21197c478bd9Sstevel@tonic-gate if (c_flag & CSTOPB)
21207c478bd9Sstevel@tonic-gate lcr |= STB; /* 2 stop bits */
21217c478bd9Sstevel@tonic-gate
21227c478bd9Sstevel@tonic-gate if (c_flag & PARENB)
21237c478bd9Sstevel@tonic-gate lcr |= PEN;
21247c478bd9Sstevel@tonic-gate
21257c478bd9Sstevel@tonic-gate if ((c_flag & PARODD) == 0)
21267c478bd9Sstevel@tonic-gate lcr |= EPS;
21277c478bd9Sstevel@tonic-gate
21287c478bd9Sstevel@tonic-gate switch (c_flag & CSIZE) {
21297c478bd9Sstevel@tonic-gate case CS5:
21307c478bd9Sstevel@tonic-gate lcr |= BITS5;
21317c478bd9Sstevel@tonic-gate break;
21327c478bd9Sstevel@tonic-gate case CS6:
21337c478bd9Sstevel@tonic-gate lcr |= BITS6;
21347c478bd9Sstevel@tonic-gate break;
21357c478bd9Sstevel@tonic-gate case CS7:
21367c478bd9Sstevel@tonic-gate lcr |= BITS7;
21377c478bd9Sstevel@tonic-gate break;
21387c478bd9Sstevel@tonic-gate case CS8:
21397c478bd9Sstevel@tonic-gate lcr |= BITS8;
21407c478bd9Sstevel@tonic-gate break;
21417c478bd9Sstevel@tonic-gate }
21427c478bd9Sstevel@tonic-gate
21437c478bd9Sstevel@tonic-gate /* set the baud rate, unless it is "0" */
21442df1fe9cSrandyf ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, DLAB);
21452df1fe9cSrandyf
21467c478bd9Sstevel@tonic-gate if (baudrate != 0) {
21474ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT,
21487c478bd9Sstevel@tonic-gate asyspdtab[baudrate] & 0xff);
21494ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR,
21507c478bd9Sstevel@tonic-gate (asyspdtab[baudrate] >> 8) & 0xff);
21517c478bd9Sstevel@tonic-gate }
21527c478bd9Sstevel@tonic-gate /* set the line control modes */
21534ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, lcr);
21547c478bd9Sstevel@tonic-gate
21557c478bd9Sstevel@tonic-gate /*
21567c478bd9Sstevel@tonic-gate * If we have a FIFO buffer, enable/flush
21577c478bd9Sstevel@tonic-gate * at intialize time, flush if transitioning from
21587c478bd9Sstevel@tonic-gate * CREAD off to CREAD on.
21597c478bd9Sstevel@tonic-gate */
21607c478bd9Sstevel@tonic-gate if ((ocflags & CREAD) == 0 && (c_flag & CREAD) ||
21617c478bd9Sstevel@tonic-gate mode == ASY_INIT)
21627c478bd9Sstevel@tonic-gate if (asy->asy_use_fifo == FIFO_ON)
21637c478bd9Sstevel@tonic-gate asy_reset_fifo(asy, FIFORXFLSH);
21647c478bd9Sstevel@tonic-gate
21657c478bd9Sstevel@tonic-gate /* remember the new cflags */
21667c478bd9Sstevel@tonic-gate asy->asy_ocflag = c_flag & ~CLOCAL;
21677c478bd9Sstevel@tonic-gate }
21687c478bd9Sstevel@tonic-gate
21697c478bd9Sstevel@tonic-gate if (baudrate == 0)
21704ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
21717c478bd9Sstevel@tonic-gate (asy->asy_mcr & RTS) | OUT2);
21727c478bd9Sstevel@tonic-gate else
21734ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
21747c478bd9Sstevel@tonic-gate asy->asy_mcr | OUT2);
21757c478bd9Sstevel@tonic-gate
21767c478bd9Sstevel@tonic-gate /*
21777c478bd9Sstevel@tonic-gate * Call the modem status interrupt handler to check for the carrier
21787c478bd9Sstevel@tonic-gate * in case CLOCAL was turned off after the carrier came on.
21797c478bd9Sstevel@tonic-gate * (Note: Modem status interrupt is not enabled if CLOCAL is ON.)
21807c478bd9Sstevel@tonic-gate */
21817c478bd9Sstevel@tonic-gate async_msint(asy);
21827c478bd9Sstevel@tonic-gate
21837c478bd9Sstevel@tonic-gate /* Set interrupt control */
21847c478bd9Sstevel@tonic-gate DEBUGCONT3(ASY_DEBUG_MODM2,
21857c478bd9Sstevel@tonic-gate "asy%d_program: c_flag & CLOCAL = %x t_cflag & CRTSCTS = %x\n",
21862df1fe9cSrandyf instance, c_flag & CLOCAL,
21877c478bd9Sstevel@tonic-gate async->async_ttycommon.t_cflag & CRTSCTS);
21882df1fe9cSrandyf
21897c478bd9Sstevel@tonic-gate if ((c_flag & CLOCAL) && !(async->async_ttycommon.t_cflag & CRTSCTS))
21907c478bd9Sstevel@tonic-gate /*
21917c478bd9Sstevel@tonic-gate * direct-wired line ignores DCD, so we don't enable modem
21927c478bd9Sstevel@tonic-gate * status interrupts.
21937c478bd9Sstevel@tonic-gate */
21947c478bd9Sstevel@tonic-gate icr = (TIEN | SIEN);
21957c478bd9Sstevel@tonic-gate else
21967c478bd9Sstevel@tonic-gate icr = (TIEN | SIEN | MIEN);
21977c478bd9Sstevel@tonic-gate
21987c478bd9Sstevel@tonic-gate if (c_flag & CREAD)
21997c478bd9Sstevel@tonic-gate icr |= RIEN;
22007c478bd9Sstevel@tonic-gate
22014ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, icr);
22027c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_PROCS, "asy%d_program: done\n", instance);
22037c478bd9Sstevel@tonic-gate }
22047c478bd9Sstevel@tonic-gate
22057c478bd9Sstevel@tonic-gate static boolean_t
asy_baudok(struct asycom * asy)22067c478bd9Sstevel@tonic-gate asy_baudok(struct asycom *asy)
22077c478bd9Sstevel@tonic-gate {
22087c478bd9Sstevel@tonic-gate struct asyncline *async = asy->asy_priv;
22097c478bd9Sstevel@tonic-gate int baudrate;
22107c478bd9Sstevel@tonic-gate
22117c478bd9Sstevel@tonic-gate
22127c478bd9Sstevel@tonic-gate baudrate = BAUDINDEX(async->async_ttycommon.t_cflag);
22137c478bd9Sstevel@tonic-gate
22147c478bd9Sstevel@tonic-gate if (baudrate >= sizeof (asyspdtab)/sizeof (*asyspdtab))
22157c478bd9Sstevel@tonic-gate return (0);
22167c478bd9Sstevel@tonic-gate
22177c478bd9Sstevel@tonic-gate return (baudrate == 0 || asyspdtab[baudrate]);
22187c478bd9Sstevel@tonic-gate }
22197c478bd9Sstevel@tonic-gate
22207c478bd9Sstevel@tonic-gate /*
22217c478bd9Sstevel@tonic-gate * asyintr() is the High Level Interrupt Handler.
22227c478bd9Sstevel@tonic-gate *
22237c478bd9Sstevel@tonic-gate * There are four different interrupt types indexed by ISR register values:
22247c478bd9Sstevel@tonic-gate * 0: modem
22257c478bd9Sstevel@tonic-gate * 1: Tx holding register is empty, ready for next char
22267c478bd9Sstevel@tonic-gate * 2: Rx register now holds a char to be picked up
22277c478bd9Sstevel@tonic-gate * 3: error or break on line
22287c478bd9Sstevel@tonic-gate * This routine checks the Bit 0 (interrupt-not-pending) to determine if
22297c478bd9Sstevel@tonic-gate * the interrupt is from this port.
22307c478bd9Sstevel@tonic-gate */
22317c478bd9Sstevel@tonic-gate uint_t
asyintr(caddr_t argasy)22327c478bd9Sstevel@tonic-gate asyintr(caddr_t argasy)
22337c478bd9Sstevel@tonic-gate {
22347c478bd9Sstevel@tonic-gate struct asycom *asy = (struct asycom *)argasy;
2235605f1b7cSPatrick Mooney struct asyncline *async = asy->asy_priv;
22367c478bd9Sstevel@tonic-gate int ret_status = DDI_INTR_UNCLAIMED;
22372df1fe9cSrandyf
2238cd43c54aSZach Kissel if ((async == NULL) ||
22397c478bd9Sstevel@tonic-gate !(async->async_flags & (ASYNC_ISOPEN|ASYNC_WOPEN))) {
2240605f1b7cSPatrick Mooney const uint8_t intr_id = ddi_get8(asy->asy_iohandle,
2241605f1b7cSPatrick Mooney asy->asy_ioaddr + ISR) & 0x0F;
2242605f1b7cSPatrick Mooney
2243605f1b7cSPatrick Mooney if (intr_id & NOINTERRUPT) {
22447c478bd9Sstevel@tonic-gate return (DDI_INTR_UNCLAIMED);
2245605f1b7cSPatrick Mooney } else {
22467c478bd9Sstevel@tonic-gate /*
22477c478bd9Sstevel@tonic-gate * reset the device by:
22487c478bd9Sstevel@tonic-gate * reading line status
22497c478bd9Sstevel@tonic-gate * reading any data from data status register
22507c478bd9Sstevel@tonic-gate * reading modem status
22517c478bd9Sstevel@tonic-gate */
22524ab75253Smrj (void) ddi_get8(asy->asy_iohandle,
22537c478bd9Sstevel@tonic-gate asy->asy_ioaddr + LSR);
22544ab75253Smrj (void) ddi_get8(asy->asy_iohandle,
22557c478bd9Sstevel@tonic-gate asy->asy_ioaddr + DAT);
22564ab75253Smrj asy->asy_msr = ddi_get8(asy->asy_iohandle,
22577c478bd9Sstevel@tonic-gate asy->asy_ioaddr + MSR);
22587c478bd9Sstevel@tonic-gate return (DDI_INTR_CLAIMED);
22597c478bd9Sstevel@tonic-gate }
22607c478bd9Sstevel@tonic-gate }
22612df1fe9cSrandyf
22627c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
226357ec6c03SZach Kissel
226457ec6c03SZach Kissel if (asy->asy_flags & ASY_DDI_SUSPENDED) {
226557ec6c03SZach Kissel mutex_exit(&asy->asy_excl_hi);
226657ec6c03SZach Kissel return (DDI_INTR_CLAIMED);
226757ec6c03SZach Kissel }
226857ec6c03SZach Kissel
22697c478bd9Sstevel@tonic-gate /*
22707c478bd9Sstevel@tonic-gate * We will loop until the interrupt line is pulled low. asy
22717c478bd9Sstevel@tonic-gate * interrupt is edge triggered.
22727c478bd9Sstevel@tonic-gate */
2273605f1b7cSPatrick Mooney for (;;) {
2274605f1b7cSPatrick Mooney const uint8_t intr_id = ddi_get8(asy->asy_iohandle,
2275605f1b7cSPatrick Mooney asy->asy_ioaddr + ISR) & 0x0F;
22762df1fe9cSrandyf
2277605f1b7cSPatrick Mooney if (intr_id & NOINTERRUPT)
22787c478bd9Sstevel@tonic-gate break;
22797c478bd9Sstevel@tonic-gate ret_status = DDI_INTR_CLAIMED;
22807c478bd9Sstevel@tonic-gate
22812df1fe9cSrandyf DEBUGCONT1(ASY_DEBUG_INTR, "asyintr: interrupt_id = 0x%d\n",
2282605f1b7cSPatrick Mooney intr_id);
2283605f1b7cSPatrick Mooney const uint8_t lsr = ddi_get8(asy->asy_iohandle,
2284605f1b7cSPatrick Mooney asy->asy_ioaddr + LSR);
2285605f1b7cSPatrick Mooney
2286605f1b7cSPatrick Mooney switch (intr_id) {
2287605f1b7cSPatrick Mooney case TxRDY:
2288605f1b7cSPatrick Mooney /*
2289605f1b7cSPatrick Mooney * The transmit-ready interrupt implies an empty
2290*8d9e2100SPatrick Mooney * transmit-hold register (or FIFO). Check that it is
2291*8d9e2100SPatrick Mooney * present before attempting to transmit more data.
2292605f1b7cSPatrick Mooney */
2293*8d9e2100SPatrick Mooney if ((lsr & XHRE) == 0) {
2294*8d9e2100SPatrick Mooney /*
2295*8d9e2100SPatrick Mooney * Taking a TxRDY interrupt only to find XHRE
2296*8d9e2100SPatrick Mooney * absent would be a surprise, except for a
2297*8d9e2100SPatrick Mooney * racing asyputchar(), which ignores the
2298*8d9e2100SPatrick Mooney * excl_hi mutex when writing to the device.
2299*8d9e2100SPatrick Mooney */
2300*8d9e2100SPatrick Mooney continue;
2301*8d9e2100SPatrick Mooney }
2302605f1b7cSPatrick Mooney async_txint(asy);
2303605f1b7cSPatrick Mooney /*
2304605f1b7cSPatrick Mooney * Unlike the other interrupts which fall through to
2305605f1b7cSPatrick Mooney * attempting to fill the output register/FIFO, TxRDY
2306605f1b7cSPatrick Mooney * has no need having just done so.
2307605f1b7cSPatrick Mooney */
2308605f1b7cSPatrick Mooney continue;
2309605f1b7cSPatrick Mooney
23107c478bd9Sstevel@tonic-gate case RxRDY:
23117c478bd9Sstevel@tonic-gate case RSTATUS:
23127c478bd9Sstevel@tonic-gate case FFTMOUT:
23137c478bd9Sstevel@tonic-gate /* receiver interrupt or receiver errors */
23147c478bd9Sstevel@tonic-gate async_rxint(asy, lsr);
23157c478bd9Sstevel@tonic-gate break;
23167c478bd9Sstevel@tonic-gate case MSTATUS:
23177c478bd9Sstevel@tonic-gate /* modem status interrupt */
23187c478bd9Sstevel@tonic-gate async_msint(asy);
23197c478bd9Sstevel@tonic-gate break;
23207c478bd9Sstevel@tonic-gate }
2321605f1b7cSPatrick Mooney /* Refill the output FIFO if it has gone empty */
23227c478bd9Sstevel@tonic-gate if ((lsr & XHRE) && (async->async_flags & ASYNC_BUSY) &&
23237c478bd9Sstevel@tonic-gate (async->async_ocnt > 0))
23247c478bd9Sstevel@tonic-gate async_txint(asy);
23257c478bd9Sstevel@tonic-gate }
23267c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
23277c478bd9Sstevel@tonic-gate return (ret_status);
23287c478bd9Sstevel@tonic-gate }
23297c478bd9Sstevel@tonic-gate
23307c478bd9Sstevel@tonic-gate /*
23317c478bd9Sstevel@tonic-gate * Transmitter interrupt service routine.
23327c478bd9Sstevel@tonic-gate * If there is more data to transmit in the current pseudo-DMA block,
23337c478bd9Sstevel@tonic-gate * send the next character if output is not stopped or draining.
23347c478bd9Sstevel@tonic-gate * Otherwise, queue up a soft interrupt.
23357c478bd9Sstevel@tonic-gate *
23367c478bd9Sstevel@tonic-gate * XXX - Needs review for HW FIFOs.
23377c478bd9Sstevel@tonic-gate */
23387c478bd9Sstevel@tonic-gate static void
async_txint(struct asycom * asy)23397c478bd9Sstevel@tonic-gate async_txint(struct asycom *asy)
23407c478bd9Sstevel@tonic-gate {
23417c478bd9Sstevel@tonic-gate struct asyncline *async = asy->asy_priv;
23427c478bd9Sstevel@tonic-gate int fifo_len;
23437c478bd9Sstevel@tonic-gate
234485fe9a71SAndy Fiddaman ASSERT(MUTEX_HELD(&asy->asy_excl_hi));
234585fe9a71SAndy Fiddaman
23467c478bd9Sstevel@tonic-gate /*
23477c478bd9Sstevel@tonic-gate * If ASYNC_BREAK or ASYNC_OUT_SUSPEND has been set, return to
23487c478bd9Sstevel@tonic-gate * asyintr()'s context to claim the interrupt without performing
23497c478bd9Sstevel@tonic-gate * any action. No character will be loaded into FIFO/THR until
23507c478bd9Sstevel@tonic-gate * timed or untimed break is removed
23517c478bd9Sstevel@tonic-gate */
23527c478bd9Sstevel@tonic-gate if (async->async_flags & (ASYNC_BREAK|ASYNC_OUT_SUSPEND))
23537c478bd9Sstevel@tonic-gate return;
23547c478bd9Sstevel@tonic-gate
23557c478bd9Sstevel@tonic-gate fifo_len = asy->asy_fifo_buf; /* with FIFO buffers */
23567c478bd9Sstevel@tonic-gate if (fifo_len > asy_max_tx_fifo)
23577c478bd9Sstevel@tonic-gate fifo_len = asy_max_tx_fifo;
23587c478bd9Sstevel@tonic-gate
23597c478bd9Sstevel@tonic-gate if (async_flowcontrol_sw_input(asy, FLOW_CHECK, IN_FLOW_NULL))
23607c478bd9Sstevel@tonic-gate fifo_len--;
23617c478bd9Sstevel@tonic-gate
23627c478bd9Sstevel@tonic-gate if (async->async_ocnt > 0 && fifo_len > 0 &&
23637c478bd9Sstevel@tonic-gate !(async->async_flags &
23647c478bd9Sstevel@tonic-gate (ASYNC_HW_OUT_FLW|ASYNC_SW_OUT_FLW|ASYNC_STOPPED))) {
23657c478bd9Sstevel@tonic-gate while (fifo_len-- > 0 && async->async_ocnt-- > 0) {
23664ab75253Smrj ddi_put8(asy->asy_iohandle,
23677c478bd9Sstevel@tonic-gate asy->asy_ioaddr + DAT, *async->async_optr++);
23687c478bd9Sstevel@tonic-gate }
23697c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_PROGRESS;
23707c478bd9Sstevel@tonic-gate }
23717c478bd9Sstevel@tonic-gate
23727c478bd9Sstevel@tonic-gate if (fifo_len <= 0)
23737c478bd9Sstevel@tonic-gate return;
23747c478bd9Sstevel@tonic-gate
23757c478bd9Sstevel@tonic-gate ASYSETSOFT(asy);
23767c478bd9Sstevel@tonic-gate }
23777c478bd9Sstevel@tonic-gate
23787c478bd9Sstevel@tonic-gate /*
23797c478bd9Sstevel@tonic-gate * Interrupt on port: handle PPS event. This function is only called
23807c478bd9Sstevel@tonic-gate * for a port on which PPS event handling has been enabled.
23817c478bd9Sstevel@tonic-gate */
23827c478bd9Sstevel@tonic-gate static void
asy_ppsevent(struct asycom * asy,int msr)23837c478bd9Sstevel@tonic-gate asy_ppsevent(struct asycom *asy, int msr)
23847c478bd9Sstevel@tonic-gate {
238585fe9a71SAndy Fiddaman ASSERT(MUTEX_HELD(&asy->asy_excl_hi));
238685fe9a71SAndy Fiddaman
23877c478bd9Sstevel@tonic-gate if (asy->asy_flags & ASY_PPS_EDGE) {
23887c478bd9Sstevel@tonic-gate /* Have seen leading edge, now look for and record drop */
23897c478bd9Sstevel@tonic-gate if ((msr & DCD) == 0)
23907c478bd9Sstevel@tonic-gate asy->asy_flags &= ~ASY_PPS_EDGE;
23917c478bd9Sstevel@tonic-gate /*
23927c478bd9Sstevel@tonic-gate * Waiting for leading edge, look for rise; stamp event and
23937c478bd9Sstevel@tonic-gate * calibrate kernel clock.
23947c478bd9Sstevel@tonic-gate */
23957c478bd9Sstevel@tonic-gate } else if (msr & DCD) {
23967c478bd9Sstevel@tonic-gate /*
23977c478bd9Sstevel@tonic-gate * This code captures a timestamp at the designated
23987c478bd9Sstevel@tonic-gate * transition of the PPS signal (DCD asserted). The
23997c478bd9Sstevel@tonic-gate * code provides a pointer to the timestamp, as well
24007c478bd9Sstevel@tonic-gate * as the hardware counter value at the capture.
24017c478bd9Sstevel@tonic-gate *
24027c478bd9Sstevel@tonic-gate * Note: the kernel has nano based time values while
24037c478bd9Sstevel@tonic-gate * NTP requires micro based, an in-line fast algorithm
24047c478bd9Sstevel@tonic-gate * to convert nsec to usec is used here -- see hrt2ts()
24057c478bd9Sstevel@tonic-gate * in common/os/timers.c for a full description.
24067c478bd9Sstevel@tonic-gate */
24077c478bd9Sstevel@tonic-gate struct timeval *tvp = &asy_ppsev.tv;
24087c478bd9Sstevel@tonic-gate timestruc_t ts;
24097c478bd9Sstevel@tonic-gate long nsec, usec;
24107c478bd9Sstevel@tonic-gate
24117c478bd9Sstevel@tonic-gate asy->asy_flags |= ASY_PPS_EDGE;
24127c478bd9Sstevel@tonic-gate LED_OFF;
24137c478bd9Sstevel@tonic-gate gethrestime(&ts);
24147c478bd9Sstevel@tonic-gate LED_ON;
24157c478bd9Sstevel@tonic-gate nsec = ts.tv_nsec;
24167c478bd9Sstevel@tonic-gate usec = nsec + (nsec >> 2);
24177c478bd9Sstevel@tonic-gate usec = nsec + (usec >> 1);
24187c478bd9Sstevel@tonic-gate usec = nsec + (usec >> 2);
24197c478bd9Sstevel@tonic-gate usec = nsec + (usec >> 4);
24207c478bd9Sstevel@tonic-gate usec = nsec - (usec >> 3);
24217c478bd9Sstevel@tonic-gate usec = nsec + (usec >> 2);
24227c478bd9Sstevel@tonic-gate usec = nsec + (usec >> 3);
24237c478bd9Sstevel@tonic-gate usec = nsec + (usec >> 4);
24247c478bd9Sstevel@tonic-gate usec = nsec + (usec >> 1);
24257c478bd9Sstevel@tonic-gate usec = nsec + (usec >> 6);
24267c478bd9Sstevel@tonic-gate tvp->tv_usec = usec >> 10;
24277c478bd9Sstevel@tonic-gate tvp->tv_sec = ts.tv_sec;
24287c478bd9Sstevel@tonic-gate
24297c478bd9Sstevel@tonic-gate ++asy_ppsev.serial;
24307c478bd9Sstevel@tonic-gate
24317c478bd9Sstevel@tonic-gate /*
24327c478bd9Sstevel@tonic-gate * Because the kernel keeps a high-resolution time,
24337c478bd9Sstevel@tonic-gate * pass the current highres timestamp in tvp and zero
24347c478bd9Sstevel@tonic-gate * in usec.
24357c478bd9Sstevel@tonic-gate */
24367c478bd9Sstevel@tonic-gate ddi_hardpps(tvp, 0);
24377c478bd9Sstevel@tonic-gate }
24387c478bd9Sstevel@tonic-gate }
24397c478bd9Sstevel@tonic-gate
24407c478bd9Sstevel@tonic-gate /*
24417c478bd9Sstevel@tonic-gate * Receiver interrupt: RxRDY interrupt, FIFO timeout interrupt or receive
24427c478bd9Sstevel@tonic-gate * error interrupt.
24437c478bd9Sstevel@tonic-gate * Try to put the character into the circular buffer for this line; if it
24447c478bd9Sstevel@tonic-gate * overflows, indicate a circular buffer overrun. If this port is always
24457c478bd9Sstevel@tonic-gate * to be serviced immediately, or the character is a STOP character, or
24467c478bd9Sstevel@tonic-gate * more than 15 characters have arrived, queue up a soft interrupt to
24477c478bd9Sstevel@tonic-gate * drain the circular buffer.
24487c478bd9Sstevel@tonic-gate * XXX - needs review for hw FIFOs support.
24497c478bd9Sstevel@tonic-gate */
24507c478bd9Sstevel@tonic-gate
24517c478bd9Sstevel@tonic-gate static void
async_rxint(struct asycom * asy,uchar_t lsr)24527c478bd9Sstevel@tonic-gate async_rxint(struct asycom *asy, uchar_t lsr)
24537c478bd9Sstevel@tonic-gate {
24547c478bd9Sstevel@tonic-gate struct asyncline *async = asy->asy_priv;
24557c478bd9Sstevel@tonic-gate uchar_t c;
24567c478bd9Sstevel@tonic-gate uint_t s, needsoft = 0;
24577c478bd9Sstevel@tonic-gate tty_common_t *tp;
24587c478bd9Sstevel@tonic-gate int looplim = asy->asy_fifo_buf * 2;
24597c478bd9Sstevel@tonic-gate
246085fe9a71SAndy Fiddaman ASSERT(MUTEX_HELD(&asy->asy_excl_hi));
246185fe9a71SAndy Fiddaman
24627c478bd9Sstevel@tonic-gate tp = &async->async_ttycommon;
24637c478bd9Sstevel@tonic-gate if (!(tp->t_cflag & CREAD)) {
24647c478bd9Sstevel@tonic-gate while (lsr & (RCA|PARERR|FRMERR|BRKDET|OVRRUN)) {
24654ab75253Smrj (void) (ddi_get8(asy->asy_iohandle,
24667c478bd9Sstevel@tonic-gate asy->asy_ioaddr + DAT) & 0xff);
24674ab75253Smrj lsr = ddi_get8(asy->asy_iohandle,
24687c478bd9Sstevel@tonic-gate asy->asy_ioaddr + LSR);
24697c478bd9Sstevel@tonic-gate if (looplim-- < 0) /* limit loop */
24707c478bd9Sstevel@tonic-gate break;
24717c478bd9Sstevel@tonic-gate }
24727c478bd9Sstevel@tonic-gate return; /* line is not open for read? */
24737c478bd9Sstevel@tonic-gate }
24747c478bd9Sstevel@tonic-gate
24757c478bd9Sstevel@tonic-gate while (lsr & (RCA|PARERR|FRMERR|BRKDET|OVRRUN)) {
24767c478bd9Sstevel@tonic-gate c = 0;
24777c478bd9Sstevel@tonic-gate s = 0; /* reset error status */
24787c478bd9Sstevel@tonic-gate if (lsr & RCA) {
24794ab75253Smrj c = ddi_get8(asy->asy_iohandle,
24807c478bd9Sstevel@tonic-gate asy->asy_ioaddr + DAT) & 0xff;
24817c478bd9Sstevel@tonic-gate
24827c478bd9Sstevel@tonic-gate /*
24837c478bd9Sstevel@tonic-gate * We handle XON/XOFF char if IXON is set,
24847c478bd9Sstevel@tonic-gate * but if received char is _POSIX_VDISABLE,
24857c478bd9Sstevel@tonic-gate * we left it to the up level module.
24867c478bd9Sstevel@tonic-gate */
24877c478bd9Sstevel@tonic-gate if (tp->t_iflag & IXON) {
24887c478bd9Sstevel@tonic-gate if ((c == async->async_stopc) &&
24897c478bd9Sstevel@tonic-gate (c != _POSIX_VDISABLE)) {
24907c478bd9Sstevel@tonic-gate async_flowcontrol_sw_output(asy,
24917c478bd9Sstevel@tonic-gate FLOW_STOP);
24927c478bd9Sstevel@tonic-gate goto check_looplim;
24937c478bd9Sstevel@tonic-gate } else if ((c == async->async_startc) &&
24947c478bd9Sstevel@tonic-gate (c != _POSIX_VDISABLE)) {
24957c478bd9Sstevel@tonic-gate async_flowcontrol_sw_output(asy,
24967c478bd9Sstevel@tonic-gate FLOW_START);
24977c478bd9Sstevel@tonic-gate needsoft = 1;
24987c478bd9Sstevel@tonic-gate goto check_looplim;
24997c478bd9Sstevel@tonic-gate }
25007c478bd9Sstevel@tonic-gate if ((tp->t_iflag & IXANY) &&
25017c478bd9Sstevel@tonic-gate (async->async_flags & ASYNC_SW_OUT_FLW)) {
25027c478bd9Sstevel@tonic-gate async_flowcontrol_sw_output(asy,
25037c478bd9Sstevel@tonic-gate FLOW_START);
25047c478bd9Sstevel@tonic-gate needsoft = 1;
25057c478bd9Sstevel@tonic-gate }
25067c478bd9Sstevel@tonic-gate }
25077c478bd9Sstevel@tonic-gate }
25087c478bd9Sstevel@tonic-gate
25097c478bd9Sstevel@tonic-gate /*
25107c478bd9Sstevel@tonic-gate * Check for character break sequence
25117c478bd9Sstevel@tonic-gate */
25127c478bd9Sstevel@tonic-gate if ((abort_enable == KIOCABORTALTERNATE) &&
25137c478bd9Sstevel@tonic-gate (asy->asy_flags & ASY_CONSOLE)) {
25147c478bd9Sstevel@tonic-gate if (abort_charseq_recognize(c))
25157c478bd9Sstevel@tonic-gate abort_sequence_enter((char *)NULL);
25167c478bd9Sstevel@tonic-gate }
25177c478bd9Sstevel@tonic-gate
25187c478bd9Sstevel@tonic-gate /* Handle framing errors */
25197c478bd9Sstevel@tonic-gate if (lsr & (PARERR|FRMERR|BRKDET|OVRRUN)) {
25207c478bd9Sstevel@tonic-gate if (lsr & PARERR) {
25217c478bd9Sstevel@tonic-gate if (tp->t_iflag & INPCK) /* parity enabled */
25227c478bd9Sstevel@tonic-gate s |= PERROR;
25237c478bd9Sstevel@tonic-gate }
25247c478bd9Sstevel@tonic-gate
25257c478bd9Sstevel@tonic-gate if (lsr & (FRMERR|BRKDET))
25267c478bd9Sstevel@tonic-gate s |= FRERROR;
25277c478bd9Sstevel@tonic-gate if (lsr & OVRRUN) {
25287c478bd9Sstevel@tonic-gate async->async_hw_overrun = 1;
25297c478bd9Sstevel@tonic-gate s |= OVERRUN;
25307c478bd9Sstevel@tonic-gate }
25317c478bd9Sstevel@tonic-gate }
25327c478bd9Sstevel@tonic-gate
25337c478bd9Sstevel@tonic-gate if (s == 0)
25347c478bd9Sstevel@tonic-gate if ((tp->t_iflag & PARMRK) &&
25357c478bd9Sstevel@tonic-gate !(tp->t_iflag & (IGNPAR|ISTRIP)) &&
25367c478bd9Sstevel@tonic-gate (c == 0377))
25377c478bd9Sstevel@tonic-gate if (RING_POK(async, 2)) {
25387c478bd9Sstevel@tonic-gate RING_PUT(async, 0377);
25397c478bd9Sstevel@tonic-gate RING_PUT(async, c);
25407c478bd9Sstevel@tonic-gate } else
25417c478bd9Sstevel@tonic-gate async->async_sw_overrun = 1;
25427c478bd9Sstevel@tonic-gate else
25437c478bd9Sstevel@tonic-gate if (RING_POK(async, 1))
25447c478bd9Sstevel@tonic-gate RING_PUT(async, c);
25457c478bd9Sstevel@tonic-gate else
25467c478bd9Sstevel@tonic-gate async->async_sw_overrun = 1;
25477c478bd9Sstevel@tonic-gate else
25487c478bd9Sstevel@tonic-gate if (s & FRERROR) /* Handle framing errors */
25497c478bd9Sstevel@tonic-gate if (c == 0)
25507c478bd9Sstevel@tonic-gate if ((asy->asy_flags & ASY_CONSOLE) &&
25517c478bd9Sstevel@tonic-gate (abort_enable !=
25527c478bd9Sstevel@tonic-gate KIOCABORTALTERNATE))
25537c478bd9Sstevel@tonic-gate abort_sequence_enter((char *)0);
25547c478bd9Sstevel@tonic-gate else
25557c478bd9Sstevel@tonic-gate async->async_break++;
25567c478bd9Sstevel@tonic-gate else
25577c478bd9Sstevel@tonic-gate if (RING_POK(async, 1))
25587c478bd9Sstevel@tonic-gate RING_MARK(async, c, s);
25597c478bd9Sstevel@tonic-gate else
25607c478bd9Sstevel@tonic-gate async->async_sw_overrun = 1;
25617c478bd9Sstevel@tonic-gate else /* Parity errors are handled by ldterm */
25627c478bd9Sstevel@tonic-gate if (RING_POK(async, 1))
25637c478bd9Sstevel@tonic-gate RING_MARK(async, c, s);
25647c478bd9Sstevel@tonic-gate else
25657c478bd9Sstevel@tonic-gate async->async_sw_overrun = 1;
25667c478bd9Sstevel@tonic-gate check_looplim:
25672df1fe9cSrandyf lsr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR);
25687c478bd9Sstevel@tonic-gate if (looplim-- < 0) /* limit loop */
25697c478bd9Sstevel@tonic-gate break;
25707c478bd9Sstevel@tonic-gate }
25717c478bd9Sstevel@tonic-gate if ((RING_CNT(async) > (RINGSIZE * 3)/4) &&
25727c478bd9Sstevel@tonic-gate !(async->async_inflow_source & IN_FLOW_RINGBUFF)) {
25737c478bd9Sstevel@tonic-gate async_flowcontrol_hw_input(asy, FLOW_STOP, IN_FLOW_RINGBUFF);
25747c478bd9Sstevel@tonic-gate (void) async_flowcontrol_sw_input(asy, FLOW_STOP,
25757c478bd9Sstevel@tonic-gate IN_FLOW_RINGBUFF);
25767c478bd9Sstevel@tonic-gate }
25777c478bd9Sstevel@tonic-gate
25787c478bd9Sstevel@tonic-gate if ((async->async_flags & ASYNC_SERVICEIMM) || needsoft ||
257985fe9a71SAndy Fiddaman (RING_FRAC(async)) || (async->async_polltid == 0)) {
25807c478bd9Sstevel@tonic-gate ASYSETSOFT(asy); /* need a soft interrupt */
25817c478bd9Sstevel@tonic-gate }
258285fe9a71SAndy Fiddaman }
25837c478bd9Sstevel@tonic-gate
25847c478bd9Sstevel@tonic-gate /*
25857c478bd9Sstevel@tonic-gate * Modem status interrupt.
25867c478bd9Sstevel@tonic-gate *
25877c478bd9Sstevel@tonic-gate * (Note: It is assumed that the MSR hasn't been read by asyintr().)
25887c478bd9Sstevel@tonic-gate */
25897c478bd9Sstevel@tonic-gate
25907c478bd9Sstevel@tonic-gate static void
async_msint(struct asycom * asy)25917c478bd9Sstevel@tonic-gate async_msint(struct asycom *asy)
25927c478bd9Sstevel@tonic-gate {
25937c478bd9Sstevel@tonic-gate struct asyncline *async = asy->asy_priv;
25947c478bd9Sstevel@tonic-gate int msr, t_cflag = async->async_ttycommon.t_cflag;
25957c478bd9Sstevel@tonic-gate #ifdef DEBUG
25967c478bd9Sstevel@tonic-gate int instance = UNIT(async->async_dev);
25977c478bd9Sstevel@tonic-gate #endif
25987c478bd9Sstevel@tonic-gate
259985fe9a71SAndy Fiddaman ASSERT(MUTEX_HELD(&asy->asy_excl_hi));
260085fe9a71SAndy Fiddaman
26017c478bd9Sstevel@tonic-gate async_msint_retry:
26027c478bd9Sstevel@tonic-gate /* this resets the interrupt */
26034ab75253Smrj msr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MSR);
26047c478bd9Sstevel@tonic-gate DEBUGCONT10(ASY_DEBUG_STATE,
26057c478bd9Sstevel@tonic-gate "async%d_msint call #%d:\n"
26067c478bd9Sstevel@tonic-gate " transition: %3s %3s %3s %3s\n"
26077c478bd9Sstevel@tonic-gate "current state: %3s %3s %3s %3s\n",
26087c478bd9Sstevel@tonic-gate instance,
26097c478bd9Sstevel@tonic-gate ++(asy->asy_msint_cnt),
26107c478bd9Sstevel@tonic-gate (msr & DCTS) ? "DCTS" : " ",
26117c478bd9Sstevel@tonic-gate (msr & DDSR) ? "DDSR" : " ",
26127c478bd9Sstevel@tonic-gate (msr & DRI) ? "DRI " : " ",
26137c478bd9Sstevel@tonic-gate (msr & DDCD) ? "DDCD" : " ",
26147c478bd9Sstevel@tonic-gate (msr & CTS) ? "CTS " : " ",
26157c478bd9Sstevel@tonic-gate (msr & DSR) ? "DSR " : " ",
26167c478bd9Sstevel@tonic-gate (msr & RI) ? "RI " : " ",
26177c478bd9Sstevel@tonic-gate (msr & DCD) ? "DCD " : " ");
26187c478bd9Sstevel@tonic-gate
26197c478bd9Sstevel@tonic-gate /* If CTS status is changed, do H/W output flow control */
26207c478bd9Sstevel@tonic-gate if ((t_cflag & CRTSCTS) && (((asy->asy_msr ^ msr) & CTS) != 0))
26217c478bd9Sstevel@tonic-gate async_flowcontrol_hw_output(asy,
26227c478bd9Sstevel@tonic-gate msr & CTS ? FLOW_START : FLOW_STOP);
26237c478bd9Sstevel@tonic-gate /*
26247c478bd9Sstevel@tonic-gate * Reading MSR resets the interrupt, we save the
26257c478bd9Sstevel@tonic-gate * value of msr so that other functions could examine MSR by
26267c478bd9Sstevel@tonic-gate * looking at asy_msr.
26277c478bd9Sstevel@tonic-gate */
26287c478bd9Sstevel@tonic-gate asy->asy_msr = (uchar_t)msr;
26297c478bd9Sstevel@tonic-gate
26307c478bd9Sstevel@tonic-gate /* Handle PPS event */
26317c478bd9Sstevel@tonic-gate if (asy->asy_flags & ASY_PPS)
26327c478bd9Sstevel@tonic-gate asy_ppsevent(asy, msr);
26337c478bd9Sstevel@tonic-gate
26347c478bd9Sstevel@tonic-gate async->async_ext++;
26357c478bd9Sstevel@tonic-gate ASYSETSOFT(asy);
26367c478bd9Sstevel@tonic-gate /*
26377c478bd9Sstevel@tonic-gate * We will make sure that the modem status presented to us
26387c478bd9Sstevel@tonic-gate * during the previous read has not changed. If the chip samples
26397c478bd9Sstevel@tonic-gate * the modem status on the falling edge of the interrupt line,
26407c478bd9Sstevel@tonic-gate * and uses this state as the base for detecting change of modem
26417c478bd9Sstevel@tonic-gate * status, we would miss a change of modem status event that occured
26427c478bd9Sstevel@tonic-gate * after we initiated a read MSR operation.
26437c478bd9Sstevel@tonic-gate */
26444ab75253Smrj msr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MSR);
26457c478bd9Sstevel@tonic-gate if (STATES(msr) != STATES(asy->asy_msr))
26467c478bd9Sstevel@tonic-gate goto async_msint_retry;
26477c478bd9Sstevel@tonic-gate }
26487c478bd9Sstevel@tonic-gate
26497c478bd9Sstevel@tonic-gate /*
26507c478bd9Sstevel@tonic-gate * Handle a second-stage interrupt.
26517c478bd9Sstevel@tonic-gate */
26527c478bd9Sstevel@tonic-gate /*ARGSUSED*/
26537c478bd9Sstevel@tonic-gate uint_t
asysoftintr(caddr_t intarg)26547c478bd9Sstevel@tonic-gate asysoftintr(caddr_t intarg)
26557c478bd9Sstevel@tonic-gate {
2656cd43c54aSZach Kissel struct asycom *asy = (struct asycom *)intarg;
2657cd43c54aSZach Kissel struct asyncline *async;
26587c478bd9Sstevel@tonic-gate int rv;
2659cd43c54aSZach Kissel uint_t cc;
26607c478bd9Sstevel@tonic-gate
26617c478bd9Sstevel@tonic-gate /*
26627c478bd9Sstevel@tonic-gate * Test and clear soft interrupt.
26637c478bd9Sstevel@tonic-gate */
2664cd43c54aSZach Kissel mutex_enter(&asy->asy_soft_lock);
26657c478bd9Sstevel@tonic-gate DEBUGCONT0(ASY_DEBUG_PROCS, "asysoftintr: enter\n");
2666cd43c54aSZach Kissel rv = asy->asysoftpend;
26677c478bd9Sstevel@tonic-gate if (rv != 0)
2668cd43c54aSZach Kissel asy->asysoftpend = 0;
2669cd43c54aSZach Kissel mutex_exit(&asy->asy_soft_lock);
26707c478bd9Sstevel@tonic-gate
26717c478bd9Sstevel@tonic-gate if (rv) {
2672cd43c54aSZach Kissel if (asy->asy_priv == NULL)
2673cd43c54aSZach Kissel return (rv ? DDI_INTR_CLAIMED : DDI_INTR_UNCLAIMED);
2674cd43c54aSZach Kissel async = (struct asyncline *)asy->asy_priv;
2675cd43c54aSZach Kissel mutex_enter(&asy->asy_excl_hi);
26767c478bd9Sstevel@tonic-gate if (asy->asy_flags & ASY_NEEDSOFT) {
26777c478bd9Sstevel@tonic-gate asy->asy_flags &= ~ASY_NEEDSOFT;
2678cd43c54aSZach Kissel mutex_exit(&asy->asy_excl_hi);
26797c478bd9Sstevel@tonic-gate async_softint(asy);
2680cd43c54aSZach Kissel mutex_enter(&asy->asy_excl_hi);
26817c478bd9Sstevel@tonic-gate }
2682cd43c54aSZach Kissel
2683cd43c54aSZach Kissel /*
2684cd43c54aSZach Kissel * There are some instances where the softintr is not
2685cd43c54aSZach Kissel * scheduled and hence not called. It so happens that
2686cd43c54aSZach Kissel * causes the last few characters to be stuck in the
2687cd43c54aSZach Kissel * ringbuffer. Hence, call the handler once again so
2688cd43c54aSZach Kissel * the last few characters are cleared.
2689cd43c54aSZach Kissel */
2690cd43c54aSZach Kissel cc = RING_CNT(async);
2691cd43c54aSZach Kissel mutex_exit(&asy->asy_excl_hi);
2692cd43c54aSZach Kissel if (cc > 0)
2693cd43c54aSZach Kissel (void) async_softint(asy);
26947c478bd9Sstevel@tonic-gate }
26957c478bd9Sstevel@tonic-gate return (rv ? DDI_INTR_CLAIMED : DDI_INTR_UNCLAIMED);
26967c478bd9Sstevel@tonic-gate }
26977c478bd9Sstevel@tonic-gate
26987c478bd9Sstevel@tonic-gate /*
26997c478bd9Sstevel@tonic-gate * Handle a software interrupt.
27007c478bd9Sstevel@tonic-gate */
27017c478bd9Sstevel@tonic-gate static void
async_softint(struct asycom * asy)27027c478bd9Sstevel@tonic-gate async_softint(struct asycom *asy)
27037c478bd9Sstevel@tonic-gate {
27047c478bd9Sstevel@tonic-gate struct asyncline *async = asy->asy_priv;
2705cd43c54aSZach Kissel uint_t cc;
27067c478bd9Sstevel@tonic-gate mblk_t *bp;
27077c478bd9Sstevel@tonic-gate queue_t *q;
27087c478bd9Sstevel@tonic-gate uchar_t val;
27097c478bd9Sstevel@tonic-gate uchar_t c;
27107c478bd9Sstevel@tonic-gate tty_common_t *tp;
27117c478bd9Sstevel@tonic-gate int nb;
27127c478bd9Sstevel@tonic-gate int instance = UNIT(async->async_dev);
27137c478bd9Sstevel@tonic-gate
27147c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_PROCS, "async%d_softint\n", instance);
2715cd43c54aSZach Kissel mutex_enter(&asy->asy_excl_hi);
27167c478bd9Sstevel@tonic-gate if (asy->asy_flags & ASY_DOINGSOFT) {
27177c478bd9Sstevel@tonic-gate asy->asy_flags |= ASY_DOINGSOFT_RETRY;
2718cd43c54aSZach Kissel mutex_exit(&asy->asy_excl_hi);
27197c478bd9Sstevel@tonic-gate return;
27207c478bd9Sstevel@tonic-gate }
27217c478bd9Sstevel@tonic-gate asy->asy_flags |= ASY_DOINGSOFT;
27227c478bd9Sstevel@tonic-gate begin:
27237c478bd9Sstevel@tonic-gate asy->asy_flags &= ~ASY_DOINGSOFT_RETRY;
2724cd43c54aSZach Kissel mutex_exit(&asy->asy_excl_hi);
27257c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
27267c478bd9Sstevel@tonic-gate tp = &async->async_ttycommon;
27277c478bd9Sstevel@tonic-gate q = tp->t_readq;
27287c478bd9Sstevel@tonic-gate if (async->async_flags & ASYNC_OUT_FLW_RESUME) {
27297c478bd9Sstevel@tonic-gate if (async->async_ocnt > 0) {
27307c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
27317c478bd9Sstevel@tonic-gate async_resume(async);
27327c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
27337c478bd9Sstevel@tonic-gate } else {
27347c478bd9Sstevel@tonic-gate if (async->async_xmitblk)
27357c478bd9Sstevel@tonic-gate freeb(async->async_xmitblk);
27367c478bd9Sstevel@tonic-gate async->async_xmitblk = NULL;
27377c478bd9Sstevel@tonic-gate async_start(async);
27387c478bd9Sstevel@tonic-gate }
27397c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_OUT_FLW_RESUME;
27407c478bd9Sstevel@tonic-gate }
27417c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
27427c478bd9Sstevel@tonic-gate if (async->async_ext) {
27437c478bd9Sstevel@tonic-gate async->async_ext = 0;
27447c478bd9Sstevel@tonic-gate /* check for carrier up */
27457c478bd9Sstevel@tonic-gate DEBUGCONT3(ASY_DEBUG_MODM2,
27467c478bd9Sstevel@tonic-gate "async%d_softint: asy_msr & DCD = %x, "
27477c478bd9Sstevel@tonic-gate "tp->t_flags & TS_SOFTCAR = %x\n",
27482df1fe9cSrandyf instance, asy->asy_msr & DCD, tp->t_flags & TS_SOFTCAR);
27492df1fe9cSrandyf
27507c478bd9Sstevel@tonic-gate if (asy->asy_msr & DCD) {
27517c478bd9Sstevel@tonic-gate /* carrier present */
27527c478bd9Sstevel@tonic-gate if ((async->async_flags & ASYNC_CARR_ON) == 0) {
27537c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_MODM2,
27547c478bd9Sstevel@tonic-gate "async%d_softint: set ASYNC_CARR_ON\n",
27557c478bd9Sstevel@tonic-gate instance);
27567c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_CARR_ON;
27577c478bd9Sstevel@tonic-gate if (async->async_flags & ASYNC_ISOPEN) {
27587c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
27597c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
27607c478bd9Sstevel@tonic-gate (void) putctl(q, M_UNHANGUP);
27617c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
27627c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
27637c478bd9Sstevel@tonic-gate }
27647c478bd9Sstevel@tonic-gate cv_broadcast(&async->async_flags_cv);
27657c478bd9Sstevel@tonic-gate }
27667c478bd9Sstevel@tonic-gate } else {
27677c478bd9Sstevel@tonic-gate if ((async->async_flags & ASYNC_CARR_ON) &&
27687c478bd9Sstevel@tonic-gate !(tp->t_cflag & CLOCAL) &&
27697c478bd9Sstevel@tonic-gate !(tp->t_flags & TS_SOFTCAR)) {
27707c478bd9Sstevel@tonic-gate int flushflag;
27717c478bd9Sstevel@tonic-gate
27727c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_MODEM,
27737c478bd9Sstevel@tonic-gate "async%d_softint: carrier dropped, "
27747c478bd9Sstevel@tonic-gate "so drop DTR\n",
27757c478bd9Sstevel@tonic-gate instance);
27767c478bd9Sstevel@tonic-gate /*
27777c478bd9Sstevel@tonic-gate * Carrier went away.
27787c478bd9Sstevel@tonic-gate * Drop DTR, abort any output in
27797c478bd9Sstevel@tonic-gate * progress, indicate that output is
27807c478bd9Sstevel@tonic-gate * not stopped, and send a hangup
27817c478bd9Sstevel@tonic-gate * notification upstream.
27827c478bd9Sstevel@tonic-gate */
27834ab75253Smrj val = ddi_get8(asy->asy_iohandle,
27847c478bd9Sstevel@tonic-gate asy->asy_ioaddr + MCR);
27854ab75253Smrj ddi_put8(asy->asy_iohandle,
27867c478bd9Sstevel@tonic-gate asy->asy_ioaddr + MCR, (val & ~DTR));
27872df1fe9cSrandyf
27887c478bd9Sstevel@tonic-gate if (async->async_flags & ASYNC_BUSY) {
27897c478bd9Sstevel@tonic-gate DEBUGCONT0(ASY_DEBUG_BUSY,
27907c478bd9Sstevel@tonic-gate "async_softint: "
27917c478bd9Sstevel@tonic-gate "Carrier dropped. "
27927c478bd9Sstevel@tonic-gate "Clearing async_ocnt\n");
27937c478bd9Sstevel@tonic-gate async->async_ocnt = 0;
27947c478bd9Sstevel@tonic-gate } /* if */
27957c478bd9Sstevel@tonic-gate
27967c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_STOPPED;
27977c478bd9Sstevel@tonic-gate if (async->async_flags & ASYNC_ISOPEN) {
27987c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
27997c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
28007c478bd9Sstevel@tonic-gate (void) putctl(q, M_HANGUP);
28017c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
28027c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_MODEM,
28037c478bd9Sstevel@tonic-gate "async%d_softint: "
28047c478bd9Sstevel@tonic-gate "putctl(q, M_HANGUP)\n",
28057c478bd9Sstevel@tonic-gate instance);
28067c478bd9Sstevel@tonic-gate /*
28077c478bd9Sstevel@tonic-gate * Flush FIFO buffers
28087c478bd9Sstevel@tonic-gate * Any data left in there is invalid now
28097c478bd9Sstevel@tonic-gate */
28107c478bd9Sstevel@tonic-gate if (asy->asy_use_fifo == FIFO_ON)
28117c478bd9Sstevel@tonic-gate asy_reset_fifo(asy, FIFOTXFLSH);
28127c478bd9Sstevel@tonic-gate /*
28137c478bd9Sstevel@tonic-gate * Flush our write queue if we have one.
28142df1fe9cSrandyf * If we're in the midst of close, then
28152df1fe9cSrandyf * flush everything. Don't leave stale
28162df1fe9cSrandyf * ioctls lying about.
28177c478bd9Sstevel@tonic-gate */
28187c478bd9Sstevel@tonic-gate flushflag = (async->async_flags &
28192df1fe9cSrandyf ASYNC_CLOSING) ? FLUSHALL :
28202df1fe9cSrandyf FLUSHDATA;
28217c478bd9Sstevel@tonic-gate flushq(tp->t_writeq, flushflag);
28227c478bd9Sstevel@tonic-gate
28232df1fe9cSrandyf /* active msg */
28242df1fe9cSrandyf bp = async->async_xmitblk;
28257c478bd9Sstevel@tonic-gate if (bp != NULL) {
28267c478bd9Sstevel@tonic-gate freeb(bp);
28277c478bd9Sstevel@tonic-gate async->async_xmitblk = NULL;
28287c478bd9Sstevel@tonic-gate }
28297c478bd9Sstevel@tonic-gate
28307c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
28317c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_BUSY;
28327c478bd9Sstevel@tonic-gate /*
28337c478bd9Sstevel@tonic-gate * This message warns of Carrier loss
28342df1fe9cSrandyf * with data left to transmit can hang
28352df1fe9cSrandyf * the system.
28367c478bd9Sstevel@tonic-gate */
28377c478bd9Sstevel@tonic-gate DEBUGCONT0(ASY_DEBUG_MODEM,
28387c478bd9Sstevel@tonic-gate "async_softint: Flushing to "
28397c478bd9Sstevel@tonic-gate "prevent HUPCL hanging\n");
28407c478bd9Sstevel@tonic-gate } /* if (ASYNC_ISOPEN) */
28417c478bd9Sstevel@tonic-gate } /* if (ASYNC_CARR_ON && CLOCAL) */
28427c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_CARR_ON;
28437c478bd9Sstevel@tonic-gate cv_broadcast(&async->async_flags_cv);
28447c478bd9Sstevel@tonic-gate } /* else */
28457c478bd9Sstevel@tonic-gate } /* if (async->async_ext) */
28467c478bd9Sstevel@tonic-gate
28477c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
28487c478bd9Sstevel@tonic-gate
28497c478bd9Sstevel@tonic-gate /*
28507c478bd9Sstevel@tonic-gate * If data has been added to the circular buffer, remove
28517c478bd9Sstevel@tonic-gate * it from the buffer, and send it up the stream if there's
28527c478bd9Sstevel@tonic-gate * somebody listening. Try to do it 16 bytes at a time. If we
28537c478bd9Sstevel@tonic-gate * have more than 16 bytes to move, move 16 byte chunks and
28547c478bd9Sstevel@tonic-gate * leave the rest for next time around (maybe it will grow).
28557c478bd9Sstevel@tonic-gate */
28567c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
28577c478bd9Sstevel@tonic-gate if (!(async->async_flags & ASYNC_ISOPEN)) {
28587c478bd9Sstevel@tonic-gate RING_INIT(async);
28597c478bd9Sstevel@tonic-gate goto rv;
28607c478bd9Sstevel@tonic-gate }
2861cd43c54aSZach Kissel if ((cc = RING_CNT(async)) == 0)
28627c478bd9Sstevel@tonic-gate goto rv;
28637c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
28647c478bd9Sstevel@tonic-gate
28657c478bd9Sstevel@tonic-gate if (!canput(q)) {
28667c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
28677c478bd9Sstevel@tonic-gate if (!(async->async_inflow_source & IN_FLOW_STREAMS)) {
28687c478bd9Sstevel@tonic-gate async_flowcontrol_hw_input(asy, FLOW_STOP,
28697c478bd9Sstevel@tonic-gate IN_FLOW_STREAMS);
28707c478bd9Sstevel@tonic-gate (void) async_flowcontrol_sw_input(asy, FLOW_STOP,
28717c478bd9Sstevel@tonic-gate IN_FLOW_STREAMS);
28727c478bd9Sstevel@tonic-gate }
28737c478bd9Sstevel@tonic-gate goto rv;
28747c478bd9Sstevel@tonic-gate }
28757c478bd9Sstevel@tonic-gate if (async->async_inflow_source & IN_FLOW_STREAMS) {
28767c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
28777c478bd9Sstevel@tonic-gate async_flowcontrol_hw_input(asy, FLOW_START,
28787c478bd9Sstevel@tonic-gate IN_FLOW_STREAMS);
28797c478bd9Sstevel@tonic-gate (void) async_flowcontrol_sw_input(asy, FLOW_START,
28807c478bd9Sstevel@tonic-gate IN_FLOW_STREAMS);
28817c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
28827c478bd9Sstevel@tonic-gate }
28832df1fe9cSrandyf
28842df1fe9cSrandyf DEBUGCONT2(ASY_DEBUG_INPUT, "async%d_softint: %d char(s) in queue.\n",
28852df1fe9cSrandyf instance, cc);
28862df1fe9cSrandyf
28877c478bd9Sstevel@tonic-gate if (!(bp = allocb(cc, BPRI_MED))) {
28887c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
28897c478bd9Sstevel@tonic-gate ttycommon_qfull(&async->async_ttycommon, q);
28907c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
28917c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
28927c478bd9Sstevel@tonic-gate goto rv;
28937c478bd9Sstevel@tonic-gate }
28947c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
28957c478bd9Sstevel@tonic-gate do {
28967c478bd9Sstevel@tonic-gate if (RING_ERR(async, S_ERRORS)) {
28977c478bd9Sstevel@tonic-gate RING_UNMARK(async);
28987c478bd9Sstevel@tonic-gate c = RING_GET(async);
28997c478bd9Sstevel@tonic-gate break;
29007c478bd9Sstevel@tonic-gate } else
29017c478bd9Sstevel@tonic-gate *bp->b_wptr++ = RING_GET(async);
29027c478bd9Sstevel@tonic-gate } while (--cc);
29037c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
29047c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
29057c478bd9Sstevel@tonic-gate if (bp->b_wptr > bp->b_rptr) {
29067c478bd9Sstevel@tonic-gate if (!canput(q)) {
29077c478bd9Sstevel@tonic-gate asyerror(CE_NOTE, "asy%d: local queue full",
29087c478bd9Sstevel@tonic-gate instance);
29097c478bd9Sstevel@tonic-gate freemsg(bp);
29107c478bd9Sstevel@tonic-gate } else
29117c478bd9Sstevel@tonic-gate (void) putq(q, bp);
29127c478bd9Sstevel@tonic-gate } else
29137c478bd9Sstevel@tonic-gate freemsg(bp);
29147c478bd9Sstevel@tonic-gate /*
29157c478bd9Sstevel@tonic-gate * If we have a parity error, then send
29167c478bd9Sstevel@tonic-gate * up an M_BREAK with the "bad"
29177c478bd9Sstevel@tonic-gate * character as an argument. Let ldterm
29187c478bd9Sstevel@tonic-gate * figure out what to do with the error.
29197c478bd9Sstevel@tonic-gate */
292085fe9a71SAndy Fiddaman if (cc)
29217c478bd9Sstevel@tonic-gate (void) putctl1(q, M_BREAK, c);
29227c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
29237c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
292485fe9a71SAndy Fiddaman if (cc) {
292585fe9a71SAndy Fiddaman ASYSETSOFT(asy); /* finish cc chars */
292685fe9a71SAndy Fiddaman }
29277c478bd9Sstevel@tonic-gate rv:
29287c478bd9Sstevel@tonic-gate if ((RING_CNT(async) < (RINGSIZE/4)) &&
29297c478bd9Sstevel@tonic-gate (async->async_inflow_source & IN_FLOW_RINGBUFF)) {
29307c478bd9Sstevel@tonic-gate async_flowcontrol_hw_input(asy, FLOW_START, IN_FLOW_RINGBUFF);
29317c478bd9Sstevel@tonic-gate (void) async_flowcontrol_sw_input(asy, FLOW_START,
29327c478bd9Sstevel@tonic-gate IN_FLOW_RINGBUFF);
29337c478bd9Sstevel@tonic-gate }
29347c478bd9Sstevel@tonic-gate
29357c478bd9Sstevel@tonic-gate /*
29367c478bd9Sstevel@tonic-gate * If a transmission has finished, indicate that it's finished,
29377c478bd9Sstevel@tonic-gate * and start that line up again.
29387c478bd9Sstevel@tonic-gate */
29397c478bd9Sstevel@tonic-gate if (async->async_break > 0) {
29407c478bd9Sstevel@tonic-gate nb = async->async_break;
29417c478bd9Sstevel@tonic-gate async->async_break = 0;
29427c478bd9Sstevel@tonic-gate if (async->async_flags & ASYNC_ISOPEN) {
29437c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
29447c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
29457c478bd9Sstevel@tonic-gate for (; nb > 0; nb--)
29467c478bd9Sstevel@tonic-gate (void) putctl(q, M_BREAK);
29477c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
29487c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
29497c478bd9Sstevel@tonic-gate }
29507c478bd9Sstevel@tonic-gate }
29517c478bd9Sstevel@tonic-gate if (async->async_ocnt <= 0 && (async->async_flags & ASYNC_BUSY)) {
29527c478bd9Sstevel@tonic-gate DEBUGCONT2(ASY_DEBUG_BUSY,
29537c478bd9Sstevel@tonic-gate "async%d_softint: Clearing ASYNC_BUSY. async_ocnt=%d\n",
29547c478bd9Sstevel@tonic-gate instance,
29557c478bd9Sstevel@tonic-gate async->async_ocnt);
29567c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_BUSY;
29577c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
29587c478bd9Sstevel@tonic-gate if (async->async_xmitblk)
29597c478bd9Sstevel@tonic-gate freeb(async->async_xmitblk);
29607c478bd9Sstevel@tonic-gate async->async_xmitblk = NULL;
29617c478bd9Sstevel@tonic-gate async_start(async);
29627c478bd9Sstevel@tonic-gate /*
29637c478bd9Sstevel@tonic-gate * If the flag isn't set after doing the async_start above, we
29647c478bd9Sstevel@tonic-gate * may have finished all the queued output. Signal any thread
29657c478bd9Sstevel@tonic-gate * stuck in close.
29667c478bd9Sstevel@tonic-gate */
29677c478bd9Sstevel@tonic-gate if (!(async->async_flags & ASYNC_BUSY))
29687c478bd9Sstevel@tonic-gate cv_broadcast(&async->async_flags_cv);
29697c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
29707c478bd9Sstevel@tonic-gate }
29717c478bd9Sstevel@tonic-gate /*
29727c478bd9Sstevel@tonic-gate * A note about these overrun bits: all they do is *tell* someone
29737c478bd9Sstevel@tonic-gate * about an error- They do not track multiple errors. In fact,
29747c478bd9Sstevel@tonic-gate * you could consider them latched register bits if you like.
29757c478bd9Sstevel@tonic-gate * We are only interested in printing the error message once for
29764cad604cSMarcel Telka * any cluster of overrun errors.
29777c478bd9Sstevel@tonic-gate */
29787c478bd9Sstevel@tonic-gate if (async->async_hw_overrun) {
29797c478bd9Sstevel@tonic-gate if (async->async_flags & ASYNC_ISOPEN) {
29807c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
29817c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
29827c478bd9Sstevel@tonic-gate asyerror(CE_NOTE, "asy%d: silo overflow", instance);
29837c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
29847c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
29857c478bd9Sstevel@tonic-gate }
29867c478bd9Sstevel@tonic-gate async->async_hw_overrun = 0;
29877c478bd9Sstevel@tonic-gate }
29887c478bd9Sstevel@tonic-gate if (async->async_sw_overrun) {
29897c478bd9Sstevel@tonic-gate if (async->async_flags & ASYNC_ISOPEN) {
29907c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
29917c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
29927c478bd9Sstevel@tonic-gate asyerror(CE_NOTE, "asy%d: ring buffer overflow",
29937c478bd9Sstevel@tonic-gate instance);
29947c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
29957c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
29967c478bd9Sstevel@tonic-gate }
29977c478bd9Sstevel@tonic-gate async->async_sw_overrun = 0;
29987c478bd9Sstevel@tonic-gate }
2999cd43c54aSZach Kissel if (asy->asy_flags & ASY_DOINGSOFT_RETRY) {
30007c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
30017c478bd9Sstevel@tonic-gate goto begin;
30027c478bd9Sstevel@tonic-gate }
30037c478bd9Sstevel@tonic-gate asy->asy_flags &= ~ASY_DOINGSOFT;
3004cd43c54aSZach Kissel mutex_exit(&asy->asy_excl_hi);
3005cd43c54aSZach Kissel mutex_exit(&asy->asy_excl);
30067c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_PROCS, "async%d_softint: done\n", instance);
30077c478bd9Sstevel@tonic-gate }
30087c478bd9Sstevel@tonic-gate
30097c478bd9Sstevel@tonic-gate /*
30107c478bd9Sstevel@tonic-gate * Restart output on a line after a delay or break timer expired.
30117c478bd9Sstevel@tonic-gate */
30127c478bd9Sstevel@tonic-gate static void
async_restart(void * arg)30137c478bd9Sstevel@tonic-gate async_restart(void *arg)
30147c478bd9Sstevel@tonic-gate {
30157c478bd9Sstevel@tonic-gate struct asyncline *async = (struct asyncline *)arg;
30167c478bd9Sstevel@tonic-gate struct asycom *asy = async->async_common;
30177c478bd9Sstevel@tonic-gate uchar_t lcr;
30187c478bd9Sstevel@tonic-gate
30197c478bd9Sstevel@tonic-gate /*
30207c478bd9Sstevel@tonic-gate * If break timer expired, turn off the break bit.
30217c478bd9Sstevel@tonic-gate */
30227c478bd9Sstevel@tonic-gate #ifdef DEBUG
30237c478bd9Sstevel@tonic-gate int instance = UNIT(async->async_dev);
30247c478bd9Sstevel@tonic-gate
30257c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_PROCS, "async%d_restart\n", instance);
30267c478bd9Sstevel@tonic-gate #endif
30277c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
30287c478bd9Sstevel@tonic-gate /*
30297c478bd9Sstevel@tonic-gate * If ASYNC_OUT_SUSPEND is also set, we don't really
30307c478bd9Sstevel@tonic-gate * clean the HW break, TIOCCBRK is responsible for this.
30317c478bd9Sstevel@tonic-gate */
30327c478bd9Sstevel@tonic-gate if ((async->async_flags & ASYNC_BREAK) &&
30337c478bd9Sstevel@tonic-gate !(async->async_flags & ASYNC_OUT_SUSPEND)) {
30347c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
30352df1fe9cSrandyf lcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
30364ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
30377c478bd9Sstevel@tonic-gate (lcr & ~SETBREAK));
30387c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
30397c478bd9Sstevel@tonic-gate }
30407c478bd9Sstevel@tonic-gate async->async_flags &= ~(ASYNC_DELAY|ASYNC_BREAK);
30417c478bd9Sstevel@tonic-gate cv_broadcast(&async->async_flags_cv);
30427c478bd9Sstevel@tonic-gate async_start(async);
30437c478bd9Sstevel@tonic-gate
30447c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
30457c478bd9Sstevel@tonic-gate }
30467c478bd9Sstevel@tonic-gate
30477c478bd9Sstevel@tonic-gate static void
async_start(struct asyncline * async)30487c478bd9Sstevel@tonic-gate async_start(struct asyncline *async)
30497c478bd9Sstevel@tonic-gate {
30507c478bd9Sstevel@tonic-gate async_nstart(async, 0);
30517c478bd9Sstevel@tonic-gate }
30527c478bd9Sstevel@tonic-gate
30537c478bd9Sstevel@tonic-gate /*
30547c478bd9Sstevel@tonic-gate * Start output on a line, unless it's busy, frozen, or otherwise.
30557c478bd9Sstevel@tonic-gate */
30567c478bd9Sstevel@tonic-gate /*ARGSUSED*/
30577c478bd9Sstevel@tonic-gate static void
async_nstart(struct asyncline * async,int mode)30587c478bd9Sstevel@tonic-gate async_nstart(struct asyncline *async, int mode)
30597c478bd9Sstevel@tonic-gate {
30607c478bd9Sstevel@tonic-gate struct asycom *asy = async->async_common;
30617c478bd9Sstevel@tonic-gate int cc;
30627c478bd9Sstevel@tonic-gate queue_t *q;
30637c478bd9Sstevel@tonic-gate mblk_t *bp;
30647c478bd9Sstevel@tonic-gate uchar_t *xmit_addr;
30657c478bd9Sstevel@tonic-gate uchar_t val;
30667c478bd9Sstevel@tonic-gate int fifo_len = 1;
30677c478bd9Sstevel@tonic-gate boolean_t didsome;
30687c478bd9Sstevel@tonic-gate mblk_t *nbp;
30697c478bd9Sstevel@tonic-gate
30707c478bd9Sstevel@tonic-gate #ifdef DEBUG
30717c478bd9Sstevel@tonic-gate int instance = UNIT(async->async_dev);
30727c478bd9Sstevel@tonic-gate
30737c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_PROCS, "async%d_nstart\n", instance);
30747c478bd9Sstevel@tonic-gate #endif
30757c478bd9Sstevel@tonic-gate if (asy->asy_use_fifo == FIFO_ON) {
30767c478bd9Sstevel@tonic-gate fifo_len = asy->asy_fifo_buf; /* with FIFO buffers */
30777c478bd9Sstevel@tonic-gate if (fifo_len > asy_max_tx_fifo)
30787c478bd9Sstevel@tonic-gate fifo_len = asy_max_tx_fifo;
30797c478bd9Sstevel@tonic-gate }
30807c478bd9Sstevel@tonic-gate
30817c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&asy->asy_excl));
30827c478bd9Sstevel@tonic-gate
30837c478bd9Sstevel@tonic-gate /*
30847c478bd9Sstevel@tonic-gate * If the chip is busy (i.e., we're waiting for a break timeout
30857c478bd9Sstevel@tonic-gate * to expire, or for the current transmission to finish, or for
30867c478bd9Sstevel@tonic-gate * output to finish draining from chip), don't grab anything new.
30877c478bd9Sstevel@tonic-gate */
30887c478bd9Sstevel@tonic-gate if (async->async_flags & (ASYNC_BREAK|ASYNC_BUSY)) {
30897c478bd9Sstevel@tonic-gate DEBUGCONT2((mode? ASY_DEBUG_OUT : 0),
30907c478bd9Sstevel@tonic-gate "async%d_nstart: start %s.\n",
30917c478bd9Sstevel@tonic-gate instance,
30927c478bd9Sstevel@tonic-gate async->async_flags & ASYNC_BREAK ? "break" : "busy");
30937c478bd9Sstevel@tonic-gate return;
30947c478bd9Sstevel@tonic-gate }
30957c478bd9Sstevel@tonic-gate
30967c478bd9Sstevel@tonic-gate /*
30977c478bd9Sstevel@tonic-gate * Check only pended sw input flow control.
30987c478bd9Sstevel@tonic-gate */
30997c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
31007c478bd9Sstevel@tonic-gate if (async_flowcontrol_sw_input(asy, FLOW_CHECK, IN_FLOW_NULL))
31017c478bd9Sstevel@tonic-gate fifo_len--;
31027c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
31037c478bd9Sstevel@tonic-gate
31047c478bd9Sstevel@tonic-gate /*
31057c478bd9Sstevel@tonic-gate * If we're waiting for a delay timeout to expire, don't grab
31067c478bd9Sstevel@tonic-gate * anything new.
31077c478bd9Sstevel@tonic-gate */
31087c478bd9Sstevel@tonic-gate if (async->async_flags & ASYNC_DELAY) {
31097c478bd9Sstevel@tonic-gate DEBUGCONT1((mode? ASY_DEBUG_OUT : 0),
31107c478bd9Sstevel@tonic-gate "async%d_nstart: start ASYNC_DELAY.\n", instance);
31117c478bd9Sstevel@tonic-gate return;
31127c478bd9Sstevel@tonic-gate }
31137c478bd9Sstevel@tonic-gate
31147c478bd9Sstevel@tonic-gate if ((q = async->async_ttycommon.t_writeq) == NULL) {
31157c478bd9Sstevel@tonic-gate DEBUGCONT1((mode? ASY_DEBUG_OUT : 0),
31167c478bd9Sstevel@tonic-gate "async%d_nstart: start writeq is null.\n", instance);
31177c478bd9Sstevel@tonic-gate return; /* not attached to a stream */
31187c478bd9Sstevel@tonic-gate }
31197c478bd9Sstevel@tonic-gate
31207c478bd9Sstevel@tonic-gate for (;;) {
31217c478bd9Sstevel@tonic-gate if ((bp = getq(q)) == NULL)
31227c478bd9Sstevel@tonic-gate return; /* no data to transmit */
31237c478bd9Sstevel@tonic-gate
31247c478bd9Sstevel@tonic-gate /*
31257c478bd9Sstevel@tonic-gate * We have a message block to work on.
31267c478bd9Sstevel@tonic-gate * Check whether it's a break, a delay, or an ioctl (the latter
31277c478bd9Sstevel@tonic-gate * occurs if the ioctl in question was waiting for the output
31287c478bd9Sstevel@tonic-gate * to drain). If it's one of those, process it immediately.
31297c478bd9Sstevel@tonic-gate */
31307c478bd9Sstevel@tonic-gate switch (bp->b_datap->db_type) {
31317c478bd9Sstevel@tonic-gate
31327c478bd9Sstevel@tonic-gate case M_BREAK:
31337c478bd9Sstevel@tonic-gate /*
31347c478bd9Sstevel@tonic-gate * Set the break bit, and arrange for "async_restart"
31357c478bd9Sstevel@tonic-gate * to be called in 1/4 second; it will turn the
31367c478bd9Sstevel@tonic-gate * break bit off, and call "async_start" to grab
31377c478bd9Sstevel@tonic-gate * the next message.
31387c478bd9Sstevel@tonic-gate */
31397c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
31404ab75253Smrj val = ddi_get8(asy->asy_iohandle,
31417c478bd9Sstevel@tonic-gate asy->asy_ioaddr + LCR);
31422df1fe9cSrandyf ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
31432df1fe9cSrandyf (val | SETBREAK));
31447c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
31457c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_BREAK;
31467c478bd9Sstevel@tonic-gate (void) timeout(async_restart, (caddr_t)async,
31477c478bd9Sstevel@tonic-gate drv_usectohz(1000000)/4);
31487c478bd9Sstevel@tonic-gate freemsg(bp);
31497c478bd9Sstevel@tonic-gate return; /* wait for this to finish */
31507c478bd9Sstevel@tonic-gate
31517c478bd9Sstevel@tonic-gate case M_DELAY:
31527c478bd9Sstevel@tonic-gate /*
31537c478bd9Sstevel@tonic-gate * Arrange for "async_restart" to be called when the
31547c478bd9Sstevel@tonic-gate * delay expires; it will turn ASYNC_DELAY off,
31557c478bd9Sstevel@tonic-gate * and call "async_start" to grab the next message.
31567c478bd9Sstevel@tonic-gate */
31577c478bd9Sstevel@tonic-gate (void) timeout(async_restart, (caddr_t)async,
31587c478bd9Sstevel@tonic-gate (int)(*(unsigned char *)bp->b_rptr + 6));
31597c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_DELAY;
31607c478bd9Sstevel@tonic-gate freemsg(bp);
31617c478bd9Sstevel@tonic-gate return; /* wait for this to finish */
31627c478bd9Sstevel@tonic-gate
31637c478bd9Sstevel@tonic-gate case M_IOCTL:
31647c478bd9Sstevel@tonic-gate /*
31657c478bd9Sstevel@tonic-gate * This ioctl was waiting for the output ahead of
31667c478bd9Sstevel@tonic-gate * it to drain; obviously, it has. Do it, and
31677c478bd9Sstevel@tonic-gate * then grab the next message after it.
31687c478bd9Sstevel@tonic-gate */
31697c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
31707c478bd9Sstevel@tonic-gate async_ioctl(async, q, bp);
31717c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
31727c478bd9Sstevel@tonic-gate continue;
31737c478bd9Sstevel@tonic-gate }
31747c478bd9Sstevel@tonic-gate
317522eb7cb5Sgd78059 while (bp != NULL && ((cc = MBLKL(bp)) == 0)) {
31767c478bd9Sstevel@tonic-gate nbp = bp->b_cont;
31777c478bd9Sstevel@tonic-gate freeb(bp);
31787c478bd9Sstevel@tonic-gate bp = nbp;
31797c478bd9Sstevel@tonic-gate }
31807c478bd9Sstevel@tonic-gate if (bp != NULL)
31817c478bd9Sstevel@tonic-gate break;
31827c478bd9Sstevel@tonic-gate }
31837c478bd9Sstevel@tonic-gate
31847c478bd9Sstevel@tonic-gate /*
31857c478bd9Sstevel@tonic-gate * We have data to transmit. If output is stopped, put
31867c478bd9Sstevel@tonic-gate * it back and try again later.
31877c478bd9Sstevel@tonic-gate */
31887c478bd9Sstevel@tonic-gate if (async->async_flags & (ASYNC_HW_OUT_FLW | ASYNC_SW_OUT_FLW |
31897c478bd9Sstevel@tonic-gate ASYNC_STOPPED | ASYNC_OUT_SUSPEND)) {
31907c478bd9Sstevel@tonic-gate (void) putbq(q, bp);
31917c478bd9Sstevel@tonic-gate return;
31927c478bd9Sstevel@tonic-gate }
31937c478bd9Sstevel@tonic-gate
31947c478bd9Sstevel@tonic-gate async->async_xmitblk = bp;
31957c478bd9Sstevel@tonic-gate xmit_addr = bp->b_rptr;
31967c478bd9Sstevel@tonic-gate bp = bp->b_cont;
31977c478bd9Sstevel@tonic-gate if (bp != NULL)
31987c478bd9Sstevel@tonic-gate (void) putbq(q, bp); /* not done with this message yet */
31997c478bd9Sstevel@tonic-gate
32007c478bd9Sstevel@tonic-gate /*
32017c478bd9Sstevel@tonic-gate * In 5-bit mode, the high order bits are used
32027c478bd9Sstevel@tonic-gate * to indicate character sizes less than five,
32037c478bd9Sstevel@tonic-gate * so we need to explicitly mask before transmitting
32047c478bd9Sstevel@tonic-gate */
32057c478bd9Sstevel@tonic-gate if ((async->async_ttycommon.t_cflag & CSIZE) == CS5) {
32067c478bd9Sstevel@tonic-gate unsigned char *p = xmit_addr;
32077c478bd9Sstevel@tonic-gate int cnt = cc;
32087c478bd9Sstevel@tonic-gate
32097c478bd9Sstevel@tonic-gate while (cnt--)
32107c478bd9Sstevel@tonic-gate *p++ &= (unsigned char) 0x1f;
32117c478bd9Sstevel@tonic-gate }
32127c478bd9Sstevel@tonic-gate
32137c478bd9Sstevel@tonic-gate /*
32147c478bd9Sstevel@tonic-gate * Set up this block for pseudo-DMA.
32157c478bd9Sstevel@tonic-gate */
32167c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
32177c478bd9Sstevel@tonic-gate /*
32187c478bd9Sstevel@tonic-gate * If the transmitter is ready, shove the first
32197c478bd9Sstevel@tonic-gate * character out.
32207c478bd9Sstevel@tonic-gate */
32217c478bd9Sstevel@tonic-gate didsome = B_FALSE;
32227c478bd9Sstevel@tonic-gate while (--fifo_len >= 0 && cc > 0) {
32234ab75253Smrj if (!(ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR) &
32247c478bd9Sstevel@tonic-gate XHRE))
32257c478bd9Sstevel@tonic-gate break;
32264ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT,
32277c478bd9Sstevel@tonic-gate *xmit_addr++);
32287c478bd9Sstevel@tonic-gate cc--;
32297c478bd9Sstevel@tonic-gate didsome = B_TRUE;
32307c478bd9Sstevel@tonic-gate }
32317c478bd9Sstevel@tonic-gate async->async_optr = xmit_addr;
32327c478bd9Sstevel@tonic-gate async->async_ocnt = cc;
32337c478bd9Sstevel@tonic-gate if (didsome)
32347c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_PROGRESS;
32357c478bd9Sstevel@tonic-gate DEBUGCONT2(ASY_DEBUG_BUSY,
32367c478bd9Sstevel@tonic-gate "async%d_nstart: Set ASYNC_BUSY. async_ocnt=%d\n",
32372df1fe9cSrandyf instance, async->async_ocnt);
32387c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_BUSY;
32397c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
32407c478bd9Sstevel@tonic-gate }
32417c478bd9Sstevel@tonic-gate
32427c478bd9Sstevel@tonic-gate /*
32437c478bd9Sstevel@tonic-gate * Resume output by poking the transmitter.
32447c478bd9Sstevel@tonic-gate */
32457c478bd9Sstevel@tonic-gate static void
async_resume(struct asyncline * async)32467c478bd9Sstevel@tonic-gate async_resume(struct asyncline *async)
32477c478bd9Sstevel@tonic-gate {
32487c478bd9Sstevel@tonic-gate struct asycom *asy = async->async_common;
32497c478bd9Sstevel@tonic-gate #ifdef DEBUG
32507c478bd9Sstevel@tonic-gate int instance;
32517c478bd9Sstevel@tonic-gate #endif
32527c478bd9Sstevel@tonic-gate
32537c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&asy->asy_excl_hi));
32547c478bd9Sstevel@tonic-gate #ifdef DEBUG
32557c478bd9Sstevel@tonic-gate instance = UNIT(async->async_dev);
32567c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_PROCS, "async%d_resume\n", instance);
32577c478bd9Sstevel@tonic-gate #endif
32587c478bd9Sstevel@tonic-gate
32594ab75253Smrj if (ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR) & XHRE) {
32607c478bd9Sstevel@tonic-gate if (async_flowcontrol_sw_input(asy, FLOW_CHECK, IN_FLOW_NULL))
32617c478bd9Sstevel@tonic-gate return;
32627c478bd9Sstevel@tonic-gate if (async->async_ocnt > 0 &&
32637c478bd9Sstevel@tonic-gate !(async->async_flags &
32647c478bd9Sstevel@tonic-gate (ASYNC_HW_OUT_FLW|ASYNC_SW_OUT_FLW|ASYNC_OUT_SUSPEND))) {
32654ab75253Smrj ddi_put8(asy->asy_iohandle,
32667c478bd9Sstevel@tonic-gate asy->asy_ioaddr + DAT, *async->async_optr++);
32677c478bd9Sstevel@tonic-gate async->async_ocnt--;
32687c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_PROGRESS;
32697c478bd9Sstevel@tonic-gate }
32707c478bd9Sstevel@tonic-gate }
32717c478bd9Sstevel@tonic-gate }
32727c478bd9Sstevel@tonic-gate
32737c478bd9Sstevel@tonic-gate /*
32747c478bd9Sstevel@tonic-gate * Hold the untimed break to last the minimum time.
32757c478bd9Sstevel@tonic-gate */
32767c478bd9Sstevel@tonic-gate static void
async_hold_utbrk(void * arg)32777c478bd9Sstevel@tonic-gate async_hold_utbrk(void *arg)
32787c478bd9Sstevel@tonic-gate {
32797c478bd9Sstevel@tonic-gate struct asyncline *async = arg;
32807c478bd9Sstevel@tonic-gate struct asycom *asy = async->async_common;
32817c478bd9Sstevel@tonic-gate
32827c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
32837c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_HOLD_UTBRK;
32847c478bd9Sstevel@tonic-gate cv_broadcast(&async->async_flags_cv);
32857c478bd9Sstevel@tonic-gate async->async_utbrktid = 0;
32867c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
32877c478bd9Sstevel@tonic-gate }
32887c478bd9Sstevel@tonic-gate
32897c478bd9Sstevel@tonic-gate /*
32907c478bd9Sstevel@tonic-gate * Resume the untimed break.
32917c478bd9Sstevel@tonic-gate */
32927c478bd9Sstevel@tonic-gate static void
async_resume_utbrk(struct asyncline * async)32937c478bd9Sstevel@tonic-gate async_resume_utbrk(struct asyncline *async)
32947c478bd9Sstevel@tonic-gate {
32957c478bd9Sstevel@tonic-gate uchar_t val;
32967c478bd9Sstevel@tonic-gate struct asycom *asy = async->async_common;
32977c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&asy->asy_excl));
32987c478bd9Sstevel@tonic-gate
32997c478bd9Sstevel@tonic-gate /*
33007c478bd9Sstevel@tonic-gate * Because the wait time is very short,
33017c478bd9Sstevel@tonic-gate * so we use uninterruptably wait.
33027c478bd9Sstevel@tonic-gate */
33037c478bd9Sstevel@tonic-gate while (async->async_flags & ASYNC_HOLD_UTBRK) {
33047c478bd9Sstevel@tonic-gate cv_wait(&async->async_flags_cv, &asy->asy_excl);
33057c478bd9Sstevel@tonic-gate }
33067c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
33077c478bd9Sstevel@tonic-gate /*
33087c478bd9Sstevel@tonic-gate * Timed break and untimed break can exist simultaneously,
33097c478bd9Sstevel@tonic-gate * if ASYNC_BREAK is also set at here, we don't
33107c478bd9Sstevel@tonic-gate * really clean the HW break.
33117c478bd9Sstevel@tonic-gate */
33127c478bd9Sstevel@tonic-gate if (!(async->async_flags & ASYNC_BREAK)) {
33134ab75253Smrj val = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
33144ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
33157c478bd9Sstevel@tonic-gate (val & ~SETBREAK));
33167c478bd9Sstevel@tonic-gate }
33177c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_OUT_SUSPEND;
33187c478bd9Sstevel@tonic-gate cv_broadcast(&async->async_flags_cv);
33197c478bd9Sstevel@tonic-gate if (async->async_ocnt > 0) {
33207c478bd9Sstevel@tonic-gate async_resume(async);
33217c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
33227c478bd9Sstevel@tonic-gate } else {
33237c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_BUSY;
33247c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
33257c478bd9Sstevel@tonic-gate if (async->async_xmitblk != NULL) {
33267c478bd9Sstevel@tonic-gate freeb(async->async_xmitblk);
33277c478bd9Sstevel@tonic-gate async->async_xmitblk = NULL;
33287c478bd9Sstevel@tonic-gate }
33297c478bd9Sstevel@tonic-gate async_start(async);
33307c478bd9Sstevel@tonic-gate }
33317c478bd9Sstevel@tonic-gate }
33327c478bd9Sstevel@tonic-gate
33337c478bd9Sstevel@tonic-gate /*
33347c478bd9Sstevel@tonic-gate * Process an "ioctl" message sent down to us.
33357c478bd9Sstevel@tonic-gate * Note that we don't need to get any locks until we are ready to access
33367c478bd9Sstevel@tonic-gate * the hardware. Nothing we access until then is going to be altered
33377c478bd9Sstevel@tonic-gate * outside of the STREAMS framework, so we should be safe.
33387c478bd9Sstevel@tonic-gate */
33397c478bd9Sstevel@tonic-gate int asydelay = 10000;
33407c478bd9Sstevel@tonic-gate static void
async_ioctl(struct asyncline * async,queue_t * wq,mblk_t * mp)33417c478bd9Sstevel@tonic-gate async_ioctl(struct asyncline *async, queue_t *wq, mblk_t *mp)
33427c478bd9Sstevel@tonic-gate {
33437c478bd9Sstevel@tonic-gate struct asycom *asy = async->async_common;
33447c478bd9Sstevel@tonic-gate tty_common_t *tp = &async->async_ttycommon;
33457c478bd9Sstevel@tonic-gate struct iocblk *iocp;
33467c478bd9Sstevel@tonic-gate unsigned datasize;
33477c478bd9Sstevel@tonic-gate int error = 0;
33487c478bd9Sstevel@tonic-gate uchar_t val;
33497c478bd9Sstevel@tonic-gate mblk_t *datamp;
33507c478bd9Sstevel@tonic-gate unsigned int index;
33517c478bd9Sstevel@tonic-gate
33527c478bd9Sstevel@tonic-gate #ifdef DEBUG
33537c478bd9Sstevel@tonic-gate int instance = UNIT(async->async_dev);
33547c478bd9Sstevel@tonic-gate
33557c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_PROCS, "async%d_ioctl\n", instance);
33567c478bd9Sstevel@tonic-gate #endif
33577c478bd9Sstevel@tonic-gate
33587c478bd9Sstevel@tonic-gate if (tp->t_iocpending != NULL) {
33597c478bd9Sstevel@tonic-gate /*
33607c478bd9Sstevel@tonic-gate * We were holding an "ioctl" response pending the
33617c478bd9Sstevel@tonic-gate * availability of an "mblk" to hold data to be passed up;
33627c478bd9Sstevel@tonic-gate * another "ioctl" came through, which means that "ioctl"
33637c478bd9Sstevel@tonic-gate * must have timed out or been aborted.
33647c478bd9Sstevel@tonic-gate */
33657c478bd9Sstevel@tonic-gate freemsg(async->async_ttycommon.t_iocpending);
33667c478bd9Sstevel@tonic-gate async->async_ttycommon.t_iocpending = NULL;
33677c478bd9Sstevel@tonic-gate }
33687c478bd9Sstevel@tonic-gate
33697c478bd9Sstevel@tonic-gate iocp = (struct iocblk *)mp->b_rptr;
33707c478bd9Sstevel@tonic-gate
33717c478bd9Sstevel@tonic-gate /*
33727c478bd9Sstevel@tonic-gate * For TIOCMGET and the PPS ioctls, do NOT call ttycommon_ioctl()
33737c478bd9Sstevel@tonic-gate * because this function frees up the message block (mp->b_cont) that
33747c478bd9Sstevel@tonic-gate * contains the user location where we pass back the results.
33757c478bd9Sstevel@tonic-gate *
33767c478bd9Sstevel@tonic-gate * Similarly, CONSOPENPOLLEDIO needs ioc_count, which ttycommon_ioctl
33777c478bd9Sstevel@tonic-gate * zaps. We know that ttycommon_ioctl doesn't know any CONS*
33787c478bd9Sstevel@tonic-gate * ioctls, so keep the others safe too.
33797c478bd9Sstevel@tonic-gate */
33807c478bd9Sstevel@tonic-gate DEBUGCONT2(ASY_DEBUG_IOCTL, "async%d_ioctl: %s\n",
33817c478bd9Sstevel@tonic-gate instance,
33827c478bd9Sstevel@tonic-gate iocp->ioc_cmd == TIOCMGET ? "TIOCMGET" :
33837c478bd9Sstevel@tonic-gate iocp->ioc_cmd == TIOCMSET ? "TIOCMSET" :
33847c478bd9Sstevel@tonic-gate iocp->ioc_cmd == TIOCMBIS ? "TIOCMBIS" :
33857c478bd9Sstevel@tonic-gate iocp->ioc_cmd == TIOCMBIC ? "TIOCMBIC" :
33867c478bd9Sstevel@tonic-gate "other");
33872df1fe9cSrandyf
33887c478bd9Sstevel@tonic-gate switch (iocp->ioc_cmd) {
33897c478bd9Sstevel@tonic-gate case TIOCMGET:
33907c478bd9Sstevel@tonic-gate case TIOCGPPS:
33917c478bd9Sstevel@tonic-gate case TIOCSPPS:
33927c478bd9Sstevel@tonic-gate case TIOCGPPSEV:
33937c478bd9Sstevel@tonic-gate case CONSOPENPOLLEDIO:
33947c478bd9Sstevel@tonic-gate case CONSCLOSEPOLLEDIO:
33957c478bd9Sstevel@tonic-gate case CONSSETABORTENABLE:
33967c478bd9Sstevel@tonic-gate case CONSGETABORTENABLE:
33977c478bd9Sstevel@tonic-gate error = -1; /* Do Nothing */
33987c478bd9Sstevel@tonic-gate break;
33997c478bd9Sstevel@tonic-gate default:
34007c478bd9Sstevel@tonic-gate
34017c478bd9Sstevel@tonic-gate /*
34027c478bd9Sstevel@tonic-gate * The only way in which "ttycommon_ioctl" can fail is if the
34037c478bd9Sstevel@tonic-gate * "ioctl" requires a response containing data to be returned
34047c478bd9Sstevel@tonic-gate * to the user, and no mblk could be allocated for the data.
34057c478bd9Sstevel@tonic-gate * No such "ioctl" alters our state. Thus, we always go ahead
34067c478bd9Sstevel@tonic-gate * and do any state-changes the "ioctl" calls for. If we
34077c478bd9Sstevel@tonic-gate * couldn't allocate the data, "ttycommon_ioctl" has stashed
34087c478bd9Sstevel@tonic-gate * the "ioctl" away safely, so we just call "bufcall" to
34097c478bd9Sstevel@tonic-gate * request that we be called back when we stand a better
34107c478bd9Sstevel@tonic-gate * chance of allocating the data.
34117c478bd9Sstevel@tonic-gate */
34127c478bd9Sstevel@tonic-gate if ((datasize = ttycommon_ioctl(tp, wq, mp, &error)) != 0) {
34137c478bd9Sstevel@tonic-gate if (async->async_wbufcid)
34147c478bd9Sstevel@tonic-gate unbufcall(async->async_wbufcid);
34157c478bd9Sstevel@tonic-gate async->async_wbufcid = bufcall(datasize, BPRI_HI,
34167c478bd9Sstevel@tonic-gate (void (*)(void *)) async_reioctl,
34177c478bd9Sstevel@tonic-gate (void *)(intptr_t)async->async_common->asy_unit);
34187c478bd9Sstevel@tonic-gate return;
34197c478bd9Sstevel@tonic-gate }
34207c478bd9Sstevel@tonic-gate }
34217c478bd9Sstevel@tonic-gate
34227c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
34237c478bd9Sstevel@tonic-gate
34247c478bd9Sstevel@tonic-gate if (error == 0) {
34257c478bd9Sstevel@tonic-gate /*
34267c478bd9Sstevel@tonic-gate * "ttycommon_ioctl" did most of the work; we just use the
34277c478bd9Sstevel@tonic-gate * data it set up.
34287c478bd9Sstevel@tonic-gate */
34297c478bd9Sstevel@tonic-gate switch (iocp->ioc_cmd) {
34307c478bd9Sstevel@tonic-gate
34317c478bd9Sstevel@tonic-gate case TCSETS:
34327c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
34337c478bd9Sstevel@tonic-gate if (asy_baudok(asy))
34347c478bd9Sstevel@tonic-gate asy_program(asy, ASY_NOINIT);
34357c478bd9Sstevel@tonic-gate else
34367c478bd9Sstevel@tonic-gate error = EINVAL;
34377c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
34387c478bd9Sstevel@tonic-gate break;
34397c478bd9Sstevel@tonic-gate case TCSETSF:
34407c478bd9Sstevel@tonic-gate case TCSETSW:
34417c478bd9Sstevel@tonic-gate case TCSETA:
34427c478bd9Sstevel@tonic-gate case TCSETAW:
34437c478bd9Sstevel@tonic-gate case TCSETAF:
34447c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
34457c478bd9Sstevel@tonic-gate if (!asy_baudok(asy))
34467c478bd9Sstevel@tonic-gate error = EINVAL;
34477c478bd9Sstevel@tonic-gate else {
34487c478bd9Sstevel@tonic-gate if (asy_isbusy(asy))
34497c478bd9Sstevel@tonic-gate asy_waiteot(asy);
34507c478bd9Sstevel@tonic-gate asy_program(asy, ASY_NOINIT);
34517c478bd9Sstevel@tonic-gate }
34527c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
34537c478bd9Sstevel@tonic-gate break;
34547c478bd9Sstevel@tonic-gate }
34557c478bd9Sstevel@tonic-gate } else if (error < 0) {
34567c478bd9Sstevel@tonic-gate /*
34577c478bd9Sstevel@tonic-gate * "ttycommon_ioctl" didn't do anything; we process it here.
34587c478bd9Sstevel@tonic-gate */
34597c478bd9Sstevel@tonic-gate error = 0;
34607c478bd9Sstevel@tonic-gate switch (iocp->ioc_cmd) {
34617c478bd9Sstevel@tonic-gate
34627c478bd9Sstevel@tonic-gate case TIOCGPPS:
34637c478bd9Sstevel@tonic-gate /*
34647c478bd9Sstevel@tonic-gate * Get PPS on/off.
34657c478bd9Sstevel@tonic-gate */
34667c478bd9Sstevel@tonic-gate if (mp->b_cont != NULL)
34677c478bd9Sstevel@tonic-gate freemsg(mp->b_cont);
34687c478bd9Sstevel@tonic-gate
34697c478bd9Sstevel@tonic-gate mp->b_cont = allocb(sizeof (int), BPRI_HI);
34707c478bd9Sstevel@tonic-gate if (mp->b_cont == NULL) {
34717c478bd9Sstevel@tonic-gate error = ENOMEM;
34727c478bd9Sstevel@tonic-gate break;
34737c478bd9Sstevel@tonic-gate }
34747c478bd9Sstevel@tonic-gate if (asy->asy_flags & ASY_PPS)
34757c478bd9Sstevel@tonic-gate *(int *)mp->b_cont->b_wptr = 1;
34767c478bd9Sstevel@tonic-gate else
34777c478bd9Sstevel@tonic-gate *(int *)mp->b_cont->b_wptr = 0;
34787c478bd9Sstevel@tonic-gate mp->b_cont->b_wptr += sizeof (int);
34797c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_IOCACK;
34807c478bd9Sstevel@tonic-gate iocp->ioc_count = sizeof (int);
34817c478bd9Sstevel@tonic-gate break;
34827c478bd9Sstevel@tonic-gate
34837c478bd9Sstevel@tonic-gate case TIOCSPPS:
34847c478bd9Sstevel@tonic-gate /*
34857c478bd9Sstevel@tonic-gate * Set PPS on/off.
34867c478bd9Sstevel@tonic-gate */
34877c478bd9Sstevel@tonic-gate error = miocpullup(mp, sizeof (int));
34887c478bd9Sstevel@tonic-gate if (error != 0)
34897c478bd9Sstevel@tonic-gate break;
34907c478bd9Sstevel@tonic-gate
34917c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
34927c478bd9Sstevel@tonic-gate if (*(int *)mp->b_cont->b_rptr)
34937c478bd9Sstevel@tonic-gate asy->asy_flags |= ASY_PPS;
34947c478bd9Sstevel@tonic-gate else
34957c478bd9Sstevel@tonic-gate asy->asy_flags &= ~ASY_PPS;
34967c478bd9Sstevel@tonic-gate /* Reset edge sense */
34977c478bd9Sstevel@tonic-gate asy->asy_flags &= ~ASY_PPS_EDGE;
34987c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
34997c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_IOCACK;
35007c478bd9Sstevel@tonic-gate break;
35017c478bd9Sstevel@tonic-gate
35027c478bd9Sstevel@tonic-gate case TIOCGPPSEV:
35037c478bd9Sstevel@tonic-gate {
35047c478bd9Sstevel@tonic-gate /*
35057c478bd9Sstevel@tonic-gate * Get PPS event data.
35067c478bd9Sstevel@tonic-gate */
35077c478bd9Sstevel@tonic-gate mblk_t *bp;
35087c478bd9Sstevel@tonic-gate void *buf;
35097c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL
35107c478bd9Sstevel@tonic-gate struct ppsclockev32 p32;
35117c478bd9Sstevel@tonic-gate #endif
35127c478bd9Sstevel@tonic-gate struct ppsclockev ppsclockev;
35137c478bd9Sstevel@tonic-gate
35147c478bd9Sstevel@tonic-gate if (mp->b_cont != NULL) {
35157c478bd9Sstevel@tonic-gate freemsg(mp->b_cont);
35167c478bd9Sstevel@tonic-gate mp->b_cont = NULL;
35177c478bd9Sstevel@tonic-gate }
35187c478bd9Sstevel@tonic-gate
35197c478bd9Sstevel@tonic-gate if ((asy->asy_flags & ASY_PPS) == 0) {
35207c478bd9Sstevel@tonic-gate error = ENXIO;
35217c478bd9Sstevel@tonic-gate break;
35227c478bd9Sstevel@tonic-gate }
35237c478bd9Sstevel@tonic-gate
35247c478bd9Sstevel@tonic-gate /* Protect from incomplete asy_ppsev */
35257c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
35267c478bd9Sstevel@tonic-gate ppsclockev = asy_ppsev;
35277c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
35287c478bd9Sstevel@tonic-gate
35297c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL
35307c478bd9Sstevel@tonic-gate if ((iocp->ioc_flag & IOC_MODELS) != IOC_NATIVE) {
35317c478bd9Sstevel@tonic-gate TIMEVAL_TO_TIMEVAL32(&p32.tv, &ppsclockev.tv);
35327c478bd9Sstevel@tonic-gate p32.serial = ppsclockev.serial;
35337c478bd9Sstevel@tonic-gate buf = &p32;
35347c478bd9Sstevel@tonic-gate iocp->ioc_count = sizeof (struct ppsclockev32);
35357c478bd9Sstevel@tonic-gate } else
35367c478bd9Sstevel@tonic-gate #endif
35377c478bd9Sstevel@tonic-gate {
35387c478bd9Sstevel@tonic-gate buf = &ppsclockev;
35397c478bd9Sstevel@tonic-gate iocp->ioc_count = sizeof (struct ppsclockev);
35407c478bd9Sstevel@tonic-gate }
35417c478bd9Sstevel@tonic-gate
35427c478bd9Sstevel@tonic-gate if ((bp = allocb(iocp->ioc_count, BPRI_HI)) == NULL) {
35437c478bd9Sstevel@tonic-gate error = ENOMEM;
35447c478bd9Sstevel@tonic-gate break;
35457c478bd9Sstevel@tonic-gate }
35467c478bd9Sstevel@tonic-gate mp->b_cont = bp;
35477c478bd9Sstevel@tonic-gate
35487c478bd9Sstevel@tonic-gate bcopy(buf, bp->b_wptr, iocp->ioc_count);
35497c478bd9Sstevel@tonic-gate bp->b_wptr += iocp->ioc_count;
35507c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_IOCACK;
35517c478bd9Sstevel@tonic-gate break;
35527c478bd9Sstevel@tonic-gate }
35537c478bd9Sstevel@tonic-gate
35547c478bd9Sstevel@tonic-gate case TCSBRK:
35557c478bd9Sstevel@tonic-gate error = miocpullup(mp, sizeof (int));
35567c478bd9Sstevel@tonic-gate if (error != 0)
35577c478bd9Sstevel@tonic-gate break;
35587c478bd9Sstevel@tonic-gate
35597c478bd9Sstevel@tonic-gate if (*(int *)mp->b_cont->b_rptr == 0) {
35607c478bd9Sstevel@tonic-gate
35617c478bd9Sstevel@tonic-gate /*
35627c478bd9Sstevel@tonic-gate * XXX Arrangements to ensure that a break
35637c478bd9Sstevel@tonic-gate * isn't in progress should be sufficient.
35647c478bd9Sstevel@tonic-gate * This ugly delay() is the only thing
35657c478bd9Sstevel@tonic-gate * that seems to work on the NCR Worldmark.
35667c478bd9Sstevel@tonic-gate * It should be replaced. Note that an
35677c478bd9Sstevel@tonic-gate * asy_waiteot() also does not work.
35687c478bd9Sstevel@tonic-gate */
35697c478bd9Sstevel@tonic-gate if (asydelay)
35707c478bd9Sstevel@tonic-gate delay(drv_usectohz(asydelay));
35717c478bd9Sstevel@tonic-gate
35727c478bd9Sstevel@tonic-gate while (async->async_flags & ASYNC_BREAK) {
35737c478bd9Sstevel@tonic-gate cv_wait(&async->async_flags_cv,
35747c478bd9Sstevel@tonic-gate &asy->asy_excl);
35757c478bd9Sstevel@tonic-gate }
35767c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
35777c478bd9Sstevel@tonic-gate /*
35787c478bd9Sstevel@tonic-gate * We loop until the TSR is empty and then
35797c478bd9Sstevel@tonic-gate * set the break. ASYNC_BREAK has been set
35807c478bd9Sstevel@tonic-gate * to ensure that no characters are
35817c478bd9Sstevel@tonic-gate * transmitted while the TSR is being
35827c478bd9Sstevel@tonic-gate * flushed and SOUT is being used for the
35837c478bd9Sstevel@tonic-gate * break signal.
35847c478bd9Sstevel@tonic-gate *
35857c478bd9Sstevel@tonic-gate * The wait period is equal to
35867c478bd9Sstevel@tonic-gate * clock / (baud * 16) * 16 * 2.
35877c478bd9Sstevel@tonic-gate */
35887c478bd9Sstevel@tonic-gate index = BAUDINDEX(
35897c478bd9Sstevel@tonic-gate async->async_ttycommon.t_cflag);
35907c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_BREAK;
35912df1fe9cSrandyf
35924ab75253Smrj while ((ddi_get8(asy->asy_iohandle,
35937c478bd9Sstevel@tonic-gate asy->asy_ioaddr + LSR) & XSRE) == 0) {
35947c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
35957c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
35967c478bd9Sstevel@tonic-gate drv_usecwait(
35977c478bd9Sstevel@tonic-gate 32*asyspdtab[index] & 0xfff);
35987c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
35997c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
36007c478bd9Sstevel@tonic-gate }
36017c478bd9Sstevel@tonic-gate /*
36027c478bd9Sstevel@tonic-gate * Arrange for "async_restart"
36037c478bd9Sstevel@tonic-gate * to be called in 1/4 second;
36047c478bd9Sstevel@tonic-gate * it will turn the break bit off, and call
36057c478bd9Sstevel@tonic-gate * "async_start" to grab the next message.
36067c478bd9Sstevel@tonic-gate */
36074ab75253Smrj val = ddi_get8(asy->asy_iohandle,
36087c478bd9Sstevel@tonic-gate asy->asy_ioaddr + LCR);
36094ab75253Smrj ddi_put8(asy->asy_iohandle,
36107c478bd9Sstevel@tonic-gate asy->asy_ioaddr + LCR,
36117c478bd9Sstevel@tonic-gate (val | SETBREAK));
36127c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
36137c478bd9Sstevel@tonic-gate (void) timeout(async_restart, (caddr_t)async,
36147c478bd9Sstevel@tonic-gate drv_usectohz(1000000)/4);
36157c478bd9Sstevel@tonic-gate } else {
36167c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_OUT,
36177c478bd9Sstevel@tonic-gate "async%d_ioctl: wait for flush.\n",
36187c478bd9Sstevel@tonic-gate instance);
36197c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
36207c478bd9Sstevel@tonic-gate asy_waiteot(asy);
36217c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
36227c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_OUT,
36237c478bd9Sstevel@tonic-gate "async%d_ioctl: ldterm satisfied.\n",
36247c478bd9Sstevel@tonic-gate instance);
36257c478bd9Sstevel@tonic-gate }
36267c478bd9Sstevel@tonic-gate break;
36277c478bd9Sstevel@tonic-gate
36287c478bd9Sstevel@tonic-gate case TIOCSBRK:
36297c478bd9Sstevel@tonic-gate if (!(async->async_flags & ASYNC_OUT_SUSPEND)) {
36307c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
36317c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_OUT_SUSPEND;
36327c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_HOLD_UTBRK;
36337c478bd9Sstevel@tonic-gate index = BAUDINDEX(
36347c478bd9Sstevel@tonic-gate async->async_ttycommon.t_cflag);
36354ab75253Smrj while ((ddi_get8(asy->asy_iohandle,
36367c478bd9Sstevel@tonic-gate asy->asy_ioaddr + LSR) & XSRE) == 0) {
36377c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
36387c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
36397c478bd9Sstevel@tonic-gate drv_usecwait(
36407c478bd9Sstevel@tonic-gate 32*asyspdtab[index] & 0xfff);
36417c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
36427c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
36437c478bd9Sstevel@tonic-gate }
36444ab75253Smrj val = ddi_get8(asy->asy_iohandle,
36457c478bd9Sstevel@tonic-gate asy->asy_ioaddr + LCR);
36464ab75253Smrj ddi_put8(asy->asy_iohandle,
36477c478bd9Sstevel@tonic-gate asy->asy_ioaddr + LCR, (val | SETBREAK));
36487c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
36497c478bd9Sstevel@tonic-gate /* wait for 100ms to hold BREAK */
36507c478bd9Sstevel@tonic-gate async->async_utbrktid =
36517c478bd9Sstevel@tonic-gate timeout((void (*)())async_hold_utbrk,
36527c478bd9Sstevel@tonic-gate (caddr_t)async,
36537c478bd9Sstevel@tonic-gate drv_usectohz(asy_min_utbrk));
36547c478bd9Sstevel@tonic-gate }
36557c478bd9Sstevel@tonic-gate mioc2ack(mp, NULL, 0, 0);
36567c478bd9Sstevel@tonic-gate break;
36577c478bd9Sstevel@tonic-gate
36587c478bd9Sstevel@tonic-gate case TIOCCBRK:
36597c478bd9Sstevel@tonic-gate if (async->async_flags & ASYNC_OUT_SUSPEND)
36607c478bd9Sstevel@tonic-gate async_resume_utbrk(async);
36617c478bd9Sstevel@tonic-gate mioc2ack(mp, NULL, 0, 0);
36627c478bd9Sstevel@tonic-gate break;
36637c478bd9Sstevel@tonic-gate
36647c478bd9Sstevel@tonic-gate case TIOCMSET:
36657c478bd9Sstevel@tonic-gate case TIOCMBIS:
36667c478bd9Sstevel@tonic-gate case TIOCMBIC:
36677c478bd9Sstevel@tonic-gate if (iocp->ioc_count != TRANSPARENT) {
36687c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_IOCTL, "async%d_ioctl: "
36697c478bd9Sstevel@tonic-gate "non-transparent\n", instance);
36707c478bd9Sstevel@tonic-gate
36717c478bd9Sstevel@tonic-gate error = miocpullup(mp, sizeof (int));
36727c478bd9Sstevel@tonic-gate if (error != 0)
36737c478bd9Sstevel@tonic-gate break;
36747c478bd9Sstevel@tonic-gate
36757c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
36767c478bd9Sstevel@tonic-gate (void) asymctl(asy,
36777c478bd9Sstevel@tonic-gate dmtoasy(*(int *)mp->b_cont->b_rptr),
36787c478bd9Sstevel@tonic-gate iocp->ioc_cmd);
36797c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
36807c478bd9Sstevel@tonic-gate iocp->ioc_error = 0;
36817c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_IOCACK;
36827c478bd9Sstevel@tonic-gate } else {
36837c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_IOCTL, "async%d_ioctl: "
36847c478bd9Sstevel@tonic-gate "transparent\n", instance);
36857c478bd9Sstevel@tonic-gate mcopyin(mp, NULL, sizeof (int), NULL);
36867c478bd9Sstevel@tonic-gate }
36877c478bd9Sstevel@tonic-gate break;
36887c478bd9Sstevel@tonic-gate
36897c478bd9Sstevel@tonic-gate case TIOCMGET:
36907c478bd9Sstevel@tonic-gate datamp = allocb(sizeof (int), BPRI_MED);
36917c478bd9Sstevel@tonic-gate if (datamp == NULL) {
36927c478bd9Sstevel@tonic-gate error = EAGAIN;
36937c478bd9Sstevel@tonic-gate break;
36947c478bd9Sstevel@tonic-gate }
36957c478bd9Sstevel@tonic-gate
36967c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
36977c478bd9Sstevel@tonic-gate *(int *)datamp->b_rptr = asymctl(asy, 0, TIOCMGET);
36987c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
36997c478bd9Sstevel@tonic-gate
37007c478bd9Sstevel@tonic-gate if (iocp->ioc_count == TRANSPARENT) {
37017c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_IOCTL, "async%d_ioctl: "
37027c478bd9Sstevel@tonic-gate "transparent\n", instance);
37032df1fe9cSrandyf mcopyout(mp, NULL, sizeof (int), NULL, datamp);
37047c478bd9Sstevel@tonic-gate } else {
37057c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_IOCTL, "async%d_ioctl: "
37067c478bd9Sstevel@tonic-gate "non-transparent\n", instance);
37077c478bd9Sstevel@tonic-gate mioc2ack(mp, datamp, sizeof (int), 0);
37087c478bd9Sstevel@tonic-gate }
37097c478bd9Sstevel@tonic-gate break;
37107c478bd9Sstevel@tonic-gate
37117c478bd9Sstevel@tonic-gate case CONSOPENPOLLEDIO:
37127c478bd9Sstevel@tonic-gate error = miocpullup(mp, sizeof (struct cons_polledio *));
37137c478bd9Sstevel@tonic-gate if (error != 0)
37147c478bd9Sstevel@tonic-gate break;
37157c478bd9Sstevel@tonic-gate
37167c478bd9Sstevel@tonic-gate *(struct cons_polledio **)mp->b_cont->b_rptr =
37177c478bd9Sstevel@tonic-gate &asy->polledio;
37187c478bd9Sstevel@tonic-gate
37197c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_IOCACK;
37207c478bd9Sstevel@tonic-gate break;
37217c478bd9Sstevel@tonic-gate
37227c478bd9Sstevel@tonic-gate case CONSCLOSEPOLLEDIO:
37237c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_IOCACK;
37247c478bd9Sstevel@tonic-gate iocp->ioc_error = 0;
37257c478bd9Sstevel@tonic-gate iocp->ioc_rval = 0;
37267c478bd9Sstevel@tonic-gate break;
37277c478bd9Sstevel@tonic-gate
37287c478bd9Sstevel@tonic-gate case CONSSETABORTENABLE:
37297c478bd9Sstevel@tonic-gate error = secpolicy_console(iocp->ioc_cr);
37307c478bd9Sstevel@tonic-gate if (error != 0)
37317c478bd9Sstevel@tonic-gate break;
37327c478bd9Sstevel@tonic-gate
37337c478bd9Sstevel@tonic-gate if (iocp->ioc_count != TRANSPARENT) {
37347c478bd9Sstevel@tonic-gate error = EINVAL;
37357c478bd9Sstevel@tonic-gate break;
37367c478bd9Sstevel@tonic-gate }
37377c478bd9Sstevel@tonic-gate
373885fe9a71SAndy Fiddaman mutex_enter(&asy->asy_excl_hi);
37397c478bd9Sstevel@tonic-gate if (*(intptr_t *)mp->b_cont->b_rptr)
37407c478bd9Sstevel@tonic-gate asy->asy_flags |= ASY_CONSOLE;
37417c478bd9Sstevel@tonic-gate else
37427c478bd9Sstevel@tonic-gate asy->asy_flags &= ~ASY_CONSOLE;
374385fe9a71SAndy Fiddaman mutex_exit(&asy->asy_excl_hi);
37447c478bd9Sstevel@tonic-gate
37457c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_IOCACK;
37467c478bd9Sstevel@tonic-gate iocp->ioc_error = 0;
37477c478bd9Sstevel@tonic-gate iocp->ioc_rval = 0;
37487c478bd9Sstevel@tonic-gate break;
37497c478bd9Sstevel@tonic-gate
37507c478bd9Sstevel@tonic-gate case CONSGETABORTENABLE:
37517c478bd9Sstevel@tonic-gate /*CONSTANTCONDITION*/
37527c478bd9Sstevel@tonic-gate ASSERT(sizeof (boolean_t) <= sizeof (boolean_t *));
37537c478bd9Sstevel@tonic-gate /*
37547c478bd9Sstevel@tonic-gate * Store the return value right in the payload
37557c478bd9Sstevel@tonic-gate * we were passed. Crude.
37567c478bd9Sstevel@tonic-gate */
37577c478bd9Sstevel@tonic-gate mcopyout(mp, NULL, sizeof (boolean_t), NULL, NULL);
37587c478bd9Sstevel@tonic-gate *(boolean_t *)mp->b_cont->b_rptr =
37597c478bd9Sstevel@tonic-gate (asy->asy_flags & ASY_CONSOLE) != 0;
37607c478bd9Sstevel@tonic-gate break;
37617c478bd9Sstevel@tonic-gate
37627c478bd9Sstevel@tonic-gate default:
37637c478bd9Sstevel@tonic-gate /*
37647c478bd9Sstevel@tonic-gate * If we don't understand it, it's an error. NAK it.
37657c478bd9Sstevel@tonic-gate */
37667c478bd9Sstevel@tonic-gate error = EINVAL;
37677c478bd9Sstevel@tonic-gate break;
37687c478bd9Sstevel@tonic-gate }
37697c478bd9Sstevel@tonic-gate }
37707c478bd9Sstevel@tonic-gate if (error != 0) {
37717c478bd9Sstevel@tonic-gate iocp->ioc_error = error;
37727c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_IOCNAK;
37737c478bd9Sstevel@tonic-gate }
37747c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
37757c478bd9Sstevel@tonic-gate qreply(wq, mp);
37767c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_PROCS, "async%d_ioctl: done\n", instance);
37777c478bd9Sstevel@tonic-gate }
37787c478bd9Sstevel@tonic-gate
37797c478bd9Sstevel@tonic-gate static int
asyrsrv(queue_t * q)37807c478bd9Sstevel@tonic-gate asyrsrv(queue_t *q)
37817c478bd9Sstevel@tonic-gate {
37827c478bd9Sstevel@tonic-gate mblk_t *bp;
37837c478bd9Sstevel@tonic-gate struct asyncline *async;
378485fe9a71SAndy Fiddaman struct asycom *asy;
37857c478bd9Sstevel@tonic-gate
37867c478bd9Sstevel@tonic-gate async = (struct asyncline *)q->q_ptr;
378785fe9a71SAndy Fiddaman asy = (struct asycom *)async->async_common;
37887c478bd9Sstevel@tonic-gate
37897c478bd9Sstevel@tonic-gate while (canputnext(q) && (bp = getq(q)))
37907c478bd9Sstevel@tonic-gate putnext(q, bp);
379185fe9a71SAndy Fiddaman mutex_enter(&asy->asy_excl_hi);
379285fe9a71SAndy Fiddaman ASYSETSOFT(asy);
379385fe9a71SAndy Fiddaman mutex_exit(&asy->asy_excl_hi);
37947c478bd9Sstevel@tonic-gate async->async_polltid = 0;
37957c478bd9Sstevel@tonic-gate return (0);
37967c478bd9Sstevel@tonic-gate }
37977c478bd9Sstevel@tonic-gate
37987c478bd9Sstevel@tonic-gate /*
37992df1fe9cSrandyf * The ASYWPUTDO_NOT_SUSP macro indicates to asywputdo() whether it should
38002df1fe9cSrandyf * handle messages as though the driver is operating normally or is
38012df1fe9cSrandyf * suspended. In the suspended case, some or all of the processing may have
38022df1fe9cSrandyf * to be delayed until the driver is resumed.
38032df1fe9cSrandyf */
38042df1fe9cSrandyf #define ASYWPUTDO_NOT_SUSP(async, wput) \
38052df1fe9cSrandyf !((wput) && ((async)->async_flags & ASYNC_DDI_SUSPENDED))
38062df1fe9cSrandyf
38072df1fe9cSrandyf /*
38082df1fe9cSrandyf * Processing for write queue put procedure.
38097c478bd9Sstevel@tonic-gate * Respond to M_STOP, M_START, M_IOCTL, and M_FLUSH messages here;
38107c478bd9Sstevel@tonic-gate * set the flow control character for M_STOPI and M_STARTI messages;
38117c478bd9Sstevel@tonic-gate * queue up M_BREAK, M_DELAY, and M_DATA messages for processing
38127c478bd9Sstevel@tonic-gate * by the start routine, and then call the start routine; discard
38137c478bd9Sstevel@tonic-gate * everything else. Note that this driver does not incorporate any
38147c478bd9Sstevel@tonic-gate * mechanism to negotiate to handle the canonicalization process.
38157c478bd9Sstevel@tonic-gate * It expects that these functions are handled in upper module(s),
38167c478bd9Sstevel@tonic-gate * as we do in ldterm.
38177c478bd9Sstevel@tonic-gate */
38187c478bd9Sstevel@tonic-gate static int
asywputdo(queue_t * q,mblk_t * mp,boolean_t wput)38192df1fe9cSrandyf asywputdo(queue_t *q, mblk_t *mp, boolean_t wput)
38207c478bd9Sstevel@tonic-gate {
38217c478bd9Sstevel@tonic-gate struct asyncline *async;
38227c478bd9Sstevel@tonic-gate struct asycom *asy;
38237c478bd9Sstevel@tonic-gate #ifdef DEBUG
38247c478bd9Sstevel@tonic-gate int instance;
38257c478bd9Sstevel@tonic-gate #endif
38267c478bd9Sstevel@tonic-gate int error;
38277c478bd9Sstevel@tonic-gate
38287c478bd9Sstevel@tonic-gate async = (struct asyncline *)q->q_ptr;
38292df1fe9cSrandyf
38307c478bd9Sstevel@tonic-gate #ifdef DEBUG
38317c478bd9Sstevel@tonic-gate instance = UNIT(async->async_dev);
38327c478bd9Sstevel@tonic-gate #endif
38337c478bd9Sstevel@tonic-gate asy = async->async_common;
38347c478bd9Sstevel@tonic-gate
38357c478bd9Sstevel@tonic-gate switch (mp->b_datap->db_type) {
38367c478bd9Sstevel@tonic-gate
38377c478bd9Sstevel@tonic-gate case M_STOP:
38387c478bd9Sstevel@tonic-gate /*
38397c478bd9Sstevel@tonic-gate * Since we don't do real DMA, we can just let the
38407c478bd9Sstevel@tonic-gate * chip coast to a stop after applying the brakes.
38417c478bd9Sstevel@tonic-gate */
38427c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
38437c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_STOPPED;
38447c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
38457c478bd9Sstevel@tonic-gate freemsg(mp);
38467c478bd9Sstevel@tonic-gate break;
38477c478bd9Sstevel@tonic-gate
38487c478bd9Sstevel@tonic-gate case M_START:
38497c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
38507c478bd9Sstevel@tonic-gate if (async->async_flags & ASYNC_STOPPED) {
38517c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_STOPPED;
38522df1fe9cSrandyf if (ASYWPUTDO_NOT_SUSP(async, wput)) {
38537c478bd9Sstevel@tonic-gate /*
38547c478bd9Sstevel@tonic-gate * If an output operation is in progress,
38557c478bd9Sstevel@tonic-gate * resume it. Otherwise, prod the start
38567c478bd9Sstevel@tonic-gate * routine.
38577c478bd9Sstevel@tonic-gate */
38587c478bd9Sstevel@tonic-gate if (async->async_ocnt > 0) {
38597c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
38607c478bd9Sstevel@tonic-gate async_resume(async);
38617c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
38627c478bd9Sstevel@tonic-gate } else {
38637c478bd9Sstevel@tonic-gate async_start(async);
38647c478bd9Sstevel@tonic-gate }
38657c478bd9Sstevel@tonic-gate }
38662df1fe9cSrandyf }
38677c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
38687c478bd9Sstevel@tonic-gate freemsg(mp);
38697c478bd9Sstevel@tonic-gate break;
38707c478bd9Sstevel@tonic-gate
38717c478bd9Sstevel@tonic-gate case M_IOCTL:
38727c478bd9Sstevel@tonic-gate switch (((struct iocblk *)mp->b_rptr)->ioc_cmd) {
38737c478bd9Sstevel@tonic-gate
38747c478bd9Sstevel@tonic-gate case TCSBRK:
38757c478bd9Sstevel@tonic-gate error = miocpullup(mp, sizeof (int));
38767c478bd9Sstevel@tonic-gate if (error != 0) {
38777c478bd9Sstevel@tonic-gate miocnak(q, mp, 0, error);
38787c478bd9Sstevel@tonic-gate return (0);
38797c478bd9Sstevel@tonic-gate }
38807c478bd9Sstevel@tonic-gate
38817c478bd9Sstevel@tonic-gate if (*(int *)mp->b_cont->b_rptr != 0) {
38827c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_OUT,
38837c478bd9Sstevel@tonic-gate "async%d_ioctl: flush request.\n",
38847c478bd9Sstevel@tonic-gate instance);
38857c478bd9Sstevel@tonic-gate (void) putq(q, mp);
38867c478bd9Sstevel@tonic-gate
38872df1fe9cSrandyf mutex_enter(&asy->asy_excl);
38882df1fe9cSrandyf if (ASYWPUTDO_NOT_SUSP(async, wput)) {
38897c478bd9Sstevel@tonic-gate /*
38907c478bd9Sstevel@tonic-gate * If an TIOCSBRK is in progress,
38917c478bd9Sstevel@tonic-gate * clean it as TIOCCBRK does,
38927c478bd9Sstevel@tonic-gate * then kick off output.
38937c478bd9Sstevel@tonic-gate * If TIOCSBRK is not in progress,
38947c478bd9Sstevel@tonic-gate * just kick off output.
38957c478bd9Sstevel@tonic-gate */
38967c478bd9Sstevel@tonic-gate async_resume_utbrk(async);
38972df1fe9cSrandyf }
38987c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
38997c478bd9Sstevel@tonic-gate break;
39007c478bd9Sstevel@tonic-gate }
39017c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/
39027c478bd9Sstevel@tonic-gate case TCSETSW:
39037c478bd9Sstevel@tonic-gate case TCSETSF:
39047c478bd9Sstevel@tonic-gate case TCSETAW:
39057c478bd9Sstevel@tonic-gate case TCSETAF:
39067c478bd9Sstevel@tonic-gate /*
39077c478bd9Sstevel@tonic-gate * The changes do not take effect until all
39087c478bd9Sstevel@tonic-gate * output queued before them is drained.
39097c478bd9Sstevel@tonic-gate * Put this message on the queue, so that
39107c478bd9Sstevel@tonic-gate * "async_start" will see it when it's done
39117c478bd9Sstevel@tonic-gate * with the output before it. Poke the
39127c478bd9Sstevel@tonic-gate * start routine, just in case.
39137c478bd9Sstevel@tonic-gate */
39147c478bd9Sstevel@tonic-gate (void) putq(q, mp);
39157c478bd9Sstevel@tonic-gate
39162df1fe9cSrandyf mutex_enter(&asy->asy_excl);
39172df1fe9cSrandyf if (ASYWPUTDO_NOT_SUSP(async, wput)) {
39187c478bd9Sstevel@tonic-gate /*
39197c478bd9Sstevel@tonic-gate * If an TIOCSBRK is in progress,
39207c478bd9Sstevel@tonic-gate * clean it as TIOCCBRK does.
39217c478bd9Sstevel@tonic-gate * then kick off output.
39227c478bd9Sstevel@tonic-gate * If TIOCSBRK is not in progress,
39237c478bd9Sstevel@tonic-gate * just kick off output.
39247c478bd9Sstevel@tonic-gate */
39257c478bd9Sstevel@tonic-gate async_resume_utbrk(async);
39262df1fe9cSrandyf }
39277c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
39287c478bd9Sstevel@tonic-gate break;
39297c478bd9Sstevel@tonic-gate
39307c478bd9Sstevel@tonic-gate default:
39317c478bd9Sstevel@tonic-gate /*
39327c478bd9Sstevel@tonic-gate * Do it now.
39337c478bd9Sstevel@tonic-gate */
39342df1fe9cSrandyf mutex_enter(&asy->asy_excl);
39352df1fe9cSrandyf if (ASYWPUTDO_NOT_SUSP(async, wput)) {
39362df1fe9cSrandyf mutex_exit(&asy->asy_excl);
39377c478bd9Sstevel@tonic-gate async_ioctl(async, q, mp);
39387c478bd9Sstevel@tonic-gate break;
39397c478bd9Sstevel@tonic-gate }
39402df1fe9cSrandyf async_put_suspq(asy, mp);
39412df1fe9cSrandyf mutex_exit(&asy->asy_excl);
39422df1fe9cSrandyf break;
39432df1fe9cSrandyf }
39447c478bd9Sstevel@tonic-gate break;
39457c478bd9Sstevel@tonic-gate
39467c478bd9Sstevel@tonic-gate case M_FLUSH:
39477c478bd9Sstevel@tonic-gate if (*mp->b_rptr & FLUSHW) {
39487c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
39497c478bd9Sstevel@tonic-gate
39507c478bd9Sstevel@tonic-gate /*
39517c478bd9Sstevel@tonic-gate * Abort any output in progress.
39527c478bd9Sstevel@tonic-gate */
39537c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
39547c478bd9Sstevel@tonic-gate if (async->async_flags & ASYNC_BUSY) {
39557c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_BUSY, "asy%dwput: "
39567c478bd9Sstevel@tonic-gate "Clearing async_ocnt, "
39577c478bd9Sstevel@tonic-gate "leaving ASYNC_BUSY set\n",
39587c478bd9Sstevel@tonic-gate instance);
39597c478bd9Sstevel@tonic-gate async->async_ocnt = 0;
39607c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_BUSY;
39617c478bd9Sstevel@tonic-gate } /* if */
39622df1fe9cSrandyf
39632df1fe9cSrandyf if (ASYWPUTDO_NOT_SUSP(async, wput)) {
39642df1fe9cSrandyf /* Flush FIFO buffers */
39652df1fe9cSrandyf if (asy->asy_use_fifo == FIFO_ON) {
39662df1fe9cSrandyf asy_reset_fifo(asy, FIFOTXFLSH);
39672df1fe9cSrandyf }
39682df1fe9cSrandyf }
39697c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
39707c478bd9Sstevel@tonic-gate
39717c478bd9Sstevel@tonic-gate /* Flush FIFO buffers */
39727c478bd9Sstevel@tonic-gate if (asy->asy_use_fifo == FIFO_ON) {
39737c478bd9Sstevel@tonic-gate asy_reset_fifo(asy, FIFOTXFLSH);
39747c478bd9Sstevel@tonic-gate }
39757c478bd9Sstevel@tonic-gate
39767c478bd9Sstevel@tonic-gate /*
39777c478bd9Sstevel@tonic-gate * Flush our write queue.
39787c478bd9Sstevel@tonic-gate */
39797c478bd9Sstevel@tonic-gate flushq(q, FLUSHDATA); /* XXX doesn't flush M_DELAY */
39807c478bd9Sstevel@tonic-gate if (async->async_xmitblk != NULL) {
39817c478bd9Sstevel@tonic-gate freeb(async->async_xmitblk);
39827c478bd9Sstevel@tonic-gate async->async_xmitblk = NULL;
39837c478bd9Sstevel@tonic-gate }
39847c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
39857c478bd9Sstevel@tonic-gate *mp->b_rptr &= ~FLUSHW; /* it has been flushed */
39867c478bd9Sstevel@tonic-gate }
39877c478bd9Sstevel@tonic-gate if (*mp->b_rptr & FLUSHR) {
39882df1fe9cSrandyf if (ASYWPUTDO_NOT_SUSP(async, wput)) {
39897c478bd9Sstevel@tonic-gate /* Flush FIFO buffers */
39907c478bd9Sstevel@tonic-gate if (asy->asy_use_fifo == FIFO_ON) {
39917c478bd9Sstevel@tonic-gate asy_reset_fifo(asy, FIFORXFLSH);
39927c478bd9Sstevel@tonic-gate }
39932df1fe9cSrandyf }
39947c478bd9Sstevel@tonic-gate flushq(RD(q), FLUSHDATA);
39957c478bd9Sstevel@tonic-gate qreply(q, mp); /* give the read queues a crack at it */
39967c478bd9Sstevel@tonic-gate } else {
39977c478bd9Sstevel@tonic-gate freemsg(mp);
39987c478bd9Sstevel@tonic-gate }
39997c478bd9Sstevel@tonic-gate
40007c478bd9Sstevel@tonic-gate /*
40017c478bd9Sstevel@tonic-gate * We must make sure we process messages that survive the
40027c478bd9Sstevel@tonic-gate * write-side flush.
40037c478bd9Sstevel@tonic-gate */
40042df1fe9cSrandyf if (ASYWPUTDO_NOT_SUSP(async, wput)) {
40057c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
40067c478bd9Sstevel@tonic-gate async_start(async);
40077c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
40082df1fe9cSrandyf }
40097c478bd9Sstevel@tonic-gate break;
40107c478bd9Sstevel@tonic-gate
40117c478bd9Sstevel@tonic-gate case M_BREAK:
40127c478bd9Sstevel@tonic-gate case M_DELAY:
40137c478bd9Sstevel@tonic-gate case M_DATA:
40147c478bd9Sstevel@tonic-gate /*
40157c478bd9Sstevel@tonic-gate * Queue the message up to be transmitted,
40167c478bd9Sstevel@tonic-gate * and poke the start routine.
40177c478bd9Sstevel@tonic-gate */
40187c478bd9Sstevel@tonic-gate (void) putq(q, mp);
40192df1fe9cSrandyf if (ASYWPUTDO_NOT_SUSP(async, wput)) {
40207c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
40217c478bd9Sstevel@tonic-gate async_start(async);
40227c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
40232df1fe9cSrandyf }
40247c478bd9Sstevel@tonic-gate break;
40257c478bd9Sstevel@tonic-gate
40267c478bd9Sstevel@tonic-gate case M_STOPI:
40277c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
40282df1fe9cSrandyf if (ASYWPUTDO_NOT_SUSP(async, wput)) {
40297c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
40307c478bd9Sstevel@tonic-gate if (!(async->async_inflow_source & IN_FLOW_USER)) {
40317c478bd9Sstevel@tonic-gate async_flowcontrol_hw_input(asy, FLOW_STOP,
40327c478bd9Sstevel@tonic-gate IN_FLOW_USER);
40332df1fe9cSrandyf (void) async_flowcontrol_sw_input(asy,
40342df1fe9cSrandyf FLOW_STOP, IN_FLOW_USER);
40357c478bd9Sstevel@tonic-gate }
40367c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
40377c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
40387c478bd9Sstevel@tonic-gate freemsg(mp);
40397c478bd9Sstevel@tonic-gate break;
40402df1fe9cSrandyf }
40412df1fe9cSrandyf async_put_suspq(asy, mp);
40422df1fe9cSrandyf mutex_exit(&asy->asy_excl);
40432df1fe9cSrandyf break;
40447c478bd9Sstevel@tonic-gate
40457c478bd9Sstevel@tonic-gate case M_STARTI:
40467c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
40472df1fe9cSrandyf if (ASYWPUTDO_NOT_SUSP(async, wput)) {
40487c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
40497c478bd9Sstevel@tonic-gate if (async->async_inflow_source & IN_FLOW_USER) {
40507c478bd9Sstevel@tonic-gate async_flowcontrol_hw_input(asy, FLOW_START,
40517c478bd9Sstevel@tonic-gate IN_FLOW_USER);
40522df1fe9cSrandyf (void) async_flowcontrol_sw_input(asy,
40532df1fe9cSrandyf FLOW_START, IN_FLOW_USER);
40547c478bd9Sstevel@tonic-gate }
40557c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
40567c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
40577c478bd9Sstevel@tonic-gate freemsg(mp);
40587c478bd9Sstevel@tonic-gate break;
40592df1fe9cSrandyf }
40602df1fe9cSrandyf async_put_suspq(asy, mp);
40612df1fe9cSrandyf mutex_exit(&asy->asy_excl);
40622df1fe9cSrandyf break;
40637c478bd9Sstevel@tonic-gate
40647c478bd9Sstevel@tonic-gate case M_CTL:
40657c478bd9Sstevel@tonic-gate if (MBLKL(mp) >= sizeof (struct iocblk) &&
40667c478bd9Sstevel@tonic-gate ((struct iocblk *)mp->b_rptr)->ioc_cmd == MC_POSIXQUERY) {
40672df1fe9cSrandyf mutex_enter(&asy->asy_excl);
40682df1fe9cSrandyf if (ASYWPUTDO_NOT_SUSP(async, wput)) {
40692df1fe9cSrandyf ((struct iocblk *)mp->b_rptr)->ioc_cmd =
40702df1fe9cSrandyf MC_HAS_POSIX;
40712df1fe9cSrandyf mutex_exit(&asy->asy_excl);
40727c478bd9Sstevel@tonic-gate qreply(q, mp);
40732df1fe9cSrandyf break;
40742df1fe9cSrandyf } else {
40752df1fe9cSrandyf async_put_suspq(asy, mp);
40762df1fe9cSrandyf }
40777c478bd9Sstevel@tonic-gate } else {
40787c478bd9Sstevel@tonic-gate /*
40797c478bd9Sstevel@tonic-gate * These MC_SERVICE type messages are used by upper
40807c478bd9Sstevel@tonic-gate * modules to tell this driver to send input up
40817c478bd9Sstevel@tonic-gate * immediately, or that it can wait for normal
40827c478bd9Sstevel@tonic-gate * processing that may or may not be done. Sun
40837c478bd9Sstevel@tonic-gate * requires these for the mouse module.
40847c478bd9Sstevel@tonic-gate * (XXX - for x86?)
40857c478bd9Sstevel@tonic-gate */
40867c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
40877c478bd9Sstevel@tonic-gate switch (*mp->b_rptr) {
40887c478bd9Sstevel@tonic-gate
40897c478bd9Sstevel@tonic-gate case MC_SERVICEIMM:
40907c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_SERVICEIMM;
40917c478bd9Sstevel@tonic-gate break;
40927c478bd9Sstevel@tonic-gate
40937c478bd9Sstevel@tonic-gate case MC_SERVICEDEF:
40947c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_SERVICEIMM;
40957c478bd9Sstevel@tonic-gate break;
40967c478bd9Sstevel@tonic-gate }
40977c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
40987c478bd9Sstevel@tonic-gate freemsg(mp);
40997c478bd9Sstevel@tonic-gate }
41007c478bd9Sstevel@tonic-gate break;
41017c478bd9Sstevel@tonic-gate
41027c478bd9Sstevel@tonic-gate case M_IOCDATA:
41032df1fe9cSrandyf mutex_enter(&asy->asy_excl);
41042df1fe9cSrandyf if (ASYWPUTDO_NOT_SUSP(async, wput)) {
41052df1fe9cSrandyf mutex_exit(&asy->asy_excl);
41067c478bd9Sstevel@tonic-gate async_iocdata(q, mp);
41077c478bd9Sstevel@tonic-gate break;
41082df1fe9cSrandyf }
41092df1fe9cSrandyf async_put_suspq(asy, mp);
41102df1fe9cSrandyf mutex_exit(&asy->asy_excl);
41112df1fe9cSrandyf break;
41127c478bd9Sstevel@tonic-gate
41137c478bd9Sstevel@tonic-gate default:
41147c478bd9Sstevel@tonic-gate freemsg(mp);
41157c478bd9Sstevel@tonic-gate break;
41167c478bd9Sstevel@tonic-gate }
41177c478bd9Sstevel@tonic-gate return (0);
41187c478bd9Sstevel@tonic-gate }
41197c478bd9Sstevel@tonic-gate
41202df1fe9cSrandyf static int
asywput(queue_t * q,mblk_t * mp)41212df1fe9cSrandyf asywput(queue_t *q, mblk_t *mp)
41222df1fe9cSrandyf {
41232df1fe9cSrandyf return (asywputdo(q, mp, B_TRUE));
41242df1fe9cSrandyf }
41252df1fe9cSrandyf
41267c478bd9Sstevel@tonic-gate /*
41277c478bd9Sstevel@tonic-gate * Retry an "ioctl", now that "bufcall" claims we may be able to allocate
41287c478bd9Sstevel@tonic-gate * the buffer we need.
41297c478bd9Sstevel@tonic-gate */
41307c478bd9Sstevel@tonic-gate static void
async_reioctl(void * unit)41317c478bd9Sstevel@tonic-gate async_reioctl(void *unit)
41327c478bd9Sstevel@tonic-gate {
41337c478bd9Sstevel@tonic-gate int instance = (uintptr_t)unit;
41347c478bd9Sstevel@tonic-gate struct asyncline *async;
41357c478bd9Sstevel@tonic-gate struct asycom *asy;
41367c478bd9Sstevel@tonic-gate queue_t *q;
41377c478bd9Sstevel@tonic-gate mblk_t *mp;
41387c478bd9Sstevel@tonic-gate
41397c478bd9Sstevel@tonic-gate asy = ddi_get_soft_state(asy_soft_state, instance);
41407c478bd9Sstevel@tonic-gate ASSERT(asy != NULL);
41417c478bd9Sstevel@tonic-gate async = asy->asy_priv;
41427c478bd9Sstevel@tonic-gate
41437c478bd9Sstevel@tonic-gate /*
41447c478bd9Sstevel@tonic-gate * The bufcall is no longer pending.
41457c478bd9Sstevel@tonic-gate */
41467c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
41477c478bd9Sstevel@tonic-gate async->async_wbufcid = 0;
41487c478bd9Sstevel@tonic-gate if ((q = async->async_ttycommon.t_writeq) == NULL) {
41497c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
41507c478bd9Sstevel@tonic-gate return;
41517c478bd9Sstevel@tonic-gate }
41527c478bd9Sstevel@tonic-gate if ((mp = async->async_ttycommon.t_iocpending) != NULL) {
41537c478bd9Sstevel@tonic-gate /* not pending any more */
41547c478bd9Sstevel@tonic-gate async->async_ttycommon.t_iocpending = NULL;
41557c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
41567c478bd9Sstevel@tonic-gate async_ioctl(async, q, mp);
41577c478bd9Sstevel@tonic-gate } else
41587c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
41597c478bd9Sstevel@tonic-gate }
41607c478bd9Sstevel@tonic-gate
41617c478bd9Sstevel@tonic-gate static void
async_iocdata(queue_t * q,mblk_t * mp)41627c478bd9Sstevel@tonic-gate async_iocdata(queue_t *q, mblk_t *mp)
41637c478bd9Sstevel@tonic-gate {
41647c478bd9Sstevel@tonic-gate struct asyncline *async = (struct asyncline *)q->q_ptr;
41657c478bd9Sstevel@tonic-gate struct asycom *asy;
41667c478bd9Sstevel@tonic-gate struct iocblk *ip;
41677c478bd9Sstevel@tonic-gate struct copyresp *csp;
41687c478bd9Sstevel@tonic-gate #ifdef DEBUG
41697c478bd9Sstevel@tonic-gate int instance = UNIT(async->async_dev);
41707c478bd9Sstevel@tonic-gate #endif
41717c478bd9Sstevel@tonic-gate
41727c478bd9Sstevel@tonic-gate asy = async->async_common;
41737c478bd9Sstevel@tonic-gate ip = (struct iocblk *)mp->b_rptr;
41747c478bd9Sstevel@tonic-gate csp = (struct copyresp *)mp->b_rptr;
41757c478bd9Sstevel@tonic-gate
41767c478bd9Sstevel@tonic-gate if (csp->cp_rval != 0) {
41777c478bd9Sstevel@tonic-gate if (csp->cp_private)
41787c478bd9Sstevel@tonic-gate freemsg(csp->cp_private);
41797c478bd9Sstevel@tonic-gate freemsg(mp);
41807c478bd9Sstevel@tonic-gate return;
41817c478bd9Sstevel@tonic-gate }
41827c478bd9Sstevel@tonic-gate
41837c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl);
41847c478bd9Sstevel@tonic-gate DEBUGCONT2(ASY_DEBUG_MODEM, "async%d_iocdata: case %s\n",
41857c478bd9Sstevel@tonic-gate instance,
41867c478bd9Sstevel@tonic-gate csp->cp_cmd == TIOCMGET ? "TIOCMGET" :
41877c478bd9Sstevel@tonic-gate csp->cp_cmd == TIOCMSET ? "TIOCMSET" :
41887c478bd9Sstevel@tonic-gate csp->cp_cmd == TIOCMBIS ? "TIOCMBIS" :
41897c478bd9Sstevel@tonic-gate "TIOCMBIC");
41907c478bd9Sstevel@tonic-gate switch (csp->cp_cmd) {
41917c478bd9Sstevel@tonic-gate
41927c478bd9Sstevel@tonic-gate case TIOCMGET:
41937c478bd9Sstevel@tonic-gate if (mp->b_cont) {
41947c478bd9Sstevel@tonic-gate freemsg(mp->b_cont);
41957c478bd9Sstevel@tonic-gate mp->b_cont = NULL;
41967c478bd9Sstevel@tonic-gate }
41977c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_IOCACK;
41987c478bd9Sstevel@tonic-gate ip->ioc_error = 0;
41997c478bd9Sstevel@tonic-gate ip->ioc_count = 0;
42007c478bd9Sstevel@tonic-gate ip->ioc_rval = 0;
42017c478bd9Sstevel@tonic-gate mp->b_wptr = mp->b_rptr + sizeof (struct iocblk);
42027c478bd9Sstevel@tonic-gate break;
42037c478bd9Sstevel@tonic-gate
42047c478bd9Sstevel@tonic-gate case TIOCMSET:
42057c478bd9Sstevel@tonic-gate case TIOCMBIS:
42067c478bd9Sstevel@tonic-gate case TIOCMBIC:
42077c478bd9Sstevel@tonic-gate mutex_enter(&asy->asy_excl_hi);
42082df1fe9cSrandyf (void) asymctl(asy, dmtoasy(*(int *)mp->b_cont->b_rptr),
42097c478bd9Sstevel@tonic-gate csp->cp_cmd);
42107c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl_hi);
42117c478bd9Sstevel@tonic-gate mioc2ack(mp, NULL, 0, 0);
42127c478bd9Sstevel@tonic-gate break;
42137c478bd9Sstevel@tonic-gate
42147c478bd9Sstevel@tonic-gate default:
42157c478bd9Sstevel@tonic-gate mp->b_datap->db_type = M_IOCNAK;
42167c478bd9Sstevel@tonic-gate ip->ioc_error = EINVAL;
42177c478bd9Sstevel@tonic-gate break;
42187c478bd9Sstevel@tonic-gate }
42197c478bd9Sstevel@tonic-gate qreply(q, mp);
42207c478bd9Sstevel@tonic-gate mutex_exit(&asy->asy_excl);
42217c478bd9Sstevel@tonic-gate }
42227c478bd9Sstevel@tonic-gate
42237c478bd9Sstevel@tonic-gate /*
42247c478bd9Sstevel@tonic-gate * debugger/console support routines.
42257c478bd9Sstevel@tonic-gate */
42267c478bd9Sstevel@tonic-gate
42277c478bd9Sstevel@tonic-gate /*
42287c478bd9Sstevel@tonic-gate * put a character out
42297c478bd9Sstevel@tonic-gate * Do not use interrupts. If char is LF, put out CR, LF.
42307c478bd9Sstevel@tonic-gate */
42317c478bd9Sstevel@tonic-gate static void
asyputchar(cons_polledio_arg_t arg,uchar_t c)4232281f0747Slt200341 asyputchar(cons_polledio_arg_t arg, uchar_t c)
42337c478bd9Sstevel@tonic-gate {
42347c478bd9Sstevel@tonic-gate struct asycom *asy = (struct asycom *)arg;
42357c478bd9Sstevel@tonic-gate
42367c478bd9Sstevel@tonic-gate if (c == '\n')
42377c478bd9Sstevel@tonic-gate asyputchar(arg, '\r');
42387c478bd9Sstevel@tonic-gate
42394ab75253Smrj while ((ddi_get8(asy->asy_iohandle,
42407c478bd9Sstevel@tonic-gate asy->asy_ioaddr + LSR) & XHRE) == 0) {
42417c478bd9Sstevel@tonic-gate /* wait for xmit to finish */
42427c478bd9Sstevel@tonic-gate drv_usecwait(10);
42437c478bd9Sstevel@tonic-gate }
42447c478bd9Sstevel@tonic-gate
42457c478bd9Sstevel@tonic-gate /* put the character out */
42464ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT, c);
42477c478bd9Sstevel@tonic-gate }
42487c478bd9Sstevel@tonic-gate
42497c478bd9Sstevel@tonic-gate /*
42507c478bd9Sstevel@tonic-gate * See if there's a character available. If no character is
42517c478bd9Sstevel@tonic-gate * available, return 0. Run in polled mode, no interrupts.
42527c478bd9Sstevel@tonic-gate */
42537c478bd9Sstevel@tonic-gate static boolean_t
asyischar(cons_polledio_arg_t arg)4254281f0747Slt200341 asyischar(cons_polledio_arg_t arg)
42557c478bd9Sstevel@tonic-gate {
42567c478bd9Sstevel@tonic-gate struct asycom *asy = (struct asycom *)arg;
42577c478bd9Sstevel@tonic-gate
42582df1fe9cSrandyf return ((ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR) & RCA)
42592df1fe9cSrandyf != 0);
42607c478bd9Sstevel@tonic-gate }
42617c478bd9Sstevel@tonic-gate
42627c478bd9Sstevel@tonic-gate /*
42637c478bd9Sstevel@tonic-gate * Get a character. Run in polled mode, no interrupts.
42647c478bd9Sstevel@tonic-gate */
42657c478bd9Sstevel@tonic-gate static int
asygetchar(cons_polledio_arg_t arg)4266281f0747Slt200341 asygetchar(cons_polledio_arg_t arg)
42677c478bd9Sstevel@tonic-gate {
42687c478bd9Sstevel@tonic-gate struct asycom *asy = (struct asycom *)arg;
42697c478bd9Sstevel@tonic-gate
42707c478bd9Sstevel@tonic-gate while (!asyischar(arg))
42717c478bd9Sstevel@tonic-gate drv_usecwait(10);
42722df1fe9cSrandyf return (ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + DAT));
42737c478bd9Sstevel@tonic-gate }
42747c478bd9Sstevel@tonic-gate
42757c478bd9Sstevel@tonic-gate /*
42767c478bd9Sstevel@tonic-gate * Set or get the modem control status.
42777c478bd9Sstevel@tonic-gate */
42787c478bd9Sstevel@tonic-gate static int
asymctl(struct asycom * asy,int bits,int how)42797c478bd9Sstevel@tonic-gate asymctl(struct asycom *asy, int bits, int how)
42807c478bd9Sstevel@tonic-gate {
42817c478bd9Sstevel@tonic-gate int mcr_r, msr_r;
42827c478bd9Sstevel@tonic-gate int instance = asy->asy_unit;
42837c478bd9Sstevel@tonic-gate
42847c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&asy->asy_excl_hi));
42857c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&asy->asy_excl));
42867c478bd9Sstevel@tonic-gate
42877c478bd9Sstevel@tonic-gate /* Read Modem Control Registers */
42884ab75253Smrj mcr_r = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MCR);
42897c478bd9Sstevel@tonic-gate
42907c478bd9Sstevel@tonic-gate switch (how) {
42917c478bd9Sstevel@tonic-gate
42927c478bd9Sstevel@tonic-gate case TIOCMSET:
42937c478bd9Sstevel@tonic-gate DEBUGCONT2(ASY_DEBUG_MODEM,
42947c478bd9Sstevel@tonic-gate "asy%dmctl: TIOCMSET, bits = %x\n", instance, bits);
42957c478bd9Sstevel@tonic-gate mcr_r = bits; /* Set bits */
42967c478bd9Sstevel@tonic-gate break;
42977c478bd9Sstevel@tonic-gate
42987c478bd9Sstevel@tonic-gate case TIOCMBIS:
42997c478bd9Sstevel@tonic-gate DEBUGCONT2(ASY_DEBUG_MODEM, "asy%dmctl: TIOCMBIS, bits = %x\n",
43007c478bd9Sstevel@tonic-gate instance, bits);
43017c478bd9Sstevel@tonic-gate mcr_r |= bits; /* Mask in bits */
43027c478bd9Sstevel@tonic-gate break;
43037c478bd9Sstevel@tonic-gate
43047c478bd9Sstevel@tonic-gate case TIOCMBIC:
43057c478bd9Sstevel@tonic-gate DEBUGCONT2(ASY_DEBUG_MODEM, "asy%dmctl: TIOCMBIC, bits = %x\n",
43067c478bd9Sstevel@tonic-gate instance, bits);
43077c478bd9Sstevel@tonic-gate mcr_r &= ~bits; /* Mask out bits */
43087c478bd9Sstevel@tonic-gate break;
43097c478bd9Sstevel@tonic-gate
43107c478bd9Sstevel@tonic-gate case TIOCMGET:
43117c478bd9Sstevel@tonic-gate /* Read Modem Status Registers */
43127c478bd9Sstevel@tonic-gate /*
43137c478bd9Sstevel@tonic-gate * If modem interrupts are enabled, we return the
43147c478bd9Sstevel@tonic-gate * saved value of msr. We read MSR only in async_msint()
43157c478bd9Sstevel@tonic-gate */
43164ab75253Smrj if (ddi_get8(asy->asy_iohandle,
43177c478bd9Sstevel@tonic-gate asy->asy_ioaddr + ICR) & MIEN) {
43187c478bd9Sstevel@tonic-gate msr_r = asy->asy_msr;
43197c478bd9Sstevel@tonic-gate DEBUGCONT2(ASY_DEBUG_MODEM,
43207c478bd9Sstevel@tonic-gate "asy%dmctl: TIOCMGET, read msr_r = %x\n",
43217c478bd9Sstevel@tonic-gate instance, msr_r);
43227c478bd9Sstevel@tonic-gate } else {
43234ab75253Smrj msr_r = ddi_get8(asy->asy_iohandle,
43247c478bd9Sstevel@tonic-gate asy->asy_ioaddr + MSR);
43257c478bd9Sstevel@tonic-gate DEBUGCONT2(ASY_DEBUG_MODEM,
43267c478bd9Sstevel@tonic-gate "asy%dmctl: TIOCMGET, read MSR = %x\n",
43277c478bd9Sstevel@tonic-gate instance, msr_r);
43287c478bd9Sstevel@tonic-gate }
43297c478bd9Sstevel@tonic-gate DEBUGCONT2(ASY_DEBUG_MODEM, "asy%dtodm: modem_lines = %x\n",
43307c478bd9Sstevel@tonic-gate instance, asytodm(mcr_r, msr_r));
43317c478bd9Sstevel@tonic-gate return (asytodm(mcr_r, msr_r));
43327c478bd9Sstevel@tonic-gate }
43337c478bd9Sstevel@tonic-gate
43344ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR, mcr_r);
43357c478bd9Sstevel@tonic-gate
43367c478bd9Sstevel@tonic-gate return (mcr_r);
43377c478bd9Sstevel@tonic-gate }
43387c478bd9Sstevel@tonic-gate
43397c478bd9Sstevel@tonic-gate static int
asytodm(int mcr_r,int msr_r)43407c478bd9Sstevel@tonic-gate asytodm(int mcr_r, int msr_r)
43417c478bd9Sstevel@tonic-gate {
43427c478bd9Sstevel@tonic-gate int b = 0;
43437c478bd9Sstevel@tonic-gate
43447c478bd9Sstevel@tonic-gate /* MCR registers */
43457c478bd9Sstevel@tonic-gate if (mcr_r & RTS)
43467c478bd9Sstevel@tonic-gate b |= TIOCM_RTS;
43477c478bd9Sstevel@tonic-gate
43487c478bd9Sstevel@tonic-gate if (mcr_r & DTR)
43497c478bd9Sstevel@tonic-gate b |= TIOCM_DTR;
43507c478bd9Sstevel@tonic-gate
43517c478bd9Sstevel@tonic-gate /* MSR registers */
43527c478bd9Sstevel@tonic-gate if (msr_r & DCD)
43537c478bd9Sstevel@tonic-gate b |= TIOCM_CAR;
43547c478bd9Sstevel@tonic-gate
43557c478bd9Sstevel@tonic-gate if (msr_r & CTS)
43567c478bd9Sstevel@tonic-gate b |= TIOCM_CTS;
43577c478bd9Sstevel@tonic-gate
43587c478bd9Sstevel@tonic-gate if (msr_r & DSR)
43597c478bd9Sstevel@tonic-gate b |= TIOCM_DSR;
43607c478bd9Sstevel@tonic-gate
43617c478bd9Sstevel@tonic-gate if (msr_r & RI)
43627c478bd9Sstevel@tonic-gate b |= TIOCM_RNG;
43637c478bd9Sstevel@tonic-gate return (b);
43647c478bd9Sstevel@tonic-gate }
43657c478bd9Sstevel@tonic-gate
43667c478bd9Sstevel@tonic-gate static int
dmtoasy(int bits)43677c478bd9Sstevel@tonic-gate dmtoasy(int bits)
43687c478bd9Sstevel@tonic-gate {
43697c478bd9Sstevel@tonic-gate int b = 0;
43707c478bd9Sstevel@tonic-gate
43717c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_MODEM, "dmtoasy: bits = %x\n", bits);
43727c478bd9Sstevel@tonic-gate #ifdef CAN_NOT_SET /* only DTR and RTS can be set */
43737c478bd9Sstevel@tonic-gate if (bits & TIOCM_CAR)
43747c478bd9Sstevel@tonic-gate b |= DCD;
43757c478bd9Sstevel@tonic-gate if (bits & TIOCM_CTS)
43767c478bd9Sstevel@tonic-gate b |= CTS;
43777c478bd9Sstevel@tonic-gate if (bits & TIOCM_DSR)
43787c478bd9Sstevel@tonic-gate b |= DSR;
43797c478bd9Sstevel@tonic-gate if (bits & TIOCM_RNG)
43807c478bd9Sstevel@tonic-gate b |= RI;
43817c478bd9Sstevel@tonic-gate #endif
43827c478bd9Sstevel@tonic-gate
43837c478bd9Sstevel@tonic-gate if (bits & TIOCM_RTS) {
43847c478bd9Sstevel@tonic-gate DEBUGCONT0(ASY_DEBUG_MODEM, "dmtoasy: set b & RTS\n");
43857c478bd9Sstevel@tonic-gate b |= RTS;
43867c478bd9Sstevel@tonic-gate }
43877c478bd9Sstevel@tonic-gate if (bits & TIOCM_DTR) {
43887c478bd9Sstevel@tonic-gate DEBUGCONT0(ASY_DEBUG_MODEM, "dmtoasy: set b & DTR\n");
43897c478bd9Sstevel@tonic-gate b |= DTR;
43907c478bd9Sstevel@tonic-gate }
43917c478bd9Sstevel@tonic-gate
43927c478bd9Sstevel@tonic-gate return (b);
43937c478bd9Sstevel@tonic-gate }
43947c478bd9Sstevel@tonic-gate
43957c478bd9Sstevel@tonic-gate static void
asyerror(int level,const char * fmt,...)43967c478bd9Sstevel@tonic-gate asyerror(int level, const char *fmt, ...)
43977c478bd9Sstevel@tonic-gate {
43987c478bd9Sstevel@tonic-gate va_list adx;
43997c478bd9Sstevel@tonic-gate static time_t last;
44007c478bd9Sstevel@tonic-gate static const char *lastfmt;
44017c478bd9Sstevel@tonic-gate time_t now;
44027c478bd9Sstevel@tonic-gate
44037c478bd9Sstevel@tonic-gate /*
44047c478bd9Sstevel@tonic-gate * Don't print the same error message too often.
44057c478bd9Sstevel@tonic-gate * Print the message only if we have not printed the
44067c478bd9Sstevel@tonic-gate * message within the last second.
44077c478bd9Sstevel@tonic-gate * Note: that fmt cannot be a pointer to a string
44087c478bd9Sstevel@tonic-gate * stored on the stack. The fmt pointer
44097c478bd9Sstevel@tonic-gate * must be in the data segment otherwise lastfmt would point
44107c478bd9Sstevel@tonic-gate * to non-sense.
44117c478bd9Sstevel@tonic-gate */
44127c478bd9Sstevel@tonic-gate now = gethrestime_sec();
44137c478bd9Sstevel@tonic-gate if (last == now && lastfmt == fmt)
44147c478bd9Sstevel@tonic-gate return;
44157c478bd9Sstevel@tonic-gate
44167c478bd9Sstevel@tonic-gate last = now;
44177c478bd9Sstevel@tonic-gate lastfmt = fmt;
44187c478bd9Sstevel@tonic-gate
44197c478bd9Sstevel@tonic-gate va_start(adx, fmt);
44207c478bd9Sstevel@tonic-gate vcmn_err(level, fmt, adx);
44217c478bd9Sstevel@tonic-gate va_end(adx);
44227c478bd9Sstevel@tonic-gate }
44237c478bd9Sstevel@tonic-gate
44247c478bd9Sstevel@tonic-gate /*
44257c478bd9Sstevel@tonic-gate * asy_parse_mode(dev_info_t *devi, struct asycom *asy)
44267c478bd9Sstevel@tonic-gate * The value of this property is in the form of "9600,8,n,1,-"
44277c478bd9Sstevel@tonic-gate * 1) speed: 9600, 4800, ...
44287c478bd9Sstevel@tonic-gate * 2) data bits
44297c478bd9Sstevel@tonic-gate * 3) parity: n(none), e(even), o(odd)
44307c478bd9Sstevel@tonic-gate * 4) stop bits
44317c478bd9Sstevel@tonic-gate * 5) handshake: -(none), h(hardware: rts/cts), s(software: xon/off)
44327c478bd9Sstevel@tonic-gate *
44337c478bd9Sstevel@tonic-gate * This parsing came from a SPARCstation eeprom.
44347c478bd9Sstevel@tonic-gate */
44357c478bd9Sstevel@tonic-gate static void
asy_parse_mode(dev_info_t * devi,struct asycom * asy)44367c478bd9Sstevel@tonic-gate asy_parse_mode(dev_info_t *devi, struct asycom *asy)
44377c478bd9Sstevel@tonic-gate {
44387c478bd9Sstevel@tonic-gate char name[40];
44397c478bd9Sstevel@tonic-gate char val[40];
44407c478bd9Sstevel@tonic-gate int len;
44417c478bd9Sstevel@tonic-gate int ret;
44427c478bd9Sstevel@tonic-gate char *p;
44437c478bd9Sstevel@tonic-gate char *p1;
44447c478bd9Sstevel@tonic-gate
44457c478bd9Sstevel@tonic-gate ASSERT(asy->asy_com_port != 0);
44467c478bd9Sstevel@tonic-gate
44477c478bd9Sstevel@tonic-gate /*
44487c478bd9Sstevel@tonic-gate * Parse the ttyx-mode property
44497c478bd9Sstevel@tonic-gate */
44507c478bd9Sstevel@tonic-gate (void) sprintf(name, "tty%c-mode", asy->asy_com_port + 'a' - 1);
44517c478bd9Sstevel@tonic-gate len = sizeof (val);
44527c478bd9Sstevel@tonic-gate ret = GET_PROP(devi, name, DDI_PROP_CANSLEEP, val, &len);
44537c478bd9Sstevel@tonic-gate if (ret != DDI_PROP_SUCCESS) {
44547c478bd9Sstevel@tonic-gate (void) sprintf(name, "com%c-mode", asy->asy_com_port + '0');
44557c478bd9Sstevel@tonic-gate len = sizeof (val);
44567c478bd9Sstevel@tonic-gate ret = GET_PROP(devi, name, DDI_PROP_CANSLEEP, val, &len);
44577c478bd9Sstevel@tonic-gate }
44587c478bd9Sstevel@tonic-gate
44597c478bd9Sstevel@tonic-gate /* no property to parse */
44607c478bd9Sstevel@tonic-gate asy->asy_cflag = 0;
44617c478bd9Sstevel@tonic-gate if (ret != DDI_PROP_SUCCESS)
44627c478bd9Sstevel@tonic-gate return;
44637c478bd9Sstevel@tonic-gate
44647c478bd9Sstevel@tonic-gate p = val;
44657c478bd9Sstevel@tonic-gate /* ---- baud rate ---- */
44667c478bd9Sstevel@tonic-gate asy->asy_cflag = CREAD|B9600; /* initial default */
44677c478bd9Sstevel@tonic-gate if (p && (p1 = strchr(p, ',')) != 0) {
44687c478bd9Sstevel@tonic-gate *p1++ = '\0';
44697c478bd9Sstevel@tonic-gate } else {
44707c478bd9Sstevel@tonic-gate asy->asy_cflag |= BITS8; /* add default bits */
44717c478bd9Sstevel@tonic-gate return;
44727c478bd9Sstevel@tonic-gate }
44737c478bd9Sstevel@tonic-gate
44747c478bd9Sstevel@tonic-gate if (strcmp(p, "110") == 0)
44757c478bd9Sstevel@tonic-gate asy->asy_bidx = B110;
44767c478bd9Sstevel@tonic-gate else if (strcmp(p, "150") == 0)
44777c478bd9Sstevel@tonic-gate asy->asy_bidx = B150;
44787c478bd9Sstevel@tonic-gate else if (strcmp(p, "300") == 0)
44797c478bd9Sstevel@tonic-gate asy->asy_bidx = B300;
44807c478bd9Sstevel@tonic-gate else if (strcmp(p, "600") == 0)
44817c478bd9Sstevel@tonic-gate asy->asy_bidx = B600;
44827c478bd9Sstevel@tonic-gate else if (strcmp(p, "1200") == 0)
44837c478bd9Sstevel@tonic-gate asy->asy_bidx = B1200;
44847c478bd9Sstevel@tonic-gate else if (strcmp(p, "2400") == 0)
44857c478bd9Sstevel@tonic-gate asy->asy_bidx = B2400;
44867c478bd9Sstevel@tonic-gate else if (strcmp(p, "4800") == 0)
44877c478bd9Sstevel@tonic-gate asy->asy_bidx = B4800;
44887c478bd9Sstevel@tonic-gate else if (strcmp(p, "9600") == 0)
44897c478bd9Sstevel@tonic-gate asy->asy_bidx = B9600;
44907c478bd9Sstevel@tonic-gate else if (strcmp(p, "19200") == 0)
44917c478bd9Sstevel@tonic-gate asy->asy_bidx = B19200;
44927c478bd9Sstevel@tonic-gate else if (strcmp(p, "38400") == 0)
44937c478bd9Sstevel@tonic-gate asy->asy_bidx = B38400;
44947c478bd9Sstevel@tonic-gate else if (strcmp(p, "57600") == 0)
44957c478bd9Sstevel@tonic-gate asy->asy_bidx = B57600;
44967c478bd9Sstevel@tonic-gate else if (strcmp(p, "115200") == 0)
44977c478bd9Sstevel@tonic-gate asy->asy_bidx = B115200;
44987c478bd9Sstevel@tonic-gate else
44997c478bd9Sstevel@tonic-gate asy->asy_bidx = B9600;
45007c478bd9Sstevel@tonic-gate
45017c478bd9Sstevel@tonic-gate asy->asy_cflag &= ~CBAUD;
45027c478bd9Sstevel@tonic-gate if (asy->asy_bidx > CBAUD) { /* > 38400 uses the CBAUDEXT bit */
45037c478bd9Sstevel@tonic-gate asy->asy_cflag |= CBAUDEXT;
45047c478bd9Sstevel@tonic-gate asy->asy_cflag |= asy->asy_bidx - CBAUD - 1;
45057c478bd9Sstevel@tonic-gate } else {
45067c478bd9Sstevel@tonic-gate asy->asy_cflag |= asy->asy_bidx;
45077c478bd9Sstevel@tonic-gate }
45087c478bd9Sstevel@tonic-gate
45097c478bd9Sstevel@tonic-gate ASSERT(asy->asy_bidx == BAUDINDEX(asy->asy_cflag));
45107c478bd9Sstevel@tonic-gate
45117c478bd9Sstevel@tonic-gate /* ---- Next item is data bits ---- */
45127c478bd9Sstevel@tonic-gate p = p1;
45137c478bd9Sstevel@tonic-gate if (p && (p1 = strchr(p, ',')) != 0) {
45147c478bd9Sstevel@tonic-gate *p1++ = '\0';
45157c478bd9Sstevel@tonic-gate } else {
45167c478bd9Sstevel@tonic-gate asy->asy_cflag |= BITS8; /* add default bits */
45177c478bd9Sstevel@tonic-gate return;
45187c478bd9Sstevel@tonic-gate }
45197c478bd9Sstevel@tonic-gate switch (*p) {
45207c478bd9Sstevel@tonic-gate default:
45217c478bd9Sstevel@tonic-gate case '8':
45227c478bd9Sstevel@tonic-gate asy->asy_cflag |= CS8;
45237c478bd9Sstevel@tonic-gate asy->asy_lcr = BITS8;
45247c478bd9Sstevel@tonic-gate break;
45257c478bd9Sstevel@tonic-gate case '7':
45267c478bd9Sstevel@tonic-gate asy->asy_cflag |= CS7;
45277c478bd9Sstevel@tonic-gate asy->asy_lcr = BITS7;
45287c478bd9Sstevel@tonic-gate break;
45297c478bd9Sstevel@tonic-gate case '6':
45307c478bd9Sstevel@tonic-gate asy->asy_cflag |= CS6;
45317c478bd9Sstevel@tonic-gate asy->asy_lcr = BITS6;
45327c478bd9Sstevel@tonic-gate break;
45337c478bd9Sstevel@tonic-gate case '5':
45347c478bd9Sstevel@tonic-gate /* LINTED: CS5 is currently zero (but might change) */
45357c478bd9Sstevel@tonic-gate asy->asy_cflag |= CS5;
45367c478bd9Sstevel@tonic-gate asy->asy_lcr = BITS5;
45377c478bd9Sstevel@tonic-gate break;
45387c478bd9Sstevel@tonic-gate }
45397c478bd9Sstevel@tonic-gate
45407c478bd9Sstevel@tonic-gate /* ---- Parity info ---- */
45417c478bd9Sstevel@tonic-gate p = p1;
45427c478bd9Sstevel@tonic-gate if (p && (p1 = strchr(p, ',')) != 0) {
45437c478bd9Sstevel@tonic-gate *p1++ = '\0';
45447c478bd9Sstevel@tonic-gate } else {
45457c478bd9Sstevel@tonic-gate return;
45467c478bd9Sstevel@tonic-gate }
45477c478bd9Sstevel@tonic-gate switch (*p) {
45487c478bd9Sstevel@tonic-gate default:
45497c478bd9Sstevel@tonic-gate case 'n':
45507c478bd9Sstevel@tonic-gate break;
45517c478bd9Sstevel@tonic-gate case 'e':
45527c478bd9Sstevel@tonic-gate asy->asy_cflag |= PARENB;
45537c478bd9Sstevel@tonic-gate asy->asy_lcr |= PEN; break;
45547c478bd9Sstevel@tonic-gate case 'o':
45557c478bd9Sstevel@tonic-gate asy->asy_cflag |= PARENB|PARODD;
45567c478bd9Sstevel@tonic-gate asy->asy_lcr |= PEN|EPS;
45577c478bd9Sstevel@tonic-gate break;
45587c478bd9Sstevel@tonic-gate }
45597c478bd9Sstevel@tonic-gate
45607c478bd9Sstevel@tonic-gate /* ---- Find stop bits ---- */
45617c478bd9Sstevel@tonic-gate p = p1;
45627c478bd9Sstevel@tonic-gate if (p && (p1 = strchr(p, ',')) != 0) {
45637c478bd9Sstevel@tonic-gate *p1++ = '\0';
45647c478bd9Sstevel@tonic-gate } else {
45657c478bd9Sstevel@tonic-gate return;
45667c478bd9Sstevel@tonic-gate }
45677c478bd9Sstevel@tonic-gate if (*p == '2') {
45687c478bd9Sstevel@tonic-gate asy->asy_cflag |= CSTOPB;
45697c478bd9Sstevel@tonic-gate asy->asy_lcr |= STB;
45707c478bd9Sstevel@tonic-gate }
45717c478bd9Sstevel@tonic-gate
45727c478bd9Sstevel@tonic-gate /* ---- handshake is next ---- */
45737c478bd9Sstevel@tonic-gate p = p1;
45747c478bd9Sstevel@tonic-gate if (p) {
45757c478bd9Sstevel@tonic-gate if ((p1 = strchr(p, ',')) != 0)
45767c478bd9Sstevel@tonic-gate *p1++ = '\0';
45777c478bd9Sstevel@tonic-gate
45787c478bd9Sstevel@tonic-gate if (*p == 'h')
45797c478bd9Sstevel@tonic-gate asy->asy_cflag |= CRTSCTS;
45807c478bd9Sstevel@tonic-gate else if (*p == 's')
45817c478bd9Sstevel@tonic-gate asy->asy_cflag |= CRTSXOFF;
45827c478bd9Sstevel@tonic-gate }
45837c478bd9Sstevel@tonic-gate }
45847c478bd9Sstevel@tonic-gate
45857c478bd9Sstevel@tonic-gate /*
45867c478bd9Sstevel@tonic-gate * Check for abort character sequence
45877c478bd9Sstevel@tonic-gate */
45887c478bd9Sstevel@tonic-gate static boolean_t
abort_charseq_recognize(uchar_t ch)45897c478bd9Sstevel@tonic-gate abort_charseq_recognize(uchar_t ch)
45907c478bd9Sstevel@tonic-gate {
45917c478bd9Sstevel@tonic-gate static int state = 0;
45927c478bd9Sstevel@tonic-gate #define CNTRL(c) ((c)&037)
45937c478bd9Sstevel@tonic-gate static char sequence[] = { '\r', '~', CNTRL('b') };
45947c478bd9Sstevel@tonic-gate
45957c478bd9Sstevel@tonic-gate if (ch == sequence[state]) {
45967c478bd9Sstevel@tonic-gate if (++state >= sizeof (sequence)) {
45977c478bd9Sstevel@tonic-gate state = 0;
45987c478bd9Sstevel@tonic-gate return (B_TRUE);
45997c478bd9Sstevel@tonic-gate }
46007c478bd9Sstevel@tonic-gate } else {
46017c478bd9Sstevel@tonic-gate state = (ch == sequence[0]) ? 1 : 0;
46027c478bd9Sstevel@tonic-gate }
46037c478bd9Sstevel@tonic-gate return (B_FALSE);
46047c478bd9Sstevel@tonic-gate }
46057c478bd9Sstevel@tonic-gate
46067c478bd9Sstevel@tonic-gate /*
46077c478bd9Sstevel@tonic-gate * Flow control functions
46087c478bd9Sstevel@tonic-gate */
46097c478bd9Sstevel@tonic-gate /*
46107c478bd9Sstevel@tonic-gate * Software input flow control
46117c478bd9Sstevel@tonic-gate * This function can execute software input flow control sucessfully
46127c478bd9Sstevel@tonic-gate * at most of situations except that the line is in BREAK status
46137c478bd9Sstevel@tonic-gate * (timed and untimed break).
46147c478bd9Sstevel@tonic-gate * INPUT VALUE of onoff:
46157c478bd9Sstevel@tonic-gate * FLOW_START means to send out a XON char
46167c478bd9Sstevel@tonic-gate * and clear SW input flow control flag.
46177c478bd9Sstevel@tonic-gate * FLOW_STOP means to send out a XOFF char
46187c478bd9Sstevel@tonic-gate * and set SW input flow control flag.
46197c478bd9Sstevel@tonic-gate * FLOW_CHECK means to check whether there is pending XON/XOFF
46207c478bd9Sstevel@tonic-gate * if it is true, send it out.
46217c478bd9Sstevel@tonic-gate * INPUT VALUE of type:
46227c478bd9Sstevel@tonic-gate * IN_FLOW_RINGBUFF means flow control is due to RING BUFFER
46237c478bd9Sstevel@tonic-gate * IN_FLOW_STREAMS means flow control is due to STREAMS
46247c478bd9Sstevel@tonic-gate * IN_FLOW_USER means flow control is due to user's commands
46257c478bd9Sstevel@tonic-gate * RETURN VALUE: B_FALSE means no flow control char is sent
46267c478bd9Sstevel@tonic-gate * B_TRUE means one flow control char is sent
46277c478bd9Sstevel@tonic-gate */
46287c478bd9Sstevel@tonic-gate static boolean_t
async_flowcontrol_sw_input(struct asycom * asy,async_flowc_action onoff,int type)46297c478bd9Sstevel@tonic-gate async_flowcontrol_sw_input(struct asycom *asy, async_flowc_action onoff,
46307c478bd9Sstevel@tonic-gate int type)
46317c478bd9Sstevel@tonic-gate {
46327c478bd9Sstevel@tonic-gate struct asyncline *async = asy->asy_priv;
46337c478bd9Sstevel@tonic-gate int instance = UNIT(async->async_dev);
46347c478bd9Sstevel@tonic-gate int rval = B_FALSE;
46357c478bd9Sstevel@tonic-gate
46367c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&asy->asy_excl_hi));
46377c478bd9Sstevel@tonic-gate
46387c478bd9Sstevel@tonic-gate if (!(async->async_ttycommon.t_iflag & IXOFF))
46397c478bd9Sstevel@tonic-gate return (rval);
46407c478bd9Sstevel@tonic-gate
46417c478bd9Sstevel@tonic-gate /*
46427c478bd9Sstevel@tonic-gate * If we get this far, then we know IXOFF is set.
46437c478bd9Sstevel@tonic-gate */
46447c478bd9Sstevel@tonic-gate switch (onoff) {
46457c478bd9Sstevel@tonic-gate case FLOW_STOP:
46467c478bd9Sstevel@tonic-gate async->async_inflow_source |= type;
46477c478bd9Sstevel@tonic-gate
46487c478bd9Sstevel@tonic-gate /*
46497c478bd9Sstevel@tonic-gate * We'll send an XOFF character for each of up to
46507c478bd9Sstevel@tonic-gate * three different input flow control attempts to stop input.
46517c478bd9Sstevel@tonic-gate * If we already send out one XOFF, but FLOW_STOP comes again,
46527c478bd9Sstevel@tonic-gate * it seems that input flow control becomes more serious,
46537c478bd9Sstevel@tonic-gate * then send XOFF again.
46547c478bd9Sstevel@tonic-gate */
46557c478bd9Sstevel@tonic-gate if (async->async_inflow_source & (IN_FLOW_RINGBUFF |
46567c478bd9Sstevel@tonic-gate IN_FLOW_STREAMS | IN_FLOW_USER))
46577c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_SW_IN_FLOW |
46587c478bd9Sstevel@tonic-gate ASYNC_SW_IN_NEEDED;
46597c478bd9Sstevel@tonic-gate DEBUGCONT2(ASY_DEBUG_SFLOW, "async%d: input sflow stop, "
46607c478bd9Sstevel@tonic-gate "type = %x\n", instance, async->async_inflow_source);
46617c478bd9Sstevel@tonic-gate break;
46627c478bd9Sstevel@tonic-gate case FLOW_START:
46637c478bd9Sstevel@tonic-gate async->async_inflow_source &= ~type;
46647c478bd9Sstevel@tonic-gate if (async->async_inflow_source == 0) {
46657c478bd9Sstevel@tonic-gate async->async_flags = (async->async_flags &
46667c478bd9Sstevel@tonic-gate ~ASYNC_SW_IN_FLOW) | ASYNC_SW_IN_NEEDED;
46677c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_SFLOW, "async%d: "
46687c478bd9Sstevel@tonic-gate "input sflow start\n", instance);
46697c478bd9Sstevel@tonic-gate }
46707c478bd9Sstevel@tonic-gate break;
46717c478bd9Sstevel@tonic-gate default:
46727c478bd9Sstevel@tonic-gate break;
46737c478bd9Sstevel@tonic-gate }
46747c478bd9Sstevel@tonic-gate
46757c478bd9Sstevel@tonic-gate if (((async->async_flags & (ASYNC_SW_IN_NEEDED | ASYNC_BREAK |
46767c478bd9Sstevel@tonic-gate ASYNC_OUT_SUSPEND)) == ASYNC_SW_IN_NEEDED) &&
46774ab75253Smrj (ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR) & XHRE)) {
46787c478bd9Sstevel@tonic-gate /*
46797c478bd9Sstevel@tonic-gate * If we get this far, then we know we need to send out
46807c478bd9Sstevel@tonic-gate * XON or XOFF char.
46817c478bd9Sstevel@tonic-gate */
46827c478bd9Sstevel@tonic-gate async->async_flags = (async->async_flags &
46837c478bd9Sstevel@tonic-gate ~ASYNC_SW_IN_NEEDED) | ASYNC_BUSY;
46844ab75253Smrj ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT,
46857c478bd9Sstevel@tonic-gate async->async_flags & ASYNC_SW_IN_FLOW ?
46867c478bd9Sstevel@tonic-gate async->async_stopc : async->async_startc);
46877c478bd9Sstevel@tonic-gate rval = B_TRUE;
46887c478bd9Sstevel@tonic-gate }
46897c478bd9Sstevel@tonic-gate return (rval);
46907c478bd9Sstevel@tonic-gate }
46917c478bd9Sstevel@tonic-gate
46927c478bd9Sstevel@tonic-gate /*
46937c478bd9Sstevel@tonic-gate * Software output flow control
46947c478bd9Sstevel@tonic-gate * This function can be executed sucessfully at any situation.
46957c478bd9Sstevel@tonic-gate * It does not handle HW, and just change the SW output flow control flag.
46967c478bd9Sstevel@tonic-gate * INPUT VALUE of onoff:
46977c478bd9Sstevel@tonic-gate * FLOW_START means to clear SW output flow control flag,
46987c478bd9Sstevel@tonic-gate * also combine with HW output flow control status to
46997c478bd9Sstevel@tonic-gate * determine if we need to set ASYNC_OUT_FLW_RESUME.
47007c478bd9Sstevel@tonic-gate * FLOW_STOP means to set SW output flow control flag,
47017c478bd9Sstevel@tonic-gate * also clear ASYNC_OUT_FLW_RESUME.
47027c478bd9Sstevel@tonic-gate */
47037c478bd9Sstevel@tonic-gate static void
async_flowcontrol_sw_output(struct asycom * asy,async_flowc_action onoff)47047c478bd9Sstevel@tonic-gate async_flowcontrol_sw_output(struct asycom *asy, async_flowc_action onoff)
47057c478bd9Sstevel@tonic-gate {
47067c478bd9Sstevel@tonic-gate struct asyncline *async = asy->asy_priv;
47077c478bd9Sstevel@tonic-gate int instance = UNIT(async->async_dev);
47087c478bd9Sstevel@tonic-gate
47097c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&asy->asy_excl_hi));
47107c478bd9Sstevel@tonic-gate
47117c478bd9Sstevel@tonic-gate if (!(async->async_ttycommon.t_iflag & IXON))
47127c478bd9Sstevel@tonic-gate return;
47137c478bd9Sstevel@tonic-gate
47147c478bd9Sstevel@tonic-gate switch (onoff) {
47157c478bd9Sstevel@tonic-gate case FLOW_STOP:
47167c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_SW_OUT_FLW;
47177c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_OUT_FLW_RESUME;
47187c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_SFLOW, "async%d: output sflow stop\n",
47197c478bd9Sstevel@tonic-gate instance);
47207c478bd9Sstevel@tonic-gate break;
47217c478bd9Sstevel@tonic-gate case FLOW_START:
47227c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_SW_OUT_FLW;
47237c478bd9Sstevel@tonic-gate if (!(async->async_flags & ASYNC_HW_OUT_FLW))
47247c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_OUT_FLW_RESUME;
47257c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_SFLOW, "async%d: output sflow start\n",
47267c478bd9Sstevel@tonic-gate instance);
47277c478bd9Sstevel@tonic-gate break;
47287c478bd9Sstevel@tonic-gate default:
47297c478bd9Sstevel@tonic-gate break;
47307c478bd9Sstevel@tonic-gate }
47317c478bd9Sstevel@tonic-gate }
47327c478bd9Sstevel@tonic-gate
47337c478bd9Sstevel@tonic-gate /*
47347c478bd9Sstevel@tonic-gate * Hardware input flow control
47357c478bd9Sstevel@tonic-gate * This function can be executed sucessfully at any situation.
47367c478bd9Sstevel@tonic-gate * It directly changes RTS depending on input parameter onoff.
47377c478bd9Sstevel@tonic-gate * INPUT VALUE of onoff:
47387c478bd9Sstevel@tonic-gate * FLOW_START means to clear HW input flow control flag,
47397c478bd9Sstevel@tonic-gate * and pull up RTS if it is low.
47407c478bd9Sstevel@tonic-gate * FLOW_STOP means to set HW input flow control flag,
47417c478bd9Sstevel@tonic-gate * and low RTS if it is high.
47427c478bd9Sstevel@tonic-gate * INPUT VALUE of type:
47437c478bd9Sstevel@tonic-gate * IN_FLOW_RINGBUFF means flow control is due to RING BUFFER
47447c478bd9Sstevel@tonic-gate * IN_FLOW_STREAMS means flow control is due to STREAMS
47457c478bd9Sstevel@tonic-gate * IN_FLOW_USER means flow control is due to user's commands
47467c478bd9Sstevel@tonic-gate */
47477c478bd9Sstevel@tonic-gate static void
async_flowcontrol_hw_input(struct asycom * asy,async_flowc_action onoff,int type)47487c478bd9Sstevel@tonic-gate async_flowcontrol_hw_input(struct asycom *asy, async_flowc_action onoff,
47497c478bd9Sstevel@tonic-gate int type)
47507c478bd9Sstevel@tonic-gate {
47517c478bd9Sstevel@tonic-gate uchar_t mcr;
47527c478bd9Sstevel@tonic-gate uchar_t flag;
47537c478bd9Sstevel@tonic-gate struct asyncline *async = asy->asy_priv;
47547c478bd9Sstevel@tonic-gate int instance = UNIT(async->async_dev);
47557c478bd9Sstevel@tonic-gate
47567c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&asy->asy_excl_hi));
47577c478bd9Sstevel@tonic-gate
47587c478bd9Sstevel@tonic-gate if (!(async->async_ttycommon.t_cflag & CRTSXOFF))
47597c478bd9Sstevel@tonic-gate return;
47607c478bd9Sstevel@tonic-gate
47617c478bd9Sstevel@tonic-gate switch (onoff) {
47627c478bd9Sstevel@tonic-gate case FLOW_STOP:
47637c478bd9Sstevel@tonic-gate async->async_inflow_source |= type;
47647c478bd9Sstevel@tonic-gate if (async->async_inflow_source & (IN_FLOW_RINGBUFF |
47657c478bd9Sstevel@tonic-gate IN_FLOW_STREAMS | IN_FLOW_USER))
47667c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_HW_IN_FLOW;
47677c478bd9Sstevel@tonic-gate DEBUGCONT2(ASY_DEBUG_HFLOW, "async%d: input hflow stop, "
47687c478bd9Sstevel@tonic-gate "type = %x\n", instance, async->async_inflow_source);
47697c478bd9Sstevel@tonic-gate break;
47707c478bd9Sstevel@tonic-gate case FLOW_START:
47717c478bd9Sstevel@tonic-gate async->async_inflow_source &= ~type;
47727c478bd9Sstevel@tonic-gate if (async->async_inflow_source == 0) {
47737c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_HW_IN_FLOW;
47747c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_HFLOW, "async%d: "
47757c478bd9Sstevel@tonic-gate "input hflow start\n", instance);
47767c478bd9Sstevel@tonic-gate }
47777c478bd9Sstevel@tonic-gate break;
47787c478bd9Sstevel@tonic-gate default:
47797c478bd9Sstevel@tonic-gate break;
47807c478bd9Sstevel@tonic-gate }
47814ab75253Smrj mcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MCR);
47827c478bd9Sstevel@tonic-gate flag = (async->async_flags & ASYNC_HW_IN_FLOW) ? 0 : RTS;
47837c478bd9Sstevel@tonic-gate
47847c478bd9Sstevel@tonic-gate if (((mcr ^ flag) & RTS) != 0) {
47854ab75253Smrj ddi_put8(asy->asy_iohandle,
47867c478bd9Sstevel@tonic-gate asy->asy_ioaddr + MCR, (mcr ^ RTS));
47877c478bd9Sstevel@tonic-gate }
47887c478bd9Sstevel@tonic-gate }
47897c478bd9Sstevel@tonic-gate
47907c478bd9Sstevel@tonic-gate /*
47917c478bd9Sstevel@tonic-gate * Hardware output flow control
47927c478bd9Sstevel@tonic-gate * This function can execute HW output flow control sucessfully
47937c478bd9Sstevel@tonic-gate * at any situation.
47947c478bd9Sstevel@tonic-gate * It doesn't really change RTS, and just change
47957c478bd9Sstevel@tonic-gate * HW output flow control flag depending on CTS status.
47967c478bd9Sstevel@tonic-gate * INPUT VALUE of onoff:
47977c478bd9Sstevel@tonic-gate * FLOW_START means to clear HW output flow control flag.
47987c478bd9Sstevel@tonic-gate * also combine with SW output flow control status to
47997c478bd9Sstevel@tonic-gate * determine if we need to set ASYNC_OUT_FLW_RESUME.
48007c478bd9Sstevel@tonic-gate * FLOW_STOP means to set HW output flow control flag.
48017c478bd9Sstevel@tonic-gate * also clear ASYNC_OUT_FLW_RESUME.
48027c478bd9Sstevel@tonic-gate */
48037c478bd9Sstevel@tonic-gate static void
async_flowcontrol_hw_output(struct asycom * asy,async_flowc_action onoff)48047c478bd9Sstevel@tonic-gate async_flowcontrol_hw_output(struct asycom *asy, async_flowc_action onoff)
48057c478bd9Sstevel@tonic-gate {
48067c478bd9Sstevel@tonic-gate struct asyncline *async = asy->asy_priv;
48077c478bd9Sstevel@tonic-gate int instance = UNIT(async->async_dev);
48087c478bd9Sstevel@tonic-gate
48097c478bd9Sstevel@tonic-gate ASSERT(mutex_owned(&asy->asy_excl_hi));
48107c478bd9Sstevel@tonic-gate
48117c478bd9Sstevel@tonic-gate if (!(async->async_ttycommon.t_cflag & CRTSCTS))
48127c478bd9Sstevel@tonic-gate return;
48137c478bd9Sstevel@tonic-gate
48147c478bd9Sstevel@tonic-gate switch (onoff) {
48157c478bd9Sstevel@tonic-gate case FLOW_STOP:
48167c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_HW_OUT_FLW;
48177c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_OUT_FLW_RESUME;
48187c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_HFLOW, "async%d: output hflow stop\n",
48197c478bd9Sstevel@tonic-gate instance);
48207c478bd9Sstevel@tonic-gate break;
48217c478bd9Sstevel@tonic-gate case FLOW_START:
48227c478bd9Sstevel@tonic-gate async->async_flags &= ~ASYNC_HW_OUT_FLW;
48237c478bd9Sstevel@tonic-gate if (!(async->async_flags & ASYNC_SW_OUT_FLW))
48247c478bd9Sstevel@tonic-gate async->async_flags |= ASYNC_OUT_FLW_RESUME;
48257c478bd9Sstevel@tonic-gate DEBUGCONT1(ASY_DEBUG_HFLOW, "async%d: output hflow start\n",
48267c478bd9Sstevel@tonic-gate instance);
48277c478bd9Sstevel@tonic-gate break;
48287c478bd9Sstevel@tonic-gate default:
48297c478bd9Sstevel@tonic-gate break;
48307c478bd9Sstevel@tonic-gate }
48317c478bd9Sstevel@tonic-gate }
483219397407SSherry Moore
483319397407SSherry Moore
483419397407SSherry Moore /*
483519397407SSherry Moore * quiesce(9E) entry point.
483619397407SSherry Moore *
483719397407SSherry Moore * This function is called when the system is single-threaded at high
483819397407SSherry Moore * PIL with preemption disabled. Therefore, this function must not be
483919397407SSherry Moore * blocked.
484019397407SSherry Moore *
484119397407SSherry Moore * This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure.
484219397407SSherry Moore * DDI_FAILURE indicates an error condition and should almost never happen.
484319397407SSherry Moore */
484419397407SSherry Moore static int
asyquiesce(dev_info_t * devi)484519397407SSherry Moore asyquiesce(dev_info_t *devi)
484619397407SSherry Moore {
484719397407SSherry Moore int instance;
484819397407SSherry Moore struct asycom *asy;
484919397407SSherry Moore
485019397407SSherry Moore instance = ddi_get_instance(devi); /* find out which unit */
485119397407SSherry Moore
485219397407SSherry Moore asy = ddi_get_soft_state(asy_soft_state, instance);
485319397407SSherry Moore if (asy == NULL)
485419397407SSherry Moore return (DDI_FAILURE);
485519397407SSherry Moore
485619397407SSherry Moore /* disable all interrupts */
485719397407SSherry Moore ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
485819397407SSherry Moore
485919397407SSherry Moore /* reset the FIFO */
486019397407SSherry Moore asy_reset_fifo(asy, FIFOTXFLSH | FIFORXFLSH);
486119397407SSherry Moore
486219397407SSherry Moore return (DDI_SUCCESS);
486319397407SSherry Moore }
4864