diff options
Diffstat (limited to 'sys/arch/sparc64/dev')
| -rw-r--r-- | sys/arch/sparc64/dev/cons.h | 69 | ||||
| -rw-r--r-- | sys/arch/sparc64/dev/consinit.c | 229 | ||||
| -rw-r--r-- | sys/arch/sparc64/dev/ebusreg.h | 95 | ||||
| -rw-r--r-- | sys/arch/sparc64/dev/ebusvar.h | 80 | ||||
| -rw-r--r-- | sys/arch/sparc64/dev/pcons.c | 501 | ||||
| -rw-r--r-- | sys/arch/sparc64/dev/zs.c | 872 |
6 files changed, 1846 insertions, 0 deletions
diff --git a/sys/arch/sparc64/dev/cons.h b/sys/arch/sparc64/dev/cons.h new file mode 100644 index 00000000000..6dd5fd15136 --- /dev/null +++ b/sys/arch/sparc64/dev/cons.h @@ -0,0 +1,69 @@ +/* $OpenBSD: cons.h,v 1.1 2001/08/19 05:21:37 jason Exp $ */ +/* $NetBSD: cons.h,v 1.3 2000/05/19 05:26:17 eeh Exp $ */ + +/*- + * Copyright (c) 2000 Eduardo E. Horvath + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * PROM console driver. + * + * This is the default fallback console driver if nothing else attaches. + */ + +struct pconssoftc { + struct device of_dev; + struct tty *of_tty; + struct timeout sc_poll_to; + int of_flags; +}; +/* flags: */ +#define OFPOLL 1 + +#define OFBURSTLEN 128 /* max number of bytes to write in one chunk */ + +/* These are shared with the consinit OBP console */ +extern int stdin, stdout; +void pcons_cnpollc __P((dev_t dev, int on)); + +struct consdev; +struct zs_chanstate; + +extern void *zs_conschan; + +extern void nullcnprobe __P((struct consdev *)); + +extern int zs_getc __P((void *arg)); +extern void zs_putc __P((void *arg, int c)); + +struct zschan * +zs_get_chan_addr __P((int zsc_unit, int channel)); + +#ifdef KGDB +void zs_kgdb_init __P((void)); +void zskgdb __P((struct zs_chanstate *)); +#endif diff --git a/sys/arch/sparc64/dev/consinit.c b/sys/arch/sparc64/dev/consinit.c new file mode 100644 index 00000000000..bf81246934f --- /dev/null +++ b/sys/arch/sparc64/dev/consinit.c @@ -0,0 +1,229 @@ +/* $NetBSD: consinit.c,v 1.9 2000/10/20 05:32:35 mrg Exp $ */ + +/*- + * Copyright (c) 1999 Eduardo E. Horvath + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include "pcons.h" + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/conf.h> +#include <sys/device.h> +#include <sys/file.h> +#include <sys/ioctl.h> +#include <sys/kernel.h> +#include <sys/proc.h> +#include <sys/tty.h> +#include <sys/time.h> +#include <sys/syslog.h> + +#include <machine/autoconf.h> +#include <machine/openfirm.h> +#include <machine/bsd_openprom.h> +#include <machine/conf.h> +#include <machine/cpu.h> +#include <machine/eeprom.h> +#include <machine/psl.h> +#include <machine/z8530var.h> +#include <machine/sparc64.h> + +#include <dev/cons.h> + +#include <sparc64/dev/cons.h> + +static void prom_cnprobe __P((struct consdev *)); +static void prom_cninit __P((struct consdev *)); +int prom_cngetc __P((dev_t)); +static void prom_cnputc __P((dev_t, int)); +static void prom_cnpollc __P((dev_t, int)); +static void prom_cnputc __P((dev_t, int)); + +int stdin = NULL, stdout = NULL; + +/* + * The console is set to this one initially, + * which lets us use the PROM until consinit() + * is called to select a real console. + */ +struct consdev consdev_prom = { + prom_cnprobe, + prom_cninit, + prom_cngetc, + prom_cnputc, + prom_cnpollc, + NULL, +}; + +/* + * The console table pointer is statically initialized + * to point to the PROM (output only) table, so that + * early calls to printf will work. + */ +struct consdev *cn_tab = &consdev_prom; + +void +prom_cnprobe(cd) + struct consdev *cd; +{ +#if NPCONS > 0 + int maj; + + for (maj = 0; maj < nchrdev; maj++) + if (cdevsw[maj].d_open == pconsopen) + break; + cd->cn_dev = makedev(maj, 0); + cd->cn_pri = CN_INTERNAL; +#endif +} + +int +prom_cngetc(dev) + dev_t dev; +{ + unsigned char ch = '\0'; + int l; +#ifdef DDB + static int nplus = 0; +#endif + + while ((l = OF_read(stdin, &ch, 1)) != 1) + /* void */; +#ifdef DDB + if (ch == '+') { + if (nplus++ > 3) Debugger(); + } else nplus = 0; +#endif + if (ch == '\r') + ch = '\n'; + return ch; +} + +static void +prom_cninit(cn) + struct consdev *cn; +{ + if (!stdin) stdin = OF_stdin(); + if (!stdout) stdout = OF_stdout(); +} + +/* + * PROM console output putchar. + */ +static void +prom_cnputc(dev, c) + dev_t dev; + int c; +{ + int s; + char c0 = (c & 0x7f); + +#if 0 + if (!stdout) stdout = OF_stdout(); +#endif + s = splhigh(); + OF_write(stdout, &c0, 1); + splx(s); +} + +void +prom_cnpollc(dev, on) + dev_t dev; + int on; +{ + if (on) { + /* Entering debugger. */ +#if NFB > 0 + fb_unblank(); +#endif + } else { + /* Resuming kernel. */ + } +#if NPCONS > 0 + pcons_cnpollc(dev, on); +#endif +} + +/*****************************************************************/ + +#ifdef DEBUG +#define DBPRINT(x) prom_printf x +#else +#define DBPRINT(x) +#endif + +/* + * This function replaces sys/dev/cninit.c + * Determine which device is the console using + * the PROM "input source" and "output sink". + */ +void +consinit() +{ + register int chosen; + char buffer[128]; + extern int stdinnode, fbnode; + char *consname = "unknown"; + + DBPRINT(("consinit()\r\n")); + if (cn_tab != &consdev_prom) return; + + DBPRINT(("setting up stdin\r\n")); + chosen = OF_finddevice("/chosen"); + OF_getprop(chosen, "stdin", &stdin, sizeof(stdin)); + DBPRINT(("stdin instance = %x\r\n", stdin)); + + if ((stdinnode = OF_instance_to_package(stdin)) == 0) { + printf("WARNING: no PROM stdin\n"); + } + + DBPRINT(("setting up stdout\r\n")); + OF_getprop(chosen, "stdout", &stdout, sizeof(stdout)); + + DBPRINT(("stdout instance = %x\r\n", stdout)); + + if ((fbnode = OF_instance_to_package(stdout)) == 0) + printf("WARNING: no PROM stdout\n"); + + DBPRINT(("stdout package = %x\r\n", fbnode)); + + if (stdinnode && (OF_getproplen(stdinnode,"keyboard") >= 0)) { +#if NKBD > 0 + printf("cninit: kdb/display not configured\n"); +#endif + consname = "keyboard/display"; + } else if (fbnode && + (OF_instance_to_path(stdinnode, buffer, sizeof(buffer) >= 0))) { + consname = buffer; + } + printf("console is %s\n", consname); + + /* Initialize PROM console */ + (*cn_tab->cn_probe)(cn_tab); + (*cn_tab->cn_init)(cn_tab); +} + diff --git a/sys/arch/sparc64/dev/ebusreg.h b/sys/arch/sparc64/dev/ebusreg.h new file mode 100644 index 00000000000..5ef7651212d --- /dev/null +++ b/sys/arch/sparc64/dev/ebusreg.h @@ -0,0 +1,95 @@ +/* $NetBSD: ebusreg.h,v 1.1 1999/06/04 13:29:13 mrg Exp $ */ + +/* + * Copyright (c) 1999 Matthew R. Green + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SPARC64_DEV_EBUSREG_H_ +#define _SPARC64_DEV_EBUSREG_H_ + +/* + * UltraSPARC `ebus' + * + * The `ebus' bus is designed to plug traditional PC-ISA devices into + * an SPARC system with as few costs as possible, without sacrificing + * to performance. Typically, it is implemented in the PCIO IC from + * SME, which also implements a `hme-compatible' PCI network device + * (`network'). The ebus has 4 DMA channels, similar to the DMA seen + * in the ESP SCSI DMA. + * + * Typical UltraSPARC systems have a NatSemi SuperIO IC to provide + * serial ports for the keyboard and mouse (`se'), floppy disk + * controller (`fdthree'), parallel port controller (`bpp') connected + * to the ebus, and a PCI-IDE controller (connected directly to the + * PCI bus, of course), as well as a Siemens Nixdorf SAB82532 dual + * channel serial controller (`su' providing ttya and ttyb), an MK48T59 + * EEPROM/clock controller (also where the idprom, including the + * ethernet address, is located), the audio system (`SUNW,CS4231', same + * as other UltraSPARC and some SPARC systems), and other various + * internal devices found on traditional SPARC systems such as the + * `power', `flashprom', etc., devices. + * + * The ebus uses an interrupt mapping scheme similar to PCI, though + * the actual structures are different. + */ + +/* + * ebus PROM structures + */ + +struct ebus_regs { + u_int32_t hi; /* high bits of physaddr */ + u_int32_t lo; + u_int32_t size; +}; + +#define EBUS_PADDR_FROM_REG(reg) ((((paddr_t)((reg)->hi)) << 32UL) | ((paddr_t)(reg)->lo)) + +struct ebus_ranges { + u_int32_t child_hi; /* child high phys addr */ + u_int32_t child_lo; /* child low phys addr */ + u_int32_t phys_hi; /* parent high phys addr */ + u_int32_t phys_mid; /* parent mid phys addr */ + u_int32_t phys_lo; /* parent low phys addr */ + u_int32_t size; +}; + +struct ebus_interrupt_map { + u_int32_t hi; /* high phys addr mask */ + u_int32_t lo; /* low phys addr mask */ + u_int32_t intr; /* interrupt mask */ + int32_t cnode; /* child node */ + u_int32_t cintr; /* child interrupt */ +}; + +struct ebus_interrupt_map_mask { + u_int32_t hi; /* high phys addr */ + u_int32_t lo; /* low phys addr */ + u_int32_t intr; /* interrupt */ +}; + +#endif /* _SPARC64_DEV_EBUSREG_H_ */ diff --git a/sys/arch/sparc64/dev/ebusvar.h b/sys/arch/sparc64/dev/ebusvar.h new file mode 100644 index 00000000000..af3827822e2 --- /dev/null +++ b/sys/arch/sparc64/dev/ebusvar.h @@ -0,0 +1,80 @@ +/* $NetBSD: ebusvar.h,v 1.5 2001/07/20 00:07:13 eeh Exp $ */ + +/* + * Copyright (c) 1999, 2000 Matthew R. Green + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef _SPARC64_DEV_EBUSVAR_H_ +#define _SPARC64_DEV_EBUSVAR_H_ + +/* + * ebus arguments; ebus attaches to a pci, and devices attach + * to the ebus. + */ + +struct ebus_attach_args { + char *ea_name; /* PROM name */ + int ea_node; /* PROM node */ + + bus_space_tag_t ea_bustag; + bus_dma_tag_t ea_dmatag; + + struct ebus_regs *ea_regs; /* registers */ + u_int32_t *ea_vaddrs; /* virtual addrs */ + u_int32_t *ea_intrs; /* interrupts */ + + int ea_nregs; /* number of them */ + int ea_nvaddrs; + int ea_nintrs; +}; + +struct ebus_softc { + struct device sc_dev; + struct psycho_softc *sc_parent; /* for iommu */ + + int sc_node; + + bus_space_tag_t sc_memtag; /* from pci */ + bus_space_tag_t sc_iotag; /* from pci */ + bus_space_tag_t sc_childbustag; /* pass to children */ + bus_dma_tag_t sc_dmatag; /* XXX */ + + struct ebus_ranges *sc_range; + struct ebus_interrupt_map *sc_intmap; + struct ebus_interrupt_map_mask sc_intmapmask; + + int sc_nrange; /* counters */ + int sc_nintmap; +}; + +bus_dma_tag_t ebus_alloc_dma_tag __P((struct ebus_softc *, bus_dma_tag_t)); +bus_space_tag_t ebus_alloc_bus_tag __P((struct ebus_softc *, int)); + +#define ebus_bus_map(t, bt, a, s, f, v, hp) \ + bus_space_map2(t, bt, a, s, f, v, hp) + +#endif /* _SPARC64_DEV_EBUSVAR_H_ */ diff --git a/sys/arch/sparc64/dev/pcons.c b/sys/arch/sparc64/dev/pcons.c new file mode 100644 index 00000000000..1c919bf14fb --- /dev/null +++ b/sys/arch/sparc64/dev/pcons.c @@ -0,0 +1,501 @@ +/* $OpenBSD: pcons.c,v 1.1 2001/08/19 05:21:37 jason Exp $ */ +/* $NetBSD: pcons.c,v 1.7 2001/05/02 10:32:20 scw Exp $ */ + +/*- + * Copyright (c) 2000 Eduardo E. Horvath + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * Default console driver. Uses the PROM or whatever + * driver(s) are appropriate. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/conf.h> +#include <sys/device.h> +#include <sys/file.h> +#include <sys/ioctl.h> +#include <sys/kernel.h> +#include <sys/proc.h> +#include <sys/tty.h> +#include <sys/time.h> +#include <sys/syslog.h> + +#include <machine/autoconf.h> +#include <machine/openfirm.h> +#include <machine/bsd_openprom.h> +#include <machine/conf.h> +#include <machine/cpu.h> +#include <machine/eeprom.h> +#include <machine/psl.h> + +#include <dev/cons.h> + +/* XXXXXXXX - this is in MI code in NetBSD */ +/* + * Stuff to handle debugger magic key sequences. + */ +#define CNS_LEN 128 +#define CNS_MAGIC_VAL(x) ((x)&0x1ff) +#define CNS_MAGIC_NEXT(x) (((x)>>9)&0x7f) +#define CNS_TERM 0x7f /* End of sequence */ + +typedef struct cnm_state { + int cnm_state; + u_short *cnm_magic; +} cnm_state_t; +extern int db_console; +#ifdef DDB +#define cn_trap() do { if (db_console) Debugger(); } while (0) +#else +#define cn_trap() +#endif +#define cn_isconsole(d) ((d) == cn_tab->cn_dev) +void cn_init_magic __P((cnm_state_t *cnm)); +void cn_destroy_magic __P((cnm_state_t *cnm)); +int cn_set_magic __P((char *magic)); +int cn_get_magic __P((char *magic, int len)); +/* This should be called for each byte read */ +#ifndef cn_check_magic +#define cn_check_magic(d, k, s) \ + do { \ + if (cn_isconsole(d)) { \ + int v = (s).cnm_magic[(s).cnm_state]; \ + if ((k) == CNS_MAGIC_VAL(v)) { \ + (s).cnm_state = CNS_MAGIC_NEXT(v); \ + if ((s).cnm_state == CNS_TERM) { \ + cn_trap(); \ + (s).cnm_state = 0; \ + } \ + } else { \ + (s).cnm_state = 0; \ + } \ + } \ + } while (/* CONSTCOND */ 0) +#endif + +/* Encode out-of-band events this way when passing to cn_check_magic() */ +#define CNC_BREAK 0x100 + +/* XXXXXXXXXX - end of this part of cnmagic, more at the end of this file. */ + +#include <sparc64/dev/cons.h> + +static int pconsmatch __P((struct device *, void *, void *)); +static void pconsattach __P((struct device *, struct device *, void *)); + +struct cfattach pcons_ca = { + sizeof(struct pconssoftc), pconsmatch, pconsattach +}; + +struct cfdriver pcons_cd = { + NULL, "pcons", DV_TTY +}; + +extern struct cfdriver pcons_cd; +static struct cnm_state pcons_cnm_state; + +static int pconsprobe __P((void)); +extern struct consdev *cn_tab; + +static int +pconsmatch(parent, match, aux) + struct device *parent; + void *match; + void *aux; +{ + struct mainbus_attach_args *ma = aux; + extern int prom_cngetc __P((dev_t)); + + /* Only attach if no other console has attached. */ + return ((strcmp("pcons", ma->ma_name) == 0) && + (cn_tab->cn_getc == prom_cngetc)); + +} + +static void pcons_poll __P((void *)); + +static void +pconsattach(parent, self, aux) + struct device *parent, *self; + void *aux; +{ + struct pconssoftc *sc = (struct pconssoftc *) self; + + printf("\n"); + if (!pconsprobe()) + return; + + cn_init_magic(&pcons_cnm_state); + cn_set_magic("+++++"); + timeout_set(&sc->sc_poll_to, pcons_poll, sc); +} + +static void pconsstart __P((struct tty *)); +static int pconsparam __P((struct tty *, struct termios *)); + +int +pconsopen(dev, flag, mode, p) + dev_t dev; + int flag, mode; + struct proc *p; +{ + struct pconssoftc *sc; + int unit = minor(dev); + struct tty *tp; + + if (unit >= pcons_cd.cd_ndevs) + return ENXIO; + sc = pcons_cd.cd_devs[unit]; + if (!sc) + return ENXIO; + if (!(tp = sc->of_tty)) + sc->of_tty = tp = ttymalloc(); + tp->t_oproc = pconsstart; + tp->t_param = pconsparam; + tp->t_dev = dev; + cn_tab->cn_dev = dev; + if (!(tp->t_state & TS_ISOPEN)) { + ttychars(tp); + tp->t_iflag = TTYDEF_IFLAG; + tp->t_oflag = TTYDEF_OFLAG; + tp->t_cflag = TTYDEF_CFLAG; + tp->t_lflag = TTYDEF_LFLAG; + tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED; + pconsparam(tp, &tp->t_termios); + ttsetwater(tp); + } else if ((tp->t_state&TS_XCLUDE) && suser(p->p_ucred, &p->p_acflag)) + return EBUSY; + tp->t_state |= TS_CARR_ON; + + if (!(sc->of_flags & OFPOLL)) { + sc->of_flags |= OFPOLL; + timeout_add(&sc->sc_poll_to, 1); + } + + return (*linesw[tp->t_line].l_open)(dev, tp); +} + +int +pconsclose(dev, flag, mode, p) + dev_t dev; + int flag, mode; + struct proc *p; +{ + struct pconssoftc *sc = pcons_cd.cd_devs[minor(dev)]; + struct tty *tp = sc->of_tty; + + timeout_del(&sc->sc_poll_to); + sc->of_flags &= ~OFPOLL; + (*linesw[tp->t_line].l_close)(tp, flag); + ttyclose(tp); + return 0; +} + +int +pconsread(dev, uio, flag) + dev_t dev; + struct uio *uio; + int flag; +{ + struct pconssoftc *sc = pcons_cd.cd_devs[minor(dev)]; + struct tty *tp = sc->of_tty; + + return (*linesw[tp->t_line].l_read)(tp, uio, flag); +} + +int +pconswrite(dev, uio, flag) + dev_t dev; + struct uio *uio; + int flag; +{ + struct pconssoftc *sc = pcons_cd.cd_devs[minor(dev)]; + struct tty *tp = sc->of_tty; + + return (*linesw[tp->t_line].l_write)(tp, uio, flag); +} + +int +pconsioctl(dev, cmd, data, flag, p) + dev_t dev; + u_long cmd; + caddr_t data; + int flag; + struct proc *p; +{ + struct pconssoftc *sc = pcons_cd.cd_devs[minor(dev)]; + struct tty *tp = sc->of_tty; + int error; + + if ((error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p)) >= 0) + return error; + if ((error = ttioctl(tp, cmd, data, flag, p)) >= 0) + return error; + return ENOTTY; +} + +struct tty * +pconstty(dev) + dev_t dev; +{ + struct pconssoftc *sc = pcons_cd.cd_devs[minor(dev)]; + + return sc->of_tty; +} + +int +pconsstop(tp, flag) + struct tty *tp; + int flag; +{ + return 0; +} + +static void +pconsstart(tp) + struct tty *tp; +{ + struct clist *cl; + int s, len; + u_char buf[OFBURSTLEN]; + + s = spltty(); + if (tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP)) { + splx(s); + return; + } + tp->t_state |= TS_BUSY; + splx(s); + cl = &tp->t_outq; + len = q_to_b(cl, buf, OFBURSTLEN); + OF_write(stdout, buf, len); + s = spltty(); + tp->t_state &= ~TS_BUSY; + if (cl->c_cc) { + tp->t_state |= TS_TIMEOUT; + timeout_add(&tp->t_rstrt_to, 1); + } + if (cl->c_cc <= tp->t_lowat) { + if (tp->t_state & TS_ASLEEP) { + tp->t_state &= ~TS_ASLEEP; + wakeup(cl); + } + selwakeup(&tp->t_wsel); + } + splx(s); +} + +static int +pconsparam(tp, t) + struct tty *tp; + struct termios *t; +{ + tp->t_ispeed = t->c_ispeed; + tp->t_ospeed = t->c_ospeed; + tp->t_cflag = t->c_cflag; + return 0; +} + +static void +pcons_poll(aux) + void *aux; +{ + struct pconssoftc *sc = aux; + struct tty *tp = sc->of_tty; + char ch; + + while (OF_read(stdin, &ch, 1) > 0) { + cn_check_magic(tp->t_dev, ch, pcons_cnm_state); + if (tp && (tp->t_state & TS_ISOPEN)) + (*linesw[tp->t_line].l_rint)(ch, tp); + } + timeout_add(&sc->sc_poll_to, 1); +} + +int +pconsprobe() +{ + if (!stdin) stdin = OF_stdin(); + if (!stdout) stdout = OF_stdout(); + + return (stdin && stdout); +} + +void +pcons_cnpollc(dev, on) + dev_t dev; + int on; +{ + struct pconssoftc *sc = NULL; + + if (pcons_cd.cd_devs) + sc = pcons_cd.cd_devs[minor(dev)]; + + if (on) { + if (!sc) return; + if (sc->of_flags & OFPOLL) + timeout_del(&sc->sc_poll_to); + sc->of_flags &= ~OFPOLL; + } else { + /* Resuming kernel. */ + if (sc && !(sc->of_flags & OFPOLL)) { + sc->of_flags |= OFPOLL; + timeout_add(&sc->sc_poll_to, 1); + } + } +} + +void pcons_dopoll __P((void)); +void +pcons_dopoll() { + pcons_poll((void*)pcons_cd.cd_devs[0]); +} + +/* XXXXXXXX --- more cnmagic stuff. */ +#define ENCODE_STATE(c, n) (short)(((c)&0x1ff)|(((n)&0x7f)<<9)) + +static unsigned short cn_magic[CNS_LEN]; + +/* + * Initialize a cnm_state_t. + */ +void +cn_init_magic(cnm_state_t *cnm) +{ + cnm->cnm_state = 0; + cnm->cnm_magic = cn_magic; +} + +/* + * Destroy a cnm_state_t. + */ +void +cn_destroy_magic(cnm_state_t *cnm) +{ + cnm->cnm_state = 0; + cnm->cnm_magic = NULL; +} + +/* + * Translate a magic string to a state + * machine table. + */ +int +cn_set_magic(char *magic) +{ + unsigned int i, c, n; + unsigned short m[CNS_LEN]; + + for (i=0; i<CNS_LEN; i++) { + c = (*magic++)&0xff; + n = *magic ? i+1 : CNS_TERM; + switch (c) { + case 0: + /* End of string */ + if (i == 0) { + /* empty string? */ + cn_magic[0] = 0; +#ifdef DEBUG + printf("cn_set_magic(): empty!\n"); +#endif + return (0); + } + do { + cn_magic[i] = m[i]; + } while (i--); + return(0); + case 0x27: + /* Escape sequence */ + c = (*magic++)&0xff; + n = *magic ? i+1 : CNS_TERM; + switch (c) { + case 0x27: + break; + case 0x01: + /* BREAK */ + c = CNC_BREAK; + break; + case 0x02: + /* NUL */ + c = 0; + break; + } + /* FALLTHROUGH */ + default: + /* Transition to the next state. */ +#ifdef DEBUG + if (!cold) + printf("mag %d %x:%x\n", i, c, n); +#endif + m[i] = ENCODE_STATE(c, n); + break; + } + } + return (EINVAL); +} + +/* + * Translatea state machine table back to + * a magic string. + */ +int +cn_get_magic(char *magic, int maglen) { + unsigned int i, c; + + for (i=0; i<CNS_LEN; i++) { + c = cn_magic[i]; + /* Translate a character */ + switch (CNS_MAGIC_VAL(c)) { + case CNC_BREAK: + *magic++ = 0x27; + *magic++ = 0x01; + break; + case 0: + *magic++ = 0x27; + *magic++ = 0x02; + break; + case 0x27: + *magic++ = 0x27; + *magic++ = 0x27; + break; + default: + *magic++ = (c&0x0ff); + break; + } + /* Now go to the next state */ + i = CNS_MAGIC_NEXT(c); + if (i == CNS_TERM || i == 0) { + /* Either termination state or empty machine */ + *magic++ = 0; + return (0); + } + } + return (EINVAL); +} + diff --git a/sys/arch/sparc64/dev/zs.c b/sys/arch/sparc64/dev/zs.c new file mode 100644 index 00000000000..bf92258c934 --- /dev/null +++ b/sys/arch/sparc64/dev/zs.c @@ -0,0 +1,872 @@ +/* $NetBSD: zs.c,v 1.29 2001/05/30 15:24:24 lukem Exp $ */ + +/*- + * Copyright (c) 1996 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by Gordon W. Ross. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the NetBSD + * Foundation, Inc. and its contributors. + * 4. Neither the name of The NetBSD Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Zilog Z8530 Dual UART driver (machine-dependent part) + * + * Runs two serial lines per chip using slave drivers. + * Plain tty/async lines use the zs_async slave. + * Sun keyboard/mouse uses the zs_kbd/zs_ms slaves. + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/conf.h> +#include <sys/device.h> +#include <sys/file.h> +#include <sys/ioctl.h> +#include <sys/kernel.h> +#include <sys/proc.h> +#include <sys/tty.h> +#include <sys/time.h> +#include <sys/syslog.h> + +#include <machine/autoconf.h> +#include <machine/openfirm.h> +#include <machine/bsd_openprom.h> +#include <machine/conf.h> +#include <machine/cpu.h> +#include <machine/eeprom.h> +#include <machine/psl.h> +#include <machine/z8530var.h> + +#include <dev/cons.h> +#include <dev/ic/z8530reg.h> +#include <dev/sun/kbd_ms_ttyvar.h> +#include <ddb/db_output.h> + +#include <sparc64/dev/cons.h> + +#include "kbd.h" /* NKBD */ +#include "ms.h" /* NMS */ +#include "zs.h" /* NZS */ + +/* Make life easier for the initialized arrays here. */ +#if NZS < 3 +#undef NZS +#define NZS 3 +#endif + +/* + * Some warts needed by z8530tty.c - + * The default parity REALLY needs to be the same as the PROM uses, + * or you can not see messages done with printf during boot-up... + */ +int zs_def_cflag = (CREAD | CS8 | HUPCL); +int zs_major = 12; + +/* + * The Sun provides a 4.9152 MHz clock to the ZS chips. + */ +#define PCLK (9600 * 512) /* PCLK pin input clock rate */ + +#define ZS_DELAY() + +/* The layout of this is hardware-dependent (padding, order). */ +struct zschan { + volatile u_char zc_csr; /* ctrl,status, and indirect access */ + u_char zc_xxx0; + volatile u_char zc_data; /* data */ + u_char zc_xxx1; +}; +struct zsdevice { + /* Yes, they are backwards. */ + struct zschan zs_chan_b; + struct zschan zs_chan_a; +}; + +/* ZS channel used as the console device (if any) */ +void *zs_conschan_get, *zs_conschan_put; + +/* Saved PROM mappings */ +static struct zsdevice *zsaddr[NZS]; + +static u_char zs_init_reg[16] = { + 0, /* 0: CMD (reset, etc.) */ + 0, /* 1: No interrupts yet. */ + 0, /* 2: IVECT */ + ZSWR3_RX_8 | ZSWR3_RX_ENABLE, + ZSWR4_CLK_X16 | ZSWR4_ONESB | ZSWR4_EVENP, + ZSWR5_TX_8 | ZSWR5_TX_ENABLE, + 0, /* 6: TXSYNC/SYNCLO */ + 0, /* 7: RXSYNC/SYNCHI */ + 0, /* 8: alias for data port */ + ZSWR9_MASTER_IE | ZSWR9_NO_VECTOR, + 0, /*10: Misc. TX/RX control bits */ + ZSWR11_TXCLK_BAUD | ZSWR11_RXCLK_BAUD, + ((PCLK/32)/9600)-2, /*12: BAUDLO (default=9600) */ + 0, /*13: BAUDHI (default=9600) */ + ZSWR14_BAUD_ENA | ZSWR14_BAUD_FROM_PCLK, + ZSWR15_BREAK_IE, +}; + +/* Console ops */ +static int zscngetc __P((dev_t)); +static void zscnputc __P((dev_t, int)); +static void zscnpollc __P((dev_t, int)); + +struct consdev zs_consdev = { + NULL, + NULL, + zscngetc, + zscnputc, + zscnpollc, + NULL, +}; + + +/**************************************************************** + * Autoconfig + ****************************************************************/ + +/* Definition of the driver for autoconfig. */ +static int zs_match_mainbus __P((struct device *, struct cfdata *, void *)); +static void zs_attach_mainbus __P((struct device *, struct device *, void *)); + +static void zs_attach __P((struct zsc_softc *, struct zsdevice *, int)); +static int zs_print __P((void *, const char *name)); + +/* Do we really need this ? */ +struct cfattach zs_ca = { + sizeof(struct zsc_softc), zs_match_mainbus, zs_attach_mainbus +}; + +struct cfattach zs_mainbus_ca = { + sizeof(struct zsc_softc), zs_match_mainbus, zs_attach_mainbus +}; + +extern struct cfdriver zs_cd; +extern int stdinnode; +extern int fbnode; + +/* Interrupt handlers. */ +int zscheckintr __P((void *)); +static int zshard __P((void *)); +static void zssoft __P((void *)); + +static int zs_get_speed __P((struct zs_chanstate *)); + +/* Console device support */ +static int zs_console_flags __P((int, int, int)); + +/* Power management hooks */ +int zs_enable __P((struct zs_chanstate *)); +void zs_disable __P((struct zs_chanstate *)); + +/* + * Is the zs chip present? + */ +static int +zs_match_mainbus(parent, cf, aux) + struct device *parent; + struct cfdata *cf; + void *aux; +{ + struct sbus_attach_args *sa = aux; + + if (strcmp(cf->cf_driver->cd_name, sa->sa_name) != 0) + return (0); + + return (1); +} + +static void +zs_attach_mainbus(parent, self, aux) + struct device *parent; + struct device *self; + void *aux; +{ + struct zsc_softc *zsc = (void *) self; + struct sbus_attach_args *sa = aux; + int zs_unit = zsc->zsc_dev.dv_unit; + + if (sa->sa_nintr == 0) { + printf(" no interrupt lines\n"); + return; + } + + /* Use the mapping setup by the Sun PROM. */ + if (zsaddr[zs_unit] == NULL) { + /* Only map registers once. */ + if (sa->sa_npromvaddrs) { + /* + * We're converting from a 32-bit pointer to a 64-bit + * pointer. Since the 32-bit entity is negative, but + * the kernel is still mapped into the lower 4GB + * range, this needs to be zero-extended. + * + * XXXXX If we map the kernel and devices into the + * high 4GB range, this needs to be changed to + * sign-extend the address. + */ + zsaddr[zs_unit] = + (struct zsdevice *) + (uintptr_t)sa->sa_promvaddrs[0]; + } else { + bus_space_handle_t kvaddr; + + if (sbus_bus_map(sa->sa_bustag, sa->sa_slot, + sa->sa_offset, + sa->sa_size, + BUS_SPACE_MAP_LINEAR, + 0, &kvaddr) != 0) { + printf("%s @ sbus: cannot map registers\n", + self->dv_xname); + return; + } + zsaddr[zs_unit] = (struct zsdevice *) + (uintptr_t)kvaddr; + } + } + zsc->zsc_bustag = sa->sa_bustag; + zsc->zsc_dmatag = sa->sa_dmatag; + zsc->zsc_promunit = getpropint(sa->sa_node, "slave", -2); + zsc->zsc_node = sa->sa_node; + zs_attach(zsc, zsaddr[zs_unit], sa->sa_pri); +} + +/* + * Attach a found zs. + * + * USE ROM PROPERTIES port-a-ignore-cd AND port-b-ignore-cd FOR + * SOFT CARRIER, AND keyboard PROPERTY FOR KEYBOARD/MOUSE? + */ +static void +zs_attach(zsc, zsd, pri) + struct zsc_softc *zsc; + struct zsdevice *zsd; + int pri; +{ + struct zsc_attach_args zsc_args; + struct zs_chanstate *cs; + int s, channel, softpri = PIL_TTY; + + if (zsd == NULL) { + printf("configuration incomplete\n"); + return; + } + + printf(" softpri %d\n", softpri); + + /* + * Initialize software state for each channel. + */ + for (channel = 0; channel < 2; channel++) { + struct zschan *zc; + struct device *child; + extern struct cfdriver zstty_cd; /* in ioconf.c */ + + zsc_args.channel = channel; + cs = &zsc->zsc_cs_store[channel]; + zsc->zsc_cs[channel] = cs; + + cs->cs_channel = channel; + cs->cs_private = NULL; + cs->cs_ops = &zsops_null; + cs->cs_brg_clk = PCLK / 16; + + zc = (channel == 0) ? &zsd->zs_chan_a : &zsd->zs_chan_b; + + zsc_args.consdev = NULL; + zsc_args.hwflags = zs_console_flags(zsc->zsc_promunit, + zsc->zsc_node, + channel); + + if (zsc_args.hwflags & ZS_HWFLAG_CONSOLE) { + zsc_args.hwflags |= ZS_HWFLAG_USE_CONSDEV; + zsc_args.consdev = &zs_consdev; + } + + if ((zsc_args.hwflags & ZS_HWFLAG_CONSOLE_INPUT) != 0) { + zs_conschan_get = zc; + } + if ((zsc_args.hwflags & ZS_HWFLAG_CONSOLE_OUTPUT) != 0) { + zs_conschan_put = zc; + } + /* Childs need to set cn_dev, etc */ + + cs->cs_reg_csr = &zc->zc_csr; + cs->cs_reg_data = &zc->zc_data; + + bcopy(zs_init_reg, cs->cs_creg, 16); + bcopy(zs_init_reg, cs->cs_preg, 16); + + /* XXX: Consult PROM properties for this?! */ + cs->cs_defspeed = zs_get_speed(cs); + cs->cs_defcflag = zs_def_cflag; + + /* Make these correspond to cs_defcflag (-crtscts) */ + cs->cs_rr0_dcd = ZSRR0_DCD; + cs->cs_rr0_cts = 0; + cs->cs_wr5_dtr = ZSWR5_DTR | ZSWR5_RTS; + cs->cs_wr5_rts = 0; + + /* + * Clear the master interrupt enable. + * The INTENA is common to both channels, + * so just do it on the A channel. + */ + if (channel == 0) { + zs_write_reg(cs, 9, 0); + } + + /* + * Look for a child driver for this channel. + * The child attach will setup the hardware. + */ + if (!(child = + config_found(&zsc->zsc_dev, (void *)&zsc_args, zs_print))) { + /* No sub-driver. Just reset it. */ + u_char reset = (channel == 0) ? + ZSWR9_A_RESET : ZSWR9_B_RESET; + s = splzs(); + zs_write_reg(cs, 9, reset); + splx(s); + } +#if (NKBD > 0) || (NMS > 0) + /* + * If this was a zstty it has a keyboard + * property on it we need to attach the + * sunkbd and sunms line disciplines. + */ + if (child + && (child->dv_cfdata->cf_driver == &zstty_cd) + && (getproplen(zsc->zsc_node, "keyboard") == 0)) { + struct kbd_ms_tty_attach_args kma; + struct zstty_softc { + /* The following are the only fields we need here */ + struct device zst_dev; + struct tty *zst_tty; + struct zs_chanstate *zst_cs; + } *zst = (struct zstty_softc *)child; + struct tty *tp; + + kma.kmta_tp = tp = zst->zst_tty; + kma.kmta_dev = tp->t_dev; + kma.kmta_consdev = zsc_args.consdev; + + /* Attach 'em if we got 'em. */ +#if (NKBD > 0) + if (channel == 0) { + kma.kmta_name = "keyboard"; + config_found(child, (void *)&kma, NULL); + } +#endif +#if (NMS > 0) + if (channel == 1) { + kma.kmta_name = "mouse"; + config_found(child, (void *)&kma, NULL); + } +#endif + } +#endif + } + + /* + * Now safe to install interrupt handlers. Note the arguments + * to the interrupt handlers aren't used. Note, we only do this + * once since both SCCs interrupt at the same level and vector. + */ + bus_intr_establish(zsc->zsc_bustag, pri, IPL_SERIAL, 0, zshard, zsc); + if (!(zsc->zsc_softintr = softintr_establish(softpri, zssoft, zsc))) + panic("zsattach: could not establish soft interrupt\n"); + + evcnt_attach_dynamic(&zsc->zsc_intrcnt, EVCNT_TYPE_INTR, NULL, + zsc->zsc_dev.dv_xname, "intr"); + + + /* + * Set the master interrupt enable and interrupt vector. + * (common to both channels, do it on A) + */ + cs = zsc->zsc_cs[0]; + s = splhigh(); + /* interrupt vector */ + zs_write_reg(cs, 2, zs_init_reg[2]); + /* master interrupt control (enable) */ + zs_write_reg(cs, 9, zs_init_reg[9]); + splx(s); + +} + +static int +zs_print(aux, name) + void *aux; + const char *name; +{ + struct zsc_attach_args *args = aux; + + if (name != NULL) + printf("%s: ", name); + + if (args->channel != -1) + printf(" channel %d", args->channel); + + return (UNCONF); +} + +/* Deprecate this? */ +static volatile int zssoftpending; + +static int +zshard(arg) + void *arg; +{ + struct zsc_softc *zsc = (struct zsc_softc *)arg; + int rr3, rval; + + rval = 0; + while ((rr3 = zsc_intr_hard(zsc))) { + /* Count up the interrupts. */ + rval |= rr3; + zsc->zsc_intrcnt.ev_count++; + } + if (((zsc->zsc_cs[0] && zsc->zsc_cs[0]->cs_softreq) || + (zsc->zsc_cs[1] && zsc->zsc_cs[1]->cs_softreq)) && + zsc->zsc_softintr) { + zssoftpending = PIL_TTY; + softintr_schedule(zsc->zsc_softintr); + } + return (rval); +} + +int +zscheckintr(arg) + void *arg; +{ + struct zsc_softc *zsc; + int unit, rval; + + rval = 0; + for (unit = 0; unit < zs_cd.cd_ndevs; unit++) { + + zsc = zs_cd.cd_devs[unit]; + if (zsc == NULL) + continue; + rval = (zshard((void *)zsc) || rval); + } + return (rval); +} + + +/* + * We need this only for TTY_DEBUG purposes. + */ +static void +zssoft(arg) + void *arg; +{ + struct zsc_softc *zsc = (struct zsc_softc *)arg; + int s; + + /* Make sure we call the tty layer at spltty. */ + s = spltty(); + zssoftpending = 0; + (void)zsc_intr_soft(zsc); +#ifdef TTY_DEBUG + { + struct zstty_softc *zst0 = zsc->zsc_cs[0]->cs_private; + struct zstty_softc *zst1 = zsc->zsc_cs[1]->cs_private; + if (zst0->zst_overflows || zst1->zst_overflows ) { + struct trapframe *frame = (struct trapframe *)arg; + + printf("zs silo overflow from %p\n", + (long)frame->tf_pc); + } + } +#endif + splx(s); +} + + +/* + * Compute the current baud rate given a ZS channel. + */ +static int +zs_get_speed(cs) + struct zs_chanstate *cs; +{ + int tconst; + + tconst = zs_read_reg(cs, 12); + tconst |= zs_read_reg(cs, 13) << 8; + return (TCONST_TO_BPS(cs->cs_brg_clk, tconst)); +} + +/* + * MD functions for setting the baud rate and control modes. + */ +int +zs_set_speed(cs, bps) + struct zs_chanstate *cs; + int bps; /* bits per second */ +{ + int tconst, real_bps; + + if (bps == 0) + return (0); + +#ifdef DIAGNOSTIC + if (cs->cs_brg_clk == 0) + panic("zs_set_speed"); +#endif + + tconst = BPS_TO_TCONST(cs->cs_brg_clk, bps); + if (tconst < 0) + return (EINVAL); + + /* Convert back to make sure we can do it. */ + real_bps = TCONST_TO_BPS(cs->cs_brg_clk, tconst); + + /* XXX - Allow some tolerance here? */ + if (real_bps != bps) + return (EINVAL); + + cs->cs_preg[12] = tconst; + cs->cs_preg[13] = tconst >> 8; + + /* Caller will stuff the pending registers. */ + return (0); +} + +int +zs_set_modes(cs, cflag) + struct zs_chanstate *cs; + int cflag; /* bits per second */ +{ + int s; + + /* + * Output hardware flow control on the chip is horrendous: + * if carrier detect drops, the receiver is disabled, and if + * CTS drops, the transmitter is stoped IN MID CHARACTER! + * Therefore, NEVER set the HFC bit, and instead use the + * status interrupt to detect CTS changes. + */ + s = splzs(); + cs->cs_rr0_pps = 0; + if ((cflag & (CLOCAL | MDMBUF)) != 0) { + cs->cs_rr0_dcd = 0; + if ((cflag & MDMBUF) == 0) + cs->cs_rr0_pps = ZSRR0_DCD; + } else + cs->cs_rr0_dcd = ZSRR0_DCD; + if ((cflag & CRTSCTS) != 0) { + cs->cs_wr5_dtr = ZSWR5_DTR; + cs->cs_wr5_rts = ZSWR5_RTS; + cs->cs_rr0_cts = ZSRR0_CTS; + } else if ((cflag & CDTRCTS) != 0) { + cs->cs_wr5_dtr = 0; + cs->cs_wr5_rts = ZSWR5_DTR; + cs->cs_rr0_cts = ZSRR0_CTS; + } else if ((cflag & MDMBUF) != 0) { + cs->cs_wr5_dtr = 0; + cs->cs_wr5_rts = ZSWR5_DTR; + cs->cs_rr0_cts = ZSRR0_DCD; + } else { + cs->cs_wr5_dtr = ZSWR5_DTR | ZSWR5_RTS; + cs->cs_wr5_rts = 0; + cs->cs_rr0_cts = 0; + } + splx(s); + + /* Caller will stuff the pending registers. */ + return (0); +} + + +/* + * Read or write the chip with suitable delays. + */ + +u_char +zs_read_reg(cs, reg) + struct zs_chanstate *cs; + u_char reg; +{ + u_char val; + + *cs->cs_reg_csr = reg; + ZS_DELAY(); + val = *cs->cs_reg_csr; + ZS_DELAY(); + return (val); +} + +void +zs_write_reg(cs, reg, val) + struct zs_chanstate *cs; + u_char reg, val; +{ + *cs->cs_reg_csr = reg; + ZS_DELAY(); + *cs->cs_reg_csr = val; + ZS_DELAY(); +} + +u_char +zs_read_csr(cs) + struct zs_chanstate *cs; +{ + u_char val; + + val = *cs->cs_reg_csr; + ZS_DELAY(); + return (val); +} + +void zs_write_csr(cs, val) + struct zs_chanstate *cs; + u_char val; +{ + *cs->cs_reg_csr = val; + ZS_DELAY(); +} + +u_char zs_read_data(cs) + struct zs_chanstate *cs; +{ + u_char val; + + val = *cs->cs_reg_data; + ZS_DELAY(); + return (val); +} + +void zs_write_data(cs, val) + struct zs_chanstate *cs; + u_char val; +{ + *cs->cs_reg_data = val; + ZS_DELAY(); +} + +/**************************************************************** + * Console support functions (Sun specific!) + * Note: this code is allowed to know about the layout of + * the chip registers, and uses that to keep things simple. + * XXX - I think I like the mvme167 code better. -gwr + ****************************************************************/ + +extern void Debugger __P((void)); + +/* + * Handle user request to enter kernel debugger. + */ +void +zs_abort(cs) + struct zs_chanstate *cs; +{ + volatile struct zschan *zc = zs_conschan_get; + int rr0; + + /* Wait for end of break to avoid PROM abort. */ + /* XXX - Limit the wait? */ + do { + rr0 = zc->zc_csr; + ZS_DELAY(); + } while (rr0 & ZSRR0_BREAK); + +#if defined(KGDB) + zskgdb(cs); +#elif defined(DDB) + { + extern int db_active; + + if (!db_active) + Debugger(); + else + /* Debugger is probably hozed */ + callrom(); + } +#else + printf("stopping on keyboard abort\n"); + callrom(); +#endif +} + + +/* + * Polled input char. + */ +int +zs_getc(arg) + void *arg; +{ + volatile struct zschan *zc = arg; + int s, c, rr0; + + s = splhigh(); + /* Wait for a character to arrive. */ + do { + rr0 = zc->zc_csr; + ZS_DELAY(); + } while ((rr0 & ZSRR0_RX_READY) == 0); + + c = zc->zc_data; + ZS_DELAY(); + splx(s); + + /* + * This is used by the kd driver to read scan codes, + * so don't translate '\r' ==> '\n' here... + */ + return (c); +} + +/* + * Polled output char. + */ +void +zs_putc(arg, c) + void *arg; + int c; +{ + volatile struct zschan *zc = arg; + int s, rr0; + + s = splhigh(); + + /* Wait for transmitter to become ready. */ + do { + rr0 = zc->zc_csr; + ZS_DELAY(); + } while ((rr0 & ZSRR0_TX_READY) == 0); + + /* + * Send the next character. + * Now you'd think that this could be followed by a ZS_DELAY() + * just like all the other chip accesses, but it turns out that + * the `transmit-ready' interrupt isn't de-asserted until + * some period of time after the register write completes + * (more than a couple instructions). So to avoid stray + * interrupts we put in the 2us delay regardless of cpu model. + */ + zc->zc_data = c; + delay(2); + + splx(s); +} + +/*****************************************************************/ + + + + +/* + * Polled console input putchar. + */ +static int +zscngetc(dev) + dev_t dev; +{ + return (zs_getc(zs_conschan_get)); +} + +/* + * Polled console output putchar. + */ +static void +zscnputc(dev, c) + dev_t dev; + int c; +{ + zs_putc(zs_conschan_put, c); +} + +int swallow_zsintrs; + +static void +zscnpollc(dev, on) + dev_t dev; + int on; +{ + /* + * Need to tell zs driver to acknowledge all interrupts or we get + * annoying spurious interrupt messages. This is because mucking + * with spl() levels during polling does not prevent interrupts from + * being generated. + */ + + if (on) swallow_zsintrs++; + else swallow_zsintrs--; +} + +int +zs_console_flags(promunit, node, channel) + int promunit; + int node; + int channel; +{ + int cookie, flags = 0; + u_int chosen; + char buf[255]; + + /* + * We'll just to the OBP grovelling down here since that's + * the only type of firmware we support. + */ + chosen = OF_finddevice("/chosen"); + + /* Default to channel 0 if there are no explicit prom args */ + cookie = 0; + if (node == OF_instance_to_package(OF_stdin())) { + if (OF_getprop(chosen, "input-device", buf, sizeof(buf)) != -1) { + + if (!strcmp("ttyb", buf)) + cookie = 1; + } + + if (channel == cookie) + flags |= ZS_HWFLAG_CONSOLE_INPUT; + } + + if (node == OF_instance_to_package(OF_stdout())) { + if (OF_getprop(chosen, "output-device", buf, sizeof(buf)) != -1) { + + if (!strcmp("ttyb", buf)) + cookie = 1; + } + + if (channel == cookie) + flags |= ZS_HWFLAG_CONSOLE_OUTPUT; + } + + return (flags); +} + |