/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* Copyright (c) 1990, 1991 UNIX System Laboratories, Inc. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989, 1990 AT&T */ /* All Rights Reserved */ /* * Copyright (c) 1992, 2010, Oracle and/or its affiliates. All rights reserved. * Copyright 2012 Milan Jurik. All rights reserved. * Copyright (c) 2016 by Delphix. All rights reserved. * Copyright 2026 Oxide Computer Company * Copyright 2024 Hans Rosenfeld */ /* * Serial I/O driver for 8250/16450/16550A/16650/16750/16950 chips. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef DEBUG #include #endif #include #include #include #include #include #include #include /* * set the RX FIFO trigger_level to half the RX FIFO size for now * we may want to make this configurable later. */ static int asy_trig_level = ASY_FCR_RHR_TRIG_8; int asy_drain_check = 15000000; /* tunable: exit drain check time */ int asy_min_dtr_low = 500000; /* tunable: minimum DTR down time */ int asy_min_utbrk = 100000; /* tunable: minumum untimed brk time */ int asymaxchip = ASY_MAXCHIP; /* tunable: limit chip support we look for */ /* * Just in case someone has a chip with broken loopback mode, we provide a * means to disable the loopback test. By default, we only loopback test * UARTs which look like they have FIFOs bigger than 16 bytes. * Set to 0 to suppress test, or to 2 to enable test on any size FIFO. */ int asy_fifo_test = 1; /* tunable: set to 0, 1, or 2 */ /* * Allow ability to switch off testing of the scratch register. * Some UART emulators might not have it. This will also disable the test * for Exar/Startech ST16C650, as that requires use of the SCR register. */ int asy_scr_test = 1; /* tunable: set to 0 to disable SCR reg test */ /* * As we don't yet support on-chip flow control, it's a bad idea to put a * large number of characters in the TX FIFO, since if other end tells us * to stop transmitting, we can only stop filling the TX FIFO, but it will * still carry on draining by itself, so remote end still gets what's left * in the FIFO. */ int asy_max_tx_fifo = 16; /* tunable: max fill of TX FIFO */ #define async_stopc async_ttycommon.t_stopc #define async_startc async_ttycommon.t_startc #define ASY_INIT 1 #define ASY_NOINIT 0 /* enum value for sw and hw flow control action */ typedef enum { FLOW_CHECK, FLOW_STOP, FLOW_START } async_flowc_action; #ifdef DEBUG typedef enum { ASY_DEBUG_INIT = 1 << 0, /* Output during driver initialization. */ ASY_DEBUG_INPUT = 1 << 1, /* Report characters received during int. */ ASY_DEBUG_EOT = 1 << 2, /* Output when wait for xmit to finish. */ ASY_DEBUG_CLOSE = 1 << 3, /* Output when driver open/close called */ ASY_DEBUG_HFLOW = 1 << 4, /* Output when H/W flowcontrol is active */ ASY_DEBUG_PROCS = 1 << 5, /* Output each proc name as it is entered. */ ASY_DEBUG_STATE = 1 << 6, /* Output value of Interrupt Service Reg. */ ASY_DEBUG_INTR = 1 << 7, /* Output value of Interrupt Service Reg. */ ASY_DEBUG_OUT = 1 << 8, /* Output about output events. */ ASY_DEBUG_BUSY = 1 << 9, /* Output when xmit is enabled/disabled */ ASY_DEBUG_MODEM = 1 << 10, /* Output about modem status & control. */ ASY_DEBUG_MODM2 = 1 << 11, /* Output about modem status & control. */ ASY_DEBUG_IOCTL = 1 << 12, /* Output about ioctl messages. */ ASY_DEBUG_CHIP = 1 << 13, /* Output about chip identification. */ ASY_DEBUG_SFLOW = 1 << 14, /* Output when S/W flowcontrol is active */ } asy_debug_t; static asy_debug_t debug = 0; #define ASY_DEBUG(asy, x) (asy->asy_debug & (x)) #define ASY_DPRINTF(asy, fac, format, ...) \ if (ASY_DEBUG(asy, fac)) \ asyerror(asy, CE_CONT, "!%s: " format, __func__, ##__VA_ARGS__) #else #define ASY_DEBUG(asy, x) B_FALSE #define ASY_DPRINTF(asy, fac, format, ...) #endif /* * PPS (Pulse Per Second) support. */ void ddi_hardpps(struct timeval *, int); /* * This is protected by the asy_excl_hi of the port on which PPS event * handling is enabled. Note that only one port should have this enabled at * any one time. Enabling PPS handling on multiple ports will result in * unpredictable (but benign) results. */ static struct ppsclockev asy_ppsev; #ifdef PPSCLOCKLED /* XXX Use these to observe PPS latencies and jitter on a scope */ #define LED_ON #define LED_OFF #else #define LED_ON #define LED_OFF #endif static void asy_put_idx(const struct asycom *, asy_reg_t, uint8_t); static uint8_t asy_get_idx(const struct asycom *, asy_reg_t); static void asy_put_add(const struct asycom *, asy_reg_t, uint8_t); static uint8_t asy_get_add(const struct asycom *, asy_reg_t); static void asy_put_ext(const struct asycom *, asy_reg_t, uint8_t); static uint8_t asy_get_ext(const struct asycom *, asy_reg_t); static void asy_put_reg(const struct asycom *, asy_reg_t, uint8_t); static uint8_t asy_get_reg(const struct asycom *, asy_reg_t); static void asy_put(const struct asycom *, asy_reg_t, uint8_t); static uint8_t asy_get(const struct asycom *, asy_reg_t); static void asy_set(const struct asycom *, asy_reg_t, uint8_t); static void asy_clr(const struct asycom *, asy_reg_t, uint8_t); static void asy_enable_interrupts(const struct asycom *, uint8_t); static void asy_disable_interrupts(const struct asycom *, uint8_t); static void asy_set_baudrate(const struct asycom *, int); static void asy_wait_baudrate(struct asycom *); #define BAUDINDEX(cflg) (((cflg) & CBAUDEXT) ? \ (((cflg) & CBAUD) + CBAUD + 1) : ((cflg) & CBAUD)) static void asysetsoft(struct asycom *); static uint_t asysoftintr(caddr_t, caddr_t); static uint_t asyintr(caddr_t, caddr_t); static boolean_t abort_charseq_recognize(uchar_t ch); /* The async interrupt entry points */ static void async_txint(struct asycom *asy); static void async_rxint(struct asycom *asy, uchar_t lsr); static void async_msint(struct asycom *asy); static void async_softint(struct asycom *asy); static void async_ioctl(struct asyncline *async, queue_t *q, mblk_t *mp); static void async_reioctl(void *unit); static void async_iocdata(queue_t *q, mblk_t *mp); static void async_restart(void *arg); static void async_start(struct asyncline *async); static void async_resume(struct asyncline *async); static void asy_program(struct asycom *asy, int mode); static void asyinit(struct asycom *asy); static void asy_waiteot(struct asycom *asy); static void asyputchar(cons_polledio_arg_t, uchar_t c); static int asygetchar(cons_polledio_arg_t); static boolean_t asyischar(cons_polledio_arg_t); static int asymctl(struct asycom *, int, int); static int asytodm(int, int); static int dmtoasy(struct asycom *, int); static void asyerror(const struct asycom *, int, const char *, ...) __KPRINTFLIKE(3); static void asy_parse_mode(dev_info_t *devi, struct asycom *asy); static void asy_soft_state_free(struct asycom *); static char *asy_hw_name(struct asycom *asy); static void async_hold_utbrk(void *arg); static void async_resume_utbrk(struct asyncline *async); static void async_dtr_free(struct asyncline *async); static int asy_identify_chip(dev_info_t *devi, struct asycom *asy); static void asy_reset_fifo(struct asycom *asy, uchar_t flags); static void asy_carrier_check(struct asycom *); static int asy_getproperty(dev_info_t *devi, struct asycom *asy, const char *property); static boolean_t async_flowcontrol_sw_input(struct asycom *asy, async_flowc_action onoff, int type); static void async_flowcontrol_sw_output(struct asycom *asy, async_flowc_action onoff); static void async_flowcontrol_hw_input(struct asycom *asy, async_flowc_action onoff, int type); static void async_flowcontrol_hw_output(struct asycom *asy, async_flowc_action onoff); #define GET_PROP(devi, pname, pflag, pval, plen) \ (ddi_prop_op(DDI_DEV_T_ANY, (devi), PROP_LEN_AND_VAL_BUF, \ (pflag), (pname), (caddr_t)(pval), (plen))) kmutex_t asy_glob_lock; /* lock protecting global data manipulation */ void *asy_soft_state; /* Standard COM port I/O addresses */ static const int standard_com_ports[] = { COM1_IOADDR, COM2_IOADDR, COM3_IOADDR, COM4_IOADDR }; static int *com_ports; static uint_t num_com_ports; #ifdef DEBUG /* * Set this to true to make the driver pretend to do a suspend. Useful * for debugging suspend/resume code with a serial debugger. */ boolean_t asy_nosuspend = B_FALSE; #endif /* * Baud rate table. Indexed by #defines found in sys/termios.h * * The default crystal frequency is 1.8432 MHz. The 8250A used a fixed /16 * prescaler and a 16bit divisor, split in two registers (DLH and DLL). * * The 16950 adds TCR and CKS registers. The TCR can be used to set the * prescaler from /4 to /16. The CKS can be used, among other things, to * select a isochronous 1x mode, effectively disabling the prescaler. * This would theoretically allow a baud rate of 1843200 driven directly * by the default crystal frequency, although the highest termios.h-defined * baud rate we can support is half of that, 921600 baud. */ #define UNSUPPORTED 0x00, 0x00, 0x00 static struct { uint8_t asy_dlh; uint8_t asy_dll; uint8_t asy_tcr; } asy_baud_tab[] = { [B0] = { UNSUPPORTED }, /* 0 baud */ [B50] = { 0x09, 0x00, 0x00 }, /* 50 baud */ [B75] = { 0x06, 0x00, 0x00 }, /* 75 baud */ [B110] = { 0x04, 0x17, 0x00 }, /* 110 baud (0.026% error) */ [B134] = { 0x03, 0x59, 0x00 }, /* 134 baud (0.058% error) */ [B150] = { 0x03, 0x00, 0x00 }, /* 150 baud */ [B200] = { 0x02, 0x40, 0x00 }, /* 200 baud */ [B300] = { 0x01, 0x80, 0x00 }, /* 300 baud */ [B600] = { 0x00, 0xc0, 0x00 }, /* 600 baud */ [B1200] = { 0x00, 0x60, 0x00 }, /* 1200 baud */ [B1800] = { 0x00, 0x40, 0x00 }, /* 1800 baud */ [B2400] = { 0x00, 0x30, 0x00 }, /* 2400 baud */ [B4800] = { 0x00, 0x18, 0x00 }, /* 4800 baud */ [B9600] = { 0x00, 0x0c, 0x00 }, /* 9600 baud */ [B19200] = { 0x00, 0x06, 0x00 }, /* 19200 baud */ [B38400] = { 0x00, 0x03, 0x00 }, /* 38400 baud */ [B57600] = { 0x00, 0x02, 0x00 }, /* 57600 baud */ [B76800] = { 0x00, 0x06, 0x04 }, /* 76800 baud (16950) */ [B115200] = { 0x00, 0x01, 0x00 }, /* 115200 baud */ [B153600] = { 0x00, 0x03, 0x04 }, /* 153600 baud (16950) */ [B230400] = { 0x00, 0x02, 0x04 }, /* 230400 baud (16950) */ [B307200] = { 0x00, 0x01, 0x06 }, /* 307200 baud (16950) */ [B460800] = { 0x00, 0x01, 0x04 }, /* 460800 baud (16950) */ [B921600] = { 0x00, 0x02, 0x01 }, /* 921600 baud (16950) */ [B1000000] = { UNSUPPORTED }, /* 1000000 baud */ [B1152000] = { UNSUPPORTED }, /* 1152000 baud */ [B1500000] = { UNSUPPORTED }, /* 1500000 baud */ [B2000000] = { UNSUPPORTED }, /* 2000000 baud */ [B2500000] = { UNSUPPORTED }, /* 2500000 baud */ [B3000000] = { UNSUPPORTED }, /* 3000000 baud */ [B3500000] = { UNSUPPORTED }, /* 3500000 baud */ [B4000000] = { UNSUPPORTED }, /* 4000000 baud */ }; /* * Register table. For each logical register, we define the minimum hwtype, the * register offset, and function pointers for reading and writing the register. * A NULL pointer indicates the register cannot be read from or written to, * respectively. */ static struct { int asy_min_hwtype; int8_t asy_reg_off; uint8_t (*asy_get_reg)(const struct asycom *, asy_reg_t); void (*asy_put_reg)(const struct asycom *, asy_reg_t, uint8_t); } asy_reg_table[] = { [ASY_ILLEGAL] = { 0, -1, NULL, NULL }, /* 8250 / 16450 / 16550 registers */ [ASY_THR] = { ASY_8250A, 0, NULL, asy_put_reg }, [ASY_RHR] = { ASY_8250A, 0, asy_get_reg, NULL }, [ASY_IER] = { ASY_8250A, 1, asy_get_reg, asy_put_reg }, [ASY_FCR] = { ASY_16550, 2, NULL, asy_put_reg }, [ASY_ISR] = { ASY_8250A, 2, asy_get_reg, NULL }, [ASY_LCR] = { ASY_8250A, 3, asy_get_reg, asy_put_reg }, [ASY_MCR] = { ASY_8250A, 4, asy_get_reg, asy_put_reg }, [ASY_LSR] = { ASY_8250A, 5, asy_get_reg, NULL }, [ASY_MSR] = { ASY_8250A, 6, asy_get_reg, NULL }, [ASY_SPR] = { ASY_8250A, 7, asy_get_reg, asy_put_reg }, [ASY_DLL] = { ASY_8250A, 0, asy_get_reg, asy_put_reg }, [ASY_DLH] = { ASY_8250A, 1, asy_get_reg, asy_put_reg }, /* 16750 extended register */ [ASY_EFR] = { ASY_16750, 2, asy_get_ext, asy_put_ext }, /* 16650 extended registers */ [ASY_XON1] = { ASY_16650, 4, asy_get_ext, asy_put_ext }, [ASY_XON2] = { ASY_16650, 5, asy_get_ext, asy_put_ext }, [ASY_XOFF1] = { ASY_16650, 6, asy_get_ext, asy_put_ext }, [ASY_XOFF2] = { ASY_16650, 7, asy_get_ext, asy_put_ext }, /* 16950 additional registers */ [ASY_ASR] = { ASY_16950, 1, asy_get_add, asy_put_add }, [ASY_RFL] = { ASY_16950, 3, asy_get_add, NULL }, [ASY_TFL] = { ASY_16950, 4, asy_get_add, NULL }, [ASY_ICR] = { ASY_16950, 5, asy_get_reg, asy_put_reg }, /* 16950 indexed registers */ [ASY_ACR] = { ASY_16950, 0, asy_get_idx, asy_put_idx }, [ASY_CPR] = { ASY_16950, 1, asy_get_idx, asy_put_idx }, [ASY_TCR] = { ASY_16950, 2, asy_get_idx, asy_put_idx }, [ASY_CKS] = { ASY_16950, 3, asy_get_idx, asy_put_idx }, [ASY_TTL] = { ASY_16950, 4, asy_get_idx, asy_put_idx }, [ASY_RTL] = { ASY_16950, 5, asy_get_idx, asy_put_idx }, [ASY_FCL] = { ASY_16950, 6, asy_get_idx, asy_put_idx }, [ASY_FCH] = { ASY_16950, 7, asy_get_idx, asy_put_idx }, [ASY_ID1] = { ASY_16950, 8, asy_get_idx, NULL }, [ASY_ID2] = { ASY_16950, 9, asy_get_idx, NULL }, [ASY_ID3] = { ASY_16950, 10, asy_get_idx, NULL }, [ASY_REV] = { ASY_16950, 11, asy_get_idx, NULL }, [ASY_CSR] = { ASY_16950, 12, NULL, asy_put_idx }, [ASY_NMR] = { ASY_16950, 13, asy_get_idx, asy_put_idx }, }; static int asyrsrv(queue_t *q); static int asyopen(queue_t *rq, dev_t *dev, int flag, int sflag, cred_t *cr); static int asyclose(queue_t *q, int flag, cred_t *credp); static int asywputdo(queue_t *q, mblk_t *mp, boolean_t); static int asywput(queue_t *q, mblk_t *mp); struct module_info asy_info = { 0, "asy", 0, INFPSZ, 4096, 128 }; static struct qinit asy_rint = { putq, asyrsrv, asyopen, asyclose, NULL, &asy_info, NULL }; static struct qinit asy_wint = { asywput, NULL, NULL, NULL, NULL, &asy_info, NULL }; struct streamtab asy_str_info = { &asy_rint, &asy_wint, NULL, NULL }; static void asy_intr_free(struct asycom *); static int asy_intr_setup(struct asycom *, int); static void asy_softintr_free(struct asycom *); static int asy_softintr_setup(struct asycom *); static int asy_suspend(struct asycom *); static int asy_resume(dev_info_t *); static int asyinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result); static int asyprobe(dev_info_t *); static int asyattach(dev_info_t *, ddi_attach_cmd_t); static int asydetach(dev_info_t *, ddi_detach_cmd_t); static int asyquiesce(dev_info_t *); static struct cb_ops cb_asy_ops = { nodev, /* cb_open */ nodev, /* cb_close */ nodev, /* cb_strategy */ nodev, /* cb_print */ nodev, /* cb_dump */ nodev, /* cb_read */ nodev, /* cb_write */ nodev, /* cb_ioctl */ nodev, /* cb_devmap */ nodev, /* cb_mmap */ nodev, /* cb_segmap */ nochpoll, /* cb_chpoll */ ddi_prop_op, /* cb_prop_op */ &asy_str_info, /* cb_stream */ D_MP /* cb_flag */ }; struct dev_ops asy_ops = { DEVO_REV, /* devo_rev */ 0, /* devo_refcnt */ asyinfo, /* devo_getinfo */ nulldev, /* devo_identify */ asyprobe, /* devo_probe */ asyattach, /* devo_attach */ asydetach, /* devo_detach */ nodev, /* devo_reset */ &cb_asy_ops, /* devo_cb_ops */ NULL, /* devo_bus_ops */ NULL, /* power */ asyquiesce, /* quiesce */ }; static struct modldrv modldrv = { &mod_driverops, /* Type of module. This one is a driver */ "ASY driver", &asy_ops, /* driver ops */ }; static struct modlinkage modlinkage = { MODREV_1, (void *)&modldrv, NULL }; int _init(void) { int i; i = ddi_soft_state_init(&asy_soft_state, sizeof (struct asycom), 2); if (i == 0) { mutex_init(&asy_glob_lock, NULL, MUTEX_DRIVER, NULL); if ((i = mod_install(&modlinkage)) != 0) { mutex_destroy(&asy_glob_lock); ddi_soft_state_fini(&asy_soft_state); #ifdef DEBUG } else { if (debug & ASY_DEBUG_INIT) cmn_err(CE_NOTE, "!%s, debug = %x", modldrv.drv_linkinfo, debug); #endif } } return (i); } int _fini(void) { int i; if ((i = mod_remove(&modlinkage)) == 0) { #ifdef DEBUG if (debug & ASY_DEBUG_INIT) cmn_err(CE_NOTE, "!%s unloading", modldrv.drv_linkinfo); #endif mutex_destroy(&asy_glob_lock); /* free "motherboard-serial-ports" property if allocated */ if (com_ports != NULL && com_ports != (int *)standard_com_ports) ddi_prop_free(com_ports); com_ports = NULL; ddi_soft_state_fini(&asy_soft_state); } return (i); } int _info(struct modinfo *modinfop) { return (mod_info(&modlinkage, modinfop)); } static void asy_put_idx(const struct asycom *asy, asy_reg_t reg, uint8_t val) { ASSERT(asy->asy_hwtype >= ASY_16950); ASSERT(reg >= ASY_ACR); ASSERT(reg <= ASY_NREG); /* * The last value written to LCR must not have been the magic value for * EFR access. Every time the driver writes that magic value to access * EFR, XON1, XON2, XOFF1, and XOFF2, the driver restores the original * value of LCR, so we should be good here. * * I'd prefer to ASSERT this, but I'm not sure it's worth the hassle. */ /* Write indexed register offset to SPR. */ asy_put(asy, ASY_SPR, asy_reg_table[reg].asy_reg_off); /* Write value to ICR. */ asy_put(asy, ASY_ICR, val); } static uint8_t asy_get_idx(const struct asycom *asy, asy_reg_t reg) { uint8_t val; ASSERT(asy->asy_hwtype >= ASY_16950); ASSERT(reg >= ASY_ACR); ASSERT(reg <= ASY_NREG); /* Enable access to ICR in ACR. */ asy_put(asy, ASY_ACR, ASY_ACR_ICR | asy->asy_acr); /* Write indexed register offset to SPR. */ asy_put(asy, ASY_SPR, asy_reg_table[reg].asy_reg_off); /* Read value from ICR. */ val = asy_get(asy, ASY_ICR); /* Restore ACR. */ asy_put(asy, ASY_ACR, asy->asy_acr); return (val); } static void asy_put_add(const struct asycom *asy, asy_reg_t reg, uint8_t val) { ASSERT(asy->asy_hwtype >= ASY_16950); /* Only ASR is writable, RFL and TFL are read-only. */ ASSERT(reg == ASY_ASR); /* * Only ASR[0] (Transmitter Disabled) and ASR[1] (Remote Transmitter * Disabled) are writable. */ ASSERT((val & ~(ASY_ASR_TD | ASY_ASR_RTD)) == 0); /* Enable access to ASR in ACR. */ asy_put(asy, ASY_ACR, ASY_ACR_ASR | asy->asy_acr); /* Write value to ASR. */ asy_put_reg(asy, reg, val); /* Restore ACR. */ asy_put(asy, ASY_ACR, asy->asy_acr); } static uint8_t asy_get_add(const struct asycom *asy, asy_reg_t reg) { uint8_t val; ASSERT(asy->asy_hwtype >= ASY_16950); ASSERT(reg >= ASY_ASR); ASSERT(reg <= ASY_TFL); /* * The last value written to LCR must not have been the magic value for * EFR access. Every time the driver writes that magic value to access * EFR, XON1, XON2, XOFF1, and XOFF2, the driver restores the original * value of LCR, so we should be good here. * * I'd prefer to ASSERT this, but I'm not sure it's worth the hassle. */ /* Enable access to ASR in ACR. */ asy_put(asy, ASY_ACR, ASY_ACR_ASR | asy->asy_acr); /* Read value from register. */ val = asy_get_reg(asy, reg); /* Restore ACR. */ asy_put(asy, ASY_ACR, 0 | asy->asy_acr); return (val); } static void asy_put_ext(const struct asycom *asy, asy_reg_t reg, uint8_t val) { uint8_t lcr; /* * On the 16750, EFR can be accessed when LCR[7]=1 (DLAB). * Only two bits are assigned for auto RTS/CTS, which we don't support * yet. * * So insist we have a 16650 or up. */ ASSERT(asy->asy_hwtype >= ASY_16650); ASSERT(reg >= ASY_EFR); ASSERT(reg <= ASY_XOFF2); /* Save LCR contents. */ lcr = asy_get(asy, ASY_LCR); /* Enable extended register access. */ asy_put(asy, ASY_LCR, ASY_LCR_EFRACCESS); /* Write extended register */ asy_put_reg(asy, reg, val); /* Restore previous LCR contents, disabling extended register access. */ asy_put(asy, ASY_LCR, lcr); } static uint8_t asy_get_ext(const struct asycom *asy, asy_reg_t reg) { uint8_t lcr, val; /* * On the 16750, EFR can be accessed when LCR[7]=1 (DLAB). * Only two bits are assigned for auto RTS/CTS, which we don't support * yet. * * So insist we have a 16650 or up. */ ASSERT(asy->asy_hwtype >= ASY_16650); ASSERT(reg >= ASY_EFR); ASSERT(reg <= ASY_XOFF2); /* Save LCR contents. */ lcr = asy_get(asy, ASY_LCR); /* Enable extended register access. */ asy_put(asy, ASY_LCR, ASY_LCR_EFRACCESS); /* Read extended register */ val = asy_get_reg(asy, reg); /* Restore previous LCR contents, disabling extended register access. */ asy_put(asy, ASY_LCR, lcr); return (val); } static void asy_put_reg(const struct asycom *asy, asy_reg_t reg, uint8_t val) { ASSERT(asy->asy_hwtype >= asy_reg_table[reg].asy_min_hwtype); ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + asy_reg_table[reg].asy_reg_off, val); } static uint8_t asy_get_reg(const struct asycom *asy, asy_reg_t reg) { ASSERT(asy->asy_hwtype >= asy_reg_table[reg].asy_min_hwtype); return (ddi_get8(asy->asy_iohandle, asy->asy_ioaddr + asy_reg_table[reg].asy_reg_off)); } static void asy_put(const struct asycom *asy, asy_reg_t reg, uint8_t val) { ASSERT(mutex_owned(&asy->asy_excl_hi)); ASSERT(reg > ASY_ILLEGAL); ASSERT(reg < ASY_NREG); ASSERT(asy->asy_hwtype >= asy_reg_table[reg].asy_min_hwtype); ASSERT(asy_reg_table[reg].asy_put_reg != NULL); asy_reg_table[reg].asy_put_reg(asy, reg, val); } static uint8_t asy_get(const struct asycom *asy, asy_reg_t reg) { uint8_t val; ASSERT(mutex_owned(&asy->asy_excl_hi)); ASSERT(reg > ASY_ILLEGAL); ASSERT(reg < ASY_NREG); ASSERT(asy->asy_hwtype >= asy_reg_table[reg].asy_min_hwtype); ASSERT(asy_reg_table[reg].asy_get_reg != NULL); val = asy_reg_table[reg].asy_get_reg(asy, reg); return (val); } static void asy_set(const struct asycom *asy, asy_reg_t reg, uint8_t bits) { uint8_t val = asy_get(asy, reg); asy_put(asy, reg, val | bits); } static void asy_clr(const struct asycom *asy, asy_reg_t reg, uint8_t bits) { uint8_t val = asy_get(asy, reg); asy_put(asy, reg, val & ~bits); } static void asy_enable_interrupts(const struct asycom *asy, uint8_t intr) { /* Don't touch any IER bits we don't support. */ intr &= ASY_IER_ALL; asy_set(asy, ASY_IER, intr); } static void asy_disable_interrupts(const struct asycom *asy, uint8_t intr) { /* Don't touch any IER bits we don't support. */ intr &= ASY_IER_ALL; asy_clr(asy, ASY_IER, intr); } static void asy_set_baudrate(const struct asycom *asy, int baudrate) { uint8_t tcr; if (baudrate == 0) return; if (baudrate >= ARRAY_SIZE(asy_baud_tab)) return; tcr = asy_baud_tab[baudrate].asy_tcr; if (tcr != 0 && asy->asy_hwtype < ASY_16950) return; if (asy->asy_hwtype >= ASY_16950) { if (tcr == 0x01) { /* Isochronous 1x mode is selected in CKS, not TCR. */ asy_put(asy, ASY_CKS, ASY_CKS_RCLK_1X | ASY_CKS_TCLK_1X); asy_put(asy, ASY_TCR, 0); } else { /* Reset CKS in case it was set to 1x mode. */ asy_put(asy, ASY_CKS, 0); ASSERT(tcr == 0x00 || tcr >= 0x04 || tcr <= 0x0f); asy_put(asy, ASY_TCR, tcr); } ASY_DPRINTF(asy, ASY_DEBUG_IOCTL, "setting baudrate %d, CKS 0x%02x, TCR 0x%02x", baudrate, asy_get(asy, ASY_CKS), asy_get(asy, ASY_TCR)); } ASY_DPRINTF(asy, ASY_DEBUG_IOCTL, "setting baudrate %d, divisor 0x%02x%02x", baudrate, asy_baud_tab[baudrate].asy_dlh, asy_baud_tab[baudrate].asy_dll); asy_set(asy, ASY_LCR, ASY_LCR_DLAB); asy_put(asy, ASY_DLL, asy_baud_tab[baudrate].asy_dll); asy_put(asy, ASY_DLH, asy_baud_tab[baudrate].asy_dlh); asy_clr(asy, ASY_LCR, ASY_LCR_DLAB); } /* * Loop until the TSR is empty. * * The wait period is clock / (baud * 16) * 16 * 2. */ static void asy_wait_baudrate(struct asycom *asy) { struct asyncline *async = asy->asy_priv; int rate = BAUDINDEX(async->async_ttycommon.t_cflag); clock_t usec = ((((clock_t)asy_baud_tab[rate].asy_dlh) << 8) | ((clock_t)asy_baud_tab[rate].asy_dll)) * 16 * 2; ASSERT(mutex_owned(&asy->asy_excl)); ASSERT(mutex_owned(&asy->asy_excl_hi)); while ((asy_get(asy, ASY_LSR) & ASY_LSR_TEMT) == 0) { mutex_exit(&asy->asy_excl_hi); mutex_exit(&asy->asy_excl); drv_usecwait(usec); mutex_enter(&asy->asy_excl); mutex_enter(&asy->asy_excl_hi); } asy_set(asy, ASY_LCR, ASY_LCR_SETBRK); } void async_put_suspq(struct asycom *asy, mblk_t *mp) { struct asyncline *async = asy->asy_priv; ASSERT(mutex_owned(&asy->asy_excl)); if (async->async_suspqf == NULL) async->async_suspqf = mp; else async->async_suspqb->b_next = mp; async->async_suspqb = mp; } static mblk_t * async_get_suspq(struct asycom *asy) { struct asyncline *async = asy->asy_priv; mblk_t *mp; ASSERT(mutex_owned(&asy->asy_excl)); if ((mp = async->async_suspqf) != NULL) { async->async_suspqf = mp->b_next; mp->b_next = NULL; } else { async->async_suspqb = NULL; } return (mp); } static void async_process_suspq(struct asycom *asy) { struct asyncline *async = asy->asy_priv; mblk_t *mp; ASSERT(mutex_owned(&asy->asy_excl)); while ((mp = async_get_suspq(asy)) != NULL) { queue_t *q; q = async->async_ttycommon.t_writeq; ASSERT(q != NULL); mutex_exit(&asy->asy_excl); (void) asywputdo(q, mp, B_FALSE); mutex_enter(&asy->asy_excl); } async->async_flags &= ~ASYNC_DDI_SUSPENDED; cv_broadcast(&async->async_flags_cv); } static int asy_get_bus_type(dev_info_t *devinfo) { char *prop; int bustype; if (ddi_prop_lookup_string(DDI_DEV_T_ANY, devinfo, 0, "device_type", &prop) != DDI_PROP_SUCCESS && ddi_prop_lookup_string(DDI_DEV_T_ANY, devinfo, 0, "bus-type", &prop) != DDI_PROP_SUCCESS) { dev_err(devinfo, CE_WARN, "!%s: can't figure out device type for parent \"%s\"", __func__, ddi_get_name(ddi_get_parent(devinfo))); return (ASY_BUS_UNKNOWN); } if (strcmp(prop, "isa") == 0) bustype = ASY_BUS_ISA; else if (strcmp(prop, "pci") == 0) bustype = ASY_BUS_PCI; else if (strcmp(prop, "pciex") == 0) return (ASY_BUS_PCI); else bustype = ASY_BUS_UNKNOWN; ddi_prop_free(prop); return (bustype); } static int asy_get_io_regnum_pci(dev_info_t *devi, struct asycom *asy) { int reglen, nregs; int regnum, i; uint64_t size; struct pci_phys_spec *reglist; if (ddi_getlongprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS, "reg", (caddr_t)®list, ®len) != DDI_PROP_SUCCESS) { dev_err(devi, CE_WARN, "!%s: reg property" " not found in devices property list", __func__); return (-1); } regnum = -1; nregs = reglen / sizeof (*reglist); for (i = 0; i < nregs; i++) { switch (reglist[i].pci_phys_hi & PCI_ADDR_MASK) { case PCI_ADDR_IO: /* I/O bus reg property */ if (regnum == -1) /* use only the first one */ regnum = i; break; default: break; } } /* check for valid count of registers */ if (regnum >= 0) { size = ((uint64_t)reglist[regnum].pci_size_low) | ((uint64_t)reglist[regnum].pci_size_hi) << 32; if (size < 8) regnum = -1; } kmem_free(reglist, reglen); return (regnum); } static int asy_get_io_regnum_isa(dev_info_t *devi, struct asycom *asy) { int regnum = -1; int reglen, nregs; struct { uint_t bustype; int base; int size; } *reglist; if (ddi_getlongprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS, "reg", (caddr_t)®list, ®len) != DDI_PROP_SUCCESS) { dev_err(devi, CE_WARN, "!%s: reg property not found " "in devices property list", __func__); return (-1); } nregs = reglen / sizeof (*reglist); /* * Find the first I/O bus in the "reg" property. */ for (int i = 0; i < nregs && regnum == -1; i++) { if (reglist[i].bustype == 1) { regnum = i; break; } } /* check for valid count of registers */ if ((regnum < 0) || (reglist[regnum].size < 8)) regnum = -1; kmem_free(reglist, reglen); return (regnum); } static int asy_get_io_regnum(dev_info_t *devinfo, struct asycom *asy) { switch (asy_get_bus_type(devinfo)) { case ASY_BUS_ISA: return (asy_get_io_regnum_isa(devinfo, asy)); case ASY_BUS_PCI: return (asy_get_io_regnum_pci(devinfo, asy)); default: return (-1); } } static void asy_intr_free(struct asycom *asy) { int i; for (i = 0; i < asy->asy_intr_cnt; i++) { if (asy->asy_inth[i] == NULL) break; if ((asy->asy_intr_cap & DDI_INTR_FLAG_BLOCK) != 0) (void) ddi_intr_block_disable(&asy->asy_inth[i], 1); else (void) ddi_intr_disable(asy->asy_inth[i]); (void) ddi_intr_remove_handler(asy->asy_inth[i]); (void) ddi_intr_free(asy->asy_inth[i]); } kmem_free(asy->asy_inth, asy->asy_inth_sz); asy->asy_inth = NULL; asy->asy_inth_sz = 0; } static int asy_intr_setup(struct asycom *asy, int intr_type) { int nintrs, navail, count; int ret; int i; if (asy->asy_intr_types == 0) { ret = ddi_intr_get_supported_types(asy->asy_dip, &asy->asy_intr_types); if (ret != DDI_SUCCESS) { asyerror(asy, CE_WARN, "ddi_intr_get_supported_types failed"); return (ret); } } if ((asy->asy_intr_types & intr_type) == 0) return (DDI_FAILURE); ret = ddi_intr_get_nintrs(asy->asy_dip, intr_type, &nintrs); if (ret != DDI_SUCCESS) { asyerror(asy, CE_WARN, "ddi_intr_get_nintrs failed, type %d", intr_type); return (ret); } if (nintrs < 1) { asyerror(asy, CE_WARN, "no interrupts of type %d", intr_type); return (DDI_FAILURE); } ret = ddi_intr_get_navail(asy->asy_dip, intr_type, &navail); if (ret != DDI_SUCCESS) { asyerror(asy, CE_WARN, "ddi_intr_get_navail failed, type %d", intr_type); return (ret); } if (navail < 1) { asyerror(asy, CE_WARN, "no available interrupts, type %d", intr_type); return (DDI_FAILURE); } /* * Some PCI(e) RS232 adapters seem to support more than one interrupt, * but the asy driver really doesn't. */ asy->asy_inth_sz = sizeof (ddi_intr_handle_t); asy->asy_inth = kmem_zalloc(asy->asy_inth_sz, KM_SLEEP); ret = ddi_intr_alloc(asy->asy_dip, asy->asy_inth, intr_type, 0, 1, &count, 0); if (ret != DDI_SUCCESS) { asyerror(asy, CE_WARN, "ddi_intr_alloc failed, count %d, " "type %d", navail, intr_type); goto fail; } if (count != 1) { asyerror(asy, CE_WARN, "ddi_intr_alloc returned not 1 but %d " "interrupts of type %d", count, intr_type); goto fail; } asy->asy_intr_cnt = count; ret = ddi_intr_get_pri(asy->asy_inth[0], &asy->asy_intr_pri); if (ret != DDI_SUCCESS) { asyerror(asy, CE_WARN, "ddi_intr_get_pri failed, type %d", intr_type); goto fail; } for (i = 0; i < count; i++) { ret = ddi_intr_add_handler(asy->asy_inth[i], asyintr, (void *)asy, (void *)(uintptr_t)i); if (ret != DDI_SUCCESS) { asyerror(asy, CE_WARN, "ddi_intr_add_handler failed, " "int %d, type %d", i, intr_type); goto fail; } } (void) ddi_intr_get_cap(asy->asy_inth[0], &asy->asy_intr_cap); for (i = 0; i < count; i++) { if (asy->asy_intr_cap & DDI_INTR_FLAG_BLOCK) ret = ddi_intr_block_enable(&asy->asy_inth[i], 1); else ret = ddi_intr_enable(asy->asy_inth[i]); if (ret != DDI_SUCCESS) { asyerror(asy, CE_WARN, "enabling interrupt %d failed, type %d", i, intr_type); goto fail; } } asy->asy_intr_type = intr_type; return (DDI_SUCCESS); fail: asy_intr_free(asy); return (ret); } static void asy_softintr_free(struct asycom *asy) { (void) ddi_intr_remove_softint(asy->asy_soft_inth); } static int asy_softintr_setup(struct asycom *asy) { int ret; ret = ddi_intr_add_softint(asy->asy_dip, &asy->asy_soft_inth, ASY_SOFT_INT_PRI, asysoftintr, asy); if (ret != DDI_SUCCESS) { asyerror(asy, CE_WARN, "ddi_intr_add_softint failed"); return (ret); } /* * This may seem pointless since we specified ASY_SOFT_INT_PRI above, * but then it's probably a good idea to consider the soft interrupt * priority an opaque value and don't hardcode any assumptions about * its actual value here. */ ret = ddi_intr_get_softint_pri(asy->asy_soft_inth, &asy->asy_soft_intr_pri); if (ret != DDI_SUCCESS) { asyerror(asy, CE_WARN, "ddi_intr_get_softint_pri failed"); return (ret); } return (DDI_SUCCESS); } static int asy_resume(dev_info_t *devi) { struct asyncline *async; struct asycom *asy; int instance = ddi_get_instance(devi); /* find out which unit */ #ifdef DEBUG if (asy_nosuspend) return (DDI_SUCCESS); #endif asy = ddi_get_soft_state(asy_soft_state, instance); if (asy == NULL) return (DDI_FAILURE); mutex_enter(&asy->asy_soft_sr); mutex_enter(&asy->asy_excl); mutex_enter(&asy->asy_excl_hi); async = asy->asy_priv; asy_disable_interrupts(asy, ASY_IER_ALL); if (asy_identify_chip(devi, asy) != DDI_SUCCESS) { mutex_exit(&asy->asy_excl_hi); mutex_exit(&asy->asy_excl); mutex_exit(&asy->asy_soft_sr); ASY_DPRINTF(asy, ASY_DEBUG_INIT, "Cannot identify UART chip at %p", (void *)asy->asy_ioaddr); return (DDI_FAILURE); } asy->asy_flags &= ~ASY_DDI_SUSPENDED; if (async->async_flags & ASYNC_ISOPEN) { asy_program(asy, ASY_INIT); /* Kick off output */ if (async->async_ocnt > 0) { async_resume(async); } else { mutex_exit(&asy->asy_excl_hi); if (async->async_xmitblk) freeb(async->async_xmitblk); async->async_xmitblk = NULL; async_start(async); mutex_enter(&asy->asy_excl_hi); } asysetsoft(asy); } mutex_exit(&asy->asy_excl_hi); mutex_exit(&asy->asy_excl); mutex_exit(&asy->asy_soft_sr); mutex_enter(&asy->asy_excl); if (async->async_flags & ASYNC_RESUME_BUFCALL) { async->async_wbufcid = bufcall(async->async_wbufcds, BPRI_HI, (void (*)(void *)) async_reioctl, (void *)(intptr_t)async->async_common->asy_unit); async->async_flags &= ~ASYNC_RESUME_BUFCALL; } async_process_suspq(asy); mutex_exit(&asy->asy_excl); return (DDI_SUCCESS); } static int asy_suspend(struct asycom *asy) { struct asyncline *async = asy->asy_priv; unsigned i; uchar_t lsr; #ifdef DEBUG if (asy_nosuspend) return (DDI_SUCCESS); #endif mutex_enter(&asy->asy_excl); ASSERT(async->async_ops >= 0); while (async->async_ops > 0) cv_wait(&async->async_ops_cv, &asy->asy_excl); async->async_flags |= ASYNC_DDI_SUSPENDED; /* Wait for timed break and delay to complete */ while ((async->async_flags & (ASYNC_BREAK|ASYNC_DELAY))) { if (cv_wait_sig(&async->async_flags_cv, &asy->asy_excl) == 0) { async_process_suspq(asy); mutex_exit(&asy->asy_excl); return (DDI_FAILURE); } } /* Clear untimed break */ if (async->async_flags & ASYNC_OUT_SUSPEND) async_resume_utbrk(async); mutex_exit(&asy->asy_excl); mutex_enter(&asy->asy_soft_sr); mutex_enter(&asy->asy_excl); if (async->async_wbufcid != 0) { bufcall_id_t bcid = async->async_wbufcid; async->async_wbufcid = 0; async->async_flags |= ASYNC_RESUME_BUFCALL; mutex_exit(&asy->asy_excl); unbufcall(bcid); mutex_enter(&asy->asy_excl); } mutex_enter(&asy->asy_excl_hi); asy_disable_interrupts(asy, ASY_IER_ALL); asy->asy_flags |= ASY_DDI_SUSPENDED; /* * Hardware interrupts are disabled we can drop our high level * lock and proceed. */ mutex_exit(&asy->asy_excl_hi); /* Process remaining RX characters and RX errors, if any */ lsr = asy_get(asy, ASY_LSR); async_rxint(asy, lsr); /* Wait for TX to drain */ for (i = 1000; i > 0; i--) { lsr = asy_get(asy, ASY_LSR); if ((lsr & (ASY_LSR_TEMT | ASY_LSR_THRE)) == (ASY_LSR_TEMT | ASY_LSR_THRE)) break; delay(drv_usectohz(10000)); } if (i == 0) asyerror(asy, CE_WARN, "transmitter wasn't drained before " "driver was suspended"); mutex_exit(&asy->asy_excl); mutex_exit(&asy->asy_soft_sr); return (DDI_SUCCESS); } static int asydetach(dev_info_t *devi, ddi_detach_cmd_t cmd) { int instance; struct asycom *asy; instance = ddi_get_instance(devi); /* find out which unit */ asy = ddi_get_soft_state(asy_soft_state, instance); if (asy == NULL) return (DDI_FAILURE); switch (cmd) { case DDI_DETACH: break; case DDI_SUSPEND: return (asy_suspend(asy)); default: return (DDI_FAILURE); } ASY_DPRINTF(asy, ASY_DEBUG_INIT, "%s shutdown", asy_hw_name(asy)); /* * Ensure that interrupts are disabled prior to destroying data and * mutexes that they depend on. */ if ((asy->asy_progress & ASY_PROGRESS_INT) != 0) asy_intr_free(asy); if ((asy->asy_progress & ASY_PROGRESS_SOFTINT) != 0) asy_softintr_free(asy); if ((asy->asy_progress & ASY_PROGRESS_ASYNC) != 0) { struct asyncline *async = asy->asy_priv; asy->asy_priv = NULL; /* cancel DTR hold timeout */ if (async->async_dtrtid != 0) { (void) untimeout(async->async_dtrtid); async->async_dtrtid = 0; } cv_destroy(&async->async_flags_cv); kmem_free(async, sizeof (struct asyncline)); } if ((asy->asy_progress & ASY_PROGRESS_MINOR) != 0) ddi_remove_minor_node(devi, NULL); if ((asy->asy_progress & ASY_PROGRESS_MUTEX) != 0) { mutex_destroy(&asy->asy_excl); mutex_destroy(&asy->asy_excl_hi); mutex_destroy(&asy->asy_soft_lock); } if ((asy->asy_progress & ASY_PROGRESS_REGS) != 0) ddi_regs_map_free(&asy->asy_iohandle); ASY_DPRINTF(asy, ASY_DEBUG_INIT, "shutdown complete"); ddi_set_driver_private(devi, NULL); asy_soft_state_free(asy); return (DDI_SUCCESS); } /* * asyprobe * We don't bother probing for the hardware, as since Solaris 2.6, device * nodes are only created for auto-detected hardware or nodes explicitly * created by the user, e.g. via the DCA. However, we should check the * device node is at least vaguely usable, i.e. we have a block of 8 i/o * ports. This prevents attempting to attach to bogus serial ports which * some BIOSs still partially report when they are disabled in the BIOS. */ static int asyprobe(dev_info_t *devi) { return ((asy_get_io_regnum(devi, NULL) < 0) ? DDI_PROBE_FAILURE : DDI_PROBE_DONTCARE); } static int asyattach(dev_info_t *devi, ddi_attach_cmd_t cmd) { int instance; int mcr; int ret; int regnum = 0; int i; struct asycom *asy; char name[ASY_MINOR_LEN]; int status; static ddi_device_acc_attr_t ioattr = { .devacc_attr_version = DDI_DEVICE_ATTR_V1, .devacc_attr_endian_flags = DDI_NEVERSWAP_ACC, .devacc_attr_dataorder = DDI_STRICTORDER_ACC, .devacc_attr_access = DDI_DEFAULT_ACC }; switch (cmd) { case DDI_ATTACH: break; case DDI_RESUME: return (asy_resume(devi)); default: return (DDI_FAILURE); } mutex_enter(&asy_glob_lock); if (com_ports == NULL) { /* need to initialize com_ports */ if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, devi, 0, "motherboard-serial-ports", &com_ports, &num_com_ports) != DDI_PROP_SUCCESS) { /* Use our built-in COM[1234] values */ com_ports = (int *)standard_com_ports; num_com_ports = sizeof (standard_com_ports) / sizeof (standard_com_ports[0]); } if (num_com_ports > 10) { /* We run out of single digits for device properties */ num_com_ports = 10; cmn_err(CE_WARN, "%s: more than %d motherboard-serial-ports", asy_info.mi_idname, num_com_ports); } } mutex_exit(&asy_glob_lock); instance = ddi_get_instance(devi); /* find out which unit */ ret = ddi_soft_state_zalloc(asy_soft_state, instance); if (ret != DDI_SUCCESS) return (DDI_FAILURE); asy = ddi_get_soft_state(asy_soft_state, instance); asy->asy_dip = devi; #ifdef DEBUG asy->asy_debug = debug; #endif asy->asy_unit = instance; regnum = asy_get_io_regnum(devi, asy); if (regnum < 0 || ddi_regs_map_setup(devi, regnum, (caddr_t *)&asy->asy_ioaddr, (offset_t)0, (offset_t)0, &ioattr, &asy->asy_iohandle) != DDI_SUCCESS) { asyerror(asy, CE_WARN, "could not map UART registers @ %p", (void *)asy->asy_ioaddr); goto fail; } asy->asy_progress |= ASY_PROGRESS_REGS; ASY_DPRINTF(asy, ASY_DEBUG_INIT, "UART @ %p", (void *)asy->asy_ioaddr); /* * Lookup the i/o address to see if this is a standard COM port * in which case we assign it the correct tty[a-d] to match the * COM port number, or some other i/o address in which case it * will be assigned /dev/term/[0123...] in some rather arbitrary * fashion. */ for (i = 0; i < num_com_ports; i++) { if (asy->asy_ioaddr == (uint8_t *)(uintptr_t)com_ports[i]) { asy->asy_com_port = i + 1; break; } } /* * It appears that there was async hardware that on reset did not clear * IER. Hence when we enable interrupts, this hardware would cause the * system to hang if there was input available. * * Don't use asy_disable_interrupts() as the mutexes haven't been * initialized yet. */ ddi_put8(asy->asy_iohandle, asy->asy_ioaddr + asy_reg_table[ASY_IER].asy_reg_off, 0); /* * Establish default settings: * - use RTS/DTR after open * - 8N1 data format * - 9600 baud */ asy->asy_mcr |= ASY_MCR_RTS | ASY_MCR_DTR; asy->asy_lcr = ASY_LCR_STOP1 | ASY_LCR_BITS8; asy->asy_bidx = B9600; asy->asy_fifo_buf = 1; asy->asy_use_fifo = ASY_FCR_FIFO_OFF; #ifdef DEBUG asy->asy_msint_cnt = 0; /* # of times in async_msint */ #endif mcr = 0; /* don't enable until open */ if (asy->asy_com_port != 0) { /* * For motherboard ports, emulate tty eeprom properties. * Actually, we can't tell if a port is motherboard or not, * so for "motherboard ports", read standard DOS COM ports. */ switch (asy_getproperty(devi, asy, "ignore-cd")) { case 0: /* *-ignore-cd=False */ ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "clear ASY_IGNORE_CD"); asy->asy_flags &= ~ASY_IGNORE_CD; /* wait for cd */ break; case 1: /* *-ignore-cd=True */ /*FALLTHRU*/ default: /* *-ignore-cd not defined */ /* * We set rather silly defaults of soft carrier on * and DTR/RTS raised here because it might be that * one of the motherboard ports is the system console. */ ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "set ASY_IGNORE_CD, set RTS & DTR"); mcr = asy->asy_mcr; /* rts/dtr on */ asy->asy_flags |= ASY_IGNORE_CD; /* ignore cd */ break; } /* Property for not raising DTR/RTS */ switch (asy_getproperty(devi, asy, "rts-dtr-off")) { case 0: /* *-rts-dtr-off=False */ asy->asy_flags |= ASY_RTS_DTR_OFF; /* OFF */ mcr = asy->asy_mcr; /* rts/dtr on */ ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "ASY_RTS_DTR_OFF set and DTR & RTS set"); break; case 1: /* *-rts-dtr-off=True */ /*FALLTHRU*/ default: /* *-rts-dtr-off undefined */ break; } /* Parse property for tty modes */ asy_parse_mode(devi, asy); } else { ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "clear ASY_IGNORE_CD, clear RTS & DTR"); asy->asy_flags &= ~ASY_IGNORE_CD; /* wait for cd */ } /* * Install per instance software interrupt handler. */ if (asy_softintr_setup(asy) != DDI_SUCCESS) { asyerror(asy, CE_WARN, "Cannot set soft interrupt"); goto fail; } asy->asy_progress |= ASY_PROGRESS_SOFTINT; /* * Install interrupt handler for this device. */ if ((asy_intr_setup(asy, DDI_INTR_TYPE_MSIX) != DDI_SUCCESS) && (asy_intr_setup(asy, DDI_INTR_TYPE_MSI) != DDI_SUCCESS) && (asy_intr_setup(asy, DDI_INTR_TYPE_FIXED) != DDI_SUCCESS)) { asyerror(asy, CE_WARN, "Cannot set device interrupt"); goto fail; } asy->asy_progress |= ASY_PROGRESS_INT; /* * Initialize mutexes before accessing the hardware */ mutex_init(&asy->asy_soft_lock, NULL, MUTEX_DRIVER, DDI_INTR_PRI(asy->asy_soft_intr_pri)); mutex_init(&asy->asy_soft_sr, NULL, MUTEX_DRIVER, DDI_INTR_PRI(asy->asy_soft_intr_pri)); mutex_init(&asy->asy_excl, NULL, MUTEX_DRIVER, NULL); mutex_init(&asy->asy_excl_hi, NULL, MUTEX_DRIVER, DDI_INTR_PRI(asy->asy_intr_pri)); asy->asy_progress |= ASY_PROGRESS_MUTEX; mutex_enter(&asy->asy_excl); mutex_enter(&asy->asy_excl_hi); if (asy_identify_chip(devi, asy) != DDI_SUCCESS) { ASY_DPRINTF(asy, ASY_DEBUG_INIT, "Cannot identify UART chip at %p", (void *)asy->asy_ioaddr); goto fail; } asy_disable_interrupts(asy, ASY_IER_ALL); asy_put(asy, ASY_LCR, asy->asy_lcr); asy_set_baudrate(asy, asy->asy_bidx); asy_put(asy, ASY_MCR, mcr); mutex_exit(&asy->asy_excl_hi); mutex_exit(&asy->asy_excl); asyinit(asy); /* initialize the asyncline structure */ asy->asy_progress |= ASY_PROGRESS_ASYNC; /* create minor device nodes for this device */ if (asy->asy_com_port != 0) { /* * For DOS COM ports, add letter suffix so * devfsadm can create correct link names. */ name[0] = asy->asy_com_port + 'a' - 1; name[1] = '\0'; } else { /* * asy port which isn't a standard DOS COM * port gets a numeric name based on instance */ (void) snprintf(name, ASY_MINOR_LEN, "%d", instance); } status = ddi_create_minor_node(devi, name, S_IFCHR, instance, asy->asy_com_port != 0 ? DDI_NT_SERIAL_MB : DDI_NT_SERIAL, 0); if (status == DDI_SUCCESS) { (void) strcat(name, ",cu"); status = ddi_create_minor_node(devi, name, S_IFCHR, OUTLINE | instance, asy->asy_com_port != 0 ? DDI_NT_SERIAL_MB_DO : DDI_NT_SERIAL_DO, 0); } if (status != DDI_SUCCESS) goto fail; asy->asy_progress |= ASY_PROGRESS_MINOR; /* * Fill in the polled I/O structure. */ asy->polledio.cons_polledio_version = CONSPOLLEDIO_V0; asy->polledio.cons_polledio_argument = (cons_polledio_arg_t)asy; asy->polledio.cons_polledio_putchar = asyputchar; asy->polledio.cons_polledio_getchar = asygetchar; asy->polledio.cons_polledio_ischar = asyischar; asy->polledio.cons_polledio_enter = NULL; asy->polledio.cons_polledio_exit = NULL; ddi_set_driver_private(devi, asy); ddi_report_dev(devi); ASY_DPRINTF(asy, ASY_DEBUG_INIT, "done"); return (DDI_SUCCESS); fail: (void) asydetach(devi, DDI_DETACH); return (DDI_FAILURE); } static int asyinfo(dev_info_t *dip __unused, ddi_info_cmd_t infocmd, void *arg, void **result) { dev_t dev = (dev_t)arg; int instance, error; struct asycom *asy; instance = UNIT(dev); switch (infocmd) { case DDI_INFO_DEVT2DEVINFO: asy = ddi_get_soft_state(asy_soft_state, instance); if ((asy == NULL) || (asy->asy_dip == NULL)) error = DDI_FAILURE; else { *result = (void *) asy->asy_dip; error = DDI_SUCCESS; } break; case DDI_INFO_DEVT2INSTANCE: *result = (void *)(intptr_t)instance; error = DDI_SUCCESS; break; default: error = DDI_FAILURE; } return (error); } /* asy_getproperty -- walk through all name variants until we find a match */ static int asy_getproperty(dev_info_t *devi, struct asycom *asy, const char *property) { int len; int ret; char letter = asy->asy_com_port + 'a' - 1; /* for ttya */ char number = asy->asy_com_port + '0'; /* for COM1 */ char val[40]; char name[40]; /* Property for ignoring DCD */ (void) sprintf(name, "tty%c-%s", letter, property); len = sizeof (val); ret = GET_PROP(devi, name, DDI_PROP_CANSLEEP, val, &len); if (ret != DDI_PROP_SUCCESS) { (void) sprintf(name, "com%c-%s", number, property); len = sizeof (val); ret = GET_PROP(devi, name, DDI_PROP_CANSLEEP, val, &len); } if (ret != DDI_PROP_SUCCESS) { (void) sprintf(name, "tty0%c-%s", number, property); len = sizeof (val); ret = GET_PROP(devi, name, DDI_PROP_CANSLEEP, val, &len); } if (ret != DDI_PROP_SUCCESS) { (void) sprintf(name, "port-%c-%s", letter, property); len = sizeof (val); ret = GET_PROP(devi, name, DDI_PROP_CANSLEEP, val, &len); } if (ret != DDI_PROP_SUCCESS) return (-1); /* property non-existant */ if (val[0] == 'f' || val[0] == 'F' || val[0] == '0') return (0); /* property false/0 */ return (1); /* property true/!0 */ } /* asy_soft_state_free - local wrapper for ddi_soft_state_free(9F) */ static void asy_soft_state_free(struct asycom *asy) { if (asy->asy_priv != NULL) { kmem_free(asy->asy_priv, sizeof (struct asyncline)); asy->asy_priv = NULL; } ddi_soft_state_free(asy_soft_state, asy->asy_unit); } static char * asy_hw_name(struct asycom *asy) { switch (asy->asy_hwtype) { case ASY_8250A: return ("8250A/16450"); case ASY_16550: return ("16550"); case ASY_16550A: return ("16550A"); case ASY_16650: return ("16650"); case ASY_16750: return ("16750"); case ASY_16950: return ("16950"); } ASY_DPRINTF(asy, ASY_DEBUG_INIT, "unknown asy_hwtype: %d", asy->asy_hwtype); return ("?"); } static boolean_t asy_is_devid(struct asycom *asy, char *venprop, char *devprop, int venid, int devid) { if (ddi_prop_get_int(DDI_DEV_T_ANY, asy->asy_dip, DDI_PROP_DONTPASS, venprop, 0) != venid) { return (B_FALSE); } if (ddi_prop_get_int(DDI_DEV_T_ANY, asy->asy_dip, DDI_PROP_DONTPASS, devprop, 0) != devid) { return (B_FALSE); } return (B_FALSE); } static void asy_check_loopback(struct asycom *asy) { if (asy_get_bus_type(asy->asy_dip) != ASY_BUS_PCI) return; /* Check if this is a Agere/Lucent Venus PCI modem chipset. */ if (asy_is_devid(asy, "vendor-id", "device-id", 0x11c1, 0x0480) || asy_is_devid(asy, "subsystem-vendor-id", "subsystem-id", 0x11c1, 0x0480)) asy->asy_flags2 |= ASY2_NO_LOOPBACK; } static int asy_identify_chip(dev_info_t *devi, struct asycom *asy) { int isr, lsr, mcr, spr; dev_t dev; uint_t hwtype; /* * Initially, we'll assume we have the highest supported chip model * until we find out what we actually have. */ asy->asy_hwtype = ASY_MAXCHIP; /* * First, see if we can even do the loopback check, which may not work * on certain hardware. */ asy_check_loopback(asy); if (asy_scr_test) { /* Check that the scratch register works. */ /* write to scratch register */ asy_put(asy, ASY_SPR, ASY_SPR_TEST); /* make sure that pattern doesn't just linger on the bus */ asy_put(asy, ASY_FCR, 0x00); /* read data back from scratch register */ spr = asy_get(asy, ASY_SPR); if (spr != ASY_SPR_TEST) { /* * Scratch register not working. * Probably not an async chip. * 8250 and 8250B don't have scratch registers, * but only worked in ancient PC XT's anyway. */ ASY_DPRINTF(asy, ASY_DEBUG_INIT, "UART @ %p " "scratch register: expected 0x5a, got 0x%02x", (void *)asy->asy_ioaddr, spr); return (DDI_FAILURE); } } /* * Use 16550 fifo reset sequence specified in NS application * note. Disable fifos until chip is initialized. */ asy_put(asy, ASY_FCR, 0x00); /* disable */ asy_put(asy, ASY_FCR, ASY_FCR_FIFO_EN); /* enable */ asy_put(asy, ASY_FCR, ASY_FCR_FIFO_EN | ASY_FCR_RHR_FL); /* reset */ if (asymaxchip >= ASY_16650 && asy_scr_test) { /* * Reset 16650 enhanced regs also, in case we have one of these */ asy_put(asy, ASY_EFR, 0); } /* * See what sort of FIFO we have. * Try enabling it and see what chip makes of this. */ asy->asy_fifor = 0; if (asymaxchip >= ASY_16550A) asy->asy_fifor |= ASY_FCR_FIFO_EN | ASY_FCR_DMA | (asy_trig_level & 0xff); /* * On the 16750, FCR[5] enables the 64 byte FIFO. FCR[5] can only be set * while LCR[7] = 1 (DLAB), which is taken care of by asy_reset_fifo(). */ if (asymaxchip >= ASY_16750) asy->asy_fifor |= ASY_FCR_FIFO64; asy_reset_fifo(asy, ASY_FCR_THR_FL | ASY_FCR_RHR_FL); mcr = asy_get(asy, ASY_MCR); isr = asy_get(asy, ASY_ISR); /* * Note we get 0xff if chip didn't return us anything, * e.g. if there's no chip there. */ if (isr == 0xff) { asyerror(asy, CE_WARN, "UART @ %p interrupt register: got 0xff", (void *)asy->asy_ioaddr); return (DDI_FAILURE); } ASY_DPRINTF(asy, ASY_DEBUG_CHIP, "probe fifo FIFOR=0x%02x ISR=0x%02x MCR=0x%02x", asy->asy_fifor | ASY_FCR_THR_FL | ASY_FCR_RHR_FL, isr, mcr); /* * Detect the chip type by comparing ISR[7,6] and ISR[5]. * * When the FIFOs are enabled by setting FCR[0], ISR[7,6] read as 1. * Additionally on a 16750, the 64 byte FIFOs are enabled by setting * FCR[5], and ISR[5] will read as 1, too. * * We will check later whether we have a 16650, which requires EFR[4]=1 * to enable its deeper FIFOs and extra features. It does not use FCR[5] * and ISR[5] to enable deeper FIFOs like the 16750 does. */ switch (isr & (ASY_ISR_FIFOEN | ASY_ISR_FIFO64)) { case 0x40: /* 16550 with broken FIFOs */ hwtype = ASY_16550; asy->asy_fifor = 0; break; case ASY_ISR_FIFOEN: /* 16550A with working FIFOs */ hwtype = ASY_16550A; asy->asy_fifo_buf = 16; asy->asy_use_fifo = ASY_FCR_FIFO_EN; asy->asy_fifor &= ~ASY_FCR_FIFO64; break; case ASY_ISR_FIFOEN | ASY_ISR_FIFO64: /* 16750 with 64byte FIFOs */ hwtype = ASY_16750; asy->asy_fifo_buf = 64; asy->asy_use_fifo = ASY_FCR_FIFO_EN; break; default: /* 8250A/16450 without FIFOs */ hwtype = ASY_8250A; asy->asy_fifor = 0; } if (hwtype > asymaxchip) { asyerror(asy, CE_WARN, "UART @ %p " "unexpected probe result: " "FCR=0x%02x ISR=0x%02x MCR=0x%02x", (void *)asy->asy_ioaddr, asy->asy_fifor | ASY_FCR_THR_FL | ASY_FCR_RHR_FL, isr, mcr); return (DDI_FAILURE); } /* * Now reset the FIFO operation appropriate for the chip type. * Note we must call asy_reset_fifo() before any possible * downgrade of the asy->asy_hwtype, or it may not disable * the more advanced features we specifically want downgraded. */ asy_reset_fifo(asy, 0); /* * Check for Exar/Startech ST16C650 or newer, which will still look like * a 16550A until we enable its enhanced mode. */ if (hwtype >= ASY_16550A && asymaxchip >= ASY_16650 && asy_scr_test) { /* * Write the XOFF2 register, which shadows SPR on the 16650. * On other chips, SPR will be overwritten. */ asy_put(asy, ASY_XOFF2, 0); /* read back scratch register */ spr = asy_get(asy, ASY_SPR); if (spr == ASY_SPR_TEST) { /* looks like we have an ST16650 -- enable it */ hwtype = ASY_16650; asy_put(asy, ASY_EFR, ASY_EFR_ENH_EN); /* * Some 16650-compatible chips are also compatible with * the 16750 and have deeper FIFOs, which we may have * detected above. Don't downgrade the FIFO size. */ if (asy->asy_fifo_buf < 32) asy->asy_fifo_buf = 32; /* * Use a 24 byte transmit FIFO trigger only if were * allowed to use >16 transmit FIFO depth by the * global tunable. */ if (asy_max_tx_fifo >= asy->asy_fifo_buf) asy->asy_fifor |= ASY_FCR_THR_TRIG_24; asy_reset_fifo(asy, 0); } } /* * If we think we got a 16650, we may actually have a 16950, so check * for that. */ if (hwtype >= ASY_16650 && asymaxchip >= ASY_16950) { uint8_t ier, asr; /* * First, clear IER and read it back. That should be a no-op as * either asyattach() or asy_resume() disabled all interrupts * before we were called. */ asy_put(asy, ASY_IER, 0); ier = asy_get(asy, ASY_IER); if (ier != 0) { dev_err(asy->asy_dip, CE_WARN, "!%s: UART @ %p " "interrupt enable register: got 0x%02x", __func__, (void *)asy->asy_ioaddr, ier); return (DDI_FAILURE); } /* * Next, try to read ASR, which shares the register offset with * IER. ASR can only be read if the ASR enable bit is set in * ACR, which itself is an indexed registers. This is taken care * of by asy_get(). * * There are a few bits in ASR which should be 1 at this point, * definitely the TX idle bit (ASR[7]) and also the FIFO size * bit (ASR[6]) since we've done everything we can to enable any * deeper FIFO support. * * Thus if we read back ASR as 0, we failed to read it, and this * isn't the chip we're looking for. */ asr = asy_get(asy, ASY_ASR); if (asr != ier) { hwtype = ASY_16950; if ((asr & ASY_ASR_FIFOSZ) != 0) asy->asy_fifo_buf = 128; else asy->asy_fifo_buf = 16; asy_reset_fifo(asy, 0); /* * Enable 16950 specific trigger level registers. Set * DTR pin to be compatible to 16450, 16550, and 16750. */ asy->asy_acr = ASY_ACR_TRIG | ASY_ACR_DTR_NORM; asy_put(asy, ASY_ACR, asy->asy_acr); /* Set half the FIFO size as receive trigger level. */ asy_put(asy, ASY_RTL, asy->asy_fifo_buf/2); /* * Set the transmit trigger level to 1. * * While one would expect that any transmit trigger * level would work (the 16550 uses a hardwired level * of 16), in my tests with a 16950 compatible chip * (MosChip 9912) I would never see a TX interrupt * on any transmit trigger level > 1. */ asy_put(asy, ASY_TTL, 1); ASY_DPRINTF(asy, ASY_DEBUG_CHIP, "ASR 0x%02x", asr); ASY_DPRINTF(asy, ASY_DEBUG_CHIP, "RFL 0x%02x", asy_get(asy, ASY_RFL)); ASY_DPRINTF(asy, ASY_DEBUG_CHIP, "TFL 0x%02x", asy_get(asy, ASY_TFL)); ASY_DPRINTF(asy, ASY_DEBUG_CHIP, "ACR 0x%02x", asy_get(asy, ASY_ACR)); ASY_DPRINTF(asy, ASY_DEBUG_CHIP, "CPR 0x%02x", asy_get(asy, ASY_CPR)); ASY_DPRINTF(asy, ASY_DEBUG_CHIP, "TCR 0x%02x", asy_get(asy, ASY_TCR)); ASY_DPRINTF(asy, ASY_DEBUG_CHIP, "CKS 0x%02x", asy_get(asy, ASY_CKS)); ASY_DPRINTF(asy, ASY_DEBUG_CHIP, "TTL 0x%02x", asy_get(asy, ASY_TTL)); ASY_DPRINTF(asy, ASY_DEBUG_CHIP, "RTL 0x%02x", asy_get(asy, ASY_RTL)); ASY_DPRINTF(asy, ASY_DEBUG_CHIP, "FCL 0x%02x", asy_get(asy, ASY_FCL)); ASY_DPRINTF(asy, ASY_DEBUG_CHIP, "FCH 0x%02x", asy_get(asy, ASY_FCH)); ASY_DPRINTF(asy, ASY_DEBUG_CHIP, "Chip ID: %02x%02x%02x,%02x", asy_get(asy, ASY_ID1), asy_get(asy, ASY_ID2), asy_get(asy, ASY_ID3), asy_get(asy, ASY_REV)); } } asy->asy_hwtype = hwtype; /* * If we think we might have a FIFO larger than 16 characters, * measure FIFO size and check it against expected. */ if (asy_fifo_test > 0 && !(asy->asy_flags2 & ASY2_NO_LOOPBACK) && (asy->asy_fifo_buf > 16 || (asy_fifo_test > 1 && asy->asy_use_fifo == ASY_FCR_FIFO_EN) || ASY_DEBUG(asy, ASY_DEBUG_CHIP))) { int i; /* Set baud rate to 57600 (fairly arbitrary choice) */ asy_set_baudrate(asy, B57600); /* Set 8 bits, 1 stop bit */ asy_put(asy, ASY_LCR, ASY_LCR_STOP1 | ASY_LCR_BITS8); /* Set loopback mode */ asy_put(asy, ASY_MCR, ASY_MCR_LOOPBACK); /* Overfill fifo */ for (i = 0; i < asy->asy_fifo_buf * 2; i++) { asy_put(asy, ASY_THR, i); } /* * Now there's an interesting question here about which * FIFO we're testing the size of, RX or TX. We just * filled the TX FIFO much faster than it can empty, * although it is possible one or two characters may * have gone from it to the TX shift register. * We wait for enough time for all the characters to * move into the RX FIFO and any excess characters to * have been lost, and then read all the RX FIFO. So * the answer we finally get will be the size which is * the MIN(RX FIFO,(TX FIFO + 1 or 2)). The critical * one is actually the TX FIFO, because if we overfill * it in normal operation, the excess characters are * lost with no warning. */ /* * Wait for characters to move into RX FIFO. * In theory, 200 * asy->asy_fifo_buf * 2 should be * enough. However, in practice it isn't always, so we * increase to 400 so some slow 16550A's finish, and we * increase to 3 so we spot more characters coming back * than we sent, in case that should ever happen. */ delay(drv_usectohz(400 * asy->asy_fifo_buf * 3)); /* Now see how many characters we can read back */ for (i = 0; i < asy->asy_fifo_buf * 3; i++) { lsr = asy_get(asy, ASY_LSR); if (!(lsr & ASY_LSR_DR)) break; /* FIFO emptied */ (void) asy_get(asy, ASY_RHR); /* lose another */ } ASY_DPRINTF(asy, ASY_DEBUG_CHIP, "FIFO size: expected=%d, measured=%d", asy->asy_fifo_buf, i); hwtype = asy->asy_hwtype; if (i < asy->asy_fifo_buf) { /* * FIFO is somewhat smaller than we anticipated. * If we have 16 characters usable, then this * UART will probably work well enough in * 16550A mode. If less than 16 characters, * then we'd better not use it at all. * UARTs with busted FIFOs do crop up. */ if (i >= 16 && asy->asy_fifo_buf >= 16) { /* fall back to a 16550A */ hwtype = ASY_16550A; asy->asy_fifo_buf = 16; asy->asy_fifor &= ~(ASY_FCR_THR_TR0 | ASY_FCR_THR_TR1); } else { /* fall back to no FIFO at all */ hwtype = ASY_16550; asy->asy_fifo_buf = 1; asy->asy_use_fifo = ASY_FCR_FIFO_OFF; asy->asy_fifor = 0; } } else if (i > asy->asy_fifo_buf) { /* * The FIFO is larger than expected. Use it if it is * a power of 2. */ if (ISP2(i)) asy->asy_fifo_buf = i; } /* * We will need to reprogram the FIFO if we changed * our mind about how to drive it above, and in any * case, it would be a good idea to flush any garbage * out incase the loopback test left anything behind. * Again as earlier above, we must call asy_reset_fifo() * before any possible downgrade of asy->asy_hwtype. */ if (asy->asy_hwtype >= ASY_16650 && hwtype < ASY_16650) { /* Disable 16650 enhanced mode */ asy_put(asy, ASY_EFR, 0); } asy_reset_fifo(asy, ASY_FCR_THR_FL | ASY_FCR_RHR_FL); asy->asy_hwtype = hwtype; /* Clear loopback mode and restore DTR/RTS */ asy_put(asy, ASY_MCR, mcr); } ASY_DPRINTF(asy, ASY_DEBUG_CHIP, "%s @ %p", asy_hw_name(asy), (void *)asy->asy_ioaddr); /* Make UART type visible in device tree for prtconf, etc */ dev = makedevice(DDI_MAJOR_T_UNKNOWN, asy->asy_unit); (void) ddi_prop_update_string(dev, devi, "uart", asy_hw_name(asy)); if (asy->asy_hwtype == ASY_16550) /* for broken 16550's, */ asy->asy_hwtype = ASY_8250A; /* drive them as 8250A */ return (DDI_SUCCESS); } /* * asyinit() initializes the TTY protocol-private data for this channel * before enabling the interrupts. */ static void asyinit(struct asycom *asy) { struct asyncline *async; asy->asy_priv = kmem_zalloc(sizeof (struct asyncline), KM_SLEEP); async = asy->asy_priv; mutex_enter(&asy->asy_excl); async->async_common = asy; cv_init(&async->async_flags_cv, NULL, CV_DRIVER, NULL); mutex_exit(&asy->asy_excl); } static int asyopen(queue_t *rq, dev_t *dev, int flag, int sflag __unused, cred_t *cr) { struct asycom *asy; struct asyncline *async; int unit; int len; struct termios *termiosp; unit = UNIT(*dev); asy = ddi_get_soft_state(asy_soft_state, unit); if (asy == NULL) return (ENXIO); /* unit not configured */ ASY_DPRINTF(asy, ASY_DEBUG_INIT, "enter"); async = asy->asy_priv; mutex_enter(&asy->asy_excl); again: mutex_enter(&asy->asy_excl_hi); /* * Block waiting for carrier to come up, unless this is a no-delay open. */ if (!(async->async_flags & ASYNC_ISOPEN)) { /* * Set the default termios settings (cflag). * Others are set in ldterm. */ mutex_exit(&asy->asy_excl_hi); if (ddi_getlongprop(DDI_DEV_T_ANY, ddi_root_node(), 0, "ttymodes", (caddr_t)&termiosp, &len) == DDI_PROP_SUCCESS && len == sizeof (struct termios)) { async->async_ttycommon.t_cflag = termiosp->c_cflag; kmem_free(termiosp, len); } else { asyerror(asy, CE_WARN, "couldn't get ttymodes property"); } mutex_enter(&asy->asy_excl_hi); /* eeprom mode support - respect properties */ if (asy->asy_cflag) async->async_ttycommon.t_cflag = asy->asy_cflag; async->async_ttycommon.t_iflag = 0; async->async_ttycommon.t_iocpending = NULL; async->async_ttycommon.t_size.ws_row = 0; async->async_ttycommon.t_size.ws_col = 0; async->async_ttycommon.t_size.ws_xpixel = 0; async->async_ttycommon.t_size.ws_ypixel = 0; async->async_dev = *dev; async->async_wbufcid = 0; async->async_startc = CSTART; async->async_stopc = CSTOP; asy_program(asy, ASY_INIT); } else if ((async->async_ttycommon.t_flags & TS_XCLUDE) && secpolicy_excl_open(cr) != 0) { mutex_exit(&asy->asy_excl_hi); mutex_exit(&asy->asy_excl); return (EBUSY); } else if ((*dev & OUTLINE) && !(async->async_flags & ASYNC_OUT)) { mutex_exit(&asy->asy_excl_hi); mutex_exit(&asy->asy_excl); return (EBUSY); } if (*dev & OUTLINE) async->async_flags |= ASYNC_OUT; /* Raise DTR on every open, but delay if it was just lowered. */ while (async->async_flags & ASYNC_DTR_DELAY) { ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "waiting for the ASYNC_DTR_DELAY to be clear"); mutex_exit(&asy->asy_excl_hi); if (cv_wait_sig(&async->async_flags_cv, &asy->asy_excl) == 0) { ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "interrupted by signal, exiting"); mutex_exit(&asy->asy_excl); return (EINTR); } mutex_enter(&asy->asy_excl_hi); } asy_set(asy, ASY_MCR, asy->asy_mcr & ASY_MCR_DTR); ASY_DPRINTF(asy, ASY_DEBUG_INIT, "\"Raise DTR on every open\": " "make mcr = %x, make TS_SOFTCAR = %s", asy_get(asy, ASY_MCR), (asy->asy_flags & ASY_IGNORE_CD) ? "ON" : "OFF"); if (asy->asy_flags & ASY_IGNORE_CD) { ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "ASY_IGNORE_CD set, set TS_SOFTCAR"); async->async_ttycommon.t_flags |= TS_SOFTCAR; } else { async->async_ttycommon.t_flags &= ~TS_SOFTCAR; } /* * Check carrier. */ asy->asy_msr = asy_get(asy, ASY_MSR); ASY_DPRINTF(asy, ASY_DEBUG_INIT, "TS_SOFTCAR is %s, MSR & DCD is %s", (async->async_ttycommon.t_flags & TS_SOFTCAR) ? "set" : "clear", (asy->asy_msr & ASY_MSR_DCD) ? "set" : "clear"); if (asy->asy_msr & ASY_MSR_DCD) async->async_flags |= ASYNC_CARR_ON; else async->async_flags &= ~ASYNC_CARR_ON; mutex_exit(&asy->asy_excl_hi); /* * If FNDELAY and FNONBLOCK are clear, block until carrier up. * Quit on interrupt. */ if (!(flag & (FNDELAY|FNONBLOCK)) && !(async->async_ttycommon.t_cflag & CLOCAL)) { if ((!(async->async_flags & (ASYNC_CARR_ON|ASYNC_OUT)) && !(async->async_ttycommon.t_flags & TS_SOFTCAR)) || ((async->async_flags & ASYNC_OUT) && !(*dev & OUTLINE))) { async->async_flags |= ASYNC_WOPEN; if (cv_wait_sig(&async->async_flags_cv, &asy->asy_excl) == B_FALSE) { async->async_flags &= ~ASYNC_WOPEN; mutex_exit(&asy->asy_excl); return (EINTR); } async->async_flags &= ~ASYNC_WOPEN; goto again; } } else if ((async->async_flags & ASYNC_OUT) && !(*dev & OUTLINE)) { mutex_exit(&asy->asy_excl); return (EBUSY); } async->async_ttycommon.t_readq = rq; async->async_ttycommon.t_writeq = WR(rq); rq->q_ptr = WR(rq)->q_ptr = (caddr_t)async; mutex_exit(&asy->asy_excl); /* * Caution here -- qprocson sets the pointers that are used by canput * called by async_softint. ASYNC_ISOPEN must *not* be set until those * pointers are valid. */ qprocson(rq); async->async_flags |= ASYNC_ISOPEN; async->async_polltid = 0; ASY_DPRINTF(asy, ASY_DEBUG_INIT, "done"); return (0); } static void async_progress_check(void *arg) { struct asyncline *async = arg; struct asycom *asy = async->async_common; mblk_t *bp; /* * We define "progress" as either waiting on a timed break or delay, or * having had at least one transmitter interrupt. If none of these are * true, then just terminate the output and wake up that close thread. */ mutex_enter(&asy->asy_excl); mutex_enter(&asy->asy_excl_hi); if (!(async->async_flags & (ASYNC_BREAK|ASYNC_DELAY|ASYNC_PROGRESS))) { async->async_ocnt = 0; async->async_flags &= ~ASYNC_BUSY; async->async_timer = 0; bp = async->async_xmitblk; async->async_xmitblk = NULL; mutex_exit(&asy->asy_excl_hi); if (bp != NULL) freeb(bp); /* * Since this timer is running, we know that we're in exit(2). * That means that the user can't possibly be waiting on any * valid ioctl(2) completion anymore, and we should just flush * everything. */ flushq(async->async_ttycommon.t_writeq, FLUSHALL); cv_broadcast(&async->async_flags_cv); } else { async->async_flags &= ~ASYNC_PROGRESS; async->async_timer = timeout(async_progress_check, async, drv_usectohz(asy_drain_check)); mutex_exit(&asy->asy_excl_hi); } mutex_exit(&asy->asy_excl); } /* * Release DTR so that asyopen() can raise it. */ static void async_dtr_free(struct asyncline *async) { struct asycom *asy = async->async_common; ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "async_dtr_free, clearing ASYNC_DTR_DELAY"); mutex_enter(&asy->asy_excl); async->async_flags &= ~ASYNC_DTR_DELAY; async->async_dtrtid = 0; cv_broadcast(&async->async_flags_cv); mutex_exit(&asy->asy_excl); } /* * Close routine. */ static int asyclose(queue_t *q, int flag, cred_t *credp __unused) { struct asyncline *async; struct asycom *asy; async = (struct asyncline *)q->q_ptr; ASSERT(async != NULL); asy = async->async_common; ASY_DPRINTF(asy, ASY_DEBUG_CLOSE, "enter"); mutex_enter(&asy->asy_excl); async->async_flags |= ASYNC_CLOSING; /* * Turn off PPS handling early to avoid events occuring during * close. Also reset the DCD edge monitoring bit. */ mutex_enter(&asy->asy_excl_hi); asy->asy_flags &= ~(ASY_PPS | ASY_PPS_EDGE); mutex_exit(&asy->asy_excl_hi); /* * There are two flavors of break -- timed (M_BREAK or TCSBRK) and * untimed (TIOCSBRK). For the timed case, these are enqueued on our * write queue and there's a timer running, so we don't have to worry * about them. For the untimed case, though, the user obviously made a * mistake, because these are handled immediately. We'll terminate the * break now and honor their implicit request by discarding the rest of * the data. */ if (async->async_flags & ASYNC_OUT_SUSPEND) { if (async->async_utbrktid != 0) { (void) untimeout(async->async_utbrktid); async->async_utbrktid = 0; } mutex_enter(&asy->asy_excl_hi); (void) asy_clr(asy, ASY_LCR, ASY_LCR_SETBRK); mutex_exit(&asy->asy_excl_hi); async->async_flags &= ~ASYNC_OUT_SUSPEND; goto nodrain; } /* * If the user told us not to delay the close ("non-blocking"), then * don't bother trying to drain. * * If the user did M_STOP (ASYNC_STOPPED), there's no hope of ever * getting an M_START (since these messages aren't enqueued), and the * only other way to clear the stop condition is by loss of DCD, which * would discard the queue data. Thus, we drop the output data if * ASYNC_STOPPED is set. */ if ((flag & (FNDELAY|FNONBLOCK)) || (async->async_flags & ASYNC_STOPPED)) { goto nodrain; } /* * If there's any pending output, then we have to try to drain it. * There are two main cases to be handled: * - called by close(2): need to drain until done or until * a signal is received. No timeout. * - called by exit(2): need to drain while making progress * or until a timeout occurs. No signals. * * If we can't rely on receiving a signal to get us out of a hung * session, then we have to use a timer. In this case, we set a timer * to check for progress in sending the output data -- all that we ask * (at each interval) is that there's been some progress made. Since * the interrupt routine grabs buffers from the write queue, we can't * trust changes in async_ocnt. Instead, we use a progress flag. * * Note that loss of carrier will cause the output queue to be flushed, * and we'll wake up again and finish normally. */ if (!ddi_can_receive_sig() && asy_drain_check != 0) { async->async_flags &= ~ASYNC_PROGRESS; async->async_timer = timeout(async_progress_check, async, drv_usectohz(asy_drain_check)); } while (async->async_ocnt > 0 || async->async_ttycommon.t_writeq->q_first != NULL || (async->async_flags & (ASYNC_BUSY|ASYNC_BREAK|ASYNC_DELAY))) { if (cv_wait_sig(&async->async_flags_cv, &asy->asy_excl) == 0) break; } if (async->async_timer != 0) { (void) untimeout(async->async_timer); async->async_timer = 0; } nodrain: async->async_ocnt = 0; if (async->async_xmitblk != NULL) freeb(async->async_xmitblk); async->async_xmitblk = NULL; /* * If line has HUPCL set or is incompletely opened fix up the modem * lines. */ ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "next check HUPCL flag"); mutex_enter(&asy->asy_excl_hi); if ((async->async_ttycommon.t_cflag & HUPCL) || (async->async_flags & ASYNC_WOPEN)) { ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "HUPCL flag = %x, ASYNC_WOPEN flag = %x", async->async_ttycommon.t_cflag & HUPCL, async->async_ttycommon.t_cflag & ASYNC_WOPEN); async->async_flags |= ASYNC_DTR_DELAY; /* turn off DTR, RTS but NOT interrupt to 386 */ if (asy->asy_flags & (ASY_IGNORE_CD|ASY_RTS_DTR_OFF)) { ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "ASY_IGNORE_CD flag = %x, " "ASY_RTS_DTR_OFF flag = %x", asy->asy_flags & ASY_IGNORE_CD, asy->asy_flags & ASY_RTS_DTR_OFF); asy_put(asy, ASY_MCR, asy->asy_mcr | ASY_MCR_OUT2); } else { ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "Dropping DTR and RTS"); asy_put(asy, ASY_MCR, ASY_MCR_OUT2); } async->async_dtrtid = timeout((void (*)())async_dtr_free, (caddr_t)async, drv_usectohz(asy_min_dtr_low)); } /* * If nobody's using it now, turn off receiver interrupts. */ if ((async->async_flags & (ASYNC_WOPEN|ASYNC_ISOPEN)) == 0) asy_disable_interrupts(asy, ASY_IER_RIEN); mutex_exit(&asy->asy_excl_hi); ttycommon_close(&async->async_ttycommon); /* * Cancel outstanding "bufcall" request. */ if (async->async_wbufcid != 0) { unbufcall(async->async_wbufcid); async->async_wbufcid = 0; } /* Note that qprocsoff can't be done until after interrupts are off */ qprocsoff(q); q->q_ptr = WR(q)->q_ptr = NULL; async->async_ttycommon.t_readq = NULL; async->async_ttycommon.t_writeq = NULL; /* * Clear out device state, except persistant device property flags. */ async->async_flags &= (ASYNC_DTR_DELAY|ASY_RTS_DTR_OFF); cv_broadcast(&async->async_flags_cv); mutex_exit(&asy->asy_excl); ASY_DPRINTF(asy, ASY_DEBUG_CLOSE, "done"); return (0); } static boolean_t asy_isbusy(struct asycom *asy) { struct asyncline *async; ASY_DPRINTF(asy, ASY_DEBUG_EOT, "enter"); async = asy->asy_priv; ASSERT(mutex_owned(&asy->asy_excl)); ASSERT(mutex_owned(&asy->asy_excl_hi)); /* * XXXX this should be recoded */ return ((async->async_ocnt > 0) || ((asy_get(asy, ASY_LSR) & (ASY_LSR_TEMT | ASY_LSR_THRE)) == 0)); } static void asy_waiteot(struct asycom *asy) { /* * Wait for the current transmission block and the * current fifo data to transmit. Once this is done * we may go on. */ ASY_DPRINTF(asy, ASY_DEBUG_EOT, "enter"); ASSERT(mutex_owned(&asy->asy_excl)); ASSERT(mutex_owned(&asy->asy_excl_hi)); while (asy_isbusy(asy)) { mutex_exit(&asy->asy_excl_hi); mutex_exit(&asy->asy_excl); drv_usecwait(10000); /* wait .01 */ mutex_enter(&asy->asy_excl); mutex_enter(&asy->asy_excl_hi); } } /* asy_reset_fifo -- flush fifos and [re]program fifo control register */ static void asy_reset_fifo(struct asycom *asy, uchar_t flush) { ASSERT(mutex_owned(&asy->asy_excl_hi)); /* On a 16750, we have to set DLAB in order to set ASY_FCR_FIFO64. */ if (asy->asy_hwtype >= ASY_16750) asy_set(asy, ASY_LCR, ASY_LCR_DLAB); asy_put(asy, ASY_FCR, asy->asy_fifor | flush); /* Clear DLAB */ if (asy->asy_hwtype >= ASY_16750) asy_clr(asy, ASY_LCR, ASY_LCR_DLAB); } /* * Program the ASY port. Most of the async operation is based on the values * of 'c_iflag' and 'c_cflag'. */ static void asy_program(struct asycom *asy, int mode) { struct asyncline *async; int baudrate, c_flag; uint8_t ier; int flush_reg; int ocflags; ASSERT(mutex_owned(&asy->asy_excl)); ASSERT(mutex_owned(&asy->asy_excl_hi)); async = asy->asy_priv; ASY_DPRINTF(asy, ASY_DEBUG_PROCS, "mode = 0x%08X, enter", mode); baudrate = BAUDINDEX(async->async_ttycommon.t_cflag); async->async_ttycommon.t_cflag &= ~(CIBAUD); if (baudrate > CBAUD) { async->async_ttycommon.t_cflag |= CIBAUDEXT; async->async_ttycommon.t_cflag |= (((baudrate - CBAUD - 1) << IBSHIFT) & CIBAUD); } else { async->async_ttycommon.t_cflag &= ~CIBAUDEXT; async->async_ttycommon.t_cflag |= ((baudrate << IBSHIFT) & CIBAUD); } c_flag = async->async_ttycommon.t_cflag & (CLOCAL|CREAD|CSTOPB|CSIZE|PARENB|PARODD|CBAUD|CBAUDEXT); asy_disable_interrupts(asy, ASY_IER_ALL); ocflags = asy->asy_ocflag; /* flush/reset the status registers */ (void) asy_get(asy, ASY_ISR); (void) asy_get(asy, ASY_LSR); asy->asy_msr = flush_reg = asy_get(asy, ASY_MSR); /* * The device is programmed in the open sequence, if we * have to hardware handshake, then this is a good time * to check if the device can receive any data. */ if ((CRTSCTS & async->async_ttycommon.t_cflag) && !(flush_reg & ASY_MSR_CTS)) { async_flowcontrol_hw_output(asy, FLOW_STOP); } else { /* * We can not use async_flowcontrol_hw_output(asy, FLOW_START) * here, because if CRTSCTS is clear, we need clear * ASYNC_HW_OUT_FLW bit. */ async->async_flags &= ~ASYNC_HW_OUT_FLW; } /* * If IXON is not set, clear ASYNC_SW_OUT_FLW; * If IXON is set, no matter what IXON flag is before this * function call to asy_program, * we will use the old ASYNC_SW_OUT_FLW status. * Because of handling IXON in the driver, we also should re-calculate * the value of ASYNC_OUT_FLW_RESUME bit, but in fact, * the TCSET* commands which call asy_program * are put into the write queue, so there is no output needed to * be resumed at this point. */ if (!(IXON & async->async_ttycommon.t_iflag)) async->async_flags &= ~ASYNC_SW_OUT_FLW; /* manually flush receive buffer or fifo (workaround for buggy fifos) */ if (mode == ASY_INIT) { if (asy->asy_use_fifo == ASY_FCR_FIFO_EN) { for (flush_reg = asy->asy_fifo_buf; flush_reg-- > 0; ) { (void) asy_get(asy, ASY_RHR); } } else { flush_reg = asy_get(asy, ASY_RHR); } } if (ocflags != (c_flag & ~CLOCAL) || mode == ASY_INIT) { /* Set line control */ uint8_t lcr = 0; if (c_flag & CSTOPB) lcr |= ASY_LCR_STOP2; /* 2 stop bits */ if (c_flag & PARENB) lcr |= ASY_LCR_PEN; if ((c_flag & PARODD) == 0) lcr |= ASY_LCR_EPS; switch (c_flag & CSIZE) { case CS5: lcr |= ASY_LCR_BITS5; break; case CS6: lcr |= ASY_LCR_BITS6; break; case CS7: lcr |= ASY_LCR_BITS7; break; case CS8: lcr |= ASY_LCR_BITS8; break; } asy_clr(asy, ASY_LCR, ASY_LCR_WLS0 | ASY_LCR_WLS1 | ASY_LCR_STB | ASY_LCR_PEN | ASY_LCR_EPS); asy_set(asy, ASY_LCR, lcr); asy_set_baudrate(asy, baudrate); /* * If we have a FIFO buffer, enable/flush * at intialize time, flush if transitioning from * CREAD off to CREAD on. */ if (((ocflags & CREAD) == 0 && (c_flag & CREAD)) || mode == ASY_INIT) { if (asy->asy_use_fifo == ASY_FCR_FIFO_EN) asy_reset_fifo(asy, ASY_FCR_RHR_FL); } /* remember the new cflags */ asy->asy_ocflag = c_flag & ~CLOCAL; } if (baudrate == 0) asy_put(asy, ASY_MCR, (asy->asy_mcr & ASY_MCR_RTS) | ASY_MCR_OUT2); else asy_put(asy, ASY_MCR, asy->asy_mcr | ASY_MCR_OUT2); /* * Call the modem status interrupt handler to check for the carrier * in case CLOCAL was turned off after the carrier came on. * (Note: Modem status interrupt is not enabled if CLOCAL is ON.) */ async_msint(asy); /* Set interrupt control */ ASY_DPRINTF(asy, ASY_DEBUG_MODM2, "c_flag & CLOCAL = %x t_cflag & CRTSCTS = %x", c_flag & CLOCAL, async->async_ttycommon.t_cflag & CRTSCTS); /* Always enable transmit and line status interrupts. */ ier = ASY_IER_TIEN | ASY_IER_SIEN; /* * Enable Modem status interrupt if hardware flow control is enabled or * this isn't a direct-wired (local) line, which ignores DCD. */ if (((c_flag & CLOCAL) == 0) || (async->async_ttycommon.t_cflag & CRTSCTS)) ier |= ASY_IER_MIEN; if (c_flag & CREAD) ier |= ASY_IER_RIEN; asy_enable_interrupts(asy, ier); ASY_DPRINTF(asy, ASY_DEBUG_PROCS, "done"); } static boolean_t asy_baudok(struct asycom *asy) { struct asyncline *async = asy->asy_priv; int baudrate; baudrate = BAUDINDEX(async->async_ttycommon.t_cflag); if (baudrate >= ARRAY_SIZE(asy_baud_tab)) return (0); return (baudrate == 0 || asy_baud_tab[baudrate].asy_dll != 0 || asy_baud_tab[baudrate].asy_dlh != 0); } /* * asyintr() is the High Level Interrupt Handler. * * There are four different interrupt types indexed by ISR register values: * 0: modem * 1: Tx holding register is empty, ready for next char * 2: Rx register now holds a char to be picked up * 3: error or break on line * This routine checks the Bit 0 (interrupt-not-pending) to determine if * the interrupt is from this port. */ uint_t asyintr(caddr_t argasy, caddr_t argunused __unused) { struct asycom *asy = (struct asycom *)argasy; struct asyncline *async; int ret_status = DDI_INTR_UNCLAIMED; mutex_enter(&asy->asy_excl_hi); async = asy->asy_priv; if (async == NULL || (async->async_flags & (ASYNC_ISOPEN|ASYNC_WOPEN)) == 0) { const uint8_t intr_id = asy_get(asy, ASY_ISR); ASY_DPRINTF(asy, ASY_DEBUG_INTR, "not open async=%p flags=0x%x interrupt_id=0x%x", async, async == NULL ? 0 : async->async_flags, intr_id); if ((intr_id & ASY_ISR_NOINTR) == 0) { /* * reset the device by: * reading line status * reading any data from data status register * reading modem status */ (void) asy_get(asy, ASY_LSR); (void) asy_get(asy, ASY_RHR); asy->asy_msr = asy_get(asy, ASY_MSR); ret_status = DDI_INTR_CLAIMED; } mutex_exit(&asy->asy_excl_hi); return (ret_status); } /* By this point we're sure this is for us. */ ret_status = DDI_INTR_CLAIMED; /* * Before this flag was set, interrupts were disabled. We may still get * here if asyintr() waited on the mutex. */ if (asy->asy_flags & ASY_DDI_SUSPENDED) { mutex_exit(&asy->asy_excl_hi); return (ret_status); } /* * We will loop until the interrupt line is pulled low. asy * interrupt is edge triggered. */ for (;;) { const uint8_t intr_id = asy_get(asy, ASY_ISR); /* * Reading LSR will clear any error bits (ASY_LSR_ERRORS) which * are set which is why the value is passed through to * async_rxint() and not re-read there. In the unexpected event * that we've ended up here without a pending interrupt, the * ASY_ISR_NOINTR case, it should do no harm to have cleared * the error bits, and it means we can get some additional * information in the debug message if it's enabled. */ const uint8_t lsr = asy_get(asy, ASY_LSR); ASY_DPRINTF(asy, ASY_DEBUG_INTR, "interrupt_id=0x%x LSR=0x%x", intr_id, lsr); if (intr_id & ASY_ISR_NOINTR) break; switch (intr_id & ASY_ISR_MASK) { case ASY_ISR_ID_RLST: case ASY_ISR_ID_RDA: case ASY_ISR_ID_TMO: /* receiver interrupt or receiver errors */ async_rxint(asy, lsr); break; case ASY_ISR_ID_THRE: /* * The transmit-ready interrupt implies an empty * transmit-hold register (or FIFO). Check that it is * present before attempting to transmit more data. */ if ((lsr & ASY_LSR_THRE) == 0) { /* * Taking a THRE interrupt only to find THRE * absent would be a surprise, except for a * racing asyputchar(), which ignores the * excl_hi mutex when writing to the device. */ continue; } async_txint(asy); /* * Unlike the other interrupts which fall through to * attempting to fill the output register/FIFO, THRE * has no need having just done so. */ continue; case ASY_ISR_ID_MST: /* modem status interrupt */ async_msint(asy); break; } /* Refill the output FIFO if it has gone empty */ if ((lsr & ASY_LSR_THRE) && (async->async_flags & ASYNC_BUSY) && async->async_ocnt > 0) async_txint(asy); } mutex_exit(&asy->asy_excl_hi); return (ret_status); } /* * Transmitter interrupt service routine. * If there is more data to transmit in the current pseudo-DMA block, * send the next character if output is not stopped or draining. * Otherwise, queue up a soft interrupt. * * XXX - Needs review for HW FIFOs. */ static void async_txint(struct asycom *asy) { struct asyncline *async = asy->asy_priv; int fifo_len; ASSERT(MUTEX_HELD(&asy->asy_excl_hi)); /* * If ASYNC_BREAK or ASYNC_OUT_SUSPEND has been set, return to * asyintr()'s context to claim the interrupt without performing * any action. No character will be loaded into FIFO/THR until * timed or untimed break is removed */ if (async->async_flags & (ASYNC_BREAK|ASYNC_OUT_SUSPEND)) return; fifo_len = asy->asy_fifo_buf; /* with FIFO buffers */ if (fifo_len > asy_max_tx_fifo) fifo_len = asy_max_tx_fifo; if (async_flowcontrol_sw_input(asy, FLOW_CHECK, IN_FLOW_NULL)) fifo_len--; if (async->async_ocnt > 0 && fifo_len > 0 && !(async->async_flags & (ASYNC_HW_OUT_FLW|ASYNC_SW_OUT_FLW|ASYNC_STOPPED))) { while (fifo_len-- > 0 && async->async_ocnt-- > 0) { asy_put(asy, ASY_THR, *async->async_optr++); } async->async_flags |= ASYNC_PROGRESS; } if (fifo_len <= 0) return; asysetsoft(asy); } /* * Interrupt on port: handle PPS event. This function is only called * for a port on which PPS event handling has been enabled. */ static void asy_ppsevent(struct asycom *asy, int msr) { ASSERT(MUTEX_HELD(&asy->asy_excl_hi)); if (asy->asy_flags & ASY_PPS_EDGE) { /* Have seen leading edge, now look for and record drop */ if ((msr & ASY_MSR_DCD) == 0) asy->asy_flags &= ~ASY_PPS_EDGE; /* * Waiting for leading edge, look for rise; stamp event and * calibrate kernel clock. */ } else if (msr & ASY_MSR_DCD) { /* * This code captures a timestamp at the designated * transition of the PPS signal (DCD asserted). The * code provides a pointer to the timestamp, as well * as the hardware counter value at the capture. * * Note: the kernel has nano based time values while * NTP requires micro based, an in-line fast algorithm * to convert nsec to usec is used here -- see hrt2ts() * in common/os/timers.c for a full description. */ struct timeval *tvp = &asy_ppsev.tv; timestruc_t ts; long nsec, usec; asy->asy_flags |= ASY_PPS_EDGE; LED_OFF; gethrestime(&ts); LED_ON; nsec = ts.tv_nsec; usec = nsec + (nsec >> 2); usec = nsec + (usec >> 1); usec = nsec + (usec >> 2); usec = nsec + (usec >> 4); usec = nsec - (usec >> 3); usec = nsec + (usec >> 2); usec = nsec + (usec >> 3); usec = nsec + (usec >> 4); usec = nsec + (usec >> 1); usec = nsec + (usec >> 6); tvp->tv_usec = usec >> 10; tvp->tv_sec = ts.tv_sec; ++asy_ppsev.serial; /* * Because the kernel keeps a high-resolution time, * pass the current highres timestamp in tvp and zero * in usec. */ ddi_hardpps(tvp, 0); } } /* * Receiver interrupt: RDA interrupt, FIFO timeout interrupt or receive * error interrupt. * Try to put the character into the circular buffer for this line; if it * overflows, indicate a circular buffer overrun. If this port is always * to be serviced immediately, or the character is a STOP character, or * more than 15 characters have arrived, queue up a soft interrupt to * drain the circular buffer. * XXX - needs review for hw FIFOs support. */ static void async_rxint(struct asycom *asy, uchar_t lsr) { struct asyncline *async = asy->asy_priv; uchar_t c; uint_t s, needsoft = 0; tty_common_t *tp; int looplim = asy->asy_fifo_buf * 2; ASSERT(MUTEX_HELD(&asy->asy_excl_hi)); tp = &async->async_ttycommon; if (!(tp->t_cflag & CREAD)) { /* Line is not open for reading. Flush receiver FIFO. */ while ((lsr & (ASY_LSR_DR | ASY_LSR_ERRORS)) != 0) { (void) asy_get(asy, ASY_RHR); lsr = asy_get(asy, ASY_LSR); if (looplim-- < 0) /* limit loop */ break; } return; } while ((lsr & (ASY_LSR_DR | ASY_LSR_ERRORS)) != 0) { c = 0; s = 0; /* reset error status */ if (lsr & ASY_LSR_DR) { c = asy_get(asy, ASY_RHR); /* * We handle XON/XOFF char if IXON is set, * but if received char is _POSIX_VDISABLE, * we left it to the up level module. */ if (tp->t_iflag & IXON) { if ((c == async->async_stopc) && (c != _POSIX_VDISABLE)) { async_flowcontrol_sw_output(asy, FLOW_STOP); goto check_looplim; } else if ((c == async->async_startc) && (c != _POSIX_VDISABLE)) { async_flowcontrol_sw_output(asy, FLOW_START); needsoft = 1; goto check_looplim; } if ((tp->t_iflag & IXANY) && (async->async_flags & ASYNC_SW_OUT_FLW)) { async_flowcontrol_sw_output(asy, FLOW_START); needsoft = 1; } } } /* * Check for character break sequence */ if ((abort_enable == KIOCABORTALTERNATE) && (asy->asy_flags & ASY_CONSOLE)) { if (abort_charseq_recognize(c)) abort_sequence_enter((char *)NULL); } /* Handle framing errors */ if (lsr & ASY_LSR_ERRORS) { if (lsr & ASY_LSR_PE) { if (tp->t_iflag & INPCK) /* parity enabled */ s |= PERROR; } if (lsr & (ASY_LSR_FE | ASY_LSR_BI)) s |= FRERROR; if (lsr & ASY_LSR_OE) { async->async_hw_overrun = 1; s |= OVERRUN; } } if (s == 0) if ((tp->t_iflag & PARMRK) && !(tp->t_iflag & (IGNPAR|ISTRIP)) && (c == 0377)) if (RING_POK(async, 2)) { RING_PUT(async, 0377); RING_PUT(async, c); } else async->async_sw_overrun = 1; else if (RING_POK(async, 1)) RING_PUT(async, c); else async->async_sw_overrun = 1; else if (s & FRERROR) /* Handle framing errors */ if (c == 0) if ((asy->asy_flags & ASY_CONSOLE) && (abort_enable != KIOCABORTALTERNATE)) abort_sequence_enter((char *)0); else async->async_break++; else if (RING_POK(async, 1)) RING_MARK(async, c, s); else async->async_sw_overrun = 1; else /* Parity errors are handled by ldterm */ if (RING_POK(async, 1)) RING_MARK(async, c, s); else async->async_sw_overrun = 1; check_looplim: lsr = asy_get(asy, ASY_LSR); if (looplim-- < 0) /* limit loop */ break; } if ((RING_CNT(async) > (RINGSIZE * 3)/4) && !(async->async_inflow_source & IN_FLOW_RINGBUFF)) { async_flowcontrol_hw_input(asy, FLOW_STOP, IN_FLOW_RINGBUFF); (void) async_flowcontrol_sw_input(asy, FLOW_STOP, IN_FLOW_RINGBUFF); } if ((async->async_flags & ASYNC_SERVICEIMM) || needsoft || (RING_FRAC(async)) || (async->async_polltid == 0)) { asysetsoft(asy); /* need a soft interrupt */ } } /* * Modem status interrupt. * * (Note: It is assumed that the MSR hasn't been read by asyintr().) */ static void async_msint(struct asycom *asy) { struct asyncline *async = asy->asy_priv; int msr, t_cflag = async->async_ttycommon.t_cflag; ASSERT(MUTEX_HELD(&asy->asy_excl_hi)); async_msint_retry: /* this resets the interrupt */ msr = asy_get(asy, ASY_MSR); ASY_DPRINTF(asy, ASY_DEBUG_STATE, "call #%d:", ++(asy->asy_msint_cnt)); ASY_DPRINTF(asy, ASY_DEBUG_STATE, " transition: %3s %3s %3s %3s", (msr & ASY_MSR_DCTS) ? "DCTS" : " ", (msr & ASY_MSR_DDSR) ? "DDSR" : " ", (msr & ASY_MSR_TERI) ? "TERI" : " ", (msr & ASY_MSR_DDCD) ? "DDCD" : " "); ASY_DPRINTF(asy, ASY_DEBUG_STATE, "current state: %3s %3s %3s %3s", (msr & ASY_MSR_CTS) ? "CTS " : " ", (msr & ASY_MSR_DSR) ? "DSR " : " ", (msr & ASY_MSR_RI) ? "RI " : " ", (msr & ASY_MSR_DCD) ? "DCD " : " "); /* If CTS status is changed, do H/W output flow control */ if ((t_cflag & CRTSCTS) && (((asy->asy_msr ^ msr) & ASY_MSR_CTS) != 0)) async_flowcontrol_hw_output(asy, msr & ASY_MSR_CTS ? FLOW_START : FLOW_STOP); /* * Reading MSR resets the interrupt, we save the * value of msr so that other functions could examine MSR by * looking at asy_msr. */ asy->asy_msr = (uchar_t)msr; /* Handle PPS event */ if (asy->asy_flags & ASY_PPS) asy_ppsevent(asy, msr); async->async_ext++; asysetsoft(asy); /* * We will make sure that the modem status presented to us * during the previous read has not changed. If the chip samples * the modem status on the falling edge of the interrupt line, * and uses this state as the base for detecting change of modem * status, we would miss a change of modem status event that occured * after we initiated a read MSR operation. */ msr = asy_get(asy, ASY_MSR); if (ASY_MSR_STATES(msr) != ASY_MSR_STATES(asy->asy_msr)) goto async_msint_retry; } /* * Pend a soft interrupt if one isn't already pending. */ static void asysetsoft(struct asycom *asy) { ASSERT(MUTEX_HELD(&asy->asy_excl_hi)); if (mutex_tryenter(&asy->asy_soft_lock) == 0) return; asy->asy_flags |= ASY_NEEDSOFT; if (!asy->asysoftpend) { asy->asysoftpend = 1; mutex_exit(&asy->asy_soft_lock); (void) ddi_intr_trigger_softint(asy->asy_soft_inth, NULL); } else { mutex_exit(&asy->asy_soft_lock); } } /* * Check the carrier signal DCD and handle carrier coming up or * going down, cleaning up as needed and signalling waiters. */ static void asy_carrier_check(struct asycom *asy) { struct asyncline *async = asy->asy_priv; tty_common_t *tp = &async->async_ttycommon; queue_t *q = tp->t_readq; mblk_t *bp; int flushflag; ASY_DPRINTF(asy, ASY_DEBUG_MODM2, "asy_msr & DCD = %x, tp->t_flags & TS_SOFTCAR = %x", asy->asy_msr & ASY_MSR_DCD, tp->t_flags & TS_SOFTCAR); if (asy->asy_msr & ASY_MSR_DCD) { /* * The DCD line is on. If we already had a carrier, * nothing changed and there's nothing to do. */ if ((async->async_flags & ASYNC_CARR_ON) != 0) return; ASY_DPRINTF(asy, ASY_DEBUG_MODM2, "set ASYNC_CARR_ON"); async->async_flags |= ASYNC_CARR_ON; if (async->async_flags & ASYNC_ISOPEN) { mutex_exit(&asy->asy_excl_hi); mutex_exit(&asy->asy_excl); (void) putctl(q, M_UNHANGUP); mutex_enter(&asy->asy_excl); mutex_enter(&asy->asy_excl_hi); } cv_broadcast(&async->async_flags_cv); return; } /* * The DCD line is off. If we had no carrier, nothing changed * and there's nothing to do. */ if ((async->async_flags & ASYNC_CARR_ON) == 0) return; /* * The DCD line is off, but we had a carrier. If we're on a local line, * where carrier is ignored, or we're using a soft carrier, we're done * here. */ if ((tp->t_cflag & CLOCAL) != 0 || (tp->t_flags & TS_SOFTCAR) != 0) goto out; /* * Else, drop DTR, abort any output in progress, indicate that output * is not stopped. */ ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "carrier dropped, so drop DTR"); asy_clr(asy, ASY_MCR, ASY_MCR_DTR); if (async->async_flags & ASYNC_BUSY) { ASY_DPRINTF(asy, ASY_DEBUG_BUSY, "Carrier dropped. Clearing async_ocnt"); async->async_ocnt = 0; } async->async_flags &= ~ASYNC_STOPPED; /* If nobody had the device open, we're done here. */ if ((async->async_flags & ASYNC_ISOPEN) == 0) goto out; /* Else, send a hangup notification upstream and clean up. */ mutex_exit(&asy->asy_excl_hi); mutex_exit(&asy->asy_excl); (void) putctl(q, M_HANGUP); mutex_enter(&asy->asy_excl); ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "putctl(q, M_HANGUP)"); /* * Flush the transmit FIFO. Any data left in there is invalid now. */ if (asy->asy_use_fifo == ASY_FCR_FIFO_EN) { mutex_enter(&asy->asy_excl_hi); asy_reset_fifo(asy, ASY_FCR_THR_FL); mutex_exit(&asy->asy_excl_hi); } /* * Flush our write queue if we have one. If we're in the midst of close, * then flush everything. Don't leave stale ioctls lying about. */ ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "Flushing to prevent HUPCL hanging"); flushflag = (async->async_flags & ASYNC_CLOSING) ? FLUSHALL : FLUSHDATA; flushq(tp->t_writeq, flushflag); /* Free the last active msg. */ bp = async->async_xmitblk; if (bp != NULL) { freeb(bp); async->async_xmitblk = NULL; } mutex_enter(&asy->asy_excl_hi); async->async_flags &= ~ASYNC_BUSY; out: /* Clear our carrier flag and signal anyone waiting. */ async->async_flags &= ~ASYNC_CARR_ON; cv_broadcast(&async->async_flags_cv); } /* * Handle a second-stage interrupt. */ uint_t asysoftintr(caddr_t intarg, caddr_t unusedarg __unused) { struct asycom *asy = (struct asycom *)intarg; struct asyncline *async; int rv; uint_t cc; /* * Test and clear soft interrupt. */ mutex_enter(&asy->asy_soft_lock); ASY_DPRINTF(asy, ASY_DEBUG_PROCS, "enter"); rv = asy->asysoftpend; if (rv != 0) asy->asysoftpend = 0; mutex_exit(&asy->asy_soft_lock); if (rv) { if (asy->asy_priv == NULL) return (rv ? DDI_INTR_CLAIMED : DDI_INTR_UNCLAIMED); async = (struct asyncline *)asy->asy_priv; mutex_enter(&asy->asy_excl_hi); if (asy->asy_flags & ASY_NEEDSOFT) { asy->asy_flags &= ~ASY_NEEDSOFT; mutex_exit(&asy->asy_excl_hi); async_softint(asy); mutex_enter(&asy->asy_excl_hi); } /* * There are some instances where the softintr is not * scheduled and hence not called. It so happens that * causes the last few characters to be stuck in the * ringbuffer. Hence, call the handler once again so * the last few characters are cleared. */ cc = RING_CNT(async); mutex_exit(&asy->asy_excl_hi); if (cc > 0) (void) async_softint(asy); } return (rv ? DDI_INTR_CLAIMED : DDI_INTR_UNCLAIMED); } /* * Handle a software interrupt. */ static void async_softint(struct asycom *asy) { struct asyncline *async = asy->asy_priv; uint_t cc; mblk_t *bp; queue_t *q; uchar_t c; tty_common_t *tp; int nb; ASY_DPRINTF(asy, ASY_DEBUG_PROCS, "enter"); mutex_enter(&asy->asy_excl_hi); if (asy->asy_flags & ASY_DOINGSOFT) { asy->asy_flags |= ASY_DOINGSOFT_RETRY; mutex_exit(&asy->asy_excl_hi); return; } asy->asy_flags |= ASY_DOINGSOFT; begin: asy->asy_flags &= ~ASY_DOINGSOFT_RETRY; mutex_exit(&asy->asy_excl_hi); mutex_enter(&asy->asy_excl); tp = &async->async_ttycommon; q = tp->t_readq; if (async->async_flags & ASYNC_OUT_FLW_RESUME) { if (async->async_ocnt > 0) { mutex_enter(&asy->asy_excl_hi); async_resume(async); mutex_exit(&asy->asy_excl_hi); } else { if (async->async_xmitblk) freeb(async->async_xmitblk); async->async_xmitblk = NULL; async_start(async); } async->async_flags &= ~ASYNC_OUT_FLW_RESUME; } mutex_enter(&asy->asy_excl_hi); if (async->async_ext) { async->async_ext = 0; asy_carrier_check(asy); } mutex_exit(&asy->asy_excl_hi); /* * If data has been added to the circular buffer, remove * it from the buffer, and send it up the stream if there's * somebody listening. Try to do it 16 bytes at a time. If we * have more than 16 bytes to move, move 16 byte chunks and * leave the rest for next time around (maybe it will grow). */ mutex_enter(&asy->asy_excl_hi); if (!(async->async_flags & ASYNC_ISOPEN)) { RING_INIT(async); goto rv; } if ((cc = RING_CNT(async)) == 0) goto rv; mutex_exit(&asy->asy_excl_hi); if (!canput(q)) { mutex_enter(&asy->asy_excl_hi); if (!(async->async_inflow_source & IN_FLOW_STREAMS)) { async_flowcontrol_hw_input(asy, FLOW_STOP, IN_FLOW_STREAMS); (void) async_flowcontrol_sw_input(asy, FLOW_STOP, IN_FLOW_STREAMS); } goto rv; } if (async->async_inflow_source & IN_FLOW_STREAMS) { mutex_enter(&asy->asy_excl_hi); async_flowcontrol_hw_input(asy, FLOW_START, IN_FLOW_STREAMS); (void) async_flowcontrol_sw_input(asy, FLOW_START, IN_FLOW_STREAMS); mutex_exit(&asy->asy_excl_hi); } ASY_DPRINTF(asy, ASY_DEBUG_INPUT, "%d char(s) in queue", cc); if (!(bp = allocb(cc, BPRI_MED))) { mutex_exit(&asy->asy_excl); ttycommon_qfull(&async->async_ttycommon, q); mutex_enter(&asy->asy_excl); mutex_enter(&asy->asy_excl_hi); goto rv; } mutex_enter(&asy->asy_excl_hi); do { if (RING_ERR(async, S_ERRORS)) { RING_UNMARK(async); c = RING_GET(async); break; } else { *bp->b_wptr++ = RING_GET(async); } } while (--cc); mutex_exit(&asy->asy_excl_hi); mutex_exit(&asy->asy_excl); if (bp->b_wptr > bp->b_rptr) { if (!canput(q)) { asyerror(asy, CE_WARN, "local queue full"); freemsg(bp); } else { (void) putq(q, bp); } } else { freemsg(bp); } /* * If we have a parity error, then send * up an M_BREAK with the "bad" * character as an argument. Let ldterm * figure out what to do with the error. */ if (cc) (void) putctl1(q, M_BREAK, c); mutex_enter(&asy->asy_excl); mutex_enter(&asy->asy_excl_hi); if (cc) { asysetsoft(asy); /* finish cc chars */ } rv: if ((RING_CNT(async) < (RINGSIZE/4)) && (async->async_inflow_source & IN_FLOW_RINGBUFF)) { async_flowcontrol_hw_input(asy, FLOW_START, IN_FLOW_RINGBUFF); (void) async_flowcontrol_sw_input(asy, FLOW_START, IN_FLOW_RINGBUFF); } /* * If a transmission has finished, indicate that it's finished, * and start that line up again. */ if (async->async_break > 0) { nb = async->async_break; async->async_break = 0; if (async->async_flags & ASYNC_ISOPEN) { mutex_exit(&asy->asy_excl_hi); mutex_exit(&asy->asy_excl); for (; nb > 0; nb--) (void) putctl(q, M_BREAK); mutex_enter(&asy->asy_excl); mutex_enter(&asy->asy_excl_hi); } } if (async->async_ocnt <= 0 && (async->async_flags & ASYNC_BUSY)) { ASY_DPRINTF(asy, ASY_DEBUG_BUSY, "Clearing ASYNC_BUSY, async_ocnt=%d", async->async_ocnt); async->async_flags &= ~ASYNC_BUSY; mutex_exit(&asy->asy_excl_hi); if (async->async_xmitblk) freeb(async->async_xmitblk); async->async_xmitblk = NULL; async_start(async); /* * If the flag isn't set after doing the async_start above, we * may have finished all the queued output. Signal any thread * stuck in close. */ if (!(async->async_flags & ASYNC_BUSY)) cv_broadcast(&async->async_flags_cv); mutex_enter(&asy->asy_excl_hi); } /* * A note about these overrun bits: all they do is *tell* someone * about an error- They do not track multiple errors. In fact, * you could consider them latched register bits if you like. * We are only interested in printing the error message once for * any cluster of overrun errors. */ if (async->async_hw_overrun) { if (async->async_flags & ASYNC_ISOPEN) { mutex_exit(&asy->asy_excl_hi); mutex_exit(&asy->asy_excl); asyerror(asy, CE_WARN, "silo overflow"); mutex_enter(&asy->asy_excl); mutex_enter(&asy->asy_excl_hi); } async->async_hw_overrun = 0; } if (async->async_sw_overrun) { if (async->async_flags & ASYNC_ISOPEN) { mutex_exit(&asy->asy_excl_hi); mutex_exit(&asy->asy_excl); asyerror(asy, CE_WARN, "ring buffer overflow"); mutex_enter(&asy->asy_excl); mutex_enter(&asy->asy_excl_hi); } async->async_sw_overrun = 0; } if (asy->asy_flags & ASY_DOINGSOFT_RETRY) { mutex_exit(&asy->asy_excl); goto begin; } asy->asy_flags &= ~ASY_DOINGSOFT; mutex_exit(&asy->asy_excl_hi); mutex_exit(&asy->asy_excl); ASY_DPRINTF(asy, ASY_DEBUG_PROCS, "done"); } /* * Restart output on a line after a delay or break timer expired. */ static void async_restart(void *arg) { struct asyncline *async = (struct asyncline *)arg; struct asycom *asy = async->async_common; ASY_DPRINTF(asy, ASY_DEBUG_PROCS, "enter"); /* * If break timer expired, turn off the break bit. */ mutex_enter(&asy->asy_excl); /* * If ASYNC_OUT_SUSPEND is also set, we don't really * clean the HW break, TIOCCBRK is responsible for this. */ if ((async->async_flags & ASYNC_BREAK) && !(async->async_flags & ASYNC_OUT_SUSPEND)) { mutex_enter(&asy->asy_excl_hi); asy_clr(asy, ASY_LCR, ASY_LCR_SETBRK); mutex_exit(&asy->asy_excl_hi); } async->async_flags &= ~(ASYNC_DELAY|ASYNC_BREAK); cv_broadcast(&async->async_flags_cv); async_start(async); mutex_exit(&asy->asy_excl); } /* * Start output on a line, unless it's busy, frozen, or otherwise. */ static void async_start(struct asyncline *async) { struct asycom *asy = async->async_common; int cc; queue_t *q; mblk_t *bp; uchar_t *xmit_addr; int fifo_len = 1; boolean_t didsome; mblk_t *nbp; ASY_DPRINTF(asy, ASY_DEBUG_PROCS, "enter"); if (asy->asy_use_fifo == ASY_FCR_FIFO_EN) { fifo_len = asy->asy_fifo_buf; /* with FIFO buffers */ if (fifo_len > asy_max_tx_fifo) fifo_len = asy_max_tx_fifo; } ASSERT(mutex_owned(&asy->asy_excl)); /* * If the chip is busy (i.e., we're waiting for a break timeout * to expire, or for the current transmission to finish, or for * output to finish draining from chip), don't grab anything new. */ if (async->async_flags & (ASYNC_BREAK|ASYNC_BUSY)) { ASY_DPRINTF(asy, ASY_DEBUG_OUT, "%s", async->async_flags & ASYNC_BREAK ? "break" : "busy"); return; } /* * Check only pended sw input flow control. */ mutex_enter(&asy->asy_excl_hi); if (async_flowcontrol_sw_input(asy, FLOW_CHECK, IN_FLOW_NULL)) fifo_len--; mutex_exit(&asy->asy_excl_hi); /* * If we're waiting for a delay timeout to expire, don't grab * anything new. */ if (async->async_flags & ASYNC_DELAY) { ASY_DPRINTF(asy, ASY_DEBUG_OUT, "start ASYNC_DELAY"); return; } if ((q = async->async_ttycommon.t_writeq) == NULL) { ASY_DPRINTF(asy, ASY_DEBUG_OUT, "start writeq is null"); return; /* not attached to a stream */ } for (;;) { if ((bp = getq(q)) == NULL) return; /* no data to transmit */ /* * We have a message block to work on. * Check whether it's a break, a delay, or an ioctl (the latter * occurs if the ioctl in question was waiting for the output * to drain). If it's one of those, process it immediately. */ switch (bp->b_datap->db_type) { case M_BREAK: /* * Set the break bit, and arrange for "async_restart" * to be called in 1/4 second; it will turn the * break bit off, and call "async_start" to grab * the next message. */ mutex_enter(&asy->asy_excl_hi); asy_set(asy, ASY_LCR, ASY_LCR_SETBRK); mutex_exit(&asy->asy_excl_hi); async->async_flags |= ASYNC_BREAK; (void) timeout(async_restart, (caddr_t)async, drv_usectohz(1000000)/4); freemsg(bp); return; /* wait for this to finish */ case M_DELAY: /* * Arrange for "async_restart" to be called when the * delay expires; it will turn ASYNC_DELAY off, * and call "async_start" to grab the next message. */ (void) timeout(async_restart, (caddr_t)async, (int)(*(unsigned char *)bp->b_rptr + 6)); async->async_flags |= ASYNC_DELAY; freemsg(bp); return; /* wait for this to finish */ case M_IOCTL: /* * This ioctl was waiting for the output ahead of * it to drain; obviously, it has. Do it, and * then grab the next message after it. */ mutex_exit(&asy->asy_excl); async_ioctl(async, q, bp); mutex_enter(&asy->asy_excl); continue; } while (bp != NULL && ((cc = MBLKL(bp)) == 0)) { nbp = bp->b_cont; freeb(bp); bp = nbp; } if (bp != NULL) break; } /* * We have data to transmit. If output is stopped, put * it back and try again later. */ if (async->async_flags & (ASYNC_HW_OUT_FLW | ASYNC_SW_OUT_FLW | ASYNC_STOPPED | ASYNC_OUT_SUSPEND)) { (void) putbq(q, bp); return; } async->async_xmitblk = bp; xmit_addr = bp->b_rptr; bp = bp->b_cont; if (bp != NULL) (void) putbq(q, bp); /* not done with this message yet */ /* * In 5-bit mode, the high order bits are used * to indicate character sizes less than five, * so we need to explicitly mask before transmitting */ if ((async->async_ttycommon.t_cflag & CSIZE) == CS5) { unsigned char *p = xmit_addr; int cnt = cc; while (cnt--) *p++ &= (unsigned char) 0x1f; } /* * Set up this block for pseudo-DMA. */ mutex_enter(&asy->asy_excl_hi); /* * If the transmitter is ready, shove the first * character out. */ didsome = B_FALSE; while (--fifo_len >= 0 && cc > 0) { if (!(asy_get(asy, ASY_LSR) & ASY_LSR_THRE)) break; asy_put(asy, ASY_THR, *xmit_addr++); cc--; didsome = B_TRUE; } async->async_optr = xmit_addr; async->async_ocnt = cc; if (didsome) async->async_flags |= ASYNC_PROGRESS; ASY_DPRINTF(asy, ASY_DEBUG_BUSY, "Set ASYNC_BUSY, async_ocnt=%d", async->async_ocnt); async->async_flags |= ASYNC_BUSY; mutex_exit(&asy->asy_excl_hi); } /* * Resume output by poking the transmitter. */ static void async_resume(struct asyncline *async) { struct asycom *asy = async->async_common; ASY_DPRINTF(asy, ASY_DEBUG_PROCS, "enter"); ASSERT(mutex_owned(&asy->asy_excl_hi)); if (asy_get(asy, ASY_LSR) & ASY_LSR_THRE) { if (async_flowcontrol_sw_input(asy, FLOW_CHECK, IN_FLOW_NULL)) return; if (async->async_ocnt > 0 && !(async->async_flags & (ASYNC_HW_OUT_FLW|ASYNC_SW_OUT_FLW|ASYNC_OUT_SUSPEND))) { asy_put(asy, ASY_THR, *async->async_optr++); async->async_ocnt--; async->async_flags |= ASYNC_PROGRESS; } } } /* * Hold the untimed break to last the minimum time. */ static void async_hold_utbrk(void *arg) { struct asyncline *async = arg; struct asycom *asy = async->async_common; mutex_enter(&asy->asy_excl); async->async_flags &= ~ASYNC_HOLD_UTBRK; cv_broadcast(&async->async_flags_cv); async->async_utbrktid = 0; mutex_exit(&asy->asy_excl); } /* * Resume the untimed break. */ static void async_resume_utbrk(struct asyncline *async) { struct asycom *asy = async->async_common; ASSERT(mutex_owned(&asy->asy_excl)); /* * Because the wait time is very short, * so we use uninterruptably wait. */ while (async->async_flags & ASYNC_HOLD_UTBRK) { cv_wait(&async->async_flags_cv, &asy->asy_excl); } mutex_enter(&asy->asy_excl_hi); /* * Timed break and untimed break can exist simultaneously, * if ASYNC_BREAK is also set at here, we don't * really clean the HW break. */ if (!(async->async_flags & ASYNC_BREAK)) asy_clr(asy, ASY_LCR, ASY_LCR_SETBRK); async->async_flags &= ~ASYNC_OUT_SUSPEND; cv_broadcast(&async->async_flags_cv); if (async->async_ocnt > 0) { async_resume(async); mutex_exit(&asy->asy_excl_hi); } else { async->async_flags &= ~ASYNC_BUSY; mutex_exit(&asy->asy_excl_hi); if (async->async_xmitblk != NULL) { freeb(async->async_xmitblk); async->async_xmitblk = NULL; } async_start(async); } } /* * Process an "ioctl" message sent down to us. * Note that we don't need to get any locks until we are ready to access * the hardware. Nothing we access until then is going to be altered * outside of the STREAMS framework, so we should be safe. */ int asydelay = 10000; static void async_ioctl(struct asyncline *async, queue_t *wq, mblk_t *mp) { struct asycom *asy = async->async_common; tty_common_t *tp = &async->async_ttycommon; struct iocblk *iocp; unsigned datasize; int error = 0; mblk_t *datamp; ASY_DPRINTF(asy, ASY_DEBUG_PROCS, "enter"); if (tp->t_iocpending != NULL) { /* * We were holding an "ioctl" response pending the * availability of an "mblk" to hold data to be passed up; * another "ioctl" came through, which means that "ioctl" * must have timed out or been aborted. */ freemsg(async->async_ttycommon.t_iocpending); async->async_ttycommon.t_iocpending = NULL; } iocp = (struct iocblk *)mp->b_rptr; /* * For TIOCMGET and the PPS ioctls, do NOT call ttycommon_ioctl() * because this function frees up the message block (mp->b_cont) that * contains the user location where we pass back the results. * * Similarly, CONSOPENPOLLEDIO needs ioc_count, which ttycommon_ioctl * zaps. We know that ttycommon_ioctl doesn't know any CONS* * ioctls, so keep the others safe too. */ ASY_DPRINTF(asy, ASY_DEBUG_IOCTL, "%s", iocp->ioc_cmd == TIOCMGET ? "TIOCMGET" : iocp->ioc_cmd == TIOCMSET ? "TIOCMSET" : iocp->ioc_cmd == TIOCMBIS ? "TIOCMBIS" : iocp->ioc_cmd == TIOCMBIC ? "TIOCMBIC" : "other"); switch (iocp->ioc_cmd) { case TIOCMGET: case TIOCGPPS: case TIOCSPPS: case TIOCGPPSEV: case CONSOPENPOLLEDIO: case CONSCLOSEPOLLEDIO: case CONSSETABORTENABLE: case CONSGETABORTENABLE: error = -1; /* Do Nothing */ break; default: /* * The only way in which "ttycommon_ioctl" can fail is if the * "ioctl" requires a response containing data to be returned * to the user, and no mblk could be allocated for the data. * No such "ioctl" alters our state. Thus, we always go ahead * and do any state-changes the "ioctl" calls for. If we * couldn't allocate the data, "ttycommon_ioctl" has stashed * the "ioctl" away safely, so we just call "bufcall" to * request that we be called back when we stand a better * chance of allocating the data. */ if ((datasize = ttycommon_ioctl(tp, wq, mp, &error)) != 0) { if (async->async_wbufcid) unbufcall(async->async_wbufcid); async->async_wbufcid = bufcall(datasize, BPRI_HI, (void (*)(void *)) async_reioctl, (void *)(intptr_t)async->async_common->asy_unit); return; } } mutex_enter(&asy->asy_excl); if (error == 0) { /* * "ttycommon_ioctl" did most of the work; we just use the * data it set up. */ switch (iocp->ioc_cmd) { case TCSETS: mutex_enter(&asy->asy_excl_hi); if (asy_baudok(asy)) asy_program(asy, ASY_NOINIT); else error = EINVAL; mutex_exit(&asy->asy_excl_hi); break; case TCSETSF: case TCSETSW: case TCSETA: case TCSETAW: case TCSETAF: mutex_enter(&asy->asy_excl_hi); if (!asy_baudok(asy)) error = EINVAL; else { if (asy_isbusy(asy)) asy_waiteot(asy); asy_program(asy, ASY_NOINIT); } mutex_exit(&asy->asy_excl_hi); break; } } else if (error < 0) { /* * "ttycommon_ioctl" didn't do anything; we process it here. */ error = 0; switch (iocp->ioc_cmd) { case TIOCGPPS: /* * Get PPS on/off. */ if (mp->b_cont != NULL) freemsg(mp->b_cont); mp->b_cont = allocb(sizeof (int), BPRI_HI); if (mp->b_cont == NULL) { error = ENOMEM; break; } if (asy->asy_flags & ASY_PPS) *(int *)mp->b_cont->b_wptr = 1; else *(int *)mp->b_cont->b_wptr = 0; mp->b_cont->b_wptr += sizeof (int); mp->b_datap->db_type = M_IOCACK; iocp->ioc_count = sizeof (int); break; case TIOCSPPS: /* * Set PPS on/off. */ error = miocpullup(mp, sizeof (int)); if (error != 0) break; mutex_enter(&asy->asy_excl_hi); if (*(int *)mp->b_cont->b_rptr) asy->asy_flags |= ASY_PPS; else asy->asy_flags &= ~ASY_PPS; /* Reset edge sense */ asy->asy_flags &= ~ASY_PPS_EDGE; mutex_exit(&asy->asy_excl_hi); mp->b_datap->db_type = M_IOCACK; break; case TIOCGPPSEV: { /* * Get PPS event data. */ mblk_t *bp; void *buf; #ifdef _SYSCALL32_IMPL struct ppsclockev32 p32; #endif struct ppsclockev ppsclockev; if (mp->b_cont != NULL) { freemsg(mp->b_cont); mp->b_cont = NULL; } if ((asy->asy_flags & ASY_PPS) == 0) { error = ENXIO; break; } /* Protect from incomplete asy_ppsev */ mutex_enter(&asy->asy_excl_hi); ppsclockev = asy_ppsev; mutex_exit(&asy->asy_excl_hi); #ifdef _SYSCALL32_IMPL if ((iocp->ioc_flag & IOC_MODELS) != IOC_NATIVE) { TIMEVAL_TO_TIMEVAL32(&p32.tv, &ppsclockev.tv); p32.serial = ppsclockev.serial; buf = &p32; iocp->ioc_count = sizeof (struct ppsclockev32); } else #endif { buf = &ppsclockev; iocp->ioc_count = sizeof (struct ppsclockev); } if ((bp = allocb(iocp->ioc_count, BPRI_HI)) == NULL) { error = ENOMEM; break; } mp->b_cont = bp; bcopy(buf, bp->b_wptr, iocp->ioc_count); bp->b_wptr += iocp->ioc_count; mp->b_datap->db_type = M_IOCACK; break; } case TCSBRK: error = miocpullup(mp, sizeof (int)); if (error != 0) break; if (*(int *)mp->b_cont->b_rptr == 0) { /* * XXX Arrangements to ensure that a break * isn't in progress should be sufficient. * This ugly delay() is the only thing * that seems to work on the NCR Worldmark. * It should be replaced. Note that an * asy_waiteot() also does not work. */ if (asydelay) delay(drv_usectohz(asydelay)); while (async->async_flags & ASYNC_BREAK) { cv_wait(&async->async_flags_cv, &asy->asy_excl); } mutex_enter(&asy->asy_excl_hi); /* * Wait until TSR is empty and then set the * break. ASYNC_BREAK has been set to ensure * that no characters are transmitted while the * TSR is being flushed and SOUT is being used * for the break signal. */ async->async_flags |= ASYNC_BREAK; asy_wait_baudrate(asy); /* * Arrange for "async_restart" * to be called in 1/4 second; * it will turn the break bit off, and call * "async_start" to grab the next message. */ asy_set(asy, ASY_LCR, ASY_LCR_SETBRK); mutex_exit(&asy->asy_excl_hi); (void) timeout(async_restart, (caddr_t)async, drv_usectohz(1000000)/4); } else { ASY_DPRINTF(asy, ASY_DEBUG_OUT, "wait for flush"); mutex_enter(&asy->asy_excl_hi); asy_waiteot(asy); mutex_exit(&asy->asy_excl_hi); ASY_DPRINTF(asy, ASY_DEBUG_OUT, "ldterm satisfied"); } break; case TIOCSBRK: if (!(async->async_flags & ASYNC_OUT_SUSPEND)) { mutex_enter(&asy->asy_excl_hi); async->async_flags |= ASYNC_OUT_SUSPEND; async->async_flags |= ASYNC_HOLD_UTBRK; asy_wait_baudrate(asy); mutex_exit(&asy->asy_excl_hi); /* wait for 100ms to hold BREAK */ async->async_utbrktid = timeout((void (*)())async_hold_utbrk, (caddr_t)async, drv_usectohz(asy_min_utbrk)); } mioc2ack(mp, NULL, 0, 0); break; case TIOCCBRK: if (async->async_flags & ASYNC_OUT_SUSPEND) async_resume_utbrk(async); mioc2ack(mp, NULL, 0, 0); break; case TIOCMSET: case TIOCMBIS: case TIOCMBIC: if (iocp->ioc_count != TRANSPARENT) { ASY_DPRINTF(asy, ASY_DEBUG_IOCTL, "non-transparent"); error = miocpullup(mp, sizeof (int)); if (error != 0) break; mutex_enter(&asy->asy_excl_hi); (void) asymctl(asy, dmtoasy(asy, *(int *)mp->b_cont->b_rptr), iocp->ioc_cmd); mutex_exit(&asy->asy_excl_hi); iocp->ioc_error = 0; mp->b_datap->db_type = M_IOCACK; } else { ASY_DPRINTF(asy, ASY_DEBUG_IOCTL, "transparent"); mcopyin(mp, NULL, sizeof (int), NULL); } break; case TIOCMGET: datamp = allocb(sizeof (int), BPRI_MED); if (datamp == NULL) { error = EAGAIN; break; } mutex_enter(&asy->asy_excl_hi); *(int *)datamp->b_rptr = asymctl(asy, 0, TIOCMGET); mutex_exit(&asy->asy_excl_hi); if (iocp->ioc_count == TRANSPARENT) { ASY_DPRINTF(asy, ASY_DEBUG_IOCTL, "transparent"); mcopyout(mp, NULL, sizeof (int), NULL, datamp); } else { ASY_DPRINTF(asy, ASY_DEBUG_IOCTL, "non-transparent"); mioc2ack(mp, datamp, sizeof (int), 0); } break; case CONSOPENPOLLEDIO: error = miocpullup(mp, sizeof (struct cons_polledio *)); if (error != 0) break; *(struct cons_polledio **)mp->b_cont->b_rptr = &asy->polledio; mp->b_datap->db_type = M_IOCACK; break; case CONSCLOSEPOLLEDIO: mp->b_datap->db_type = M_IOCACK; iocp->ioc_error = 0; iocp->ioc_rval = 0; break; case CONSSETABORTENABLE: error = secpolicy_console(iocp->ioc_cr); if (error != 0) break; if (iocp->ioc_count != TRANSPARENT) { error = EINVAL; break; } mutex_enter(&asy->asy_excl_hi); if (*(intptr_t *)mp->b_cont->b_rptr) asy->asy_flags |= ASY_CONSOLE; else asy->asy_flags &= ~ASY_CONSOLE; mutex_exit(&asy->asy_excl_hi); mp->b_datap->db_type = M_IOCACK; iocp->ioc_error = 0; iocp->ioc_rval = 0; break; case CONSGETABORTENABLE: /*CONSTANTCONDITION*/ ASSERT(sizeof (boolean_t) <= sizeof (boolean_t *)); /* * Store the return value right in the payload * we were passed. Crude. */ mcopyout(mp, NULL, sizeof (boolean_t), NULL, NULL); *(boolean_t *)mp->b_cont->b_rptr = (asy->asy_flags & ASY_CONSOLE) != 0; break; default: /* * If we don't understand it, it's an error. NAK it. */ error = EINVAL; break; } } if (error != 0) { iocp->ioc_error = error; mp->b_datap->db_type = M_IOCNAK; } mutex_exit(&asy->asy_excl); qreply(wq, mp); ASY_DPRINTF(asy, ASY_DEBUG_PROCS, "done"); } static int asyrsrv(queue_t *q) { mblk_t *bp; struct asyncline *async; struct asycom *asy; async = (struct asyncline *)q->q_ptr; asy = (struct asycom *)async->async_common; while (canputnext(q) && (bp = getq(q))) putnext(q, bp); mutex_enter(&asy->asy_excl_hi); asysetsoft(asy); mutex_exit(&asy->asy_excl_hi); async->async_polltid = 0; return (0); } /* * The ASYWPUTDO_NOT_SUSP macro indicates to asywputdo() whether it should * handle messages as though the driver is operating normally or is * suspended. In the suspended case, some or all of the processing may have * to be delayed until the driver is resumed. */ #define ASYWPUTDO_NOT_SUSP(async, wput) \ !((wput) && ((async)->async_flags & ASYNC_DDI_SUSPENDED)) /* * Processing for write queue put procedure. * Respond to M_STOP, M_START, M_IOCTL, and M_FLUSH messages here; * set the flow control character for M_STOPI and M_STARTI messages; * queue up M_BREAK, M_DELAY, and M_DATA messages for processing * by the start routine, and then call the start routine; discard * everything else. Note that this driver does not incorporate any * mechanism to negotiate to handle the canonicalization process. * It expects that these functions are handled in upper module(s), * as we do in ldterm. */ static int asywputdo(queue_t *q, mblk_t *mp, boolean_t wput) { struct asyncline *async; struct asycom *asy; int error; async = (struct asyncline *)q->q_ptr; asy = async->async_common; switch (mp->b_datap->db_type) { case M_STOP: /* * Since we don't do real DMA, we can just let the * chip coast to a stop after applying the brakes. */ mutex_enter(&asy->asy_excl); async->async_flags |= ASYNC_STOPPED; mutex_exit(&asy->asy_excl); freemsg(mp); break; case M_START: mutex_enter(&asy->asy_excl); if (async->async_flags & ASYNC_STOPPED) { async->async_flags &= ~ASYNC_STOPPED; if (ASYWPUTDO_NOT_SUSP(async, wput)) { /* * If an output operation is in progress, * resume it. Otherwise, prod the start * routine. */ if (async->async_ocnt > 0) { mutex_enter(&asy->asy_excl_hi); async_resume(async); mutex_exit(&asy->asy_excl_hi); } else { async_start(async); } } } mutex_exit(&asy->asy_excl); freemsg(mp); break; case M_IOCTL: switch (((struct iocblk *)mp->b_rptr)->ioc_cmd) { case TCSBRK: error = miocpullup(mp, sizeof (int)); if (error != 0) { miocnak(q, mp, 0, error); return (0); } if (*(int *)mp->b_cont->b_rptr != 0) { ASY_DPRINTF(asy, ASY_DEBUG_OUT, "flush request"); (void) putq(q, mp); mutex_enter(&asy->asy_excl); if (ASYWPUTDO_NOT_SUSP(async, wput)) { /* * If an TIOCSBRK is in progress, * clean it as TIOCCBRK does, * then kick off output. * If TIOCSBRK is not in progress, * just kick off output. */ async_resume_utbrk(async); } mutex_exit(&asy->asy_excl); break; } /*FALLTHROUGH*/ case TCSETSW: case TCSETSF: case TCSETAW: case TCSETAF: /* * The changes do not take effect until all * output queued before them is drained. * Put this message on the queue, so that * "async_start" will see it when it's done * with the output before it. Poke the * start routine, just in case. */ (void) putq(q, mp); mutex_enter(&asy->asy_excl); if (ASYWPUTDO_NOT_SUSP(async, wput)) { /* * If an TIOCSBRK is in progress, * clean it as TIOCCBRK does. * then kick off output. * If TIOCSBRK is not in progress, * just kick off output. */ async_resume_utbrk(async); } mutex_exit(&asy->asy_excl); break; default: /* * Do it now. */ mutex_enter(&asy->asy_excl); if (ASYWPUTDO_NOT_SUSP(async, wput)) { mutex_exit(&asy->asy_excl); async_ioctl(async, q, mp); break; } async_put_suspq(asy, mp); mutex_exit(&asy->asy_excl); break; } break; case M_FLUSH: if (*mp->b_rptr & FLUSHW) { mutex_enter(&asy->asy_excl); /* * Abort any output in progress. */ mutex_enter(&asy->asy_excl_hi); if (async->async_flags & ASYNC_BUSY) { ASY_DPRINTF(asy, ASY_DEBUG_BUSY, "Clearing async_ocnt, " "leaving ASYNC_BUSY set"); async->async_ocnt = 0; async->async_flags &= ~ASYNC_BUSY; } /* if */ if (ASYWPUTDO_NOT_SUSP(async, wput)) { /* Flush FIFO buffers */ if (asy->asy_use_fifo == ASY_FCR_FIFO_EN) { asy_reset_fifo(asy, ASY_FCR_THR_FL); } } mutex_exit(&asy->asy_excl_hi); /* * Flush our write queue. */ flushq(q, FLUSHDATA); /* XXX doesn't flush M_DELAY */ if (async->async_xmitblk != NULL) { freeb(async->async_xmitblk); async->async_xmitblk = NULL; } mutex_exit(&asy->asy_excl); *mp->b_rptr &= ~FLUSHW; /* it has been flushed */ } if (*mp->b_rptr & FLUSHR) { if (ASYWPUTDO_NOT_SUSP(async, wput)) { mutex_enter(&asy->asy_excl); mutex_enter(&asy->asy_excl_hi); /* Flush FIFO buffers */ if (asy->asy_use_fifo == ASY_FCR_FIFO_EN) { asy_reset_fifo(asy, ASY_FCR_RHR_FL); } mutex_exit(&asy->asy_excl_hi); mutex_exit(&asy->asy_excl); } flushq(RD(q), FLUSHDATA); qreply(q, mp); /* give the read queues a crack at it */ } else { freemsg(mp); } /* * We must make sure we process messages that survive the * write-side flush. */ if (ASYWPUTDO_NOT_SUSP(async, wput)) { mutex_enter(&asy->asy_excl); async_start(async); mutex_exit(&asy->asy_excl); } break; case M_BREAK: case M_DELAY: case M_DATA: /* * Queue the message up to be transmitted, * and poke the start routine. */ (void) putq(q, mp); if (ASYWPUTDO_NOT_SUSP(async, wput)) { mutex_enter(&asy->asy_excl); async_start(async); mutex_exit(&asy->asy_excl); } break; case M_STOPI: mutex_enter(&asy->asy_excl); if (ASYWPUTDO_NOT_SUSP(async, wput)) { mutex_enter(&asy->asy_excl_hi); if (!(async->async_inflow_source & IN_FLOW_USER)) { async_flowcontrol_hw_input(asy, FLOW_STOP, IN_FLOW_USER); (void) async_flowcontrol_sw_input(asy, FLOW_STOP, IN_FLOW_USER); } mutex_exit(&asy->asy_excl_hi); mutex_exit(&asy->asy_excl); freemsg(mp); break; } async_put_suspq(asy, mp); mutex_exit(&asy->asy_excl); break; case M_STARTI: mutex_enter(&asy->asy_excl); if (ASYWPUTDO_NOT_SUSP(async, wput)) { mutex_enter(&asy->asy_excl_hi); if (async->async_inflow_source & IN_FLOW_USER) { async_flowcontrol_hw_input(asy, FLOW_START, IN_FLOW_USER); (void) async_flowcontrol_sw_input(asy, FLOW_START, IN_FLOW_USER); } mutex_exit(&asy->asy_excl_hi); mutex_exit(&asy->asy_excl); freemsg(mp); break; } async_put_suspq(asy, mp); mutex_exit(&asy->asy_excl); break; case M_CTL: if (MBLKL(mp) >= sizeof (struct iocblk) && ((struct iocblk *)mp->b_rptr)->ioc_cmd == MC_POSIXQUERY) { mutex_enter(&asy->asy_excl); if (ASYWPUTDO_NOT_SUSP(async, wput)) { ((struct iocblk *)mp->b_rptr)->ioc_cmd = MC_HAS_POSIX; mutex_exit(&asy->asy_excl); qreply(q, mp); break; } else { async_put_suspq(asy, mp); } } else { /* * These MC_SERVICE type messages are used by upper * modules to tell this driver to send input up * immediately, or that it can wait for normal * processing that may or may not be done. Sun * requires these for the mouse module. * (XXX - for x86?) */ mutex_enter(&asy->asy_excl); switch (*mp->b_rptr) { case MC_SERVICEIMM: async->async_flags |= ASYNC_SERVICEIMM; break; case MC_SERVICEDEF: async->async_flags &= ~ASYNC_SERVICEIMM; break; } mutex_exit(&asy->asy_excl); freemsg(mp); } break; case M_IOCDATA: mutex_enter(&asy->asy_excl); if (ASYWPUTDO_NOT_SUSP(async, wput)) { mutex_exit(&asy->asy_excl); async_iocdata(q, mp); break; } async_put_suspq(asy, mp); mutex_exit(&asy->asy_excl); break; default: freemsg(mp); break; } return (0); } static int asywput(queue_t *q, mblk_t *mp) { return (asywputdo(q, mp, B_TRUE)); } /* * Retry an "ioctl", now that "bufcall" claims we may be able to allocate * the buffer we need. */ static void async_reioctl(void *unit) { int instance = (uintptr_t)unit; struct asyncline *async; struct asycom *asy; queue_t *q; mblk_t *mp; asy = ddi_get_soft_state(asy_soft_state, instance); ASSERT(asy != NULL); async = asy->asy_priv; /* * The bufcall is no longer pending. */ mutex_enter(&asy->asy_excl); async->async_wbufcid = 0; if ((q = async->async_ttycommon.t_writeq) == NULL) { mutex_exit(&asy->asy_excl); return; } if ((mp = async->async_ttycommon.t_iocpending) != NULL) { /* not pending any more */ async->async_ttycommon.t_iocpending = NULL; mutex_exit(&asy->asy_excl); async_ioctl(async, q, mp); } else mutex_exit(&asy->asy_excl); } static void async_iocdata(queue_t *q, mblk_t *mp) { struct asyncline *async = (struct asyncline *)q->q_ptr; struct asycom *asy; struct iocblk *ip; struct copyresp *csp; asy = async->async_common; ip = (struct iocblk *)mp->b_rptr; csp = (struct copyresp *)mp->b_rptr; if (csp->cp_rval != 0) { if (csp->cp_private) freemsg(csp->cp_private); freemsg(mp); return; } mutex_enter(&asy->asy_excl); ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "case %s", csp->cp_cmd == TIOCMGET ? "TIOCMGET" : csp->cp_cmd == TIOCMSET ? "TIOCMSET" : csp->cp_cmd == TIOCMBIS ? "TIOCMBIS" : "TIOCMBIC"); switch (csp->cp_cmd) { case TIOCMGET: if (mp->b_cont) { freemsg(mp->b_cont); mp->b_cont = NULL; } mp->b_datap->db_type = M_IOCACK; ip->ioc_error = 0; ip->ioc_count = 0; ip->ioc_rval = 0; mp->b_wptr = mp->b_rptr + sizeof (struct iocblk); break; case TIOCMSET: case TIOCMBIS: case TIOCMBIC: mutex_enter(&asy->asy_excl_hi); (void) asymctl(asy, dmtoasy(asy, *(int *)mp->b_cont->b_rptr), csp->cp_cmd); mutex_exit(&asy->asy_excl_hi); mioc2ack(mp, NULL, 0, 0); break; default: mp->b_datap->db_type = M_IOCNAK; ip->ioc_error = EINVAL; break; } qreply(q, mp); mutex_exit(&asy->asy_excl); } /* * debugger/console support routines. */ /* * put a character out * Do not use interrupts. If char is LF, put out CR, LF. */ static void asyputchar(cons_polledio_arg_t arg, uchar_t c) { struct asycom *asy = (struct asycom *)arg; if (c == '\n') asyputchar(arg, '\r'); while ((asy_get_reg(asy, ASY_LSR) & ASY_LSR_THRE) == 0) { /* wait for xmit to finish */ drv_usecwait(10); } /* put the character out */ asy_put_reg(asy, ASY_THR, c); } /* * See if there's a character available. If no character is * available, return 0. Run in polled mode, no interrupts. */ static boolean_t asyischar(cons_polledio_arg_t arg) { struct asycom *asy = (struct asycom *)arg; return ((asy_get_reg(asy, ASY_LSR) & ASY_LSR_DR) != 0); } /* * Get a character. Run in polled mode, no interrupts. */ static int asygetchar(cons_polledio_arg_t arg) { struct asycom *asy = (struct asycom *)arg; while (!asyischar(arg)) drv_usecwait(10); return (asy_get_reg(asy, ASY_RHR)); } /* * Set or get the modem control status. */ static int asymctl(struct asycom *asy, int bits, int how) { int mcr_r, msr_r; ASSERT(mutex_owned(&asy->asy_excl_hi)); ASSERT(mutex_owned(&asy->asy_excl)); /* Read Modem Control Registers */ mcr_r = asy_get(asy, ASY_MCR); switch (how) { case TIOCMSET: ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "TIOCMSET, bits = %x", bits); mcr_r = bits; /* Set bits */ break; case TIOCMBIS: ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "TIOCMBIS, bits = %x", bits); mcr_r |= bits; /* Mask in bits */ break; case TIOCMBIC: ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "TIOCMBIC, bits = %x", bits); mcr_r &= ~bits; /* Mask out bits */ break; case TIOCMGET: /* Read Modem Status Registers */ /* * If modem interrupts are enabled, we return the * saved value of msr. We read MSR only in async_msint() */ if (asy_get(asy, ASY_IER) & ASY_IER_MIEN) { msr_r = asy->asy_msr; ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "TIOCMGET, read msr_r = %x", msr_r); } else { msr_r = asy_get(asy, ASY_MSR); ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "TIOCMGET, read MSR = %x", msr_r); } ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "modem_lines = %x", asytodm(mcr_r, msr_r)); return (asytodm(mcr_r, msr_r)); } asy_put(asy, ASY_MCR, mcr_r); return (mcr_r); } static int asytodm(int mcr_r, int msr_r) { int b = 0; /* MCR registers */ if (mcr_r & ASY_MCR_RTS) b |= TIOCM_RTS; if (mcr_r & ASY_MCR_DTR) b |= TIOCM_DTR; /* MSR registers */ if (msr_r & ASY_MSR_DCD) b |= TIOCM_CAR; if (msr_r & ASY_MSR_CTS) b |= TIOCM_CTS; if (msr_r & ASY_MSR_DSR) b |= TIOCM_DSR; if (msr_r & ASY_MSR_RI) b |= TIOCM_RNG; return (b); } static int dmtoasy(struct asycom *asy, int bits) { int b = 0; ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "bits = %x", bits); #ifdef CAN_NOT_SET /* only DTR and RTS can be set */ if (bits & TIOCM_CAR) b |= ASY_MSR_DCD; if (bits & TIOCM_CTS) b |= ASY_MSR_CTS; if (bits & TIOCM_DSR) b |= ASY_MSR_DSR; if (bits & TIOCM_RNG) b |= ASY_MSR_RI; #endif if (bits & TIOCM_RTS) { ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "set b & RTS"); b |= ASY_MCR_RTS; } if (bits & TIOCM_DTR) { ASY_DPRINTF(asy, ASY_DEBUG_MODEM, "set b & DTR"); b |= ASY_MCR_DTR; } return (b); } static void asyerror(const struct asycom *asy, int level, const char *fmt, ...) { va_list adx; static time_t last; static const char *lastfmt; time_t now; /* * Don't print the same error message too often. * Print the message only if we have not printed the * message within the last second. * Note: that fmt cannot be a pointer to a string * stored on the stack. The fmt pointer * must be in the data segment otherwise lastfmt would point * to non-sense. */ now = gethrestime_sec(); if (last == now && lastfmt == fmt) return; last = now; lastfmt = fmt; va_start(adx, fmt); vdev_err(asy->asy_dip, level, fmt, adx); va_end(adx); } /* * asy_parse_mode(dev_info_t *devi, struct asycom *asy) * The value of this property is in the form of "9600,8,n,1,-" * 1) speed: 9600, 4800, ... * 2) data bits * 3) parity: n(none), e(even), o(odd) * 4) stop bits * 5) handshake: -(none), h(hardware: rts/cts), s(software: xon/off) * * This parsing came from a SPARCstation eeprom. */ static void asy_parse_mode(dev_info_t *devi, struct asycom *asy) { char name[40]; char val[40]; int len; int ret; char *p; char *p1; ASSERT(asy->asy_com_port != 0); /* * Parse the ttyx-mode property */ (void) sprintf(name, "tty%c-mode", asy->asy_com_port + 'a' - 1); len = sizeof (val); ret = GET_PROP(devi, name, DDI_PROP_CANSLEEP, val, &len); if (ret != DDI_PROP_SUCCESS) { (void) sprintf(name, "com%c-mode", asy->asy_com_port + '0'); len = sizeof (val); ret = GET_PROP(devi, name, DDI_PROP_CANSLEEP, val, &len); } /* no property to parse */ asy->asy_cflag = 0; if (ret != DDI_PROP_SUCCESS) return; p = val; /* ---- baud rate ---- */ asy->asy_cflag = CREAD|B9600; /* initial default */ if (p && (p1 = strchr(p, ',')) != 0) { *p1++ = '\0'; } else { asy->asy_cflag |= ASY_LCR_BITS8; /* add default bits */ return; } if (strcmp(p, "110") == 0) asy->asy_bidx = B110; else if (strcmp(p, "150") == 0) asy->asy_bidx = B150; else if (strcmp(p, "300") == 0) asy->asy_bidx = B300; else if (strcmp(p, "600") == 0) asy->asy_bidx = B600; else if (strcmp(p, "1200") == 0) asy->asy_bidx = B1200; else if (strcmp(p, "2400") == 0) asy->asy_bidx = B2400; else if (strcmp(p, "4800") == 0) asy->asy_bidx = B4800; else if (strcmp(p, "9600") == 0) asy->asy_bidx = B9600; else if (strcmp(p, "19200") == 0) asy->asy_bidx = B19200; else if (strcmp(p, "38400") == 0) asy->asy_bidx = B38400; else if (strcmp(p, "57600") == 0) asy->asy_bidx = B57600; else if (strcmp(p, "115200") == 0) asy->asy_bidx = B115200; else asy->asy_bidx = B9600; asy->asy_cflag &= ~CBAUD; if (asy->asy_bidx > CBAUD) { /* > 38400 uses the CBAUDEXT bit */ asy->asy_cflag |= CBAUDEXT; asy->asy_cflag |= asy->asy_bidx - CBAUD - 1; } else { asy->asy_cflag |= asy->asy_bidx; } ASSERT(asy->asy_bidx == BAUDINDEX(asy->asy_cflag)); /* ---- Next item is data bits ---- */ p = p1; if (p && (p1 = strchr(p, ',')) != 0) { *p1++ = '\0'; } else { asy->asy_cflag |= ASY_LCR_BITS8; /* add default bits */ return; } switch (*p) { default: case '8': asy->asy_cflag |= CS8; asy->asy_lcr = ASY_LCR_BITS8; break; case '7': asy->asy_cflag |= CS7; asy->asy_lcr = ASY_LCR_BITS7; break; case '6': asy->asy_cflag |= CS6; asy->asy_lcr = ASY_LCR_BITS6; break; case '5': /* LINTED: CS5 is currently zero (but might change) */ asy->asy_cflag |= CS5; asy->asy_lcr = ASY_LCR_BITS5; break; } /* ---- Parity info ---- */ p = p1; if (p && (p1 = strchr(p, ',')) != 0) { *p1++ = '\0'; } else { return; } switch (*p) { default: case 'n': break; case 'e': asy->asy_cflag |= PARENB; asy->asy_lcr |= ASY_LCR_PEN; break; case 'o': asy->asy_cflag |= PARENB|PARODD; asy->asy_lcr |= ASY_LCR_PEN | ASY_LCR_EPS; break; } /* ---- Find stop bits ---- */ p = p1; if (p && (p1 = strchr(p, ',')) != 0) { *p1++ = '\0'; } else { return; } if (*p == '2') { asy->asy_cflag |= CSTOPB; asy->asy_lcr |= ASY_LCR_STB; } /* ---- handshake is next ---- */ p = p1; if (p) { if ((p1 = strchr(p, ',')) != 0) *p1++ = '\0'; if (*p == 'h') asy->asy_cflag |= CRTSCTS; else if (*p == 's') asy->asy_cflag |= CRTSXOFF; } } /* * Check for abort character sequence */ static boolean_t abort_charseq_recognize(uchar_t ch) { static int state = 0; #define CNTRL(c) ((c)&037) static char sequence[] = { '\r', '~', CNTRL('b') }; if (ch == sequence[state]) { if (++state >= sizeof (sequence)) { state = 0; return (B_TRUE); } } else { state = (ch == sequence[0]) ? 1 : 0; } return (B_FALSE); } /* * Flow control functions */ /* * Software input flow control * This function can execute software input flow control sucessfully * at most of situations except that the line is in BREAK status * (timed and untimed break). * INPUT VALUE of onoff: * FLOW_START means to send out a XON char * and clear SW input flow control flag. * FLOW_STOP means to send out a XOFF char * and set SW input flow control flag. * FLOW_CHECK means to check whether there is pending XON/XOFF * if it is true, send it out. * INPUT VALUE of type: * IN_FLOW_RINGBUFF means flow control is due to RING BUFFER * IN_FLOW_STREAMS means flow control is due to STREAMS * IN_FLOW_USER means flow control is due to user's commands * RETURN VALUE: B_FALSE means no flow control char is sent * B_TRUE means one flow control char is sent */ static boolean_t async_flowcontrol_sw_input(struct asycom *asy, async_flowc_action onoff, int type) { struct asyncline *async = asy->asy_priv; int rval = B_FALSE; ASSERT(mutex_owned(&asy->asy_excl_hi)); if (!(async->async_ttycommon.t_iflag & IXOFF)) return (rval); /* * If we get this far, then we know IXOFF is set. */ switch (onoff) { case FLOW_STOP: async->async_inflow_source |= type; /* * We'll send an XOFF character for each of up to * three different input flow control attempts to stop input. * If we already send out one XOFF, but FLOW_STOP comes again, * it seems that input flow control becomes more serious, * then send XOFF again. */ if (async->async_inflow_source & (IN_FLOW_RINGBUFF | IN_FLOW_STREAMS | IN_FLOW_USER)) async->async_flags |= ASYNC_SW_IN_FLOW | ASYNC_SW_IN_NEEDED; ASY_DPRINTF(asy, ASY_DEBUG_SFLOW, "input sflow stop, type = %x", async->async_inflow_source); break; case FLOW_START: async->async_inflow_source &= ~type; if (async->async_inflow_source == 0) { async->async_flags = (async->async_flags & ~ASYNC_SW_IN_FLOW) | ASYNC_SW_IN_NEEDED; ASY_DPRINTF(asy, ASY_DEBUG_SFLOW, "input sflow start"); } break; default: break; } if (((async->async_flags & (ASYNC_SW_IN_NEEDED | ASYNC_BREAK | ASYNC_OUT_SUSPEND)) == ASYNC_SW_IN_NEEDED) && (asy_get(asy, ASY_LSR) & ASY_LSR_THRE)) { /* * If we get this far, then we know we need to send out * XON or XOFF char. */ async->async_flags = (async->async_flags & ~ASYNC_SW_IN_NEEDED) | ASYNC_BUSY; asy_put(asy, ASY_THR, async->async_flags & ASYNC_SW_IN_FLOW ? async->async_stopc : async->async_startc); rval = B_TRUE; } return (rval); } /* * Software output flow control * This function can be executed sucessfully at any situation. * It does not handle HW, and just change the SW output flow control flag. * INPUT VALUE of onoff: * FLOW_START means to clear SW output flow control flag, * also combine with HW output flow control status to * determine if we need to set ASYNC_OUT_FLW_RESUME. * FLOW_STOP means to set SW output flow control flag, * also clear ASYNC_OUT_FLW_RESUME. */ static void async_flowcontrol_sw_output(struct asycom *asy, async_flowc_action onoff) { struct asyncline *async = asy->asy_priv; ASSERT(mutex_owned(&asy->asy_excl_hi)); if (!(async->async_ttycommon.t_iflag & IXON)) return; switch (onoff) { case FLOW_STOP: async->async_flags |= ASYNC_SW_OUT_FLW; async->async_flags &= ~ASYNC_OUT_FLW_RESUME; ASY_DPRINTF(asy, ASY_DEBUG_SFLOW, "output sflow stop"); break; case FLOW_START: async->async_flags &= ~ASYNC_SW_OUT_FLW; if (!(async->async_flags & ASYNC_HW_OUT_FLW)) async->async_flags |= ASYNC_OUT_FLW_RESUME; ASY_DPRINTF(asy, ASY_DEBUG_SFLOW, "output sflow start"); break; default: break; } } /* * Hardware input flow control * This function can be executed sucessfully at any situation. * It directly changes RTS depending on input parameter onoff. * INPUT VALUE of onoff: * FLOW_START means to clear HW input flow control flag, * and pull up RTS if it is low. * FLOW_STOP means to set HW input flow control flag, * and low RTS if it is high. * INPUT VALUE of type: * IN_FLOW_RINGBUFF means flow control is due to RING BUFFER * IN_FLOW_STREAMS means flow control is due to STREAMS * IN_FLOW_USER means flow control is due to user's commands */ static void async_flowcontrol_hw_input(struct asycom *asy, async_flowc_action onoff, int type) { uchar_t mcr; uchar_t flag; struct asyncline *async = asy->asy_priv; ASSERT(mutex_owned(&asy->asy_excl_hi)); if (!(async->async_ttycommon.t_cflag & CRTSXOFF)) return; switch (onoff) { case FLOW_STOP: async->async_inflow_source |= type; if (async->async_inflow_source & (IN_FLOW_RINGBUFF | IN_FLOW_STREAMS | IN_FLOW_USER)) async->async_flags |= ASYNC_HW_IN_FLOW; ASY_DPRINTF(asy, ASY_DEBUG_HFLOW, "input hflow stop, type = %x", async->async_inflow_source); break; case FLOW_START: async->async_inflow_source &= ~type; if (async->async_inflow_source == 0) { async->async_flags &= ~ASYNC_HW_IN_FLOW; ASY_DPRINTF(asy, ASY_DEBUG_HFLOW, "input hflow start"); } break; default: break; } mcr = asy_get(asy, ASY_MCR); flag = (async->async_flags & ASYNC_HW_IN_FLOW) ? 0 : ASY_MCR_RTS; if (((mcr ^ flag) & ASY_MCR_RTS) != 0) { asy_put(asy, ASY_MCR, (mcr ^ ASY_MCR_RTS)); } } /* * Hardware output flow control * This function can execute HW output flow control sucessfully * at any situation. * It doesn't really change RTS, and just change * HW output flow control flag depending on CTS status. * INPUT VALUE of onoff: * FLOW_START means to clear HW output flow control flag. * also combine with SW output flow control status to * determine if we need to set ASYNC_OUT_FLW_RESUME. * FLOW_STOP means to set HW output flow control flag. * also clear ASYNC_OUT_FLW_RESUME. */ static void async_flowcontrol_hw_output(struct asycom *asy, async_flowc_action onoff) { struct asyncline *async = asy->asy_priv; ASSERT(mutex_owned(&asy->asy_excl_hi)); if (!(async->async_ttycommon.t_cflag & CRTSCTS)) return; switch (onoff) { case FLOW_STOP: async->async_flags |= ASYNC_HW_OUT_FLW; async->async_flags &= ~ASYNC_OUT_FLW_RESUME; ASY_DPRINTF(asy, ASY_DEBUG_HFLOW, "output hflow stop"); break; case FLOW_START: async->async_flags &= ~ASYNC_HW_OUT_FLW; if (!(async->async_flags & ASYNC_SW_OUT_FLW)) async->async_flags |= ASYNC_OUT_FLW_RESUME; ASY_DPRINTF(asy, ASY_DEBUG_HFLOW, "output hflow start"); break; default: break; } } /* * quiesce(9E) entry point. * * This function is called when the system is single-threaded at high * PIL with preemption disabled. Therefore, this function must not be * blocked. * * This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure. * DDI_FAILURE indicates an error condition and should almost never happen. */ static int asyquiesce(dev_info_t *devi) { int instance; struct asycom *asy; instance = ddi_get_instance(devi); /* find out which unit */ asy = ddi_get_soft_state(asy_soft_state, instance); if (asy == NULL) return (DDI_FAILURE); asy_disable_interrupts(asy, ASY_IER_ALL); /* Flush the FIFOs, if required */ if (asy->asy_use_fifo == ASY_FCR_FIFO_EN) { asy_reset_fifo(asy, ASY_FCR_THR_FL | ASY_FCR_RHR_FL); } return (DDI_SUCCESS); }