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