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 /* Copyright (c) 1990, 1991 UNIX System Laboratories, Inc. */ 22 /* Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T */ 23 /* All Rights Reserved */ 24 25 /* 26 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 27 * Use is subject to license terms. 28 * Copyright (c) 2016 by Delphix. All rights reserved. 29 * Copyright (c) 2019 Peter Tribble. 30 */ 31 32 33 /* 34 * Serial I/O driver for 82510/8250/16450/16550AF/16C554D chips. 35 * Modified as sparc keyboard/mouse driver. 36 */ 37 #define SU_REGISTER_FILE_NO 0 38 #define SU_REGOFFSET 0 39 #define SU_REGISTER_LEN 8 40 41 #include <sys/param.h> 42 #include <sys/types.h> 43 #include <sys/signal.h> 44 #include <sys/stream.h> 45 #include <sys/termio.h> 46 #include <sys/errno.h> 47 #include <sys/file.h> 48 #include <sys/cmn_err.h> 49 #include <sys/stropts.h> 50 #include <sys/strsubr.h> 51 #include <sys/strsun.h> 52 #include <sys/strtty.h> 53 #include <sys/debug.h> 54 #include <sys/kbio.h> 55 #include <sys/cred.h> 56 #include <sys/modctl.h> 57 #include <sys/stat.h> 58 #include <sys/consdev.h> 59 #include <sys/mkdev.h> 60 #include <sys/kmem.h> 61 #include <sys/cred.h> 62 #ifdef DEBUG 63 #include <sys/promif.h> 64 #endif 65 #include <sys/ddi.h> 66 #include <sys/sunddi.h> 67 #include <sys/sudev.h> 68 #include <sys/note.h> 69 #include <sys/timex.h> 70 #include <sys/policy.h> 71 72 #define async_stopc async_ttycommon.t_stopc 73 #define async_startc async_ttycommon.t_startc 74 75 #define ASY_INIT 1 76 #define ASY_NOINIT 0 77 78 #ifdef DEBUG 79 #define ASY_DEBUG_INIT 0x001 80 #define ASY_DEBUG_INPUT 0x002 81 #define ASY_DEBUG_EOT 0x004 82 #define ASY_DEBUG_CLOSE 0x008 83 #define ASY_DEBUG_HFLOW 0x010 84 #define ASY_DEBUG_PROCS 0x020 85 #define ASY_DEBUG_STATE 0x040 86 #define ASY_DEBUG_INTR 0x080 87 static int asydebug = 0; 88 #endif 89 static int su_log = 0; 90 91 int su_drain_check = 15000000; /* tunable: exit drain check time */ 92 93 static struct ppsclockev asy_ppsev; 94 95 static int max_asy_instance = -1; 96 static void *su_asycom; /* soft state asycom pointer */ 97 static void *su_asyncline; /* soft state asyncline pointer */ 98 static boolean_t abort_charseq_recognize(uchar_t ch); 99 100 static uint_t asysoftintr(caddr_t intarg); 101 static uint_t asyintr(caddr_t argasy); 102 103 /* The async interrupt entry points */ 104 static void async_txint(struct asycom *asy, uchar_t lsr); 105 static void async_rxint(struct asycom *asy, uchar_t lsr); 106 static void async_msint(struct asycom *asy); 107 static int async_softint(struct asycom *asy); 108 109 static void async_ioctl(struct asyncline *async, queue_t *q, mblk_t *mp, 110 boolean_t iswput); 111 static void async_reioctl(void *); 112 static void async_iocdata(queue_t *q, mblk_t *mp); 113 static void async_restart(void *); 114 static void async_start(struct asyncline *async); 115 static void async_nstart(struct asyncline *async, int mode); 116 static void async_resume(struct asyncline *async); 117 static int asy_program(struct asycom *asy, int mode); 118 119 /* Polled mode functions */ 120 static void asyputchar(cons_polledio_arg_t, uchar_t c); 121 static int asygetchar(cons_polledio_arg_t); 122 static boolean_t asyischar(cons_polledio_arg_t); 123 static void asy_polled_enter(cons_polledio_arg_t); 124 static void asy_polled_exit(cons_polledio_arg_t); 125 126 static int asymctl(struct asycom *, int, int); 127 static int asytodm(int, int); 128 static int dmtoasy(int); 129 static void asycheckflowcontrol_hw(struct asycom *asy); 130 static boolean_t asycheckflowcontrol_sw(struct asycom *asy); 131 static void asy_ppsevent(struct asycom *asy, int msr); 132 133 extern kcondvar_t lbolt_cv; 134 extern int ddi_create_internal_pathname(dev_info_t *dip, char *name, 135 int spec_type, minor_t minor_num); 136 137 138 /* 139 * Baud rate table. Indexed by #defines found in sys/termios.h 140 */ 141 ushort_t asyspdtab[] = { 142 0, /* 0 baud rate */ 143 0x900, /* 50 baud rate */ 144 0x600, /* 75 baud rate */ 145 0x417, /* 110 baud rate (%0.026) */ 146 0x359, /* 134 baud rate (%0.058) */ 147 0x300, /* 150 baud rate */ 148 0x240, /* 200 baud rate */ 149 0x180, /* 300 baud rate */ 150 0x0c0, /* 600 baud rate */ 151 0x060, /* 1200 baud rate */ 152 0x040, /* 1800 baud rate */ 153 0x030, /* 2400 baud rate */ 154 0x018, /* 4800 baud rate */ 155 0x00c, /* 9600 baud rate */ 156 0x006, /* 19200 baud rate */ 157 0x003, /* 38400 baud rate */ 158 0x002, /* 57600 baud rate */ 159 0, /* 76800 baud rate - not supported */ 160 0x001, /* 115200 baud rate */ 161 0, /* 153600 baud rate - not supported */ 162 0x8002, /* 230400 baud rate - supported on specific platforms */ 163 0, /* 307200 baud rate - not supported */ 164 0x8001 /* 460800 baud rate - supported on specific platforms */ 165 }; 166 167 /* 168 * Number of speeds supported is the number of entries in 169 * the above table. 170 */ 171 #define N_SU_SPEEDS (sizeof (asyspdtab)/sizeof (ushort_t)) 172 173 /* 174 * Human-readable baud rate table. 175 * Indexed by #defines found in sys/termios.h 176 */ 177 int baudtable[] = { 178 0, /* 0 baud rate */ 179 50, /* 50 baud rate */ 180 75, /* 75 baud rate */ 181 110, /* 110 baud rate */ 182 134, /* 134 baud rate */ 183 150, /* 150 baud rate */ 184 200, /* 200 baud rate */ 185 300, /* 300 baud rate */ 186 600, /* 600 baud rate */ 187 1200, /* 1200 baud rate */ 188 1800, /* 1800 baud rate */ 189 2400, /* 2400 baud rate */ 190 4800, /* 4800 baud rate */ 191 9600, /* 9600 baud rate */ 192 19200, /* 19200 baud rate */ 193 38400, /* 38400 baud rate */ 194 57600, /* 57600 baud rate */ 195 76800, /* 76800 baud rate */ 196 115200, /* 115200 baud rate */ 197 153600, /* 153600 baud rate */ 198 230400, /* 230400 baud rate */ 199 307200, /* 307200 baud rate */ 200 460800 /* 460800 baud rate */ 201 }; 202 203 static int asyopen(queue_t *rq, dev_t *dev, int flag, int sflag, cred_t *cr); 204 static int asyclose(queue_t *q, int flag, cred_t *cr); 205 static int asywput(queue_t *q, mblk_t *mp); 206 static int asyrsrv(queue_t *q); 207 208 struct module_info asy_info = { 209 0, 210 "su", 211 0, 212 INFPSZ, 213 32*4096, 214 4096 215 }; 216 217 static struct qinit asy_rint = { 218 putq, 219 asyrsrv, 220 asyopen, 221 asyclose, 222 NULL, 223 &asy_info, 224 NULL 225 }; 226 227 static struct qinit asy_wint = { 228 asywput, 229 NULL, 230 NULL, 231 NULL, 232 NULL, 233 &asy_info, 234 NULL 235 }; 236 237 struct streamtab asy_str_info = { 238 &asy_rint, 239 &asy_wint, 240 NULL, 241 NULL 242 }; 243 244 static int asyinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, 245 void **result); 246 static int asyprobe(dev_info_t *); 247 static int asyattach(dev_info_t *, ddi_attach_cmd_t); 248 static int asydetach(dev_info_t *, ddi_detach_cmd_t); 249 250 static struct cb_ops cb_asy_ops = { 251 nodev, /* cb_open */ 252 nodev, /* cb_close */ 253 nodev, /* cb_strategy */ 254 nodev, /* cb_print */ 255 nodev, /* cb_dump */ 256 nodev, /* cb_read */ 257 nodev, /* cb_write */ 258 nodev, /* cb_ioctl */ 259 nodev, /* cb_devmap */ 260 nodev, /* cb_mmap */ 261 nodev, /* cb_segmap */ 262 nochpoll, /* cb_chpoll */ 263 ddi_prop_op, /* cb_prop_op */ 264 &asy_str_info, /* cb_stream */ 265 D_MP /* cb_flag */ 266 }; 267 268 struct dev_ops asy_ops = { 269 DEVO_REV, /* devo_rev */ 270 0, /* devo_refcnt */ 271 asyinfo, /* devo_getinfo */ 272 nulldev, /* devo_identify */ 273 asyprobe, /* devo_probe */ 274 asyattach, /* devo_attach */ 275 asydetach, /* devo_detach */ 276 nodev, /* devo_reset */ 277 &cb_asy_ops, /* devo_cb_ops */ 278 NULL, /* devo_bus_ops */ 279 NULL, /* devo_power */ 280 ddi_quiesce_not_supported, /* devo_quiesce */ 281 }; 282 283 /* 284 * Module linkage information for the kernel. 285 */ 286 287 static struct modldrv modldrv = { 288 &mod_driverops, /* Type of module. This one is a driver */ 289 "su driver", 290 &asy_ops, /* driver ops */ 291 }; 292 293 static struct modlinkage modlinkage = { 294 MODREV_1, 295 &modldrv, 296 NULL 297 }; 298 299 int 300 _init(void) 301 { 302 int status; 303 304 status = ddi_soft_state_init(&su_asycom, sizeof (struct asycom), 305 SU_INITIAL_SOFT_ITEMS); 306 if (status != 0) 307 return (status); 308 status = ddi_soft_state_init(&su_asyncline, sizeof (struct asyncline), 309 SU_INITIAL_SOFT_ITEMS); 310 if (status != 0) { 311 ddi_soft_state_fini(&su_asycom); 312 return (status); 313 } 314 315 if ((status = mod_install(&modlinkage)) != 0) { 316 ddi_soft_state_fini(&su_asycom); 317 ddi_soft_state_fini(&su_asyncline); 318 } 319 320 return (status); 321 } 322 323 int 324 _fini(void) 325 { 326 int i; 327 328 i = mod_remove(&modlinkage); 329 if (i == 0) { 330 ddi_soft_state_fini(&su_asycom); 331 ddi_soft_state_fini(&su_asyncline); 332 } 333 334 return (i); 335 } 336 337 int 338 _info(struct modinfo *modinfop) 339 { 340 return (mod_info(&modlinkage, modinfop)); 341 } 342 343 static int 344 asyprobe(dev_info_t *devi) 345 { 346 int instance; 347 ddi_acc_handle_t handle; 348 uchar_t *addr; 349 ddi_device_acc_attr_t attr; 350 351 attr.devacc_attr_version = DDI_DEVICE_ATTR_V0; 352 attr.devacc_attr_endian_flags = DDI_STRUCTURE_LE_ACC; 353 attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC; 354 if (ddi_regs_map_setup(devi, SU_REGISTER_FILE_NO, (caddr_t *)&addr, 355 SU_REGOFFSET, SU_REGISTER_LEN, &attr, &handle) != DDI_SUCCESS) { 356 cmn_err(CE_WARN, "asyprobe regs map setup failed"); 357 return (DDI_PROBE_FAILURE); 358 } 359 #ifdef DEBUG 360 if (asydebug) 361 printf("Probe address mapped %p\n", (void *)addr); 362 #endif 363 364 /* 365 * Probe for the device: 366 * Ser. int. uses bits 0,1,2; FIFO uses 3,6,7; 4,5 wired low. 367 * If bit 4 or 5 appears on inb() ISR, board is not there. 368 */ 369 if (ddi_get8(handle, addr+ISR) & 0x30) { 370 ddi_regs_map_free(&handle); 371 return (DDI_PROBE_FAILURE); 372 } 373 374 instance = ddi_get_instance(devi); 375 if (max_asy_instance < instance) 376 max_asy_instance = instance; 377 ddi_regs_map_free(&handle); 378 379 return (DDI_PROBE_SUCCESS); /* hw is present */ 380 } 381 382 static int 383 asydetach(dev_info_t *devi, ddi_detach_cmd_t cmd) 384 { 385 int instance; 386 struct asycom *asy; 387 struct asyncline *async; 388 char name[16]; 389 390 instance = ddi_get_instance(devi); /* find out which unit */ 391 392 asy = (struct asycom *)ddi_get_soft_state(su_asycom, instance); 393 async = (struct asyncline *)ddi_get_soft_state(su_asyncline, instance); 394 395 switch (cmd) { 396 case DDI_DETACH: 397 break; 398 case DDI_SUSPEND: 399 /* grab both mutex locks */ 400 mutex_enter(asy->asy_excl); 401 mutex_enter(asy->asy_excl_hi); 402 if (asy->suspended) { 403 mutex_exit(asy->asy_excl_hi); 404 mutex_exit(asy->asy_excl); 405 return (DDI_SUCCESS); 406 } 407 asy->suspended = B_TRUE; 408 409 /* 410 * The quad UART ST16C554D, version D2 (made by EXAR) 411 * has an anomaly of generating spurious interrupts 412 * when the ICR is loaded with zero. The workaround 413 * would be to read/write any register with DATA1 bit 414 * set to 0 before such write. 415 */ 416 if (asy->asy_hwtype == ASY16C554D) 417 OUTB(SPR, 0); 418 419 /* Disable further interrupts */ 420 OUTB(ICR, 0); 421 mutex_exit(asy->asy_excl_hi); 422 mutex_exit(asy->asy_excl); 423 return (DDI_SUCCESS); 424 425 default: 426 return (DDI_FAILURE); 427 } 428 429 #ifdef DEBUG 430 if (asydebug & ASY_DEBUG_INIT) 431 cmn_err(CE_NOTE, "su%d: ASY%s shutdown.", instance, 432 asy->asy_hwtype == ASY82510 ? "82510" : 433 asy->asy_hwtype == ASY16550AF ? "16550AF" : 434 asy->asy_hwtype == ASY16C554D ? "16C554D" : 435 "8250"); 436 #endif 437 /* 438 * Before removing interrupts it is always better to disable 439 * interrupts if the chip gives a provision to disable the 440 * serial port interrupts. 441 */ 442 mutex_enter(asy->asy_excl); 443 mutex_enter(asy->asy_excl_hi); 444 /* disable interrupts, see EXAR bug */ 445 if (asy->asy_hwtype == ASY16C554D) 446 OUTB(SPR, 0); 447 OUTB(ICR, 0); 448 mutex_exit(asy->asy_excl_hi); 449 mutex_exit(asy->asy_excl); 450 451 /* remove minor device node(s) for this device */ 452 (void) sprintf(name, "%c", (instance+'a')); /* serial-port */ 453 ddi_remove_minor_node(devi, name); 454 (void) sprintf(name, "%c,cu", (instance+'a')); /* serial-port:dailout */ 455 ddi_remove_minor_node(devi, name); 456 457 mutex_destroy(asy->asy_excl); 458 mutex_destroy(asy->asy_excl_hi); 459 kmem_free(asy->asy_excl, sizeof (kmutex_t)); 460 kmem_free(asy->asy_excl_hi, sizeof (kmutex_t)); 461 cv_destroy(&async->async_flags_cv); 462 kstat_delete(asy->sukstat); 463 ddi_remove_intr(devi, 0, asy->asy_iblock); 464 ddi_regs_map_free(&asy->asy_handle); 465 ddi_remove_softintr(asy->asy_softintr_id); 466 mutex_destroy(asy->asy_soft_lock); 467 kmem_free(asy->asy_soft_lock, sizeof (kmutex_t)); 468 ddi_soft_state_free(su_asycom, instance); 469 ddi_soft_state_free(su_asyncline, instance); 470 return (DDI_SUCCESS); 471 } 472 473 static int 474 asyattach(dev_info_t *devi, ddi_attach_cmd_t cmd) 475 { 476 int instance; 477 struct asycom *asy; 478 struct asyncline *async; 479 char name[40]; 480 ddi_device_acc_attr_t attr; 481 enum states { EMPTY, SOFTSTATE, REGSMAP, MUTEXES, ADDINTR, 482 SOFTINTR, ASYINIT, KSTAT, MINORNODE }; 483 enum states state = EMPTY; 484 char *hwtype; 485 486 instance = ddi_get_instance(devi); /* find out which unit */ 487 488 /* cannot attach a device that has not been probed first */ 489 if (instance > max_asy_instance) 490 return (DDI_FAILURE); 491 492 if (cmd != DDI_RESUME) { 493 /* Allocate soft state space */ 494 if (ddi_soft_state_zalloc(su_asycom, instance) != DDI_SUCCESS) { 495 cmn_err(CE_WARN, "su%d: cannot allocate soft state", 496 instance); 497 goto error; 498 } 499 } 500 state = SOFTSTATE; 501 502 asy = (struct asycom *)ddi_get_soft_state(su_asycom, instance); 503 504 if (asy == NULL) { 505 cmn_err(CE_WARN, "su%d: cannot get soft state", instance); 506 goto error; 507 } 508 509 switch (cmd) { 510 case DDI_ATTACH: 511 break; 512 case DDI_RESUME: { 513 struct asyncline *async; 514 515 /* grab both mutex locks */ 516 mutex_enter(asy->asy_excl); 517 mutex_enter(asy->asy_excl_hi); 518 if (!asy->suspended) { 519 mutex_exit(asy->asy_excl_hi); 520 mutex_exit(asy->asy_excl); 521 return (DDI_SUCCESS); 522 } 523 /* 524 * re-setup all the registers and enable interrupts if 525 * needed 526 */ 527 async = (struct asyncline *)asy->asy_priv; 528 if ((async) && (async->async_flags & ASYNC_ISOPEN)) 529 (void) asy_program(asy, ASY_INIT); 530 asy->suspended = B_FALSE; 531 mutex_exit(asy->asy_excl_hi); 532 mutex_exit(asy->asy_excl); 533 return (DDI_SUCCESS); 534 } 535 default: 536 goto error; 537 } 538 539 attr.devacc_attr_version = DDI_DEVICE_ATTR_V0; 540 attr.devacc_attr_endian_flags = DDI_STRUCTURE_LE_ACC; 541 attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC; 542 543 if (ddi_regs_map_setup(devi, SU_REGISTER_FILE_NO, 544 (caddr_t *)&asy->asy_ioaddr, SU_REGOFFSET, SU_REGISTER_LEN, 545 &attr, &asy->asy_handle) != DDI_SUCCESS) { 546 cmn_err(CE_WARN, "asyprobe regs map setup failed"); 547 goto error; 548 } 549 state = REGSMAP; 550 551 #ifdef DEBUG 552 if (asydebug) 553 printf("su attach mapped %p\n", (void *)asy->asy_ioaddr); 554 #endif 555 556 /* 557 * Initialize the port with default settings. 558 */ 559 asy->asy_fifo_buf = 1; 560 asy->asy_use_fifo = FIFO_OFF; 561 562 /* 563 * Check for baudrate generator's "baud-divisor-factor" property setup 564 * by OBP, since different UART chips might have different baudrate 565 * generator divisor. e.g., in case of NSPG's Sputnik platform, the 566 * baud-divisor-factor is 13, it uses dedicated 16552 "DUART" chip 567 * instead of SuperIO. Since the baud-divisor-factor must be a positive 568 * integer, the divisors will always be at least as large as the values 569 * in asyspdtab[]. Make the default factor 1. 570 */ 571 asy->asy_baud_divisor_factor = ddi_prop_get_int(DDI_DEV_T_ANY, devi, 572 DDI_PROP_DONTPASS, "baud-divisor-factor", 1); 573 574 /* set speed cap */ 575 asy->asy_speed_cap = ddi_prop_get_int(DDI_DEV_T_ANY, devi, 576 DDI_PROP_DONTPASS, "serial-speed-cap", 115200); 577 578 /* check for ASY82510 chip */ 579 OUTB(ISR, 0x20); 580 if (INB(ISR) & 0x20) { /* 82510 chip is present */ 581 /* 582 * Since most of the general operation of the 82510 chip 583 * can be done from BANK 0 (8250A/16450 compatable mode) 584 * we will default to BANK 0. 585 */ 586 asy->asy_hwtype = ASY82510; 587 OUTB(DAT+7, 0x04); /* clear status */ 588 OUTB(ISR, 0x40); /* set to bank 2 */ 589 OUTB(MCR, 0x08); /* IMD */ 590 OUTB(DAT, 0x21); /* FMD */ 591 OUTB(ISR, 0x00); /* set to bank 0 */ 592 asy->asy_trig_level = 0; 593 } else { /* Set the UART in FIFO mode if it has FIFO buffers */ 594 asy->asy_hwtype = ASY16550AF; 595 OUTB(FIFOR, 0x00); /* clear fifo register */ 596 asy->asy_trig_level = 0x00; /* sets the fifo Threshold to 1 */ 597 598 /* set/Enable FIFO */ 599 OUTB(FIFOR, FIFO_ON | FIFODMA | FIFOTXFLSH | FIFORXFLSH | 600 (asy->asy_trig_level & 0xff)); 601 602 if ((INB(ISR) & 0xc0) == 0xc0) 603 asy->asy_use_fifo = FIFO_ON; 604 else { 605 asy->asy_hwtype = ASY8250; 606 OUTB(FIFOR, 0x00); /* NO FIFOs */ 607 asy->asy_trig_level = 0; 608 } 609 } 610 611 /* check for ST16C554D chip */ 612 if ((ddi_prop_lookup_string(DDI_DEV_T_ANY, devi, DDI_PROP_NOTPROM | 613 DDI_PROP_DONTPASS, "hwtype", &hwtype)) == DDI_PROP_SUCCESS) { 614 if (strcmp(hwtype, "ST16C554D") == 0) 615 asy->asy_hwtype = ASY16C554D; 616 ddi_prop_free(hwtype); 617 } 618 619 /* disable interrupts, see EXAR bug */ 620 if (asy->asy_hwtype == ASY16C554D) 621 OUTB(SPR, 0); 622 OUTB(ICR, 0); 623 OUTB(LCR, DLAB); /* select baud rate generator */ 624 /* Set the baud rate to 9600 */ 625 OUTB(DAT+DLL, (ASY9600*asy->asy_baud_divisor_factor) & 0xff); 626 OUTB(DAT+DLH, ((ASY9600*asy->asy_baud_divisor_factor) >> 8) & 0xff); 627 OUTB(LCR, STOP1|BITS8); 628 OUTB(MCR, (DTR | RTS| OUT2)); 629 630 /* 631 * Set up the other components of the asycom structure for this port. 632 */ 633 asy->asy_excl = (kmutex_t *) 634 kmem_zalloc(sizeof (kmutex_t), KM_SLEEP); 635 asy->asy_excl_hi = (kmutex_t *) 636 kmem_zalloc(sizeof (kmutex_t), KM_SLEEP); 637 asy->asy_soft_lock = (kmutex_t *) 638 kmem_zalloc(sizeof (kmutex_t), KM_SLEEP); 639 asy->asy_unit = instance; 640 asy->asy_dip = devi; 641 642 if (ddi_get_iblock_cookie(devi, 0, &asy->asy_iblock) != DDI_SUCCESS) { 643 cmn_err(CE_NOTE, 644 "Get iblock_cookie failed-Device interrupt%x\n", instance); 645 goto error; 646 } 647 648 if (ddi_get_soft_iblock_cookie(devi, DDI_SOFTINT_HIGH, 649 &asy->asy_soft_iblock) != DDI_SUCCESS) { 650 cmn_err(CE_NOTE, "Get iblock_cookie failed -soft interrupt%x\n", 651 instance); 652 goto error; 653 } 654 655 mutex_init(asy->asy_soft_lock, NULL, MUTEX_DRIVER, 656 (void *)asy->asy_soft_iblock); 657 mutex_init(asy->asy_excl, NULL, MUTEX_DRIVER, NULL); 658 mutex_init(asy->asy_excl_hi, NULL, MUTEX_DRIVER, 659 (void *)asy->asy_iblock); 660 state = MUTEXES; 661 662 /* 663 * Install interrupt handlers for this device. 664 */ 665 if (ddi_add_intr(devi, 0, &(asy->asy_iblock), 0, asyintr, 666 (caddr_t)asy) != DDI_SUCCESS) { 667 cmn_err(CE_CONT, 668 "Cannot set device interrupt for su driver\n"); 669 goto error; 670 } 671 state = ADDINTR; 672 673 if (ddi_add_softintr(devi, DDI_SOFTINT_HIGH, &(asy->asy_softintr_id), 674 &asy->asy_soft_iblock, 0, asysoftintr, (caddr_t)asy) 675 != DDI_SUCCESS) { 676 cmn_err(CE_CONT, "Cannot set soft interrupt for su driver\n"); 677 goto error; 678 } 679 state = SOFTINTR; 680 681 /* initialize the asyncline structure */ 682 if (ddi_soft_state_zalloc(su_asyncline, instance) != DDI_SUCCESS) { 683 cmn_err(CE_CONT, "su%d: cannot allocate soft state", instance); 684 goto error; 685 } 686 state = ASYINIT; 687 688 async = (struct asyncline *)ddi_get_soft_state(su_asyncline, instance); 689 690 mutex_enter(asy->asy_excl); 691 async->async_common = asy; 692 cv_init(&async->async_flags_cv, NULL, CV_DEFAULT, NULL); 693 mutex_exit(asy->asy_excl); 694 695 if ((asy->sukstat = kstat_create("su", instance, "serialstat", 696 "misc", KSTAT_TYPE_NAMED, 2, KSTAT_FLAG_VIRTUAL)) != NULL) { 697 asy->sukstat->ks_data = &asy->kstats; 698 kstat_named_init(&asy->kstats.ringover, "ring buffer overflow", 699 KSTAT_DATA_UINT64); 700 kstat_named_init(&asy->kstats.siloover, "silo overflow", 701 KSTAT_DATA_UINT64); 702 kstat_install(asy->sukstat); 703 } 704 state = KSTAT; 705 706 if (strcmp(ddi_node_name(devi), "rsc-console") == 0) { 707 /* 708 * If the device is configured as the 'rsc-console' 709 * create the minor device for this node. 710 */ 711 if (ddi_create_minor_node(devi, "ssp", S_IFCHR, 712 asy->asy_unit | RSC_DEVICE, DDI_PSEUDO, 0) == DDI_FAILURE) { 713 cmn_err(CE_WARN, 714 "%s%d: Failed to create node rsc-console", 715 ddi_get_name(devi), ddi_get_instance(devi)); 716 goto error; 717 } 718 719 asy->asy_lom_console = 0; 720 asy->asy_rsc_console = 1; 721 asy->asy_rsc_control = 0; 722 asy->asy_device_type = ASY_SERIAL; 723 asy->asy_flags |= ASY_IGNORE_CD; 724 725 } else if (strcmp(ddi_node_name(devi), "lom-console") == 0) { 726 /* 727 * If the device is configured as the 'lom-console' 728 * create the minor device for this node. 729 * Do not create a dialout device. 730 * Use the same minor numbers as would be used for standard 731 * serial instances. 732 */ 733 if (ddi_create_minor_node(devi, "lom-console", S_IFCHR, 734 instance, DDI_NT_SERIAL_LOMCON, 0) == DDI_FAILURE) { 735 cmn_err(CE_WARN, 736 "%s%d: Failed to create node lom-console", 737 ddi_get_name(devi), ddi_get_instance(devi)); 738 goto error; 739 } 740 asy->asy_lom_console = 1; 741 asy->asy_rsc_console = 0; 742 asy->asy_rsc_control = 0; 743 asy->asy_device_type = ASY_SERIAL; 744 asy->asy_flags |= ASY_IGNORE_CD; 745 746 } else if (strcmp(ddi_node_name(devi), "rsc-control") == 0) { 747 /* 748 * If the device is configured as the 'rsc-control' 749 * create the minor device for this node. 750 */ 751 if (ddi_create_minor_node(devi, "sspctl", S_IFCHR, 752 asy->asy_unit | RSC_DEVICE, DDI_PSEUDO, 0) == DDI_FAILURE) { 753 cmn_err(CE_WARN, "%s%d: Failed to create rsc-control", 754 ddi_get_name(devi), ddi_get_instance(devi)); 755 goto error; 756 } 757 758 asy->asy_lom_console = 0; 759 asy->asy_rsc_console = 0; 760 asy->asy_rsc_control = 1; 761 asy->asy_device_type = ASY_SERIAL; 762 asy->asy_flags |= ASY_IGNORE_CD; 763 764 } else if (ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS, 765 "keyboard", 0)) { 766 /* 767 * If the device is a keyboard, then create an internal 768 * pathname so that the dacf code will link the node into 769 * the keyboard console stream. See dacf.conf. 770 */ 771 if (ddi_create_internal_pathname(devi, "keyboard", 772 S_IFCHR, instance) == DDI_FAILURE) { 773 goto error; 774 } 775 asy->asy_flags |= ASY_IGNORE_CD; /* ignore cd */ 776 asy->asy_device_type = ASY_KEYBOARD; /* Device type */ 777 } else if (ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS, 778 "mouse", 0)) { 779 /* 780 * If the device is a mouse, then create an internal 781 * pathname so that the dacf code will link the node into 782 * the mouse stream. See dacf.conf. 783 */ 784 if (ddi_create_internal_pathname(devi, "mouse", S_IFCHR, 785 instance) == DDI_FAILURE) { 786 goto error; 787 } 788 asy->asy_flags |= ASY_IGNORE_CD; /* ignore cd */ 789 asy->asy_device_type = ASY_MOUSE; 790 } else { 791 /* 792 * If not used for keyboard/mouse, create minor devices nodes 793 * for this device 794 */ 795 /* serial-port */ 796 (void) sprintf(name, "%c", (instance+'a')); 797 if (ddi_create_minor_node(devi, name, S_IFCHR, instance, 798 DDI_NT_SERIAL_MB, 0) == DDI_FAILURE) { 799 goto error; 800 } 801 state = MINORNODE; 802 /* serial-port:dailout */ 803 (void) sprintf(name, "%c,cu", (instance+'a')); 804 if (ddi_create_minor_node(devi, name, S_IFCHR, instance|OUTLINE, 805 DDI_NT_SERIAL_MB_DO, 0) == DDI_FAILURE) { 806 goto error; 807 } 808 /* Property for ignoring DCD */ 809 if (ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS, 810 "ignore-cd", 0)) { 811 asy->asy_flags |= ASY_IGNORE_CD; /* ignore cd */ 812 } else { 813 asy->asy_flags &= ~ASY_IGNORE_CD; 814 /* 815 * if ignore-cd is not available it could be 816 * some old legacy platform, try to see 817 * whether the old legacy property exists 818 */ 819 (void) sprintf(name, 820 "port-%c-ignore-cd", (instance+ 'a')); 821 if (ddi_getprop(DDI_DEV_T_ANY, devi, 822 DDI_PROP_DONTPASS, name, 0)) 823 asy->asy_flags |= ASY_IGNORE_CD; 824 } 825 asy->asy_device_type = ASY_SERIAL; 826 } 827 828 /* 829 * Fill in the polled I/O structure 830 */ 831 asy->polledio.cons_polledio_version = CONSPOLLEDIO_V0; 832 asy->polledio.cons_polledio_argument = (cons_polledio_arg_t)asy; 833 asy->polledio.cons_polledio_putchar = asyputchar; 834 asy->polledio.cons_polledio_getchar = asygetchar; 835 asy->polledio.cons_polledio_ischar = asyischar; 836 asy->polledio.cons_polledio_enter = asy_polled_enter; 837 asy->polledio.cons_polledio_exit = asy_polled_exit; 838 839 /* Initialize saved ICR and polled_enter */ 840 asy->polled_icr = 0; 841 asy->polled_enter = B_FALSE; 842 843 ddi_report_dev(devi); 844 return (DDI_SUCCESS); 845 846 error: 847 if (state == MINORNODE) { 848 (void) sprintf(name, "%c", (instance+'a')); 849 ddi_remove_minor_node(devi, name); 850 } 851 if (state >= KSTAT) 852 kstat_delete(asy->sukstat); 853 if (state >= ASYINIT) { 854 cv_destroy(&async->async_flags_cv); 855 ddi_soft_state_free(su_asyncline, instance); 856 } 857 if (state >= SOFTINTR) 858 ddi_remove_softintr(asy->asy_softintr_id); 859 if (state >= ADDINTR) 860 ddi_remove_intr(devi, 0, asy->asy_iblock); 861 if (state >= MUTEXES) { 862 mutex_destroy(asy->asy_excl_hi); 863 mutex_destroy(asy->asy_excl); 864 mutex_destroy(asy->asy_soft_lock); 865 kmem_free(asy->asy_excl_hi, sizeof (kmutex_t)); 866 kmem_free(asy->asy_excl, sizeof (kmutex_t)); 867 kmem_free(asy->asy_soft_lock, sizeof (kmutex_t)); 868 } 869 if (state >= REGSMAP) 870 ddi_regs_map_free(&asy->asy_handle); 871 if (state >= SOFTSTATE) 872 ddi_soft_state_free(su_asycom, instance); 873 /* no action for EMPTY state */ 874 return (DDI_FAILURE); 875 } 876 877 static int 878 asyinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, 879 void **result) 880 { 881 _NOTE(ARGUNUSED(dip)) 882 dev_t dev = (dev_t)arg; 883 int instance, error; 884 struct asycom *asy; 885 886 if ((instance = UNIT(dev)) > max_asy_instance) 887 return (DDI_FAILURE); 888 889 switch (infocmd) { 890 case DDI_INFO_DEVT2DEVINFO: 891 asy = (struct asycom *)ddi_get_soft_state(su_asycom, 892 instance); 893 if (asy->asy_dip == NULL) 894 error = DDI_FAILURE; 895 else { 896 *result = (void *) asy->asy_dip; 897 error = DDI_SUCCESS; 898 } 899 break; 900 case DDI_INFO_DEVT2INSTANCE: 901 *result = (void *)(uintptr_t)instance; 902 error = DDI_SUCCESS; 903 break; 904 default: 905 error = DDI_FAILURE; 906 } 907 return (error); 908 } 909 910 static int 911 asyopen(queue_t *rq, dev_t *dev, int flag, int sflag, cred_t *cr) 912 { 913 _NOTE(ARGUNUSED(sflag)) 914 struct asycom *asy; 915 struct asyncline *async; 916 int mcr; 917 int unit; 918 int len; 919 struct termios *termiosp; 920 921 #ifdef DEBUG 922 if (asydebug & ASY_DEBUG_CLOSE) 923 printf("open\n"); 924 #endif 925 unit = UNIT(*dev); 926 if (unit > max_asy_instance) 927 return (ENXIO); /* unit not configured */ 928 929 async = (struct asyncline *)ddi_get_soft_state(su_asyncline, unit); 930 if (async == NULL) 931 return (ENXIO); 932 933 asy = async->async_common; 934 if (asy == NULL) 935 return (ENXIO); /* device not found by autoconfig */ 936 937 mutex_enter(asy->asy_excl); 938 asy->asy_priv = (caddr_t)async; 939 940 again: 941 mutex_enter(asy->asy_excl_hi); 942 /* 943 * Block waiting for carrier to come up, unless this is a no-delay open. 944 */ 945 if (!(async->async_flags & ASYNC_ISOPEN)) { 946 /* 947 * If this port is for a RSC console or control 948 * use the following termio info 949 */ 950 if (asy->asy_rsc_console || asy->asy_rsc_control) { 951 async->async_ttycommon.t_cflag = CIBAUDEXT | CBAUDEXT | 952 (B115200 & CBAUD); 953 async->async_ttycommon.t_cflag |= ((B115200 << IBSHIFT) 954 & CIBAUD); 955 async->async_ttycommon.t_cflag |= CS8 | CREAD | CLOCAL; 956 } else if (asy->asy_lom_console) { 957 async->async_ttycommon.t_cflag = B9600 & CBAUD; 958 async->async_ttycommon.t_cflag |= ((B9600 << IBSHIFT) 959 & CIBAUD); 960 async->async_ttycommon.t_cflag |= CS8 | CREAD | CLOCAL; 961 } else { 962 963 /* 964 * Set the default termios settings (cflag). 965 * Others are set in ldterm. Release the spin 966 * mutex as we can block here, reaquire before 967 * calling asy_program. 968 */ 969 mutex_exit(asy->asy_excl_hi); 970 if (ddi_getlongprop(DDI_DEV_T_ANY, ddi_root_node(), 971 0, "ttymodes", (caddr_t)&termiosp, &len) 972 == DDI_PROP_SUCCESS && 973 len == sizeof (struct termios)) { 974 async->async_ttycommon.t_cflag = 975 termiosp->c_cflag; 976 kmem_free(termiosp, len); 977 } else { 978 cmn_err(CE_WARN, 979 "su: couldn't get ttymodes property!"); 980 } 981 mutex_enter(asy->asy_excl_hi); 982 } 983 async->async_ttycommon.t_iflag = 0; 984 async->async_ttycommon.t_iocpending = NULL; 985 async->async_ttycommon.t_size.ws_row = 0; 986 async->async_ttycommon.t_size.ws_col = 0; 987 async->async_ttycommon.t_size.ws_xpixel = 0; 988 async->async_ttycommon.t_size.ws_ypixel = 0; 989 async->async_dev = *dev; 990 async->async_wbufcid = 0; 991 992 async->async_startc = CSTART; 993 async->async_stopc = CSTOP; 994 (void) asy_program(asy, ASY_INIT); 995 } else if ((async->async_ttycommon.t_flags & TS_XCLUDE) && 996 secpolicy_excl_open(cr) != 0) { 997 mutex_exit(asy->asy_excl_hi); 998 mutex_exit(asy->asy_excl); 999 return (EBUSY); 1000 } else if ((*dev & OUTLINE) && !(async->async_flags & ASYNC_OUT)) { 1001 mutex_exit(asy->asy_excl_hi); 1002 mutex_exit(asy->asy_excl); 1003 return (EBUSY); 1004 } 1005 1006 if (*dev & OUTLINE) 1007 async->async_flags |= ASYNC_OUT; 1008 1009 /* Raise DTR on every open */ 1010 mcr = INB(MCR); 1011 OUTB(MCR, mcr|DTR); 1012 1013 /* 1014 * Check carrier. 1015 */ 1016 if (asy->asy_flags & ASY_IGNORE_CD) 1017 async->async_ttycommon.t_flags |= TS_SOFTCAR; 1018 if ((async->async_ttycommon.t_flags & TS_SOFTCAR) || 1019 (INB(MSR) & DCD)) 1020 async->async_flags |= ASYNC_CARR_ON; 1021 else 1022 async->async_flags &= ~ASYNC_CARR_ON; 1023 mutex_exit(asy->asy_excl_hi); 1024 1025 /* 1026 * If FNDELAY and FNONBLOCK are clear, block until carrier up. 1027 * Quit on interrupt. 1028 */ 1029 if (!(flag & (FNDELAY|FNONBLOCK)) && 1030 !(async->async_ttycommon.t_cflag & CLOCAL)) { 1031 if (!(async->async_flags & (ASYNC_CARR_ON|ASYNC_OUT)) || 1032 ((async->async_flags & ASYNC_OUT) && 1033 !(*dev & OUTLINE))) { 1034 async->async_flags |= ASYNC_WOPEN; 1035 if (cv_wait_sig(&async->async_flags_cv, 1036 asy->asy_excl) == 0) { 1037 async->async_flags &= ~ASYNC_WOPEN; 1038 mutex_exit(asy->asy_excl); 1039 return (EINTR); 1040 } 1041 async->async_flags &= ~ASYNC_WOPEN; 1042 goto again; 1043 } 1044 } else if ((async->async_flags & ASYNC_OUT) && !(*dev & OUTLINE)) { 1045 mutex_exit(asy->asy_excl); 1046 return (EBUSY); 1047 } 1048 1049 if (asy->suspended) { 1050 mutex_exit(asy->asy_excl); 1051 (void) ddi_dev_is_needed(asy->asy_dip, 0, 1); 1052 mutex_enter(asy->asy_excl); 1053 } 1054 1055 async->async_ttycommon.t_readq = rq; 1056 async->async_ttycommon.t_writeq = WR(rq); 1057 rq->q_ptr = WR(rq)->q_ptr = (caddr_t)async; 1058 mutex_exit(asy->asy_excl); 1059 qprocson(rq); 1060 async->async_flags |= ASYNC_ISOPEN; 1061 async->async_polltid = 0; 1062 return (0); 1063 } 1064 1065 static void 1066 async_progress_check(void *arg) 1067 { 1068 struct asyncline *async = arg; 1069 struct asycom *asy = async->async_common; 1070 mblk_t *bp; 1071 1072 /* 1073 * We define "progress" as either waiting on a timed break or delay, or 1074 * having had at least one transmitter interrupt. If none of these are 1075 * true, then just terminate the output and wake up that close thread. 1076 */ 1077 mutex_enter(asy->asy_excl); 1078 mutex_enter(asy->asy_excl_hi); 1079 if (!(async->async_flags & (ASYNC_BREAK|ASYNC_DELAY|ASYNC_PROGRESS))) { 1080 async->async_ocnt = 0; 1081 async->async_flags &= ~ASYNC_BUSY; 1082 async->async_timer = 0; 1083 bp = async->async_xmitblk; 1084 async->async_xmitblk = NULL; 1085 mutex_exit(asy->asy_excl_hi); 1086 if (bp != NULL) 1087 freeb(bp); 1088 /* 1089 * Since this timer is running, we know that we're in exit(2). 1090 * That means that the user can't possibly be waiting on any 1091 * valid ioctl(2) completion anymore, and we should just flush 1092 * everything. 1093 */ 1094 flushq(async->async_ttycommon.t_writeq, FLUSHALL); 1095 cv_broadcast(&async->async_flags_cv); 1096 } else { 1097 async->async_flags &= ~ASYNC_PROGRESS; 1098 async->async_timer = timeout(async_progress_check, async, 1099 drv_usectohz(su_drain_check)); 1100 mutex_exit(asy->asy_excl_hi); 1101 } 1102 mutex_exit(asy->asy_excl); 1103 } 1104 1105 /* 1106 * Close routine. 1107 */ 1108 static int 1109 asyclose(queue_t *q, int flag, cred_t *cr __unused) 1110 { 1111 struct asyncline *async; 1112 struct asycom *asy; 1113 int icr, lcr; 1114 int nohupcl; 1115 1116 1117 #ifdef DEBUG 1118 if (asydebug & ASY_DEBUG_CLOSE) 1119 printf("close\n"); 1120 #endif 1121 async = q->q_ptr; 1122 ASSERT(async != NULL); 1123 asy = async->async_common; 1124 1125 /* get the nohupcl OBP property of this device */ 1126 nohupcl = ddi_getprop(DDI_DEV_T_ANY, asy->asy_dip, DDI_PROP_DONTPASS, 1127 "nohupcl", 0); 1128 1129 mutex_enter(asy->asy_excl); 1130 async->async_flags |= ASYNC_CLOSING; 1131 1132 /* 1133 * Turn off PPS handling early to avoid events occuring during 1134 * close. Also reset the DCD edge monitoring bit. 1135 */ 1136 mutex_enter(asy->asy_excl_hi); 1137 asy->asy_flags &= ~(ASY_PPS | ASY_PPS_EDGE); 1138 mutex_exit(asy->asy_excl_hi); 1139 1140 /* 1141 * There are two flavors of break -- timed (M_BREAK or TCSBRK) and 1142 * untimed (TIOCSBRK). For the timed case, these are enqueued on our 1143 * write queue and there's a timer running, so we don't have to worry 1144 * about them. For the untimed case, though, the user obviously made a 1145 * mistake, because these are handled immediately. We'll terminate the 1146 * break now and honor their implicit request by discarding the rest of 1147 * the data. 1148 */ 1149 if (!(async->async_flags & ASYNC_BREAK)) { 1150 mutex_enter(asy->asy_excl_hi); 1151 lcr = INB(LCR); 1152 if (lcr & SETBREAK) { 1153 OUTB(LCR, (lcr & ~SETBREAK)); 1154 } 1155 mutex_exit(asy->asy_excl_hi); 1156 if (lcr & SETBREAK) 1157 goto nodrain; 1158 } 1159 1160 /* 1161 * If the user told us not to delay the close ("non-blocking"), then 1162 * don't bother trying to drain. 1163 * 1164 * If the user did M_STOP (ASYNC_STOPPED), there's no hope of ever 1165 * getting an M_START (since these messages aren't enqueued), and the 1166 * only other way to clear the stop condition is by loss of DCD, which 1167 * would discard the queue data. Thus, we drop the output data if 1168 * ASYNC_STOPPED is set. 1169 */ 1170 if ((flag & (FNDELAY|FNONBLOCK)) || 1171 (async->async_flags & ASYNC_STOPPED)) { 1172 goto nodrain; 1173 } 1174 1175 /* 1176 * If there's any pending output, then we have to try to drain it. 1177 * There are two main cases to be handled: 1178 * - called by close(2): need to drain until done or until 1179 * a signal is received. No timeout. 1180 * - called by exit(2): need to drain while making progress 1181 * or until a timeout occurs. No signals. 1182 * 1183 * If we can't rely on receiving a signal to get us out of a hung 1184 * session, then we have to use a timer. In this case, we set a timer 1185 * to check for progress in sending the output data -- all that we ask 1186 * (at each interval) is that there's been some progress made. Since 1187 * the interrupt routine grabs buffers from the write queue, we can't 1188 * trust async_ocnt. Instead, we use a flag. 1189 * 1190 * Note that loss of carrier will cause the output queue to be flushed, 1191 * and we'll wake up again and finish normally. 1192 */ 1193 if (!ddi_can_receive_sig() && su_drain_check != 0) { 1194 async->async_flags &= ~ASYNC_PROGRESS; 1195 async->async_timer = timeout(async_progress_check, async, 1196 drv_usectohz(su_drain_check)); 1197 } 1198 1199 while (async->async_ocnt > 0 || 1200 async->async_ttycommon.t_writeq->q_first != NULL || 1201 (async->async_flags & (ASYNC_BUSY|ASYNC_BREAK|ASYNC_DELAY))) { 1202 if (cv_wait_sig(&async->async_flags_cv, asy->asy_excl) == 0) 1203 break; 1204 } 1205 if (async->async_timer != 0) { 1206 (void) untimeout(async->async_timer); 1207 async->async_timer = 0; 1208 } 1209 1210 nodrain: 1211 mutex_enter(asy->asy_excl_hi); 1212 1213 /* turn off the loopback mode */ 1214 if ((async->async_dev != rconsdev) && 1215 (async->async_dev != kbddev) && 1216 (async->async_dev != stdindev)) { 1217 OUTB(MCR, INB(MCR) & ~ ASY_LOOP); 1218 } 1219 1220 async->async_ocnt = 0; 1221 if (async->async_xmitblk != NULL) 1222 freeb(async->async_xmitblk); 1223 async->async_xmitblk = NULL; 1224 1225 /* 1226 * If the "nohupcl" OBP property is set for this device, do 1227 * not turn off DTR and RTS no matter what. Otherwise, if the 1228 * line has HUPCL set or is incompletely opened, turn off DTR 1229 * and RTS to fix the modem line. 1230 */ 1231 if (!nohupcl && ((async->async_ttycommon.t_cflag & HUPCL) || 1232 (async->async_flags & ASYNC_WOPEN))) { 1233 /* turn off DTR, RTS but NOT interrupt to 386 */ 1234 OUTB(MCR, OUT2); 1235 mutex_exit(asy->asy_excl_hi); 1236 /* 1237 * Don't let an interrupt in the middle of close 1238 * bounce us back to the top; just continue closing 1239 * as if nothing had happened. 1240 */ 1241 if (cv_wait_sig(&lbolt_cv, asy->asy_excl) == 0) 1242 goto out; 1243 mutex_enter(asy->asy_excl_hi); 1244 } 1245 1246 /* 1247 * If nobody's using it now, turn off receiver interrupts. 1248 */ 1249 if ((async->async_flags & (ASYNC_WOPEN|ASYNC_ISOPEN)) == 0) { 1250 icr = INB(ICR); 1251 OUTB(ICR, (icr & ~RIEN)); 1252 } 1253 mutex_exit(asy->asy_excl_hi); 1254 out: 1255 /* 1256 * Clear out device state. 1257 */ 1258 async->async_flags = 0; 1259 ttycommon_close(&async->async_ttycommon); 1260 cv_broadcast(&async->async_flags_cv); 1261 1262 /* 1263 * Clear ASY_DOINGSOFT and ASY_NEEDSOFT in case we were in 1264 * async_softint or an interrupt was pending when the process 1265 * using the port exited. 1266 */ 1267 asy->asy_flags &= ~ASY_DOINGSOFT & ~ASY_NEEDSOFT; 1268 1269 /* 1270 * Cancel outstanding "bufcall" request. 1271 */ 1272 if (async->async_wbufcid) { 1273 unbufcall(async->async_wbufcid); 1274 async->async_wbufcid = 0; 1275 } 1276 1277 /* 1278 * If inperim is true, it means the port is closing while there's 1279 * a pending software interrupt. async_flags has been zeroed out, 1280 * so this instance of leaveq() needs to be called before we call 1281 * qprocsoff() to disable services on the q. If inperim is false, 1282 * leaveq() has already been called or we're not in a perimeter. 1283 */ 1284 if (asy->inperim == B_TRUE) { 1285 asy->inperim = B_FALSE; 1286 mutex_exit(asy->asy_excl); 1287 leaveq(q); 1288 } else { 1289 mutex_exit(asy->asy_excl); 1290 } 1291 1292 /* Note that qprocsoff can't be done until after interrupts are off */ 1293 qprocsoff(q); 1294 q->q_ptr = WR(q)->q_ptr = NULL; 1295 async->async_ttycommon.t_readq = NULL; 1296 async->async_ttycommon.t_writeq = NULL; 1297 1298 return (0); 1299 } 1300 1301 /* 1302 * Checks to see if the serial port is still transmitting 1303 * characters. It returns true when there are characters 1304 * queued to transmit, when the holding register contains 1305 * a byte, or when the shifting register still contains 1306 * data to send. 1307 * 1308 */ 1309 static boolean_t 1310 asy_isbusy(struct asycom *asy) 1311 { 1312 struct asyncline *async; 1313 1314 #ifdef DEBUG 1315 if (asydebug & ASY_DEBUG_EOT) 1316 printf("isbusy\n"); 1317 #endif 1318 async = (struct asyncline *)asy->asy_priv; 1319 ASSERT(mutex_owned(asy->asy_excl)); 1320 ASSERT(mutex_owned(asy->asy_excl_hi)); 1321 return ((async->async_ocnt > 0) || 1322 ((INB(LSR) & XSRE) == 0)); 1323 } 1324 1325 /* 1326 * Program the ASY port. Most of the async operation is based on the values 1327 * of 'c_iflag' and 'c_cflag'. 1328 */ 1329 static int 1330 asy_program(struct asycom *asy, int mode) 1331 { 1332 struct asyncline *async; 1333 int baudrate, c_flag; 1334 int icr, lcr; 1335 int ocflags; 1336 int error = 0; 1337 1338 ASSERT(mutex_owned(asy->asy_excl)); 1339 ASSERT(mutex_owned(asy->asy_excl_hi)); 1340 1341 #ifdef DEBUG 1342 if (asydebug & ASY_DEBUG_PROCS) 1343 printf("program\n"); 1344 #endif 1345 async = (struct asyncline *)asy->asy_priv; 1346 1347 baudrate = async->async_ttycommon.t_cflag & CBAUD; 1348 if (async->async_ttycommon.t_cflag & CBAUDEXT) 1349 baudrate += 16; 1350 1351 /* Limit baudrate so it can't index out of baudtable */ 1352 if (baudrate >= N_SU_SPEEDS) baudrate = B9600; 1353 1354 /* 1355 * If baud rate requested is greater than the speed cap 1356 * or is an unsupported baud rate then reset t_cflag baud 1357 * to the last valid baud rate. If this is the initial 1358 * pass through asy_program then set it to 9600. 1359 */ 1360 if (((baudrate > 0) && (asyspdtab[baudrate] == 0)) || 1361 (baudtable[baudrate] > asy->asy_speed_cap)) { 1362 async->async_ttycommon.t_cflag &= ~CBAUD & ~CBAUDEXT & 1363 ~CIBAUD & ~CIBAUDEXT; 1364 if (mode == ASY_INIT) { 1365 async->async_ttycommon.t_cflag |= B9600; 1366 async->async_ttycommon.t_cflag |= B9600 << IBSHIFT; 1367 baudrate = B9600; 1368 } else { 1369 async->async_ttycommon.t_cflag |= 1370 (asy->asy_ocflags & (CBAUD | CBAUDEXT | 1371 CIBAUD | CIBAUDEXT)); 1372 error = EINVAL; 1373 goto end; 1374 } 1375 } 1376 1377 /* 1378 * If CIBAUD and CIBAUDEXT are zero then we should set them to 1379 * the equivelant output baud bits. Else, if CIBAUD and CIBAUDEXT 1380 * don't match CBAUD and CBAUDEXT respectively then we should 1381 * notify the requestor that we do not support split speeds. 1382 */ 1383 if ((async->async_ttycommon.t_cflag & (CIBAUD|CIBAUDEXT)) == 0) { 1384 async->async_ttycommon.t_cflag |= 1385 (async->async_ttycommon.t_cflag & CBAUD) << IBSHIFT; 1386 if (async->async_ttycommon.t_cflag & CBAUDEXT) 1387 async->async_ttycommon.t_cflag |= CIBAUDEXT; 1388 } else { 1389 if ((((async->async_ttycommon.t_cflag & CBAUD) << IBSHIFT) != 1390 (async->async_ttycommon.t_cflag & CIBAUD)) || 1391 !(((async->async_ttycommon.t_cflag & (CBAUDEXT | 1392 CIBAUDEXT)) == (CBAUDEXT | CIBAUDEXT)) || 1393 ((async->async_ttycommon.t_cflag & (CBAUDEXT | 1394 CIBAUDEXT)) == 0))) { 1395 async->async_ttycommon.t_cflag &= ~CBAUD & ~CBAUDEXT & 1396 ~CIBAUD & ~CIBAUDEXT; 1397 async->async_ttycommon.t_cflag |= 1398 (asy->asy_ocflags & (CBAUD | CBAUDEXT | 1399 CIBAUD | CIBAUDEXT)); 1400 error = EINVAL; 1401 goto end; 1402 } 1403 } 1404 1405 c_flag = async->async_ttycommon.t_cflag & 1406 (CLOCAL | CREAD | CSTOPB | CSIZE | PARENB | PARODD | CBAUD | 1407 CBAUDEXT | CIBAUD | CIBAUDEXT); 1408 1409 /* disable interrupts, see EXAR bug */ 1410 if (asy->asy_hwtype == ASY16C554D) 1411 OUTB(SPR, 0); 1412 OUTB(ICR, 0); 1413 1414 ocflags = asy->asy_ocflags; 1415 1416 /* flush/reset the status registers */ 1417 if (mode == ASY_INIT) { 1418 (void) INB(DAT); 1419 (void) INB(ISR); 1420 (void) INB(LSR); 1421 (void) INB(MSR); 1422 } 1423 1424 if (ocflags != (c_flag & ~CLOCAL) || mode == ASY_INIT) { 1425 /* Set line control */ 1426 lcr = INB(LCR); 1427 lcr &= ~(WLS0|WLS1|STB|PEN|EPS); 1428 1429 if (c_flag & CSTOPB) 1430 lcr |= STB; /* 2 stop bits */ 1431 1432 if (c_flag & PARENB) 1433 lcr |= PEN; 1434 1435 if ((c_flag & PARODD) == 0) 1436 lcr |= EPS; 1437 1438 switch (c_flag & CSIZE) { 1439 case CS5: 1440 lcr |= BITS5; 1441 break; 1442 case CS6: 1443 lcr |= BITS6; 1444 break; 1445 case CS7: 1446 lcr |= BITS7; 1447 break; 1448 case CS8: 1449 lcr |= BITS8; 1450 break; 1451 } 1452 1453 /* set the baud rate when the rate is NOT B0 */ 1454 if (baudrate != 0) { 1455 OUTB(LCR, DLAB); 1456 OUTB(DAT, (asyspdtab[baudrate] * 1457 asy->asy_baud_divisor_factor) & 0xff); 1458 OUTB(ICR, ((asyspdtab[baudrate] * 1459 asy->asy_baud_divisor_factor) >> 8) & 0xff); 1460 } 1461 /* set the line control modes */ 1462 OUTB(LCR, lcr); 1463 1464 /* 1465 * if transitioning from CREAD off to CREAD on, 1466 * flush the FIFO buffer if we have one. 1467 */ 1468 if ((ocflags & CREAD) == 0 && (c_flag & CREAD)) { 1469 if (asy->asy_use_fifo == FIFO_ON) { 1470 OUTB(FIFOR, FIFO_ON | FIFODMA | FIFORXFLSH | 1471 (asy->asy_trig_level & 0xff)); 1472 } 1473 } 1474 1475 /* remember the new cflags */ 1476 asy->asy_ocflags = c_flag & ~CLOCAL; 1477 } 1478 1479 /* whether or not CLOCAL is set, modify the modem control lines */ 1480 if (baudrate == 0) 1481 /* B0 has been issued, lower DTR */ 1482 OUTB(MCR, RTS|OUT2); 1483 else 1484 /* raise DTR */ 1485 OUTB(MCR, DTR|RTS|OUT2); 1486 1487 /* 1488 * Call the modem status interrupt handler to check for the carrier 1489 * in case CLOCAL was turned off after the carrier came on. 1490 * (Note: Modem status interrupt is not enabled if CLOCAL is ON.) 1491 */ 1492 async_msint(asy); 1493 1494 /* Set interrupt control */ 1495 if ((c_flag & CLOCAL) && !(async->async_ttycommon.t_cflag & CRTSCTS)) 1496 /* 1497 * direct-wired line ignores DCD, so we don't enable modem 1498 * status interrupts. 1499 */ 1500 icr = (TIEN | SIEN); 1501 else 1502 icr = (TIEN | SIEN | MIEN); 1503 1504 if (c_flag & CREAD) 1505 icr |= RIEN; 1506 1507 OUTB(ICR, icr); 1508 end: 1509 return (error); 1510 } 1511 1512 /* 1513 * Polled mode support -- all functions called with interrupts 1514 * disabled. 1515 */ 1516 1517 static void 1518 asyputchar(cons_polledio_arg_t arg, uchar_t c) 1519 { 1520 struct asycom *asy = (struct asycom *)arg; 1521 1522 /* 1523 * If we see a line feed make sure to also 1524 * put out a carriage return. 1525 */ 1526 if (c == '\n') 1527 asyputchar(arg, '\r'); 1528 1529 while ((INB(LSR) & XHRE) == 0) { 1530 /* wait for the transmission to complete */ 1531 drv_usecwait(10); 1532 } 1533 1534 /* ouput the character */ 1535 OUTB(DAT, c); 1536 } 1537 1538 /* 1539 * Determines if there is a character avaialable for 1540 * reading. 1541 */ 1542 static boolean_t 1543 asyischar(cons_polledio_arg_t arg) 1544 { 1545 struct asycom *asy = (struct asycom *)arg; 1546 return ((INB(LSR) & RCA) != 0); 1547 } 1548 1549 static int 1550 asygetchar(cons_polledio_arg_t arg) 1551 { 1552 struct asycom *asy = (struct asycom *)arg; 1553 1554 /* 1555 * Spin waiting for a character to be 1556 * available to read. 1557 */ 1558 while (!asyischar(arg)) 1559 drv_usecwait(10); 1560 1561 return (INB(DAT)); 1562 } 1563 1564 /* 1565 * Called when machine is transitioning to polled mode 1566 */ 1567 static void 1568 asy_polled_enter(cons_polledio_arg_t arg) 1569 { 1570 struct asycom *asy = (struct asycom *)arg; 1571 1572 mutex_enter(asy->asy_excl); 1573 mutex_enter(asy->asy_excl_hi); 1574 1575 /* 1576 * If this is the first time that asy_polled_enter() 1577 * has been called, during this transition request, 1578 * save the ICR. Clear the software interrupt 1579 * flags since we won't be able to handle these when 1580 * we are in polled mode. 1581 */ 1582 if (!asy->polled_enter) { 1583 asy->polled_enter = B_TRUE; 1584 asy->polled_icr = INB(ICR); 1585 1586 /* Disable HW interrupts */ 1587 if (asy->asy_hwtype == ASY16C554D) 1588 OUTB(SPR, 0); 1589 OUTB(ICR, 0); 1590 1591 asy->asy_flags &= ~ASY_DOINGSOFT & ~ASY_NEEDSOFT; 1592 } 1593 mutex_exit(asy->asy_excl_hi); 1594 mutex_exit(asy->asy_excl); 1595 } 1596 1597 /* 1598 * Called when machine is transitioning from polled mode. 1599 */ 1600 static void 1601 asy_polled_exit(cons_polledio_arg_t arg) 1602 { 1603 struct asycom *asy = (struct asycom *)arg; 1604 1605 mutex_enter(asy->asy_excl); 1606 mutex_enter(asy->asy_excl_hi); 1607 1608 /* Restore the ICR */ 1609 OUTB(ICR, asy->polled_icr); 1610 1611 /* 1612 * We have finished this polled IO transition. 1613 * Set polled_enter to B_FALSE to note this. 1614 */ 1615 asy->polled_enter = B_FALSE; 1616 mutex_exit(asy->asy_excl_hi); 1617 mutex_exit(asy->asy_excl); 1618 } 1619 1620 /* 1621 * asyintr() is the High Level Interrupt Handler. 1622 * 1623 * There are four different interrupt types indexed by ISR register values: 1624 * 0: modem 1625 * 1: Tx holding register is empty, ready for next char 1626 * 2: Rx register now holds a char to be picked up 1627 * 3: error or break on line 1628 * This routine checks the Bit 0 (interrupt-not-pending) to determine if 1629 * the interrupt is from this port. 1630 */ 1631 uint_t 1632 asyintr(caddr_t argasy) 1633 { 1634 struct asycom *asy = (struct asycom *)argasy; 1635 struct asyncline *async; 1636 int ret_status = DDI_INTR_UNCLAIMED; 1637 uchar_t interrupt_id, lsr; 1638 1639 interrupt_id = INB(ISR) & 0x0F; 1640 async = (struct asyncline *)asy->asy_priv; 1641 if ((async == NULL) || 1642 !(async->async_flags & (ASYNC_ISOPEN|ASYNC_WOPEN))) { 1643 if (interrupt_id & NOINTERRUPT) { 1644 return (DDI_INTR_UNCLAIMED); 1645 } else { 1646 lsr = INB(LSR); 1647 if ((lsr & BRKDET) && 1648 ((abort_enable == KIOCABORTENABLE) && 1649 (async->async_dev == rconsdev))) 1650 abort_sequence_enter((char *)NULL); 1651 else { 1652 /* reset line status */ 1653 (void) INB(LSR); 1654 /* discard any data */ 1655 (void) INB(DAT); 1656 /* reset modem status */ 1657 (void) INB(MSR); 1658 return (DDI_INTR_CLAIMED); 1659 } 1660 } 1661 } 1662 /* 1663 * Spurious interrupts happen in this driver 1664 * because of the transmission on serial port not handled 1665 * properly. 1666 * 1667 * The reasons for Spurious interrupts are: 1668 * 1. There is a path in async_nstart which transmits 1669 * characters without going through interrupt services routine 1670 * which causes spurious interrupts to happen. 1671 * 2. In the async_txint more than one character is sent 1672 * in one interrupt service. 1673 * 3. In async_rxint more than one characters are received in 1674 * in one interrupt service. 1675 * 1676 * Hence we have flags to indicate that such scenerio has happened. 1677 * and claim only such interrupts and others we donot claim it 1678 * as it could be a indicator of some hardware problem. 1679 * 1680 */ 1681 if (interrupt_id & NOINTERRUPT) { 1682 mutex_enter(asy->asy_excl_hi); 1683 if ((asy->asy_xmit_count > 1) || 1684 (asy->asy_out_of_band_xmit > 0) || 1685 (asy->asy_rx_count > 1)) { 1686 asy->asy_xmit_count = 0; 1687 asy->asy_out_of_band_xmit = 0; 1688 asy->asy_rx_count = 0; 1689 mutex_exit(asy->asy_excl_hi); 1690 return (DDI_INTR_CLAIMED); 1691 } else { 1692 mutex_exit(asy->asy_excl_hi); 1693 return (DDI_INTR_UNCLAIMED); 1694 } 1695 } 1696 ret_status = DDI_INTR_CLAIMED; 1697 mutex_enter(asy->asy_excl_hi); 1698 if (asy->asy_hwtype == ASY82510) 1699 OUTB(ISR, 0x00); /* set bank 0 */ 1700 1701 #ifdef DEBUG 1702 if (asydebug & ASY_DEBUG_INTR) 1703 prom_printf("l"); 1704 #endif 1705 lsr = INB(LSR); 1706 switch (interrupt_id) { 1707 case RxRDY: 1708 case RSTATUS: 1709 case FFTMOUT: 1710 /* receiver interrupt or receiver errors */ 1711 async_rxint(asy, lsr); 1712 break; 1713 case TxRDY: 1714 /* transmit interrupt */ 1715 async_txint(asy, lsr); 1716 break; 1717 case MSTATUS: 1718 /* modem status interrupt */ 1719 async_msint(asy); 1720 break; 1721 } 1722 mutex_exit(asy->asy_excl_hi); 1723 return (ret_status); 1724 } 1725 1726 /* 1727 * Transmitter interrupt service routine. 1728 * If there is more data to transmit in the current pseudo-DMA block, 1729 * send the next character if output is not stopped or draining. 1730 * Otherwise, queue up a soft interrupt. 1731 * 1732 * XXX - Needs review for HW FIFOs. 1733 */ 1734 static void 1735 async_txint(struct asycom *asy, uchar_t lsr) 1736 { 1737 struct asyncline *async = (struct asyncline *)asy->asy_priv; 1738 int fifo_len; 1739 int xmit_progress; 1740 1741 asycheckflowcontrol_hw(asy); 1742 1743 /* 1744 * If ASYNC_BREAK has been set, return to asyintr()'s context to 1745 * claim the interrupt without performing any action. 1746 */ 1747 if (async->async_flags & ASYNC_BREAK) 1748 return; 1749 1750 fifo_len = asy->asy_fifo_buf; /* with FIFO buffers */ 1751 1752 /* 1753 * Check for flow control and do the needed action. 1754 */ 1755 if (asycheckflowcontrol_sw(asy)) { 1756 return; 1757 } 1758 1759 if (async->async_ocnt > 0 && 1760 !(async->async_flags & (ASYNC_HW_OUT_FLW|ASYNC_STOPPED))) { 1761 xmit_progress = 0; 1762 while (fifo_len > 0 && async->async_ocnt > 0) { 1763 if (lsr & XHRE) { 1764 OUTB(DAT, *async->async_optr++); 1765 fifo_len--; 1766 async->async_ocnt--; 1767 xmit_progress++; 1768 } 1769 /* 1770 * Reading the lsr, (moved reading at the end of 1771 * while loop) as already we have read once at 1772 * the beginning of interrupt service 1773 */ 1774 lsr = INB(LSR); 1775 } 1776 asy->asy_xmit_count = xmit_progress; 1777 if (xmit_progress > 0) 1778 async->async_flags |= ASYNC_PROGRESS; 1779 } 1780 1781 if (fifo_len == 0) { 1782 return; 1783 } 1784 1785 1786 ASYSETSOFT(asy); 1787 } 1788 1789 /* 1790 * Receiver interrupt: RxRDY interrupt, FIFO timeout interrupt or receive 1791 * error interrupt. 1792 * Try to put the character into the circular buffer for this line; if it 1793 * overflows, indicate a circular buffer overrun. If this port is always 1794 * to be serviced immediately, or the character is a STOP character, or 1795 * more than 15 characters have arrived, queue up a soft interrupt to 1796 * drain the circular buffer. 1797 * XXX - needs review for hw FIFOs support. 1798 */ 1799 1800 static void 1801 async_rxint(struct asycom *asy, uchar_t lsr) 1802 { 1803 struct asyncline *async = (struct asyncline *)asy->asy_priv; 1804 uchar_t c = 0; 1805 uint_t s = 0, needsoft = 0; 1806 register tty_common_t *tp; 1807 1808 tp = &async->async_ttycommon; 1809 if (!(tp->t_cflag & CREAD)) { 1810 if (lsr & (RCA|PARERR|FRMERR|BRKDET|OVRRUN)) { 1811 (void) (INB(DAT) & 0xff); 1812 } 1813 return; /* line is not open for read? */ 1814 } 1815 asy->asy_rx_count = 0; 1816 while (lsr & (RCA|PARERR|FRMERR|BRKDET|OVRRUN)) { 1817 c = 0; 1818 s = 0; 1819 asy->asy_rx_count++; 1820 if (lsr & RCA) { 1821 c = INB(DAT) & 0xff; 1822 /* 1823 * Even a single character is received 1824 * we need Soft interrupt to pass it to 1825 * higher layers. 1826 */ 1827 needsoft = 1; 1828 } 1829 1830 /* Check for character break sequence */ 1831 if ((abort_enable == KIOCABORTALTERNATE) && 1832 (async->async_dev == rconsdev)) { 1833 if (abort_charseq_recognize(c)) 1834 abort_sequence_enter((char *)NULL); 1835 } 1836 1837 /* Handle framing errors */ 1838 if (lsr & (PARERR|FRMERR|BRKDET|OVRRUN)) { 1839 if (lsr & PARERR) { 1840 if (tp->t_iflag & INPCK) /* parity enabled */ 1841 s |= PERROR; 1842 } 1843 if (lsr & (FRMERR|BRKDET)) 1844 s |= FRERROR; 1845 if (lsr & OVRRUN) { 1846 async->async_hw_overrun = 1; 1847 s |= OVERRUN; 1848 } 1849 } 1850 1851 if (s == 0) 1852 if ((tp->t_iflag & PARMRK) && 1853 !(tp->t_iflag & (IGNPAR|ISTRIP)) && 1854 (c == 0377)) 1855 if (RING_POK(async, 2)) { 1856 RING_PUT(async, 0377); 1857 RING_PUT(async, c); 1858 } else 1859 async->async_sw_overrun = 1; 1860 else 1861 if (RING_POK(async, 1)) 1862 RING_PUT(async, c); 1863 else 1864 async->async_sw_overrun = 1; 1865 else 1866 if (s & FRERROR) { /* Handle framing errors */ 1867 if (c == 0) { 1868 /* Look for break on kbd, stdin, or rconsdev */ 1869 if ((async->async_dev == kbddev) || 1870 ((async->async_dev == rconsdev) || 1871 (async->async_dev == stdindev)) && 1872 (abort_enable != 1873 KIOCABORTALTERNATE)) 1874 abort_sequence_enter((char *)0); 1875 else 1876 async->async_break++; 1877 } else { 1878 if (RING_POK(async, 1)) 1879 RING_MARK(async, c, s); 1880 else 1881 async->async_sw_overrun = 1; 1882 } 1883 } else { /* Parity errors handled by ldterm */ 1884 if (RING_POK(async, 1)) 1885 RING_MARK(async, c, s); 1886 else 1887 async->async_sw_overrun = 1; 1888 } 1889 lsr = INB(LSR); 1890 if (asy->asy_rx_count > 16) break; 1891 } 1892 /* Check whether there is a request for hw/sw inbound/input flow ctrl */ 1893 if ((async->async_ttycommon.t_cflag & CRTSXOFF) || 1894 (async->async_ttycommon.t_iflag & IXOFF)) 1895 if ((int)(RING_CNT(async)) > (RINGSIZE * 3)/4) { 1896 #ifdef DEBUG 1897 if (asydebug & ASY_DEBUG_HFLOW) 1898 printf("asy%d: hardware flow stop input.\n", 1899 UNIT(async->async_dev)); 1900 #endif 1901 async->async_flags |= ASYNC_HW_IN_FLOW; 1902 async->async_flowc = async->async_stopc; 1903 async->async_ringbuf_overflow = 1; 1904 } 1905 1906 if ((async->async_flags & ASYNC_SERVICEIMM) || needsoft || 1907 (RING_FRAC(async)) || (async->async_polltid == 0)) 1908 ASYSETSOFT(asy); /* need a soft interrupt */ 1909 } 1910 1911 /* 1912 * Interrupt on port: handle PPS event. This function is only called 1913 * for a port on which PPS event handling has been enabled. 1914 */ 1915 static void 1916 asy_ppsevent(struct asycom *asy, int msr) 1917 { 1918 if (asy->asy_flags & ASY_PPS_EDGE) { 1919 /* Have seen leading edge, now look for and record drop */ 1920 if ((msr & DCD) == 0) 1921 asy->asy_flags &= ~ASY_PPS_EDGE; 1922 /* 1923 * Waiting for leading edge, look for rise; stamp event and 1924 * calibrate kernel clock. 1925 */ 1926 } else if (msr & DCD) { 1927 /* 1928 * This code captures a timestamp at the designated 1929 * transition of the PPS signal (DCD asserted). The 1930 * code provides a pointer to the timestamp, as well 1931 * as the hardware counter value at the capture. 1932 * 1933 * Note: the kernel has nano based time values while 1934 * NTP requires micro based, an in-line fast algorithm 1935 * to convert nsec to usec is used here -- see hrt2ts() 1936 * in common/os/timers.c for a full description. 1937 */ 1938 struct timeval *tvp = &asy_ppsev.tv; 1939 timestruc_t ts; 1940 long nsec, usec; 1941 1942 asy->asy_flags |= ASY_PPS_EDGE; 1943 gethrestime(&ts); 1944 nsec = ts.tv_nsec; 1945 usec = nsec + (nsec >> 2); 1946 usec = nsec + (usec >> 1); 1947 usec = nsec + (usec >> 2); 1948 usec = nsec + (usec >> 4); 1949 usec = nsec - (usec >> 3); 1950 usec = nsec + (usec >> 2); 1951 usec = nsec + (usec >> 3); 1952 usec = nsec + (usec >> 4); 1953 usec = nsec + (usec >> 1); 1954 usec = nsec + (usec >> 6); 1955 tvp->tv_usec = usec >> 10; 1956 tvp->tv_sec = ts.tv_sec; 1957 1958 ++asy_ppsev.serial; 1959 1960 /* 1961 * Because the kernel keeps a high-resolution time, 1962 * pass the current highres timestamp in tvp and zero 1963 * in usec. 1964 */ 1965 ddi_hardpps(tvp, 0); 1966 } 1967 } 1968 1969 /* 1970 * Modem status interrupt. 1971 * 1972 * (Note: It is assumed that the MSR hasn't been read by asyintr().) 1973 */ 1974 1975 static void 1976 async_msint(struct asycom *asy) 1977 { 1978 struct asyncline *async = (struct asyncline *)asy->asy_priv; 1979 int msr; 1980 1981 msr = INB(MSR); /* this resets the interrupt */ 1982 asy->asy_cached_msr = msr; 1983 #ifdef DEBUG 1984 if (asydebug & ASY_DEBUG_STATE) { 1985 printf(" transition: %3s %3s %3s %3s\n" 1986 "current state: %3s %3s %3s %3s\n", 1987 (msr & DCTS) ? "CTS" : " ", 1988 (msr & DDSR) ? "DSR" : " ", 1989 (msr & DRI) ? "RI " : " ", 1990 (msr & DDCD) ? "DCD" : " ", 1991 (msr & CTS) ? "CTS" : " ", 1992 (msr & DSR) ? "DSR" : " ", 1993 (msr & RI) ? "RI " : " ", 1994 (msr & DCD) ? "DCD" : " "); 1995 } 1996 #endif 1997 if (async->async_ttycommon.t_cflag & CRTSCTS && !(msr & CTS)) { 1998 #ifdef DEBUG 1999 if (asydebug & ASY_DEBUG_HFLOW) 2000 printf("asy%d: hflow start\n", 2001 UNIT(async->async_dev)); 2002 #endif 2003 async->async_flags |= ASYNC_HW_OUT_FLW; 2004 } 2005 if (asy->asy_hwtype == ASY82510) 2006 OUTB(MSR, (msr & 0xF0)); 2007 2008 /* Handle PPS event */ 2009 if (asy->asy_flags & ASY_PPS) 2010 asy_ppsevent(asy, msr); 2011 2012 async->async_ext++; 2013 ASYSETSOFT(asy); 2014 } 2015 2016 /* 2017 * Handle a second-stage interrupt. 2018 */ 2019 uint_t 2020 asysoftintr(caddr_t intarg) 2021 { 2022 struct asycom *asy = (struct asycom *)intarg; 2023 struct asyncline *async; 2024 int rv; 2025 int cc; 2026 /* 2027 * Test and clear soft interrupt. 2028 */ 2029 mutex_enter(asy->asy_soft_lock); 2030 #ifdef DEBUG 2031 if (asydebug & ASY_DEBUG_PROCS) 2032 printf("softintr\n"); 2033 #endif 2034 rv = asy->asysoftpend; 2035 if (rv != 0) 2036 asy->asysoftpend = 0; 2037 mutex_exit(asy->asy_soft_lock); 2038 2039 if (rv) { 2040 if (asy->asy_priv == NULL) 2041 return (rv); 2042 async = (struct asyncline *)asy->asy_priv; 2043 mutex_enter(asy->asy_excl_hi); 2044 if (asy->asy_flags & ASY_NEEDSOFT) { 2045 asy->asy_flags &= ~ASY_NEEDSOFT; 2046 mutex_exit(asy->asy_excl_hi); 2047 (void) async_softint(asy); 2048 mutex_enter(asy->asy_excl_hi); 2049 } 2050 /* 2051 * There are some instances where the softintr is not 2052 * scheduled and hence not called. It so happened that makes 2053 * the last few characters to be stuck in ringbuffer. 2054 * Hence, call once again the handler so that the last few 2055 * characters are cleared. 2056 */ 2057 cc = RING_CNT(async); 2058 mutex_exit(asy->asy_excl_hi); 2059 if (cc > 0) { 2060 (void) async_softint(asy); 2061 } 2062 } 2063 return (rv); 2064 } 2065 2066 /* 2067 * Handle a software interrupt. 2068 */ 2069 static int 2070 async_softint(struct asycom *asy) 2071 { 2072 struct asyncline *async = (struct asyncline *)asy->asy_priv; 2073 uint_t cc; 2074 mblk_t *bp; 2075 queue_t *q; 2076 uchar_t val; 2077 uchar_t c; 2078 tty_common_t *tp; 2079 2080 #ifdef DEBUG 2081 if (asydebug & ASY_DEBUG_PROCS) 2082 printf("process\n"); 2083 #endif 2084 mutex_enter(asy->asy_excl); 2085 if (asy->asy_flags & ASY_DOINGSOFT) { 2086 mutex_exit(asy->asy_excl); 2087 return (0); 2088 } 2089 tp = &async->async_ttycommon; 2090 q = tp->t_readq; 2091 if (q != NULL) { 2092 mutex_exit(asy->asy_excl); 2093 enterq(q); 2094 mutex_enter(asy->asy_excl); 2095 } 2096 mutex_enter(asy->asy_excl_hi); 2097 asy->asy_flags |= ASY_DOINGSOFT; 2098 2099 if (INB(ICR) & MIEN) 2100 val = asy->asy_cached_msr & 0xFF; 2101 else 2102 val = INB(MSR) & 0xFF; 2103 2104 if (async->async_ttycommon.t_cflag & CRTSCTS) { 2105 if ((val & CTS) && (async->async_flags & ASYNC_HW_OUT_FLW)) { 2106 #ifdef DEBUG 2107 if (asydebug & ASY_DEBUG_HFLOW) 2108 printf("asy%d: hflow start\n", 2109 UNIT(async->async_dev)); 2110 #endif 2111 async->async_flags &= ~ASYNC_HW_OUT_FLW; 2112 mutex_exit(asy->asy_excl_hi); 2113 if (async->async_ocnt > 0) { 2114 mutex_enter(asy->asy_excl_hi); 2115 async_resume(async); 2116 mutex_exit(asy->asy_excl_hi); 2117 } else { 2118 async_start(async); 2119 } 2120 mutex_enter(asy->asy_excl_hi); 2121 } 2122 } 2123 if (async->async_ext) { 2124 async->async_ext = 0; 2125 /* check for carrier up */ 2126 if ((val & DCD) || (tp->t_flags & TS_SOFTCAR)) { 2127 /* carrier present */ 2128 if ((async->async_flags & ASYNC_CARR_ON) == 0) { 2129 async->async_flags |= ASYNC_CARR_ON; 2130 mutex_exit(asy->asy_excl_hi); 2131 mutex_exit(asy->asy_excl); 2132 if (async->async_flags & ASYNC_ISOPEN) 2133 (void) putctl(q, M_UNHANGUP); 2134 cv_broadcast(&async->async_flags_cv); 2135 mutex_enter(asy->asy_excl); 2136 mutex_enter(asy->asy_excl_hi); 2137 } 2138 } else { 2139 if ((async->async_flags & ASYNC_CARR_ON) && 2140 !(tp->t_cflag & CLOCAL)) { 2141 int flushflag; 2142 2143 /* 2144 * Carrier went away. 2145 * Drop DTR, abort any output in 2146 * progress, indicate that output is 2147 * not stopped, and send a hangup 2148 * notification upstream. 2149 * 2150 * If we're in the midst of close, then flush 2151 * everything. Don't leave stale ioctls lying 2152 * about. 2153 */ 2154 val = INB(MCR); 2155 OUTB(MCR, (val & ~DTR)); 2156 flushflag = (async->async_flags & 2157 ASYNC_CLOSING) ? FLUSHALL : FLUSHDATA; 2158 if (tp->t_writeq != NULL) { 2159 flushq(tp->t_writeq, flushflag); 2160 } 2161 if (async->async_xmitblk != NULL) { 2162 freeb(async->async_xmitblk); 2163 async->async_xmitblk = NULL; 2164 } 2165 if (async->async_flags & ASYNC_BUSY) { 2166 async->async_ocnt = 0; 2167 async->async_flags &= ~ASYNC_BUSY; 2168 } 2169 async->async_flags &= ~ASYNC_STOPPED; 2170 if (async->async_flags & ASYNC_ISOPEN) { 2171 mutex_exit(asy->asy_excl_hi); 2172 mutex_exit(asy->asy_excl); 2173 (void) putctl(q, M_HANGUP); 2174 mutex_enter(asy->asy_excl); 2175 mutex_enter(asy->asy_excl_hi); 2176 } 2177 async->async_flags &= ~ASYNC_CARR_ON; 2178 mutex_exit(asy->asy_excl_hi); 2179 cv_broadcast(&async->async_flags_cv); 2180 mutex_enter(asy->asy_excl_hi); 2181 } 2182 } 2183 } 2184 2185 /* 2186 * If data has been added to the circular buffer, remove 2187 * it from the buffer, and send it up the stream if there's 2188 * somebody listening. Try to do it 16 bytes at a time. If we 2189 * have more than 16 bytes to move, move 16 byte chunks and 2190 * leave the rest for next time around (maybe it will grow). 2191 */ 2192 if (!(async->async_flags & ASYNC_ISOPEN)) { 2193 RING_INIT(async); 2194 goto rv; 2195 } 2196 if ((cc = RING_CNT(async)) == 0) { 2197 goto rv; 2198 } 2199 mutex_exit(asy->asy_excl_hi); 2200 2201 if (!canput(q)) { 2202 if ((async->async_flags & ASYNC_HW_IN_FLOW) == 0) { 2203 #ifdef DEBUG 2204 if (!(asydebug & ASY_DEBUG_HFLOW)) { 2205 printf("asy%d: hflow stop input.\n", 2206 UNIT(async->async_dev)); 2207 if (canputnext(q)) 2208 printf("asy%d: next queue is " 2209 "ready\n", 2210 UNIT(async->async_dev)); 2211 } 2212 #endif 2213 mutex_enter(asy->asy_excl_hi); 2214 async->async_flags |= ASYNC_HW_IN_FLOW; 2215 async->async_flowc = async->async_stopc; 2216 } else mutex_enter(asy->asy_excl_hi); 2217 goto rv; 2218 } 2219 2220 if (async->async_ringbuf_overflow) { 2221 if ((async->async_flags & ASYNC_HW_IN_FLOW) && 2222 ((int)(RING_CNT(async)) < (RINGSIZE/4))) { 2223 #ifdef DEBUG 2224 if (asydebug & ASY_DEBUG_HFLOW) 2225 printf("asy%d: hflow start input.\n", 2226 UNIT(async->async_dev)); 2227 #endif 2228 mutex_enter(asy->asy_excl_hi); 2229 async->async_flags &= ~ASYNC_HW_IN_FLOW; 2230 async->async_flowc = async->async_startc; 2231 async->async_ringbuf_overflow = 0; 2232 goto rv; 2233 } 2234 } 2235 #ifdef DEBUG 2236 if (asydebug & ASY_DEBUG_INPUT) 2237 printf("asy%d: %d char(s) in queue.\n", 2238 UNIT(async->async_dev), cc); 2239 #endif 2240 /* 2241 * Before you pull the characters from the RING BUF 2242 * Check whether you can put into the queue again 2243 */ 2244 if ((!canputnext(q)) || (!canput(q))) { 2245 mutex_enter(asy->asy_excl_hi); 2246 if ((async->async_flags & ASYNC_HW_IN_FLOW) == 0) { 2247 async->async_flags |= ASYNC_HW_IN_FLOW; 2248 async->async_flowc = async->async_stopc; 2249 async->async_queue_full = 1; 2250 } 2251 goto rv; 2252 } 2253 mutex_enter(asy->asy_excl_hi); 2254 if (async->async_queue_full) { 2255 /* 2256 * Last time the Stream queue didnot allow 2257 * now it allows so, relax, the flow control 2258 */ 2259 if (async->async_flags & ASYNC_HW_IN_FLOW) { 2260 async->async_flags &= ~ASYNC_HW_IN_FLOW; 2261 async->async_queue_full = 0; 2262 async->async_flowc = async->async_startc; 2263 goto rv; 2264 } else 2265 async->async_queue_full = 0; 2266 } 2267 mutex_exit(asy->asy_excl_hi); 2268 if (!(bp = allocb(cc, BPRI_MED))) { 2269 ttycommon_qfull(&async->async_ttycommon, q); 2270 mutex_enter(asy->asy_excl_hi); 2271 goto rv; 2272 } 2273 mutex_enter(asy->asy_excl_hi); 2274 do { 2275 if (RING_ERR(async, S_ERRORS)) { 2276 RING_UNMARK(async); 2277 c = RING_GET(async); 2278 break; 2279 } else { 2280 *bp->b_wptr++ = RING_GET(async); 2281 } 2282 } while (--cc); 2283 2284 mutex_exit(asy->asy_excl_hi); 2285 mutex_exit(asy->asy_excl); 2286 if (bp->b_wptr > bp->b_rptr) { 2287 if (!canputnext(q)) { 2288 if (!canput(q)) { 2289 /* 2290 * Even after taking all precautions that 2291 * Still we are unable to queue, then we 2292 * cannot do anything, just drop the block 2293 */ 2294 cmn_err(CE_NOTE, 2295 "su%d: local queue full\n", 2296 UNIT(async->async_dev)); 2297 freemsg(bp); 2298 mutex_enter(asy->asy_excl_hi); 2299 if ((async->async_flags & 2300 ASYNC_HW_IN_FLOW) == 0) { 2301 async->async_flags |= 2302 ASYNC_HW_IN_FLOW; 2303 async->async_flowc = 2304 async->async_stopc; 2305 async->async_queue_full = 1; 2306 } 2307 mutex_exit(asy->asy_excl_hi); 2308 } else { 2309 (void) putq(q, bp); 2310 } 2311 } else { 2312 putnext(q, bp); 2313 } 2314 } else { 2315 freemsg(bp); 2316 } 2317 /* 2318 * If we have a parity error, then send 2319 * up an M_BREAK with the "bad" 2320 * character as an argument. Let ldterm 2321 * figure out what to do with the error. 2322 */ 2323 if (cc) 2324 (void) putctl1(q, M_BREAK, c); 2325 mutex_enter(asy->asy_excl); 2326 mutex_enter(asy->asy_excl_hi); 2327 rv: 2328 /* 2329 * If a transmission has finished, indicate that it's finished, 2330 * and start that line up again. 2331 */ 2332 if (async->async_break) { 2333 async->async_break = 0; 2334 if (async->async_flags & ASYNC_ISOPEN) { 2335 mutex_exit(asy->asy_excl_hi); 2336 mutex_exit(asy->asy_excl); 2337 (void) putctl(q, M_BREAK); 2338 mutex_enter(asy->asy_excl); 2339 mutex_enter(asy->asy_excl_hi); 2340 } 2341 } 2342 if ((async->async_ocnt <= 0 && (async->async_flags & ASYNC_BUSY)) || 2343 (async->async_flowc != '\0')) { 2344 async->async_flags &= ~ASYNC_BUSY; 2345 mutex_exit(asy->asy_excl_hi); 2346 if (async->async_xmitblk) 2347 freeb(async->async_xmitblk); 2348 async->async_xmitblk = NULL; 2349 if (async->async_flags & ASYNC_ISOPEN) { 2350 asy->inperim = B_TRUE; 2351 mutex_exit(asy->asy_excl); 2352 enterq(async->async_ttycommon.t_writeq); 2353 mutex_enter(asy->asy_excl); 2354 } 2355 async_start(async); 2356 /* 2357 * We need to check for inperim and ISOPEN due to 2358 * multi-threading implications; it's possible to close the 2359 * port and nullify async_flags while completing the software 2360 * interrupt. If the port is closed, leaveq() will have already 2361 * been called. We don't want to call it twice. 2362 */ 2363 if ((asy->inperim) && (async->async_flags & ASYNC_ISOPEN)) { 2364 mutex_exit(asy->asy_excl); 2365 leaveq(async->async_ttycommon.t_writeq); 2366 mutex_enter(asy->asy_excl); 2367 asy->inperim = B_FALSE; 2368 } 2369 if (!(async->async_flags & ASYNC_BUSY)) 2370 cv_broadcast(&async->async_flags_cv); 2371 mutex_enter(asy->asy_excl_hi); 2372 } 2373 /* 2374 * A note about these overrun bits: all they do is *tell* someone 2375 * about an error- They do not track multiple errors. In fact, 2376 * you could consider them latched register bits if you like. 2377 * We are only interested in printing the error message once for 2378 * any cluster of overrun errors. 2379 */ 2380 if (async->async_hw_overrun) { 2381 if (async->async_flags & ASYNC_ISOPEN) { 2382 if (su_log > 0) { 2383 mutex_exit(asy->asy_excl_hi); 2384 mutex_exit(asy->asy_excl); 2385 cmn_err(CE_NOTE, "su%d: silo overflow\n", 2386 UNIT(async->async_dev)); 2387 mutex_enter(asy->asy_excl); 2388 mutex_enter(asy->asy_excl_hi); 2389 } 2390 INC64_KSTAT(asy, siloover); 2391 } 2392 async->async_hw_overrun = 0; 2393 } 2394 if (async->async_sw_overrun) { 2395 if (async->async_flags & ASYNC_ISOPEN) { 2396 if (su_log > 0) { 2397 mutex_exit(asy->asy_excl_hi); 2398 mutex_exit(asy->asy_excl); 2399 cmn_err(CE_NOTE, "su%d: ring buffer overflow\n", 2400 UNIT(async->async_dev)); 2401 mutex_enter(asy->asy_excl); 2402 mutex_enter(asy->asy_excl_hi); 2403 } 2404 INC64_KSTAT(asy, ringover); 2405 } 2406 async->async_sw_overrun = 0; 2407 } 2408 asy->asy_flags &= ~ASY_DOINGSOFT; 2409 mutex_exit(asy->asy_excl_hi); 2410 mutex_exit(asy->asy_excl); 2411 if (q != NULL) 2412 leaveq(q); 2413 return (0); 2414 } 2415 2416 /* 2417 * Restart output on a line after a delay or break timer expired. 2418 */ 2419 static void 2420 async_restart(void *arg) 2421 { 2422 struct asyncline *async = arg; 2423 struct asycom *asy = async->async_common; 2424 queue_t *q; 2425 uchar_t lcr; 2426 2427 /* 2428 * If break timer expired, turn off the break bit. 2429 */ 2430 #ifdef DEBUG 2431 if (asydebug & ASY_DEBUG_PROCS) 2432 printf("restart\n"); 2433 #endif 2434 mutex_enter(asy->asy_excl); 2435 if (async->async_flags & ASYNC_BREAK) { 2436 unsigned int rate; 2437 2438 mutex_enter(asy->asy_excl_hi); 2439 lcr = INB(LCR); 2440 OUTB(LCR, (lcr & ~SETBREAK)); 2441 2442 /* 2443 * Go to sleep for the time it takes for at least one 2444 * stop bit to be received by the device at the other 2445 * end of the line as stated in the RS-232 specification. 2446 * The wait period is equal to: 2447 * 2 clock cycles * (1 MICROSEC / baud rate) 2448 */ 2449 rate = async->async_ttycommon.t_cflag & CBAUD; 2450 if (async->async_ttycommon.t_cflag & CBAUDEXT) 2451 rate += 16; 2452 if (rate >= N_SU_SPEEDS || rate == B0) { 2453 rate = B9600; 2454 } 2455 2456 mutex_exit(asy->asy_excl_hi); 2457 mutex_exit(asy->asy_excl); 2458 drv_usecwait(2 * MICROSEC / baudtable[rate]); 2459 mutex_enter(asy->asy_excl); 2460 } 2461 async->async_flags &= ~(ASYNC_DELAY|ASYNC_BREAK|ASYNC_DRAINING); 2462 if ((q = async->async_ttycommon.t_writeq) != NULL) { 2463 mutex_exit(asy->asy_excl); 2464 enterq(q); 2465 mutex_enter(asy->asy_excl); 2466 } 2467 async_start(async); 2468 mutex_exit(asy->asy_excl); 2469 if (q != NULL) 2470 leaveq(q); 2471 2472 /* cleared break or delay flag; may have made some output progress */ 2473 cv_broadcast(&async->async_flags_cv); 2474 } 2475 2476 static void 2477 async_start(struct asyncline *async) 2478 { 2479 async_nstart(async, 0); 2480 } 2481 2482 /* 2483 * Start output on a line, unless it's busy, frozen, or otherwise. 2484 */ 2485 static void 2486 async_nstart(struct asyncline *async, int mode) 2487 { 2488 register struct asycom *asy = async->async_common; 2489 register int cc; 2490 register queue_t *q; 2491 mblk_t *bp, *nbp; 2492 uchar_t *xmit_addr; 2493 uchar_t val; 2494 int fifo_len = 1; 2495 int xmit_progress; 2496 2497 #ifdef DEBUG 2498 if (asydebug & ASY_DEBUG_PROCS) 2499 printf("start\n"); 2500 #endif 2501 if (asy->asy_use_fifo == FIFO_ON) 2502 fifo_len = asy->asy_fifo_buf; /* with FIFO buffers */ 2503 2504 ASSERT(mutex_owned(asy->asy_excl)); 2505 mutex_enter(asy->asy_excl_hi); 2506 asycheckflowcontrol_hw(asy); 2507 2508 /* 2509 * If the chip is busy (i.e., we're waiting for a break timeout 2510 * to expire, or for the current transmission to finish, or for 2511 * output to finish draining from chip), don't grab anything new. 2512 */ 2513 if (async->async_flags & (ASYNC_BREAK|ASYNC_BUSY|ASYNC_DRAINING)) { 2514 mutex_exit(asy->asy_excl_hi); 2515 #ifdef DEBUG 2516 if (mode && asydebug & ASY_DEBUG_CLOSE) 2517 printf("asy%d: start %s.\n", 2518 UNIT(async->async_dev), 2519 async->async_flags & ASYNC_BREAK 2520 ? "break" : "busy"); 2521 #endif 2522 return; 2523 } 2524 2525 /* 2526 * If we have a flow-control character to transmit, do it now. 2527 */ 2528 if (asycheckflowcontrol_sw(asy)) { 2529 mutex_exit(asy->asy_excl_hi); 2530 return; 2531 } 2532 mutex_exit(asy->asy_excl_hi); 2533 /* 2534 * If we're waiting for a delay timeout to expire, don't grab 2535 * anything new. 2536 */ 2537 if (async->async_flags & ASYNC_DELAY) { 2538 #ifdef DEBUG 2539 if (mode && asydebug & ASY_DEBUG_CLOSE) 2540 printf("asy%d: start ASYNC_DELAY.\n", 2541 UNIT(async->async_dev)); 2542 #endif 2543 return; 2544 } 2545 2546 if ((q = async->async_ttycommon.t_writeq) == NULL) { 2547 #ifdef DEBUG 2548 if (mode && asydebug & ASY_DEBUG_CLOSE) 2549 printf("asy%d: start writeq is null.\n", 2550 UNIT(async->async_dev)); 2551 #endif 2552 return; /* not attached to a stream */ 2553 } 2554 2555 for (;;) { 2556 if ((bp = getq(q)) == NULL) 2557 return; /* no data to transmit */ 2558 2559 /* 2560 * We have a message block to work on. 2561 * Check whether it's a break, a delay, or an ioctl (the latter 2562 * occurs if the ioctl in question was waiting for the output 2563 * to drain). If it's one of those, process it immediately. 2564 */ 2565 switch (bp->b_datap->db_type) { 2566 2567 case M_BREAK: 2568 /* 2569 * Set the break bit, and arrange for "async_restart" 2570 * to be called in 1/4 second; it will turn the 2571 * break bit off, and call "async_start" to grab 2572 * the next message. 2573 */ 2574 mutex_enter(asy->asy_excl_hi); 2575 val = INB(LCR); 2576 OUTB(LCR, (val | SETBREAK)); 2577 mutex_exit(asy->asy_excl_hi); 2578 async->async_flags |= ASYNC_BREAK; 2579 (void) timeout(async_restart, async, hz / 4); 2580 freemsg(bp); 2581 return; /* wait for this to finish */ 2582 2583 case M_DELAY: 2584 /* 2585 * Arrange for "async_restart" to be called when the 2586 * delay expires; it will turn ASYNC_DELAY off, 2587 * and call "async_start" to grab the next message. 2588 */ 2589 (void) timeout(async_restart, async, 2590 (clock_t)(*(unsigned char *)bp->b_rptr + 6)); 2591 async->async_flags |= ASYNC_DELAY; 2592 freemsg(bp); 2593 return; /* wait for this to finish */ 2594 2595 case M_IOCTL: 2596 /* 2597 * This ioctl needs to wait for the output ahead of 2598 * it to drain. Try to do it, and then either 2599 * redo the ioctl at a later time or grab the next 2600 * message after it. 2601 */ 2602 2603 mutex_enter(asy->asy_excl_hi); 2604 if (asy_isbusy(asy)) { 2605 /* 2606 * Get the divisor by calculating the rate 2607 */ 2608 unsigned int rate; 2609 2610 mutex_exit(asy->asy_excl_hi); 2611 rate = async->async_ttycommon.t_cflag & CBAUD; 2612 if (async->async_ttycommon.t_cflag & CBAUDEXT) 2613 rate += 16; 2614 if (rate >= N_SU_SPEEDS || rate == B0) { 2615 rate = B9600; 2616 } 2617 2618 /* 2619 * We need to do a callback as the port will 2620 * be set to drain 2621 */ 2622 async->async_flags |= ASYNC_DRAINING; 2623 2624 /* 2625 * Put the message we just processed back onto 2626 * the end of the queue 2627 */ 2628 if (putq(q, bp) == 0) 2629 freemsg(bp); 2630 2631 /* 2632 * We need to delay until the TSR and THR 2633 * have been exhausted. We base the delay on 2634 * the amount of time it takes to transmit 2635 * 2 chars at the current baud rate in 2636 * microseconds. 2637 * 2638 * Therefore, the wait period is: 2639 * 2640 * (#TSR bits + #THR bits) * 2641 * 1 MICROSEC / baud rate 2642 */ 2643 (void) timeout(async_restart, async, 2644 drv_usectohz(16 * MICROSEC / 2645 baudtable[rate])); 2646 return; 2647 } 2648 mutex_exit(asy->asy_excl_hi); 2649 mutex_exit(asy->asy_excl); 2650 async_ioctl(async, q, bp, B_FALSE); 2651 mutex_enter(asy->asy_excl); 2652 continue; 2653 } 2654 2655 while (bp != NULL && (cc = bp->b_wptr - bp->b_rptr) == 0) { 2656 nbp = bp->b_cont; 2657 freeb(bp); 2658 bp = nbp; 2659 } 2660 if (bp != NULL) 2661 break; 2662 } 2663 2664 /* 2665 * We have data to transmit. If output is stopped, put 2666 * it back and try again later. 2667 */ 2668 if (async->async_flags & (ASYNC_HW_OUT_FLW|ASYNC_STOPPED)) { 2669 #ifdef DEBUG 2670 if (asydebug & ASY_DEBUG_HFLOW && 2671 async->async_flags & ASYNC_HW_OUT_FLW) 2672 printf("asy%d: output hflow in effect.\n", 2673 UNIT(async->async_dev)); 2674 #endif 2675 mutex_exit(asy->asy_excl); 2676 (void) putbq(q, bp); 2677 /* 2678 * We entered the routine owning the lock, we need to 2679 * exit the routine owning the lock. 2680 */ 2681 mutex_enter(asy->asy_excl); 2682 return; 2683 } 2684 2685 async->async_xmitblk = bp; 2686 xmit_addr = bp->b_rptr; 2687 bp = bp->b_cont; 2688 if (bp != NULL) { 2689 mutex_exit(asy->asy_excl); 2690 (void) putbq(q, bp); /* not done with this message yet */ 2691 mutex_enter(asy->asy_excl); 2692 } 2693 2694 /* 2695 * In 5-bit mode, the high order bits are used 2696 * to indicate character sizes less than five, 2697 * so we need to explicitly mask before transmitting 2698 */ 2699 if ((async->async_ttycommon.t_cflag & CSIZE) == CS5) { 2700 register unsigned char *p = xmit_addr; 2701 register int cnt = cc; 2702 2703 while (cnt--) 2704 *p++ &= (unsigned char) 0x1f; 2705 } 2706 2707 /* 2708 * Set up this block for pseudo-DMA. 2709 */ 2710 mutex_enter(asy->asy_excl_hi); 2711 async->async_optr = xmit_addr; 2712 async->async_ocnt = cc; 2713 /* 2714 * If the transmitter is ready, shove some 2715 * characters out. 2716 */ 2717 xmit_progress = 0; 2718 while (fifo_len-- && async->async_ocnt) { 2719 if (INB(LSR) & XHRE) { 2720 OUTB(DAT, *async->async_optr++); 2721 async->async_ocnt--; 2722 xmit_progress++; 2723 } 2724 } 2725 asy->asy_out_of_band_xmit = xmit_progress; 2726 if (xmit_progress > 0) 2727 async->async_flags |= ASYNC_PROGRESS; 2728 async->async_flags |= ASYNC_BUSY; 2729 mutex_exit(asy->asy_excl_hi); 2730 } 2731 2732 /* 2733 * Resume output by poking the transmitter. 2734 */ 2735 static void 2736 async_resume(struct asyncline *async) 2737 { 2738 register struct asycom *asy = async->async_common; 2739 2740 ASSERT(mutex_owned(asy->asy_excl_hi)); 2741 #ifdef DEBUG 2742 if (asydebug & ASY_DEBUG_PROCS) 2743 printf("resume\n"); 2744 #endif 2745 2746 asycheckflowcontrol_hw(asy); 2747 2748 if (INB(LSR) & XHRE) { 2749 if (asycheckflowcontrol_sw(asy)) { 2750 return; 2751 } else if (async->async_ocnt > 0) { 2752 OUTB(DAT, *async->async_optr++); 2753 async->async_ocnt--; 2754 async->async_flags |= ASYNC_PROGRESS; 2755 } 2756 } 2757 } 2758 2759 /* 2760 * Process an "ioctl" message sent down to us. 2761 * Note that we don't need to get any locks until we are ready to access 2762 * the hardware. Nothing we access until then is going to be altered 2763 * outside of the STREAMS framework, so we should be safe. 2764 */ 2765 static void 2766 async_ioctl(struct asyncline *async, queue_t *wq, mblk_t *mp, boolean_t iswput) 2767 { 2768 register struct asycom *asy = async->async_common; 2769 register tty_common_t *tp = &async->async_ttycommon; 2770 register struct iocblk *iocp; 2771 register unsigned datasize; 2772 size_t ioc_count; 2773 mblk_t *datamp; 2774 int error = 0; 2775 uchar_t val, icr; 2776 #ifdef DEBUG 2777 if (asydebug & ASY_DEBUG_PROCS) 2778 printf("ioctl\n"); 2779 #endif 2780 2781 if (tp->t_iocpending != NULL) { 2782 /* 2783 * We were holding an "ioctl" response pending the 2784 * availability of an "mblk" to hold data to be passed up; 2785 * another "ioctl" came through, which means that "ioctl" 2786 * must have timed out or been aborted. 2787 */ 2788 freemsg(async->async_ttycommon.t_iocpending); 2789 async->async_ttycommon.t_iocpending = NULL; 2790 } 2791 2792 iocp = (struct iocblk *)mp->b_rptr; 2793 2794 /* 2795 * Save off the ioc count in case we need to restore it 2796 * because we are queuing a message block. 2797 */ 2798 ioc_count = iocp->ioc_count; 2799 2800 /* 2801 * For TIOCMGET, TIOCMBIC, TIOCMBIS, TIOCMSET, and PPS, do NOT call 2802 * ttycommon_ioctl() because this function frees up the message block 2803 * (mp->b_cont) that contains the address of the user variable where 2804 * we need to pass back the bit array. 2805 * 2806 * Similarly, ttycommon_ioctl() does not know about CONSOPENPOLLEDIO 2807 * and CONSCLOSEPOLLEDIO, so don't let ttycommon_ioctl() touch them. 2808 */ 2809 if (iocp->ioc_cmd == TIOCMGET || 2810 iocp->ioc_cmd == TIOCMBIC || 2811 iocp->ioc_cmd == TIOCMBIS || 2812 iocp->ioc_cmd == TIOCMSET || 2813 iocp->ioc_cmd == TIOCGPPS || 2814 iocp->ioc_cmd == TIOCSPPS || 2815 iocp->ioc_cmd == TIOCGPPSEV || 2816 iocp->ioc_cmd == CONSOPENPOLLEDIO || 2817 iocp->ioc_cmd == CONSCLOSEPOLLEDIO) 2818 error = -1; /* Do Nothing */ 2819 else 2820 2821 /* 2822 * The only way in which "ttycommon_ioctl" can fail is if the "ioctl" 2823 * requires a response containing data to be returned to the user, 2824 * and no mblk could be allocated for the data. 2825 * No such "ioctl" alters our state. Thus, we always go ahead and 2826 * do any state-changes the "ioctl" calls for. If we couldn't allocate 2827 * the data, "ttycommon_ioctl" has stashed the "ioctl" away safely, so 2828 * we just call "bufcall" to request that we be called back when we 2829 * stand a better chance of allocating the data. 2830 */ 2831 if ((datasize = ttycommon_ioctl(tp, wq, mp, &error)) != 0) { 2832 if (async->async_wbufcid) 2833 unbufcall(async->async_wbufcid); 2834 async->async_wbufcid = bufcall(datasize, BPRI_HI, async_reioctl, 2835 async); 2836 return; 2837 } 2838 2839 mutex_enter(asy->asy_excl); 2840 2841 if (error == 0) { 2842 /* 2843 * "ttycommon_ioctl" did most of the work; we just use the 2844 * data it set up. 2845 */ 2846 switch (iocp->ioc_cmd) { 2847 2848 case TCSETS: 2849 if (!(asy->asy_rsc_console || asy->asy_rsc_control || 2850 asy->asy_lom_console)) { 2851 mutex_enter(asy->asy_excl_hi); 2852 error = asy_program(asy, ASY_NOINIT); 2853 mutex_exit(asy->asy_excl_hi); 2854 } 2855 break; 2856 case TCSETSF: 2857 case TCSETSW: 2858 case TCSETA: 2859 case TCSETAW: 2860 case TCSETAF: 2861 if (!(asy->asy_rsc_console || asy->asy_rsc_control || 2862 asy->asy_lom_console)) { 2863 mutex_enter(asy->asy_excl_hi); 2864 if (iswput && asy_isbusy(asy)) { 2865 /* 2866 * ttycommon_ioctl sets the db_type to 2867 * M_IOCACK and ioc_count to zero 2868 * we need to undo this when we 2869 * queue a control message. This will 2870 * allow the control messages to be 2871 * processed again when the chip 2872 * becomes available. 2873 */ 2874 mp->b_datap->db_type = M_IOCTL; 2875 iocp->ioc_count = ioc_count; 2876 2877 if (putq(wq, mp) == 0) 2878 freemsg(mp); 2879 mutex_exit(asy->asy_excl_hi); 2880 mutex_exit(asy->asy_excl); 2881 return; 2882 } 2883 2884 /* 2885 * TCSETA, TCSETAW, and TCSETAF make use of 2886 * the termio structure and therefore have 2887 * no concept of any speed except what can 2888 * be represented by CBAUD. This is because 2889 * of legacy SVR4 code. Therefore, if we see 2890 * one of the aforementioned IOCTL commands 2891 * we should zero out CBAUDEXT, CIBAUD, and 2892 * CIBAUDEXT as to not break legacy 2893 * functionality. This is because CBAUDEXT, 2894 * CIBAUD, and CIBAUDEXT can't be stored in 2895 * an unsigned short. By zeroing out CBAUDEXT, 2896 * CIBAUD, and CIBAUDEXT in the t_cflag of the 2897 * termios structure asy_program() will set the 2898 * input baud rate to the output baud rate. 2899 */ 2900 if (iocp->ioc_cmd == TCSETA || 2901 iocp->ioc_cmd == TCSETAW || 2902 iocp->ioc_cmd == TCSETAF) 2903 tp->t_cflag &= ~(CIBAUD | 2904 CIBAUDEXT | CBAUDEXT); 2905 2906 error = asy_program(asy, ASY_NOINIT); 2907 mutex_exit(asy->asy_excl_hi); 2908 } 2909 break; 2910 case TIOCSSOFTCAR: 2911 /* Set the driver state appropriately */ 2912 mutex_enter(asy->asy_excl_hi); 2913 if (tp->t_flags & TS_SOFTCAR) 2914 asy->asy_flags |= ASY_IGNORE_CD; 2915 else 2916 asy->asy_flags &= ~ASY_IGNORE_CD; 2917 mutex_exit(asy->asy_excl_hi); 2918 break; 2919 } 2920 } else if (error < 0) { 2921 /* 2922 * "ttycommon_ioctl" didn't do anything; we process it here. 2923 */ 2924 error = 0; 2925 switch (iocp->ioc_cmd) { 2926 2927 case TIOCGPPS: 2928 /* 2929 * Get PPS on/off. 2930 */ 2931 if (mp->b_cont != NULL) 2932 freemsg(mp->b_cont); 2933 2934 mp->b_cont = allocb(sizeof (int), BPRI_HI); 2935 if (mp->b_cont == NULL) { 2936 error = ENOMEM; 2937 break; 2938 } 2939 if (asy->asy_flags & ASY_PPS) 2940 *(int *)mp->b_cont->b_wptr = 1; 2941 else 2942 *(int *)mp->b_cont->b_wptr = 0; 2943 mp->b_cont->b_wptr += sizeof (int); 2944 mp->b_datap->db_type = M_IOCACK; 2945 iocp->ioc_count = sizeof (int); 2946 break; 2947 2948 case TIOCSPPS: 2949 /* 2950 * Set PPS on/off. 2951 */ 2952 error = miocpullup(mp, sizeof (int)); 2953 if (error != 0) 2954 break; 2955 2956 mutex_enter(asy->asy_excl_hi); 2957 if (*(int *)mp->b_cont->b_rptr) 2958 asy->asy_flags |= ASY_PPS; 2959 else 2960 asy->asy_flags &= ~ASY_PPS; 2961 /* Reset edge sense */ 2962 asy->asy_flags &= ~ASY_PPS_EDGE; 2963 mutex_exit(asy->asy_excl_hi); 2964 mp->b_datap->db_type = M_IOCACK; 2965 break; 2966 2967 case TIOCGPPSEV: { 2968 /* 2969 * Get PPS event data. 2970 */ 2971 mblk_t *bp; 2972 void *buf; 2973 #ifdef _SYSCALL32_IMPL 2974 struct ppsclockev32 p32; 2975 #endif 2976 struct ppsclockev ppsclockev; 2977 2978 if (mp->b_cont != NULL) { 2979 freemsg(mp->b_cont); 2980 mp->b_cont = NULL; 2981 } 2982 2983 if ((asy->asy_flags & ASY_PPS) == 0) { 2984 error = ENXIO; 2985 break; 2986 } 2987 2988 /* Protect from incomplete asy_ppsev */ 2989 mutex_enter(asy->asy_excl_hi); 2990 ppsclockev = asy_ppsev; 2991 mutex_exit(asy->asy_excl_hi); 2992 2993 #ifdef _SYSCALL32_IMPL 2994 if ((iocp->ioc_flag & IOC_MODELS) != IOC_NATIVE) { 2995 TIMEVAL_TO_TIMEVAL32(&p32.tv, &ppsclockev.tv); 2996 p32.serial = ppsclockev.serial; 2997 buf = &p32; 2998 iocp->ioc_count = sizeof (struct ppsclockev32); 2999 } else 3000 #endif 3001 { 3002 buf = &ppsclockev; 3003 iocp->ioc_count = sizeof (struct ppsclockev); 3004 } 3005 3006 if ((bp = allocb(iocp->ioc_count, BPRI_HI)) == NULL) { 3007 error = ENOMEM; 3008 break; 3009 } 3010 mp->b_cont = bp; 3011 3012 bcopy(buf, bp->b_wptr, iocp->ioc_count); 3013 bp->b_wptr += iocp->ioc_count; 3014 mp->b_datap->db_type = M_IOCACK; 3015 break; 3016 } 3017 3018 case TCSBRK: 3019 error = miocpullup(mp, sizeof (int)); 3020 if (error != 0) 3021 break; 3022 3023 mutex_enter(asy->asy_excl_hi); 3024 if (*(int *)mp->b_cont->b_rptr == 0) { 3025 /* 3026 * Get the divisor by calculating the rate 3027 */ 3028 unsigned int rate, divisor; 3029 rate = async->async_ttycommon.t_cflag & CBAUD; 3030 if (async->async_ttycommon.t_cflag & CBAUDEXT) 3031 rate += 16; 3032 if (rate >= N_SU_SPEEDS) rate = B9600; 3033 divisor = asyspdtab[rate] & 0xfff; 3034 3035 /* 3036 * To ensure that erroneous characters are 3037 * not sent out when the break is set, SB 3038 * recommends three steps: 3039 * 3040 * 1) pad the TSR with 0 bits 3041 * 2) When the TSR is full, set break 3042 * 3) When the TSR has been flushed, unset 3043 * the break when transmission must be 3044 * restored. 3045 * 3046 * We loop until the TSR is empty and then 3047 * set the break. ASYNC_BREAK has been set 3048 * to ensure that no characters are 3049 * transmitted while the TSR is being 3050 * flushed and SOUT is being used for the 3051 * break signal. 3052 * 3053 * The wait period is equal to 3054 * clock / (baud * 16) * 16 * 2. 3055 */ 3056 async->async_flags |= ASYNC_BREAK; 3057 while ((INB(LSR) & XSRE) == 0) { 3058 mutex_exit(asy->asy_excl_hi); 3059 mutex_exit(asy->asy_excl); 3060 drv_usecwait(32*divisor); 3061 mutex_enter(asy->asy_excl); 3062 mutex_enter(asy->asy_excl_hi); 3063 } 3064 3065 /* 3066 * Set the break bit, and arrange for 3067 * "async_restart" to be called in 1/4 second; 3068 * it will turn the break bit off, and call 3069 * "async_start" to grab the next message. 3070 */ 3071 val = INB(LCR); 3072 OUTB(LCR, (val | SETBREAK)); 3073 mutex_exit(asy->asy_excl_hi); 3074 (void) timeout(async_restart, async, hz / 4); 3075 } else { 3076 #ifdef DEBUG 3077 if (asydebug & ASY_DEBUG_CLOSE) 3078 printf("asy%d: wait for flush.\n", 3079 UNIT(async->async_dev)); 3080 #endif 3081 if (iswput && asy_isbusy(asy)) { 3082 if (putq(wq, mp) == 0) 3083 freemsg(mp); 3084 mutex_exit(asy->asy_excl_hi); 3085 mutex_exit(asy->asy_excl); 3086 return; 3087 } 3088 mutex_exit(asy->asy_excl_hi); 3089 #ifdef DEBUG 3090 if (asydebug & ASY_DEBUG_CLOSE) 3091 printf("asy%d: ldterm satisfied.\n", 3092 UNIT(async->async_dev)); 3093 #endif 3094 } 3095 break; 3096 3097 case TIOCSBRK: 3098 mutex_enter(asy->asy_excl_hi); 3099 val = INB(LCR); 3100 OUTB(LCR, (val | SETBREAK)); 3101 mutex_exit(asy->asy_excl_hi); 3102 mutex_exit(asy->asy_excl); 3103 miocack(wq, mp, 0, 0); 3104 return; 3105 3106 case TIOCCBRK: 3107 mutex_enter(asy->asy_excl_hi); 3108 val = INB(LCR); 3109 OUTB(LCR, (val & ~SETBREAK)); 3110 mutex_exit(asy->asy_excl_hi); 3111 mutex_exit(asy->asy_excl); 3112 miocack(wq, mp, 0, 0); 3113 return; 3114 3115 case TIOCMSET: 3116 case TIOCMBIS: 3117 case TIOCMBIC: 3118 if (iocp->ioc_count == TRANSPARENT) 3119 mcopyin(mp, NULL, sizeof (int), NULL); 3120 else { 3121 error = miocpullup(mp, sizeof (int)); 3122 if (error != 0) 3123 break; 3124 3125 mutex_enter(asy->asy_excl_hi); 3126 3127 (void) asymctl(asy, 3128 dmtoasy(*(int *)mp->b_cont->b_rptr), 3129 iocp->ioc_cmd); 3130 3131 mutex_exit(asy->asy_excl_hi); 3132 iocp->ioc_error = 0; 3133 mp->b_datap->db_type = M_IOCACK; 3134 } 3135 break; 3136 3137 case TIOCSILOOP: 3138 mutex_enter(asy->asy_excl_hi); 3139 /* 3140 * If somebody misues this Ioctl when used for 3141 * driving keyboard and mouse indicate not supported 3142 */ 3143 if ((asy->asy_device_type == ASY_KEYBOARD) || 3144 (asy->asy_device_type == ASY_MOUSE)) { 3145 mutex_exit(asy->asy_excl_hi); 3146 error = ENOTTY; 3147 break; 3148 } 3149 3150 /* should not use when we're the console */ 3151 if ((async->async_dev == kbddev) || 3152 (async->async_dev == rconsdev) || 3153 (async->async_dev == stdindev)) { 3154 mutex_exit(asy->asy_excl_hi); 3155 error = EINVAL; 3156 break; 3157 } 3158 3159 val = INB(MCR); 3160 icr = INB(ICR); 3161 /* 3162 * Disable the Modem Status Interrupt 3163 * The reason for disabling is the status of 3164 * modem signal are in the higher 4 bits instead of 3165 * lower four bits when in loopback mode, 3166 * so, donot worry about Modem interrupt when 3167 * you are planning to set 3168 * this in loopback mode until it is cleared by 3169 * another ioctl to get out of the loopback mode 3170 */ 3171 OUTB(ICR, icr & ~ MIEN); 3172 OUTB(MCR, val | ASY_LOOP); 3173 mutex_exit(asy->asy_excl_hi); 3174 iocp->ioc_error = 0; 3175 mp->b_datap->db_type = M_IOCACK; 3176 break; 3177 3178 case TIOCMGET: 3179 datamp = allocb(sizeof (int), BPRI_MED); 3180 if (datamp == NULL) { 3181 error = EAGAIN; 3182 break; 3183 } 3184 3185 mutex_enter(asy->asy_excl_hi); 3186 *(int *)datamp->b_rptr = asymctl(asy, 0, TIOCMGET); 3187 mutex_exit(asy->asy_excl_hi); 3188 3189 if (iocp->ioc_count == TRANSPARENT) { 3190 mcopyout(mp, NULL, sizeof (int), NULL, datamp); 3191 } else { 3192 if (mp->b_cont != NULL) 3193 freemsg(mp->b_cont); 3194 mp->b_cont = datamp; 3195 mp->b_cont->b_wptr += sizeof (int); 3196 mp->b_datap->db_type = M_IOCACK; 3197 iocp->ioc_count = sizeof (int); 3198 } 3199 break; 3200 3201 case CONSOPENPOLLEDIO: 3202 /* 3203 * If we are driving a keyboard there is nothing 3204 * upstream to translate the scan codes. Therefore, 3205 * set the error code to ENOTSUP and NAK the request 3206 */ 3207 if (asy->asy_device_type == ASY_KEYBOARD) { 3208 error = ENOTSUP; 3209 break; 3210 } 3211 3212 error = miocpullup(mp, sizeof (struct cons_polledio *)); 3213 if (error != 0) 3214 break; 3215 3216 /* 3217 * send up a message block containing the 3218 * cons_polledio structure. This provides 3219 * handles to the putchar, getchar, ischar, 3220 * polledio_enter and polledio_exit functions. 3221 */ 3222 *(struct cons_polledio **)mp->b_cont->b_rptr = 3223 &asy->polledio; 3224 3225 mp->b_datap->db_type = M_IOCACK; 3226 break; 3227 3228 case CONSCLOSEPOLLEDIO: 3229 /* 3230 * If we are driving a keyboard we never successfully 3231 * called CONSOPENPOLLEDIO so set the error to 3232 * ENOTSUP and NAK the request. 3233 */ 3234 if (asy->asy_device_type == ASY_KEYBOARD) { 3235 error = ENOTSUP; 3236 break; 3237 } 3238 3239 mp->b_datap->db_type = M_IOCACK; 3240 iocp->ioc_error = 0; 3241 iocp->ioc_rval = 0; 3242 break; 3243 3244 default: /* unexpected ioctl type */ 3245 /* 3246 * If we don't understand it, it's an error. NAK it. 3247 */ 3248 error = EINVAL; 3249 break; 3250 } 3251 } 3252 if (error != 0) { 3253 iocp->ioc_error = error; 3254 mp->b_datap->db_type = M_IOCNAK; 3255 } 3256 mutex_exit(asy->asy_excl); 3257 qreply(wq, mp); 3258 } 3259 3260 static int 3261 asyrsrv(queue_t *q) 3262 { 3263 mblk_t *bp; 3264 struct asyncline *async; 3265 3266 async = (struct asyncline *)q->q_ptr; 3267 3268 while (canputnext(q) && (bp = getq(q))) 3269 putnext(q, bp); 3270 ASYSETSOFT(async->async_common); 3271 async->async_polltid = 0; 3272 return (0); 3273 } 3274 3275 /* 3276 * Put procedure for write queue. 3277 * Respond to M_STOP, M_START, M_IOCTL, and M_FLUSH messages here; 3278 * set the flow control character for M_STOPI and M_STARTI messages; 3279 * queue up M_BREAK, M_DELAY, and M_DATA messages for processing 3280 * by the start routine, and then call the start routine; discard 3281 * everything else. Note that this driver does not incorporate any 3282 * mechanism to negotiate to handle the canonicalization process. 3283 * It expects that these functions are handled in upper module(s), 3284 * as we do in ldterm. 3285 */ 3286 static int 3287 asywput(queue_t *q, mblk_t *mp) 3288 { 3289 register struct asyncline *async; 3290 register struct asycom *asy; 3291 int error; 3292 3293 async = (struct asyncline *)q->q_ptr; 3294 asy = async->async_common; 3295 3296 switch (mp->b_datap->db_type) { 3297 3298 case M_STOP: 3299 /* 3300 * Since we don't do real DMA, we can just let the 3301 * chip coast to a stop after applying the brakes. 3302 */ 3303 mutex_enter(asy->asy_excl); 3304 async->async_flags |= ASYNC_STOPPED; 3305 mutex_exit(asy->asy_excl); 3306 freemsg(mp); 3307 break; 3308 3309 case M_START: 3310 mutex_enter(asy->asy_excl); 3311 if (async->async_flags & ASYNC_STOPPED) { 3312 async->async_flags &= ~ASYNC_STOPPED; 3313 /* 3314 * If an output operation is in progress, 3315 * resume it. Otherwise, prod the start 3316 * routine. 3317 */ 3318 if (async->async_ocnt > 0) { 3319 mutex_enter(asy->asy_excl_hi); 3320 async_resume(async); 3321 mutex_exit(asy->asy_excl_hi); 3322 } else { 3323 async_start(async); 3324 } 3325 } 3326 mutex_exit(asy->asy_excl); 3327 freemsg(mp); 3328 break; 3329 3330 case M_IOCTL: 3331 switch (((struct iocblk *)mp->b_rptr)->ioc_cmd) { 3332 3333 case TCSBRK: 3334 error = miocpullup(mp, sizeof (int)); 3335 if (error != 0) { 3336 miocnak(q, mp, 0, error); 3337 return (0); 3338 } 3339 3340 if (*(int *)mp->b_cont->b_rptr != 0) { 3341 #ifdef DEBUG 3342 if (asydebug & ASY_DEBUG_CLOSE) 3343 printf("asy%d: flush request.\n", 3344 UNIT(async->async_dev)); 3345 #endif 3346 (void) putq(q, mp); 3347 mutex_enter(asy->asy_excl); 3348 async_nstart(async, 1); 3349 mutex_exit(asy->asy_excl); 3350 break; 3351 } 3352 /*FALLTHROUGH*/ 3353 case TCSETSW: 3354 case TCSETSF: 3355 case TCSETAW: 3356 case TCSETAF: 3357 /* 3358 * The changes do not take effect until all 3359 * output queued before them is drained. 3360 * Put this message on the queue, so that 3361 * "async_start" will see it when it's done 3362 * with the output before it. Poke the 3363 * start routine, just in case. 3364 */ 3365 (void) putq(q, mp); 3366 mutex_enter(asy->asy_excl); 3367 async_start(async); 3368 mutex_exit(asy->asy_excl); 3369 break; 3370 3371 default: 3372 /* 3373 * Do it now. 3374 */ 3375 async_ioctl(async, q, mp, B_TRUE); 3376 break; 3377 } 3378 break; 3379 3380 case M_FLUSH: 3381 if (*mp->b_rptr & FLUSHW) { 3382 mutex_enter(asy->asy_excl); 3383 3384 /* 3385 * Abort any output in progress. 3386 */ 3387 mutex_enter(asy->asy_excl_hi); 3388 if (async->async_flags & ASYNC_BUSY) { 3389 async->async_ocnt = 0; 3390 async->async_flags &= ~ASYNC_BUSY; 3391 } 3392 mutex_exit(asy->asy_excl_hi); 3393 3394 /* Flush FIFO buffers */ 3395 if (asy->asy_use_fifo == FIFO_ON) { 3396 OUTB(FIFOR, FIFO_ON | FIFODMA | FIFOTXFLSH | 3397 (asy->asy_trig_level & 0xff)); 3398 } 3399 3400 /* 3401 * Flush our write queue. 3402 */ 3403 flushq(q, FLUSHDATA); /* XXX doesn't flush M_DELAY */ 3404 if (async->async_xmitblk != NULL) { 3405 freeb(async->async_xmitblk); 3406 async->async_xmitblk = NULL; 3407 } 3408 3409 mutex_exit(asy->asy_excl); 3410 *mp->b_rptr &= ~FLUSHW; /* it has been flushed */ 3411 } 3412 if (*mp->b_rptr & FLUSHR) { 3413 /* Flush FIFO buffers */ 3414 if (asy->asy_use_fifo == FIFO_ON) { 3415 OUTB(FIFOR, FIFO_ON | FIFODMA | FIFORXFLSH | 3416 (asy->asy_trig_level & 0xff)); 3417 } 3418 flushq(RD(q), FLUSHDATA); 3419 qreply(q, mp); /* give the read queues a crack at it */ 3420 } else { 3421 freemsg(mp); 3422 } 3423 3424 /* 3425 * We must make sure we process messages that survive the 3426 * write-side flush. Without this call, the close protocol 3427 * with ldterm can hang forever. (ldterm will have sent us a 3428 * TCSBRK ioctl that it expects a response to.) 3429 */ 3430 mutex_enter(asy->asy_excl); 3431 async_start(async); 3432 mutex_exit(asy->asy_excl); 3433 break; 3434 case M_BREAK: 3435 case M_DELAY: 3436 case M_DATA: 3437 /* 3438 * Queue the message up to be transmitted, 3439 * and poke the start routine. 3440 */ 3441 (void) putq(q, mp); 3442 mutex_enter(asy->asy_excl); 3443 async_start(async); 3444 mutex_exit(asy->asy_excl); 3445 break; 3446 3447 case M_STOPI: 3448 mutex_enter(asy->asy_excl); 3449 async->async_flowc = async->async_stopc; 3450 async_start(async); /* poke the start routine */ 3451 mutex_exit(asy->asy_excl); 3452 freemsg(mp); 3453 break; 3454 3455 case M_STARTI: 3456 mutex_enter(asy->asy_excl); 3457 async->async_flowc = async->async_startc; 3458 async_start(async); /* poke the start routine */ 3459 mutex_exit(asy->asy_excl); 3460 freemsg(mp); 3461 break; 3462 3463 case M_CTL: 3464 if (MBLKL(mp) >= sizeof (struct iocblk) && 3465 ((struct iocblk *)mp->b_rptr)->ioc_cmd == MC_POSIXQUERY) { 3466 ((struct iocblk *)mp->b_rptr)->ioc_cmd = MC_HAS_POSIX; 3467 qreply(q, mp); 3468 } else { 3469 /* 3470 * These MC_SERVICE type messages are used by upper 3471 * modules to tell this driver to send input up 3472 * immediately, or that it can wait for normal 3473 * processing that may or may not be done. Sun 3474 * requires these for the mouse module. 3475 * (XXX - for x86?) 3476 */ 3477 mutex_enter(asy->asy_excl); 3478 switch (*mp->b_rptr) { 3479 3480 case MC_SERVICEIMM: 3481 async->async_flags |= ASYNC_SERVICEIMM; 3482 break; 3483 3484 case MC_SERVICEDEF: 3485 async->async_flags &= ~ASYNC_SERVICEIMM; 3486 break; 3487 } 3488 mutex_exit(asy->asy_excl); 3489 freemsg(mp); 3490 } 3491 break; 3492 3493 case M_IOCDATA: 3494 async_iocdata(q, mp); 3495 break; 3496 3497 default: 3498 freemsg(mp); 3499 break; 3500 } 3501 return (0); 3502 } 3503 3504 /* 3505 * Retry an "ioctl", now that "bufcall" claims we may be able to allocate 3506 * the buffer we need. 3507 */ 3508 static void 3509 async_reioctl(void *arg) 3510 { 3511 struct asyncline *async = arg; 3512 struct asycom *asy = async->async_common; 3513 queue_t *q; 3514 mblk_t *mp; 3515 3516 /* 3517 * The bufcall is no longer pending. 3518 */ 3519 mutex_enter(asy->asy_excl); 3520 async->async_wbufcid = 0; 3521 if ((q = async->async_ttycommon.t_writeq) == NULL) { 3522 mutex_exit(asy->asy_excl); 3523 return; 3524 } 3525 if ((mp = async->async_ttycommon.t_iocpending) != NULL) { 3526 /* not pending any more */ 3527 async->async_ttycommon.t_iocpending = NULL; 3528 mutex_exit(asy->asy_excl); 3529 /* not in STREAMS queue; we no longer know if we're in wput */ 3530 async_ioctl(async, q, mp, B_TRUE); 3531 } else 3532 mutex_exit(asy->asy_excl); 3533 } 3534 3535 static void 3536 async_iocdata(queue_t *q, mblk_t *mp) 3537 { 3538 struct asyncline *async = (struct asyncline *)q->q_ptr; 3539 struct asycom *asy; 3540 struct copyresp *csp; 3541 3542 asy = async->async_common; 3543 csp = (struct copyresp *)mp->b_rptr; 3544 3545 if (csp->cp_rval != 0) { 3546 freemsg(mp); 3547 return; 3548 } 3549 3550 mutex_enter(asy->asy_excl); 3551 3552 switch (csp->cp_cmd) { 3553 case TIOCMSET: 3554 case TIOCMBIS: 3555 case TIOCMBIC: 3556 if (mp->b_cont == NULL) { 3557 mutex_exit(asy->asy_excl); 3558 miocnak(q, mp, 0, EINVAL); 3559 break; 3560 } 3561 3562 mutex_enter(asy->asy_excl_hi); 3563 (void) asymctl(asy, dmtoasy(*(int *)mp->b_cont->b_rptr), 3564 csp->cp_cmd); 3565 mutex_exit(asy->asy_excl_hi); 3566 3567 freemsg(mp->b_cont); 3568 mp->b_cont = NULL; 3569 mutex_exit(asy->asy_excl); 3570 miocack(q, mp, 0, 0); 3571 break; 3572 3573 case TIOCMGET: 3574 if (mp->b_cont != NULL) { 3575 freemsg(mp->b_cont); 3576 mp->b_cont = NULL; 3577 } 3578 mutex_exit(asy->asy_excl); 3579 miocack(q, mp, 0, 0); 3580 break; 3581 3582 default: 3583 mutex_exit(asy->asy_excl); 3584 miocnak(q, mp, 0, EINVAL); 3585 break; 3586 } 3587 } 3588 3589 3590 /* 3591 * Set or get the modem control status. 3592 */ 3593 static int 3594 asymctl(struct asycom *asy, int bits, int how) 3595 { 3596 register int mcr_r, msr_r; 3597 3598 ASSERT(mutex_owned(asy->asy_excl_hi)); 3599 ASSERT(mutex_owned(asy->asy_excl)); 3600 3601 /* Read Modem Control Registers */ 3602 mcr_r = INB(MCR); 3603 3604 switch (how) { 3605 3606 case TIOCMSET: 3607 mcr_r = bits; 3608 break; 3609 3610 case TIOCMBIS: 3611 mcr_r |= bits; /* Set bits from input */ 3612 break; 3613 3614 case TIOCMBIC: 3615 mcr_r &= ~bits; /* Set ~bits from input */ 3616 break; 3617 3618 case TIOCMGET: 3619 /* Read Modem Status Registers */ 3620 if (INB(ICR) & MIEN) 3621 msr_r = asy->asy_cached_msr; 3622 else 3623 msr_r = INB(MSR); 3624 return (asytodm(mcr_r, msr_r)); 3625 } 3626 3627 OUTB(MCR, mcr_r); 3628 3629 return (mcr_r); 3630 } 3631 3632 static int 3633 asytodm(int mcr_r, int msr_r) 3634 { 3635 register int b = 0; 3636 3637 3638 /* MCR registers */ 3639 if (mcr_r & RTS) 3640 b |= TIOCM_RTS; 3641 3642 if (mcr_r & DTR) 3643 b |= TIOCM_DTR; 3644 3645 /* MSR registers */ 3646 if (msr_r & DCD) 3647 b |= TIOCM_CAR; 3648 3649 if (msr_r & CTS) 3650 b |= TIOCM_CTS; 3651 3652 if (msr_r & DSR) 3653 b |= TIOCM_DSR; 3654 3655 if (msr_r & RI) 3656 b |= TIOCM_RNG; 3657 3658 return (b); 3659 } 3660 3661 static int 3662 dmtoasy(int bits) 3663 { 3664 register int b = 0; 3665 3666 #ifdef CAN_NOT_SET /* only DTR and RTS can be set */ 3667 if (bits & TIOCM_CAR) 3668 b |= DCD; 3669 if (bits & TIOCM_CTS) 3670 b |= CTS; 3671 if (bits & TIOCM_DSR) 3672 b |= DSR; 3673 if (bits & TIOCM_RNG) 3674 b |= RI; 3675 #endif 3676 3677 if (bits & TIOCM_RTS) 3678 b |= RTS; 3679 if (bits & TIOCM_DTR) 3680 b |= DTR; 3681 3682 return (b); 3683 } 3684 3685 static void 3686 asycheckflowcontrol_hw(struct asycom *asy) 3687 { 3688 struct asyncline *async; 3689 uchar_t mcr, flag; 3690 3691 ASSERT(mutex_owned(asy->asy_excl_hi)); 3692 3693 async = (struct asyncline *)asy->asy_priv; 3694 ASSERT(async != NULL); 3695 3696 if (async->async_ttycommon.t_cflag & CRTSXOFF) { 3697 mcr = INB(MCR); 3698 flag = (async->async_flags & ASYNC_HW_IN_FLOW) ? 0 : RTS; 3699 if (((mcr ^ flag) & RTS) != 0) { 3700 OUTB(MCR, (mcr ^ RTS)); 3701 } 3702 } 3703 } 3704 3705 static boolean_t 3706 asycheckflowcontrol_sw(struct asycom *asy) 3707 { 3708 uchar_t ss; 3709 struct asyncline *async; 3710 int rval = B_FALSE; 3711 3712 ASSERT(mutex_owned(asy->asy_excl_hi)); 3713 3714 async = (struct asyncline *)asy->asy_priv; 3715 ASSERT(async != NULL); 3716 3717 if ((ss = async->async_flowc) != '\0' && (INB(LSR) & XHRE)) { 3718 /* 3719 * If we get this far, then we know that flowc is non-zero and 3720 * that there's transmit room available. We've "handled" the 3721 * request now, so clear it. If the user didn't ask for IXOFF, 3722 * then don't actually send anything, but wait for the next 3723 * opportunity. 3724 */ 3725 async->async_flowc = '\0'; 3726 if (async->async_ttycommon.t_iflag & IXOFF) { 3727 async->async_flags |= ASYNC_BUSY; 3728 OUTB(DAT, ss); 3729 rval = B_TRUE; 3730 } 3731 } 3732 3733 return (rval); 3734 } 3735 3736 /* 3737 * Check for abort character sequence 3738 */ 3739 static boolean_t 3740 abort_charseq_recognize(uchar_t ch) 3741 { 3742 static int state = 0; 3743 #define CNTRL(c) ((c)&037) 3744 static char sequence[] = { '\r', '~', CNTRL('b') }; 3745 3746 if (ch == sequence[state]) { 3747 if (++state >= sizeof (sequence)) { 3748 state = 0; 3749 return (B_TRUE); 3750 } 3751 } else { 3752 state = (ch == sequence[0]) ? 1 : 0; 3753 } 3754 return (B_FALSE); 3755 } 3756