Lines Matching defs:asy
64 #include <sys/asy.h>
170 static void async_txint(struct asycom *asy);
171 static void async_rxint(struct asycom *asy, uchar_t lsr);
172 static void async_msint(struct asycom *asy);
173 static void async_softint(struct asycom *asy);
182 static void asy_program(struct asycom *asy, int mode);
183 static void asyinit(struct asycom *asy);
184 static void asy_waiteot(struct asycom *asy);
194 static void asy_parse_mode(dev_info_t *devi, struct asycom *asy);
196 static char *asy_hw_name(struct asycom *asy);
200 static int asy_identify_chip(dev_info_t *devi, struct asycom *asy);
201 static void asy_reset_fifo(struct asycom *asy, uchar_t flags);
202 static int asy_getproperty(dev_info_t *devi, struct asycom *asy,
204 static boolean_t async_flowcontrol_sw_input(struct asycom *asy,
206 static void async_flowcontrol_sw_output(struct asycom *asy,
208 static void async_flowcontrol_hw_input(struct asycom *asy,
210 static void async_flowcontrol_hw_output(struct asycom *asy,
284 "asy",
415 async_put_suspq(struct asycom *asy, mblk_t *mp)
417 struct asyncline *async = asy->asy_priv;
419 ASSERT(mutex_owned(&asy->asy_excl));
430 async_get_suspq(struct asycom *asy)
432 struct asyncline *async = asy->asy_priv;
435 ASSERT(mutex_owned(&asy->asy_excl));
447 async_process_suspq(struct asycom *asy)
449 struct asyncline *async = asy->asy_priv;
452 ASSERT(mutex_owned(&asy->asy_excl));
454 while ((mp = async_get_suspq(asy)) != NULL) {
459 mutex_exit(&asy->asy_excl);
461 mutex_enter(&asy->asy_excl);
481 "asy: can't figure out device type for"
495 asy_get_io_regnum_pci(dev_info_t *devi, struct asycom *asy)
513 if (asy)
514 asy->asy_flags2 |= ASY2_NO_LOOPBACK;
542 asy_get_io_regnum_isa(dev_info_t *devi, struct asycom *asy)
570 if (asy)
571 asy->asy_flags2 |= ASY2_NO_LOOPBACK;
587 asy_get_io_regnum(dev_info_t *devinfo, struct asycom *asy)
591 return (asy_get_io_regnum_isa(devinfo, asy));
593 return (asy_get_io_regnum_pci(devinfo, asy));
603 struct asycom *asy;
608 asy = ddi_get_soft_state(asy_soft_state, instance);
609 if (asy == NULL)
611 async = asy->asy_priv;
615 DEBUGNOTE2(ASY_DEBUG_INIT, "asy%d: %s shutdown.",
616 instance, asy_hw_name(asy));
627 mutex_destroy(&asy->asy_excl);
628 mutex_destroy(&asy->asy_excl_hi);
630 ddi_remove_intr(devi, 0, asy->asy_iblock);
631 ddi_regs_map_free(&asy->asy_iohandle);
632 ddi_remove_softintr(asy->asy_softintr_id);
633 mutex_destroy(&asy->asy_soft_lock);
634 asy_soft_state_free(asy);
635 DEBUGNOTE1(ASY_DEBUG_INIT, "asy%d: shutdown complete",
647 mutex_enter(&asy->asy_excl);
651 cv_wait(&async->async_ops_cv, &asy->asy_excl);
657 if (cv_wait_sig(&async->async_flags_cv, &asy->asy_excl)
659 async_process_suspq(asy);
660 mutex_exit(&asy->asy_excl);
669 mutex_exit(&asy->asy_excl);
671 mutex_enter(&asy->asy_soft_sr);
672 mutex_enter(&asy->asy_excl);
677 mutex_exit(&asy->asy_excl);
679 mutex_enter(&asy->asy_excl);
681 mutex_enter(&asy->asy_excl_hi);
684 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
685 asy->asy_flags |= ASY_DDI_SUSPENDED;
691 mutex_exit(&asy->asy_excl_hi);
694 lsr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR);
695 async_rxint(asy, lsr);
699 lsr = ddi_get8(asy->asy_iohandle,
700 asy->asy_ioaddr + LSR);
707 "asy: transmitter wasn't drained before "
710 mutex_exit(&asy->asy_excl);
711 mutex_exit(&asy->asy_soft_sr);
745 struct asycom *asy;
767 asy = ddi_get_soft_state(asy_soft_state, instance);
768 if (asy == NULL)
771 mutex_enter(&asy->asy_soft_sr);
772 mutex_enter(&asy->asy_excl);
773 mutex_enter(&asy->asy_excl_hi);
775 async = asy->asy_priv;
777 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
778 if (asy_identify_chip(devi, asy) != DDI_SUCCESS) {
779 mutex_exit(&asy->asy_excl_hi);
780 mutex_exit(&asy->asy_excl);
781 mutex_exit(&asy->asy_soft_sr);
783 (void *)asy->asy_ioaddr);
786 asy->asy_flags &= ~ASY_DDI_SUSPENDED;
788 asy_program(asy, ASY_INIT);
793 mutex_exit(&asy->asy_excl_hi);
798 mutex_enter(&asy->asy_excl_hi);
800 ASYSETSOFT(asy);
802 mutex_exit(&asy->asy_excl_hi);
803 mutex_exit(&asy->asy_excl);
804 mutex_exit(&asy->asy_soft_sr);
806 mutex_enter(&asy->asy_excl);
813 async_process_suspq(asy);
814 mutex_exit(&asy->asy_excl);
824 asy = ddi_get_soft_state(asy_soft_state, instance);
825 ASSERT(asy != NULL); /* can't fail - we only just allocated it */
826 asy->asy_unit = instance;
832 regnum = asy_get_io_regnum(devi, asy);
835 ddi_regs_map_setup(devi, regnum, (caddr_t *)&asy->asy_ioaddr,
836 (offset_t)0, (offset_t)0, &ioattr, &asy->asy_iohandle)
838 cmn_err(CE_WARN, "asy%d: could not map UART registers @ %p",
839 instance, (void *)asy->asy_ioaddr);
841 asy_soft_state_free(asy);
845 DEBUGCONT2(ASY_DEBUG_INIT, "asy%dattach: UART @ %p\n",
846 instance, (void *)asy->asy_ioaddr);
877 if (asy->asy_ioaddr == (uint8_t *)(uintptr_t)com_ports[i]) {
878 asy->asy_com_port = i + 1;
890 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0x00);
893 asy->asy_mcr |= RTS|DTR; /* do use RTS/DTR after open */
894 asy->asy_lcr = STOP1|BITS8; /* default to 1 stop 8 bits */
895 asy->asy_bidx = B9600; /* default to 9600 */
897 asy->asy_msint_cnt = 0; /* # of times in async_msint */
901 if (asy->asy_com_port != 0) {
907 switch (asy_getproperty(devi, asy, "ignore-cd")) {
910 "asy%dattach: clear ASY_IGNORE_CD\n", instance);
911 asy->asy_flags &= ~ASY_IGNORE_CD; /* wait for cd */
922 "asy%dattach: set ASY_IGNORE_CD, set RTS & DTR\n",
924 mcr = asy->asy_mcr; /* rts/dtr on */
925 asy->asy_flags |= ASY_IGNORE_CD; /* ignore cd */
930 switch (asy_getproperty(devi, asy, "rts-dtr-off")) {
932 asy->asy_flags |= ASY_RTS_DTR_OFF; /* OFF */
933 mcr = asy->asy_mcr; /* rts/dtr on */
934 DEBUGCONT1(ASY_DEBUG_MODEM, "asy%dattach: "
945 asy_parse_mode(devi, asy);
948 "asy%dattach: clear ASY_IGNORE_CD, clear RTS & DTR\n",
950 asy->asy_flags &= ~ASY_IGNORE_CD; /* wait for cd */
957 asy->asy_fifo_buf = 1;
958 asy->asy_use_fifo = FIFO_OFF;
963 if ((ddi_get_iblock_cookie(devi, 0, &asy->asy_iblock) !=
966 &asy->asy_soft_iblock) != DDI_SUCCESS)) {
967 ddi_regs_map_free(&asy->asy_iohandle);
969 "asy%d: could not hook interrupt for UART @ %p\n",
970 instance, (void *)asy->asy_ioaddr);
971 asy_soft_state_free(asy);
978 mutex_init(&asy->asy_soft_lock, NULL, MUTEX_DRIVER,
979 (void *)asy->asy_soft_iblock);
980 mutex_init(&asy->asy_excl, NULL, MUTEX_DRIVER, NULL);
981 mutex_init(&asy->asy_excl_hi, NULL, MUTEX_DRIVER,
982 (void *)asy->asy_iblock);
983 mutex_init(&asy->asy_soft_sr, NULL, MUTEX_DRIVER,
984 (void *)asy->asy_soft_iblock);
985 mutex_enter(&asy->asy_excl);
986 mutex_enter(&asy->asy_excl_hi);
988 if (asy_identify_chip(devi, asy) != DDI_SUCCESS) {
989 mutex_exit(&asy->asy_excl_hi);
990 mutex_exit(&asy->asy_excl);
991 mutex_destroy(&asy->asy_soft_lock);
992 mutex_destroy(&asy->asy_excl);
993 mutex_destroy(&asy->asy_excl_hi);
994 mutex_destroy(&asy->asy_soft_sr);
995 ddi_regs_map_free(&asy->asy_iohandle);
997 (void *)asy->asy_ioaddr);
998 asy_soft_state_free(asy);
1003 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
1005 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, DLAB);
1007 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + (DAT+DLL),
1008 asyspdtab[asy->asy_bidx] & 0xff);
1009 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + (DAT+DLH),
1010 (asyspdtab[asy->asy_bidx] >> 8) & 0xff);
1011 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, asy->asy_lcr);
1012 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR, mcr);
1014 mutex_exit(&asy->asy_excl_hi);
1015 mutex_exit(&asy->asy_excl);
1020 asy->asy_dip = devi;
1026 &(asy->asy_softintr_id), NULL, 0, asysoftintr,
1027 (caddr_t)asy) != DDI_SUCCESS) {
1028 mutex_destroy(&asy->asy_soft_lock);
1029 mutex_destroy(&asy->asy_excl);
1030 mutex_destroy(&asy->asy_excl_hi);
1031 ddi_regs_map_free(&asy->asy_iohandle);
1034 asy_soft_state_free(asy);
1038 mutex_enter(&asy->asy_excl);
1039 mutex_enter(&asy->asy_excl_hi);
1045 (caddr_t)asy) != DDI_SUCCESS) {
1046 mutex_exit(&asy->asy_excl_hi);
1047 mutex_exit(&asy->asy_excl);
1048 ddi_remove_softintr(asy->asy_softintr_id);
1049 mutex_destroy(&asy->asy_soft_lock);
1050 mutex_destroy(&asy->asy_excl);
1051 mutex_destroy(&asy->asy_excl_hi);
1052 ddi_regs_map_free(&asy->asy_iohandle);
1055 asy_soft_state_free(asy);
1059 mutex_exit(&asy->asy_excl_hi);
1060 mutex_exit(&asy->asy_excl);
1062 asyinit(asy); /* initialize the asyncline structure */
1065 if (asy->asy_com_port != 0) {
1070 name[0] = asy->asy_com_port + 'a' - 1;
1074 * asy port which isn't a standard DOS COM
1080 asy->asy_com_port != 0 ? DDI_NT_SERIAL_MB : DDI_NT_SERIAL, NULL);
1085 asy->asy_com_port != 0 ? DDI_NT_SERIAL_MB_DO :
1090 struct asyncline *async = asy->asy_priv;
1093 ddi_remove_intr(devi, 0, asy->asy_iblock);
1094 ddi_remove_softintr(asy->asy_softintr_id);
1095 mutex_destroy(&asy->asy_soft_lock);
1096 mutex_destroy(&asy->asy_excl);
1097 mutex_destroy(&asy->asy_excl_hi);
1099 ddi_regs_map_free(&asy->asy_iohandle);
1100 asy_soft_state_free(asy);
1107 asy->polledio.cons_polledio_version = CONSPOLLEDIO_V0;
1108 asy->polledio.cons_polledio_argument = (cons_polledio_arg_t)asy;
1109 asy->polledio.cons_polledio_putchar = asyputchar;
1110 asy->polledio.cons_polledio_getchar = asygetchar;
1111 asy->polledio.cons_polledio_ischar = asyischar;
1112 asy->polledio.cons_polledio_enter = NULL;
1113 asy->polledio.cons_polledio_exit = NULL;
1116 DEBUGCONT1(ASY_DEBUG_INIT, "asy%dattach: done\n", instance);
1127 struct asycom *asy;
1133 asy = ddi_get_soft_state(asy_soft_state, instance);
1134 if ((asy == NULL) || (asy->asy_dip == NULL))
1137 *result = (void *) asy->asy_dip;
1154 asy_getproperty(dev_info_t *devi, struct asycom *asy, const char *property)
1158 char letter = asy->asy_com_port + 'a' - 1; /* for ttya */
1159 char number = asy->asy_com_port + '0'; /* for COM1 */
1192 asy_soft_state_free(struct asycom *asy)
1196 if (asy->asy_unit == max_asy_instance) {
1205 if (asy->asy_priv != NULL) {
1206 kmem_free(asy->asy_priv, sizeof (struct asyncline));
1207 asy->asy_priv = NULL;
1209 ddi_soft_state_free(asy_soft_state, asy->asy_unit);
1213 asy_hw_name(struct asycom *asy)
1215 switch (asy->asy_hwtype) {
1228 "asy%d: asy_hw_name: unknown asy_hwtype: %d",
1229 asy->asy_unit, asy->asy_hwtype);
1235 asy_identify_chip(dev_info_t *devi, struct asycom *asy)
1246 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + SCR, SCRTEST);
1248 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + FIFOR, 0x00);
1250 ret = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + SCR);
1258 cmn_err(CE_CONT, "!asy%d: UART @ %p "
1260 asy->asy_unit, (void *)asy->asy_ioaddr, ret);
1268 ddi_put8(asy->asy_iohandle,
1269 asy->asy_ioaddr + FIFOR, 0x00); /* clear */
1270 ddi_put8(asy->asy_iohandle,
1271 asy->asy_ioaddr + FIFOR, FIFO_ON); /* enable */
1272 ddi_put8(asy->asy_iohandle,
1273 asy->asy_ioaddr + FIFOR, FIFO_ON | FIFORXFLSH);
1279 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1281 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + EFR,
1283 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1292 asy->asy_fifor = 0;
1293 asy->asy_hwtype = asymaxchip; /* just for asy_reset_fifo() */
1295 asy->asy_fifor |=
1298 asy->asy_fifor |= FIFOEXTRA1 | FIFOEXTRA2;
1300 asy_reset_fifo(asy, FIFOTXFLSH | FIFORXFLSH);
1302 mcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MCR);
1303 ret = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + ISR);
1305 "asy%d: probe fifo FIFOR=0x%02x ISR=0x%02x MCR=0x%02x\n",
1306 asy->asy_unit, asy->asy_fifor | FIFOTXFLSH | FIFORXFLSH,
1311 asy->asy_fifor = 0;
1315 asy->asy_fifo_buf = 16;
1316 asy->asy_use_fifo = FIFO_ON;
1317 asy->asy_fifor &= ~(FIFOEXTRA1 | FIFOEXTRA2);
1321 asy->asy_fifo_buf = 32;
1322 asy->asy_use_fifo = FIFO_ON;
1323 asy->asy_fifor &= ~(FIFOEXTRA1);
1331 cmn_err(CE_CONT, "asy%d: UART @ %p "
1333 asy->asy_unit, (void *)asy->asy_ioaddr);
1339 asy->asy_fifo_buf = 64;
1340 asy->asy_use_fifo = FIFO_ON;
1344 asy->asy_fifor = 0;
1348 cmn_err(CE_CONT, "asy%d: UART @ %p "
1351 asy->asy_unit, (void *)asy->asy_ioaddr,
1352 asy->asy_fifor | FIFOTXFLSH | FIFORXFLSH, ret, mcr);
1359 * downgrade of the asy->asy_hwtype, or it may not disable
1362 asy_reset_fifo(asy, 0);
1363 asy->asy_hwtype = hwtype;
1369 if (asy->asy_hwtype == ASY16550A && asymaxchip >= ASY16650 &&
1372 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1375 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + SCR, 0);
1377 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1380 ret = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + SCR);
1383 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1385 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + EFR,
1387 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1389 asy->asy_hwtype = ASY16650;
1390 asy->asy_fifo_buf = 32;
1391 asy->asy_fifor |= 0x10; /* 24 byte txfifo trigger */
1392 asy_reset_fifo(asy, 0);
1401 !(asy->asy_flags2 & ASY2_NO_LOOPBACK) &&
1402 (asy->asy_fifo_buf > 16 ||
1403 (asy_fifo_test > 1 && asy->asy_use_fifo == FIFO_ON) ||
1408 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1410 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT,
1412 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR,
1415 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1418 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
1422 for (i = 0; i < asy->asy_fifo_buf * 2; i++) {
1423 ddi_put8(asy->asy_iohandle,
1424 asy->asy_ioaddr + DAT, i);
1443 * In theory, 200 * asy->asy_fifo_buf * 2 should be
1449 delay(drv_usectohz(400 * asy->asy_fifo_buf * 3));
1452 for (i = 0; i < asy->asy_fifo_buf * 3; i++) {
1453 ret = ddi_get8(asy->asy_iohandle,
1454 asy->asy_ioaddr + LSR);
1457 (void) ddi_get8(asy->asy_iohandle,
1458 asy->asy_ioaddr + DAT); /* lose another */
1462 "asy%d FIFO size: expected=%d, measured=%d\n",
1463 asy->asy_unit, asy->asy_fifo_buf, i);
1465 hwtype = asy->asy_hwtype;
1466 if (i < asy->asy_fifo_buf) {
1475 if (i >= 16 && asy->asy_fifo_buf >= 16) {
1478 asy->asy_fifo_buf = 16;
1479 asy->asy_fifor &= ~(FIFOEXTRA1 | FIFOEXTRA2);
1483 asy->asy_fifo_buf = 1;
1484 asy->asy_use_fifo = FIFO_OFF;
1485 asy->asy_fifor &=
1495 * before any possible downgrade of asy->asy_hwtype.
1497 if (asy->asy_hwtype >= ASY16650 && hwtype < ASY16650) {
1499 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1501 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + EFR,
1503 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
1506 asy_reset_fifo(asy, FIFOTXFLSH | FIFORXFLSH);
1507 asy->asy_hwtype = hwtype;
1510 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR, mcr);
1513 DEBUGNOTE3(ASY_DEBUG_CHIP, "asy%d %s @ %p",
1514 asy->asy_unit, asy_hw_name(asy), (void *)asy->asy_ioaddr);
1517 dev = makedevice(DDI_MAJOR_T_UNKNOWN, asy->asy_unit);
1518 (void) ddi_prop_update_string(dev, devi, "uart", asy_hw_name(asy));
1520 if (asy->asy_hwtype == ASY16550) /* for broken 16550's, */
1521 asy->asy_hwtype = ASY8250A; /* drive them as 8250A */
1531 asyinit(struct asycom *asy)
1535 asy->asy_priv = kmem_zalloc(sizeof (struct asyncline), KM_SLEEP);
1536 async = asy->asy_priv;
1537 mutex_enter(&asy->asy_excl);
1538 async->async_common = asy;
1540 mutex_exit(&asy->asy_excl);
1547 struct asycom *asy;
1555 DEBUGCONT1(ASY_DEBUG_CLOSE, "asy%dopen\n", unit);
1556 asy = ddi_get_soft_state(asy_soft_state, unit);
1557 if (asy == NULL)
1559 async = asy->asy_priv;
1560 mutex_enter(&asy->asy_excl);
1563 mutex_enter(&asy->asy_excl_hi);
1573 mutex_exit(&asy->asy_excl_hi);
1583 "asy: couldn't get ttymodes property!");
1584 mutex_enter(&asy->asy_excl_hi);
1587 if (asy->asy_cflag)
1588 async->async_ttycommon.t_cflag = asy->asy_cflag;
1601 asy_program(asy, ASY_INIT);
1605 mutex_exit(&asy->asy_excl_hi);
1606 mutex_exit(&asy->asy_excl);
1609 mutex_exit(&asy->asy_excl_hi);
1610 mutex_exit(&asy->asy_excl);
1620 "asy%dopen: waiting for the ASYNC_DTR_DELAY to be clear\n",
1622 mutex_exit(&asy->asy_excl_hi);
1624 &asy->asy_excl) == 0) {
1626 "asy%dopen: interrupted by signal, exiting\n",
1628 mutex_exit(&asy->asy_excl);
1631 mutex_enter(&asy->asy_excl_hi);
1634 mcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MCR);
1635 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
1636 mcr|(asy->asy_mcr&DTR));
1639 "asy%dopen: \"Raise DTR on every open\": make mcr = %x, "
1641 unit, mcr|(asy->asy_mcr&DTR),
1642 (asy->asy_flags & ASY_IGNORE_CD) ? "ON" : "OFF");
1644 if (asy->asy_flags & ASY_IGNORE_CD) {
1646 "asy%dopen: ASY_IGNORE_CD set, set TS_SOFTCAR\n",
1656 asy->asy_msr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MSR);
1657 DEBUGCONT3(ASY_DEBUG_INIT, "asy%dopen: TS_SOFTCAR is %s, "
1661 (asy->asy_msr & DCD) ? "set" : "clear");
1663 if (asy->asy_msr & DCD)
1667 mutex_exit(&asy->asy_excl_hi);
1681 &asy->asy_excl) == B_FALSE) {
1683 mutex_exit(&asy->asy_excl);
1690 mutex_exit(&asy->asy_excl);
1697 mutex_exit(&asy->asy_excl);
1706 DEBUGCONT1(ASY_DEBUG_INIT, "asy%dopen: done\n", unit);
1714 struct asycom *asy = async->async_common;
1722 mutex_enter(&asy->asy_excl);
1723 mutex_enter(&asy->asy_excl_hi);
1730 mutex_exit(&asy->asy_excl_hi);
1745 mutex_exit(&asy->asy_excl_hi);
1747 mutex_exit(&asy->asy_excl);
1756 struct asycom *asy = async->async_common;
1760 mutex_enter(&asy->asy_excl);
1764 mutex_exit(&asy->asy_excl);
1775 struct asycom *asy;
1785 DEBUGCONT1(ASY_DEBUG_CLOSE, "asy%dclose\n", instance);
1787 asy = async->async_common;
1789 mutex_enter(&asy->asy_excl);
1796 mutex_enter(&asy->asy_excl_hi);
1797 asy->asy_flags &= ~(ASY_PPS | ASY_PPS_EDGE);
1798 mutex_exit(&asy->asy_excl_hi);
1814 mutex_enter(&asy->asy_excl_hi);
1815 lcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
1816 ddi_put8(asy->asy_iohandle,
1817 asy->asy_ioaddr + LCR, (lcr & ~SETBREAK));
1818 mutex_exit(&asy->asy_excl_hi);
1864 if (cv_wait_sig(&async->async_flags_cv, &asy->asy_excl) == 0)
1882 DEBUGCONT1(ASY_DEBUG_MODEM, "asy%dclose: next check HUPCL flag\n",
1884 mutex_enter(&asy->asy_excl_hi);
1888 "asy%dclose: HUPCL flag = %x, ASYNC_WOPEN flag = %x\n",
1895 if (asy->asy_flags & (ASY_IGNORE_CD|ASY_RTS_DTR_OFF)) {
1897 "asy%dclose: ASY_IGNORE_CD flag = %x, "
1900 asy->asy_flags & ASY_IGNORE_CD,
1901 asy->asy_flags & ASY_RTS_DTR_OFF);
1903 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
1904 asy->asy_mcr|OUT2);
1907 "asy%dclose: Dropping DTR and RTS\n", instance);
1908 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
1919 icr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + ICR);
1920 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR,
1923 mutex_exit(&asy->asy_excl_hi);
1946 mutex_exit(&asy->asy_excl);
1948 DEBUGCONT1(ASY_DEBUG_CLOSE, "asy%dclose: done\n", instance);
1953 asy_isbusy(struct asycom *asy)
1958 async = asy->asy_priv;
1959 ASSERT(mutex_owned(&asy->asy_excl));
1960 ASSERT(mutex_owned(&asy->asy_excl_hi));
1965 ((ddi_get8(asy->asy_iohandle,
1966 asy->asy_ioaddr + LSR) & (XSRE|XHRE)) == 0));
1970 asy_waiteot(struct asycom *asy)
1978 ASSERT(mutex_owned(&asy->asy_excl));
1979 ASSERT(mutex_owned(&asy->asy_excl_hi));
1980 while (asy_isbusy(asy)) {
1981 mutex_exit(&asy->asy_excl_hi);
1982 mutex_exit(&asy->asy_excl);
1984 mutex_enter(&asy->asy_excl);
1985 mutex_enter(&asy->asy_excl_hi);
1991 asy_reset_fifo(struct asycom *asy, uchar_t flush)
1997 if (asy->asy_hwtype >= ASY16750) {
1998 lcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
1999 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
2003 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + FIFOR,
2004 asy->asy_fifor | flush);
2008 if (asy->asy_hwtype >= ASY16750) {
2009 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, lcr);
2022 asy_program(struct asycom *asy, int mode)
2033 ASSERT(mutex_owned(&asy->asy_excl));
2034 ASSERT(mutex_owned(&asy->asy_excl_hi));
2036 async = asy->asy_priv;
2040 "asy%d_program: mode = 0x%08X, enter\n", instance, mode);
2061 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
2063 ocflags = asy->asy_ocflag;
2066 (void) ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + ISR);
2067 (void) ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR);
2068 asy->asy_msr = flush_reg = ddi_get8(asy->asy_iohandle,
2069 asy->asy_ioaddr + MSR);
2077 async_flowcontrol_hw_output(asy, FLOW_STOP);
2080 * We can not use async_flowcontrol_hw_output(asy, FLOW_START)
2103 if (asy->asy_use_fifo == FIFO_ON) {
2104 for (flush_reg = asy->asy_fifo_buf; flush_reg-- > 0; ) {
2105 (void) ddi_get8(asy->asy_iohandle,
2106 asy->asy_ioaddr + DAT);
2109 flush_reg = ddi_get8(asy->asy_iohandle,
2110 asy->asy_ioaddr + DAT);
2115 lcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
2143 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, DLAB);
2146 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT,
2148 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR,
2152 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR, lcr);
2161 if (asy->asy_use_fifo == FIFO_ON)
2162 asy_reset_fifo(asy, FIFORXFLSH);
2165 asy->asy_ocflag = c_flag & ~CLOCAL;
2169 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
2170 (asy->asy_mcr & RTS) | OUT2);
2172 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR,
2173 asy->asy_mcr | OUT2);
2180 async_msint(asy);
2184 "asy%d_program: c_flag & CLOCAL = %x t_cflag & CRTSCTS = %x\n",
2200 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, icr);
2201 DEBUGCONT1(ASY_DEBUG_PROCS, "asy%d_program: done\n", instance);
2205 asy_baudok(struct asycom *asy)
2207 struct asyncline *async = asy->asy_priv;
2233 struct asycom *asy = (struct asycom *)argasy;
2238 interrupt_id = ddi_get8(asy->asy_iohandle,
2239 asy->asy_ioaddr + ISR) & 0x0F;
2240 async = asy->asy_priv;
2253 (void) ddi_get8(asy->asy_iohandle,
2254 asy->asy_ioaddr + LSR);
2255 (void) ddi_get8(asy->asy_iohandle,
2256 asy->asy_ioaddr + DAT);
2257 asy->asy_msr = ddi_get8(asy->asy_iohandle,
2258 asy->asy_ioaddr + MSR);
2263 mutex_enter(&asy->asy_excl_hi);
2265 if (asy->asy_flags & ASY_DDI_SUSPENDED) {
2266 mutex_exit(&asy->asy_excl_hi);
2271 * We will loop until the interrupt line is pulled low. asy
2276 (ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + ISR) & 0x0F)) {
2284 lsr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR);
2290 async_rxint(asy, lsr);
2294 async_txint(asy);
2298 async_msint(asy);
2303 async_txint(asy);
2305 mutex_exit(&asy->asy_excl_hi);
2318 async_txint(struct asycom *asy)
2320 struct asyncline *async = asy->asy_priv;
2323 ASSERT(MUTEX_HELD(&asy->asy_excl_hi));
2334 fifo_len = asy->asy_fifo_buf; /* with FIFO buffers */
2338 if (async_flowcontrol_sw_input(asy, FLOW_CHECK, IN_FLOW_NULL))
2345 ddi_put8(asy->asy_iohandle,
2346 asy->asy_ioaddr + DAT, *async->async_optr++);
2354 ASYSETSOFT(asy);
2362 asy_ppsevent(struct asycom *asy, int msr)
2364 ASSERT(MUTEX_HELD(&asy->asy_excl_hi));
2366 if (asy->asy_flags & ASY_PPS_EDGE) {
2369 asy->asy_flags &= ~ASY_PPS_EDGE;
2390 asy->asy_flags |= ASY_PPS_EDGE;
2431 async_rxint(struct asycom *asy, uchar_t lsr)
2433 struct asyncline *async = asy->asy_priv;
2437 int looplim = asy->asy_fifo_buf * 2;
2439 ASSERT(MUTEX_HELD(&asy->asy_excl_hi));
2444 (void) (ddi_get8(asy->asy_iohandle,
2445 asy->asy_ioaddr + DAT) & 0xff);
2446 lsr = ddi_get8(asy->asy_iohandle,
2447 asy->asy_ioaddr + LSR);
2458 c = ddi_get8(asy->asy_iohandle,
2459 asy->asy_ioaddr + DAT) & 0xff;
2469 async_flowcontrol_sw_output(asy,
2474 async_flowcontrol_sw_output(asy,
2481 async_flowcontrol_sw_output(asy,
2492 (asy->asy_flags & ASY_CONSOLE)) {
2529 if ((asy->asy_flags & ASY_CONSOLE) &&
2546 lsr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR);
2552 async_flowcontrol_hw_input(asy, FLOW_STOP, IN_FLOW_RINGBUFF);
2553 (void) async_flowcontrol_sw_input(asy, FLOW_STOP,
2559 ASYSETSOFT(asy); /* need a soft interrupt */
2570 async_msint(struct asycom *asy)
2572 struct asyncline *async = asy->asy_priv;
2578 ASSERT(MUTEX_HELD(&asy->asy_excl_hi));
2582 msr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MSR);
2588 ++(asy->asy_msint_cnt),
2599 if ((t_cflag & CRTSCTS) && (((asy->asy_msr ^ msr) & CTS) != 0))
2600 async_flowcontrol_hw_output(asy,
2607 asy->asy_msr = (uchar_t)msr;
2610 if (asy->asy_flags & ASY_PPS)
2611 asy_ppsevent(asy, msr);
2614 ASYSETSOFT(asy);
2623 msr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MSR);
2624 if (STATES(msr) != STATES(asy->asy_msr))
2635 struct asycom *asy = (struct asycom *)intarg;
2643 mutex_enter(&asy->asy_soft_lock);
2645 rv = asy->asysoftpend;
2647 asy->asysoftpend = 0;
2648 mutex_exit(&asy->asy_soft_lock);
2651 if (asy->asy_priv == NULL)
2653 async = (struct asyncline *)asy->asy_priv;
2654 mutex_enter(&asy->asy_excl_hi);
2655 if (asy->asy_flags & ASY_NEEDSOFT) {
2656 asy->asy_flags &= ~ASY_NEEDSOFT;
2657 mutex_exit(&asy->asy_excl_hi);
2658 async_softint(asy);
2659 mutex_enter(&asy->asy_excl_hi);
2670 mutex_exit(&asy->asy_excl_hi);
2672 (void) async_softint(asy);
2681 async_softint(struct asycom *asy)
2683 struct asyncline *async = asy->asy_priv;
2694 mutex_enter(&asy->asy_excl_hi);
2695 if (asy->asy_flags & ASY_DOINGSOFT) {
2696 asy->asy_flags |= ASY_DOINGSOFT_RETRY;
2697 mutex_exit(&asy->asy_excl_hi);
2700 asy->asy_flags |= ASY_DOINGSOFT;
2702 asy->asy_flags &= ~ASY_DOINGSOFT_RETRY;
2703 mutex_exit(&asy->asy_excl_hi);
2704 mutex_enter(&asy->asy_excl);
2709 mutex_enter(&asy->asy_excl_hi);
2711 mutex_exit(&asy->asy_excl_hi);
2720 mutex_enter(&asy->asy_excl_hi);
2727 instance, asy->asy_msr & DCD, tp->t_flags & TS_SOFTCAR);
2729 if (asy->asy_msr & DCD) {
2737 mutex_exit(&asy->asy_excl_hi);
2738 mutex_exit(&asy->asy_excl);
2740 mutex_enter(&asy->asy_excl);
2741 mutex_enter(&asy->asy_excl_hi);
2762 val = ddi_get8(asy->asy_iohandle,
2763 asy->asy_ioaddr + MCR);
2764 ddi_put8(asy->asy_iohandle,
2765 asy->asy_ioaddr + MCR, (val & ~DTR));
2777 mutex_exit(&asy->asy_excl_hi);
2778 mutex_exit(&asy->asy_excl);
2780 mutex_enter(&asy->asy_excl);
2789 if (asy->asy_use_fifo == FIFO_ON)
2790 asy_reset_fifo(asy, FIFOTXFLSH);
2809 mutex_enter(&asy->asy_excl_hi);
2826 mutex_exit(&asy->asy_excl_hi);
2835 mutex_enter(&asy->asy_excl_hi);
2842 mutex_exit(&asy->asy_excl_hi);
2845 mutex_enter(&asy->asy_excl_hi);
2847 async_flowcontrol_hw_input(asy, FLOW_STOP,
2849 (void) async_flowcontrol_sw_input(asy, FLOW_STOP,
2855 mutex_enter(&asy->asy_excl_hi);
2856 async_flowcontrol_hw_input(asy, FLOW_START,
2858 (void) async_flowcontrol_sw_input(asy, FLOW_START,
2860 mutex_exit(&asy->asy_excl_hi);
2867 mutex_exit(&asy->asy_excl);
2869 mutex_enter(&asy->asy_excl);
2870 mutex_enter(&asy->asy_excl_hi);
2873 mutex_enter(&asy->asy_excl_hi);
2882 mutex_exit(&asy->asy_excl_hi);
2883 mutex_exit(&asy->asy_excl);
2886 asyerror(CE_NOTE, "asy%d: local queue full",
2901 mutex_enter(&asy->asy_excl);
2902 mutex_enter(&asy->asy_excl_hi);
2904 ASYSETSOFT(asy); /* finish cc chars */
2909 async_flowcontrol_hw_input(asy, FLOW_START, IN_FLOW_RINGBUFF);
2910 (void) async_flowcontrol_sw_input(asy, FLOW_START,
2922 mutex_exit(&asy->asy_excl_hi);
2923 mutex_exit(&asy->asy_excl);
2926 mutex_enter(&asy->asy_excl);
2927 mutex_enter(&asy->asy_excl_hi);
2936 mutex_exit(&asy->asy_excl_hi);
2948 mutex_enter(&asy->asy_excl_hi);
2959 mutex_exit(&asy->asy_excl_hi);
2960 mutex_exit(&asy->asy_excl);
2961 asyerror(CE_NOTE, "asy%d: silo overflow", instance);
2962 mutex_enter(&asy->asy_excl);
2963 mutex_enter(&asy->asy_excl_hi);
2969 mutex_exit(&asy->asy_excl_hi);
2970 mutex_exit(&asy->asy_excl);
2971 asyerror(CE_NOTE, "asy%d: ring buffer overflow",
2973 mutex_enter(&asy->asy_excl);
2974 mutex_enter(&asy->asy_excl_hi);
2978 if (asy->asy_flags & ASY_DOINGSOFT_RETRY) {
2979 mutex_exit(&asy->asy_excl);
2982 asy->asy_flags &= ~ASY_DOINGSOFT;
2983 mutex_exit(&asy->asy_excl_hi);
2984 mutex_exit(&asy->asy_excl);
2995 struct asycom *asy = async->async_common;
3006 mutex_enter(&asy->asy_excl);
3013 mutex_enter(&asy->asy_excl_hi);
3014 lcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
3015 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
3017 mutex_exit(&asy->asy_excl_hi);
3023 mutex_exit(&asy->asy_excl);
3039 struct asycom *asy = async->async_common;
3054 if (asy->asy_use_fifo == FIFO_ON) {
3055 fifo_len = asy->asy_fifo_buf; /* with FIFO buffers */
3060 ASSERT(mutex_owned(&asy->asy_excl));
3078 mutex_enter(&asy->asy_excl_hi);
3079 if (async_flowcontrol_sw_input(asy, FLOW_CHECK, IN_FLOW_NULL))
3081 mutex_exit(&asy->asy_excl_hi);
3118 mutex_enter(&asy->asy_excl_hi);
3119 val = ddi_get8(asy->asy_iohandle,
3120 asy->asy_ioaddr + LCR);
3121 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
3123 mutex_exit(&asy->asy_excl_hi);
3148 mutex_exit(&asy->asy_excl);
3150 mutex_enter(&asy->asy_excl);
3195 mutex_enter(&asy->asy_excl_hi);
3202 if (!(ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR) &
3205 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT,
3218 mutex_exit(&asy->asy_excl_hi);
3227 struct asycom *asy = async->async_common;
3232 ASSERT(mutex_owned(&asy->asy_excl_hi));
3238 if (ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR) & XHRE) {
3239 if (async_flowcontrol_sw_input(asy, FLOW_CHECK, IN_FLOW_NULL))
3244 ddi_put8(asy->asy_iohandle,
3245 asy->asy_ioaddr + DAT, *async->async_optr++);
3259 struct asycom *asy = async->async_common;
3261 mutex_enter(&asy->asy_excl);
3265 mutex_exit(&asy->asy_excl);
3275 struct asycom *asy = async->async_common;
3276 ASSERT(mutex_owned(&asy->asy_excl));
3283 cv_wait(&async->async_flags_cv, &asy->asy_excl);
3285 mutex_enter(&asy->asy_excl_hi);
3292 val = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LCR);
3293 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + LCR,
3300 mutex_exit(&asy->asy_excl_hi);
3303 mutex_exit(&asy->asy_excl_hi);
3322 struct asycom *asy = async->async_common;
3401 mutex_enter(&asy->asy_excl);
3411 mutex_enter(&asy->asy_excl_hi);
3412 if (asy_baudok(asy))
3413 asy_program(asy, ASY_NOINIT);
3416 mutex_exit(&asy->asy_excl_hi);
3423 mutex_enter(&asy->asy_excl_hi);
3424 if (!asy_baudok(asy))
3427 if (asy_isbusy(asy))
3428 asy_waiteot(asy);
3429 asy_program(asy, ASY_NOINIT);
3431 mutex_exit(&asy->asy_excl_hi);
3453 if (asy->asy_flags & ASY_PPS)
3470 mutex_enter(&asy->asy_excl_hi);
3472 asy->asy_flags |= ASY_PPS;
3474 asy->asy_flags &= ~ASY_PPS;
3476 asy->asy_flags &= ~ASY_PPS_EDGE;
3477 mutex_exit(&asy->asy_excl_hi);
3498 if ((asy->asy_flags & ASY_PPS) == 0) {
3504 mutex_enter(&asy->asy_excl_hi);
3506 mutex_exit(&asy->asy_excl_hi);
3553 &asy->asy_excl);
3555 mutex_enter(&asy->asy_excl_hi);
3571 while ((ddi_get8(asy->asy_iohandle,
3572 asy->asy_ioaddr + LSR) & XSRE) == 0) {
3573 mutex_exit(&asy->asy_excl_hi);
3574 mutex_exit(&asy->asy_excl);
3577 mutex_enter(&asy->asy_excl);
3578 mutex_enter(&asy->asy_excl_hi);
3586 val = ddi_get8(asy->asy_iohandle,
3587 asy->asy_ioaddr + LCR);
3588 ddi_put8(asy->asy_iohandle,
3589 asy->asy_ioaddr + LCR,
3591 mutex_exit(&asy->asy_excl_hi);
3598 mutex_enter(&asy->asy_excl_hi);
3599 asy_waiteot(asy);
3600 mutex_exit(&asy->asy_excl_hi);
3609 mutex_enter(&asy->asy_excl_hi);
3614 while ((ddi_get8(asy->asy_iohandle,
3615 asy->asy_ioaddr + LSR) & XSRE) == 0) {
3616 mutex_exit(&asy->asy_excl_hi);
3617 mutex_exit(&asy->asy_excl);
3620 mutex_enter(&asy->asy_excl);
3621 mutex_enter(&asy->asy_excl_hi);
3623 val = ddi_get8(asy->asy_iohandle,
3624 asy->asy_ioaddr + LCR);
3625 ddi_put8(asy->asy_iohandle,
3626 asy->asy_ioaddr + LCR, (val | SETBREAK));
3627 mutex_exit(&asy->asy_excl_hi);
3654 mutex_enter(&asy->asy_excl_hi);
3655 (void) asymctl(asy,
3658 mutex_exit(&asy->asy_excl_hi);
3675 mutex_enter(&asy->asy_excl_hi);
3676 *(int *)datamp->b_rptr = asymctl(asy, 0, TIOCMGET);
3677 mutex_exit(&asy->asy_excl_hi);
3696 &asy->polledio;
3717 mutex_enter(&asy->asy_excl_hi);
3719 asy->asy_flags |= ASY_CONSOLE;
3721 asy->asy_flags &= ~ASY_CONSOLE;
3722 mutex_exit(&asy->asy_excl_hi);
3738 (asy->asy_flags & ASY_CONSOLE) != 0;
3753 mutex_exit(&asy->asy_excl);
3763 struct asycom *asy;
3766 asy = (struct asycom *)async->async_common;
3770 mutex_enter(&asy->asy_excl_hi);
3771 ASYSETSOFT(asy);
3772 mutex_exit(&asy->asy_excl_hi);
3801 struct asycom *asy;
3812 asy = async->async_common;
3821 mutex_enter(&asy->asy_excl);
3823 mutex_exit(&asy->asy_excl);
3828 mutex_enter(&asy->asy_excl);
3838 mutex_enter(&asy->asy_excl_hi);
3840 mutex_exit(&asy->asy_excl_hi);
3846 mutex_exit(&asy->asy_excl);
3866 mutex_enter(&asy->asy_excl);
3877 mutex_exit(&asy->asy_excl);
3895 mutex_enter(&asy->asy_excl);
3906 mutex_exit(&asy->asy_excl);
3913 mutex_enter(&asy->asy_excl);
3915 mutex_exit(&asy->asy_excl);
3919 async_put_suspq(asy, mp);
3920 mutex_exit(&asy->asy_excl);
3927 mutex_enter(&asy->asy_excl);
3932 mutex_enter(&asy->asy_excl_hi);
3934 DEBUGCONT1(ASY_DEBUG_BUSY, "asy%dwput: "
3944 if (asy->asy_use_fifo == FIFO_ON) {
3945 asy_reset_fifo(asy, FIFOTXFLSH);
3948 mutex_exit(&asy->asy_excl_hi);
3951 if (asy->asy_use_fifo == FIFO_ON) {
3952 asy_reset_fifo(asy, FIFOTXFLSH);
3963 mutex_exit(&asy->asy_excl);
3969 if (asy->asy_use_fifo == FIFO_ON) {
3970 asy_reset_fifo(asy, FIFORXFLSH);
3984 mutex_enter(&asy->asy_excl);
3986 mutex_exit(&asy->asy_excl);
3999 mutex_enter(&asy->asy_excl);
4001 mutex_exit(&asy->asy_excl);
4006 mutex_enter(&asy->asy_excl);
4008 mutex_enter(&asy->asy_excl_hi);
4010 async_flowcontrol_hw_input(asy, FLOW_STOP,
4012 (void) async_flowcontrol_sw_input(asy,
4015 mutex_exit(&asy->asy_excl_hi);
4016 mutex_exit(&asy->asy_excl);
4020 async_put_suspq(asy, mp);
4021 mutex_exit(&asy->asy_excl);
4025 mutex_enter(&asy->asy_excl);
4027 mutex_enter(&asy->asy_excl_hi);
4029 async_flowcontrol_hw_input(asy, FLOW_START,
4031 (void) async_flowcontrol_sw_input(asy,
4034 mutex_exit(&asy->asy_excl_hi);
4035 mutex_exit(&asy->asy_excl);
4039 async_put_suspq(asy, mp);
4040 mutex_exit(&asy->asy_excl);
4046 mutex_enter(&asy->asy_excl);
4050 mutex_exit(&asy->asy_excl);
4054 async_put_suspq(asy, mp);
4065 mutex_enter(&asy->asy_excl);
4076 mutex_exit(&asy->asy_excl);
4082 mutex_enter(&asy->asy_excl);
4084 mutex_exit(&asy->asy_excl);
4088 async_put_suspq(asy, mp);
4089 mutex_exit(&asy->asy_excl);
4114 struct asycom *asy;
4118 asy = ddi_get_soft_state(asy_soft_state, instance);
4119 ASSERT(asy != NULL);
4120 async = asy->asy_priv;
4125 mutex_enter(&asy->asy_excl);
4128 mutex_exit(&asy->asy_excl);
4134 mutex_exit(&asy->asy_excl);
4137 mutex_exit(&asy->asy_excl);
4144 struct asycom *asy;
4151 asy = async->async_common;
4162 mutex_enter(&asy->asy_excl);
4186 mutex_enter(&asy->asy_excl_hi);
4187 (void) asymctl(asy, dmtoasy(*(int *)mp->b_cont->b_rptr),
4189 mutex_exit(&asy->asy_excl_hi);
4199 mutex_exit(&asy->asy_excl);
4213 struct asycom *asy = (struct asycom *)arg;
4218 while ((ddi_get8(asy->asy_iohandle,
4219 asy->asy_ioaddr + LSR) & XHRE) == 0) {
4225 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT, c);
4235 struct asycom *asy = (struct asycom *)arg;
4237 return ((ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR) & RCA)
4247 struct asycom *asy = (struct asycom *)arg;
4251 return (ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + DAT));
4258 asymctl(struct asycom *asy, int bits, int how)
4261 int instance = asy->asy_unit;
4263 ASSERT(mutex_owned(&asy->asy_excl_hi));
4264 ASSERT(mutex_owned(&asy->asy_excl));
4267 mcr_r = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MCR);
4273 "asy%dmctl: TIOCMSET, bits = %x\n", instance, bits);
4278 DEBUGCONT2(ASY_DEBUG_MODEM, "asy%dmctl: TIOCMBIS, bits = %x\n",
4284 DEBUGCONT2(ASY_DEBUG_MODEM, "asy%dmctl: TIOCMBIC, bits = %x\n",
4295 if (ddi_get8(asy->asy_iohandle,
4296 asy->asy_ioaddr + ICR) & MIEN) {
4297 msr_r = asy->asy_msr;
4299 "asy%dmctl: TIOCMGET, read msr_r = %x\n",
4302 msr_r = ddi_get8(asy->asy_iohandle,
4303 asy->asy_ioaddr + MSR);
4305 "asy%dmctl: TIOCMGET, read MSR = %x\n",
4308 DEBUGCONT2(ASY_DEBUG_MODEM, "asy%dtodm: modem_lines = %x\n",
4313 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + MCR, mcr_r);
4404 * asy_parse_mode(dev_info_t *devi, struct asycom *asy)
4415 asy_parse_mode(dev_info_t *devi, struct asycom *asy)
4424 ASSERT(asy->asy_com_port != 0);
4429 (void) sprintf(name, "tty%c-mode", asy->asy_com_port + 'a' - 1);
4433 (void) sprintf(name, "com%c-mode", asy->asy_com_port + '0');
4439 asy->asy_cflag = 0;
4445 asy->asy_cflag = CREAD|B9600; /* initial default */
4449 asy->asy_cflag |= BITS8; /* add default bits */
4454 asy->asy_bidx = B110;
4456 asy->asy_bidx = B150;
4458 asy->asy_bidx = B300;
4460 asy->asy_bidx = B600;
4462 asy->asy_bidx = B1200;
4464 asy->asy_bidx = B2400;
4466 asy->asy_bidx = B4800;
4468 asy->asy_bidx = B9600;
4470 asy->asy_bidx = B19200;
4472 asy->asy_bidx = B38400;
4474 asy->asy_bidx = B57600;
4476 asy->asy_bidx = B115200;
4478 asy->asy_bidx = B9600;
4480 asy->asy_cflag &= ~CBAUD;
4481 if (asy->asy_bidx > CBAUD) { /* > 38400 uses the CBAUDEXT bit */
4482 asy->asy_cflag |= CBAUDEXT;
4483 asy->asy_cflag |= asy->asy_bidx - CBAUD - 1;
4485 asy->asy_cflag |= asy->asy_bidx;
4488 ASSERT(asy->asy_bidx == BAUDINDEX(asy->asy_cflag));
4495 asy->asy_cflag |= BITS8; /* add default bits */
4501 asy->asy_cflag |= CS8;
4502 asy->asy_lcr = BITS8;
4505 asy->asy_cflag |= CS7;
4506 asy->asy_lcr = BITS7;
4509 asy->asy_cflag |= CS6;
4510 asy->asy_lcr = BITS6;
4514 asy->asy_cflag |= CS5;
4515 asy->asy_lcr = BITS5;
4531 asy->asy_cflag |= PARENB;
4532 asy->asy_lcr |= PEN; break;
4534 asy->asy_cflag |= PARENB|PARODD;
4535 asy->asy_lcr |= PEN|EPS;
4547 asy->asy_cflag |= CSTOPB;
4548 asy->asy_lcr |= STB;
4558 asy->asy_cflag |= CRTSCTS;
4560 asy->asy_cflag |= CRTSXOFF;
4608 async_flowcontrol_sw_input(struct asycom *asy, async_flowc_action onoff,
4611 struct asyncline *async = asy->asy_priv;
4615 ASSERT(mutex_owned(&asy->asy_excl_hi));
4656 (ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + LSR) & XHRE)) {
4663 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + DAT,
4683 async_flowcontrol_sw_output(struct asycom *asy, async_flowc_action onoff)
4685 struct asyncline *async = asy->asy_priv;
4688 ASSERT(mutex_owned(&asy->asy_excl_hi));
4727 async_flowcontrol_hw_input(struct asycom *asy, async_flowc_action onoff,
4732 struct asyncline *async = asy->asy_priv;
4735 ASSERT(mutex_owned(&asy->asy_excl_hi));
4760 mcr = ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + MCR);
4764 ddi_put8(asy->asy_iohandle,
4765 asy->asy_ioaddr + MCR, (mcr ^ RTS));
4783 async_flowcontrol_hw_output(struct asycom *asy, async_flowc_action onoff)
4785 struct asyncline *async = asy->asy_priv;
4788 ASSERT(mutex_owned(&asy->asy_excl_hi));
4827 struct asycom *asy;
4831 asy = ddi_get_soft_state(asy_soft_state, instance);
4832 if (asy == NULL)
4836 ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + ICR, 0);
4839 asy_reset_fifo(asy, FIFOTXFLSH | FIFORXFLSH);