Lines Matching defs:asy
63 #include <sys/asy.h>
169 static void async_txint(struct asycom *asy);
170 static void async_rxint(struct asycom *asy, uchar_t lsr);
171 static void async_msint(struct asycom *asy);
172 static void async_softint(struct asycom *asy);
181 static void asy_program(struct asycom *asy, int mode);
182 static void asyinit(struct asycom *asy);
183 static void asy_waiteot(struct asycom *asy);
193 static void asy_parse_mode(dev_info_t *devi, struct asycom *asy);
195 static char *asy_hw_name(struct asycom *asy);
199 static int asy_identify_chip(dev_info_t *devi, struct asycom *asy);
200 static void asy_reset_fifo(struct asycom *asy, uchar_t flags);
201 static int asy_getproperty(dev_info_t *devi, struct asycom *asy,
203 static boolean_t async_flowcontrol_sw_input(struct asycom *asy,
205 static void async_flowcontrol_sw_output(struct asycom *asy,
207 static void async_flowcontrol_hw_input(struct asycom *asy,
209 static void async_flowcontrol_hw_output(struct asycom *asy,
283 "asy",
414 async_put_suspq(struct asycom *asy, mblk_t *mp)
416 struct asyncline *async = asy->asy_priv;
418 ASSERT(mutex_owned(&asy->asy_excl));
429 async_get_suspq(struct asycom *asy)
431 struct asyncline *async = asy->asy_priv;
434 ASSERT(mutex_owned(&asy->asy_excl));
446 async_process_suspq(struct asycom *asy)
448 struct asyncline *async = asy->asy_priv;
451 ASSERT(mutex_owned(&asy->asy_excl));
453 while ((mp = async_get_suspq(asy)) != NULL) {
458 mutex_exit(&asy->asy_excl);
460 mutex_enter(&asy->asy_excl);
480 "asy: can't figure out device type for"
494 asy_get_io_regnum_pci(dev_info_t *devi, struct asycom *asy)
512 if (asy)
513 asy->asy_flags2 |= ASY2_NO_LOOPBACK;
541 asy_get_io_regnum_isa(dev_info_t *devi, struct asycom *asy)
569 if (asy)
570 asy->asy_flags2 |= ASY2_NO_LOOPBACK;
586 asy_get_io_regnum(dev_info_t *devinfo, struct asycom *asy)
590 return (asy_get_io_regnum_isa(devinfo, asy));
592 return (asy_get_io_regnum_pci(devinfo, asy));
602 struct asycom *asy;
607 asy = ddi_get_soft_state(asy_soft_state, instance);
608 if (asy == NULL)
610 async = asy->asy_priv;
614 DEBUGNOTE2(ASY_DEBUG_INIT, "asy%d: %s shutdown.",
615 instance, asy_hw_name(asy));
626 mutex_destroy(&asy->asy_excl);
627 mutex_destroy(&asy->asy_excl_hi);
629 ddi_remove_intr(devi, 0, asy->asy_iblock);
630 ddi_regs_map_free(&asy->asy_iohandle);
631 ddi_remove_softintr(asy->asy_softintr_id);
632 mutex_destroy(&asy->asy_soft_lock);
633 asy_soft_state_free(asy);
634 DEBUGNOTE1(ASY_DEBUG_INIT, "asy%d: shutdown complete",
646 mutex_enter(&asy->asy_excl);
650 cv_wait(&async->async_ops_cv, &asy->asy_excl);
656 if (cv_wait_sig(&async->async_flags_cv, &asy->asy_excl)
658 async_process_suspq(asy);
659 mutex_exit(&asy->asy_excl);
668 mutex_exit(&asy->asy_excl);
670 mutex_enter(&asy->asy_soft_sr);
671 mutex_enter(&asy->asy_excl);
676 mutex_exit(&asy->asy_excl);
678 mutex_enter(&asy->asy_excl);
680 mutex_enter(&asy->asy_excl_hi);
683 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
684 asy->asy_flags |= ASY_DDI_SUSPENDED;
690 mutex_exit(&asy->asy_excl_hi);
693 lsr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR);
694 async_rxint(asy, lsr);
698 lsr = ddi_get8(asy->asy_iohandle,
699 asy->asy_ioaddr + LSR);
706 "asy: transmitter wasn't drained before "
709 mutex_exit(&asy->asy_excl);
710 mutex_exit(&asy->asy_soft_sr);
744 struct asycom *asy;
766 asy = ddi_get_soft_state(asy_soft_state, instance);
767 if (asy == NULL)
770 mutex_enter(&asy->asy_soft_sr);
771 mutex_enter(&asy->asy_excl);
772 mutex_enter(&asy->asy_excl_hi);
774 async = asy->asy_priv;
776 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
777 if (asy_identify_chip(devi, asy) != DDI_SUCCESS) {
778 mutex_exit(&asy->asy_excl_hi);
779 mutex_exit(&asy->asy_excl);
780 mutex_exit(&asy->asy_soft_sr);
782 (void *)asy->asy_ioaddr);
785 asy->asy_flags &= ~ASY_DDI_SUSPENDED;
787 asy_program(asy, ASY_INIT);
792 mutex_exit(&asy->asy_excl_hi);
797 mutex_enter(&asy->asy_excl_hi);
799 ASYSETSOFT(asy);
801 mutex_exit(&asy->asy_excl_hi);
802 mutex_exit(&asy->asy_excl);
803 mutex_exit(&asy->asy_soft_sr);
805 mutex_enter(&asy->asy_excl);
812 async_process_suspq(asy);
813 mutex_exit(&asy->asy_excl);
823 asy = ddi_get_soft_state(asy_soft_state, instance);
824 ASSERT(asy != NULL); /* can't fail - we only just allocated it */
825 asy->asy_unit = instance;
831 regnum = asy_get_io_regnum(devi, asy);
834 ddi_regs_map_setup(devi, regnum, (caddr_t *)&asy->asy_ioaddr,
835 (offset_t)0, (offset_t)0, &ioattr, &asy->asy_iohandle)
837 cmn_err(CE_WARN, "asy%d: could not map UART registers @ %p",
838 instance, (void *)asy->asy_ioaddr);
840 asy_soft_state_free(asy);
844 DEBUGCONT2(ASY_DEBUG_INIT, "asy%dattach: UART @ %p\n",
845 instance, (void *)asy->asy_ioaddr);
876 if (asy->asy_ioaddr == (uint8_t *)(uintptr_t)com_ports[i]) {
877 asy->asy_com_port = i + 1;
889 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0x00);
892 asy->asy_mcr |= RTS|DTR; /* do use RTS/DTR after open */
893 asy->asy_lcr = STOP1|BITS8; /* default to 1 stop 8 bits */
894 asy->asy_bidx = B9600; /* default to 9600 */
896 asy->asy_msint_cnt = 0; /* # of times in async_msint */
900 if (asy->asy_com_port != 0) {
906 switch (asy_getproperty(devi, asy, "ignore-cd")) {
909 "asy%dattach: clear ASY_IGNORE_CD\n", instance);
910 asy->asy_flags &= ~ASY_IGNORE_CD; /* wait for cd */
921 "asy%dattach: set ASY_IGNORE_CD, set RTS & DTR\n",
923 mcr = asy->asy_mcr; /* rts/dtr on */
924 asy->asy_flags |= ASY_IGNORE_CD; /* ignore cd */
929 switch (asy_getproperty(devi, asy, "rts-dtr-off")) {
931 asy->asy_flags |= ASY_RTS_DTR_OFF; /* OFF */
932 mcr = asy->asy_mcr; /* rts/dtr on */
933 DEBUGCONT1(ASY_DEBUG_MODEM, "asy%dattach: "
944 asy_parse_mode(devi, asy);
947 "asy%dattach: clear ASY_IGNORE_CD, clear RTS & DTR\n",
949 asy->asy_flags &= ~ASY_IGNORE_CD; /* wait for cd */
956 asy->asy_fifo_buf = 1;
957 asy->asy_use_fifo = FIFO_OFF;
962 if ((ddi_get_iblock_cookie(devi, 0, &asy->asy_iblock) !=
965 &asy->asy_soft_iblock) != DDI_SUCCESS)) {
966 ddi_regs_map_free(&asy->asy_iohandle);
968 "asy%d: could not hook interrupt for UART @ %p\n",
969 instance, (void *)asy->asy_ioaddr);
970 asy_soft_state_free(asy);
977 mutex_init(&asy->asy_soft_lock, NULL, MUTEX_DRIVER,
978 (void *)asy->asy_soft_iblock);
979 mutex_init(&asy->asy_excl, NULL, MUTEX_DRIVER, NULL);
980 mutex_init(&asy->asy_excl_hi, NULL, MUTEX_DRIVER,
981 (void *)asy->asy_iblock);
982 mutex_init(&asy->asy_soft_sr, NULL, MUTEX_DRIVER,
983 (void *)asy->asy_soft_iblock);
984 mutex_enter(&asy->asy_excl);
985 mutex_enter(&asy->asy_excl_hi);
987 if (asy_identify_chip(devi, asy) != DDI_SUCCESS) {
988 mutex_exit(&asy->asy_excl_hi);
989 mutex_exit(&asy->asy_excl);
990 mutex_destroy(&asy->asy_soft_lock);
991 mutex_destroy(&asy->asy_excl);
992 mutex_destroy(&asy->asy_excl_hi);
993 mutex_destroy(&asy->asy_soft_sr);
994 ddi_regs_map_free(&asy->asy_iohandle);
996 (void *)asy->asy_ioaddr);
997 asy_soft_state_free(asy);
1002 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
1004 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, DLAB);
1006 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + (DAT+DLL),
1007 asyspdtab[asy->asy_bidx] & 0xff);
1008 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + (DAT+DLH),
1009 (asyspdtab[asy->asy_bidx] >> 8) & 0xff);
1010 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, asy->asy_lcr);
1011 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR, mcr);
1013 mutex_exit(&asy->asy_excl_hi);
1014 mutex_exit(&asy->asy_excl);
1019 asy->asy_dip = devi;
1025 &(asy->asy_softintr_id), NULL, 0, asysoftintr,
1026 (caddr_t)asy) != DDI_SUCCESS) {
1027 mutex_destroy(&asy->asy_soft_lock);
1028 mutex_destroy(&asy->asy_excl);
1029 mutex_destroy(&asy->asy_excl_hi);
1030 ddi_regs_map_free(&asy->asy_iohandle);
1033 asy_soft_state_free(asy);
1037 mutex_enter(&asy->asy_excl);
1038 mutex_enter(&asy->asy_excl_hi);
1044 (caddr_t)asy) != DDI_SUCCESS) {
1045 mutex_exit(&asy->asy_excl_hi);
1046 mutex_exit(&asy->asy_excl);
1047 ddi_remove_softintr(asy->asy_softintr_id);
1048 mutex_destroy(&asy->asy_soft_lock);
1049 mutex_destroy(&asy->asy_excl);
1050 mutex_destroy(&asy->asy_excl_hi);
1051 ddi_regs_map_free(&asy->asy_iohandle);
1054 asy_soft_state_free(asy);
1058 mutex_exit(&asy->asy_excl_hi);
1059 mutex_exit(&asy->asy_excl);
1061 asyinit(asy); /* initialize the asyncline structure */
1064 if (asy->asy_com_port != 0) {
1069 name[0] = asy->asy_com_port + 'a' - 1;
1073 * asy port which isn't a standard DOS COM
1079 asy->asy_com_port != 0 ? DDI_NT_SERIAL_MB : DDI_NT_SERIAL, NULL);
1084 asy->asy_com_port != 0 ? DDI_NT_SERIAL_MB_DO :
1089 struct asyncline *async = asy->asy_priv;
1092 ddi_remove_intr(devi, 0, asy->asy_iblock);
1093 ddi_remove_softintr(asy->asy_softintr_id);
1094 mutex_destroy(&asy->asy_soft_lock);
1095 mutex_destroy(&asy->asy_excl);
1096 mutex_destroy(&asy->asy_excl_hi);
1098 ddi_regs_map_free(&asy->asy_iohandle);
1099 asy_soft_state_free(asy);
1106 asy->polledio.cons_polledio_version = CONSPOLLEDIO_V0;
1107 asy->polledio.cons_polledio_argument = (cons_polledio_arg_t)asy;
1108 asy->polledio.cons_polledio_putchar = asyputchar;
1109 asy->polledio.cons_polledio_getchar = asygetchar;
1110 asy->polledio.cons_polledio_ischar = asyischar;
1111 asy->polledio.cons_polledio_enter = NULL;
1112 asy->polledio.cons_polledio_exit = NULL;
1115 DEBUGCONT1(ASY_DEBUG_INIT, "asy%dattach: done\n", instance);
1126 struct asycom *asy;
1132 asy = ddi_get_soft_state(asy_soft_state, instance);
1133 if ((asy == NULL) || (asy->asy_dip == NULL))
1136 *result = (void *) asy->asy_dip;
1153 asy_getproperty(dev_info_t *devi, struct asycom *asy, const char *property)
1157 char letter = asy->asy_com_port + 'a' - 1; /* for ttya */
1158 char number = asy->asy_com_port + '0'; /* for COM1 */
1191 asy_soft_state_free(struct asycom *asy)
1195 if (asy->asy_unit == max_asy_instance) {
1204 if (asy->asy_priv != NULL) {
1205 kmem_free(asy->asy_priv, sizeof (struct asyncline));
1206 asy->asy_priv = NULL;
1208 ddi_soft_state_free(asy_soft_state, asy->asy_unit);
1212 asy_hw_name(struct asycom *asy)
1214 switch (asy->asy_hwtype) {
1227 "asy%d: asy_hw_name: unknown asy_hwtype: %d",
1228 asy->asy_unit, asy->asy_hwtype);
1234 asy_identify_chip(dev_info_t *devi, struct asycom *asy)
1245 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + SCR, SCRTEST);
1247 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + FIFOR, 0x00);
1249 ret = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + SCR);
1257 cmn_err(CE_CONT, "!asy%d: UART @ %p "
1259 asy->asy_unit, (void *)asy->asy_ioaddr, ret);
1267 ddi_put8(asy->asy_iohandle,
1268 asy->asy_ioaddr + FIFOR, 0x00); /* clear */
1269 ddi_put8(asy->asy_iohandle,
1270 asy->asy_ioaddr + FIFOR, FIFO_ON); /* enable */
1271 ddi_put8(asy->asy_iohandle,
1272 asy->asy_ioaddr + FIFOR, FIFO_ON | FIFORXFLSH);
1278 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1280 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + EFR,
1282 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1291 asy->asy_fifor = 0;
1292 asy->asy_hwtype = asymaxchip; /* just for asy_reset_fifo() */
1294 asy->asy_fifor |=
1297 asy->asy_fifor |= FIFOEXTRA1 | FIFOEXTRA2;
1299 asy_reset_fifo(asy, FIFOTXFLSH | FIFORXFLSH);
1301 mcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MCR);
1302 ret = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + ISR);
1304 "asy%d: probe fifo FIFOR=0x%02x ISR=0x%02x MCR=0x%02x\n",
1305 asy->asy_unit, asy->asy_fifor | FIFOTXFLSH | FIFORXFLSH,
1310 asy->asy_fifor = 0;
1314 asy->asy_fifo_buf = 16;
1315 asy->asy_use_fifo = FIFO_ON;
1316 asy->asy_fifor &= ~(FIFOEXTRA1 | FIFOEXTRA2);
1320 asy->asy_fifo_buf = 32;
1321 asy->asy_use_fifo = FIFO_ON;
1322 asy->asy_fifor &= ~(FIFOEXTRA1);
1330 cmn_err(CE_CONT, "asy%d: UART @ %p "
1332 asy->asy_unit, (void *)asy->asy_ioaddr);
1338 asy->asy_fifo_buf = 64;
1339 asy->asy_use_fifo = FIFO_ON;
1343 asy->asy_fifor = 0;
1347 cmn_err(CE_CONT, "asy%d: UART @ %p "
1350 asy->asy_unit, (void *)asy->asy_ioaddr,
1351 asy->asy_fifor | FIFOTXFLSH | FIFORXFLSH, ret, mcr);
1358 * downgrade of the asy->asy_hwtype, or it may not disable
1361 asy_reset_fifo(asy, 0);
1362 asy->asy_hwtype = hwtype;
1368 if (asy->asy_hwtype == ASY16550A && asymaxchip >= ASY16650 &&
1371 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1374 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + SCR, 0);
1376 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1379 ret = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + SCR);
1382 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1384 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + EFR,
1386 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1388 asy->asy_hwtype = ASY16650;
1389 asy->asy_fifo_buf = 32;
1390 asy->asy_fifor |= 0x10; /* 24 byte txfifo trigger */
1391 asy_reset_fifo(asy, 0);
1400 !(asy->asy_flags2 & ASY2_NO_LOOPBACK) &&
1401 (asy->asy_fifo_buf > 16 ||
1402 (asy_fifo_test > 1 && asy->asy_use_fifo == FIFO_ON) ||
1407 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1409 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT,
1411 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR,
1414 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1417 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
1421 for (i = 0; i < asy->asy_fifo_buf * 2; i++) {
1422 ddi_put8(asy->asy_iohandle,
1423 asy->asy_ioaddr + DAT, i);
1442 * In theory, 200 * asy->asy_fifo_buf * 2 should be
1448 delay(drv_usectohz(400 * asy->asy_fifo_buf * 3));
1451 for (i = 0; i < asy->asy_fifo_buf * 3; i++) {
1452 ret = ddi_get8(asy->asy_iohandle,
1453 asy->asy_ioaddr + LSR);
1456 (void) ddi_get8(asy->asy_iohandle,
1457 asy->asy_ioaddr + DAT); /* lose another */
1461 "asy%d FIFO size: expected=%d, measured=%d\n",
1462 asy->asy_unit, asy->asy_fifo_buf, i);
1464 hwtype = asy->asy_hwtype;
1465 if (i < asy->asy_fifo_buf) {
1474 if (i >= 16 && asy->asy_fifo_buf >= 16) {
1477 asy->asy_fifo_buf = 16;
1478 asy->asy_fifor &= ~(FIFOEXTRA1 | FIFOEXTRA2);
1482 asy->asy_fifo_buf = 1;
1483 asy->asy_use_fifo = FIFO_OFF;
1484 asy->asy_fifor &=
1494 * before any possible downgrade of asy->asy_hwtype.
1496 if (asy->asy_hwtype >= ASY16650 && hwtype < ASY16650) {
1498 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1500 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + EFR,
1502 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1505 asy_reset_fifo(asy, FIFOTXFLSH | FIFORXFLSH);
1506 asy->asy_hwtype = hwtype;
1509 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR, mcr);
1512 DEBUGNOTE3(ASY_DEBUG_CHIP, "asy%d %s @ %p",
1513 asy->asy_unit, asy_hw_name(asy), (void *)asy->asy_ioaddr);
1516 dev = makedevice(DDI_MAJOR_T_UNKNOWN, asy->asy_unit);
1517 (void) ddi_prop_update_string(dev, devi, "uart", asy_hw_name(asy));
1519 if (asy->asy_hwtype == ASY16550) /* for broken 16550's, */
1520 asy->asy_hwtype = ASY8250A; /* drive them as 8250A */
1530 asyinit(struct asycom *asy)
1534 asy->asy_priv = kmem_zalloc(sizeof (struct asyncline), KM_SLEEP);
1535 async = asy->asy_priv;
1536 mutex_enter(&asy->asy_excl);
1537 async->async_common = asy;
1539 mutex_exit(&asy->asy_excl);
1546 struct asycom *asy;
1554 DEBUGCONT1(ASY_DEBUG_CLOSE, "asy%dopen\n", unit);
1555 asy = ddi_get_soft_state(asy_soft_state, unit);
1556 if (asy == NULL)
1558 async = asy->asy_priv;
1559 mutex_enter(&asy->asy_excl);
1562 mutex_enter(&asy->asy_excl_hi);
1572 mutex_exit(&asy->asy_excl_hi);
1582 "asy: couldn't get ttymodes property!");
1583 mutex_enter(&asy->asy_excl_hi);
1586 if (asy->asy_cflag)
1587 async->async_ttycommon.t_cflag = asy->asy_cflag;
1600 asy_program(asy, ASY_INIT);
1604 mutex_exit(&asy->asy_excl_hi);
1605 mutex_exit(&asy->asy_excl);
1608 mutex_exit(&asy->asy_excl_hi);
1609 mutex_exit(&asy->asy_excl);
1619 "asy%dopen: waiting for the ASYNC_DTR_DELAY to be clear\n",
1621 mutex_exit(&asy->asy_excl_hi);
1623 &asy->asy_excl) == 0) {
1625 "asy%dopen: interrupted by signal, exiting\n",
1627 mutex_exit(&asy->asy_excl);
1630 mutex_enter(&asy->asy_excl_hi);
1633 mcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MCR);
1634 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
1635 mcr|(asy->asy_mcr&DTR));
1638 "asy%dopen: \"Raise DTR on every open\": make mcr = %x, "
1640 unit, mcr|(asy->asy_mcr&DTR),
1641 (asy->asy_flags & ASY_IGNORE_CD) ? "ON" : "OFF");
1643 if (asy->asy_flags & ASY_IGNORE_CD) {
1645 "asy%dopen: ASY_IGNORE_CD set, set TS_SOFTCAR\n",
1655 asy->asy_msr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MSR);
1656 DEBUGCONT3(ASY_DEBUG_INIT, "asy%dopen: TS_SOFTCAR is %s, "
1660 (asy->asy_msr & DCD) ? "set" : "clear");
1662 if (asy->asy_msr & DCD)
1666 mutex_exit(&asy->asy_excl_hi);
1680 &asy->asy_excl) == B_FALSE) {
1682 mutex_exit(&asy->asy_excl);
1689 mutex_exit(&asy->asy_excl);
1696 mutex_exit(&asy->asy_excl);
1705 DEBUGCONT1(ASY_DEBUG_INIT, "asy%dopen: done\n", unit);
1713 struct asycom *asy = async->async_common;
1721 mutex_enter(&asy->asy_excl);
1722 mutex_enter(&asy->asy_excl_hi);
1729 mutex_exit(&asy->asy_excl_hi);
1744 mutex_exit(&asy->asy_excl_hi);
1746 mutex_exit(&asy->asy_excl);
1755 struct asycom *asy = async->async_common;
1759 mutex_enter(&asy->asy_excl);
1763 mutex_exit(&asy->asy_excl);
1774 struct asycom *asy;
1784 DEBUGCONT1(ASY_DEBUG_CLOSE, "asy%dclose\n", instance);
1786 asy = async->async_common;
1788 mutex_enter(&asy->asy_excl);
1795 mutex_enter(&asy->asy_excl_hi);
1796 asy->asy_flags &= ~(ASY_PPS | ASY_PPS_EDGE);
1797 mutex_exit(&asy->asy_excl_hi);
1813 mutex_enter(&asy->asy_excl_hi);
1814 lcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
1815 ddi_put8(asy->asy_iohandle,
1816 asy->asy_ioaddr + LCR, (lcr & ~SETBREAK));
1817 mutex_exit(&asy->asy_excl_hi);
1863 if (cv_wait_sig(&async->async_flags_cv, &asy->asy_excl) == 0)
1881 DEBUGCONT1(ASY_DEBUG_MODEM, "asy%dclose: next check HUPCL flag\n",
1883 mutex_enter(&asy->asy_excl_hi);
1887 "asy%dclose: HUPCL flag = %x, ASYNC_WOPEN flag = %x\n",
1894 if (asy->asy_flags & (ASY_IGNORE_CD|ASY_RTS_DTR_OFF)) {
1896 "asy%dclose: ASY_IGNORE_CD flag = %x, "
1899 asy->asy_flags & ASY_IGNORE_CD,
1900 asy->asy_flags & ASY_RTS_DTR_OFF);
1902 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
1903 asy->asy_mcr|OUT2);
1906 "asy%dclose: Dropping DTR and RTS\n", instance);
1907 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
1918 icr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + ICR);
1919 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR,
1922 mutex_exit(&asy->asy_excl_hi);
1945 mutex_exit(&asy->asy_excl);
1947 DEBUGCONT1(ASY_DEBUG_CLOSE, "asy%dclose: done\n", instance);
1952 asy_isbusy(struct asycom *asy)
1957 async = asy->asy_priv;
1958 ASSERT(mutex_owned(&asy->asy_excl));
1959 ASSERT(mutex_owned(&asy->asy_excl_hi));
1964 ((ddi_get8(asy->asy_iohandle,
1965 asy->asy_ioaddr + LSR) & (XSRE|XHRE)) == 0));
1969 asy_waiteot(struct asycom *asy)
1977 ASSERT(mutex_owned(&asy->asy_excl));
1978 ASSERT(mutex_owned(&asy->asy_excl_hi));
1979 while (asy_isbusy(asy)) {
1980 mutex_exit(&asy->asy_excl_hi);
1981 mutex_exit(&asy->asy_excl);
1983 mutex_enter(&asy->asy_excl);
1984 mutex_enter(&asy->asy_excl_hi);
1990 asy_reset_fifo(struct asycom *asy, uchar_t flush)
1996 if (asy->asy_hwtype >= ASY16750) {
1997 lcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
1998 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
2002 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + FIFOR,
2003 asy->asy_fifor | flush);
2007 if (asy->asy_hwtype >= ASY16750) {
2008 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, lcr);
2021 asy_program(struct asycom *asy, int mode)
2032 ASSERT(mutex_owned(&asy->asy_excl));
2033 ASSERT(mutex_owned(&asy->asy_excl_hi));
2035 async = asy->asy_priv;
2039 "asy%d_program: mode = 0x%08X, enter\n", instance, mode);
2060 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
2062 ocflags = asy->asy_ocflag;
2065 (void) ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + ISR);
2066 (void) ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR);
2067 asy->asy_msr = flush_reg = ddi_get8(asy->asy_iohandle,
2068 asy->asy_ioaddr + MSR);
2076 async_flowcontrol_hw_output(asy, FLOW_STOP);
2079 * We can not use async_flowcontrol_hw_output(asy, FLOW_START)
2102 if (asy->asy_use_fifo == FIFO_ON) {
2103 for (flush_reg = asy->asy_fifo_buf; flush_reg-- > 0; ) {
2104 (void) ddi_get8(asy->asy_iohandle,
2105 asy->asy_ioaddr + DAT);
2108 flush_reg = ddi_get8(asy->asy_iohandle,
2109 asy->asy_ioaddr + DAT);
2114 lcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
2142 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, DLAB);
2145 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT,
2147 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR,
2151 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, lcr);
2160 if (asy->asy_use_fifo == FIFO_ON)
2161 asy_reset_fifo(asy, FIFORXFLSH);
2164 asy->asy_ocflag = c_flag & ~CLOCAL;
2168 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
2169 (asy->asy_mcr & RTS) | OUT2);
2171 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
2172 asy->asy_mcr | OUT2);
2179 async_msint(asy);
2183 "asy%d_program: c_flag & CLOCAL = %x t_cflag & CRTSCTS = %x\n",
2199 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, icr);
2200 DEBUGCONT1(ASY_DEBUG_PROCS, "asy%d_program: done\n", instance);
2204 asy_baudok(struct asycom *asy)
2206 struct asyncline *async = asy->asy_priv;
2232 struct asycom *asy = (struct asycom *)argasy;
2237 interrupt_id = ddi_get8(asy->asy_iohandle,
2238 asy->asy_ioaddr + ISR) & 0x0F;
2239 async = asy->asy_priv;
2252 (void) ddi_get8(asy->asy_iohandle,
2253 asy->asy_ioaddr + LSR);
2254 (void) ddi_get8(asy->asy_iohandle,
2255 asy->asy_ioaddr + DAT);
2256 asy->asy_msr = ddi_get8(asy->asy_iohandle,
2257 asy->asy_ioaddr + MSR);
2262 mutex_enter(&asy->asy_excl_hi);
2264 if (asy->asy_flags & ASY_DDI_SUSPENDED) {
2265 mutex_exit(&asy->asy_excl_hi);
2270 * We will loop until the interrupt line is pulled low. asy
2275 (ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + ISR) & 0x0F)) {
2283 lsr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR);
2289 async_rxint(asy, lsr);
2293 async_txint(asy);
2297 async_msint(asy);
2302 async_txint(asy);
2304 mutex_exit(&asy->asy_excl_hi);
2317 async_txint(struct asycom *asy)
2319 struct asyncline *async = asy->asy_priv;
2331 fifo_len = asy->asy_fifo_buf; /* with FIFO buffers */
2335 if (async_flowcontrol_sw_input(asy, FLOW_CHECK, IN_FLOW_NULL))
2342 ddi_put8(asy->asy_iohandle,
2343 asy->asy_ioaddr + DAT, *async->async_optr++);
2351 ASYSETSOFT(asy);
2359 asy_ppsevent(struct asycom *asy, int msr)
2361 if (asy->asy_flags & ASY_PPS_EDGE) {
2364 asy->asy_flags &= ~ASY_PPS_EDGE;
2385 asy->asy_flags |= ASY_PPS_EDGE;
2426 async_rxint(struct asycom *asy, uchar_t lsr)
2428 struct asyncline *async = asy->asy_priv;
2432 int looplim = asy->asy_fifo_buf * 2;
2437 (void) (ddi_get8(asy->asy_iohandle,
2438 asy->asy_ioaddr + DAT) & 0xff);
2439 lsr = ddi_get8(asy->asy_iohandle,
2440 asy->asy_ioaddr + LSR);
2451 c = ddi_get8(asy->asy_iohandle,
2452 asy->asy_ioaddr + DAT) & 0xff;
2462 async_flowcontrol_sw_output(asy,
2467 async_flowcontrol_sw_output(asy,
2474 async_flowcontrol_sw_output(asy,
2485 (asy->asy_flags & ASY_CONSOLE)) {
2522 if ((asy->asy_flags & ASY_CONSOLE) &&
2539 lsr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR);
2545 async_flowcontrol_hw_input(asy, FLOW_STOP, IN_FLOW_RINGBUFF);
2546 (void) async_flowcontrol_sw_input(asy, FLOW_STOP,
2552 ASYSETSOFT(asy); /* need a soft interrupt */
2562 async_msint(struct asycom *asy)
2564 struct asyncline *async = asy->asy_priv;
2572 msr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MSR);
2578 ++(asy->asy_msint_cnt),
2589 if ((t_cflag & CRTSCTS) && (((asy->asy_msr ^ msr) & CTS) != 0))
2590 async_flowcontrol_hw_output(asy,
2597 asy->asy_msr = (uchar_t)msr;
2600 if (asy->asy_flags & ASY_PPS)
2601 asy_ppsevent(asy, msr);
2604 ASYSETSOFT(asy);
2613 msr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MSR);
2614 if (STATES(msr) != STATES(asy->asy_msr))
2625 struct asycom *asy = (struct asycom *)intarg;
2633 mutex_enter(&asy->asy_soft_lock);
2635 rv = asy->asysoftpend;
2637 asy->asysoftpend = 0;
2638 mutex_exit(&asy->asy_soft_lock);
2641 if (asy->asy_priv == NULL)
2643 async = (struct asyncline *)asy->asy_priv;
2644 mutex_enter(&asy->asy_excl_hi);
2645 if (asy->asy_flags & ASY_NEEDSOFT) {
2646 asy->asy_flags &= ~ASY_NEEDSOFT;
2647 mutex_exit(&asy->asy_excl_hi);
2648 async_softint(asy);
2649 mutex_enter(&asy->asy_excl_hi);
2660 mutex_exit(&asy->asy_excl_hi);
2662 (void) async_softint(asy);
2671 async_softint(struct asycom *asy)
2673 struct asyncline *async = asy->asy_priv;
2684 mutex_enter(&asy->asy_excl_hi);
2685 if (asy->asy_flags & ASY_DOINGSOFT) {
2686 asy->asy_flags |= ASY_DOINGSOFT_RETRY;
2687 mutex_exit(&asy->asy_excl_hi);
2690 asy->asy_flags |= ASY_DOINGSOFT;
2692 asy->asy_flags &= ~ASY_DOINGSOFT_RETRY;
2693 mutex_exit(&asy->asy_excl_hi);
2694 mutex_enter(&asy->asy_excl);
2699 mutex_enter(&asy->asy_excl_hi);
2701 mutex_exit(&asy->asy_excl_hi);
2710 mutex_enter(&asy->asy_excl_hi);
2717 instance, asy->asy_msr & DCD, tp->t_flags & TS_SOFTCAR);
2719 if (asy->asy_msr & DCD) {
2727 mutex_exit(&asy->asy_excl_hi);
2728 mutex_exit(&asy->asy_excl);
2730 mutex_enter(&asy->asy_excl);
2731 mutex_enter(&asy->asy_excl_hi);
2752 val = ddi_get8(asy->asy_iohandle,
2753 asy->asy_ioaddr + MCR);
2754 ddi_put8(asy->asy_iohandle,
2755 asy->asy_ioaddr + MCR, (val & ~DTR));
2767 mutex_exit(&asy->asy_excl_hi);
2768 mutex_exit(&asy->asy_excl);
2770 mutex_enter(&asy->asy_excl);
2779 if (asy->asy_use_fifo == FIFO_ON)
2780 asy_reset_fifo(asy, FIFOTXFLSH);
2799 mutex_enter(&asy->asy_excl_hi);
2816 mutex_exit(&asy->asy_excl_hi);
2825 mutex_enter(&asy->asy_excl_hi);
2832 mutex_exit(&asy->asy_excl_hi);
2835 mutex_enter(&asy->asy_excl_hi);
2837 async_flowcontrol_hw_input(asy, FLOW_STOP,
2839 (void) async_flowcontrol_sw_input(asy, FLOW_STOP,
2845 mutex_enter(&asy->asy_excl_hi);
2846 async_flowcontrol_hw_input(asy, FLOW_START,
2848 (void) async_flowcontrol_sw_input(asy, FLOW_START,
2850 mutex_exit(&asy->asy_excl_hi);
2857 mutex_exit(&asy->asy_excl);
2859 mutex_enter(&asy->asy_excl);
2860 mutex_enter(&asy->asy_excl_hi);
2863 mutex_enter(&asy->asy_excl_hi);
2872 mutex_exit(&asy->asy_excl_hi);
2873 mutex_exit(&asy->asy_excl);
2876 asyerror(CE_NOTE, "asy%d: local queue full",
2893 mutex_enter(&asy->asy_excl);
2894 mutex_enter(&asy->asy_excl_hi);
2898 async_flowcontrol_hw_input(asy, FLOW_START, IN_FLOW_RINGBUFF);
2899 (void) async_flowcontrol_sw_input(asy, FLOW_START,
2911 mutex_exit(&asy->asy_excl_hi);
2912 mutex_exit(&asy->asy_excl);
2915 mutex_enter(&asy->asy_excl);
2916 mutex_enter(&asy->asy_excl_hi);
2925 mutex_exit(&asy->asy_excl_hi);
2937 mutex_enter(&asy->asy_excl_hi);
2948 mutex_exit(&asy->asy_excl_hi);
2949 mutex_exit(&asy->asy_excl);
2950 asyerror(CE_NOTE, "asy%d: silo overflow", instance);
2951 mutex_enter(&asy->asy_excl);
2952 mutex_enter(&asy->asy_excl_hi);
2958 mutex_exit(&asy->asy_excl_hi);
2959 mutex_exit(&asy->asy_excl);
2960 asyerror(CE_NOTE, "asy%d: ring buffer overflow",
2962 mutex_enter(&asy->asy_excl);
2963 mutex_enter(&asy->asy_excl_hi);
2967 if (asy->asy_flags & ASY_DOINGSOFT_RETRY) {
2968 mutex_exit(&asy->asy_excl);
2971 asy->asy_flags &= ~ASY_DOINGSOFT;
2972 mutex_exit(&asy->asy_excl_hi);
2973 mutex_exit(&asy->asy_excl);
2984 struct asycom *asy = async->async_common;
2995 mutex_enter(&asy->asy_excl);
3002 mutex_enter(&asy->asy_excl_hi);
3003 lcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
3004 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
3006 mutex_exit(&asy->asy_excl_hi);
3012 mutex_exit(&asy->asy_excl);
3028 struct asycom *asy = async->async_common;
3043 if (asy->asy_use_fifo == FIFO_ON) {
3044 fifo_len = asy->asy_fifo_buf; /* with FIFO buffers */
3049 ASSERT(mutex_owned(&asy->asy_excl));
3067 mutex_enter(&asy->asy_excl_hi);
3068 if (async_flowcontrol_sw_input(asy, FLOW_CHECK, IN_FLOW_NULL))
3070 mutex_exit(&asy->asy_excl_hi);
3107 mutex_enter(&asy->asy_excl_hi);
3108 val = ddi_get8(asy->asy_iohandle,
3109 asy->asy_ioaddr + LCR);
3110 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
3112 mutex_exit(&asy->asy_excl_hi);
3137 mutex_exit(&asy->asy_excl);
3139 mutex_enter(&asy->asy_excl);
3184 mutex_enter(&asy->asy_excl_hi);
3191 if (!(ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR) &
3194 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT,
3207 mutex_exit(&asy->asy_excl_hi);
3216 struct asycom *asy = async->async_common;
3221 ASSERT(mutex_owned(&asy->asy_excl_hi));
3227 if (ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR) & XHRE) {
3228 if (async_flowcontrol_sw_input(asy, FLOW_CHECK, IN_FLOW_NULL))
3233 ddi_put8(asy->asy_iohandle,
3234 asy->asy_ioaddr + DAT, *async->async_optr++);
3248 struct asycom *asy = async->async_common;
3250 mutex_enter(&asy->asy_excl);
3254 mutex_exit(&asy->asy_excl);
3264 struct asycom *asy = async->async_common;
3265 ASSERT(mutex_owned(&asy->asy_excl));
3272 cv_wait(&async->async_flags_cv, &asy->asy_excl);
3274 mutex_enter(&asy->asy_excl_hi);
3281 val = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
3282 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
3289 mutex_exit(&asy->asy_excl_hi);
3292 mutex_exit(&asy->asy_excl_hi);
3311 struct asycom *asy = async->async_common;
3390 mutex_enter(&asy->asy_excl);
3400 mutex_enter(&asy->asy_excl_hi);
3401 if (asy_baudok(asy))
3402 asy_program(asy, ASY_NOINIT);
3405 mutex_exit(&asy->asy_excl_hi);
3412 mutex_enter(&asy->asy_excl_hi);
3413 if (!asy_baudok(asy))
3416 if (asy_isbusy(asy))
3417 asy_waiteot(asy);
3418 asy_program(asy, ASY_NOINIT);
3420 mutex_exit(&asy->asy_excl_hi);
3442 if (asy->asy_flags & ASY_PPS)
3459 mutex_enter(&asy->asy_excl_hi);
3461 asy->asy_flags |= ASY_PPS;
3463 asy->asy_flags &= ~ASY_PPS;
3465 asy->asy_flags &= ~ASY_PPS_EDGE;
3466 mutex_exit(&asy->asy_excl_hi);
3487 if ((asy->asy_flags & ASY_PPS) == 0) {
3493 mutex_enter(&asy->asy_excl_hi);
3495 mutex_exit(&asy->asy_excl_hi);
3542 &asy->asy_excl);
3544 mutex_enter(&asy->asy_excl_hi);
3560 while ((ddi_get8(asy->asy_iohandle,
3561 asy->asy_ioaddr + LSR) & XSRE) == 0) {
3562 mutex_exit(&asy->asy_excl_hi);
3563 mutex_exit(&asy->asy_excl);
3566 mutex_enter(&asy->asy_excl);
3567 mutex_enter(&asy->asy_excl_hi);
3575 val = ddi_get8(asy->asy_iohandle,
3576 asy->asy_ioaddr + LCR);
3577 ddi_put8(asy->asy_iohandle,
3578 asy->asy_ioaddr + LCR,
3580 mutex_exit(&asy->asy_excl_hi);
3587 mutex_enter(&asy->asy_excl_hi);
3588 asy_waiteot(asy);
3589 mutex_exit(&asy->asy_excl_hi);
3598 mutex_enter(&asy->asy_excl_hi);
3603 while ((ddi_get8(asy->asy_iohandle,
3604 asy->asy_ioaddr + LSR) & XSRE) == 0) {
3605 mutex_exit(&asy->asy_excl_hi);
3606 mutex_exit(&asy->asy_excl);
3609 mutex_enter(&asy->asy_excl);
3610 mutex_enter(&asy->asy_excl_hi);
3612 val = ddi_get8(asy->asy_iohandle,
3613 asy->asy_ioaddr + LCR);
3614 ddi_put8(asy->asy_iohandle,
3615 asy->asy_ioaddr + LCR, (val | SETBREAK));
3616 mutex_exit(&asy->asy_excl_hi);
3643 mutex_enter(&asy->asy_excl_hi);
3644 (void) asymctl(asy,
3647 mutex_exit(&asy->asy_excl_hi);
3664 mutex_enter(&asy->asy_excl_hi);
3665 *(int *)datamp->b_rptr = asymctl(asy, 0, TIOCMGET);
3666 mutex_exit(&asy->asy_excl_hi);
3685 &asy->polledio;
3707 asy->asy_flags |= ASY_CONSOLE;
3709 asy->asy_flags &= ~ASY_CONSOLE;
3725 (asy->asy_flags & ASY_CONSOLE) != 0;
3740 mutex_exit(&asy->asy_excl);
3784 struct asycom *asy;
3795 asy = async->async_common;
3804 mutex_enter(&asy->asy_excl);
3806 mutex_exit(&asy->asy_excl);
3811 mutex_enter(&asy->asy_excl);
3821 mutex_enter(&asy->asy_excl_hi);
3823 mutex_exit(&asy->asy_excl_hi);
3829 mutex_exit(&asy->asy_excl);
3849 mutex_enter(&asy->asy_excl);
3860 mutex_exit(&asy->asy_excl);
3878 mutex_enter(&asy->asy_excl);
3889 mutex_exit(&asy->asy_excl);
3896 mutex_enter(&asy->asy_excl);
3898 mutex_exit(&asy->asy_excl);
3902 async_put_suspq(asy, mp);
3903 mutex_exit(&asy->asy_excl);
3910 mutex_enter(&asy->asy_excl);
3915 mutex_enter(&asy->asy_excl_hi);
3917 DEBUGCONT1(ASY_DEBUG_BUSY, "asy%dwput: "
3927 if (asy->asy_use_fifo == FIFO_ON) {
3928 asy_reset_fifo(asy, FIFOTXFLSH);
3931 mutex_exit(&asy->asy_excl_hi);
3934 if (asy->asy_use_fifo == FIFO_ON) {
3935 asy_reset_fifo(asy, FIFOTXFLSH);
3946 mutex_exit(&asy->asy_excl);
3952 if (asy->asy_use_fifo == FIFO_ON) {
3953 asy_reset_fifo(asy, FIFORXFLSH);
3967 mutex_enter(&asy->asy_excl);
3969 mutex_exit(&asy->asy_excl);
3982 mutex_enter(&asy->asy_excl);
3984 mutex_exit(&asy->asy_excl);
3989 mutex_enter(&asy->asy_excl);
3991 mutex_enter(&asy->asy_excl_hi);
3993 async_flowcontrol_hw_input(asy, FLOW_STOP,
3995 (void) async_flowcontrol_sw_input(asy,
3998 mutex_exit(&asy->asy_excl_hi);
3999 mutex_exit(&asy->asy_excl);
4003 async_put_suspq(asy, mp);
4004 mutex_exit(&asy->asy_excl);
4008 mutex_enter(&asy->asy_excl);
4010 mutex_enter(&asy->asy_excl_hi);
4012 async_flowcontrol_hw_input(asy, FLOW_START,
4014 (void) async_flowcontrol_sw_input(asy,
4017 mutex_exit(&asy->asy_excl_hi);
4018 mutex_exit(&asy->asy_excl);
4022 async_put_suspq(asy, mp);
4023 mutex_exit(&asy->asy_excl);
4029 mutex_enter(&asy->asy_excl);
4033 mutex_exit(&asy->asy_excl);
4037 async_put_suspq(asy, mp);
4048 mutex_enter(&asy->asy_excl);
4059 mutex_exit(&asy->asy_excl);
4065 mutex_enter(&asy->asy_excl);
4067 mutex_exit(&asy->asy_excl);
4071 async_put_suspq(asy, mp);
4072 mutex_exit(&asy->asy_excl);
4097 struct asycom *asy;
4101 asy = ddi_get_soft_state(asy_soft_state, instance);
4102 ASSERT(asy != NULL);
4103 async = asy->asy_priv;
4108 mutex_enter(&asy->asy_excl);
4111 mutex_exit(&asy->asy_excl);
4117 mutex_exit(&asy->asy_excl);
4120 mutex_exit(&asy->asy_excl);
4127 struct asycom *asy;
4134 asy = async->async_common;
4145 mutex_enter(&asy->asy_excl);
4169 mutex_enter(&asy->asy_excl_hi);
4170 (void) asymctl(asy, dmtoasy(*(int *)mp->b_cont->b_rptr),
4172 mutex_exit(&asy->asy_excl_hi);
4182 mutex_exit(&asy->asy_excl);
4196 struct asycom *asy = (struct asycom *)arg;
4201 while ((ddi_get8(asy->asy_iohandle,
4202 asy->asy_ioaddr + LSR) & XHRE) == 0) {
4208 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT, c);
4218 struct asycom *asy = (struct asycom *)arg;
4220 return ((ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR) & RCA)
4230 struct asycom *asy = (struct asycom *)arg;
4234 return (ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + DAT));
4241 asymctl(struct asycom *asy, int bits, int how)
4244 int instance = asy->asy_unit;
4246 ASSERT(mutex_owned(&asy->asy_excl_hi));
4247 ASSERT(mutex_owned(&asy->asy_excl));
4250 mcr_r = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MCR);
4256 "asy%dmctl: TIOCMSET, bits = %x\n", instance, bits);
4261 DEBUGCONT2(ASY_DEBUG_MODEM, "asy%dmctl: TIOCMBIS, bits = %x\n",
4267 DEBUGCONT2(ASY_DEBUG_MODEM, "asy%dmctl: TIOCMBIC, bits = %x\n",
4278 if (ddi_get8(asy->asy_iohandle,
4279 asy->asy_ioaddr + ICR) & MIEN) {
4280 msr_r = asy->asy_msr;
4282 "asy%dmctl: TIOCMGET, read msr_r = %x\n",
4285 msr_r = ddi_get8(asy->asy_iohandle,
4286 asy->asy_ioaddr + MSR);
4288 "asy%dmctl: TIOCMGET, read MSR = %x\n",
4291 DEBUGCONT2(ASY_DEBUG_MODEM, "asy%dtodm: modem_lines = %x\n",
4296 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR, mcr_r);
4387 * asy_parse_mode(dev_info_t *devi, struct asycom *asy)
4398 asy_parse_mode(dev_info_t *devi, struct asycom *asy)
4407 ASSERT(asy->asy_com_port != 0);
4412 (void) sprintf(name, "tty%c-mode", asy->asy_com_port + 'a' - 1);
4416 (void) sprintf(name, "com%c-mode", asy->asy_com_port + '0');
4422 asy->asy_cflag = 0;
4428 asy->asy_cflag = CREAD|B9600; /* initial default */
4432 asy->asy_cflag |= BITS8; /* add default bits */
4437 asy->asy_bidx = B110;
4439 asy->asy_bidx = B150;
4441 asy->asy_bidx = B300;
4443 asy->asy_bidx = B600;
4445 asy->asy_bidx = B1200;
4447 asy->asy_bidx = B2400;
4449 asy->asy_bidx = B4800;
4451 asy->asy_bidx = B9600;
4453 asy->asy_bidx = B19200;
4455 asy->asy_bidx = B38400;
4457 asy->asy_bidx = B57600;
4459 asy->asy_bidx = B115200;
4461 asy->asy_bidx = B9600;
4463 asy->asy_cflag &= ~CBAUD;
4464 if (asy->asy_bidx > CBAUD) { /* > 38400 uses the CBAUDEXT bit */
4465 asy->asy_cflag |= CBAUDEXT;
4466 asy->asy_cflag |= asy->asy_bidx - CBAUD - 1;
4468 asy->asy_cflag |= asy->asy_bidx;
4471 ASSERT(asy->asy_bidx == BAUDINDEX(asy->asy_cflag));
4478 asy->asy_cflag |= BITS8; /* add default bits */
4484 asy->asy_cflag |= CS8;
4485 asy->asy_lcr = BITS8;
4488 asy->asy_cflag |= CS7;
4489 asy->asy_lcr = BITS7;
4492 asy->asy_cflag |= CS6;
4493 asy->asy_lcr = BITS6;
4497 asy->asy_cflag |= CS5;
4498 asy->asy_lcr = BITS5;
4514 asy->asy_cflag |= PARENB;
4515 asy->asy_lcr |= PEN; break;
4517 asy->asy_cflag |= PARENB|PARODD;
4518 asy->asy_lcr |= PEN|EPS;
4530 asy->asy_cflag |= CSTOPB;
4531 asy->asy_lcr |= STB;
4541 asy->asy_cflag |= CRTSCTS;
4543 asy->asy_cflag |= CRTSXOFF;
4591 async_flowcontrol_sw_input(struct asycom *asy, async_flowc_action onoff,
4594 struct asyncline *async = asy->asy_priv;
4598 ASSERT(mutex_owned(&asy->asy_excl_hi));
4639 (ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR) & XHRE)) {
4646 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT,
4666 async_flowcontrol_sw_output(struct asycom *asy, async_flowc_action onoff)
4668 struct asyncline *async = asy->asy_priv;
4671 ASSERT(mutex_owned(&asy->asy_excl_hi));
4710 async_flowcontrol_hw_input(struct asycom *asy, async_flowc_action onoff,
4715 struct asyncline *async = asy->asy_priv;
4718 ASSERT(mutex_owned(&asy->asy_excl_hi));
4743 mcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MCR);
4747 ddi_put8(asy->asy_iohandle,
4748 asy->asy_ioaddr + MCR, (mcr ^ RTS));
4766 async_flowcontrol_hw_output(struct asycom *asy, async_flowc_action onoff)
4768 struct asyncline *async = asy->asy_priv;
4771 ASSERT(mutex_owned(&asy->asy_excl_hi));
4810 struct asycom *asy;
4814 asy = ddi_get_soft_state(asy_soft_state, instance);
4815 if (asy == NULL)
4819 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
4822 asy_reset_fifo(asy, FIFOTXFLSH | FIFORXFLSH);