xref: /titanic_50/usr/src/uts/common/io/asy.c (revision 69112edd987c28fa551d4f8d9362a84a45365f17)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*	Copyright (c) 1990, 1991 UNIX System Laboratories, Inc.	*/
23 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T	*/
24 /*	  All Rights Reserved					*/
25 
26 /*
27  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
28  * Use is subject to license terms.
29  */
30 
31 
32 /*
33  * Serial I/O driver for 8250/16450/16550A/16650/16750 chips.
34  */
35 
36 #include <sys/param.h>
37 #include <sys/types.h>
38 #include <sys/signal.h>
39 #include <sys/stream.h>
40 #include <sys/termio.h>
41 #include <sys/errno.h>
42 #include <sys/file.h>
43 #include <sys/cmn_err.h>
44 #include <sys/stropts.h>
45 #include <sys/strsubr.h>
46 #include <sys/strtty.h>
47 #include <sys/debug.h>
48 #include <sys/kbio.h>
49 #include <sys/cred.h>
50 #include <sys/stat.h>
51 #include <sys/consdev.h>
52 #include <sys/mkdev.h>
53 #include <sys/kmem.h>
54 #include <sys/cred.h>
55 #include <sys/strsun.h>
56 #ifdef DEBUG
57 #include <sys/promif.h>
58 #endif
59 #include <sys/modctl.h>
60 #include <sys/ddi.h>
61 #include <sys/sunddi.h>
62 #include <sys/pci.h>
63 #include <sys/asy.h>
64 #include <sys/policy.h>
65 
66 /*
67  * set the RX FIFO trigger_level to half the RX FIFO size for now
68  * we may want to make this configurable later.
69  */
70 static	int asy_trig_level = FIFO_TRIG_8;
71 
72 int asy_drain_check = 15000000;		/* tunable: exit drain check time */
73 int asy_min_dtr_low = 500000;		/* tunable: minimum DTR down time */
74 int asy_min_utbrk = 100000;		/* tunable: minumum untimed brk time */
75 
76 int asymaxchip = ASY16750;	/* tunable: limit chip support we look for */
77 
78 /*
79  * Just in case someone has a chip with broken loopback mode, we provide a
80  * means to disable the loopback test. By default, we only loopback test
81  * UARTs which look like they have FIFOs bigger than 16 bytes.
82  * Set to 0 to suppress test, or to 2 to enable test on any size FIFO.
83  */
84 int asy_fifo_test = 1;		/* tunable: set to 0, 1, or 2 */
85 
86 /*
87  * Allow ability to switch off testing of the scratch register.
88  * Some UART emulators might not have it. This will also disable the test
89  * for Exar/Startech ST16C650, as that requires use of the SCR register.
90  */
91 int asy_scr_test = 1;		/* tunable: set to 0 to disable SCR reg test */
92 
93 /*
94  * As we don't yet support on-chip flow control, it's a bad idea to put a
95  * large number of characters in the TX FIFO, since if other end tells us
96  * to stop transmitting, we can only stop filling the TX FIFO, but it will
97  * still carry on draining by itself, so remote end still gets what's left
98  * in the FIFO.
99  */
100 int asy_max_tx_fifo = 16;	/* tunable: max fill of TX FIFO */
101 
102 #define	async_stopc	async_ttycommon.t_stopc
103 #define	async_startc	async_ttycommon.t_startc
104 
105 #define	ASY_INIT	1
106 #define	ASY_NOINIT	0
107 
108 /* enum value for sw and hw flow control action */
109 typedef enum {
110 	FLOW_CHECK,
111 	FLOW_STOP,
112 	FLOW_START
113 } async_flowc_action;
114 
115 #ifdef DEBUG
116 #define	ASY_DEBUG_INIT	0x0001	/* Output msgs during driver initialization. */
117 #define	ASY_DEBUG_INPUT	0x0002	/* Report characters received during int. */
118 #define	ASY_DEBUG_EOT	0x0004	/* Output msgs when wait for xmit to finish. */
119 #define	ASY_DEBUG_CLOSE	0x0008	/* Output msgs when driver open/close called */
120 #define	ASY_DEBUG_HFLOW	0x0010	/* Output msgs when H/W flowcontrol is active */
121 #define	ASY_DEBUG_PROCS	0x0020	/* Output each proc name as it is entered. */
122 #define	ASY_DEBUG_STATE	0x0040	/* Output value of Interrupt Service Reg. */
123 #define	ASY_DEBUG_INTR	0x0080	/* Output value of Interrupt Service Reg. */
124 #define	ASY_DEBUG_OUT	0x0100	/* Output msgs about output events. */
125 #define	ASY_DEBUG_BUSY	0x0200	/* Output msgs when xmit is enabled/disabled */
126 #define	ASY_DEBUG_MODEM	0x0400	/* Output msgs about modem status & control. */
127 #define	ASY_DEBUG_MODM2	0x0800	/* Output msgs about modem status & control. */
128 #define	ASY_DEBUG_IOCTL	0x1000	/* Output msgs about ioctl messages. */
129 #define	ASY_DEBUG_CHIP	0x2000	/* Output msgs about chip identification. */
130 #define	ASY_DEBUG_SFLOW	0x4000	/* Output msgs when S/W flowcontrol is active */
131 #define	ASY_DEBUG(x) (debug & (x))
132 static	int debug  = 0;
133 #else
134 #define	ASY_DEBUG(x) B_FALSE
135 #endif
136 
137 /* pnpISA compressed device ids */
138 #define	pnpMTS0219 0xb6930219	/* Multitech MT5634ZTX modem */
139 
140 /*
141  * PPS (Pulse Per Second) support.
142  */
143 void ddi_hardpps();
144 /*
145  * This is protected by the asy_excl_hi of the port on which PPS event
146  * handling is enabled.  Note that only one port should have this enabled at
147  * any one time.  Enabling PPS handling on multiple ports will result in
148  * unpredictable (but benign) results.
149  */
150 static struct ppsclockev asy_ppsev;
151 
152 #ifdef PPSCLOCKLED
153 /* XXX Use these to observe PPS latencies and jitter on a scope */
154 #define	LED_ON
155 #define	LED_OFF
156 #else
157 #define	LED_ON
158 #define	LED_OFF
159 #endif
160 
161 static	int max_asy_instance = -1;
162 
163 static	uint_t	asysoftintr(caddr_t intarg);
164 static	uint_t	asyintr(caddr_t argasy);
165 
166 static boolean_t abort_charseq_recognize(uchar_t ch);
167 
168 /* The async interrupt entry points */
169 static void	async_txint(struct asycom *asy);
170 static void	async_rxint(struct asycom *asy, uchar_t lsr);
171 static void	async_msint(struct asycom *asy);
172 static void	async_softint(struct asycom *asy);
173 
174 static void	async_ioctl(struct asyncline *async, queue_t *q, mblk_t *mp);
175 static void	async_reioctl(void *unit);
176 static void	async_iocdata(queue_t *q, mblk_t *mp);
177 static void	async_restart(void *arg);
178 static void	async_start(struct asyncline *async);
179 static void	async_nstart(struct asyncline *async, int mode);
180 static void	async_resume(struct asyncline *async);
181 static void	asy_program(struct asycom *asy, int mode);
182 static void	asyinit(struct asycom *asy);
183 static void	asy_waiteot(struct asycom *asy);
184 static void	asyputchar(cons_polledio_arg_t, uchar_t c);
185 static int	asygetchar(cons_polledio_arg_t);
186 static boolean_t	asyischar(cons_polledio_arg_t);
187 
188 static int	asymctl(struct asycom *, int, int);
189 static int	asytodm(int, int);
190 static int	dmtoasy(int);
191 /*PRINTFLIKE2*/
192 static void	asyerror(int level, const char *fmt, ...) __KPRINTFLIKE(2);
193 static void	asy_parse_mode(dev_info_t *devi, struct asycom *asy);
194 static void	asy_soft_state_free(struct asycom *);
195 static char	*asy_hw_name(struct asycom *asy);
196 static void	async_hold_utbrk(void *arg);
197 static void	async_resume_utbrk(struct asyncline *async);
198 static void	async_dtr_free(struct asyncline *async);
199 static int	asy_identify_chip(dev_info_t *devi, struct asycom *asy);
200 static void	asy_reset_fifo(struct asycom *asy, uchar_t flags);
201 static int	asy_getproperty(dev_info_t *devi, struct asycom *asy,
202 		    const char *property);
203 static boolean_t	async_flowcontrol_sw_input(struct asycom *asy,
204 			    async_flowc_action onoff, int type);
205 static void	async_flowcontrol_sw_output(struct asycom *asy,
206 		    async_flowc_action onoff);
207 static void	async_flowcontrol_hw_input(struct asycom *asy,
208 		    async_flowc_action onoff, int type);
209 static void	async_flowcontrol_hw_output(struct asycom *asy,
210 		    async_flowc_action onoff);
211 
212 #define	GET_PROP(devi, pname, pflag, pval, plen) \
213 		(ddi_prop_op(DDI_DEV_T_ANY, (devi), PROP_LEN_AND_VAL_BUF, \
214 		(pflag), (pname), (caddr_t)(pval), (plen)))
215 
216 static ddi_iblock_cookie_t asy_soft_iblock;
217 ddi_softintr_t asy_softintr_id;
218 static	int asy_addedsoft = 0;
219 int	asysoftpend;	/* soft interrupt pending */
220 kmutex_t asy_soft_lock;	/* lock protecting asysoftpend */
221 kmutex_t asy_glob_lock; /* lock protecting global data manipulation */
222 void *asy_soft_state;
223 
224 /* Standard COM port I/O addresses */
225 static const int standard_com_ports[] = {
226 	COM1_IOADDR, COM2_IOADDR, COM3_IOADDR, COM4_IOADDR
227 };
228 
229 static int *com_ports;
230 static uint_t num_com_ports;
231 
232 #ifdef	DEBUG
233 /*
234  * Set this to true to make the driver pretend to do a suspend.  Useful
235  * for debugging suspend/resume code with a serial debugger.
236  */
237 boolean_t	asy_nosuspend = B_FALSE;
238 #endif
239 
240 
241 /*
242  * Baud rate table. Indexed by #defines found in sys/termios.h
243  */
244 ushort_t asyspdtab[] = {
245 	0,	/* 0 baud rate */
246 	0x900,	/* 50 baud rate */
247 	0x600,	/* 75 baud rate */
248 	0x417,	/* 110 baud rate (%0.026) */
249 	0x359,	/* 134 baud rate (%0.058) */
250 	0x300,	/* 150 baud rate */
251 	0x240,	/* 200 baud rate */
252 	0x180,	/* 300 baud rate */
253 	0x0c0,	/* 600 baud rate */
254 	0x060,	/* 1200 baud rate */
255 	0x040,	/* 1800 baud rate */
256 	0x030,	/* 2400 baud rate */
257 	0x018,	/* 4800 baud rate */
258 	0x00c,	/* 9600 baud rate */
259 	0x006,	/* 19200 baud rate */
260 	0x003,	/* 38400 baud rate */
261 
262 	0x002,	/* 57600 baud rate */
263 	0x0,	/* 76800 baud rate not supported */
264 	0x001,	/* 115200 baud rate */
265 	0x0,	/* 153600 baud rate not supported */
266 	0x0,	/* 0x8002 (SMC chip) 230400 baud rate not supported */
267 	0x0,	/* 307200 baud rate not supported */
268 	0x0,	/* 0x8001 (SMC chip) 460800 baud rate not supported */
269 	0x0,	/* unused */
270 	0x0,	/* unused */
271 	0x0,	/* unused */
272 	0x0,	/* unused */
273 	0x0,	/* unused */
274 	0x0,	/* unused */
275 	0x0,	/* unused */
276 	0x0,	/* unused */
277 	0x0,	/* unused */
278 };
279 
280 static int asyrsrv(queue_t *q);
281 static int asyopen(queue_t *rq, dev_t *dev, int flag, int sflag, cred_t *cr);
282 static int asyclose(queue_t *q, int flag, cred_t *credp);
283 static int asywputdo(queue_t *q, mblk_t *mp, boolean_t);
284 static int asywput(queue_t *q, mblk_t *mp);
285 
286 struct module_info asy_info = {
287 	0,
288 	"asy",
289 	0,
290 	INFPSZ,
291 	4096,
292 	128
293 };
294 
295 static struct qinit asy_rint = {
296 	putq,
297 	asyrsrv,
298 	asyopen,
299 	asyclose,
300 	NULL,
301 	&asy_info,
302 	NULL
303 };
304 
305 static struct qinit asy_wint = {
306 	asywput,
307 	NULL,
308 	NULL,
309 	NULL,
310 	NULL,
311 	&asy_info,
312 	NULL
313 };
314 
315 struct streamtab asy_str_info = {
316 	&asy_rint,
317 	&asy_wint,
318 	NULL,
319 	NULL
320 };
321 
322 static int asyinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
323 		void **result);
324 static int asyprobe(dev_info_t *);
325 static int asyattach(dev_info_t *, ddi_attach_cmd_t);
326 static int asydetach(dev_info_t *, ddi_detach_cmd_t);
327 static int asyquiesce(dev_info_t *);
328 
329 static 	struct cb_ops cb_asy_ops = {
330 	nodev,			/* cb_open */
331 	nodev,			/* cb_close */
332 	nodev,			/* cb_strategy */
333 	nodev,			/* cb_print */
334 	nodev,			/* cb_dump */
335 	nodev,			/* cb_read */
336 	nodev,			/* cb_write */
337 	nodev,			/* cb_ioctl */
338 	nodev,			/* cb_devmap */
339 	nodev,			/* cb_mmap */
340 	nodev,			/* cb_segmap */
341 	nochpoll,		/* cb_chpoll */
342 	ddi_prop_op,		/* cb_prop_op */
343 	&asy_str_info,		/* cb_stream */
344 	D_MP			/* cb_flag */
345 };
346 
347 struct dev_ops asy_ops = {
348 	DEVO_REV,		/* devo_rev */
349 	0,			/* devo_refcnt */
350 	asyinfo,		/* devo_getinfo */
351 	nulldev,		/* devo_identify */
352 	asyprobe,		/* devo_probe */
353 	asyattach,		/* devo_attach */
354 	asydetach,		/* devo_detach */
355 	nodev,			/* devo_reset */
356 	&cb_asy_ops,		/* devo_cb_ops */
357 	NULL,			/* devo_bus_ops */
358 	NULL,			/* power */
359 	asyquiesce,		/* quiesce */
360 };
361 
362 static struct modldrv modldrv = {
363 	&mod_driverops, /* Type of module.  This one is a driver */
364 	"ASY driver",
365 	&asy_ops,	/* driver ops */
366 };
367 
368 static struct modlinkage modlinkage = {
369 	MODREV_1,
370 	(void *)&modldrv,
371 	NULL
372 };
373 
374 int
375 _init(void)
376 {
377 	int i;
378 
379 	i = ddi_soft_state_init(&asy_soft_state, sizeof (struct asycom), 2);
380 	if (i == 0) {
381 		mutex_init(&asy_glob_lock, NULL, MUTEX_DRIVER, NULL);
382 		if ((i = mod_install(&modlinkage)) != 0) {
383 			mutex_destroy(&asy_glob_lock);
384 			ddi_soft_state_fini(&asy_soft_state);
385 		} else {
386 			DEBUGCONT2(ASY_DEBUG_INIT, "%s, debug = %x\n",
387 			    modldrv.drv_linkinfo, debug);
388 		}
389 	}
390 	return (i);
391 }
392 
393 int
394 _fini(void)
395 {
396 	int i;
397 
398 	if ((i = mod_remove(&modlinkage)) == 0) {
399 		DEBUGCONT1(ASY_DEBUG_INIT, "%s unloading\n",
400 		    modldrv.drv_linkinfo);
401 		ASSERT(max_asy_instance == -1);
402 		mutex_destroy(&asy_glob_lock);
403 		if (asy_addedsoft)
404 			ddi_remove_softintr(asy_softintr_id);
405 		asy_addedsoft = 0;
406 		/* free "motherboard-serial-ports" property if allocated */
407 		if (com_ports != NULL && com_ports != (int *)standard_com_ports)
408 			ddi_prop_free(com_ports);
409 		com_ports = NULL;
410 		mutex_destroy(&asy_soft_lock);
411 		ddi_soft_state_fini(&asy_soft_state);
412 	}
413 	return (i);
414 }
415 
416 int
417 _info(struct modinfo *modinfop)
418 {
419 	return (mod_info(&modlinkage, modinfop));
420 }
421 
422 void
423 async_put_suspq(struct asycom *asy, mblk_t *mp)
424 {
425 	struct asyncline *async = asy->asy_priv;
426 
427 	ASSERT(mutex_owned(&asy->asy_excl));
428 
429 	if (async->async_suspqf == NULL)
430 		async->async_suspqf = mp;
431 	else
432 		async->async_suspqb->b_next = mp;
433 
434 	async->async_suspqb = mp;
435 }
436 
437 static mblk_t *
438 async_get_suspq(struct asycom *asy)
439 {
440 	struct asyncline *async = asy->asy_priv;
441 	mblk_t *mp;
442 
443 	ASSERT(mutex_owned(&asy->asy_excl));
444 
445 	if ((mp = async->async_suspqf) != NULL) {
446 		async->async_suspqf = mp->b_next;
447 		mp->b_next = NULL;
448 	} else {
449 		async->async_suspqb = NULL;
450 	}
451 	return (mp);
452 }
453 
454 static void
455 async_process_suspq(struct asycom *asy)
456 {
457 	struct asyncline *async = asy->asy_priv;
458 	mblk_t *mp;
459 
460 	ASSERT(mutex_owned(&asy->asy_excl));
461 
462 	while ((mp = async_get_suspq(asy)) != NULL) {
463 		queue_t *q;
464 
465 		q = async->async_ttycommon.t_writeq;
466 		ASSERT(q != NULL);
467 		mutex_exit(&asy->asy_excl);
468 		(void) asywputdo(q, mp, B_FALSE);
469 		mutex_enter(&asy->asy_excl);
470 	}
471 	async->async_flags &= ~ASYNC_DDI_SUSPENDED;
472 	cv_broadcast(&async->async_flags_cv);
473 }
474 
475 static int
476 asy_get_bus_type(dev_info_t *devinfo)
477 {
478 	char	parent_type[16];
479 	int	parentlen;
480 
481 	parentlen = sizeof (parent_type);
482 
483 	if (ddi_prop_op(DDI_DEV_T_ANY, devinfo, PROP_LEN_AND_VAL_BUF, 0,
484 	    "device_type", (caddr_t)parent_type, &parentlen)
485 	    != DDI_PROP_SUCCESS && ddi_prop_op(DDI_DEV_T_ANY, devinfo,
486 	    PROP_LEN_AND_VAL_BUF, 0, "bus-type", (caddr_t)parent_type,
487 	    &parentlen) != DDI_PROP_SUCCESS) {
488 			cmn_err(CE_WARN,
489 			    "asy: can't figure out device type for"
490 			    " parent \"%s\"",
491 			    ddi_get_name(ddi_get_parent(devinfo)));
492 			return (ASY_BUS_UNKNOWN);
493 	}
494 	if (strcmp(parent_type, "isa") == 0)
495 		return (ASY_BUS_ISA);
496 	else if (strcmp(parent_type, "pci") == 0)
497 		return (ASY_BUS_PCI);
498 	else
499 		return (ASY_BUS_UNKNOWN);
500 }
501 
502 static int
503 asy_get_io_regnum_pci(dev_info_t *devi, struct asycom *asy)
504 {
505 	int reglen, nregs;
506 	int regnum, i;
507 	uint64_t size;
508 	struct pci_phys_spec *reglist;
509 
510 	if (ddi_getlongprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
511 	    "reg", (caddr_t)&reglist, &reglen) != DDI_PROP_SUCCESS) {
512 		cmn_err(CE_WARN, "asy_get_io_regnum_pci: reg property"
513 		    " not found in devices property list");
514 		return (-1);
515 	}
516 
517 	/*
518 	 * PCI devices are assumed to not have broken FIFOs;
519 	 * Agere/Lucent Venus PCI modem chipsets are an example
520 	 */
521 	if (asy)
522 		asy->asy_flags2 |= ASY2_NO_LOOPBACK;
523 
524 	regnum = -1;
525 	nregs = reglen / sizeof (*reglist);
526 	for (i = 0; i < nregs; i++) {
527 		switch (reglist[i].pci_phys_hi & PCI_ADDR_MASK) {
528 		case PCI_ADDR_IO:		/* I/O bus reg property */
529 			if (regnum == -1) /* use only the first one */
530 				regnum = i;
531 			break;
532 
533 		default:
534 			break;
535 		}
536 	}
537 
538 	/* check for valid count of registers */
539 	if (regnum >= 0) {
540 		size = ((uint64_t)reglist[regnum].pci_size_low) |
541 		    ((uint64_t)reglist[regnum].pci_size_hi) << 32;
542 		if (size < 8)
543 			regnum = -1;
544 	}
545 	kmem_free(reglist, reglen);
546 	return (regnum);
547 }
548 
549 static int
550 asy_get_io_regnum_isa(dev_info_t *devi, struct asycom *asy)
551 {
552 	int reglen, nregs;
553 	int regnum, i;
554 	struct {
555 		uint_t bustype;
556 		int base;
557 		int size;
558 	} *reglist;
559 
560 	if (ddi_getlongprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
561 	    "reg", (caddr_t)&reglist, &reglen) != DDI_PROP_SUCCESS) {
562 		cmn_err(CE_WARN, "asy_get_io_regnum: reg property not found "
563 		    "in devices property list");
564 		return (-1);
565 	}
566 
567 	regnum = -1;
568 	nregs = reglen / sizeof (*reglist);
569 	for (i = 0; i < nregs; i++) {
570 		switch (reglist[i].bustype) {
571 		case 1:			/* I/O bus reg property */
572 			if (regnum == -1) /* only use the first one */
573 				regnum = i;
574 			break;
575 
576 		case pnpMTS0219:	/* Multitech MT5634ZTX modem */
577 			/* Venus chipset can't do loopback test */
578 			if (asy)
579 				asy->asy_flags2 |= ASY2_NO_LOOPBACK;
580 			break;
581 
582 		default:
583 			break;
584 		}
585 	}
586 
587 	/* check for valid count of registers */
588 	if ((regnum < 0) || (reglist[regnum].size < 8))
589 		regnum = -1;
590 	kmem_free(reglist, reglen);
591 	return (regnum);
592 }
593 
594 static int
595 asy_get_io_regnum(dev_info_t *devinfo, struct asycom *asy)
596 {
597 	switch (asy_get_bus_type(devinfo)) {
598 	case ASY_BUS_ISA:
599 		return (asy_get_io_regnum_isa(devinfo, asy));
600 	case ASY_BUS_PCI:
601 		return (asy_get_io_regnum_pci(devinfo, asy));
602 	default:
603 		return (-1);
604 	}
605 }
606 
607 static int
608 asydetach(dev_info_t *devi, ddi_detach_cmd_t cmd)
609 {
610 	int instance;
611 	struct asycom *asy;
612 	struct asyncline *async;
613 
614 	instance = ddi_get_instance(devi);	/* find out which unit */
615 
616 	asy = ddi_get_soft_state(asy_soft_state, instance);
617 	if (asy == NULL)
618 		return (DDI_FAILURE);
619 	async = asy->asy_priv;
620 
621 	switch (cmd) {
622 	case DDI_DETACH:
623 		DEBUGNOTE2(ASY_DEBUG_INIT, "asy%d: %s shutdown.",
624 		    instance, asy_hw_name(asy));
625 
626 		/* cancel DTR hold timeout */
627 		if (async->async_dtrtid != 0) {
628 			(void) untimeout(async->async_dtrtid);
629 			async->async_dtrtid = 0;
630 		}
631 
632 		/* remove all minor device node(s) for this device */
633 		ddi_remove_minor_node(devi, NULL);
634 
635 		mutex_destroy(&asy->asy_excl);
636 		mutex_destroy(&asy->asy_excl_hi);
637 		cv_destroy(&async->async_flags_cv);
638 		ddi_remove_intr(devi, 0, asy->asy_iblock);
639 		ddi_regs_map_free(&asy->asy_iohandle);
640 		asy_soft_state_free(asy);
641 		DEBUGNOTE1(ASY_DEBUG_INIT, "asy%d: shutdown complete",
642 		    instance);
643 		break;
644 	case DDI_SUSPEND:
645 		{
646 		unsigned i;
647 		uchar_t lsr;
648 
649 #ifdef	DEBUG
650 		if (asy_nosuspend)
651 			return (DDI_SUCCESS);
652 #endif
653 		mutex_enter(&asy->asy_excl);
654 
655 		ASSERT(async->async_ops >= 0);
656 		while (async->async_ops > 0)
657 			cv_wait(&async->async_ops_cv, &asy->asy_excl);
658 
659 		async->async_flags |= ASYNC_DDI_SUSPENDED;
660 
661 		/* Wait for timed break and delay to complete */
662 		while ((async->async_flags & (ASYNC_BREAK|ASYNC_DELAY))) {
663 			if (cv_wait_sig(&async->async_flags_cv, &asy->asy_excl)
664 			    == 0) {
665 				async_process_suspq(asy);
666 				mutex_exit(&asy->asy_excl);
667 				return (DDI_FAILURE);
668 			}
669 		}
670 
671 		/* Clear untimed break */
672 		if (async->async_flags & ASYNC_OUT_SUSPEND)
673 			async_resume_utbrk(async);
674 
675 		mutex_exit(&asy->asy_excl);
676 
677 		mutex_enter(&asy->asy_soft_sr);
678 		mutex_enter(&asy->asy_excl);
679 		if (async->async_wbufcid != 0) {
680 			bufcall_id_t bcid = async->async_wbufcid;
681 			async->async_wbufcid = 0;
682 			async->async_flags |= ASYNC_RESUME_BUFCALL;
683 			mutex_exit(&asy->asy_excl);
684 			unbufcall(bcid);
685 			mutex_enter(&asy->asy_excl);
686 		}
687 		mutex_enter(&asy->asy_excl_hi);
688 
689 		/* Disable interrupts from chip */
690 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
691 		asy->asy_flags |= ASY_DDI_SUSPENDED;
692 
693 		/* Process remaining RX characters and RX errors, if any */
694 		lsr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR);
695 		async_rxint(asy, lsr);
696 
697 		/* Wait for TX to drain */
698 		for (i = 1000; i > 0; i--) {
699 			lsr = ddi_get8(asy->asy_iohandle,
700 			    asy->asy_ioaddr + LSR);
701 			if ((lsr & (XSRE | XHRE)) == (XSRE | XHRE))
702 				break;
703 			delay(drv_usectohz(10000));
704 		}
705 		if (i == 0)
706 			cmn_err(CE_WARN,
707 			    "asy: transmitter wasn't drained before "
708 			    "driver was suspended");
709 
710 		mutex_exit(&asy->asy_excl_hi);
711 		mutex_exit(&asy->asy_excl);
712 		mutex_exit(&asy->asy_soft_sr);
713 		break;
714 	}
715 	default:
716 		return (DDI_FAILURE);
717 	}
718 
719 	return (DDI_SUCCESS);
720 }
721 
722 /*
723  * asyprobe
724  * We don't bother probing for the hardware, as since Solaris 2.6, device
725  * nodes are only created for auto-detected hardware or nodes explicitly
726  * created by the user, e.g. via the DCA. However, we should check the
727  * device node is at least vaguely usable, i.e. we have a block of 8 i/o
728  * ports. This prevents attempting to attach to bogus serial ports which
729  * some BIOSs still partially report when they are disabled in the BIOS.
730  */
731 static int
732 asyprobe(dev_info_t *devi)
733 {
734 	return ((asy_get_io_regnum(devi, NULL) < 0) ?
735 	    DDI_PROBE_FAILURE : DDI_PROBE_DONTCARE);
736 }
737 
738 static int
739 asyattach(dev_info_t *devi, ddi_attach_cmd_t cmd)
740 {
741 	int instance;
742 	int mcr;
743 	int ret;
744 	int regnum = 0;
745 	int i;
746 	struct asycom *asy;
747 	char name[ASY_MINOR_LEN];
748 	int status;
749 	static ddi_device_acc_attr_t ioattr = {
750 		DDI_DEVICE_ATTR_V0,
751 		DDI_NEVERSWAP_ACC,
752 		DDI_STRICTORDER_ACC,
753 	};
754 
755 	instance = ddi_get_instance(devi);	/* find out which unit */
756 
757 	switch (cmd) {
758 	case DDI_ATTACH:
759 		break;
760 	case DDI_RESUME:
761 	{
762 		struct asyncline *async;
763 
764 #ifdef	DEBUG
765 		if (asy_nosuspend)
766 			return (DDI_SUCCESS);
767 #endif
768 		asy = ddi_get_soft_state(asy_soft_state, instance);
769 		if (asy == NULL)
770 			return (DDI_FAILURE);
771 
772 		mutex_enter(&asy->asy_soft_sr);
773 		mutex_enter(&asy->asy_excl);
774 		mutex_enter(&asy->asy_excl_hi);
775 
776 		async = asy->asy_priv;
777 		/* Disable interrupts */
778 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
779 		if (asy_identify_chip(devi, asy) != DDI_SUCCESS) {
780 			mutex_exit(&asy->asy_excl_hi);
781 			mutex_exit(&asy->asy_excl);
782 			mutex_exit(&asy->asy_soft_sr);
783 			cmn_err(CE_WARN, "!Cannot identify UART chip at %p\n",
784 			    (void *)asy->asy_ioaddr);
785 			return (DDI_FAILURE);
786 		}
787 		asy->asy_flags &= ~ASY_DDI_SUSPENDED;
788 		if (async->async_flags & ASYNC_ISOPEN) {
789 			asy_program(asy, ASY_INIT);
790 			/* Kick off output */
791 			if (async->async_ocnt > 0) {
792 				async_resume(async);
793 			} else {
794 				mutex_exit(&asy->asy_excl_hi);
795 				if (async->async_xmitblk)
796 					freeb(async->async_xmitblk);
797 				async->async_xmitblk = NULL;
798 				async_start(async);
799 				mutex_enter(&asy->asy_excl_hi);
800 			}
801 			ASYSETSOFT(asy);
802 		}
803 		mutex_exit(&asy->asy_excl_hi);
804 		mutex_exit(&asy->asy_excl);
805 		mutex_exit(&asy->asy_soft_sr);
806 
807 		mutex_enter(&asy->asy_excl);
808 		if (async->async_flags & ASYNC_RESUME_BUFCALL) {
809 			async->async_wbufcid = bufcall(async->async_wbufcds,
810 			    BPRI_HI, (void (*)(void *)) async_reioctl,
811 			    (void *)(intptr_t)async->async_common->asy_unit);
812 			async->async_flags &= ~ASYNC_RESUME_BUFCALL;
813 		}
814 		async_process_suspq(asy);
815 		mutex_exit(&asy->asy_excl);
816 		return (DDI_SUCCESS);
817 	}
818 	default:
819 		return (DDI_FAILURE);
820 	}
821 
822 	ret = ddi_soft_state_zalloc(asy_soft_state, instance);
823 	if (ret != DDI_SUCCESS)
824 		return (DDI_FAILURE);
825 	asy = ddi_get_soft_state(asy_soft_state, instance);
826 	ASSERT(asy != NULL);	/* can't fail - we only just allocated it */
827 	asy->asy_unit = instance;
828 	mutex_enter(&asy_glob_lock);
829 	if (instance > max_asy_instance)
830 		max_asy_instance = instance;
831 	mutex_exit(&asy_glob_lock);
832 
833 	regnum = asy_get_io_regnum(devi, asy);
834 
835 	if (regnum < 0 ||
836 	    ddi_regs_map_setup(devi, regnum, (caddr_t *)&asy->asy_ioaddr,
837 	    (offset_t)0, (offset_t)0, &ioattr, &asy->asy_iohandle)
838 	    != DDI_SUCCESS) {
839 		cmn_err(CE_WARN, "asy%d: could not map UART registers @ %p",
840 		    instance, (void *)asy->asy_ioaddr);
841 
842 		asy_soft_state_free(asy);
843 		return (DDI_FAILURE);
844 	}
845 
846 	DEBUGCONT2(ASY_DEBUG_INIT, "asy%dattach: UART @ %p\n",
847 	    instance, (void *)asy->asy_ioaddr);
848 
849 	mutex_enter(&asy_glob_lock);
850 	if (com_ports == NULL) {	/* need to initialize com_ports */
851 		if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, devi, 0,
852 		    "motherboard-serial-ports", &com_ports, &num_com_ports) !=
853 		    DDI_PROP_SUCCESS) {
854 			/* Use our built-in COM[1234] values */
855 			com_ports = (int *)standard_com_ports;
856 			num_com_ports = sizeof (standard_com_ports) /
857 			    sizeof (standard_com_ports[0]);
858 		}
859 		if (num_com_ports > 10) {
860 			/* We run out of single digits for device properties */
861 			num_com_ports = 10;
862 			cmn_err(CE_WARN,
863 			    "More than %d motherboard-serial-ports",
864 			    num_com_ports);
865 		}
866 	}
867 	mutex_exit(&asy_glob_lock);
868 
869 	/*
870 	 * Lookup the i/o address to see if this is a standard COM port
871 	 * in which case we assign it the correct tty[a-d] to match the
872 	 * COM port number, or some other i/o address in which case it
873 	 * will be assigned /dev/term/[0123...] in some rather arbitrary
874 	 * fashion.
875 	 */
876 
877 	for (i = 0; i < num_com_ports; i++) {
878 		if (asy->asy_ioaddr == (uint8_t *)(uintptr_t)com_ports[i]) {
879 			asy->asy_com_port = i + 1;
880 			break;
881 		}
882 	}
883 
884 	/*
885 	 * It appears that there was async hardware that on reset
886 	 * did not clear ICR.  Hence when we get to
887 	 * ddi_get_iblock_cookie below, this hardware would cause
888 	 * the system to hang if there was input available.
889 	 */
890 
891 	ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0x00);
892 
893 	/* establish default usage */
894 	asy->asy_mcr |= RTS|DTR;		/* do use RTS/DTR after open */
895 	asy->asy_lcr = STOP1|BITS8;		/* default to 1 stop 8 bits */
896 	asy->asy_bidx = B9600;			/* default to 9600  */
897 #ifdef DEBUG
898 	asy->asy_msint_cnt = 0;			/* # of times in async_msint */
899 #endif
900 	mcr = 0;				/* don't enable until open */
901 
902 	if (asy->asy_com_port != 0) {
903 		/*
904 		 * For motherboard ports, emulate tty eeprom properties.
905 		 * Actually, we can't tell if a port is motherboard or not,
906 		 * so for "motherboard ports", read standard DOS COM ports.
907 		 */
908 		switch (asy_getproperty(devi, asy, "ignore-cd")) {
909 		case 0:				/* *-ignore-cd=False */
910 			DEBUGCONT1(ASY_DEBUG_MODEM,
911 			    "asy%dattach: clear ASY_IGNORE_CD\n", instance);
912 			asy->asy_flags &= ~ASY_IGNORE_CD; /* wait for cd */
913 			break;
914 		case 1:				/* *-ignore-cd=True */
915 			/*FALLTHRU*/
916 		default:			/* *-ignore-cd not defined */
917 			/*
918 			 * We set rather silly defaults of soft carrier on
919 			 * and DTR/RTS raised here because it might be that
920 			 * one of the motherboard ports is the system console.
921 			 */
922 			DEBUGCONT1(ASY_DEBUG_MODEM,
923 			    "asy%dattach: set ASY_IGNORE_CD, set RTS & DTR\n",
924 			    instance);
925 			mcr = asy->asy_mcr;		/* rts/dtr on */
926 			asy->asy_flags |= ASY_IGNORE_CD;	/* ignore cd */
927 			break;
928 		}
929 
930 		/* Property for not raising DTR/RTS */
931 		switch (asy_getproperty(devi, asy, "rts-dtr-off")) {
932 		case 0:				/* *-rts-dtr-off=False */
933 			asy->asy_flags |= ASY_RTS_DTR_OFF;	/* OFF */
934 			mcr = asy->asy_mcr;		/* rts/dtr on */
935 			DEBUGCONT1(ASY_DEBUG_MODEM, "asy%dattach: "
936 			    "ASY_RTS_DTR_OFF set and DTR & RTS set\n",
937 			    instance);
938 			break;
939 		case 1:				/* *-rts-dtr-off=True */
940 			/*FALLTHRU*/
941 		default:			/* *-rts-dtr-off undefined */
942 			break;
943 		}
944 
945 		/* Parse property for tty modes */
946 		asy_parse_mode(devi, asy);
947 	} else {
948 		DEBUGCONT1(ASY_DEBUG_MODEM,
949 		    "asy%dattach: clear ASY_IGNORE_CD, clear RTS & DTR\n",
950 		    instance);
951 		asy->asy_flags &= ~ASY_IGNORE_CD;	/* wait for cd */
952 	}
953 
954 	/*
955 	 * Initialize the port with default settings.
956 	 */
957 
958 	asy->asy_fifo_buf = 1;
959 	asy->asy_use_fifo = FIFO_OFF;
960 
961 	/*
962 	 * Get icookie for mutexes initialization
963 	 */
964 	if ((ddi_get_iblock_cookie(devi, 0, &asy->asy_iblock) !=
965 	    DDI_SUCCESS) ||
966 	    (ddi_get_soft_iblock_cookie(devi, DDI_SOFTINT_MED,
967 	    &asy_soft_iblock) != DDI_SUCCESS)) {
968 		ddi_regs_map_free(&asy->asy_iohandle);
969 		cmn_err(CE_CONT,
970 		    "asy%d: could not hook interrupt for UART @ %p\n",
971 		    instance, (void *)asy->asy_ioaddr);
972 		asy_soft_state_free(asy);
973 		return (DDI_FAILURE);
974 	}
975 
976 	/*
977 	 * Initialize mutexes before accessing the hardware
978 	 */
979 	mutex_init(&asy->asy_excl, NULL, MUTEX_DRIVER, asy_soft_iblock);
980 	mutex_init(&asy->asy_excl_hi, NULL, MUTEX_DRIVER,
981 	    (void *)asy->asy_iblock);
982 	mutex_init(&asy->asy_soft_sr, NULL, MUTEX_DRIVER, asy_soft_iblock);
983 
984 	mutex_enter(&asy->asy_excl);
985 	mutex_enter(&asy->asy_excl_hi);
986 
987 	if (asy_identify_chip(devi, asy) != DDI_SUCCESS) {
988 		mutex_exit(&asy->asy_excl_hi);
989 		mutex_exit(&asy->asy_excl);
990 		mutex_destroy(&asy->asy_excl);
991 		mutex_destroy(&asy->asy_excl_hi);
992 		mutex_destroy(&asy->asy_soft_sr);
993 		ddi_regs_map_free(&asy->asy_iohandle);
994 		cmn_err(CE_CONT, "!Cannot identify UART chip at %p\n",
995 		    (void *)asy->asy_ioaddr);
996 		asy_soft_state_free(asy);
997 		return (DDI_FAILURE);
998 	}
999 
1000 	/* disable all interrupts */
1001 	ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
1002 	/* select baud rate generator */
1003 	ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, DLAB);
1004 	/* Set the baud rate to 9600 */
1005 	ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + (DAT+DLL),
1006 	    asyspdtab[asy->asy_bidx] & 0xff);
1007 	ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + (DAT+DLH),
1008 	    (asyspdtab[asy->asy_bidx] >> 8) & 0xff);
1009 	ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, asy->asy_lcr);
1010 	ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR, mcr);
1011 
1012 	mutex_exit(&asy->asy_excl_hi);
1013 	mutex_exit(&asy->asy_excl);
1014 
1015 	/*
1016 	 * Set up the other components of the asycom structure for this port.
1017 	 */
1018 	asy->asy_dip = devi;
1019 
1020 	mutex_enter(&asy_glob_lock);
1021 	if (asy_addedsoft == 0) { /* install the soft interrupt handler */
1022 		if (ddi_add_softintr(devi, DDI_SOFTINT_MED,
1023 		    &asy_softintr_id, NULL, 0, asysoftintr,
1024 		    (caddr_t)0) != DDI_SUCCESS) {
1025 			mutex_destroy(&asy->asy_excl);
1026 			mutex_destroy(&asy->asy_excl_hi);
1027 			ddi_regs_map_free(&asy->asy_iohandle);
1028 			mutex_exit(&asy_glob_lock);
1029 			cmn_err(CE_CONT,
1030 			    "Can not set soft interrupt for ASY driver\n");
1031 			asy_soft_state_free(asy);
1032 			return (DDI_FAILURE);
1033 		}
1034 		mutex_init(&asy_soft_lock, NULL, MUTEX_DRIVER,
1035 		    (void *)asy->asy_iblock);
1036 		asy_addedsoft++;
1037 	}
1038 	mutex_exit(&asy_glob_lock);
1039 
1040 	mutex_enter(&asy->asy_excl);
1041 	mutex_enter(&asy->asy_excl_hi);
1042 
1043 	/*
1044 	 * Install interrupt handler for this device.
1045 	 */
1046 	if (ddi_add_intr(devi, 0, NULL, 0, asyintr,
1047 	    (caddr_t)asy) != DDI_SUCCESS) {
1048 		mutex_exit(&asy->asy_excl_hi);
1049 		mutex_exit(&asy->asy_excl);
1050 		mutex_destroy(&asy->asy_excl);
1051 		mutex_destroy(&asy->asy_excl_hi);
1052 		ddi_regs_map_free(&asy->asy_iohandle);
1053 		cmn_err(CE_CONT,
1054 		    "Can not set device interrupt for ASY driver\n");
1055 		asy_soft_state_free(asy);
1056 		return (DDI_FAILURE);
1057 	}
1058 
1059 	mutex_exit(&asy->asy_excl_hi);
1060 	mutex_exit(&asy->asy_excl);
1061 
1062 	asyinit(asy);	/* initialize the asyncline structure */
1063 
1064 	/* create minor device nodes for this device */
1065 	if (asy->asy_com_port != 0) {
1066 		/*
1067 		 * For DOS COM ports, add letter suffix so
1068 		 * devfsadm can create correct link names.
1069 		 */
1070 		name[0] = asy->asy_com_port + 'a' - 1;
1071 		name[1] = '\0';
1072 	} else {
1073 		/*
1074 		 * asy port which isn't a standard DOS COM
1075 		 * port gets a numeric name based on instance
1076 		 */
1077 		(void) snprintf(name, ASY_MINOR_LEN, "%d", instance);
1078 	}
1079 	status = ddi_create_minor_node(devi, name, S_IFCHR, instance,
1080 	    asy->asy_com_port != 0 ? DDI_NT_SERIAL_MB : DDI_NT_SERIAL, NULL);
1081 	if (status == DDI_SUCCESS) {
1082 		(void) strcat(name, ",cu");
1083 		status = ddi_create_minor_node(devi, name, S_IFCHR,
1084 		    OUTLINE | instance,
1085 		    asy->asy_com_port != 0 ? DDI_NT_SERIAL_MB_DO :
1086 		    DDI_NT_SERIAL_DO, NULL);
1087 	}
1088 
1089 	if (status != DDI_SUCCESS) {
1090 		struct asyncline *async = asy->asy_priv;
1091 
1092 		ddi_remove_minor_node(devi, NULL);
1093 		ddi_remove_intr(devi, 0, asy->asy_iblock);
1094 		mutex_destroy(&asy->asy_excl);
1095 		mutex_destroy(&asy->asy_excl_hi);
1096 		cv_destroy(&async->async_flags_cv);
1097 		ddi_regs_map_free(&asy->asy_iohandle);
1098 		asy_soft_state_free(asy);
1099 		return (DDI_FAILURE);
1100 	}
1101 
1102 	/*
1103 	 * Fill in the polled I/O structure.
1104 	 */
1105 	asy->polledio.cons_polledio_version = CONSPOLLEDIO_V0;
1106 	asy->polledio.cons_polledio_argument = (cons_polledio_arg_t)asy;
1107 	asy->polledio.cons_polledio_putchar = asyputchar;
1108 	asy->polledio.cons_polledio_getchar = asygetchar;
1109 	asy->polledio.cons_polledio_ischar = asyischar;
1110 	asy->polledio.cons_polledio_enter = NULL;
1111 	asy->polledio.cons_polledio_exit = NULL;
1112 
1113 	ddi_report_dev(devi);
1114 	DEBUGCONT1(ASY_DEBUG_INIT, "asy%dattach: done\n", instance);
1115 	return (DDI_SUCCESS);
1116 }
1117 
1118 /*ARGSUSED*/
1119 static int
1120 asyinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
1121 	void **result)
1122 {
1123 	dev_t dev = (dev_t)arg;
1124 	int instance, error;
1125 	struct asycom *asy;
1126 
1127 	instance = UNIT(dev);
1128 
1129 	switch (infocmd) {
1130 	case DDI_INFO_DEVT2DEVINFO:
1131 		asy = ddi_get_soft_state(asy_soft_state, instance);
1132 		if ((asy == NULL) || (asy->asy_dip == NULL))
1133 			error = DDI_FAILURE;
1134 		else {
1135 			*result = (void *) asy->asy_dip;
1136 			error = DDI_SUCCESS;
1137 		}
1138 		break;
1139 	case DDI_INFO_DEVT2INSTANCE:
1140 		*result = (void *)(intptr_t)instance;
1141 		error = DDI_SUCCESS;
1142 		break;
1143 	default:
1144 		error = DDI_FAILURE;
1145 	}
1146 	return (error);
1147 }
1148 
1149 /* asy_getproperty -- walk through all name variants until we find a match */
1150 
1151 static int
1152 asy_getproperty(dev_info_t *devi, struct asycom *asy, const char *property)
1153 {
1154 	int len;
1155 	int ret;
1156 	char letter = asy->asy_com_port + 'a' - 1;	/* for ttya */
1157 	char number = asy->asy_com_port + '0';		/* for COM1 */
1158 	char val[40];
1159 	char name[40];
1160 
1161 	/* Property for ignoring DCD */
1162 	(void) sprintf(name, "tty%c-%s", letter, property);
1163 	len = sizeof (val);
1164 	ret = GET_PROP(devi, name, DDI_PROP_CANSLEEP, val, &len);
1165 	if (ret != DDI_PROP_SUCCESS) {
1166 		(void) sprintf(name, "com%c-%s", number, property);
1167 		len = sizeof (val);
1168 		ret = GET_PROP(devi, name, DDI_PROP_CANSLEEP, val, &len);
1169 	}
1170 	if (ret != DDI_PROP_SUCCESS) {
1171 		(void) sprintf(name, "tty0%c-%s", number, property);
1172 		len = sizeof (val);
1173 		ret = GET_PROP(devi, name, DDI_PROP_CANSLEEP, val, &len);
1174 	}
1175 	if (ret != DDI_PROP_SUCCESS) {
1176 		(void) sprintf(name, "port-%c-%s", letter, property);
1177 		len = sizeof (val);
1178 		ret = GET_PROP(devi, name, DDI_PROP_CANSLEEP, val, &len);
1179 	}
1180 	if (ret != DDI_PROP_SUCCESS)
1181 		return (-1);		/* property non-existant */
1182 	if (val[0] == 'f' || val[0] == 'F' || val[0] == '0')
1183 		return (0);		/* property false/0 */
1184 	return (1);			/* property true/!0 */
1185 }
1186 
1187 /* asy_soft_state_free - local wrapper for ddi_soft_state_free(9F) */
1188 
1189 static void
1190 asy_soft_state_free(struct asycom *asy)
1191 {
1192 	mutex_enter(&asy_glob_lock);
1193 	/* If we were the max_asy_instance, work out new value */
1194 	if (asy->asy_unit == max_asy_instance) {
1195 		while (--max_asy_instance >= 0) {
1196 			if (ddi_get_soft_state(asy_soft_state,
1197 			    max_asy_instance) != NULL)
1198 				break;
1199 		}
1200 	}
1201 	mutex_exit(&asy_glob_lock);
1202 
1203 	if (asy->asy_priv != NULL) {
1204 		kmem_free(asy->asy_priv, sizeof (struct asyncline));
1205 		asy->asy_priv = NULL;
1206 	}
1207 	ddi_soft_state_free(asy_soft_state, asy->asy_unit);
1208 }
1209 
1210 static char *
1211 asy_hw_name(struct asycom *asy)
1212 {
1213 	switch (asy->asy_hwtype) {
1214 	case ASY8250A:
1215 		return ("8250A/16450");
1216 	case ASY16550:
1217 		return ("16550");
1218 	case ASY16550A:
1219 		return ("16550A");
1220 	case ASY16650:
1221 		return ("16650");
1222 	case ASY16750:
1223 		return ("16750");
1224 	default:
1225 		DEBUGNOTE2(ASY_DEBUG_INIT,
1226 		    "asy%d: asy_hw_name: unknown asy_hwtype: %d",
1227 		    asy->asy_unit, asy->asy_hwtype);
1228 		return ("?");
1229 	}
1230 }
1231 
1232 static int
1233 asy_identify_chip(dev_info_t *devi, struct asycom *asy)
1234 {
1235 	int ret;
1236 	int mcr;
1237 	dev_t dev;
1238 	uint_t hwtype;
1239 
1240 	if (asy_scr_test) {
1241 		/* Check scratch register works. */
1242 
1243 		/* write to scratch register */
1244 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + SCR, SCRTEST);
1245 		/* make sure that pattern doesn't just linger on the bus */
1246 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + FIFOR, 0x00);
1247 		/* read data back from scratch register */
1248 		ret = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + SCR);
1249 		if (ret != SCRTEST) {
1250 			/*
1251 			 * Scratch register not working.
1252 			 * Probably not an async chip.
1253 			 * 8250 and 8250B don't have scratch registers,
1254 			 * but only worked in ancient PC XT's anyway.
1255 			 */
1256 			cmn_err(CE_CONT, "!asy%d: UART @ %p "
1257 			    "scratch register: expected 0x5a, got 0x%02x\n",
1258 			    asy->asy_unit, (void *)asy->asy_ioaddr, ret);
1259 			return (DDI_FAILURE);
1260 		}
1261 	}
1262 	/*
1263 	 * Use 16550 fifo reset sequence specified in NS application
1264 	 * note. Disable fifos until chip is initialized.
1265 	 */
1266 	ddi_put8(asy->asy_iohandle,
1267 	    asy->asy_ioaddr + FIFOR, 0x00);	/* clear */
1268 	ddi_put8(asy->asy_iohandle,
1269 	    asy->asy_ioaddr + FIFOR, FIFO_ON);	/* enable */
1270 	ddi_put8(asy->asy_iohandle,
1271 	    asy->asy_ioaddr + FIFOR, FIFO_ON | FIFORXFLSH);
1272 						/* reset */
1273 	if (asymaxchip >= ASY16650 && asy_scr_test) {
1274 		/*
1275 		 * Reset 16650 enhanced regs also, in case we have one of these
1276 		 */
1277 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1278 		    EFRACCESS);
1279 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + EFR,
1280 		    0);
1281 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1282 		    STOP1|BITS8);
1283 	}
1284 
1285 	/*
1286 	 * See what sort of FIFO we have.
1287 	 * Try enabling it and see what chip makes of this.
1288 	 */
1289 
1290 	asy->asy_fifor = 0;
1291 	asy->asy_hwtype = asymaxchip; /* just for asy_reset_fifo() */
1292 	if (asymaxchip >= ASY16550A)
1293 		asy->asy_fifor |=
1294 		    FIFO_ON | FIFODMA | (asy_trig_level & 0xff);
1295 	if (asymaxchip >= ASY16650)
1296 		asy->asy_fifor |= FIFOEXTRA1 | FIFOEXTRA2;
1297 
1298 	asy_reset_fifo(asy, FIFOTXFLSH | FIFORXFLSH);
1299 
1300 	mcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MCR);
1301 	ret = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + ISR);
1302 	DEBUGCONT4(ASY_DEBUG_CHIP,
1303 	    "asy%d: probe fifo FIFOR=0x%02x ISR=0x%02x MCR=0x%02x\n",
1304 	    asy->asy_unit, asy->asy_fifor | FIFOTXFLSH | FIFORXFLSH,
1305 	    ret, mcr);
1306 	switch (ret & 0xf0) {
1307 	case 0x40:
1308 		hwtype = ASY16550; /* 16550 with broken FIFO */
1309 		asy->asy_fifor = 0;
1310 		break;
1311 	case 0xc0:
1312 		hwtype = ASY16550A;
1313 		asy->asy_fifo_buf = 16;
1314 		asy->asy_use_fifo = FIFO_ON;
1315 		asy->asy_fifor &= ~(FIFOEXTRA1 | FIFOEXTRA2);
1316 		break;
1317 	case 0xe0:
1318 		hwtype = ASY16650;
1319 		asy->asy_fifo_buf = 32;
1320 		asy->asy_use_fifo = FIFO_ON;
1321 		asy->asy_fifor &= ~(FIFOEXTRA1);
1322 		break;
1323 	case 0xf0:
1324 		/*
1325 		 * Note we get 0xff if chip didn't return us anything,
1326 		 * e.g. if there's no chip there.
1327 		 */
1328 		if (ret == 0xff) {
1329 			cmn_err(CE_CONT, "asy%d: UART @ %p "
1330 			    "interrupt register: got 0xff\n",
1331 			    asy->asy_unit, (void *)asy->asy_ioaddr);
1332 			return (DDI_FAILURE);
1333 		}
1334 		/*FALLTHRU*/
1335 	case 0xd0:
1336 		hwtype = ASY16750;
1337 		asy->asy_fifo_buf = 64;
1338 		asy->asy_use_fifo = FIFO_ON;
1339 		break;
1340 	default:
1341 		hwtype = ASY8250A; /* No FIFO */
1342 		asy->asy_fifor = 0;
1343 	}
1344 
1345 	if (hwtype > asymaxchip) {
1346 		cmn_err(CE_CONT, "asy%d: UART @ %p "
1347 		    "unexpected probe result: "
1348 		    "FIFOR=0x%02x ISR=0x%02x MCR=0x%02x\n",
1349 		    asy->asy_unit, (void *)asy->asy_ioaddr,
1350 		    asy->asy_fifor | FIFOTXFLSH | FIFORXFLSH, ret, mcr);
1351 		return (DDI_FAILURE);
1352 	}
1353 
1354 	/*
1355 	 * Now reset the FIFO operation appropriate for the chip type.
1356 	 * Note we must call asy_reset_fifo() before any possible
1357 	 * downgrade of the asy->asy_hwtype, or it may not disable
1358 	 * the more advanced features we specifically want downgraded.
1359 	 */
1360 	asy_reset_fifo(asy, 0);
1361 	asy->asy_hwtype = hwtype;
1362 
1363 	/*
1364 	 * Check for Exar/Startech ST16C650, which will still look like a
1365 	 * 16550A until we enable its enhanced mode.
1366 	 */
1367 	if (asy->asy_hwtype == ASY16550A && asymaxchip >= ASY16650 &&
1368 	    asy_scr_test) {
1369 		/* Enable enhanced mode register access */
1370 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1371 		    EFRACCESS);
1372 		/* zero scratch register (not scratch register if enhanced) */
1373 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + SCR, 0);
1374 		/* Disable enhanced mode register access */
1375 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1376 		    STOP1|BITS8);
1377 		/* read back scratch register */
1378 		ret = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + SCR);
1379 		if (ret == SCRTEST) {
1380 			/* looks like we have an ST16650 -- enable it */
1381 			ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1382 			    EFRACCESS);
1383 			ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + EFR,
1384 			    ENHENABLE);
1385 			ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1386 			    STOP1|BITS8);
1387 			asy->asy_hwtype = ASY16650;
1388 			asy->asy_fifo_buf = 32;
1389 			asy->asy_fifor |= 0x10; /* 24 byte txfifo trigger */
1390 			asy_reset_fifo(asy, 0);
1391 		}
1392 	}
1393 
1394 	/*
1395 	 * If we think we might have a FIFO larger than 16 characters,
1396 	 * measure FIFO size and check it against expected.
1397 	 */
1398 	if (asy_fifo_test > 0 &&
1399 	    !(asy->asy_flags2 & ASY2_NO_LOOPBACK) &&
1400 	    (asy->asy_fifo_buf > 16 ||
1401 	    (asy_fifo_test > 1 && asy->asy_use_fifo == FIFO_ON) ||
1402 	    ASY_DEBUG(ASY_DEBUG_CHIP))) {
1403 		int i;
1404 
1405 		/* Set baud rate to 57600 (fairly arbitrary choice) */
1406 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1407 		    DLAB);
1408 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT,
1409 		    asyspdtab[B57600] & 0xff);
1410 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR,
1411 		    (asyspdtab[B57600] >> 8) & 0xff);
1412 		/* Set 8 bits, 1 stop bit */
1413 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1414 		    STOP1|BITS8);
1415 		/* Set loopback mode */
1416 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
1417 		    DTR | RTS | ASY_LOOP | OUT1 | OUT2);
1418 
1419 		/* Overfill fifo */
1420 		for (i = 0; i < asy->asy_fifo_buf * 2; i++) {
1421 			ddi_put8(asy->asy_iohandle,
1422 			    asy->asy_ioaddr + DAT, i);
1423 		}
1424 		/*
1425 		 * Now there's an interesting question here about which
1426 		 * FIFO we're testing the size of, RX or TX. We just
1427 		 * filled the TX FIFO much faster than it can empty,
1428 		 * although it is possible one or two characters may
1429 		 * have gone from it to the TX shift register.
1430 		 * We wait for enough time for all the characters to
1431 		 * move into the RX FIFO and any excess characters to
1432 		 * have been lost, and then read all the RX FIFO. So
1433 		 * the answer we finally get will be the size which is
1434 		 * the MIN(RX FIFO,(TX FIFO + 1 or 2)). The critical
1435 		 * one is actually the TX FIFO, because if we overfill
1436 		 * it in normal operation, the excess characters are
1437 		 * lost with no warning.
1438 		 */
1439 		/*
1440 		 * Wait for characters to move into RX FIFO.
1441 		 * In theory, 200 * asy->asy_fifo_buf * 2 should be
1442 		 * enough. However, in practice it isn't always, so we
1443 		 * increase to 400 so some slow 16550A's finish, and we
1444 		 * increase to 3 so we spot more characters coming back
1445 		 * than we sent, in case that should ever happen.
1446 		 */
1447 		delay(drv_usectohz(400 * asy->asy_fifo_buf * 3));
1448 
1449 		/* Now see how many characters we can read back */
1450 		for (i = 0; i < asy->asy_fifo_buf * 3; i++) {
1451 			ret = ddi_get8(asy->asy_iohandle,
1452 			    asy->asy_ioaddr + LSR);
1453 			if (!(ret & RCA))
1454 				break;	/* FIFO emptied */
1455 			(void) ddi_get8(asy->asy_iohandle,
1456 			    asy->asy_ioaddr + DAT); /* lose another */
1457 		}
1458 
1459 		DEBUGCONT3(ASY_DEBUG_CHIP,
1460 		    "asy%d FIFO size: expected=%d, measured=%d\n",
1461 		    asy->asy_unit, asy->asy_fifo_buf, i);
1462 
1463 		hwtype = asy->asy_hwtype;
1464 		if (i < asy->asy_fifo_buf) {
1465 			/*
1466 			 * FIFO is somewhat smaller than we anticipated.
1467 			 * If we have 16 characters usable, then this
1468 			 * UART will probably work well enough in
1469 			 * 16550A mode. If less than 16 characters,
1470 			 * then we'd better not use it at all.
1471 			 * UARTs with busted FIFOs do crop up.
1472 			 */
1473 			if (i >= 16 && asy->asy_fifo_buf >= 16) {
1474 				/* fall back to a 16550A */
1475 				hwtype = ASY16550A;
1476 				asy->asy_fifo_buf = 16;
1477 				asy->asy_fifor &= ~(FIFOEXTRA1 | FIFOEXTRA2);
1478 			} else {
1479 				/* fall back to no FIFO at all */
1480 				hwtype = ASY16550;
1481 				asy->asy_fifo_buf = 1;
1482 				asy->asy_use_fifo = FIFO_OFF;
1483 				asy->asy_fifor &=
1484 				    ~(FIFO_ON | FIFOEXTRA1 | FIFOEXTRA2);
1485 			}
1486 		}
1487 		/*
1488 		 * We will need to reprogram the FIFO if we changed
1489 		 * our mind about how to drive it above, and in any
1490 		 * case, it would be a good idea to flush any garbage
1491 		 * out incase the loopback test left anything behind.
1492 		 * Again as earlier above, we must call asy_reset_fifo()
1493 		 * before any possible downgrade of asy->asy_hwtype.
1494 		 */
1495 		if (asy->asy_hwtype >= ASY16650 && hwtype < ASY16650) {
1496 			/* Disable 16650 enhanced mode */
1497 			ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1498 			    EFRACCESS);
1499 			ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + EFR,
1500 			    0);
1501 			ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1502 			    STOP1|BITS8);
1503 		}
1504 		asy_reset_fifo(asy, FIFOTXFLSH | FIFORXFLSH);
1505 		asy->asy_hwtype = hwtype;
1506 
1507 		/* Clear loopback mode and restore DTR/RTS */
1508 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR, mcr);
1509 	}
1510 
1511 	DEBUGNOTE3(ASY_DEBUG_CHIP, "asy%d %s @ %p",
1512 	    asy->asy_unit, asy_hw_name(asy), (void *)asy->asy_ioaddr);
1513 
1514 	/* Make UART type visible in device tree for prtconf, etc */
1515 	dev = makedevice(DDI_MAJOR_T_UNKNOWN, asy->asy_unit);
1516 	(void) ddi_prop_update_string(dev, devi, "uart", asy_hw_name(asy));
1517 
1518 	if (asy->asy_hwtype == ASY16550)	/* for broken 16550's, */
1519 		asy->asy_hwtype = ASY8250A;	/* drive them as 8250A */
1520 
1521 	return (DDI_SUCCESS);
1522 }
1523 
1524 /*
1525  * asyinit() initializes the TTY protocol-private data for this channel
1526  * before enabling the interrupts.
1527  */
1528 static void
1529 asyinit(struct asycom *asy)
1530 {
1531 	struct asyncline *async;
1532 
1533 	asy->asy_priv = kmem_zalloc(sizeof (struct asyncline), KM_SLEEP);
1534 	async = asy->asy_priv;
1535 	mutex_enter(&asy->asy_excl);
1536 	async->async_common = asy;
1537 	cv_init(&async->async_flags_cv, NULL, CV_DRIVER, NULL);
1538 	mutex_exit(&asy->asy_excl);
1539 }
1540 
1541 /*ARGSUSED3*/
1542 static int
1543 asyopen(queue_t *rq, dev_t *dev, int flag, int sflag, cred_t *cr)
1544 {
1545 	struct asycom	*asy;
1546 	struct asyncline *async;
1547 	int		mcr;
1548 	int		unit;
1549 	int 		len;
1550 	struct termios 	*termiosp;
1551 
1552 	unit = UNIT(*dev);
1553 	DEBUGCONT1(ASY_DEBUG_CLOSE, "asy%dopen\n", unit);
1554 	asy = ddi_get_soft_state(asy_soft_state, unit);
1555 	if (asy == NULL)
1556 		return (ENXIO);		/* unit not configured */
1557 	async = asy->asy_priv;
1558 	mutex_enter(&asy->asy_excl);
1559 
1560 again:
1561 	mutex_enter(&asy->asy_excl_hi);
1562 
1563 	/*
1564 	 * Block waiting for carrier to come up, unless this is a no-delay open.
1565 	 */
1566 	if (!(async->async_flags & ASYNC_ISOPEN)) {
1567 		/*
1568 		 * Set the default termios settings (cflag).
1569 		 * Others are set in ldterm.
1570 		 */
1571 		mutex_exit(&asy->asy_excl_hi);
1572 
1573 		if (ddi_getlongprop(DDI_DEV_T_ANY, ddi_root_node(),
1574 		    0, "ttymodes",
1575 		    (caddr_t)&termiosp, &len) == DDI_PROP_SUCCESS &&
1576 		    len == sizeof (struct termios)) {
1577 			async->async_ttycommon.t_cflag = termiosp->c_cflag;
1578 			kmem_free(termiosp, len);
1579 		} else
1580 			cmn_err(CE_WARN,
1581 			    "asy: couldn't get ttymodes property!");
1582 		mutex_enter(&asy->asy_excl_hi);
1583 
1584 		/* eeprom mode support - respect properties */
1585 		if (asy->asy_cflag)
1586 			async->async_ttycommon.t_cflag = asy->asy_cflag;
1587 
1588 		async->async_ttycommon.t_iflag = 0;
1589 		async->async_ttycommon.t_iocpending = NULL;
1590 		async->async_ttycommon.t_size.ws_row = 0;
1591 		async->async_ttycommon.t_size.ws_col = 0;
1592 		async->async_ttycommon.t_size.ws_xpixel = 0;
1593 		async->async_ttycommon.t_size.ws_ypixel = 0;
1594 		async->async_dev = *dev;
1595 		async->async_wbufcid = 0;
1596 
1597 		async->async_startc = CSTART;
1598 		async->async_stopc = CSTOP;
1599 		asy_program(asy, ASY_INIT);
1600 	} else
1601 		if ((async->async_ttycommon.t_flags & TS_XCLUDE) &&
1602 		    secpolicy_excl_open(cr) != 0) {
1603 		mutex_exit(&asy->asy_excl_hi);
1604 		mutex_exit(&asy->asy_excl);
1605 		return (EBUSY);
1606 	} else if ((*dev & OUTLINE) && !(async->async_flags & ASYNC_OUT)) {
1607 		mutex_exit(&asy->asy_excl_hi);
1608 		mutex_exit(&asy->asy_excl);
1609 		return (EBUSY);
1610 	}
1611 
1612 	if (*dev & OUTLINE)
1613 		async->async_flags |= ASYNC_OUT;
1614 
1615 	/* Raise DTR on every open, but delay if it was just lowered. */
1616 	while (async->async_flags & ASYNC_DTR_DELAY) {
1617 		DEBUGCONT1(ASY_DEBUG_MODEM,
1618 		    "asy%dopen: waiting for the ASYNC_DTR_DELAY to be clear\n",
1619 		    unit);
1620 		mutex_exit(&asy->asy_excl_hi);
1621 		if (cv_wait_sig(&async->async_flags_cv,
1622 		    &asy->asy_excl) == 0) {
1623 			DEBUGCONT1(ASY_DEBUG_MODEM,
1624 			    "asy%dopen: interrupted by signal, exiting\n",
1625 			    unit);
1626 			mutex_exit(&asy->asy_excl);
1627 			return (EINTR);
1628 		}
1629 		mutex_enter(&asy->asy_excl_hi);
1630 	}
1631 
1632 	mcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MCR);
1633 	ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
1634 	    mcr|(asy->asy_mcr&DTR));
1635 
1636 	DEBUGCONT3(ASY_DEBUG_INIT,
1637 	    "asy%dopen: \"Raise DTR on every open\": make mcr = %x, "
1638 	    "make TS_SOFTCAR = %s\n",
1639 	    unit, mcr|(asy->asy_mcr&DTR),
1640 	    (asy->asy_flags & ASY_IGNORE_CD) ? "ON" : "OFF");
1641 
1642 	if (asy->asy_flags & ASY_IGNORE_CD) {
1643 		DEBUGCONT1(ASY_DEBUG_MODEM,
1644 		    "asy%dopen: ASY_IGNORE_CD set, set TS_SOFTCAR\n",
1645 		    unit);
1646 		async->async_ttycommon.t_flags |= TS_SOFTCAR;
1647 	}
1648 	else
1649 		async->async_ttycommon.t_flags &= ~TS_SOFTCAR;
1650 
1651 	/*
1652 	 * Check carrier.
1653 	 */
1654 	asy->asy_msr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MSR);
1655 	DEBUGCONT3(ASY_DEBUG_INIT, "asy%dopen: TS_SOFTCAR is %s, "
1656 	    "MSR & DCD is %s\n",
1657 	    unit,
1658 	    (async->async_ttycommon.t_flags & TS_SOFTCAR) ? "set" : "clear",
1659 	    (asy->asy_msr & DCD) ? "set" : "clear");
1660 
1661 	if (asy->asy_msr & DCD)
1662 		async->async_flags |= ASYNC_CARR_ON;
1663 	else
1664 		async->async_flags &= ~ASYNC_CARR_ON;
1665 	mutex_exit(&asy->asy_excl_hi);
1666 
1667 	/*
1668 	 * If FNDELAY and FNONBLOCK are clear, block until carrier up.
1669 	 * Quit on interrupt.
1670 	 */
1671 	if (!(flag & (FNDELAY|FNONBLOCK)) &&
1672 	    !(async->async_ttycommon.t_cflag & CLOCAL)) {
1673 		if ((!(async->async_flags & (ASYNC_CARR_ON|ASYNC_OUT)) &&
1674 		    !(async->async_ttycommon.t_flags & TS_SOFTCAR)) ||
1675 		    ((async->async_flags & ASYNC_OUT) &&
1676 		    !(*dev & OUTLINE))) {
1677 			async->async_flags |= ASYNC_WOPEN;
1678 			if (cv_wait_sig(&async->async_flags_cv,
1679 			    &asy->asy_excl) == B_FALSE) {
1680 				async->async_flags &= ~ASYNC_WOPEN;
1681 				mutex_exit(&asy->asy_excl);
1682 				return (EINTR);
1683 			}
1684 			async->async_flags &= ~ASYNC_WOPEN;
1685 			goto again;
1686 		}
1687 	} else if ((async->async_flags & ASYNC_OUT) && !(*dev & OUTLINE)) {
1688 		mutex_exit(&asy->asy_excl);
1689 		return (EBUSY);
1690 	}
1691 
1692 	async->async_ttycommon.t_readq = rq;
1693 	async->async_ttycommon.t_writeq = WR(rq);
1694 	rq->q_ptr = WR(rq)->q_ptr = (caddr_t)async;
1695 	mutex_exit(&asy->asy_excl);
1696 	/*
1697 	 * Caution here -- qprocson sets the pointers that are used by canput
1698 	 * called by async_softint.  ASYNC_ISOPEN must *not* be set until those
1699 	 * pointers are valid.
1700 	 */
1701 	qprocson(rq);
1702 	async->async_flags |= ASYNC_ISOPEN;
1703 	async->async_polltid = 0;
1704 	DEBUGCONT1(ASY_DEBUG_INIT, "asy%dopen: done\n", unit);
1705 	return (0);
1706 }
1707 
1708 static void
1709 async_progress_check(void *arg)
1710 {
1711 	struct asyncline *async = arg;
1712 	struct asycom	 *asy = async->async_common;
1713 	mblk_t *bp;
1714 
1715 	/*
1716 	 * We define "progress" as either waiting on a timed break or delay, or
1717 	 * having had at least one transmitter interrupt.  If none of these are
1718 	 * true, then just terminate the output and wake up that close thread.
1719 	 */
1720 	mutex_enter(&asy->asy_excl);
1721 	mutex_enter(&asy->asy_excl_hi);
1722 	if (!(async->async_flags & (ASYNC_BREAK|ASYNC_DELAY|ASYNC_PROGRESS))) {
1723 		async->async_ocnt = 0;
1724 		async->async_flags &= ~ASYNC_BUSY;
1725 		async->async_timer = 0;
1726 		bp = async->async_xmitblk;
1727 		async->async_xmitblk = NULL;
1728 		mutex_exit(&asy->asy_excl_hi);
1729 		if (bp != NULL)
1730 			freeb(bp);
1731 		/*
1732 		 * Since this timer is running, we know that we're in exit(2).
1733 		 * That means that the user can't possibly be waiting on any
1734 		 * valid ioctl(2) completion anymore, and we should just flush
1735 		 * everything.
1736 		 */
1737 		flushq(async->async_ttycommon.t_writeq, FLUSHALL);
1738 		cv_broadcast(&async->async_flags_cv);
1739 	} else {
1740 		async->async_flags &= ~ASYNC_PROGRESS;
1741 		async->async_timer = timeout(async_progress_check, async,
1742 		    drv_usectohz(asy_drain_check));
1743 		mutex_exit(&asy->asy_excl_hi);
1744 	}
1745 	mutex_exit(&asy->asy_excl);
1746 }
1747 
1748 /*
1749  * Release DTR so that asyopen() can raise it.
1750  */
1751 static void
1752 async_dtr_free(struct asyncline *async)
1753 {
1754 	struct asycom *asy = async->async_common;
1755 
1756 	DEBUGCONT0(ASY_DEBUG_MODEM,
1757 	    "async_dtr_free, clearing ASYNC_DTR_DELAY\n");
1758 	mutex_enter(&asy->asy_excl);
1759 	async->async_flags &= ~ASYNC_DTR_DELAY;
1760 	async->async_dtrtid = 0;
1761 	cv_broadcast(&async->async_flags_cv);
1762 	mutex_exit(&asy->asy_excl);
1763 }
1764 
1765 /*
1766  * Close routine.
1767  */
1768 /*ARGSUSED2*/
1769 static int
1770 asyclose(queue_t *q, int flag, cred_t *credp)
1771 {
1772 	struct asyncline *async;
1773 	struct asycom	 *asy;
1774 	int icr, lcr;
1775 #ifdef DEBUG
1776 	int instance;
1777 #endif
1778 
1779 	async = (struct asyncline *)q->q_ptr;
1780 	ASSERT(async != NULL);
1781 #ifdef DEBUG
1782 	instance = UNIT(async->async_dev);
1783 	DEBUGCONT1(ASY_DEBUG_CLOSE, "asy%dclose\n", instance);
1784 #endif
1785 	asy = async->async_common;
1786 
1787 	mutex_enter(&asy->asy_excl);
1788 	async->async_flags |= ASYNC_CLOSING;
1789 
1790 	/*
1791 	 * Turn off PPS handling early to avoid events occuring during
1792 	 * close.  Also reset the DCD edge monitoring bit.
1793 	 */
1794 	mutex_enter(&asy->asy_excl_hi);
1795 	asy->asy_flags &= ~(ASY_PPS | ASY_PPS_EDGE);
1796 	mutex_exit(&asy->asy_excl_hi);
1797 
1798 	/*
1799 	 * There are two flavors of break -- timed (M_BREAK or TCSBRK) and
1800 	 * untimed (TIOCSBRK).  For the timed case, these are enqueued on our
1801 	 * write queue and there's a timer running, so we don't have to worry
1802 	 * about them.  For the untimed case, though, the user obviously made a
1803 	 * mistake, because these are handled immediately.  We'll terminate the
1804 	 * break now and honor his implicit request by discarding the rest of
1805 	 * the data.
1806 	 */
1807 	if (async->async_flags & ASYNC_OUT_SUSPEND) {
1808 		if (async->async_utbrktid != 0) {
1809 			(void) untimeout(async->async_utbrktid);
1810 			async->async_utbrktid = 0;
1811 		}
1812 		mutex_enter(&asy->asy_excl_hi);
1813 		lcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
1814 		ddi_put8(asy->asy_iohandle,
1815 		    asy->asy_ioaddr + LCR, (lcr & ~SETBREAK));
1816 		mutex_exit(&asy->asy_excl_hi);
1817 		async->async_flags &= ~ASYNC_OUT_SUSPEND;
1818 		goto nodrain;
1819 	}
1820 
1821 	/*
1822 	 * If the user told us not to delay the close ("non-blocking"), then
1823 	 * don't bother trying to drain.
1824 	 *
1825 	 * If the user did M_STOP (ASYNC_STOPPED), there's no hope of ever
1826 	 * getting an M_START (since these messages aren't enqueued), and the
1827 	 * only other way to clear the stop condition is by loss of DCD, which
1828 	 * would discard the queue data.  Thus, we drop the output data if
1829 	 * ASYNC_STOPPED is set.
1830 	 */
1831 	if ((flag & (FNDELAY|FNONBLOCK)) ||
1832 	    (async->async_flags & ASYNC_STOPPED)) {
1833 		goto nodrain;
1834 	}
1835 
1836 	/*
1837 	 * If there's any pending output, then we have to try to drain it.
1838 	 * There are two main cases to be handled:
1839 	 *	- called by close(2): need to drain until done or until
1840 	 *	  a signal is received.  No timeout.
1841 	 *	- called by exit(2): need to drain while making progress
1842 	 *	  or until a timeout occurs.  No signals.
1843 	 *
1844 	 * If we can't rely on receiving a signal to get us out of a hung
1845 	 * session, then we have to use a timer.  In this case, we set a timer
1846 	 * to check for progress in sending the output data -- all that we ask
1847 	 * (at each interval) is that there's been some progress made.  Since
1848 	 * the interrupt routine grabs buffers from the write queue, we can't
1849 	 * trust changes in async_ocnt.  Instead, we use a progress flag.
1850 	 *
1851 	 * Note that loss of carrier will cause the output queue to be flushed,
1852 	 * and we'll wake up again and finish normally.
1853 	 */
1854 	if (!ddi_can_receive_sig() && asy_drain_check != 0) {
1855 		async->async_flags &= ~ASYNC_PROGRESS;
1856 		async->async_timer = timeout(async_progress_check, async,
1857 		    drv_usectohz(asy_drain_check));
1858 	}
1859 	while (async->async_ocnt > 0 ||
1860 	    async->async_ttycommon.t_writeq->q_first != NULL ||
1861 	    (async->async_flags & (ASYNC_BUSY|ASYNC_BREAK|ASYNC_DELAY))) {
1862 		if (cv_wait_sig(&async->async_flags_cv, &asy->asy_excl) == 0)
1863 			break;
1864 	}
1865 	if (async->async_timer != 0) {
1866 		(void) untimeout(async->async_timer);
1867 		async->async_timer = 0;
1868 	}
1869 
1870 nodrain:
1871 	async->async_ocnt = 0;
1872 	if (async->async_xmitblk != NULL)
1873 		freeb(async->async_xmitblk);
1874 	async->async_xmitblk = NULL;
1875 
1876 	/*
1877 	 * If line has HUPCL set or is incompletely opened fix up the modem
1878 	 * lines.
1879 	 */
1880 	DEBUGCONT1(ASY_DEBUG_MODEM, "asy%dclose: next check HUPCL flag\n",
1881 	    instance);
1882 	mutex_enter(&asy->asy_excl_hi);
1883 	if ((async->async_ttycommon.t_cflag & HUPCL) ||
1884 	    (async->async_flags & ASYNC_WOPEN)) {
1885 		DEBUGCONT3(ASY_DEBUG_MODEM,
1886 		    "asy%dclose: HUPCL flag = %x, ASYNC_WOPEN flag = %x\n",
1887 		    instance,
1888 		    async->async_ttycommon.t_cflag & HUPCL,
1889 		    async->async_ttycommon.t_cflag & ASYNC_WOPEN);
1890 		async->async_flags |= ASYNC_DTR_DELAY;
1891 
1892 		/* turn off DTR, RTS but NOT interrupt to 386 */
1893 		if (asy->asy_flags & (ASY_IGNORE_CD|ASY_RTS_DTR_OFF)) {
1894 			DEBUGCONT3(ASY_DEBUG_MODEM,
1895 			    "asy%dclose: ASY_IGNORE_CD flag = %x, "
1896 			    "ASY_RTS_DTR_OFF flag = %x\n",
1897 			    instance,
1898 			    asy->asy_flags & ASY_IGNORE_CD,
1899 			    asy->asy_flags & ASY_RTS_DTR_OFF);
1900 
1901 			ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
1902 			    asy->asy_mcr|OUT2);
1903 		} else {
1904 			DEBUGCONT1(ASY_DEBUG_MODEM,
1905 			    "asy%dclose: Dropping DTR and RTS\n", instance);
1906 			ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
1907 			    OUT2);
1908 		}
1909 		async->async_dtrtid =
1910 		    timeout((void (*)())async_dtr_free,
1911 		    (caddr_t)async, drv_usectohz(asy_min_dtr_low));
1912 	}
1913 	/*
1914 	 * If nobody's using it now, turn off receiver interrupts.
1915 	 */
1916 	if ((async->async_flags & (ASYNC_WOPEN|ASYNC_ISOPEN)) == 0) {
1917 		icr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + ICR);
1918 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR,
1919 		    (icr & ~RIEN));
1920 	}
1921 	mutex_exit(&asy->asy_excl_hi);
1922 out:
1923 	ttycommon_close(&async->async_ttycommon);
1924 
1925 	/*
1926 	 * Cancel outstanding "bufcall" request.
1927 	 */
1928 	if (async->async_wbufcid != 0) {
1929 		unbufcall(async->async_wbufcid);
1930 		async->async_wbufcid = 0;
1931 	}
1932 
1933 	/* Note that qprocsoff can't be done until after interrupts are off */
1934 	qprocsoff(q);
1935 	q->q_ptr = WR(q)->q_ptr = NULL;
1936 	async->async_ttycommon.t_readq = NULL;
1937 	async->async_ttycommon.t_writeq = NULL;
1938 
1939 	/*
1940 	 * Clear out device state, except persistant device property flags.
1941 	 */
1942 	async->async_flags &= (ASYNC_DTR_DELAY|ASY_RTS_DTR_OFF);
1943 	cv_broadcast(&async->async_flags_cv);
1944 	mutex_exit(&asy->asy_excl);
1945 
1946 	DEBUGCONT1(ASY_DEBUG_CLOSE, "asy%dclose: done\n", instance);
1947 	return (0);
1948 }
1949 
1950 static boolean_t
1951 asy_isbusy(struct asycom *asy)
1952 {
1953 	struct asyncline *async;
1954 
1955 	DEBUGCONT0(ASY_DEBUG_EOT, "asy_isbusy\n");
1956 	async = asy->asy_priv;
1957 	ASSERT(mutex_owned(&asy->asy_excl));
1958 	ASSERT(mutex_owned(&asy->asy_excl_hi));
1959 /*
1960  * XXXX this should be recoded
1961  */
1962 	return ((async->async_ocnt > 0) ||
1963 	    ((ddi_get8(asy->asy_iohandle,
1964 	    asy->asy_ioaddr + LSR) & (XSRE|XHRE)) == 0));
1965 }
1966 
1967 static void
1968 asy_waiteot(struct asycom *asy)
1969 {
1970 	/*
1971 	 * Wait for the current transmission block and the
1972 	 * current fifo data to transmit. Once this is done
1973 	 * we may go on.
1974 	 */
1975 	DEBUGCONT0(ASY_DEBUG_EOT, "asy_waiteot\n");
1976 	ASSERT(mutex_owned(&asy->asy_excl));
1977 	ASSERT(mutex_owned(&asy->asy_excl_hi));
1978 	while (asy_isbusy(asy)) {
1979 		mutex_exit(&asy->asy_excl_hi);
1980 		mutex_exit(&asy->asy_excl);
1981 		drv_usecwait(10000);		/* wait .01 */
1982 		mutex_enter(&asy->asy_excl);
1983 		mutex_enter(&asy->asy_excl_hi);
1984 	}
1985 }
1986 
1987 /* asy_reset_fifo -- flush fifos and [re]program fifo control register */
1988 static void
1989 asy_reset_fifo(struct asycom *asy, uchar_t flush)
1990 {
1991 	uchar_t lcr;
1992 
1993 	/* On a 16750, we have to set DLAB in order to set FIFOEXTRA. */
1994 
1995 	if (asy->asy_hwtype >= ASY16750) {
1996 		lcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
1997 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1998 		    lcr | DLAB);
1999 	}
2000 
2001 	ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + FIFOR,
2002 	    asy->asy_fifor | flush);
2003 
2004 	/* Clear DLAB */
2005 
2006 	if (asy->asy_hwtype >= ASY16750) {
2007 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, lcr);
2008 	}
2009 }
2010 
2011 /*
2012  * Program the ASY port. Most of the async operation is based on the values
2013  * of 'c_iflag' and 'c_cflag'.
2014  */
2015 
2016 #define	BAUDINDEX(cflg)	(((cflg) & CBAUDEXT) ? \
2017 			(((cflg) & CBAUD) + CBAUD + 1) : ((cflg) & CBAUD))
2018 
2019 static void
2020 asy_program(struct asycom *asy, int mode)
2021 {
2022 	struct asyncline *async;
2023 	int baudrate, c_flag;
2024 	int icr, lcr;
2025 	int flush_reg;
2026 	int ocflags;
2027 #ifdef DEBUG
2028 	int instance;
2029 #endif
2030 
2031 	ASSERT(mutex_owned(&asy->asy_excl));
2032 	ASSERT(mutex_owned(&asy->asy_excl_hi));
2033 
2034 	async = asy->asy_priv;
2035 #ifdef DEBUG
2036 	instance = UNIT(async->async_dev);
2037 	DEBUGCONT2(ASY_DEBUG_PROCS,
2038 	    "asy%d_program: mode = 0x%08X, enter\n", instance, mode);
2039 #endif
2040 
2041 	baudrate = BAUDINDEX(async->async_ttycommon.t_cflag);
2042 
2043 	async->async_ttycommon.t_cflag &= ~(CIBAUD);
2044 
2045 	if (baudrate > CBAUD) {
2046 		async->async_ttycommon.t_cflag |= CIBAUDEXT;
2047 		async->async_ttycommon.t_cflag |=
2048 		    (((baudrate - CBAUD - 1) << IBSHIFT) & CIBAUD);
2049 	} else {
2050 		async->async_ttycommon.t_cflag &= ~CIBAUDEXT;
2051 		async->async_ttycommon.t_cflag |=
2052 		    ((baudrate << IBSHIFT) & CIBAUD);
2053 	}
2054 
2055 	c_flag = async->async_ttycommon.t_cflag &
2056 	    (CLOCAL|CREAD|CSTOPB|CSIZE|PARENB|PARODD|CBAUD|CBAUDEXT);
2057 
2058 	/* disable interrupts */
2059 	ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
2060 
2061 	ocflags = asy->asy_ocflag;
2062 
2063 	/* flush/reset the status registers */
2064 	(void) ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + ISR);
2065 	(void) ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR);
2066 	asy->asy_msr = flush_reg = ddi_get8(asy->asy_iohandle,
2067 	    asy->asy_ioaddr + MSR);
2068 	/*
2069 	 * The device is programmed in the open sequence, if we
2070 	 * have to hardware handshake, then this is a good time
2071 	 * to check if the device can receive any data.
2072 	 */
2073 
2074 	if ((CRTSCTS & async->async_ttycommon.t_cflag) && !(flush_reg & CTS)) {
2075 		async_flowcontrol_hw_output(asy, FLOW_STOP);
2076 	} else {
2077 		/*
2078 		 * We can not use async_flowcontrol_hw_output(asy, FLOW_START)
2079 		 * here, because if CRTSCTS is clear, we need clear
2080 		 * ASYNC_HW_OUT_FLW bit.
2081 		 */
2082 		async->async_flags &= ~ASYNC_HW_OUT_FLW;
2083 	}
2084 
2085 	/*
2086 	 * If IXON is not set, clear ASYNC_SW_OUT_FLW;
2087 	 * If IXON is set, no matter what IXON flag is before this
2088 	 * function call to asy_program,
2089 	 * we will use the old ASYNC_SW_OUT_FLW status.
2090 	 * Because of handling IXON in the driver, we also should re-calculate
2091 	 * the value of ASYNC_OUT_FLW_RESUME bit, but in fact,
2092 	 * the TCSET* commands which call asy_program
2093 	 * are put into the write queue, so there is no output needed to
2094 	 * be resumed at this point.
2095 	 */
2096 	if (!(IXON & async->async_ttycommon.t_iflag))
2097 		async->async_flags &= ~ASYNC_SW_OUT_FLW;
2098 
2099 	/* manually flush receive buffer or fifo (workaround for buggy fifos) */
2100 	if (mode == ASY_INIT)
2101 		if (asy->asy_use_fifo == FIFO_ON) {
2102 			for (flush_reg = asy->asy_fifo_buf; flush_reg-- > 0; ) {
2103 				(void) ddi_get8(asy->asy_iohandle,
2104 				    asy->asy_ioaddr + DAT);
2105 			}
2106 		} else {
2107 			flush_reg = ddi_get8(asy->asy_iohandle,
2108 			    asy->asy_ioaddr + DAT);
2109 		}
2110 
2111 	if (ocflags != (c_flag & ~CLOCAL) || mode == ASY_INIT) {
2112 		/* Set line control */
2113 		lcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
2114 		lcr &= ~(WLS0|WLS1|STB|PEN|EPS);
2115 
2116 		if (c_flag & CSTOPB)
2117 			lcr |= STB;	/* 2 stop bits */
2118 
2119 		if (c_flag & PARENB)
2120 			lcr |= PEN;
2121 
2122 		if ((c_flag & PARODD) == 0)
2123 			lcr |= EPS;
2124 
2125 		switch (c_flag & CSIZE) {
2126 		case CS5:
2127 			lcr |= BITS5;
2128 			break;
2129 		case CS6:
2130 			lcr |= BITS6;
2131 			break;
2132 		case CS7:
2133 			lcr |= BITS7;
2134 			break;
2135 		case CS8:
2136 			lcr |= BITS8;
2137 			break;
2138 		}
2139 
2140 		/* set the baud rate, unless it is "0" */
2141 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, DLAB);
2142 
2143 		if (baudrate != 0) {
2144 			ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT,
2145 			    asyspdtab[baudrate] & 0xff);
2146 			ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR,
2147 			    (asyspdtab[baudrate] >> 8) & 0xff);
2148 		}
2149 		/* set the line control modes */
2150 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, lcr);
2151 
2152 		/*
2153 		 * If we have a FIFO buffer, enable/flush
2154 		 * at intialize time, flush if transitioning from
2155 		 * CREAD off to CREAD on.
2156 		 */
2157 		if ((ocflags & CREAD) == 0 && (c_flag & CREAD) ||
2158 		    mode == ASY_INIT)
2159 			if (asy->asy_use_fifo == FIFO_ON)
2160 				asy_reset_fifo(asy, FIFORXFLSH);
2161 
2162 		/* remember the new cflags */
2163 		asy->asy_ocflag = c_flag & ~CLOCAL;
2164 	}
2165 
2166 	if (baudrate == 0)
2167 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
2168 		    (asy->asy_mcr & RTS) | OUT2);
2169 	else
2170 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
2171 		    asy->asy_mcr | OUT2);
2172 
2173 	/*
2174 	 * Call the modem status interrupt handler to check for the carrier
2175 	 * in case CLOCAL was turned off after the carrier came on.
2176 	 * (Note: Modem status interrupt is not enabled if CLOCAL is ON.)
2177 	 */
2178 	async_msint(asy);
2179 
2180 	/* Set interrupt control */
2181 	DEBUGCONT3(ASY_DEBUG_MODM2,
2182 	    "asy%d_program: c_flag & CLOCAL = %x t_cflag & CRTSCTS = %x\n",
2183 	    instance, c_flag & CLOCAL,
2184 	    async->async_ttycommon.t_cflag & CRTSCTS);
2185 
2186 	if ((c_flag & CLOCAL) && !(async->async_ttycommon.t_cflag & CRTSCTS))
2187 		/*
2188 		 * direct-wired line ignores DCD, so we don't enable modem
2189 		 * status interrupts.
2190 		 */
2191 		icr = (TIEN | SIEN);
2192 	else
2193 		icr = (TIEN | SIEN | MIEN);
2194 
2195 	if (c_flag & CREAD)
2196 		icr |= RIEN;
2197 
2198 	ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, icr);
2199 	DEBUGCONT1(ASY_DEBUG_PROCS, "asy%d_program: done\n", instance);
2200 }
2201 
2202 static boolean_t
2203 asy_baudok(struct asycom *asy)
2204 {
2205 	struct asyncline *async = asy->asy_priv;
2206 	int baudrate;
2207 
2208 
2209 	baudrate = BAUDINDEX(async->async_ttycommon.t_cflag);
2210 
2211 	if (baudrate >= sizeof (asyspdtab)/sizeof (*asyspdtab))
2212 		return (0);
2213 
2214 	return (baudrate == 0 || asyspdtab[baudrate]);
2215 }
2216 
2217 /*
2218  * asyintr() is the High Level Interrupt Handler.
2219  *
2220  * There are four different interrupt types indexed by ISR register values:
2221  *		0: modem
2222  *		1: Tx holding register is empty, ready for next char
2223  *		2: Rx register now holds a char to be picked up
2224  *		3: error or break on line
2225  * This routine checks the Bit 0 (interrupt-not-pending) to determine if
2226  * the interrupt is from this port.
2227  */
2228 uint_t
2229 asyintr(caddr_t argasy)
2230 {
2231 	struct asycom		*asy = (struct asycom *)argasy;
2232 	struct asyncline	*async;
2233 	int			ret_status = DDI_INTR_UNCLAIMED;
2234 	uchar_t			interrupt_id, lsr;
2235 
2236 	interrupt_id = ddi_get8(asy->asy_iohandle,
2237 	    asy->asy_ioaddr + ISR) & 0x0F;
2238 	async = asy->asy_priv;
2239 
2240 	if ((async == NULL) || asy_addedsoft == 0 ||
2241 	    !(async->async_flags & (ASYNC_ISOPEN|ASYNC_WOPEN))) {
2242 		if (interrupt_id & NOINTERRUPT)
2243 			return (DDI_INTR_UNCLAIMED);
2244 		else {
2245 			/*
2246 			 * reset the device by:
2247 			 *	reading line status
2248 			 *	reading any data from data status register
2249 			 *	reading modem status
2250 			 */
2251 			(void) ddi_get8(asy->asy_iohandle,
2252 			    asy->asy_ioaddr + LSR);
2253 			(void) ddi_get8(asy->asy_iohandle,
2254 			    asy->asy_ioaddr + DAT);
2255 			asy->asy_msr = ddi_get8(asy->asy_iohandle,
2256 			    asy->asy_ioaddr + MSR);
2257 			return (DDI_INTR_CLAIMED);
2258 		}
2259 	}
2260 
2261 	mutex_enter(&asy->asy_excl_hi);
2262 	/*
2263 	 * We will loop until the interrupt line is pulled low. asy
2264 	 * interrupt is edge triggered.
2265 	 */
2266 	/* CSTYLED */
2267 	for (;; interrupt_id =
2268 	    (ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + ISR) & 0x0F)) {
2269 
2270 		if (interrupt_id & NOINTERRUPT)
2271 			break;
2272 		ret_status = DDI_INTR_CLAIMED;
2273 
2274 		DEBUGCONT1(ASY_DEBUG_INTR, "asyintr: interrupt_id = 0x%d\n",
2275 		    interrupt_id);
2276 		lsr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR);
2277 		switch (interrupt_id) {
2278 		case RxRDY:
2279 		case RSTATUS:
2280 		case FFTMOUT:
2281 			/* receiver interrupt or receiver errors */
2282 			async_rxint(asy, lsr);
2283 			break;
2284 		case TxRDY:
2285 			/* transmit interrupt */
2286 			async_txint(asy);
2287 			continue;
2288 		case MSTATUS:
2289 			/* modem status interrupt */
2290 			async_msint(asy);
2291 			break;
2292 		}
2293 		if ((lsr & XHRE) && (async->async_flags & ASYNC_BUSY) &&
2294 		    (async->async_ocnt > 0))
2295 			async_txint(asy);
2296 	}
2297 	mutex_exit(&asy->asy_excl_hi);
2298 	return (ret_status);
2299 }
2300 
2301 /*
2302  * Transmitter interrupt service routine.
2303  * If there is more data to transmit in the current pseudo-DMA block,
2304  * send the next character if output is not stopped or draining.
2305  * Otherwise, queue up a soft interrupt.
2306  *
2307  * XXX -  Needs review for HW FIFOs.
2308  */
2309 static void
2310 async_txint(struct asycom *asy)
2311 {
2312 	struct asyncline *async = asy->asy_priv;
2313 	int		fifo_len;
2314 
2315 	/*
2316 	 * If ASYNC_BREAK or ASYNC_OUT_SUSPEND has been set, return to
2317 	 * asyintr()'s context to claim the interrupt without performing
2318 	 * any action. No character will be loaded into FIFO/THR until
2319 	 * timed or untimed break is removed
2320 	 */
2321 	if (async->async_flags & (ASYNC_BREAK|ASYNC_OUT_SUSPEND))
2322 		return;
2323 
2324 	fifo_len = asy->asy_fifo_buf; /* with FIFO buffers */
2325 	if (fifo_len > asy_max_tx_fifo)
2326 		fifo_len = asy_max_tx_fifo;
2327 
2328 	if (async_flowcontrol_sw_input(asy, FLOW_CHECK, IN_FLOW_NULL))
2329 		fifo_len--;
2330 
2331 	if (async->async_ocnt > 0 && fifo_len > 0 &&
2332 	    !(async->async_flags &
2333 	    (ASYNC_HW_OUT_FLW|ASYNC_SW_OUT_FLW|ASYNC_STOPPED))) {
2334 		while (fifo_len-- > 0 && async->async_ocnt-- > 0) {
2335 			ddi_put8(asy->asy_iohandle,
2336 			    asy->asy_ioaddr + DAT, *async->async_optr++);
2337 		}
2338 		async->async_flags |= ASYNC_PROGRESS;
2339 	}
2340 
2341 	if (fifo_len <= 0)
2342 		return;
2343 
2344 	ASYSETSOFT(asy);
2345 }
2346 
2347 /*
2348  * Interrupt on port: handle PPS event.  This function is only called
2349  * for a port on which PPS event handling has been enabled.
2350  */
2351 static void
2352 asy_ppsevent(struct asycom *asy, int msr)
2353 {
2354 	if (asy->asy_flags & ASY_PPS_EDGE) {
2355 		/* Have seen leading edge, now look for and record drop */
2356 		if ((msr & DCD) == 0)
2357 			asy->asy_flags &= ~ASY_PPS_EDGE;
2358 		/*
2359 		 * Waiting for leading edge, look for rise; stamp event and
2360 		 * calibrate kernel clock.
2361 		 */
2362 	} else if (msr & DCD) {
2363 			/*
2364 			 * This code captures a timestamp at the designated
2365 			 * transition of the PPS signal (DCD asserted).  The
2366 			 * code provides a pointer to the timestamp, as well
2367 			 * as the hardware counter value at the capture.
2368 			 *
2369 			 * Note: the kernel has nano based time values while
2370 			 * NTP requires micro based, an in-line fast algorithm
2371 			 * to convert nsec to usec is used here -- see hrt2ts()
2372 			 * in common/os/timers.c for a full description.
2373 			 */
2374 			struct timeval *tvp = &asy_ppsev.tv;
2375 			timestruc_t ts;
2376 			long nsec, usec;
2377 
2378 			asy->asy_flags |= ASY_PPS_EDGE;
2379 			LED_OFF;
2380 			gethrestime(&ts);
2381 			LED_ON;
2382 			nsec = ts.tv_nsec;
2383 			usec = nsec + (nsec >> 2);
2384 			usec = nsec + (usec >> 1);
2385 			usec = nsec + (usec >> 2);
2386 			usec = nsec + (usec >> 4);
2387 			usec = nsec - (usec >> 3);
2388 			usec = nsec + (usec >> 2);
2389 			usec = nsec + (usec >> 3);
2390 			usec = nsec + (usec >> 4);
2391 			usec = nsec + (usec >> 1);
2392 			usec = nsec + (usec >> 6);
2393 			tvp->tv_usec = usec >> 10;
2394 			tvp->tv_sec = ts.tv_sec;
2395 
2396 			++asy_ppsev.serial;
2397 
2398 			/*
2399 			 * Because the kernel keeps a high-resolution time,
2400 			 * pass the current highres timestamp in tvp and zero
2401 			 * in usec.
2402 			 */
2403 			ddi_hardpps(tvp, 0);
2404 	}
2405 }
2406 
2407 /*
2408  * Receiver interrupt: RxRDY interrupt, FIFO timeout interrupt or receive
2409  * error interrupt.
2410  * Try to put the character into the circular buffer for this line; if it
2411  * overflows, indicate a circular buffer overrun. If this port is always
2412  * to be serviced immediately, or the character is a STOP character, or
2413  * more than 15 characters have arrived, queue up a soft interrupt to
2414  * drain the circular buffer.
2415  * XXX - needs review for hw FIFOs support.
2416  */
2417 
2418 static void
2419 async_rxint(struct asycom *asy, uchar_t lsr)
2420 {
2421 	struct asyncline *async = asy->asy_priv;
2422 	uchar_t c;
2423 	uint_t s, needsoft = 0;
2424 	tty_common_t *tp;
2425 	int looplim = asy->asy_fifo_buf * 2;
2426 
2427 	tp = &async->async_ttycommon;
2428 	if (!(tp->t_cflag & CREAD)) {
2429 		while (lsr & (RCA|PARERR|FRMERR|BRKDET|OVRRUN)) {
2430 			(void) (ddi_get8(asy->asy_iohandle,
2431 			    asy->asy_ioaddr + DAT) & 0xff);
2432 			lsr = ddi_get8(asy->asy_iohandle,
2433 			    asy->asy_ioaddr + LSR);
2434 			if (looplim-- < 0)		/* limit loop */
2435 				break;
2436 		}
2437 		return; /* line is not open for read? */
2438 	}
2439 
2440 	while (lsr & (RCA|PARERR|FRMERR|BRKDET|OVRRUN)) {
2441 		c = 0;
2442 		s = 0;				/* reset error status */
2443 		if (lsr & RCA) {
2444 			c = ddi_get8(asy->asy_iohandle,
2445 			    asy->asy_ioaddr + DAT) & 0xff;
2446 
2447 			/*
2448 			 * We handle XON/XOFF char if IXON is set,
2449 			 * but if received char is _POSIX_VDISABLE,
2450 			 * we left it to the up level module.
2451 			 */
2452 			if (tp->t_iflag & IXON) {
2453 				if ((c == async->async_stopc) &&
2454 				    (c != _POSIX_VDISABLE)) {
2455 					async_flowcontrol_sw_output(asy,
2456 					    FLOW_STOP);
2457 					goto check_looplim;
2458 				} else if ((c == async->async_startc) &&
2459 				    (c != _POSIX_VDISABLE)) {
2460 					async_flowcontrol_sw_output(asy,
2461 					    FLOW_START);
2462 					needsoft = 1;
2463 					goto check_looplim;
2464 				}
2465 				if ((tp->t_iflag & IXANY) &&
2466 				    (async->async_flags & ASYNC_SW_OUT_FLW)) {
2467 					async_flowcontrol_sw_output(asy,
2468 					    FLOW_START);
2469 					needsoft = 1;
2470 				}
2471 			}
2472 		}
2473 
2474 		/*
2475 		 * Check for character break sequence
2476 		 */
2477 		if ((abort_enable == KIOCABORTALTERNATE) &&
2478 		    (asy->asy_flags & ASY_CONSOLE)) {
2479 			if (abort_charseq_recognize(c))
2480 				abort_sequence_enter((char *)NULL);
2481 		}
2482 
2483 		/* Handle framing errors */
2484 		if (lsr & (PARERR|FRMERR|BRKDET|OVRRUN)) {
2485 			if (lsr & PARERR) {
2486 				if (tp->t_iflag & INPCK) /* parity enabled */
2487 					s |= PERROR;
2488 			}
2489 
2490 			if (lsr & (FRMERR|BRKDET))
2491 				s |= FRERROR;
2492 			if (lsr & OVRRUN) {
2493 				async->async_hw_overrun = 1;
2494 				s |= OVERRUN;
2495 			}
2496 		}
2497 
2498 		if (s == 0)
2499 			if ((tp->t_iflag & PARMRK) &&
2500 			    !(tp->t_iflag & (IGNPAR|ISTRIP)) &&
2501 			    (c == 0377))
2502 				if (RING_POK(async, 2)) {
2503 					RING_PUT(async, 0377);
2504 					RING_PUT(async, c);
2505 				} else
2506 					async->async_sw_overrun = 1;
2507 			else
2508 				if (RING_POK(async, 1))
2509 					RING_PUT(async, c);
2510 				else
2511 					async->async_sw_overrun = 1;
2512 		else
2513 			if (s & FRERROR) /* Handle framing errors */
2514 				if (c == 0)
2515 					if ((asy->asy_flags & ASY_CONSOLE) &&
2516 					    (abort_enable !=
2517 					    KIOCABORTALTERNATE))
2518 						abort_sequence_enter((char *)0);
2519 					else
2520 						async->async_break++;
2521 				else
2522 					if (RING_POK(async, 1))
2523 						RING_MARK(async, c, s);
2524 					else
2525 						async->async_sw_overrun = 1;
2526 			else /* Parity errors are handled by ldterm */
2527 				if (RING_POK(async, 1))
2528 					RING_MARK(async, c, s);
2529 				else
2530 					async->async_sw_overrun = 1;
2531 check_looplim:
2532 		lsr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR);
2533 		if (looplim-- < 0)		/* limit loop */
2534 			break;
2535 	}
2536 	if ((RING_CNT(async) > (RINGSIZE * 3)/4) &&
2537 	    !(async->async_inflow_source & IN_FLOW_RINGBUFF)) {
2538 		async_flowcontrol_hw_input(asy, FLOW_STOP, IN_FLOW_RINGBUFF);
2539 		(void) async_flowcontrol_sw_input(asy, FLOW_STOP,
2540 		    IN_FLOW_RINGBUFF);
2541 	}
2542 
2543 	if ((async->async_flags & ASYNC_SERVICEIMM) || needsoft ||
2544 	    (RING_FRAC(async)) || (async->async_polltid == 0))
2545 		ASYSETSOFT(asy);	/* need a soft interrupt */
2546 }
2547 
2548 /*
2549  * Modem status interrupt.
2550  *
2551  * (Note: It is assumed that the MSR hasn't been read by asyintr().)
2552  */
2553 
2554 static void
2555 async_msint(struct asycom *asy)
2556 {
2557 	struct asyncline *async = asy->asy_priv;
2558 	int msr, t_cflag = async->async_ttycommon.t_cflag;
2559 #ifdef DEBUG
2560 	int instance = UNIT(async->async_dev);
2561 #endif
2562 
2563 async_msint_retry:
2564 	/* this resets the interrupt */
2565 	msr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MSR);
2566 	DEBUGCONT10(ASY_DEBUG_STATE,
2567 	    "async%d_msint call #%d:\n"
2568 	    "   transition: %3s %3s %3s %3s\n"
2569 	    "current state: %3s %3s %3s %3s\n",
2570 	    instance,
2571 	    ++(asy->asy_msint_cnt),
2572 	    (msr & DCTS) ? "DCTS" : "    ",
2573 	    (msr & DDSR) ? "DDSR" : "    ",
2574 	    (msr & DRI)  ? "DRI " : "    ",
2575 	    (msr & DDCD) ? "DDCD" : "    ",
2576 	    (msr & CTS)  ? "CTS " : "    ",
2577 	    (msr & DSR)  ? "DSR " : "    ",
2578 	    (msr & RI)   ? "RI  " : "    ",
2579 	    (msr & DCD)  ? "DCD " : "    ");
2580 
2581 	/* If CTS status is changed, do H/W output flow control */
2582 	if ((t_cflag & CRTSCTS) && (((asy->asy_msr ^ msr) & CTS) != 0))
2583 		async_flowcontrol_hw_output(asy,
2584 		    msr & CTS ? FLOW_START : FLOW_STOP);
2585 	/*
2586 	 * Reading MSR resets the interrupt, we save the
2587 	 * value of msr so that other functions could examine MSR by
2588 	 * looking at asy_msr.
2589 	 */
2590 	asy->asy_msr = (uchar_t)msr;
2591 
2592 	/* Handle PPS event */
2593 	if (asy->asy_flags & ASY_PPS)
2594 		asy_ppsevent(asy, msr);
2595 
2596 	async->async_ext++;
2597 	ASYSETSOFT(asy);
2598 	/*
2599 	 * We will make sure that the modem status presented to us
2600 	 * during the previous read has not changed. If the chip samples
2601 	 * the modem status on the falling edge of the interrupt line,
2602 	 * and uses this state as the base for detecting change of modem
2603 	 * status, we would miss a change of modem status event that occured
2604 	 * after we initiated a read MSR operation.
2605 	 */
2606 	msr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MSR);
2607 	if (STATES(msr) != STATES(asy->asy_msr))
2608 		goto	async_msint_retry;
2609 }
2610 
2611 /*
2612  * Handle a second-stage interrupt.
2613  */
2614 /*ARGSUSED*/
2615 uint_t
2616 asysoftintr(caddr_t intarg)
2617 {
2618 	struct asycom *asy;
2619 	int rv;
2620 	int instance;
2621 
2622 	/*
2623 	 * Test and clear soft interrupt.
2624 	 */
2625 	mutex_enter(&asy_soft_lock);
2626 	DEBUGCONT0(ASY_DEBUG_PROCS, "asysoftintr: enter\n");
2627 	rv = asysoftpend;
2628 	if (rv != 0)
2629 		asysoftpend = 0;
2630 	mutex_exit(&asy_soft_lock);
2631 
2632 	if (rv) {
2633 		/*
2634 		 * Note - we can optimize the loop by remembering the last
2635 		 * device that requested soft interrupt
2636 		 */
2637 		for (instance = 0; instance <= max_asy_instance; instance++) {
2638 			asy = ddi_get_soft_state(asy_soft_state, instance);
2639 			if (asy == NULL || asy->asy_priv == NULL)
2640 				continue;
2641 			mutex_enter(&asy_soft_lock);
2642 			if (asy->asy_flags & ASY_NEEDSOFT) {
2643 				asy->asy_flags &= ~ASY_NEEDSOFT;
2644 				mutex_exit(&asy_soft_lock);
2645 				async_softint(asy);
2646 			} else
2647 				mutex_exit(&asy_soft_lock);
2648 		}
2649 	}
2650 	return (rv ? DDI_INTR_CLAIMED : DDI_INTR_UNCLAIMED);
2651 }
2652 
2653 /*
2654  * Handle a software interrupt.
2655  */
2656 static void
2657 async_softint(struct asycom *asy)
2658 {
2659 	struct asyncline *async = asy->asy_priv;
2660 	short	cc;
2661 	mblk_t	*bp;
2662 	queue_t	*q;
2663 	uchar_t	val;
2664 	uchar_t	c;
2665 	tty_common_t	*tp;
2666 	int nb;
2667 	int instance = UNIT(async->async_dev);
2668 
2669 	DEBUGCONT1(ASY_DEBUG_PROCS, "async%d_softint\n", instance);
2670 	mutex_enter(&asy_soft_lock);
2671 	if (asy->asy_flags & ASY_DOINGSOFT) {
2672 		asy->asy_flags |= ASY_DOINGSOFT_RETRY;
2673 		mutex_exit(&asy_soft_lock);
2674 		return;
2675 	}
2676 	asy->asy_flags |= ASY_DOINGSOFT;
2677 begin:
2678 	asy->asy_flags &= ~ASY_DOINGSOFT_RETRY;
2679 	mutex_exit(&asy_soft_lock);
2680 	mutex_enter(&asy->asy_excl);
2681 	tp = &async->async_ttycommon;
2682 	q = tp->t_readq;
2683 	if (async->async_flags & ASYNC_OUT_FLW_RESUME) {
2684 		if (async->async_ocnt > 0) {
2685 			mutex_enter(&asy->asy_excl_hi);
2686 			async_resume(async);
2687 			mutex_exit(&asy->asy_excl_hi);
2688 		} else {
2689 			if (async->async_xmitblk)
2690 				freeb(async->async_xmitblk);
2691 			async->async_xmitblk = NULL;
2692 			async_start(async);
2693 		}
2694 		async->async_flags &= ~ASYNC_OUT_FLW_RESUME;
2695 	}
2696 	mutex_enter(&asy->asy_excl_hi);
2697 	if (async->async_ext) {
2698 		async->async_ext = 0;
2699 		/* check for carrier up */
2700 		DEBUGCONT3(ASY_DEBUG_MODM2,
2701 		    "async%d_softint: asy_msr & DCD = %x, "
2702 		    "tp->t_flags & TS_SOFTCAR = %x\n",
2703 		    instance, asy->asy_msr & DCD, tp->t_flags & TS_SOFTCAR);
2704 
2705 		if (asy->asy_msr & DCD) {
2706 			/* carrier present */
2707 			if ((async->async_flags & ASYNC_CARR_ON) == 0) {
2708 				DEBUGCONT1(ASY_DEBUG_MODM2,
2709 				    "async%d_softint: set ASYNC_CARR_ON\n",
2710 				    instance);
2711 				async->async_flags |= ASYNC_CARR_ON;
2712 				if (async->async_flags & ASYNC_ISOPEN) {
2713 					mutex_exit(&asy->asy_excl_hi);
2714 					mutex_exit(&asy->asy_excl);
2715 					(void) putctl(q, M_UNHANGUP);
2716 					mutex_enter(&asy->asy_excl);
2717 					mutex_enter(&asy->asy_excl_hi);
2718 				}
2719 				cv_broadcast(&async->async_flags_cv);
2720 			}
2721 		} else {
2722 			if ((async->async_flags & ASYNC_CARR_ON) &&
2723 			    !(tp->t_cflag & CLOCAL) &&
2724 			    !(tp->t_flags & TS_SOFTCAR)) {
2725 				int flushflag;
2726 
2727 				DEBUGCONT1(ASY_DEBUG_MODEM,
2728 				    "async%d_softint: carrier dropped, "
2729 				    "so drop DTR\n",
2730 				    instance);
2731 				/*
2732 				 * Carrier went away.
2733 				 * Drop DTR, abort any output in
2734 				 * progress, indicate that output is
2735 				 * not stopped, and send a hangup
2736 				 * notification upstream.
2737 				 */
2738 				val = ddi_get8(asy->asy_iohandle,
2739 				    asy->asy_ioaddr + MCR);
2740 				ddi_put8(asy->asy_iohandle,
2741 				    asy->asy_ioaddr + MCR, (val & ~DTR));
2742 
2743 				if (async->async_flags & ASYNC_BUSY) {
2744 					DEBUGCONT0(ASY_DEBUG_BUSY,
2745 					    "async_softint: "
2746 					    "Carrier dropped.  "
2747 					    "Clearing async_ocnt\n");
2748 					async->async_ocnt = 0;
2749 				}	/* if */
2750 
2751 				async->async_flags &= ~ASYNC_STOPPED;
2752 				if (async->async_flags & ASYNC_ISOPEN) {
2753 					mutex_exit(&asy->asy_excl_hi);
2754 					mutex_exit(&asy->asy_excl);
2755 					(void) putctl(q, M_HANGUP);
2756 					mutex_enter(&asy->asy_excl);
2757 					DEBUGCONT1(ASY_DEBUG_MODEM,
2758 					    "async%d_softint: "
2759 					    "putctl(q, M_HANGUP)\n",
2760 					    instance);
2761 					/*
2762 					 * Flush FIFO buffers
2763 					 * Any data left in there is invalid now
2764 					 */
2765 					if (asy->asy_use_fifo == FIFO_ON)
2766 						asy_reset_fifo(asy, FIFOTXFLSH);
2767 					/*
2768 					 * Flush our write queue if we have one.
2769 					 * If we're in the midst of close, then
2770 					 * flush everything. Don't leave stale
2771 					 * ioctls lying about.
2772 					 */
2773 					flushflag = (async->async_flags &
2774 					    ASYNC_CLOSING) ? FLUSHALL :
2775 					    FLUSHDATA;
2776 					flushq(tp->t_writeq, flushflag);
2777 
2778 					/* active msg */
2779 					bp = async->async_xmitblk;
2780 					if (bp != NULL) {
2781 						freeb(bp);
2782 						async->async_xmitblk = NULL;
2783 					}
2784 
2785 					mutex_enter(&asy->asy_excl_hi);
2786 					async->async_flags &= ~ASYNC_BUSY;
2787 					/*
2788 					 * This message warns of Carrier loss
2789 					 * with data left to transmit can hang
2790 					 * the system.
2791 					 */
2792 					DEBUGCONT0(ASY_DEBUG_MODEM,
2793 					    "async_softint: Flushing to "
2794 					    "prevent HUPCL hanging\n");
2795 				}	/* if (ASYNC_ISOPEN) */
2796 			}	/* if (ASYNC_CARR_ON && CLOCAL) */
2797 			async->async_flags &= ~ASYNC_CARR_ON;
2798 			cv_broadcast(&async->async_flags_cv);
2799 		}	/* else */
2800 	}	/* if (async->async_ext) */
2801 
2802 	mutex_exit(&asy->asy_excl_hi);
2803 
2804 	/*
2805 	 * If data has been added to the circular buffer, remove
2806 	 * it from the buffer, and send it up the stream if there's
2807 	 * somebody listening. Try to do it 16 bytes at a time. If we
2808 	 * have more than 16 bytes to move, move 16 byte chunks and
2809 	 * leave the rest for next time around (maybe it will grow).
2810 	 */
2811 	mutex_enter(&asy->asy_excl_hi);
2812 	if (!(async->async_flags & ASYNC_ISOPEN)) {
2813 		RING_INIT(async);
2814 		goto rv;
2815 	}
2816 	if ((cc = RING_CNT(async)) <= 0)
2817 		goto rv;
2818 	mutex_exit(&asy->asy_excl_hi);
2819 
2820 	if (!canput(q)) {
2821 		mutex_enter(&asy->asy_excl_hi);
2822 		if (!(async->async_inflow_source & IN_FLOW_STREAMS)) {
2823 			async_flowcontrol_hw_input(asy, FLOW_STOP,
2824 			    IN_FLOW_STREAMS);
2825 			(void) async_flowcontrol_sw_input(asy, FLOW_STOP,
2826 			    IN_FLOW_STREAMS);
2827 		}
2828 		goto rv;
2829 	}
2830 	if (async->async_inflow_source & IN_FLOW_STREAMS) {
2831 		mutex_enter(&asy->asy_excl_hi);
2832 		async_flowcontrol_hw_input(asy, FLOW_START,
2833 		    IN_FLOW_STREAMS);
2834 		(void) async_flowcontrol_sw_input(asy, FLOW_START,
2835 		    IN_FLOW_STREAMS);
2836 		mutex_exit(&asy->asy_excl_hi);
2837 	}
2838 
2839 	DEBUGCONT2(ASY_DEBUG_INPUT, "async%d_softint: %d char(s) in queue.\n",
2840 	    instance, cc);
2841 
2842 	if (!(bp = allocb(cc, BPRI_MED))) {
2843 		mutex_exit(&asy->asy_excl);
2844 		ttycommon_qfull(&async->async_ttycommon, q);
2845 		mutex_enter(&asy->asy_excl);
2846 		mutex_enter(&asy->asy_excl_hi);
2847 		goto rv;
2848 	}
2849 	mutex_enter(&asy->asy_excl_hi);
2850 	do {
2851 		if (RING_ERR(async, S_ERRORS)) {
2852 			RING_UNMARK(async);
2853 			c = RING_GET(async);
2854 			break;
2855 		} else
2856 			*bp->b_wptr++ = RING_GET(async);
2857 	} while (--cc);
2858 	mutex_exit(&asy->asy_excl_hi);
2859 	mutex_exit(&asy->asy_excl);
2860 	if (bp->b_wptr > bp->b_rptr) {
2861 			if (!canput(q)) {
2862 				asyerror(CE_NOTE, "asy%d: local queue full",
2863 				    instance);
2864 				freemsg(bp);
2865 			} else
2866 				(void) putq(q, bp);
2867 	} else
2868 		freemsg(bp);
2869 	/*
2870 	 * If we have a parity error, then send
2871 	 * up an M_BREAK with the "bad"
2872 	 * character as an argument. Let ldterm
2873 	 * figure out what to do with the error.
2874 	 */
2875 	if (cc) {
2876 		(void) putctl1(q, M_BREAK, c);
2877 		ASYSETSOFT(async->async_common);	/* finish cc chars */
2878 	}
2879 	mutex_enter(&asy->asy_excl);
2880 	mutex_enter(&asy->asy_excl_hi);
2881 rv:
2882 	if ((RING_CNT(async) < (RINGSIZE/4)) &&
2883 	    (async->async_inflow_source & IN_FLOW_RINGBUFF)) {
2884 		async_flowcontrol_hw_input(asy, FLOW_START, IN_FLOW_RINGBUFF);
2885 		(void) async_flowcontrol_sw_input(asy, FLOW_START,
2886 		    IN_FLOW_RINGBUFF);
2887 	}
2888 
2889 	/*
2890 	 * If a transmission has finished, indicate that it's finished,
2891 	 * and start that line up again.
2892 	 */
2893 	if (async->async_break > 0) {
2894 		nb = async->async_break;
2895 		async->async_break = 0;
2896 		if (async->async_flags & ASYNC_ISOPEN) {
2897 			mutex_exit(&asy->asy_excl_hi);
2898 			mutex_exit(&asy->asy_excl);
2899 			for (; nb > 0; nb--)
2900 				(void) putctl(q, M_BREAK);
2901 			mutex_enter(&asy->asy_excl);
2902 			mutex_enter(&asy->asy_excl_hi);
2903 		}
2904 	}
2905 	if (async->async_ocnt <= 0 && (async->async_flags & ASYNC_BUSY)) {
2906 		DEBUGCONT2(ASY_DEBUG_BUSY,
2907 		    "async%d_softint: Clearing ASYNC_BUSY.  async_ocnt=%d\n",
2908 		    instance,
2909 		    async->async_ocnt);
2910 		async->async_flags &= ~ASYNC_BUSY;
2911 		mutex_exit(&asy->asy_excl_hi);
2912 		if (async->async_xmitblk)
2913 			freeb(async->async_xmitblk);
2914 		async->async_xmitblk = NULL;
2915 		async_start(async);
2916 		/*
2917 		 * If the flag isn't set after doing the async_start above, we
2918 		 * may have finished all the queued output.  Signal any thread
2919 		 * stuck in close.
2920 		 */
2921 		if (!(async->async_flags & ASYNC_BUSY))
2922 			cv_broadcast(&async->async_flags_cv);
2923 		mutex_enter(&asy->asy_excl_hi);
2924 	}
2925 	/*
2926 	 * A note about these overrun bits: all they do is *tell* someone
2927 	 * about an error- They do not track multiple errors. In fact,
2928 	 * you could consider them latched register bits if you like.
2929 	 * We are only interested in printing the error message once for
2930 	 * any cluster of overrun errrors.
2931 	 */
2932 	if (async->async_hw_overrun) {
2933 		if (async->async_flags & ASYNC_ISOPEN) {
2934 			mutex_exit(&asy->asy_excl_hi);
2935 			mutex_exit(&asy->asy_excl);
2936 			asyerror(CE_NOTE, "asy%d: silo overflow", instance);
2937 			mutex_enter(&asy->asy_excl);
2938 			mutex_enter(&asy->asy_excl_hi);
2939 		}
2940 		async->async_hw_overrun = 0;
2941 	}
2942 	if (async->async_sw_overrun) {
2943 		if (async->async_flags & ASYNC_ISOPEN) {
2944 			mutex_exit(&asy->asy_excl_hi);
2945 			mutex_exit(&asy->asy_excl);
2946 			asyerror(CE_NOTE, "asy%d: ring buffer overflow",
2947 			    instance);
2948 			mutex_enter(&asy->asy_excl);
2949 			mutex_enter(&asy->asy_excl_hi);
2950 		}
2951 		async->async_sw_overrun = 0;
2952 	}
2953 	mutex_exit(&asy->asy_excl_hi);
2954 	mutex_exit(&asy->asy_excl);
2955 	mutex_enter(&asy_soft_lock);
2956 	if (asy->asy_flags & ASY_DOINGSOFT_RETRY) {
2957 		goto begin;
2958 	}
2959 	asy->asy_flags &= ~ASY_DOINGSOFT;
2960 	mutex_exit(&asy_soft_lock);
2961 	DEBUGCONT1(ASY_DEBUG_PROCS, "async%d_softint: done\n", instance);
2962 }
2963 
2964 /*
2965  * Restart output on a line after a delay or break timer expired.
2966  */
2967 static void
2968 async_restart(void *arg)
2969 {
2970 	struct asyncline *async = (struct asyncline *)arg;
2971 	struct asycom *asy = async->async_common;
2972 	uchar_t lcr;
2973 
2974 	/*
2975 	 * If break timer expired, turn off the break bit.
2976 	 */
2977 #ifdef DEBUG
2978 	int instance = UNIT(async->async_dev);
2979 
2980 	DEBUGCONT1(ASY_DEBUG_PROCS, "async%d_restart\n", instance);
2981 #endif
2982 	mutex_enter(&asy->asy_excl);
2983 	/*
2984 	 * If ASYNC_OUT_SUSPEND is also set, we don't really
2985 	 * clean the HW break, TIOCCBRK is responsible for this.
2986 	 */
2987 	if ((async->async_flags & ASYNC_BREAK) &&
2988 	    !(async->async_flags & ASYNC_OUT_SUSPEND)) {
2989 		mutex_enter(&asy->asy_excl_hi);
2990 		lcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
2991 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
2992 		    (lcr & ~SETBREAK));
2993 		mutex_exit(&asy->asy_excl_hi);
2994 	}
2995 	async->async_flags &= ~(ASYNC_DELAY|ASYNC_BREAK);
2996 	cv_broadcast(&async->async_flags_cv);
2997 	async_start(async);
2998 
2999 	mutex_exit(&asy->asy_excl);
3000 }
3001 
3002 static void
3003 async_start(struct asyncline *async)
3004 {
3005 	async_nstart(async, 0);
3006 }
3007 
3008 /*
3009  * Start output on a line, unless it's busy, frozen, or otherwise.
3010  */
3011 /*ARGSUSED*/
3012 static void
3013 async_nstart(struct asyncline *async, int mode)
3014 {
3015 	struct asycom *asy = async->async_common;
3016 	int cc;
3017 	queue_t *q;
3018 	mblk_t *bp;
3019 	uchar_t *xmit_addr;
3020 	uchar_t	val;
3021 	int	fifo_len = 1;
3022 	boolean_t didsome;
3023 	mblk_t *nbp;
3024 
3025 #ifdef DEBUG
3026 	int instance = UNIT(async->async_dev);
3027 
3028 	DEBUGCONT1(ASY_DEBUG_PROCS, "async%d_nstart\n", instance);
3029 #endif
3030 	if (asy->asy_use_fifo == FIFO_ON) {
3031 		fifo_len = asy->asy_fifo_buf; /* with FIFO buffers */
3032 		if (fifo_len > asy_max_tx_fifo)
3033 			fifo_len = asy_max_tx_fifo;
3034 	}
3035 
3036 	ASSERT(mutex_owned(&asy->asy_excl));
3037 
3038 	/*
3039 	 * If the chip is busy (i.e., we're waiting for a break timeout
3040 	 * to expire, or for the current transmission to finish, or for
3041 	 * output to finish draining from chip), don't grab anything new.
3042 	 */
3043 	if (async->async_flags & (ASYNC_BREAK|ASYNC_BUSY)) {
3044 		DEBUGCONT2((mode? ASY_DEBUG_OUT : 0),
3045 		    "async%d_nstart: start %s.\n",
3046 		    instance,
3047 		    async->async_flags & ASYNC_BREAK ? "break" : "busy");
3048 		return;
3049 	}
3050 
3051 	/*
3052 	 * Check only pended sw input flow control.
3053 	 */
3054 	mutex_enter(&asy->asy_excl_hi);
3055 	if (async_flowcontrol_sw_input(asy, FLOW_CHECK, IN_FLOW_NULL))
3056 		fifo_len--;
3057 	mutex_exit(&asy->asy_excl_hi);
3058 
3059 	/*
3060 	 * If we're waiting for a delay timeout to expire, don't grab
3061 	 * anything new.
3062 	 */
3063 	if (async->async_flags & ASYNC_DELAY) {
3064 		DEBUGCONT1((mode? ASY_DEBUG_OUT : 0),
3065 		    "async%d_nstart: start ASYNC_DELAY.\n", instance);
3066 		return;
3067 	}
3068 
3069 	if ((q = async->async_ttycommon.t_writeq) == NULL) {
3070 		DEBUGCONT1((mode? ASY_DEBUG_OUT : 0),
3071 		    "async%d_nstart: start writeq is null.\n", instance);
3072 		return;	/* not attached to a stream */
3073 	}
3074 
3075 	for (;;) {
3076 		if ((bp = getq(q)) == NULL)
3077 			return;	/* no data to transmit */
3078 
3079 		/*
3080 		 * We have a message block to work on.
3081 		 * Check whether it's a break, a delay, or an ioctl (the latter
3082 		 * occurs if the ioctl in question was waiting for the output
3083 		 * to drain).  If it's one of those, process it immediately.
3084 		 */
3085 		switch (bp->b_datap->db_type) {
3086 
3087 		case M_BREAK:
3088 			/*
3089 			 * Set the break bit, and arrange for "async_restart"
3090 			 * to be called in 1/4 second; it will turn the
3091 			 * break bit off, and call "async_start" to grab
3092 			 * the next message.
3093 			 */
3094 			mutex_enter(&asy->asy_excl_hi);
3095 			val = ddi_get8(asy->asy_iohandle,
3096 			    asy->asy_ioaddr + LCR);
3097 			ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
3098 			    (val | SETBREAK));
3099 			mutex_exit(&asy->asy_excl_hi);
3100 			async->async_flags |= ASYNC_BREAK;
3101 			(void) timeout(async_restart, (caddr_t)async,
3102 			    drv_usectohz(1000000)/4);
3103 			freemsg(bp);
3104 			return;	/* wait for this to finish */
3105 
3106 		case M_DELAY:
3107 			/*
3108 			 * Arrange for "async_restart" to be called when the
3109 			 * delay expires; it will turn ASYNC_DELAY off,
3110 			 * and call "async_start" to grab the next message.
3111 			 */
3112 			(void) timeout(async_restart, (caddr_t)async,
3113 			    (int)(*(unsigned char *)bp->b_rptr + 6));
3114 			async->async_flags |= ASYNC_DELAY;
3115 			freemsg(bp);
3116 			return;	/* wait for this to finish */
3117 
3118 		case M_IOCTL:
3119 			/*
3120 			 * This ioctl was waiting for the output ahead of
3121 			 * it to drain; obviously, it has.  Do it, and
3122 			 * then grab the next message after it.
3123 			 */
3124 			mutex_exit(&asy->asy_excl);
3125 			async_ioctl(async, q, bp);
3126 			mutex_enter(&asy->asy_excl);
3127 			continue;
3128 		}
3129 
3130 		while (bp != NULL && ((cc = MBLKL(bp)) == 0)) {
3131 			nbp = bp->b_cont;
3132 			freeb(bp);
3133 			bp = nbp;
3134 		}
3135 		if (bp != NULL)
3136 			break;
3137 	}
3138 
3139 	/*
3140 	 * We have data to transmit.  If output is stopped, put
3141 	 * it back and try again later.
3142 	 */
3143 	if (async->async_flags & (ASYNC_HW_OUT_FLW | ASYNC_SW_OUT_FLW |
3144 	    ASYNC_STOPPED | ASYNC_OUT_SUSPEND)) {
3145 		(void) putbq(q, bp);
3146 		return;
3147 	}
3148 
3149 	async->async_xmitblk = bp;
3150 	xmit_addr = bp->b_rptr;
3151 	bp = bp->b_cont;
3152 	if (bp != NULL)
3153 		(void) putbq(q, bp);	/* not done with this message yet */
3154 
3155 	/*
3156 	 * In 5-bit mode, the high order bits are used
3157 	 * to indicate character sizes less than five,
3158 	 * so we need to explicitly mask before transmitting
3159 	 */
3160 	if ((async->async_ttycommon.t_cflag & CSIZE) == CS5) {
3161 		unsigned char *p = xmit_addr;
3162 		int cnt = cc;
3163 
3164 		while (cnt--)
3165 			*p++ &= (unsigned char) 0x1f;
3166 	}
3167 
3168 	/*
3169 	 * Set up this block for pseudo-DMA.
3170 	 */
3171 	mutex_enter(&asy->asy_excl_hi);
3172 	/*
3173 	 * If the transmitter is ready, shove the first
3174 	 * character out.
3175 	 */
3176 	didsome = B_FALSE;
3177 	while (--fifo_len >= 0 && cc > 0) {
3178 		if (!(ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR) &
3179 		    XHRE))
3180 			break;
3181 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT,
3182 		    *xmit_addr++);
3183 		cc--;
3184 		didsome = B_TRUE;
3185 	}
3186 	async->async_optr = xmit_addr;
3187 	async->async_ocnt = cc;
3188 	if (didsome)
3189 		async->async_flags |= ASYNC_PROGRESS;
3190 	DEBUGCONT2(ASY_DEBUG_BUSY,
3191 	    "async%d_nstart: Set ASYNC_BUSY.  async_ocnt=%d\n",
3192 	    instance, async->async_ocnt);
3193 	async->async_flags |= ASYNC_BUSY;
3194 	mutex_exit(&asy->asy_excl_hi);
3195 }
3196 
3197 /*
3198  * Resume output by poking the transmitter.
3199  */
3200 static void
3201 async_resume(struct asyncline *async)
3202 {
3203 	struct asycom *asy = async->async_common;
3204 #ifdef DEBUG
3205 	int instance;
3206 #endif
3207 
3208 	ASSERT(mutex_owned(&asy->asy_excl_hi));
3209 #ifdef DEBUG
3210 	instance = UNIT(async->async_dev);
3211 	DEBUGCONT1(ASY_DEBUG_PROCS, "async%d_resume\n", instance);
3212 #endif
3213 
3214 	if (ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR) & XHRE) {
3215 		if (async_flowcontrol_sw_input(asy, FLOW_CHECK, IN_FLOW_NULL))
3216 			return;
3217 		if (async->async_ocnt > 0 &&
3218 		    !(async->async_flags &
3219 		    (ASYNC_HW_OUT_FLW|ASYNC_SW_OUT_FLW|ASYNC_OUT_SUSPEND))) {
3220 			ddi_put8(asy->asy_iohandle,
3221 			    asy->asy_ioaddr + DAT, *async->async_optr++);
3222 			async->async_ocnt--;
3223 			async->async_flags |= ASYNC_PROGRESS;
3224 		}
3225 	}
3226 }
3227 
3228 /*
3229  * Hold the untimed break to last the minimum time.
3230  */
3231 static void
3232 async_hold_utbrk(void *arg)
3233 {
3234 	struct asyncline *async = arg;
3235 	struct asycom *asy = async->async_common;
3236 
3237 	mutex_enter(&asy->asy_excl);
3238 	async->async_flags &= ~ASYNC_HOLD_UTBRK;
3239 	cv_broadcast(&async->async_flags_cv);
3240 	async->async_utbrktid = 0;
3241 	mutex_exit(&asy->asy_excl);
3242 }
3243 
3244 /*
3245  * Resume the untimed break.
3246  */
3247 static void
3248 async_resume_utbrk(struct asyncline *async)
3249 {
3250 	uchar_t	val;
3251 	struct asycom *asy = async->async_common;
3252 	ASSERT(mutex_owned(&asy->asy_excl));
3253 
3254 	/*
3255 	 * Because the wait time is very short,
3256 	 * so we use uninterruptably wait.
3257 	 */
3258 	while (async->async_flags & ASYNC_HOLD_UTBRK) {
3259 		cv_wait(&async->async_flags_cv, &asy->asy_excl);
3260 	}
3261 	mutex_enter(&asy->asy_excl_hi);
3262 	/*
3263 	 * Timed break and untimed break can exist simultaneously,
3264 	 * if ASYNC_BREAK is also set at here, we don't
3265 	 * really clean the HW break.
3266 	 */
3267 	if (!(async->async_flags & ASYNC_BREAK)) {
3268 		val = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
3269 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
3270 		    (val & ~SETBREAK));
3271 	}
3272 	async->async_flags &= ~ASYNC_OUT_SUSPEND;
3273 	cv_broadcast(&async->async_flags_cv);
3274 	if (async->async_ocnt > 0) {
3275 		async_resume(async);
3276 		mutex_exit(&asy->asy_excl_hi);
3277 	} else {
3278 		async->async_flags &= ~ASYNC_BUSY;
3279 		mutex_exit(&asy->asy_excl_hi);
3280 		if (async->async_xmitblk != NULL) {
3281 			freeb(async->async_xmitblk);
3282 			async->async_xmitblk = NULL;
3283 		}
3284 		async_start(async);
3285 	}
3286 }
3287 
3288 /*
3289  * Process an "ioctl" message sent down to us.
3290  * Note that we don't need to get any locks until we are ready to access
3291  * the hardware.  Nothing we access until then is going to be altered
3292  * outside of the STREAMS framework, so we should be safe.
3293  */
3294 int asydelay = 10000;
3295 static void
3296 async_ioctl(struct asyncline *async, queue_t *wq, mblk_t *mp)
3297 {
3298 	struct asycom *asy = async->async_common;
3299 	tty_common_t  *tp = &async->async_ttycommon;
3300 	struct iocblk *iocp;
3301 	unsigned datasize;
3302 	int error = 0;
3303 	uchar_t val;
3304 	mblk_t *datamp;
3305 	unsigned int index;
3306 
3307 #ifdef DEBUG
3308 	int instance = UNIT(async->async_dev);
3309 
3310 	DEBUGCONT1(ASY_DEBUG_PROCS, "async%d_ioctl\n", instance);
3311 #endif
3312 
3313 	if (tp->t_iocpending != NULL) {
3314 		/*
3315 		 * We were holding an "ioctl" response pending the
3316 		 * availability of an "mblk" to hold data to be passed up;
3317 		 * another "ioctl" came through, which means that "ioctl"
3318 		 * must have timed out or been aborted.
3319 		 */
3320 		freemsg(async->async_ttycommon.t_iocpending);
3321 		async->async_ttycommon.t_iocpending = NULL;
3322 	}
3323 
3324 	iocp = (struct iocblk *)mp->b_rptr;
3325 
3326 	/*
3327 	 * For TIOCMGET and the PPS ioctls, do NOT call ttycommon_ioctl()
3328 	 * because this function frees up the message block (mp->b_cont) that
3329 	 * contains the user location where we pass back the results.
3330 	 *
3331 	 * Similarly, CONSOPENPOLLEDIO needs ioc_count, which ttycommon_ioctl
3332 	 * zaps.  We know that ttycommon_ioctl doesn't know any CONS*
3333 	 * ioctls, so keep the others safe too.
3334 	 */
3335 	DEBUGCONT2(ASY_DEBUG_IOCTL, "async%d_ioctl: %s\n",
3336 	    instance,
3337 	    iocp->ioc_cmd == TIOCMGET ? "TIOCMGET" :
3338 	    iocp->ioc_cmd == TIOCMSET ? "TIOCMSET" :
3339 	    iocp->ioc_cmd == TIOCMBIS ? "TIOCMBIS" :
3340 	    iocp->ioc_cmd == TIOCMBIC ? "TIOCMBIC" :
3341 	    "other");
3342 
3343 	switch (iocp->ioc_cmd) {
3344 	case TIOCMGET:
3345 	case TIOCGPPS:
3346 	case TIOCSPPS:
3347 	case TIOCGPPSEV:
3348 	case CONSOPENPOLLEDIO:
3349 	case CONSCLOSEPOLLEDIO:
3350 	case CONSSETABORTENABLE:
3351 	case CONSGETABORTENABLE:
3352 		error = -1; /* Do Nothing */
3353 		break;
3354 	default:
3355 
3356 		/*
3357 		 * The only way in which "ttycommon_ioctl" can fail is if the
3358 		 * "ioctl" requires a response containing data to be returned
3359 		 * to the user, and no mblk could be allocated for the data.
3360 		 * No such "ioctl" alters our state.  Thus, we always go ahead
3361 		 * and do any state-changes the "ioctl" calls for.  If we
3362 		 * couldn't allocate the data, "ttycommon_ioctl" has stashed
3363 		 * the "ioctl" away safely, so we just call "bufcall" to
3364 		 * request that we be called back when we stand a better
3365 		 * chance of allocating the data.
3366 		 */
3367 		if ((datasize = ttycommon_ioctl(tp, wq, mp, &error)) != 0) {
3368 			if (async->async_wbufcid)
3369 				unbufcall(async->async_wbufcid);
3370 			async->async_wbufcid = bufcall(datasize, BPRI_HI,
3371 			    (void (*)(void *)) async_reioctl,
3372 			    (void *)(intptr_t)async->async_common->asy_unit);
3373 			return;
3374 		}
3375 	}
3376 
3377 	mutex_enter(&asy->asy_excl);
3378 
3379 	if (error == 0) {
3380 		/*
3381 		 * "ttycommon_ioctl" did most of the work; we just use the
3382 		 * data it set up.
3383 		 */
3384 		switch (iocp->ioc_cmd) {
3385 
3386 		case TCSETS:
3387 			mutex_enter(&asy->asy_excl_hi);
3388 			if (asy_baudok(asy))
3389 				asy_program(asy, ASY_NOINIT);
3390 			else
3391 				error = EINVAL;
3392 			mutex_exit(&asy->asy_excl_hi);
3393 			break;
3394 		case TCSETSF:
3395 		case TCSETSW:
3396 		case TCSETA:
3397 		case TCSETAW:
3398 		case TCSETAF:
3399 			mutex_enter(&asy->asy_excl_hi);
3400 			if (!asy_baudok(asy))
3401 				error = EINVAL;
3402 			else {
3403 				if (asy_isbusy(asy))
3404 					asy_waiteot(asy);
3405 				asy_program(asy, ASY_NOINIT);
3406 			}
3407 			mutex_exit(&asy->asy_excl_hi);
3408 			break;
3409 		}
3410 	} else if (error < 0) {
3411 		/*
3412 		 * "ttycommon_ioctl" didn't do anything; we process it here.
3413 		 */
3414 		error = 0;
3415 		switch (iocp->ioc_cmd) {
3416 
3417 		case TIOCGPPS:
3418 			/*
3419 			 * Get PPS on/off.
3420 			 */
3421 			if (mp->b_cont != NULL)
3422 				freemsg(mp->b_cont);
3423 
3424 			mp->b_cont = allocb(sizeof (int), BPRI_HI);
3425 			if (mp->b_cont == NULL) {
3426 				error = ENOMEM;
3427 				break;
3428 			}
3429 			if (asy->asy_flags & ASY_PPS)
3430 				*(int *)mp->b_cont->b_wptr = 1;
3431 			else
3432 				*(int *)mp->b_cont->b_wptr = 0;
3433 			mp->b_cont->b_wptr += sizeof (int);
3434 			mp->b_datap->db_type = M_IOCACK;
3435 			iocp->ioc_count = sizeof (int);
3436 			break;
3437 
3438 		case TIOCSPPS:
3439 			/*
3440 			 * Set PPS on/off.
3441 			 */
3442 			error = miocpullup(mp, sizeof (int));
3443 			if (error != 0)
3444 				break;
3445 
3446 			mutex_enter(&asy->asy_excl_hi);
3447 			if (*(int *)mp->b_cont->b_rptr)
3448 				asy->asy_flags |= ASY_PPS;
3449 			else
3450 				asy->asy_flags &= ~ASY_PPS;
3451 			/* Reset edge sense */
3452 			asy->asy_flags &= ~ASY_PPS_EDGE;
3453 			mutex_exit(&asy->asy_excl_hi);
3454 			mp->b_datap->db_type = M_IOCACK;
3455 			break;
3456 
3457 		case TIOCGPPSEV:
3458 		{
3459 			/*
3460 			 * Get PPS event data.
3461 			 */
3462 			mblk_t *bp;
3463 			void *buf;
3464 #ifdef _SYSCALL32_IMPL
3465 			struct ppsclockev32 p32;
3466 #endif
3467 			struct ppsclockev ppsclockev;
3468 
3469 			if (mp->b_cont != NULL) {
3470 				freemsg(mp->b_cont);
3471 				mp->b_cont = NULL;
3472 			}
3473 
3474 			if ((asy->asy_flags & ASY_PPS) == 0) {
3475 				error = ENXIO;
3476 				break;
3477 			}
3478 
3479 			/* Protect from incomplete asy_ppsev */
3480 			mutex_enter(&asy->asy_excl_hi);
3481 			ppsclockev = asy_ppsev;
3482 			mutex_exit(&asy->asy_excl_hi);
3483 
3484 #ifdef _SYSCALL32_IMPL
3485 			if ((iocp->ioc_flag & IOC_MODELS) != IOC_NATIVE) {
3486 				TIMEVAL_TO_TIMEVAL32(&p32.tv, &ppsclockev.tv);
3487 				p32.serial = ppsclockev.serial;
3488 				buf = &p32;
3489 				iocp->ioc_count = sizeof (struct ppsclockev32);
3490 			} else
3491 #endif
3492 			{
3493 				buf = &ppsclockev;
3494 				iocp->ioc_count = sizeof (struct ppsclockev);
3495 			}
3496 
3497 			if ((bp = allocb(iocp->ioc_count, BPRI_HI)) == NULL) {
3498 				error = ENOMEM;
3499 				break;
3500 			}
3501 			mp->b_cont = bp;
3502 
3503 			bcopy(buf, bp->b_wptr, iocp->ioc_count);
3504 			bp->b_wptr += iocp->ioc_count;
3505 			mp->b_datap->db_type = M_IOCACK;
3506 			break;
3507 		}
3508 
3509 		case TCSBRK:
3510 			error = miocpullup(mp, sizeof (int));
3511 			if (error != 0)
3512 				break;
3513 
3514 			if (*(int *)mp->b_cont->b_rptr == 0) {
3515 
3516 				/*
3517 				 * XXX Arrangements to ensure that a break
3518 				 * isn't in progress should be sufficient.
3519 				 * This ugly delay() is the only thing
3520 				 * that seems to work on the NCR Worldmark.
3521 				 * It should be replaced. Note that an
3522 				 * asy_waiteot() also does not work.
3523 				 */
3524 				if (asydelay)
3525 					delay(drv_usectohz(asydelay));
3526 
3527 				while (async->async_flags & ASYNC_BREAK) {
3528 					cv_wait(&async->async_flags_cv,
3529 					    &asy->asy_excl);
3530 				}
3531 				mutex_enter(&asy->asy_excl_hi);
3532 				/*
3533 				 * We loop until the TSR is empty and then
3534 				 * set the break.  ASYNC_BREAK has been set
3535 				 * to ensure that no characters are
3536 				 * transmitted while the TSR is being
3537 				 * flushed and SOUT is being used for the
3538 				 * break signal.
3539 				 *
3540 				 * The wait period is equal to
3541 				 * clock / (baud * 16) * 16 * 2.
3542 				 */
3543 				index = BAUDINDEX(
3544 				    async->async_ttycommon.t_cflag);
3545 				async->async_flags |= ASYNC_BREAK;
3546 
3547 				while ((ddi_get8(asy->asy_iohandle,
3548 				    asy->asy_ioaddr + LSR) & XSRE) == 0) {
3549 					mutex_exit(&asy->asy_excl_hi);
3550 					mutex_exit(&asy->asy_excl);
3551 					drv_usecwait(
3552 					    32*asyspdtab[index] & 0xfff);
3553 					mutex_enter(&asy->asy_excl);
3554 					mutex_enter(&asy->asy_excl_hi);
3555 				}
3556 				/*
3557 				 * Arrange for "async_restart"
3558 				 * to be called in 1/4 second;
3559 				 * it will turn the break bit off, and call
3560 				 * "async_start" to grab the next message.
3561 				 */
3562 				val = ddi_get8(asy->asy_iohandle,
3563 				    asy->asy_ioaddr + LCR);
3564 				ddi_put8(asy->asy_iohandle,
3565 				    asy->asy_ioaddr + LCR,
3566 				    (val | SETBREAK));
3567 				mutex_exit(&asy->asy_excl_hi);
3568 				(void) timeout(async_restart, (caddr_t)async,
3569 				    drv_usectohz(1000000)/4);
3570 			} else {
3571 				DEBUGCONT1(ASY_DEBUG_OUT,
3572 				    "async%d_ioctl: wait for flush.\n",
3573 				    instance);
3574 				mutex_enter(&asy->asy_excl_hi);
3575 				asy_waiteot(asy);
3576 				mutex_exit(&asy->asy_excl_hi);
3577 				DEBUGCONT1(ASY_DEBUG_OUT,
3578 				    "async%d_ioctl: ldterm satisfied.\n",
3579 				    instance);
3580 			}
3581 			break;
3582 
3583 		case TIOCSBRK:
3584 			if (!(async->async_flags & ASYNC_OUT_SUSPEND)) {
3585 				mutex_enter(&asy->asy_excl_hi);
3586 				async->async_flags |= ASYNC_OUT_SUSPEND;
3587 				async->async_flags |= ASYNC_HOLD_UTBRK;
3588 				index = BAUDINDEX(
3589 				    async->async_ttycommon.t_cflag);
3590 				while ((ddi_get8(asy->asy_iohandle,
3591 				    asy->asy_ioaddr + LSR) & XSRE) == 0) {
3592 					mutex_exit(&asy->asy_excl_hi);
3593 					mutex_exit(&asy->asy_excl);
3594 					drv_usecwait(
3595 					    32*asyspdtab[index] & 0xfff);
3596 					mutex_enter(&asy->asy_excl);
3597 					mutex_enter(&asy->asy_excl_hi);
3598 				}
3599 				val = ddi_get8(asy->asy_iohandle,
3600 				    asy->asy_ioaddr + LCR);
3601 				ddi_put8(asy->asy_iohandle,
3602 				    asy->asy_ioaddr + LCR, (val | SETBREAK));
3603 				mutex_exit(&asy->asy_excl_hi);
3604 				/* wait for 100ms to hold BREAK */
3605 				async->async_utbrktid =
3606 				    timeout((void (*)())async_hold_utbrk,
3607 				    (caddr_t)async,
3608 				    drv_usectohz(asy_min_utbrk));
3609 			}
3610 			mioc2ack(mp, NULL, 0, 0);
3611 			break;
3612 
3613 		case TIOCCBRK:
3614 			if (async->async_flags & ASYNC_OUT_SUSPEND)
3615 				async_resume_utbrk(async);
3616 			mioc2ack(mp, NULL, 0, 0);
3617 			break;
3618 
3619 		case TIOCMSET:
3620 		case TIOCMBIS:
3621 		case TIOCMBIC:
3622 			if (iocp->ioc_count != TRANSPARENT) {
3623 				DEBUGCONT1(ASY_DEBUG_IOCTL, "async%d_ioctl: "
3624 				    "non-transparent\n", instance);
3625 
3626 				error = miocpullup(mp, sizeof (int));
3627 				if (error != 0)
3628 					break;
3629 
3630 				mutex_enter(&asy->asy_excl_hi);
3631 				(void) asymctl(asy,
3632 				    dmtoasy(*(int *)mp->b_cont->b_rptr),
3633 				    iocp->ioc_cmd);
3634 				mutex_exit(&asy->asy_excl_hi);
3635 				iocp->ioc_error = 0;
3636 				mp->b_datap->db_type = M_IOCACK;
3637 			} else {
3638 				DEBUGCONT1(ASY_DEBUG_IOCTL, "async%d_ioctl: "
3639 				    "transparent\n", instance);
3640 				mcopyin(mp, NULL, sizeof (int), NULL);
3641 			}
3642 			break;
3643 
3644 		case TIOCMGET:
3645 			datamp = allocb(sizeof (int), BPRI_MED);
3646 			if (datamp == NULL) {
3647 				error = EAGAIN;
3648 				break;
3649 			}
3650 
3651 			mutex_enter(&asy->asy_excl_hi);
3652 			*(int *)datamp->b_rptr = asymctl(asy, 0, TIOCMGET);
3653 			mutex_exit(&asy->asy_excl_hi);
3654 
3655 			if (iocp->ioc_count == TRANSPARENT) {
3656 				DEBUGCONT1(ASY_DEBUG_IOCTL, "async%d_ioctl: "
3657 				    "transparent\n", instance);
3658 				mcopyout(mp, NULL, sizeof (int), NULL, datamp);
3659 			} else {
3660 				DEBUGCONT1(ASY_DEBUG_IOCTL, "async%d_ioctl: "
3661 				    "non-transparent\n", instance);
3662 				mioc2ack(mp, datamp, sizeof (int), 0);
3663 			}
3664 			break;
3665 
3666 		case CONSOPENPOLLEDIO:
3667 			error = miocpullup(mp, sizeof (struct cons_polledio *));
3668 			if (error != 0)
3669 				break;
3670 
3671 			*(struct cons_polledio **)mp->b_cont->b_rptr =
3672 			    &asy->polledio;
3673 
3674 			mp->b_datap->db_type = M_IOCACK;
3675 			break;
3676 
3677 		case CONSCLOSEPOLLEDIO:
3678 			mp->b_datap->db_type = M_IOCACK;
3679 			iocp->ioc_error = 0;
3680 			iocp->ioc_rval = 0;
3681 			break;
3682 
3683 		case CONSSETABORTENABLE:
3684 			error = secpolicy_console(iocp->ioc_cr);
3685 			if (error != 0)
3686 				break;
3687 
3688 			if (iocp->ioc_count != TRANSPARENT) {
3689 				error = EINVAL;
3690 				break;
3691 			}
3692 
3693 			if (*(intptr_t *)mp->b_cont->b_rptr)
3694 				asy->asy_flags |= ASY_CONSOLE;
3695 			else
3696 				asy->asy_flags &= ~ASY_CONSOLE;
3697 
3698 			mp->b_datap->db_type = M_IOCACK;
3699 			iocp->ioc_error = 0;
3700 			iocp->ioc_rval = 0;
3701 			break;
3702 
3703 		case CONSGETABORTENABLE:
3704 			/*CONSTANTCONDITION*/
3705 			ASSERT(sizeof (boolean_t) <= sizeof (boolean_t *));
3706 			/*
3707 			 * Store the return value right in the payload
3708 			 * we were passed.  Crude.
3709 			 */
3710 			mcopyout(mp, NULL, sizeof (boolean_t), NULL, NULL);
3711 			*(boolean_t *)mp->b_cont->b_rptr =
3712 			    (asy->asy_flags & ASY_CONSOLE) != 0;
3713 			break;
3714 
3715 		default:
3716 			/*
3717 			 * If we don't understand it, it's an error.  NAK it.
3718 			 */
3719 			error = EINVAL;
3720 			break;
3721 		}
3722 	}
3723 	if (error != 0) {
3724 		iocp->ioc_error = error;
3725 		mp->b_datap->db_type = M_IOCNAK;
3726 	}
3727 	mutex_exit(&asy->asy_excl);
3728 	qreply(wq, mp);
3729 	DEBUGCONT1(ASY_DEBUG_PROCS, "async%d_ioctl: done\n", instance);
3730 }
3731 
3732 static int
3733 asyrsrv(queue_t *q)
3734 {
3735 	mblk_t *bp;
3736 	struct asyncline *async;
3737 
3738 	async = (struct asyncline *)q->q_ptr;
3739 
3740 	while (canputnext(q) && (bp = getq(q)))
3741 		putnext(q, bp);
3742 	ASYSETSOFT(async->async_common);
3743 	async->async_polltid = 0;
3744 	return (0);
3745 }
3746 
3747 /*
3748  * The ASYWPUTDO_NOT_SUSP macro indicates to asywputdo() whether it should
3749  * handle messages as though the driver is operating normally or is
3750  * suspended.  In the suspended case, some or all of the processing may have
3751  * to be delayed until the driver is resumed.
3752  */
3753 #define	ASYWPUTDO_NOT_SUSP(async, wput) \
3754 	!((wput) && ((async)->async_flags & ASYNC_DDI_SUSPENDED))
3755 
3756 /*
3757  * Processing for write queue put procedure.
3758  * Respond to M_STOP, M_START, M_IOCTL, and M_FLUSH messages here;
3759  * set the flow control character for M_STOPI and M_STARTI messages;
3760  * queue up M_BREAK, M_DELAY, and M_DATA messages for processing
3761  * by the start routine, and then call the start routine; discard
3762  * everything else.  Note that this driver does not incorporate any
3763  * mechanism to negotiate to handle the canonicalization process.
3764  * It expects that these functions are handled in upper module(s),
3765  * as we do in ldterm.
3766  */
3767 static int
3768 asywputdo(queue_t *q, mblk_t *mp, boolean_t wput)
3769 {
3770 	struct asyncline *async;
3771 	struct asycom *asy;
3772 #ifdef DEBUG
3773 	int instance;
3774 #endif
3775 	int error;
3776 
3777 	async = (struct asyncline *)q->q_ptr;
3778 
3779 #ifdef DEBUG
3780 	instance = UNIT(async->async_dev);
3781 #endif
3782 	asy = async->async_common;
3783 
3784 	switch (mp->b_datap->db_type) {
3785 
3786 	case M_STOP:
3787 		/*
3788 		 * Since we don't do real DMA, we can just let the
3789 		 * chip coast to a stop after applying the brakes.
3790 		 */
3791 		mutex_enter(&asy->asy_excl);
3792 		async->async_flags |= ASYNC_STOPPED;
3793 		mutex_exit(&asy->asy_excl);
3794 		freemsg(mp);
3795 		break;
3796 
3797 	case M_START:
3798 		mutex_enter(&asy->asy_excl);
3799 		if (async->async_flags & ASYNC_STOPPED) {
3800 			async->async_flags &= ~ASYNC_STOPPED;
3801 			if (ASYWPUTDO_NOT_SUSP(async, wput)) {
3802 				/*
3803 				 * If an output operation is in progress,
3804 				 * resume it.  Otherwise, prod the start
3805 				 * routine.
3806 				 */
3807 				if (async->async_ocnt > 0) {
3808 					mutex_enter(&asy->asy_excl_hi);
3809 					async_resume(async);
3810 					mutex_exit(&asy->asy_excl_hi);
3811 				} else {
3812 					async_start(async);
3813 				}
3814 			}
3815 		}
3816 		mutex_exit(&asy->asy_excl);
3817 		freemsg(mp);
3818 		break;
3819 
3820 	case M_IOCTL:
3821 		switch (((struct iocblk *)mp->b_rptr)->ioc_cmd) {
3822 
3823 		case TCSBRK:
3824 			error = miocpullup(mp, sizeof (int));
3825 			if (error != 0) {
3826 				miocnak(q, mp, 0, error);
3827 				return (0);
3828 			}
3829 
3830 			if (*(int *)mp->b_cont->b_rptr != 0) {
3831 				DEBUGCONT1(ASY_DEBUG_OUT,
3832 				    "async%d_ioctl: flush request.\n",
3833 				    instance);
3834 				(void) putq(q, mp);
3835 
3836 				mutex_enter(&asy->asy_excl);
3837 				if (ASYWPUTDO_NOT_SUSP(async, wput)) {
3838 					/*
3839 					 * If an TIOCSBRK is in progress,
3840 					 * clean it as TIOCCBRK does,
3841 					 * then kick off output.
3842 					 * If TIOCSBRK is not in progress,
3843 					 * just kick off output.
3844 					 */
3845 					async_resume_utbrk(async);
3846 				}
3847 				mutex_exit(&asy->asy_excl);
3848 				break;
3849 			}
3850 			/*FALLTHROUGH*/
3851 		case TCSETSW:
3852 		case TCSETSF:
3853 		case TCSETAW:
3854 		case TCSETAF:
3855 			/*
3856 			 * The changes do not take effect until all
3857 			 * output queued before them is drained.
3858 			 * Put this message on the queue, so that
3859 			 * "async_start" will see it when it's done
3860 			 * with the output before it.  Poke the
3861 			 * start routine, just in case.
3862 			 */
3863 			(void) putq(q, mp);
3864 
3865 			mutex_enter(&asy->asy_excl);
3866 			if (ASYWPUTDO_NOT_SUSP(async, wput)) {
3867 				/*
3868 				 * If an TIOCSBRK is in progress,
3869 				 * clean it as TIOCCBRK does.
3870 				 * then kick off output.
3871 				 * If TIOCSBRK is not in progress,
3872 				 * just kick off output.
3873 				 */
3874 				async_resume_utbrk(async);
3875 			}
3876 			mutex_exit(&asy->asy_excl);
3877 			break;
3878 
3879 		default:
3880 			/*
3881 			 * Do it now.
3882 			 */
3883 			mutex_enter(&asy->asy_excl);
3884 			if (ASYWPUTDO_NOT_SUSP(async, wput)) {
3885 				mutex_exit(&asy->asy_excl);
3886 				async_ioctl(async, q, mp);
3887 				break;
3888 			}
3889 			async_put_suspq(asy, mp);
3890 			mutex_exit(&asy->asy_excl);
3891 			break;
3892 		}
3893 		break;
3894 
3895 	case M_FLUSH:
3896 		if (*mp->b_rptr & FLUSHW) {
3897 			mutex_enter(&asy->asy_excl);
3898 
3899 			/*
3900 			 * Abort any output in progress.
3901 			 */
3902 			mutex_enter(&asy->asy_excl_hi);
3903 			if (async->async_flags & ASYNC_BUSY) {
3904 				DEBUGCONT1(ASY_DEBUG_BUSY, "asy%dwput: "
3905 				    "Clearing async_ocnt, "
3906 				    "leaving ASYNC_BUSY set\n",
3907 				    instance);
3908 				async->async_ocnt = 0;
3909 				async->async_flags &= ~ASYNC_BUSY;
3910 			} /* if */
3911 
3912 			if (ASYWPUTDO_NOT_SUSP(async, wput)) {
3913 				/* Flush FIFO buffers */
3914 				if (asy->asy_use_fifo == FIFO_ON) {
3915 					asy_reset_fifo(asy, FIFOTXFLSH);
3916 				}
3917 			}
3918 			mutex_exit(&asy->asy_excl_hi);
3919 
3920 			/* Flush FIFO buffers */
3921 			if (asy->asy_use_fifo == FIFO_ON) {
3922 				asy_reset_fifo(asy, FIFOTXFLSH);
3923 			}
3924 
3925 			/*
3926 			 * Flush our write queue.
3927 			 */
3928 			flushq(q, FLUSHDATA);	/* XXX doesn't flush M_DELAY */
3929 			if (async->async_xmitblk != NULL) {
3930 				freeb(async->async_xmitblk);
3931 				async->async_xmitblk = NULL;
3932 			}
3933 			mutex_exit(&asy->asy_excl);
3934 			*mp->b_rptr &= ~FLUSHW;	/* it has been flushed */
3935 		}
3936 		if (*mp->b_rptr & FLUSHR) {
3937 			if (ASYWPUTDO_NOT_SUSP(async, wput)) {
3938 				/* Flush FIFO buffers */
3939 				if (asy->asy_use_fifo == FIFO_ON) {
3940 					asy_reset_fifo(asy, FIFORXFLSH);
3941 				}
3942 			}
3943 			flushq(RD(q), FLUSHDATA);
3944 			qreply(q, mp);	/* give the read queues a crack at it */
3945 		} else {
3946 			freemsg(mp);
3947 		}
3948 
3949 		/*
3950 		 * We must make sure we process messages that survive the
3951 		 * write-side flush.
3952 		 */
3953 		if (ASYWPUTDO_NOT_SUSP(async, wput)) {
3954 			mutex_enter(&asy->asy_excl);
3955 			async_start(async);
3956 			mutex_exit(&asy->asy_excl);
3957 		}
3958 		break;
3959 
3960 	case M_BREAK:
3961 	case M_DELAY:
3962 	case M_DATA:
3963 		/*
3964 		 * Queue the message up to be transmitted,
3965 		 * and poke the start routine.
3966 		 */
3967 		(void) putq(q, mp);
3968 		if (ASYWPUTDO_NOT_SUSP(async, wput)) {
3969 			mutex_enter(&asy->asy_excl);
3970 			async_start(async);
3971 			mutex_exit(&asy->asy_excl);
3972 		}
3973 		break;
3974 
3975 	case M_STOPI:
3976 		mutex_enter(&asy->asy_excl);
3977 		if (ASYWPUTDO_NOT_SUSP(async, wput)) {
3978 			mutex_enter(&asy->asy_excl_hi);
3979 			if (!(async->async_inflow_source & IN_FLOW_USER)) {
3980 				async_flowcontrol_hw_input(asy, FLOW_STOP,
3981 				    IN_FLOW_USER);
3982 				(void) async_flowcontrol_sw_input(asy,
3983 				    FLOW_STOP, IN_FLOW_USER);
3984 			}
3985 			mutex_exit(&asy->asy_excl_hi);
3986 			mutex_exit(&asy->asy_excl);
3987 			freemsg(mp);
3988 			break;
3989 		}
3990 		async_put_suspq(asy, mp);
3991 		mutex_exit(&asy->asy_excl);
3992 		break;
3993 
3994 	case M_STARTI:
3995 		mutex_enter(&asy->asy_excl);
3996 		if (ASYWPUTDO_NOT_SUSP(async, wput)) {
3997 			mutex_enter(&asy->asy_excl_hi);
3998 			if (async->async_inflow_source & IN_FLOW_USER) {
3999 				async_flowcontrol_hw_input(asy, FLOW_START,
4000 				    IN_FLOW_USER);
4001 				(void) async_flowcontrol_sw_input(asy,
4002 				    FLOW_START, IN_FLOW_USER);
4003 			}
4004 			mutex_exit(&asy->asy_excl_hi);
4005 			mutex_exit(&asy->asy_excl);
4006 			freemsg(mp);
4007 			break;
4008 		}
4009 		async_put_suspq(asy, mp);
4010 		mutex_exit(&asy->asy_excl);
4011 		break;
4012 
4013 	case M_CTL:
4014 		if (MBLKL(mp) >= sizeof (struct iocblk) &&
4015 		    ((struct iocblk *)mp->b_rptr)->ioc_cmd == MC_POSIXQUERY) {
4016 			mutex_enter(&asy->asy_excl);
4017 			if (ASYWPUTDO_NOT_SUSP(async, wput)) {
4018 				((struct iocblk *)mp->b_rptr)->ioc_cmd =
4019 				    MC_HAS_POSIX;
4020 				mutex_exit(&asy->asy_excl);
4021 				qreply(q, mp);
4022 				break;
4023 			} else {
4024 				async_put_suspq(asy, mp);
4025 			}
4026 		} else {
4027 			/*
4028 			 * These MC_SERVICE type messages are used by upper
4029 			 * modules to tell this driver to send input up
4030 			 * immediately, or that it can wait for normal
4031 			 * processing that may or may not be done.  Sun
4032 			 * requires these for the mouse module.
4033 			 * (XXX - for x86?)
4034 			 */
4035 			mutex_enter(&asy->asy_excl);
4036 			switch (*mp->b_rptr) {
4037 
4038 			case MC_SERVICEIMM:
4039 				async->async_flags |= ASYNC_SERVICEIMM;
4040 				break;
4041 
4042 			case MC_SERVICEDEF:
4043 				async->async_flags &= ~ASYNC_SERVICEIMM;
4044 				break;
4045 			}
4046 			mutex_exit(&asy->asy_excl);
4047 			freemsg(mp);
4048 		}
4049 		break;
4050 
4051 	case M_IOCDATA:
4052 		mutex_enter(&asy->asy_excl);
4053 		if (ASYWPUTDO_NOT_SUSP(async, wput)) {
4054 			mutex_exit(&asy->asy_excl);
4055 			async_iocdata(q, mp);
4056 			break;
4057 		}
4058 		async_put_suspq(asy, mp);
4059 		mutex_exit(&asy->asy_excl);
4060 		break;
4061 
4062 	default:
4063 		freemsg(mp);
4064 		break;
4065 	}
4066 	return (0);
4067 }
4068 
4069 static int
4070 asywput(queue_t *q, mblk_t *mp)
4071 {
4072 	return (asywputdo(q, mp, B_TRUE));
4073 }
4074 
4075 /*
4076  * Retry an "ioctl", now that "bufcall" claims we may be able to allocate
4077  * the buffer we need.
4078  */
4079 static void
4080 async_reioctl(void *unit)
4081 {
4082 	int instance = (uintptr_t)unit;
4083 	struct asyncline *async;
4084 	struct asycom *asy;
4085 	queue_t	*q;
4086 	mblk_t	*mp;
4087 
4088 	asy = ddi_get_soft_state(asy_soft_state, instance);
4089 	ASSERT(asy != NULL);
4090 	async = asy->asy_priv;
4091 
4092 	/*
4093 	 * The bufcall is no longer pending.
4094 	 */
4095 	mutex_enter(&asy->asy_excl);
4096 	async->async_wbufcid = 0;
4097 	if ((q = async->async_ttycommon.t_writeq) == NULL) {
4098 		mutex_exit(&asy->asy_excl);
4099 		return;
4100 	}
4101 	if ((mp = async->async_ttycommon.t_iocpending) != NULL) {
4102 		/* not pending any more */
4103 		async->async_ttycommon.t_iocpending = NULL;
4104 		mutex_exit(&asy->asy_excl);
4105 		async_ioctl(async, q, mp);
4106 	} else
4107 		mutex_exit(&asy->asy_excl);
4108 }
4109 
4110 static void
4111 async_iocdata(queue_t *q, mblk_t *mp)
4112 {
4113 	struct asyncline	*async = (struct asyncline *)q->q_ptr;
4114 	struct asycom		*asy;
4115 	struct iocblk *ip;
4116 	struct copyresp *csp;
4117 #ifdef DEBUG
4118 	int instance = UNIT(async->async_dev);
4119 #endif
4120 
4121 	asy = async->async_common;
4122 	ip = (struct iocblk *)mp->b_rptr;
4123 	csp = (struct copyresp *)mp->b_rptr;
4124 
4125 	if (csp->cp_rval != 0) {
4126 		if (csp->cp_private)
4127 			freemsg(csp->cp_private);
4128 		freemsg(mp);
4129 		return;
4130 	}
4131 
4132 	mutex_enter(&asy->asy_excl);
4133 	DEBUGCONT2(ASY_DEBUG_MODEM, "async%d_iocdata: case %s\n",
4134 	    instance,
4135 	    csp->cp_cmd == TIOCMGET ? "TIOCMGET" :
4136 	    csp->cp_cmd == TIOCMSET ? "TIOCMSET" :
4137 	    csp->cp_cmd == TIOCMBIS ? "TIOCMBIS" :
4138 	    "TIOCMBIC");
4139 	switch (csp->cp_cmd) {
4140 
4141 	case TIOCMGET:
4142 		if (mp->b_cont) {
4143 			freemsg(mp->b_cont);
4144 			mp->b_cont = NULL;
4145 		}
4146 		mp->b_datap->db_type = M_IOCACK;
4147 		ip->ioc_error = 0;
4148 		ip->ioc_count = 0;
4149 		ip->ioc_rval = 0;
4150 		mp->b_wptr = mp->b_rptr + sizeof (struct iocblk);
4151 		break;
4152 
4153 	case TIOCMSET:
4154 	case TIOCMBIS:
4155 	case TIOCMBIC:
4156 		mutex_enter(&asy->asy_excl_hi);
4157 		(void) asymctl(asy, dmtoasy(*(int *)mp->b_cont->b_rptr),
4158 		    csp->cp_cmd);
4159 		mutex_exit(&asy->asy_excl_hi);
4160 		mioc2ack(mp, NULL, 0, 0);
4161 		break;
4162 
4163 	default:
4164 		mp->b_datap->db_type = M_IOCNAK;
4165 		ip->ioc_error = EINVAL;
4166 		break;
4167 	}
4168 	qreply(q, mp);
4169 	mutex_exit(&asy->asy_excl);
4170 }
4171 
4172 /*
4173  * debugger/console support routines.
4174  */
4175 
4176 /*
4177  * put a character out
4178  * Do not use interrupts.  If char is LF, put out CR, LF.
4179  */
4180 static void
4181 asyputchar(cons_polledio_arg_t arg, uchar_t c)
4182 {
4183 	struct asycom *asy = (struct asycom *)arg;
4184 
4185 	if (c == '\n')
4186 		asyputchar(arg, '\r');
4187 
4188 	while ((ddi_get8(asy->asy_iohandle,
4189 	    asy->asy_ioaddr + LSR) & XHRE) == 0) {
4190 		/* wait for xmit to finish */
4191 		drv_usecwait(10);
4192 	}
4193 
4194 	/* put the character out */
4195 	ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT, c);
4196 }
4197 
4198 /*
4199  * See if there's a character available. If no character is
4200  * available, return 0. Run in polled mode, no interrupts.
4201  */
4202 static boolean_t
4203 asyischar(cons_polledio_arg_t arg)
4204 {
4205 	struct asycom *asy = (struct asycom *)arg;
4206 
4207 	return ((ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR) & RCA)
4208 	    != 0);
4209 }
4210 
4211 /*
4212  * Get a character. Run in polled mode, no interrupts.
4213  */
4214 static int
4215 asygetchar(cons_polledio_arg_t arg)
4216 {
4217 	struct asycom *asy = (struct asycom *)arg;
4218 
4219 	while (!asyischar(arg))
4220 		drv_usecwait(10);
4221 	return (ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + DAT));
4222 }
4223 
4224 /*
4225  * Set or get the modem control status.
4226  */
4227 static int
4228 asymctl(struct asycom *asy, int bits, int how)
4229 {
4230 	int mcr_r, msr_r;
4231 	int instance = asy->asy_unit;
4232 
4233 	ASSERT(mutex_owned(&asy->asy_excl_hi));
4234 	ASSERT(mutex_owned(&asy->asy_excl));
4235 
4236 	/* Read Modem Control Registers */
4237 	mcr_r = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MCR);
4238 
4239 	switch (how) {
4240 
4241 	case TIOCMSET:
4242 		DEBUGCONT2(ASY_DEBUG_MODEM,
4243 		    "asy%dmctl: TIOCMSET, bits = %x\n", instance, bits);
4244 		mcr_r = bits;		/* Set bits	*/
4245 		break;
4246 
4247 	case TIOCMBIS:
4248 		DEBUGCONT2(ASY_DEBUG_MODEM, "asy%dmctl: TIOCMBIS, bits = %x\n",
4249 		    instance, bits);
4250 		mcr_r |= bits;		/* Mask in bits	*/
4251 		break;
4252 
4253 	case TIOCMBIC:
4254 		DEBUGCONT2(ASY_DEBUG_MODEM, "asy%dmctl: TIOCMBIC, bits = %x\n",
4255 		    instance, bits);
4256 		mcr_r &= ~bits;		/* Mask out bits */
4257 		break;
4258 
4259 	case TIOCMGET:
4260 		/* Read Modem Status Registers */
4261 		/*
4262 		 * If modem interrupts are enabled, we return the
4263 		 * saved value of msr. We read MSR only in async_msint()
4264 		 */
4265 		if (ddi_get8(asy->asy_iohandle,
4266 		    asy->asy_ioaddr + ICR) & MIEN) {
4267 			msr_r = asy->asy_msr;
4268 			DEBUGCONT2(ASY_DEBUG_MODEM,
4269 			    "asy%dmctl: TIOCMGET, read msr_r = %x\n",
4270 			    instance, msr_r);
4271 		} else {
4272 			msr_r = ddi_get8(asy->asy_iohandle,
4273 			    asy->asy_ioaddr + MSR);
4274 			DEBUGCONT2(ASY_DEBUG_MODEM,
4275 			    "asy%dmctl: TIOCMGET, read MSR = %x\n",
4276 			    instance, msr_r);
4277 		}
4278 		DEBUGCONT2(ASY_DEBUG_MODEM, "asy%dtodm: modem_lines = %x\n",
4279 		    instance, asytodm(mcr_r, msr_r));
4280 		return (asytodm(mcr_r, msr_r));
4281 	}
4282 
4283 	ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR, mcr_r);
4284 
4285 	return (mcr_r);
4286 }
4287 
4288 static int
4289 asytodm(int mcr_r, int msr_r)
4290 {
4291 	int b = 0;
4292 
4293 	/* MCR registers */
4294 	if (mcr_r & RTS)
4295 		b |= TIOCM_RTS;
4296 
4297 	if (mcr_r & DTR)
4298 		b |= TIOCM_DTR;
4299 
4300 	/* MSR registers */
4301 	if (msr_r & DCD)
4302 		b |= TIOCM_CAR;
4303 
4304 	if (msr_r & CTS)
4305 		b |= TIOCM_CTS;
4306 
4307 	if (msr_r & DSR)
4308 		b |= TIOCM_DSR;
4309 
4310 	if (msr_r & RI)
4311 		b |= TIOCM_RNG;
4312 	return (b);
4313 }
4314 
4315 static int
4316 dmtoasy(int bits)
4317 {
4318 	int b = 0;
4319 
4320 	DEBUGCONT1(ASY_DEBUG_MODEM, "dmtoasy: bits = %x\n", bits);
4321 #ifdef	CAN_NOT_SET	/* only DTR and RTS can be set */
4322 	if (bits & TIOCM_CAR)
4323 		b |= DCD;
4324 	if (bits & TIOCM_CTS)
4325 		b |= CTS;
4326 	if (bits & TIOCM_DSR)
4327 		b |= DSR;
4328 	if (bits & TIOCM_RNG)
4329 		b |= RI;
4330 #endif
4331 
4332 	if (bits & TIOCM_RTS) {
4333 		DEBUGCONT0(ASY_DEBUG_MODEM, "dmtoasy: set b & RTS\n");
4334 		b |= RTS;
4335 	}
4336 	if (bits & TIOCM_DTR) {
4337 		DEBUGCONT0(ASY_DEBUG_MODEM, "dmtoasy: set b & DTR\n");
4338 		b |= DTR;
4339 	}
4340 
4341 	return (b);
4342 }
4343 
4344 static void
4345 asyerror(int level, const char *fmt, ...)
4346 {
4347 	va_list adx;
4348 	static	time_t	last;
4349 	static	const char *lastfmt;
4350 	time_t	now;
4351 
4352 	/*
4353 	 * Don't print the same error message too often.
4354 	 * Print the message only if we have not printed the
4355 	 * message within the last second.
4356 	 * Note: that fmt cannot be a pointer to a string
4357 	 * stored on the stack. The fmt pointer
4358 	 * must be in the data segment otherwise lastfmt would point
4359 	 * to non-sense.
4360 	 */
4361 	now = gethrestime_sec();
4362 	if (last == now && lastfmt == fmt)
4363 		return;
4364 
4365 	last = now;
4366 	lastfmt = fmt;
4367 
4368 	va_start(adx, fmt);
4369 	vcmn_err(level, fmt, adx);
4370 	va_end(adx);
4371 }
4372 
4373 /*
4374  * asy_parse_mode(dev_info_t *devi, struct asycom *asy)
4375  * The value of this property is in the form of "9600,8,n,1,-"
4376  * 1) speed: 9600, 4800, ...
4377  * 2) data bits
4378  * 3) parity: n(none), e(even), o(odd)
4379  * 4) stop bits
4380  * 5) handshake: -(none), h(hardware: rts/cts), s(software: xon/off)
4381  *
4382  * This parsing came from a SPARCstation eeprom.
4383  */
4384 static void
4385 asy_parse_mode(dev_info_t *devi, struct asycom *asy)
4386 {
4387 	char		name[40];
4388 	char		val[40];
4389 	int		len;
4390 	int		ret;
4391 	char		*p;
4392 	char		*p1;
4393 
4394 	ASSERT(asy->asy_com_port != 0);
4395 
4396 	/*
4397 	 * Parse the ttyx-mode property
4398 	 */
4399 	(void) sprintf(name, "tty%c-mode", asy->asy_com_port + 'a' - 1);
4400 	len = sizeof (val);
4401 	ret = GET_PROP(devi, name, DDI_PROP_CANSLEEP, val, &len);
4402 	if (ret != DDI_PROP_SUCCESS) {
4403 		(void) sprintf(name, "com%c-mode", asy->asy_com_port + '0');
4404 		len = sizeof (val);
4405 		ret = GET_PROP(devi, name, DDI_PROP_CANSLEEP, val, &len);
4406 	}
4407 
4408 	/* no property to parse */
4409 	asy->asy_cflag = 0;
4410 	if (ret != DDI_PROP_SUCCESS)
4411 		return;
4412 
4413 	p = val;
4414 	/* ---- baud rate ---- */
4415 	asy->asy_cflag = CREAD|B9600;		/* initial default */
4416 	if (p && (p1 = strchr(p, ',')) != 0) {
4417 		*p1++ = '\0';
4418 	} else {
4419 		asy->asy_cflag |= BITS8;	/* add default bits */
4420 		return;
4421 	}
4422 
4423 	if (strcmp(p, "110") == 0)
4424 		asy->asy_bidx = B110;
4425 	else if (strcmp(p, "150") == 0)
4426 		asy->asy_bidx = B150;
4427 	else if (strcmp(p, "300") == 0)
4428 		asy->asy_bidx = B300;
4429 	else if (strcmp(p, "600") == 0)
4430 		asy->asy_bidx = B600;
4431 	else if (strcmp(p, "1200") == 0)
4432 		asy->asy_bidx = B1200;
4433 	else if (strcmp(p, "2400") == 0)
4434 		asy->asy_bidx = B2400;
4435 	else if (strcmp(p, "4800") == 0)
4436 		asy->asy_bidx = B4800;
4437 	else if (strcmp(p, "9600") == 0)
4438 		asy->asy_bidx = B9600;
4439 	else if (strcmp(p, "19200") == 0)
4440 		asy->asy_bidx = B19200;
4441 	else if (strcmp(p, "38400") == 0)
4442 		asy->asy_bidx = B38400;
4443 	else if (strcmp(p, "57600") == 0)
4444 		asy->asy_bidx = B57600;
4445 	else if (strcmp(p, "115200") == 0)
4446 		asy->asy_bidx = B115200;
4447 	else
4448 		asy->asy_bidx = B9600;
4449 
4450 	asy->asy_cflag &= ~CBAUD;
4451 	if (asy->asy_bidx > CBAUD) {	/* > 38400 uses the CBAUDEXT bit */
4452 		asy->asy_cflag |= CBAUDEXT;
4453 		asy->asy_cflag |= asy->asy_bidx - CBAUD - 1;
4454 	} else {
4455 		asy->asy_cflag |= asy->asy_bidx;
4456 	}
4457 
4458 	ASSERT(asy->asy_bidx == BAUDINDEX(asy->asy_cflag));
4459 
4460 	/* ---- Next item is data bits ---- */
4461 	p = p1;
4462 	if (p && (p1 = strchr(p, ',')) != 0)  {
4463 		*p1++ = '\0';
4464 	} else {
4465 		asy->asy_cflag |= BITS8;	/* add default bits */
4466 		return;
4467 	}
4468 	switch (*p) {
4469 		default:
4470 		case '8':
4471 			asy->asy_cflag |= CS8;
4472 			asy->asy_lcr = BITS8;
4473 			break;
4474 		case '7':
4475 			asy->asy_cflag |= CS7;
4476 			asy->asy_lcr = BITS7;
4477 			break;
4478 		case '6':
4479 			asy->asy_cflag |= CS6;
4480 			asy->asy_lcr = BITS6;
4481 			break;
4482 		case '5':
4483 			/* LINTED: CS5 is currently zero (but might change) */
4484 			asy->asy_cflag |= CS5;
4485 			asy->asy_lcr = BITS5;
4486 			break;
4487 	}
4488 
4489 	/* ---- Parity info ---- */
4490 	p = p1;
4491 	if (p && (p1 = strchr(p, ',')) != 0)  {
4492 		*p1++ = '\0';
4493 	} else {
4494 		return;
4495 	}
4496 	switch (*p)  {
4497 		default:
4498 		case 'n':
4499 			break;
4500 		case 'e':
4501 			asy->asy_cflag |= PARENB;
4502 			asy->asy_lcr |= PEN; break;
4503 		case 'o':
4504 			asy->asy_cflag |= PARENB|PARODD;
4505 			asy->asy_lcr |= PEN|EPS;
4506 			break;
4507 	}
4508 
4509 	/* ---- Find stop bits ---- */
4510 	p = p1;
4511 	if (p && (p1 = strchr(p, ',')) != 0)  {
4512 		*p1++ = '\0';
4513 	} else {
4514 		return;
4515 	}
4516 	if (*p == '2') {
4517 		asy->asy_cflag |= CSTOPB;
4518 		asy->asy_lcr |= STB;
4519 	}
4520 
4521 	/* ---- handshake is next ---- */
4522 	p = p1;
4523 	if (p) {
4524 		if ((p1 = strchr(p, ',')) != 0)
4525 			*p1++ = '\0';
4526 
4527 		if (*p == 'h')
4528 			asy->asy_cflag |= CRTSCTS;
4529 		else if (*p == 's')
4530 			asy->asy_cflag |= CRTSXOFF;
4531 	}
4532 }
4533 
4534 /*
4535  * Check for abort character sequence
4536  */
4537 static boolean_t
4538 abort_charseq_recognize(uchar_t ch)
4539 {
4540 	static int state = 0;
4541 #define	CNTRL(c) ((c)&037)
4542 	static char sequence[] = { '\r', '~', CNTRL('b') };
4543 
4544 	if (ch == sequence[state]) {
4545 		if (++state >= sizeof (sequence)) {
4546 			state = 0;
4547 			return (B_TRUE);
4548 		}
4549 	} else {
4550 		state = (ch == sequence[0]) ? 1 : 0;
4551 	}
4552 	return (B_FALSE);
4553 }
4554 
4555 /*
4556  * Flow control functions
4557  */
4558 /*
4559  * Software input flow control
4560  * This function can execute software input flow control sucessfully
4561  * at most of situations except that the line is in BREAK status
4562  * (timed and untimed break).
4563  * INPUT VALUE of onoff:
4564  *               FLOW_START means to send out a XON char
4565  *                          and clear SW input flow control flag.
4566  *               FLOW_STOP means to send out a XOFF char
4567  *                          and set SW input flow control flag.
4568  *               FLOW_CHECK means to check whether there is pending XON/XOFF
4569  *                          if it is true, send it out.
4570  * INPUT VALUE of type:
4571  *		 IN_FLOW_RINGBUFF means flow control is due to RING BUFFER
4572  *		 IN_FLOW_STREAMS means flow control is due to STREAMS
4573  *		 IN_FLOW_USER means flow control is due to user's commands
4574  * RETURN VALUE: B_FALSE means no flow control char is sent
4575  *               B_TRUE means one flow control char is sent
4576  */
4577 static boolean_t
4578 async_flowcontrol_sw_input(struct asycom *asy, async_flowc_action onoff,
4579     int type)
4580 {
4581 	struct asyncline *async = asy->asy_priv;
4582 	int instance = UNIT(async->async_dev);
4583 	int rval = B_FALSE;
4584 
4585 	ASSERT(mutex_owned(&asy->asy_excl_hi));
4586 
4587 	if (!(async->async_ttycommon.t_iflag & IXOFF))
4588 		return (rval);
4589 
4590 	/*
4591 	 * If we get this far, then we know IXOFF is set.
4592 	 */
4593 	switch (onoff) {
4594 	case FLOW_STOP:
4595 		async->async_inflow_source |= type;
4596 
4597 		/*
4598 		 * We'll send an XOFF character for each of up to
4599 		 * three different input flow control attempts to stop input.
4600 		 * If we already send out one XOFF, but FLOW_STOP comes again,
4601 		 * it seems that input flow control becomes more serious,
4602 		 * then send XOFF again.
4603 		 */
4604 		if (async->async_inflow_source & (IN_FLOW_RINGBUFF |
4605 		    IN_FLOW_STREAMS | IN_FLOW_USER))
4606 			async->async_flags |= ASYNC_SW_IN_FLOW |
4607 			    ASYNC_SW_IN_NEEDED;
4608 		DEBUGCONT2(ASY_DEBUG_SFLOW, "async%d: input sflow stop, "
4609 		    "type = %x\n", instance, async->async_inflow_source);
4610 		break;
4611 	case FLOW_START:
4612 		async->async_inflow_source &= ~type;
4613 		if (async->async_inflow_source == 0) {
4614 			async->async_flags = (async->async_flags &
4615 			    ~ASYNC_SW_IN_FLOW) | ASYNC_SW_IN_NEEDED;
4616 			DEBUGCONT1(ASY_DEBUG_SFLOW, "async%d: "
4617 			    "input sflow start\n", instance);
4618 		}
4619 		break;
4620 	default:
4621 		break;
4622 	}
4623 
4624 	if (((async->async_flags & (ASYNC_SW_IN_NEEDED | ASYNC_BREAK |
4625 	    ASYNC_OUT_SUSPEND)) == ASYNC_SW_IN_NEEDED) &&
4626 	    (ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR) & XHRE)) {
4627 		/*
4628 		 * If we get this far, then we know we need to send out
4629 		 * XON or XOFF char.
4630 		 */
4631 		async->async_flags = (async->async_flags &
4632 		    ~ASYNC_SW_IN_NEEDED) | ASYNC_BUSY;
4633 		ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT,
4634 		    async->async_flags & ASYNC_SW_IN_FLOW ?
4635 		    async->async_stopc : async->async_startc);
4636 		rval = B_TRUE;
4637 	}
4638 	return (rval);
4639 }
4640 
4641 /*
4642  * Software output flow control
4643  * This function can be executed sucessfully at any situation.
4644  * It does not handle HW, and just change the SW output flow control flag.
4645  * INPUT VALUE of onoff:
4646  *                 FLOW_START means to clear SW output flow control flag,
4647  *			also combine with HW output flow control status to
4648  *			determine if we need to set ASYNC_OUT_FLW_RESUME.
4649  *                 FLOW_STOP means to set SW output flow control flag,
4650  *			also clear ASYNC_OUT_FLW_RESUME.
4651  */
4652 static void
4653 async_flowcontrol_sw_output(struct asycom *asy, async_flowc_action onoff)
4654 {
4655 	struct asyncline *async = asy->asy_priv;
4656 	int instance = UNIT(async->async_dev);
4657 
4658 	ASSERT(mutex_owned(&asy->asy_excl_hi));
4659 
4660 	if (!(async->async_ttycommon.t_iflag & IXON))
4661 		return;
4662 
4663 	switch (onoff) {
4664 	case FLOW_STOP:
4665 		async->async_flags |= ASYNC_SW_OUT_FLW;
4666 		async->async_flags &= ~ASYNC_OUT_FLW_RESUME;
4667 		DEBUGCONT1(ASY_DEBUG_SFLOW, "async%d: output sflow stop\n",
4668 		    instance);
4669 		break;
4670 	case FLOW_START:
4671 		async->async_flags &= ~ASYNC_SW_OUT_FLW;
4672 		if (!(async->async_flags & ASYNC_HW_OUT_FLW))
4673 			async->async_flags |= ASYNC_OUT_FLW_RESUME;
4674 		DEBUGCONT1(ASY_DEBUG_SFLOW, "async%d: output sflow start\n",
4675 		    instance);
4676 		break;
4677 	default:
4678 		break;
4679 	}
4680 }
4681 
4682 /*
4683  * Hardware input flow control
4684  * This function can be executed sucessfully at any situation.
4685  * It directly changes RTS depending on input parameter onoff.
4686  * INPUT VALUE of onoff:
4687  *       FLOW_START means to clear HW input flow control flag,
4688  *                  and pull up RTS if it is low.
4689  *       FLOW_STOP means to set HW input flow control flag,
4690  *                  and low RTS if it is high.
4691  * INPUT VALUE of type:
4692  *		 IN_FLOW_RINGBUFF means flow control is due to RING BUFFER
4693  *		 IN_FLOW_STREAMS means flow control is due to STREAMS
4694  *		 IN_FLOW_USER means flow control is due to user's commands
4695  */
4696 static void
4697 async_flowcontrol_hw_input(struct asycom *asy, async_flowc_action onoff,
4698     int type)
4699 {
4700 	uchar_t	mcr;
4701 	uchar_t	flag;
4702 	struct asyncline *async = asy->asy_priv;
4703 	int instance = UNIT(async->async_dev);
4704 
4705 	ASSERT(mutex_owned(&asy->asy_excl_hi));
4706 
4707 	if (!(async->async_ttycommon.t_cflag & CRTSXOFF))
4708 		return;
4709 
4710 	switch (onoff) {
4711 	case FLOW_STOP:
4712 		async->async_inflow_source |= type;
4713 		if (async->async_inflow_source & (IN_FLOW_RINGBUFF |
4714 		    IN_FLOW_STREAMS | IN_FLOW_USER))
4715 			async->async_flags |= ASYNC_HW_IN_FLOW;
4716 		DEBUGCONT2(ASY_DEBUG_HFLOW, "async%d: input hflow stop, "
4717 		    "type = %x\n", instance, async->async_inflow_source);
4718 		break;
4719 	case FLOW_START:
4720 		async->async_inflow_source &= ~type;
4721 		if (async->async_inflow_source == 0) {
4722 			async->async_flags &= ~ASYNC_HW_IN_FLOW;
4723 			DEBUGCONT1(ASY_DEBUG_HFLOW, "async%d: "
4724 			    "input hflow start\n", instance);
4725 		}
4726 		break;
4727 	default:
4728 		break;
4729 	}
4730 	mcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MCR);
4731 	flag = (async->async_flags & ASYNC_HW_IN_FLOW) ? 0 : RTS;
4732 
4733 	if (((mcr ^ flag) & RTS) != 0) {
4734 		ddi_put8(asy->asy_iohandle,
4735 		    asy->asy_ioaddr + MCR, (mcr ^ RTS));
4736 	}
4737 }
4738 
4739 /*
4740  * Hardware output flow control
4741  * This function can execute HW output flow control sucessfully
4742  * at any situation.
4743  * It doesn't really change RTS, and just change
4744  * HW output flow control flag depending on CTS status.
4745  * INPUT VALUE of onoff:
4746  *                FLOW_START means to clear HW output flow control flag.
4747  *			also combine with SW output flow control status to
4748  *			determine if we need to set ASYNC_OUT_FLW_RESUME.
4749  *                FLOW_STOP means to set HW output flow control flag.
4750  *			also clear ASYNC_OUT_FLW_RESUME.
4751  */
4752 static void
4753 async_flowcontrol_hw_output(struct asycom *asy, async_flowc_action onoff)
4754 {
4755 	struct asyncline *async = asy->asy_priv;
4756 	int instance = UNIT(async->async_dev);
4757 
4758 	ASSERT(mutex_owned(&asy->asy_excl_hi));
4759 
4760 	if (!(async->async_ttycommon.t_cflag & CRTSCTS))
4761 		return;
4762 
4763 	switch (onoff) {
4764 	case FLOW_STOP:
4765 		async->async_flags |= ASYNC_HW_OUT_FLW;
4766 		async->async_flags &= ~ASYNC_OUT_FLW_RESUME;
4767 		DEBUGCONT1(ASY_DEBUG_HFLOW, "async%d: output hflow stop\n",
4768 		    instance);
4769 		break;
4770 	case FLOW_START:
4771 		async->async_flags &= ~ASYNC_HW_OUT_FLW;
4772 		if (!(async->async_flags & ASYNC_SW_OUT_FLW))
4773 			async->async_flags |= ASYNC_OUT_FLW_RESUME;
4774 		DEBUGCONT1(ASY_DEBUG_HFLOW, "async%d: output hflow start\n",
4775 		    instance);
4776 		break;
4777 	default:
4778 		break;
4779 	}
4780 }
4781 
4782 
4783 /*
4784  * quiesce(9E) entry point.
4785  *
4786  * This function is called when the system is single-threaded at high
4787  * PIL with preemption disabled. Therefore, this function must not be
4788  * blocked.
4789  *
4790  * This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure.
4791  * DDI_FAILURE indicates an error condition and should almost never happen.
4792  */
4793 static int
4794 asyquiesce(dev_info_t *devi)
4795 {
4796 	int instance;
4797 	struct asycom *asy;
4798 
4799 	instance = ddi_get_instance(devi);	/* find out which unit */
4800 
4801 	asy = ddi_get_soft_state(asy_soft_state, instance);
4802 	if (asy == NULL)
4803 		return (DDI_FAILURE);
4804 
4805 	/* disable all interrupts */
4806 	ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
4807 
4808 	/* reset the FIFO */
4809 	asy_reset_fifo(asy, FIFOTXFLSH | FIFORXFLSH);
4810 
4811 	return (DDI_SUCCESS);
4812 }
4813