static bool com_isa_resume(device_t self, const pmf_qual_t *qual) { struct com_isa_softc *isc = device_private(self); struct com_softc *sc = &isc->sc_com; isc->sc_ih = isa_intr_establish(isc->sc_ic, isc->sc_irq, IST_EDGE, IPL_SERIAL, comintr, sc); return com_resume(self, qual); }
static bool com_isa_resume(device_t self PMF_FN_ARGS) { struct com_isa_softc *isc = device_private(self); struct com_softc *sc = &isc->sc_com; isc->sc_ih = isa_intr_establish(isc->sc_ic, isc->sc_irq, IST_EDGE, IPL_SERIAL, comintr, sc); return com_resume(self PMF_FN_CALL); }
void com_isa_attach(struct device *parent, struct device *self, void *aux) { struct com_softc *sc = (struct com_softc *)self; struct isa_attach_args *ia = aux; bus_space_handle_t ioh; bus_space_tag_t iot; int iobase, irq; sc->sc_hwflags = 0; sc->sc_swflags = 0; iobase = ia->ia_iobase; iot = ia->ia_iot; #ifdef KGDB if ((iobase != comconsaddr) && (iobase != com_kgdb_addr)) { #else if (iobase != comconsaddr) { #endif if (bus_space_map(iot, iobase, COM_NPORTS, 0, &ioh)) panic("com_isa_attach: mapping failed"); } else { #ifdef KGDB if (iobase == comconsaddr) ioh = comconsioh; else ioh = com_kgdb_ioh; #else ioh = comconsioh; #endif } sc->sc_iot = iot; sc->sc_ioh = ioh; sc->sc_iobase = iobase; sc->sc_frequency = COM_FREQ; com_attach_subr(sc); irq = ia->ia_irq; if (irq != IRQUNK) { #ifdef KGDB if (iobase == com_kgdb_addr) { sc->sc_ih = isa_intr_establish(ia->ia_ic, irq, IST_EDGE, IPL_HIGH, kgdbintr, sc, sc->sc_dev.dv_xname); } else { sc->sc_ih = isa_intr_establish(ia->ia_ic, irq, IST_EDGE, IPL_TTY, comintr, sc, sc->sc_dev.dv_xname); } #else sc->sc_ih = isa_intr_establish(ia->ia_ic, irq, IST_EDGE, IPL_TTY, comintr, sc, sc->sc_dev.dv_xname); #endif /* KGDB */ } } int com_isa_activate(struct device *self, int act) { struct com_softc *sc = (struct com_softc *)self; switch (act) { case DVACT_SUSPEND: break; case DVACT_RESUME: com_resume(sc); break; } return (0); }
static int dosim( char *what, /* in: command (pz,op,dc,ac,tf,tran,sens,disto,noise,run) */ wordlist *wl /* in: command option */ /* global variables in: ft_curckt, ft_circuits, out: ft_setflag, ft_intrpt, rawfileFp, rawfileBinary, last_used_rawfile */ ) { wordlist *ww = NULL; bool dofile = FALSE; char buf[BSIZE_SP]; struct circ *ct; int err = 0; /* set file type to binary or to what is given by environmental variable SPICE_ASCIIRAWFILE in ivars.c */ bool ascii = AsciiRawFile; if (eq(what, "run") && wl) dofile = TRUE; /* add "what" to beginning of wordlist wl, except "what" equals "run" and a rawfile name is given (in wl) */ if (!dofile) { ww = wl_cons(copy(what), wl); } /* reset output file type according to variable given in spinit */ if (cp_getvar("filetype", CP_STRING, buf)) { if (eq(buf, "binary")) ascii = FALSE; else if (eq(buf, "ascii")) ascii = TRUE; else { fprintf(cp_err, "Warning: strange file type \"%s\" (using \"ascii\")\n", buf); ascii = TRUE; } } if (!ft_curckt) { fprintf(cp_err, "Error: there aren't any circuits loaded.\n"); return 1; } else if (ft_curckt->ci_ckt == NULL) { /* Set noparse? */ fprintf(cp_err, "Error: circuit not parsed.\n"); return 1; } for (ct = ft_circuits; ct; ct = ct->ci_next) if (ct->ci_inprogress && (ct != ft_curckt)) { fprintf(cp_err, "Warning: losing old state for circuit '%s'\n", ct->ci_name); ct->ci_inprogress = FALSE; } /* "resume" will never occur in ngspice */ if (ft_curckt->ci_inprogress && eq(what, "resume")) { ft_setflag = TRUE; /* don't allow abort upon interrupt during run */ ft_intrpt = FALSE; fprintf(cp_err, "Warning: resuming run in progress.\n"); com_resume(NULL); ft_setflag = FALSE; /* Now allow aborts again */ return 0; } /* From now on until the next prompt, an interrupt will just * set a flag and let spice finish up, then control will be * passed back to the user. */ ft_setflag = TRUE; /* Don't allow abort upon interrupt during run. */ ft_intrpt = FALSE; /* command "run" is given with rawfile name in wl */ if (dofile) { if (!*wl->wl_word) rawfileFp = stdout; #if defined(__MINGW32__) || defined(_MSC_VER) /* ask if binary or ASCII, open file with wb or w */ else if (ascii) { if ((rawfileFp = fopen(wl->wl_word, "w")) == NULL) { perror(wl->wl_word); ft_setflag = FALSE; return 1; } fprintf(cp_out, "ASCII raw file\n"); } else if (!ascii) { if ((rawfileFp = fopen(wl->wl_word, "wb")) == NULL) { perror(wl->wl_word); ft_setflag = FALSE; return 1; } fprintf(cp_out, "binary raw file\n"); } /*---------------------------------------------------------------------------*/ #else else if (!(rawfileFp = fopen(wl->wl_word, "w"))) { setvbuf(rawfileFp, rawfileBuf, _IOFBF, RAWBUF_SIZE); perror(wl->wl_word); ft_setflag = FALSE; return 1; } #endif /* __MINGW32__ */ rawfileBinary = !ascii; } else { rawfileFp = NULL; } /*save rawfile name */ if (last_used_rawfile) tfree(last_used_rawfile); if (rawfileFp) last_used_rawfile = copy(wl->wl_word); else last_used_rawfile = NULL; ft_curckt->ci_inprogress = TRUE; /* "sens2" not used in ngspice */ if (eq(what, "sens2")) { if (if_sens_run(ft_curckt->ci_ckt, ww, ft_curckt->ci_symtab) == 1) { /* The circuit was interrupted somewhere. */ fprintf(cp_err, "%s simulation interrupted\n", what); #ifdef XSPICE /* gtri - add - 12/12/90 - wbk - record error and return errchk */ g_ipc.run_error = IPC_TRUE; if (g_ipc.enabled) ipc_send_errchk(); /* gtri - end - 12/12/90 */ #endif } else { ft_curckt->ci_inprogress = FALSE; } /* Do a run of the circuit */ } else { err = if_run(ft_curckt->ci_ckt, what, ww, ft_curckt->ci_symtab); if (err == 1) { /* The circuit was interrupted somewhere. */ fprintf(cp_err, "%s simulation interrupted\n", what); #ifdef XSPICE /* record error and return errchk */ g_ipc.run_error = IPC_TRUE; if (g_ipc.enabled) ipc_send_errchk(); /* gtri - end - 12/12/90 */ #endif err = 0; } else if (err == 2) { fprintf(cp_err, "%s simulation(s) aborted\n", what); ft_curckt->ci_inprogress = FALSE; err = 1; } else { ft_curckt->ci_inprogress = FALSE; } } /* close the rawfile */ if (rawfileFp) { if (ftell(rawfileFp) == 0) { (void) fclose(rawfileFp); (void) unlink(wl->wl_word); } else { (void) fclose(rawfileFp); } } ft_curckt->ci_runonce = TRUE; ft_setflag = FALSE; /* va: garbage collection: unlink first word (inserted here) and tfree it */ if (!dofile) { tfree(ww->wl_word); if (wl) wl->wl_prev = NULL; tfree(ww); } /* execute the .measure statements */ if (!err && ft_curckt->ci_last_an && ft_curckt->ci_meas) do_measure(ft_curckt->ci_last_an, FALSE); return err; }
int com_activate(struct device *self, int act) { struct com_softc *sc = (struct com_softc *)self; int s, rv = 0; switch (act) { case DVACT_SUSPEND: if (timeout_del(&sc->sc_dtr_tmo)) { /* Make sure DTR gets raised upon resume. */ SET(sc->sc_mcr, MCR_DTR | MCR_RTS); } timeout_del(&sc->sc_diag_tmo); break; case DVACT_RESUME: com_resume(sc); break; case DVACT_DEACTIVATE: #ifdef KGDB if (sc->sc_hwflags & (COM_HW_CONSOLE|COM_HW_KGDB)) { #else if (sc->sc_hwflags & COM_HW_CONSOLE) { #endif /* KGDB */ rv = EBUSY; break; } s = spltty(); if (sc->disable != NULL && sc->enabled != 0) { (*sc->disable)(sc); sc->enabled = 0; } splx(s); break; } return (rv); } int comopen(dev_t dev, int flag, int mode, struct proc *p) { int unit = DEVUNIT(dev); struct com_softc *sc; bus_space_tag_t iot; bus_space_handle_t ioh; struct tty *tp; int s; int error = 0; if (unit >= com_cd.cd_ndevs) return ENXIO; sc = com_cd.cd_devs[unit]; if (!sc) return ENXIO; #ifdef KGDB /* * If this is the kgdb port, no other use is permitted. */ if (ISSET(sc->sc_hwflags, COM_HW_KGDB)) return (EBUSY); #endif /* KGDB */ s = spltty(); if (!sc->sc_tty) { tp = sc->sc_tty = ttymalloc(1000000); } else tp = sc->sc_tty; splx(s); tp->t_oproc = comstart; tp->t_param = comparam; tp->t_dev = dev; if (!ISSET(tp->t_state, TS_ISOPEN)) { SET(tp->t_state, TS_WOPEN); ttychars(tp); tp->t_iflag = TTYDEF_IFLAG; tp->t_oflag = TTYDEF_OFLAG; #ifdef COM_CONSOLE if (ISSET(sc->sc_hwflags, COM_HW_CONSOLE)) { tp->t_cflag = comconscflag; tp->t_ispeed = tp->t_ospeed = comconsrate; } else #endif { tp->t_cflag = TTYDEF_CFLAG; tp->t_ispeed = tp->t_ospeed = comdefaultrate; } if (ISSET(sc->sc_swflags, COM_SW_CLOCAL)) SET(tp->t_cflag, CLOCAL); if (ISSET(sc->sc_swflags, COM_SW_CRTSCTS)) SET(tp->t_cflag, CRTSCTS); if (ISSET(sc->sc_swflags, COM_SW_MDMBUF)) SET(tp->t_cflag, MDMBUF); tp->t_lflag = TTYDEF_LFLAG; s = spltty(); sc->sc_initialize = 1; comparam(tp, &tp->t_termios); ttsetwater(tp); sc->sc_ibufp = sc->sc_ibuf = sc->sc_ibufs[0]; sc->sc_ibufhigh = sc->sc_ibuf + COM_IHIGHWATER; sc->sc_ibufend = sc->sc_ibuf + COM_IBUFSIZE; iot = sc->sc_iot; ioh = sc->sc_ioh; /* * Wake up the sleepy heads. */ if (!ISSET(sc->sc_hwflags, COM_HW_CONSOLE)) { switch (sc->sc_uarttype) { case COM_UART_ST16650: case COM_UART_ST16650V2: bus_space_write_1(iot, ioh, com_lcr, LCR_EFR); bus_space_write_1(iot, ioh, com_efr, EFR_ECB); bus_space_write_1(iot, ioh, com_ier, 0); bus_space_write_1(iot, ioh, com_efr, 0); bus_space_write_1(iot, ioh, com_lcr, 0); break; case COM_UART_TI16750: bus_space_write_1(iot, ioh, com_ier, 0); break; case COM_UART_PXA2X0: bus_space_write_1(iot, ioh, com_ier, IER_EUART); break; } } if (ISSET(sc->sc_hwflags, COM_HW_FIFO)) { u_int8_t fifo = FIFO_ENABLE|FIFO_RCV_RST|FIFO_XMT_RST; u_int8_t lcr; if (tp->t_ispeed <= 1200) fifo |= FIFO_TRIGGER_1; else if (tp->t_ispeed <= 38400) fifo |= FIFO_TRIGGER_4; else fifo |= FIFO_TRIGGER_8; if (sc->sc_uarttype == COM_UART_TI16750) { fifo |= FIFO_ENABLE_64BYTE; lcr = bus_space_read_1(iot, ioh, com_lcr); bus_space_write_1(iot, ioh, com_lcr, lcr | LCR_DLAB); } /* * (Re)enable and drain FIFOs. * * Certain SMC chips cause problems if the FIFOs are * enabled while input is ready. Turn off the FIFO * if necessary to clear the input. Test the input * ready bit after enabling the FIFOs to handle races * between enabling and fresh input. * * Set the FIFO threshold based on the receive speed. */ for (;;) { bus_space_write_1(iot, ioh, com_fifo, 0); delay(100); (void) bus_space_read_1(iot, ioh, com_data); bus_space_write_1(iot, ioh, com_fifo, fifo | FIFO_RCV_RST | FIFO_XMT_RST); delay(100); if(!ISSET(bus_space_read_1(iot, ioh, com_lsr), LSR_RXRDY)) break; } if (sc->sc_uarttype == COM_UART_TI16750) bus_space_write_1(iot, ioh, com_lcr, lcr); } /* Flush any pending I/O. */ while (ISSET(bus_space_read_1(iot, ioh, com_lsr), LSR_RXRDY)) (void) bus_space_read_1(iot, ioh, com_data); /* You turn me on, baby! */ sc->sc_mcr = MCR_DTR | MCR_RTS; if (!ISSET(sc->sc_hwflags, COM_HW_NOIEN)) SET(sc->sc_mcr, MCR_IENABLE); bus_space_write_1(iot, ioh, com_mcr, sc->sc_mcr); sc->sc_ier = IER_ERXRDY | IER_ERLS | IER_EMSC; #ifdef COM_PXA2X0 if (sc->sc_uarttype == COM_UART_PXA2X0) sc->sc_ier |= IER_EUART | IER_ERXTOUT; #endif bus_space_write_1(iot, ioh, com_ier, sc->sc_ier); sc->sc_msr = bus_space_read_1(iot, ioh, com_msr); if (ISSET(sc->sc_swflags, COM_SW_SOFTCAR) || DEVCUA(dev) || ISSET(sc->sc_msr, MSR_DCD) || ISSET(tp->t_cflag, MDMBUF)) SET(tp->t_state, TS_CARR_ON); else CLR(tp->t_state, TS_CARR_ON); #ifdef COM_PXA2X0 if (sc->sc_uarttype == COM_UART_PXA2X0 && ISSET(sc->sc_hwflags, COM_HW_SIR)) { bus_space_write_1(iot, ioh, com_isr, ISR_RECV); #ifdef __zaurus__ scoop_set_irled(1); #endif } #endif } else if (ISSET(tp->t_state, TS_XCLUDE) && suser(p, 0) != 0) return EBUSY; else s = spltty(); if (DEVCUA(dev)) { if (ISSET(tp->t_state, TS_ISOPEN)) { /* Ah, but someone already is dialed in... */ splx(s); return EBUSY; } sc->sc_cua = 1; /* We go into CUA mode. */ } else { /* tty (not cua) device; wait for carrier if necessary. */ if (ISSET(flag, O_NONBLOCK)) { if (sc->sc_cua) { /* Opening TTY non-blocking... but the CUA is busy. */ splx(s); return EBUSY; } } else { while (sc->sc_cua || (!ISSET(tp->t_cflag, CLOCAL) && !ISSET(tp->t_state, TS_CARR_ON))) { SET(tp->t_state, TS_WOPEN); error = ttysleep(tp, &tp->t_rawq, TTIPRI | PCATCH, ttopen, 0); /* * If TS_WOPEN has been reset, that means the cua device * has been closed. We don't want to fail in that case, * so just go around again. */ if (error && ISSET(tp->t_state, TS_WOPEN)) { CLR(tp->t_state, TS_WOPEN); if (!sc->sc_cua && !ISSET(tp->t_state, TS_ISOPEN)) compwroff(sc); splx(s); return error; } } } } splx(s); return (*linesw[tp->t_line].l_open)(dev, tp, p); }