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