src - OpenBSD base system

diff options


context:
space:
mode:

author	Theo de Raadt <deraadt@cvs.openbsd.org>	1996-04-21 22:33:19 +0000
committer	Theo de Raadt <deraadt@cvs.openbsd.org>	1996-04-21 22:33:19 +0000
commit	67d88b0a9910a68bb666b448d2dac29cb4d3d8c2 (patch)
tree	967b89f6e07398a22bd8c76d30179b648776542d /sys/dev/ic
parent	ba95d3c1d69cdb251d15a12ebf70f50b0ea2019b (diff)

partial sync with netbsd 960418, more to come

Diffstat (limited to 'sys/dev/ic')

-rw-r--r--

sys/dev/ic/aic7xxx.c

-rw-r--r--

sys/dev/ic/aic7xxxvar.h

-rw-r--r--

sys/dev/ic/am7990.c

-rw-r--r--

sys/dev/ic/com.c

116

-rw-r--r--

sys/dev/ic/comvar.h

-rw-r--r--

sys/dev/ic/ncr5380sbc.c

-rw-r--r--

sys/dev/ic/smc90cx6.c

1231

-rw-r--r--

sys/dev/ic/smc90cx6reg.h

-rw-r--r--

sys/dev/ic/z8530sc.c

108

-rw-r--r--

sys/dev/ic/z8530sc.h

-rw-r--r--

sys/dev/ic/z8530tty.c

253

11 files changed, 1695 insertions, 239 deletions

diff --git a/sys/dev/ic/aic7xxx.c b/sys/dev/ic/aic7xxx.c
index a3bf8e44807..215e059b98d 100644
--- a/sys/dev/ic/aic7xxx.c
+++ b/sys/dev/ic/aic7xxx.c

@@ -1,5 +1,5 @@

-/* $OpenBSD: aic7xxx.c,v 1.3 1996/04/18 23:47:15 niklas Exp $ */

-/* $NetBSD: aic7xxx.c,v 1.3 1996/02/25 22:56:30 cgd Exp $ */

+/* $OpenBSD: aic7xxx.c,v 1.4 1996/04/21 22:21:03 deraadt Exp $ */

+/* $NetBSD: aic7xxx.c,v 1.5 1996/03/29 00:24:58 mycroft Exp $ */

* Generic driver for the aic7xxx based adaptec SCSI controllers

@@ -63,13 +63,12 @@ void ahcminphys __P((struct buf *));

int ahc_poll __P((struct ahc_softc *, struct scsi_xfer *, int));

/* Different debugging levels */

+#ifdef AHC_DEBUG

#define AHC_SHOWMISC 0x0001

#define AHC_SHOWCMDS 0x0002

#define AHC_SHOWSCBS 0x0004

-/*#define AHC_DEBUG /**/

int ahc_debug = AHC_SHOWMISC;

-/*#define AHC_MORE_DEBUG /**/

+#endif

#ifdef AHC_MORE_DEBUG

#define DEBUGLEVEL -1

@@ -629,7 +628,6 @@ ahc_scsirate(offset, period, ahc, target)

struct ahc_softc *ahc;

int target;

{

- u_char scsirate;

int i;

for (i = 0; i < ahc_num_syncrates; i++) {

@@ -652,9 +650,15 @@ ahc_scsirate(offset, period, ahc, target)

#endif /* AHC_DEBUG */

}

-ahcprint()

+int

+ahcprint(aux, name)

+ void *aux;

+ char *name;

{

+ if (name != NULL)

+ printf("%s: scsibus ", name);

+ return UNCONF;

}

@@ -768,7 +772,7 @@ ahcintr(ahc)

break;

case NO_IDENT:

panic("%s: No IDENTIFY message from reconnecting "

- "target %d at seqaddr = 0x%lx "

+ "target %d at seqaddr = 0x%x "

"SAVED_TCL == 0x%x\n",

ahc->sc_dev.dv_xname,

(inb(SELID + iobase) >> 4) & 0xf,

@@ -847,7 +851,7 @@ ahcintr(ahc)

#ifdef AHC_DEBUG

if (ahc_debug & AHC_SHOWMISC)

- printf("Sending SDTR!!\n");

+ printf("Sending SDTR!!\n");

#endif

outb(HA_RETURN_1 + iobase, SEND_SDTR);

}

@@ -1018,7 +1022,6 @@ ahcintr(ahc)

if (xs->error == XS_NOERROR &&

scb->flags != SCB_CHKSENSE) {

- u_char flags;

u_char head;

u_char tail;

struct ahc_dma_seg *sg = scb->ahc_dma;

@@ -1389,7 +1392,6 @@ ahc_init(ahc)

ahc->sc_dev.dv_xname, sizeof(struct ahc_scb), SCB_DOWN_SIZE,

sizeof(struct ahc_dma_seg));

#endif /* AHC_DEBUG */

- /*printf("%s: reading board settings\n", ahc->sc_dev.dv_xname);/**/

/* Save the IRQ type before we do a chip reset */

diff --git a/sys/dev/ic/aic7xxxvar.h b/sys/dev/ic/aic7xxxvar.h
index 48e902a398c..82022e8ab35 100644
--- a/sys/dev/ic/aic7xxxvar.h
+++ b/sys/dev/ic/aic7xxxvar.h

@@ -1,5 +1,5 @@

-/* $OpenBSD: aic7xxxvar.h,v 1.2 1996/04/18 23:47:16 niklas Exp $ */

-/* $NetBSD: aic7xxxvar.h,v 1.2 1996/03/14 02:30:30 cgd Exp $ */

+/* $OpenBSD: aic7xxxvar.h,v 1.3 1996/04/21 22:21:12 deraadt Exp $ */

+/* $NetBSD: aic7xxxvar.h,v 1.3 1996/03/29 00:25:02 mycroft Exp $ */

* Interface to the generic driver for the aic7xxx based adaptec

@@ -27,8 +27,6 @@

#ifndef _AIC7XXX_H_

#define _AIC7XXX_H_

-/*#include "ahc.h" /* for NAHC from config */

#define AHC_NSEG 256 /* number of dma segments supported */

#define AHC_SCB_MAX 16 /*

diff --git a/sys/dev/ic/am7990.c b/sys/dev/ic/am7990.c
index 87c5712eba2..b050dd728db 100644
--- a/sys/dev/ic/am7990.c
+++ b/sys/dev/ic/am7990.c

@@ -1,5 +1,5 @@

-/* $OpenBSD: am7990.c,v 1.4 1996/04/18 23:47:17 niklas Exp $ */

-/* $NetBSD: am7990.c,v 1.11 1996/03/14 19:05:07 christos Exp $ */

+/* $OpenBSD: am7990.c,v 1.5 1996/04/21 22:21:15 deraadt Exp $ */

+/* $NetBSD: am7990.c,v 1.16 1996/04/09 15:21:59 pk Exp $ */

/*-

@@ -74,6 +74,10 @@ void xmit_print __P((struct le_softc *, int));

#define ifp (&sc->sc_arpcom.ac_if)

+#ifndef ETHER_CMP

+#define ETHER_CMP(a, b) bcmp((a), (b), ETHER_ADDR_LEN)

+#endif

void

leconfig(sc)

struct le_softc *sc;

@@ -123,8 +127,8 @@ leconfig(sc)

panic("leconfig: weird memory size");

}

- printf(": address %s\n%s: %d receive buffers, %d transmit buffers\n",

- ether_sprintf(sc->sc_arpcom.ac_enaddr),

+ printf(": address %s\n", ether_sprintf(sc->sc_arpcom.ac_enaddr));

+ printf("%s: %d receive buffers, %d transmit buffers\n",

sc->sc_dev.dv_xname, sc->sc_nrbuf, sc->sc_ntbuf);

mem = 0;

@@ -420,8 +424,7 @@ leread(sc, boff, len)

if ((ifp->if_flags & IFF_PROMISC) != 0 &&

(eh->ether_dhost[0] & 1) == 0 && /* !mcast and !bcast */

- bcmp(eh->ether_dhost, sc->sc_arpcom.ac_enaddr,

- sizeof(eh->ether_dhost)) != 0) {

+ ETHER_CMP(eh->ether_dhost, sc->sc_arpcom.ac_enaddr)) {

m_freem(m);

return;

}

@@ -430,10 +433,15 @@ leread(sc, boff, len)

#endif

#ifdef LANCE_REVC_BUG

- if (bcmp(eh->ether_dhost, sc->sc_arpcom.ac_enaddr,

- sizeof(eh->ether_dhost)) != 0 &&

- bcmp(eh->ether_dhost, etherbroadcastaddr,

- sizeof(eh->ether_dhost)) != 0) {

+ /*

+ * The old LANCE (Rev. C) chips have a bug which causes

+ * garbage to be inserted in front of the received packet.

+ * The work-around is to ignore packets with an invalid

+ * destination address (garbage will usually not match).

+ * Of course, this precludes multicast support...

+ */

+ if (ETHER_CMP(eh->ether_dhost, sc->sc_arpcom.ac_enaddr) &&

+ ETHER_CMP(eh->ether_dhost, etherbroadcastaddr)) {

m_freem(m);

return;

}

@@ -483,7 +491,7 @@ lerint(sc)

printf("%s: receive buffer error\n",

sc->sc_dev.dv_xname);

ifp->if_ierrors++;

- } else if (rmd.rmd1_bits & (LE_R1_STP | LE_R1_ENP) !=

+ } else if ((rmd.rmd1_bits & (LE_R1_STP | LE_R1_ENP)) !=

(LE_R1_STP | LE_R1_ENP)) {

printf("%s: dropping chained buffer\n",

sc->sc_dev.dv_xname);

@@ -503,8 +511,12 @@ lerint(sc)

#ifdef LEDEBUG

if (sc->sc_debug)

- printf("sc->sc_last_rd = %x, rmd = %x\n",

- sc->sc_last_rd, rmd);

+ printf("sc->sc_last_rd = %x, rmd: "

+ "ladr %04x, hadr %02x, flags %02x, "

+ "bcnt %04x, mcnt %04x\n",

+ sc->sc_last_rd,

+ rmd.rmd0, rmd.rmd1_hadr, rmd.rmd1_bits,

+ rmd.rmd2, rmd.rmd3);

#endif

if (++bix == sc->sc_nrbuf)

@@ -529,7 +541,11 @@ letint(sc)

#ifdef LEDEBUG

if (sc->sc_debug)

- printf("trans tmd = %x\n", tmd);

+ printf("trans tmd: "

+ "ladr %04x, hadr %02x, flags %02x, "

+ "bcnt %04x, mcnt %04x\n",

+ tmd.tmd0, tmd.tmd1_hadr, tmd.tmd1_bits,

+ tmd.tmd2, tmd.tmd3);

#endif

(*sc->sc_copyfromdesc)(sc, &tmd, LE_TMDADDR(sc, bix),

@@ -877,9 +893,10 @@ recv_print(sc, no)

rmd.rmd0, rmd.rmd1_hadr, rmd.rmd1_bits, rmd.rmd2, rmd.rmd3);

if (len >= sizeof(eh)) {

(*sc->sc_copyfrombuf)(sc, &eh, LE_RBUFADDR(sc, no), sizeof(eh));

- printf("%s: dst %s", ether_sprintf(eh.ether_dhost));

+ printf("%s: dst %s", sc->sc_dev.dv_xname,

+ ether_sprintf(eh.ether_dhost));

printf(" src %s type %04x\n", ether_sprintf(eh.ether_shost),

- ntohs(eh.ether_type));

+ ntohs(eh.ether_type));

}

@@ -902,7 +919,8 @@ xmit_print(sc, no)

tmd.tmd0, tmd.tmd1_hadr, tmd.tmd1_bits, tmd.tmd2, tmd.tmd3);

if (len >= sizeof(eh)) {

(*sc->sc_copyfrombuf)(sc, &eh, LE_TBUFADDR(sc, no), sizeof(eh));

- printf("%s: dst %s", ether_sprintf(eh.ether_dhost));

+ printf("%s: dst %s", sc->sc_dev.dv_xname,

+ ether_sprintf(eh.ether_dhost));

printf(" src %s type %04x\n", ether_sprintf(eh.ether_shost),

ntohs(eh.ether_type));

}

@@ -938,8 +956,7 @@ lesetladrf(ac, af)

af[0] = af[1] = af[2] = af[3] = 0x0000;

ETHER_FIRST_MULTI(step, ac, enm);

while (enm != NULL) {

- if (bcmp(enm->enm_addrlo, enm->enm_addrhi,

- sizeof(enm->enm_addrlo)) != 0) {

+ if (ETHER_CMP(enm->enm_addrlo, enm->enm_addrhi)) {

* We must listen to a range of multicast addresses.

* For now, just accept all multicasts, rather than

@@ -1058,7 +1075,6 @@ copytobuf_gap2(sc, fromv, boff, len)

volatile caddr_t buf = sc->sc_mem;

- register int xfer;

if (boff & 0x1) {

/* handle unaligned first byte */

@@ -1088,7 +1104,6 @@ copyfrombuf_gap2(sc, tov, boff, len)

- register int xfer;

if (boff & 0x1) {

/* handle unaligned first byte */

diff --git a/sys/dev/ic/com.c b/sys/dev/ic/com.c
index d34ba82a096..77dd24748f4 100644
--- a/sys/dev/ic/com.c
+++ b/sys/dev/ic/com.c

@@ -1,5 +1,5 @@

-/* $OpenBSD: com.c,v 1.10 1996/04/18 23:47:32 niklas Exp $ */

-/* $NetBSD: com.c,v 1.75 1996/03/10 09:01:24 cgd Exp $ */

+/* $OpenBSD: com.c,v 1.11 1996/04/21 22:23:15 deraadt Exp $ */

+/* $NetBSD: com.c,v 1.79 1996/04/15 18:54:31 cgd Exp $ */

/*-

@@ -57,7 +57,11 @@

#include <sys/types.h>

#include <sys/device.h>

-#include <machine/cpu.h>

+#ifdef i386 /* XXX */

+#include <machine/cpu.h> /* XXX */

+#else /* XXX */

+#include <machine/intr.h>

+#endif /* XXX */

#include <machine/bus.h>

#include <dev/isa/isavar.h>

@@ -69,6 +73,8 @@

#endif

#define com_lcr com_cfcr

+#include "com.h"

#define COM_IBUFSIZE (2 * 512)

#define COM_IHIGHWATER ((3 * COM_IBUFSIZE) / 4)

@@ -109,11 +115,9 @@ struct com_softc {

u_char sc_ibufs[2][COM_IBUFSIZE];

};

-int comprobe __P((struct device *, void *, void *));

#ifdef COM_HAYESP

int comprobeHAYESP __P((bus_io_handle_t hayespioh, struct com_softc *sc));

#endif

-void comattach __P((struct device *, struct device *, void *));

int comopen __P((dev_t, int, int, struct proc *));

int comclose __P((dev_t, int, int, struct proc *));

void comdiag __P((void *));

@@ -122,11 +126,30 @@ void compoll __P((void *));

int comparam __P((struct tty *, struct termios *));

void comstart __P((struct tty *));

-int cominit __P((bus_chipset_tag_t, bus_io_handle_t, int));

+/*

+ * XXX the following two cfattach structs should be different, and possibly

+ * XXX elsewhere.

+ */

+int comprobe __P((struct device *, void *, void *));

+void comattach __P((struct device *, struct device *, void *));

+#if NCOM_ISA

+struct cfattach com_isa_ca = {

+ sizeof(struct com_softc), comprobe, comattach

+};

+#endif

-struct cfdriver comcd = {

- NULL, "com", comprobe, comattach, DV_TTY, sizeof(struct com_softc)

+#if NCOM_COMMULTI

+struct cfattach com_commulti_ca = {

+ sizeof(struct com_softc), comprobe, comattach

};

+#endif

+struct cfdriver com_cd = {

+ NULL, "com", DV_TTY

+};

+int cominit __P((bus_chipset_tag_t, bus_io_handle_t, int));

#ifdef COMCONSOLE

int comdefaultrate = CONSPEED; /* XXX why set default? */

@@ -138,6 +161,7 @@ int comconsinit;

int comconsattached;

bus_chipset_tag_t comconsbc;

bus_io_handle_t comconsioh;

+tcflag_t comconscflag = TTYDEF_CFLAG;

int commajor;

int comsopen = 0;

@@ -157,7 +181,7 @@ extern int kgdb_debug_init;

#define CLR(t, f) (t) &= ~(f)

#define ISSET(t, f) ((t) & (f))

-#include "pcmciabus.h"

+/*#include "pcmciabus.h"*/

#if NPCMCIABUS >0

/* additional setup needed for pcmcia devices */

#include <dev/pcmcia/pcmciabus.h>

@@ -327,13 +351,22 @@ comprobe(parent, match, aux)

int iobase, needioh;

int rv = 1;

+ /*

+ * XXX should be broken out into functions for isa probe and

+ * XXX for commulti probe, with a helper function that contains

+ * XXX most of the interesting stuff.

+ */

+#if NCOM_ISA

if (!strcmp(parent->dv_cfdata->cf_driver->cd_name, "isa")) {

struct isa_attach_args *ia = aux;

bc = ia->ia_bc;

iobase = ia->ia_iobase;

needioh = 1;

- } else {

+ } else

+#endif

+#if NCOM_COMMULTI

+ if (1) {

struct commulti_attach_args *ca = aux;

if (cf->cf_loc[0] != -1 && cf->cf_loc[0] != ca->ca_slave)

@@ -343,7 +376,9 @@ comprobe(parent, match, aux)

iobase = ca->ca_iobase;

ioh = ca->ca_ioh;

needioh = 0;

- }

+ } else

+#endif

+ return(0); /* This cannot happen */

/* if it's in use as console, it's there. */

if (iobase == comconsaddr && !comconsattached)

@@ -358,12 +393,14 @@ comprobe(parent, match, aux)

bus_io_unmap(bc, ioh, COM_NPORTS);

out:

+#if NCOM_ISA

if (rv && !strcmp(parent->dv_cfdata->cf_driver->cd_name, "isa")) {

struct isa_attach_args *ia = aux;

ia->ia_iosize = COM_NPORTS;

ia->ia_msize = 0;

}

+#endif

return (rv);

}

@@ -383,8 +420,14 @@ comattach(parent, self, aux)

int *hayespp;

#endif

+ /*

+ * XXX should be broken out into functions for isa attach and

+ * XXX for commulti attach, with a helper function that contains

+ * XXX most of the interesting stuff.

+ */

sc->sc_hwflags = 0;

sc->sc_swflags = 0;

+#if NCOM_ISA

if (!strcmp(parent->dv_cfdata->cf_driver->cd_name, "isa")) {

struct isa_attach_args *ia = aux;

@@ -399,7 +442,10 @@ comattach(parent, self, aux)

} else

ioh = comconsioh;

irq = ia->ia_irq;

- } else {

+ } else

+#endif

+#if NCOM_COMMULTI

+ if (1) {

struct commulti_attach_args *ca = aux;

@@ -412,7 +458,9 @@ comattach(parent, self, aux)

if (ca->ca_noien)

sc->sc_hwflags |= COM_HW_NOIEN;

- }

+ } else

+#endif

+ panic("comattach: impossible");

sc->sc_bc = bc;

sc->sc_ioh = ioh;

@@ -473,9 +521,18 @@ comattach(parent, self, aux)

bus_io_write_1(bc, ioh, com_ier, 0);

bus_io_write_1(bc, ioh, com_mcr, 0);

- if (irq != IRQUNK)

- sc->sc_ih = isa_intr_establish(irq, IST_EDGE, IPL_TTY,

- comintr, sc, sc->sc_dev.dv_xname);

+ if (irq != IRQUNK) {

+#if NCOM_ISA

+ if (!strcmp(parent->dv_cfdata->cf_driver->cd_name, "isa")) {

+ struct isa_attach_args *ia = aux;

+ sc->sc_ih = isa_intr_establish(ia->ia_ic, irq,

+ IST_EDGE, IPL_TTY, comintr, sc,

+ sc->sc_dev.dv_xname);

+ } else

+#endif

+ panic("comattach: IRQ but can't have one");

+ }

#ifdef KGDB

if (kgdb_dev == makedev(commajor, unit)) {

@@ -516,9 +573,9 @@ comopen(dev, flag, mode, p)

int s;

int error = 0;

- if (unit >= comcd.cd_ndevs)

+ if (unit >= com_cd.cd_ndevs)

return ENXIO;

- sc = comcd.cd_devs[unit];

+ sc = com_cd.cd_devs[unit];

if (!sc)

return ENXIO;

@@ -535,7 +592,10 @@ comopen(dev, flag, mode, p)

ttychars(tp);

tp->t_iflag = TTYDEF_IFLAG;

tp->t_oflag = TTYDEF_OFLAG;

- tp->t_cflag = TTYDEF_CFLAG;

+ if (ISSET(sc->sc_hwflags, COM_HW_CONSOLE))

+ tp->t_cflag = comconscflag;

+ else

+ tp->t_cflag = TTYDEF_CFLAG;

if (ISSET(sc->sc_swflags, COM_SW_CLOCAL))

SET(tp->t_cflag, CLOCAL);

if (ISSET(sc->sc_swflags, COM_SW_CRTSCTS))

@@ -644,7 +704,7 @@ comclose(dev, flag, mode, p)

struct proc *p;

{

int unit = COMUNIT(dev);

- struct com_softc *sc = comcd.cd_devs[unit];

+ struct com_softc *sc = com_cd.cd_devs[unit];

struct tty *tp = sc->sc_tty;

bus_chipset_tag_t bc = sc->sc_bc;

bus_io_handle_t ioh = sc->sc_ioh;

@@ -684,7 +744,7 @@ comread(dev, uio, flag)

struct uio *uio;

int flag;

{

- struct com_softc *sc = comcd.cd_devs[COMUNIT(dev)];

+ struct com_softc *sc = com_cd.cd_devs[COMUNIT(dev)];

struct tty *tp = sc->sc_tty;

return ((*linesw[tp->t_line].l_read)(tp, uio, flag));

@@ -696,7 +756,7 @@ comwrite(dev, uio, flag)

struct uio *uio;

int flag;

{

- struct com_softc *sc = comcd.cd_devs[COMUNIT(dev)];

+ struct com_softc *sc = com_cd.cd_devs[COMUNIT(dev)];

struct tty *tp = sc->sc_tty;

return ((*linesw[tp->t_line].l_write)(tp, uio, flag));

@@ -706,7 +766,7 @@ struct tty *

comtty(dev)

dev_t dev;

{

- struct com_softc *sc = comcd.cd_devs[COMUNIT(dev)];

+ struct com_softc *sc = com_cd.cd_devs[COMUNIT(dev)];

struct tty *tp = sc->sc_tty;

return (tp);

@@ -734,7 +794,7 @@ comioctl(dev, cmd, data, flag, p)

struct proc *p;

{

int unit = COMUNIT(dev);

- struct com_softc *sc = comcd.cd_devs[unit];

+ struct com_softc *sc = com_cd.cd_devs[unit];

struct tty *tp = sc->sc_tty;

bus_chipset_tag_t bc = sc->sc_bc;

bus_io_handle_t ioh = sc->sc_ioh;

@@ -846,7 +906,7 @@ comparam(tp, t)

struct tty *tp;

struct termios *t;

{

- struct com_softc *sc = comcd.cd_devs[COMUNIT(tp->t_dev)];

+ struct com_softc *sc = com_cd.cd_devs[COMUNIT(tp->t_dev)];

bus_chipset_tag_t bc = sc->sc_bc;

bus_io_handle_t ioh = sc->sc_ioh;

int ospeed = comspeed(t->c_ospeed);

@@ -985,7 +1045,7 @@ void

comstart(tp)

struct tty *tp;

{

- struct com_softc *sc = comcd.cd_devs[COMUNIT(tp->t_dev)];

+ struct com_softc *sc = com_cd.cd_devs[COMUNIT(tp->t_dev)];

bus_chipset_tag_t bc = sc->sc_bc;

bus_io_handle_t ioh = sc->sc_ioh;

int s;

@@ -1106,8 +1166,8 @@ compoll(arg)

comevents = 0;

splx(s);

- for (unit = 0; unit < comcd.cd_ndevs; unit++) {

- sc = comcd.cd_devs[unit];

+ for (unit = 0; unit < com_cd.cd_ndevs; unit++) {

+ sc = com_cd.cd_devs[unit];

if (sc == 0 || sc->sc_ibufp == sc->sc_ibuf)

continue;

diff --git a/sys/dev/ic/comvar.h b/sys/dev/ic/comvar.h
index 9b412b06936..c3f8068caec 100644
--- a/sys/dev/ic/comvar.h
+++ b/sys/dev/ic/comvar.h

@@ -1,5 +1,5 @@

-/* $OpenBSD: comvar.h,v 1.1 1996/04/19 16:08:34 niklas Exp $ */

-/* $NetBSD: comvar.h,v 1.3 1996/03/10 09:01:26 cgd Exp $ */

+/* $OpenBSD: comvar.h,v 1.2 1996/04/21 22:23:20 deraadt Exp $ */

+/* $NetBSD: comvar.h,v 1.4 1996/04/15 18:54:35 cgd Exp $ */

@@ -46,3 +46,4 @@ extern int comconsaddr;

extern int comconsattached;

extern bus_chipset_tag_t comconsbc;

extern bus_io_handle_t comconsioh;

+extern tcflag_t comconscflag;

diff --git a/sys/dev/ic/ncr5380sbc.c b/sys/dev/ic/ncr5380sbc.c
index 2fe5e7db748..a7e356d4bac 100644
--- a/sys/dev/ic/ncr5380sbc.c
+++ b/sys/dev/ic/ncr5380sbc.c

@@ -1,5 +1,5 @@

-/* $OpenBSD: ncr5380sbc.c,v 1.4 1996/04/18 23:47:19 niklas Exp $ */

-/* $NetBSD: ncr5380sbc.c,v 1.8 1996/03/07 15:00:17 christos Exp $ */

+/* $OpenBSD: ncr5380sbc.c,v 1.5 1996/04/21 22:21:21 deraadt Exp $ */

+/* $NetBSD: ncr5380sbc.c,v 1.9 1996/03/18 23:09:02 gwr Exp $ */

@@ -2330,8 +2330,25 @@ do_actions:

if (act_flags & ACT_DISCONNECT) {

* The device has dropped BSY (or will soon).

- * Return and let ncr5380_sched() do its thing.

+ * We have to wait here for BSY to drop, otherwise

+ * the next command may decide we need a bus reset.

+ timo = ncr5380_wait_nrq_timo; /* XXX */

+ for (;;) {

+ if (!SCI_BUSY(sc))

+ goto busfree;

+ if (--timo <= 0)

+ break;

+ delay(2);

+ }

+ /* Device is sitting on the bus! */

+ printf("%s: SCSI job did not finish, resetting...\n",

+ sc->sc_dev.dv_xname);

+ ncr5380_reset_scsibus(sc);

+ busfree:

+ NCR_TRACE("machine: discon, waited %d\n",

+ ncr5380_wait_nrq_timo - timo);

*sc->sci_icmd = 0;

*sc->sci_mode = 0;

*sc->sci_tcmd = PHASE_INVALID;

diff --git a/sys/dev/ic/smc90cx6.c b/sys/dev/ic/smc90cx6.c
new file mode 100644
index 00000000000..afa12df2b80
--- /dev/null
+++ b/sys/dev/ic/smc90cx6.c

@@ -0,0 +1,1231 @@

+/* $NetBSD: smc90cx6.c,v 1.16 1996/03/20 13:28:50 is Exp $ */

+/*

+ *

+ * 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 Ignatios Souvatzis

+ * for the NetBSD Project.

+ * 4. 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.

+ */

+/*

+ * Driver for the Commodore Busines Machines ARCnet card.

+ */

+#define BAHASMCOPY /**/

+#define BAHSOFTCOPY /**/

+#define BAHRETRANSMIT /**/

+/* #define BAHTIMINGS */

+/* #define BAH_DEBUG 3 */

+/* zeroth version of M68060 support */

+#if defined(M68060) && defined(BAHASMCOPY)

+#undef BAHASMCOPY

+#endif

+#include "bpfilter.h"

+#include <sys/param.h>

+#include <sys/systm.h>

+#include <sys/mbuf.h>

+#include <sys/buf.h>

+#include <sys/device.h>

+#include <sys/protosw.h>

+#include <sys/socket.h>

+#include <sys/syslog.h>

+#include <sys/ioctl.h>

+#include <sys/errno.h>

+#include <net/if.h>

+#include <net/if_dl.h>

+#include <net/if_types.h>

+#include <net/netisr.h>

+#ifdef INET

+#include <netinet/in.h>

+#include <netinet/in_systm.h>

+#include <netinet/in_var.h>

+#include <netinet/ip.h>

+#include <netinet/if_ether.h>

+#include <netinet/if_arc.h>

+#endif

+#if NBPFILTER > 0

+#include <net/bpf.h>

+#include <net/bpfdesc.h>

+#endif

+#include <sys/kernel.h>

+#include <machine/cpu.h>

+#include <machine/mtpr.h>

+#include <amiga/amiga/device.h>

+#include <amiga/amiga/isr.h>

+#include <amiga/dev/zbusvar.h>

+#include <amiga/dev/if_bahreg.h>

+/* these should be elsewhere */

+#define ARC_MIN_LEN 1

+#define ARC_MIN_FORBID_LEN 254

+#define ARC_MAX_FORBID_LEN 256

+#define ARC_MAX_LEN 508

+#define ARC_ADDR_LEN 1

+/* for watchdog timer. This should be more than enough. */

+#define ARCTIMEOUT (5*IFNET_SLOWHZ)

+/*

+ * This currently uses 2 bufs for tx, 2 for rx

+ *

+ * New rx protocol:

+ *

+ * rx has a fillcount variable. If fillcount > (NRXBUF-1),

+ * rx can be switched off from rx hard int.

+ * Else rx is restarted on the other receiver.

+ * rx soft int counts down. if it is == (NRXBUF-1), it restarts

+ * the receiver.

+ * To ensure packet ordering (we need that for 1201 later), we have a counter

+ * which is incremented modulo 256 on each receive and a per buffer

+ * variable, which is set to the counter on filling. The soft int can

+ * compare both values to determine the older packet.

+ *

+ * Transmit direction:

+ *

+ * bah_start checks tx_fillcount

+ * case 2: return

+ *

+ * else fill tx_act ^ 1 && inc tx_fillcount

+ *

+ * check tx_fillcount again.

+ * case 2: set IFF_OACTIVE to stop arc_output from filling us.

+ * case 1: start tx

+ *

+ * tint clears IFF_OCATIVE, decrements and checks tx_fillcount

+ * case 1: start tx on tx_act ^ 1, softcall bah_start

+ * case 0: softcall bah_start

+ *

+ * #define fill(i) get mbuf && copy mbuf to chip(i)

+ */

+#ifdef BAHTIMINGS

+/*

+ * ARCnet stats; per interface.

+ */

+struct bah_stats {

+ u_long mincopyin;

+ u_long maxcopyin; /* divided by byte count */

+ u_long mincopyout;

+ u_long maxcopyout;

+ u_long minsend;

+ u_long maxsend;

+ u_long lasttxstart_mics;

+ struct timeval lasttxstart_tv;

+};

+#error BAHTIMINGS CODE IS BROKEN; use of clkread() is bogus

+#endif

+/*

+ * Arcnet software status per interface

+ */

+struct bah_softc {

+ struct device sc_dev;

+ struct arccom sc_arccom; /* Common arcnet structures */

+ struct isr sc_isr;

+ struct a2060 *sc_base;

+ u_long sc_recontime; /* seconds only, I'm lazy */

+ u_long sc_reconcount; /* for the above */

+ u_long sc_reconcount_excessive; /* for the above */

+#define ARC_EXCESSIVE_RECONS 20

+#define ARC_EXCESSIVE_RECONS_REWARN 400

+ u_char sc_intmask;

+ u_char sc_rx_act; /* 2..3 */

+ u_char sc_tx_act; /* 0..1 */

+ u_char sc_rx_fillcount;

+ u_char sc_tx_fillcount;

+ u_char sc_broadcast[2]; /* is it a broadcast packet? */

+ u_char sc_retransmits[2]; /* unused at the moment */

+#ifdef BAHTIMINGS

+ struct bah_stats sc_stats;

+#endif

+};

+int bah_zbus_match __P((struct device *, void *, void *));

+void bah_zbus_attach __P((struct device *, struct device *, void *));

+void bah_init __P((struct bah_softc *));

+void bah_reset __P((struct bah_softc *));

+void bah_stop __P((struct bah_softc *));

+void bah_start __P((struct ifnet *));

+int bahintr __P((struct bah_softc *sc));

+int bah_ioctl __P((struct ifnet *, unsigned long, caddr_t));

+void bah_watchdog __P((int));

+void movepout __P((u_char *from, u_char __volatile *to, int len));

+void movepin __P((u_char __volatile *from, u_char *to, int len));

+void bah_srint __P((void *vsc, void *dummy));

+void callstart __P((void *vsc, void *dummy));

+#ifdef BAHTIMINGS

+int clkread();

+#endif

+struct cfattach bah_zbus_ca = {

+ sizeof(struct bah_softc), bah_zbus_match, bah_zbus_attach

+};

+struct cfdriver bah_cd = {

+ NULL, "bah", DV_IFNET

+};

+int

+bah_zbus_match(parent, match, aux)

+ struct device *parent;

+ void *match, *aux;

+ struct zbus_args *zap = aux;

+ if ((zap->manid == 514 || zap->manid == 1053) && zap->prodid == 9)

+ return (1);

+ return (0);

+void

+bah_zbus_attach(parent, self, aux)

+ struct device *parent, *self;

+ void *aux;

+ struct bah_softc *sc = (void *)self;

+ struct zbus_args *zap = aux;

+ struct ifnet *ifp = &sc->sc_arccom.ac_if;

+ int s, linkaddress;

+#if (defined(BAH_DEBUG) && (BAH_DEBUG > 2))

+ printf("\n%s: attach(0x%x, 0x%x, 0x%x)\n",

+ sc->sc_dev.dv_xname, parent, self, aux);

+#endif

+ s = splhigh();

+ sc->sc_base = zap->va;

+ /*

+ * read the arcnet address from the board

+ */

+ sc->sc_base->kick1 = 0x0;

+ sc->sc_base->kick2 = 0x0;

+ DELAY(200);

+ sc->sc_base->kick1 = 0xFF;

+ sc->sc_base->kick2 = 0xFF;

+ do {

+ DELAY(200);

+ } while (!(sc->sc_base->status & ARC_POR));

+ linkaddress = sc->sc_base->dipswitches;

+#ifdef BAHTIMINGS

+ printf(": link addr 0x%02x(%ld), with timer\n",

+ linkaddress, linkaddress);

+#else

+ printf(": link addr 0x%02x(%ld)\n", linkaddress, linkaddress);

+#endif

+ sc->sc_arccom.ac_anaddr = linkaddress;

+ /* clear the int mask... */

+ sc->sc_base->status = sc->sc_intmask = 0;

+ sc->sc_base->command = ARC_CONF(CONF_LONG);

+ sc->sc_base->command = ARC_CLR(CLR_POR|CLR_RECONFIG);

+ sc->sc_recontime = sc->sc_reconcount = 0;

+ /* and reenable kernel int level */

+ splx(s);

+ /*

+ * set interface to stopped condition (reset)

+ */

+ bah_stop(sc);

+ ifp->if_unit = sc->sc_dev.dv_unit;

+ ifp->if_name = bah_cd.cd_name;

+ ifp->if_output = arc_output;

+ ifp->if_start = bah_start;

+ ifp->if_ioctl = bah_ioctl;

+ ifp->if_timer = 0;

+ ifp->if_watchdog = bah_watchdog;

+ ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX |

+ IFF_NOTRAILERS | IFF_NOARP;

+ ifp->if_mtu = ARCMTU;

+ if_attach(ifp);

+ arc_ifattach(ifp);

+#if NBPFILTER > 0

+ bpfattach(&ifp->if_bpf, ifp, DLT_ARCNET, ARC_HDRLEN);

+#endif

+ /* under heavy load we need four of them: */

+ alloc_sicallback();

+ sc->sc_isr.isr_intr = bahintr;

+ sc->sc_isr.isr_arg = sc;

+ sc->sc_isr.isr_ipl = 2;

+ add_isr(&sc->sc_isr);

+/*

+ * Initialize device

+ *

+ */

+void

+bah_init(sc)

+ struct bah_softc *sc;

+ struct ifnet *ifp;

+ int s;

+ ifp = &sc->sc_arccom.ac_if;

+ if ((ifp->if_flags & IFF_RUNNING) == 0) {

+ s = splnet();

+ ifp->if_flags |= IFF_RUNNING;

+ bah_reset(sc);

+ bah_start(ifp);

+ splx(s);

+ }

+/*

+ * Reset the interface...

+ *

+ * this assumes that it is called inside a critical section...

+ *

+ */

+void

+bah_reset(sc)

+ struct bah_softc *sc;

+ struct ifnet *ifp;

+ int linkaddress;

+ ifp = &sc->sc_arccom.ac_if;

+#ifdef BAH_DEBUG

+ printf("%s: reset\n", sc->sc_dev.dv_xname);

+#endif

+ /* stop hardware in case it still runs */

+ sc->sc_base->kick1 = 0;

+ sc->sc_base->kick2 = 0;

+ DELAY(200);

+ /* and restart it */

+ sc->sc_base->kick1 = 0xFF;

+ sc->sc_base->kick2 = 0xFF;

+ do {

+ DELAY(200);

+ } while (!(sc->sc_base->status & ARC_POR));

+ linkaddress = sc->sc_base->dipswitches;

+#if defined(BAH_DEBUG) && (BAH_DEBUG > 2)

+ printf("bah%ld: reset: card reset, link addr = 0x%02x (%ld)\n",

+ ifp->if_unit, linkaddress, linkaddress);

+#endif

+ sc->sc_arccom.ac_anaddr = linkaddress;

+ /* tell the routing level about the (possibly changed) link address */

+ arc_ifattach(ifp);

+ /* POR is NMI, but we need it below: */

+ sc->sc_intmask = ARC_RECON|ARC_POR;

+ sc->sc_base->status = sc->sc_intmask;

+ sc->sc_base->command = ARC_CONF(CONF_LONG);

+#ifdef BAH_DEBUG

+ printf("%s: reset: chip configured, status=0x%02x\n",

+ sc->sc_dev.dv_xname, sc->sc_base->status);

+#endif

+ sc->sc_base->command = ARC_CLR(CLR_POR|CLR_RECONFIG);

+#ifdef BAH_DEBUG

+ printf("%s: reset: bits cleared, status=0x%02x\n",

+ sc->sc_dev.dv_xname, sc->sc_base->status);

+#endif

+ sc->sc_reconcount_excessive = ARC_EXCESSIVE_RECONS;

+ /* start receiver */

+ sc->sc_intmask |= ARC_RI;

+ sc->sc_rx_fillcount = 0;

+ sc->sc_rx_act = 2;

+ sc->sc_base->command = ARC_RXBC(2);

+ sc->sc_base->status = sc->sc_intmask;

+#ifdef BAH_DEBUG

+ printf("%s: reset: started receiver, status=0x%02x\n",

+ sc->sc_dev.dv_xname, sc->sc_base->status);

+#endif

+ /* and init transmitter status */

+ sc->sc_tx_act = 0;

+ sc->sc_tx_fillcount = 0;

+ ifp->if_flags |= IFF_RUNNING;

+ ifp->if_flags &= ~IFF_OACTIVE;

+#ifdef BAHTIMINGS

+ bzero((caddr_t)&(sc->sc_stats), sizeof(sc->sc_stats));

+ sc->sc_stats.mincopyin =

+ sc->sc_stats.mincopyout =

+ sc->sc_stats.minsend = ULONG_MAX;

+#endif

+ bah_start(ifp);

+/*

+ * Take interface offline

+ */

+void

+bah_stop(sc)

+ struct bah_softc *sc;

+ /* Stop the interrupts */

+ sc->sc_base->status = 0;

+ /* Stop the interface */

+ sc->sc_base->kick1 = 0;

+ sc->sc_base->kick2 = 0;

+ /* Stop watchdog timer */

+ sc->sc_arccom.ac_if.if_timer = 0;

+#ifdef BAHTIMINGS

+ log(LOG_DEBUG,"%s: to board: %6lu .. %6lu ns/byte\n",

+ sc->sc_dev.dv_xname,

+ sc->sc_stats.mincopyout, sc->sc_stats.maxcopyout);

+ log(LOG_DEBUG,"%s: from board: %6lu .. %6lu ns/byte\n",

+ sc->sc_dev.dv_xname,

+ sc->sc_stats.mincopyin, sc->sc_stats.maxcopyin);

+ log(LOG_DEBUG,"%s: send time: %6lu .. %6lu mics/byte\n",

+ sc->sc_dev.dv_xname,

+ sc->sc_stats.minsend, sc->sc_stats.maxsend);

+ sc->sc_stats.minsend =

+ sc->sc_stats.mincopyout =

+ sc->sc_stats.mincopyin = ULONG_MAX;

+ sc->sc_stats.maxsend =

+ sc->sc_stats.maxcopyout =

+ sc->sc_stats.maxcopyin = 0;

+#endif

+__inline void

+movepout(from, to, len)

+ u_char *from;

+ __volatile u_char *to;

+ int len;

+#ifdef BAHASMCOPY

+ u_short shortd;

+ u_long longd, longd1, longd2, longd3, longd4;

+ if ((len > 3) && ((long)from) & 3) {

+ switch (((long)from) & 3) {

+ case 3:

+ *to = *from++;

+ to += 2; --len;

+ break;

+ case 1:

+ *to = *from++;

+ to += 2; --len;

+ case 2:

+ shortd = *((u_short *)from)++;

+ asm("movepw %0,%1@(0)" : : "d"(shortd), "a"(to));

+ to += 4; len -= 2;

+ break;

+ default:

+ }

+ while (len >= 32) {

+ longd1 = *((u_long *)from)++;

+ longd2 = *((u_long *)from)++;

+ longd3 = *((u_long *)from)++;

+ longd4 = *((u_long *)from)++;

+ asm("movepl %0,%1@(0)" : : "d"(longd1), "a"(to));

+ asm("movepl %0,%1@(8)" : : "d"(longd2), "a"(to));

+ asm("movepl %0,%1@(16)" : : "d"(longd3), "a"(to));

+ asm("movepl %0,%1@(24)" : : "d"(longd4), "a"(to));

+ longd1 = *((u_long *)from)++;

+ longd2 = *((u_long *)from)++;

+ longd3 = *((u_long *)from)++;

+ longd4 = *((u_long *)from)++;

+ asm("movepl %0,%1@(32)" : : "d"(longd1), "a"(to));

+ asm("movepl %0,%1@(40)" : : "d"(longd2), "a"(to));

+ asm("movepl %0,%1@(48)" : : "d"(longd3), "a"(to));

+ asm("movepl %0,%1@(56)" : : "d"(longd4), "a"(to));

+ to += 64; len -= 32;

+ }

+ while (len > 0) {

+ longd = *((u_long *)from)++;

+ asm("movepl %0,%1@(0)" : : "d"(longd), "a"(to));

+ to += 8; len -= 4;

+ }

+#endif

+ while (len > 0) {

+ *to = *from++;

+ to += 2;

+ --len;

+ }

+/*

+ * Start output on interface. Get another datagram to send

+ * off the interface queue, and copy it to the

+ * interface becore starting the output

+ *

+ * this assumes that it is called inside a critical section...

+ * XXX hm... does it still?

+ *

+ */

+void

+bah_start(ifp)

+ struct ifnet *ifp;

+ struct bah_softc *sc;

+ struct mbuf *m,*mp;

+ __volatile u_char *bah_ram_ptr;

+ int len, tlen, offset, s, buffer;

+#ifdef BAHTIMINGS

+ u_long copystart, lencopy, perbyte;

+#endif

+ sc = bah_cd.cd_devs[ifp->if_unit];

+#if defined(BAH_DEBUG) && (BAH_DEBUG > 3)

+ printf("%s: start(0x%x)\n", sc->sc_dev.dv_xname, ifp);

+#endif

+ if ((ifp->if_flags & IFF_RUNNING) == 0)

+ return;

+ s = splnet();

+ if (sc->sc_tx_fillcount >= 2) {

+ splx(s);

+ return;

+ }

+ IF_DEQUEUE(&ifp->if_snd, m);

+ buffer = sc->sc_tx_act ^ 1;

+ splx(s);

+ if (m == 0)

+ return;

+#if NBPFILTER > 0

+ /*

+ * If bpf is listening on this interface, let it

+ * see the packet before we commit it to the wire

+ *

+ * (can't give the copy in A2060 card RAM to bpf, because

+ * that RAM is just accessed as on every other byte)

+ */

+ if (ifp->if_bpf)

+ bpf_mtap(ifp->if_bpf, m);

+#endif

+#ifdef BAH_DEBUG

+ m = m_pullup(m,3); /* gcc does structure padding */

+ printf("%s: start: filling %ld from %ld to %ld type %ld\n",

+ sc->sc_dev.dv_xname, buffer, mtod(m, u_char *)[0],

+ mtod(m, u_char *)[1], mtod(m, u_char *)[2]);

+#else

+ m = m_pullup(m, 2);

+#endif

+ bah_ram_ptr = sc->sc_base->buffers + buffer*512*2;

+ /* write the addresses to RAM and throw them away */

+ /*

+ * Hardware does this: Yet Another Microsecond Saved.

+ * (btw, timing code says usually 2 microseconds)

+ * bah_ram_ptr[0*2] = mtod(m, u_char *)[0];

+ */

+ bah_ram_ptr[1 * 2] = mtod(m, u_char *)[1];

+ m_adj(m, 2);

+ /* get total length left at this point */

+ tlen = m->m_pkthdr.len;

+ if (tlen < ARC_MIN_FORBID_LEN) {

+ offset = 256 - tlen;

+ bah_ram_ptr[2 * 2] = offset;

+ } else {

+ bah_ram_ptr[2 * 2] = 0;

+ if (tlen <= ARC_MAX_FORBID_LEN)

+ offset = 255; /* !!! */

+ else {

+ if (tlen > ARC_MAX_LEN)

+ tlen = ARC_MAX_LEN;

+ offset = 512 - tlen;

+ }

+ bah_ram_ptr[3 * 2] = offset;

+ }

+ bah_ram_ptr += offset * 2;

+ /* lets loop through the mbuf chain */

+ for (mp = m; mp; mp = mp->m_next) {

+ if ((len = mp->m_len)) { /* YAMS */

+#ifdef BAHTIMINGS

+ lencopy = len;

+ copystart = clkread();

+#endif

+ movepout(mtod(mp, caddr_t), bah_ram_ptr, len);

+#ifdef BAHTIMINGS

+ perbyte = 1000 * (clkread() - copystart) / lencopy;

+ sc->sc_stats.mincopyout =

+ ulmin(sc->sc_stats.mincopyout, perbyte);

+ sc->sc_stats.maxcopyout =

+ ulmax(sc->sc_stats.maxcopyout, perbyte);

+#endif

+ bah_ram_ptr += len*2;

+ }

+ sc->sc_broadcast[buffer] = (m->m_flags & M_BCAST) != 0;

+ sc->sc_retransmits[buffer] = (m->m_flags & M_BCAST) ? 1 : 5;

+ /* actually transmit the packet */

+ s = splnet();

+ if (++sc->sc_tx_fillcount > 1) {

+ /*

+ * We are filled up to the rim. No more bufs for the moment,

+ * please.

+ */

+ ifp->if_flags |= IFF_OACTIVE;

+ } else {

+#ifdef BAH_DEBUG

+ printf("%s: start: starting transmitter on buffer %d\n",

+ sc->sc_dev.dv_xname, buffer);

+#endif

+ /* Transmitter was off, start it */

+ sc->sc_tx_act = buffer;

+ /*

+ * We still can accept another buf, so don't:

+ * ifp->if_flags |= IFF_OACTIVE;

+ */

+ sc->sc_intmask |= ARC_TA;

+ sc->sc_base->command = ARC_TX(buffer);

+ sc->sc_base->status = sc->sc_intmask;

+ sc->sc_arccom.ac_if.if_timer = ARCTIMEOUT;

+#ifdef BAHTIMINGS

+ bcopy((caddr_t)&time,

+ (caddr_t)&(sc->sc_stats.lasttxstart_tv),

+ sizeof(struct timeval));

+ sc->sc_stats.lasttxstart_mics = clkread();

+#endif

+ }

+ splx(s);

+ m_freem(m);

+ /*

+ * After 10 times reading the docs, I realized

+ * that in the case the receiver NAKs the buffer request,

+ * the hardware retries till shutdown.

+ * This is integrated now in the code above.

+ */

+ return;

+void

+callstart(vsc, dummy)

+ void *vsc, *dummy;

+ struct bah_softc *sc;

+ sc = (struct bah_softc *)vsc;

+ bah_start(&sc->sc_arccom.ac_if);

+__inline void

+movepin(from, to, len)

+ __volatile u_char *from;

+ u_char *to;

+ int len;

+#ifdef BAHASMCOPY

+ unsigned long longd, longd1, longd2, longd3, longd4;

+ ushort shortd;

+ if ((len > 3) && (((long)to) & 3)) {

+ switch (((long)to) & 3) {

+ case 3: *to++ = *from;

+ from += 2; --len;

+ break;

+ case 1: *to++ = *from;

+ from += 2; --len;

+ case 2: asm ("movepw %1@(0),%0": "=d" (shortd) : "a" (from));

+ *((ushort *)to)++ = shortd;

+ from += 4; len -= 2;

+ break;

+ default:

+ }

+ while (len >= 32) {

+ asm("movepl %1@(0),%0" : "=d"(longd1) : "a" (from));

+ asm("movepl %1@(8),%0" : "=d"(longd2) : "a" (from));

+ asm("movepl %1@(16),%0" : "=d"(longd3) : "a" (from));

+ asm("movepl %1@(24),%0" : "=d"(longd4) : "a" (from));

+ *((unsigned long *)to)++ = longd1;

+ *((unsigned long *)to)++ = longd2;

+ *((unsigned long *)to)++ = longd3;

+ *((unsigned long *)to)++ = longd4;

+ asm("movepl %1@(32),%0" : "=d"(longd1) : "a" (from));

+ asm("movepl %1@(40),%0" : "=d"(longd2) : "a" (from));

+ asm("movepl %1@(48),%0" : "=d"(longd3) : "a" (from));

+ asm("movepl %1@(56),%0" : "=d"(longd4) : "a" (from));

+ *((unsigned long *)to)++ = longd1;

+ *((unsigned long *)to)++ = longd2;

+ *((unsigned long *)to)++ = longd3;

+ *((unsigned long *)to)++ = longd4;

+ from += 64; len -= 32;

+ }

+ while (len > 0) {

+ asm("movepl %1@(0),%0" : "=d"(longd) : "a" (from));

+ *((unsigned long *)to)++ = longd;

+ from += 8; len -= 4;

+ }

+#endif /* BAHASMCOPY */

+ while (len > 0) {

+ *to++ = *from;

+ from += 2;

+ --len;

+ }

+/*

+ * Arcnet interface receiver soft interrupt:

+ * get the stuff out of any filled buffer we find.

+ */

+void

+bah_srint(vsc, dummy)

+ void *vsc, *dummy;

+ struct bah_softc *sc;

+ int buffer, len, len1, amount, offset, s, i, type;

+ u_char __volatile *bah_ram_ptr;

+ struct mbuf *m, *dst, *head;

+ struct arc_header *ah;

+ struct ifnet *ifp;

+#ifdef BAHTIMINGS

+ u_long copystart, lencopy, perbyte;

+#endif

+ sc = (struct bah_softc *)vsc;

+ ifp = &sc->sc_arccom.ac_if;

+ head = 0;

+ s = splnet();

+ buffer = sc->sc_rx_act ^ 1;

+ splx(s);

+ /* Allocate header mbuf */

+ MGETHDR(m, M_DONTWAIT, MT_DATA);

+ if (m == 0) {

+ /*

+ * in case s.th. goes wrong with mem, drop it

+ * to make sure the receiver can be started again

+ * count it as input error (we dont have any other

+ * detectable)

+ */

+ ifp->if_ierrors++;

+ goto cleanup;

+ }

+ m->m_pkthdr.rcvif = ifp;

+ /*

+ * Align so that IP packet will be longword aligned. Here we

+ * assume that m_data of new packet is longword aligned.

+ * When implementing PHDS, we might have to change it to 2,

+ * (2*sizeof(ulong) - ARC_HDRNEWLEN)), packet type dependent.

+ */

+ bah_ram_ptr = sc->sc_base->buffers + buffer*512*2;

+ offset = bah_ram_ptr[2*2];

+ if (offset)

+ len = 256 - offset;

+ else {

+ offset = bah_ram_ptr[3*2];

+ len = 512 - offset;

+ }

+ type = bah_ram_ptr[offset*2];

+ m->m_data += 1 + arc_isphds(type);

+ head = m;

+ ah = mtod(head, struct arc_header *);

+ ah->arc_shost = bah_ram_ptr[0*2];

+ ah->arc_dhost = bah_ram_ptr[1*2];

+ m->m_pkthdr.len = len+2; /* whole packet length */

+ m->m_len = 2; /* mbuf filled with ARCnet addresses */

+ bah_ram_ptr += offset*2; /* ram buffer continues there */

+ while (len > 0) {

+ len1 = len;

+ amount = M_TRAILINGSPACE(m);

+ if (amount == 0) {

+ dst = m;

+ MGET(m, M_DONTWAIT, MT_DATA);

+ if (m == 0) {

+ ifp->if_ierrors++;

+ goto cleanup;

+ }

+ if (len1 >= MINCLSIZE)

+ MCLGET(m, M_DONTWAIT);

+ m->m_len = 0;

+ dst->m_next = m;

+ amount = M_TRAILINGSPACE(m);

+ }

+ if (amount < len1)

+ len1 = amount;

+#ifdef BAHTIMINGS

+ lencopy = len;

+ copystart = clkread();

+#endif

+ movepin(bah_ram_ptr, mtod(m, u_char *) + m->m_len, len1);

+#ifdef BAHTIMINGS

+ perbyte = 1000 * (clkread() - copystart) / lencopy;

+ sc->sc_stats.mincopyin =

+ ulmin(sc->sc_stats.mincopyin, perbyte);

+ sc->sc_stats.maxcopyin =

+ ulmax(sc->sc_stats.maxcopyin, perbyte);

+#endif

+ m->m_len += len1;

+ bah_ram_ptr += len1*2;

+ len -= len1;

+ }

+#if NBPFILTER > 0

+ if (ifp->if_bpf)

+ bpf_mtap(ifp->if_bpf, head);

+#endif

+ arc_input(&sc->sc_arccom.ac_if, head);

+ /* arc_input has freed it, we dont need to... */

+ head = NULL;

+ ifp->if_ipackets++;

+cleanup:

+ if (head != NULL)

+ m_freem(head);

+ /* mark buffer as invalid by source id 0 */

+ sc->sc_base->buffers[buffer*512*2] = 0;

+ s = splnet();

+ if (--sc->sc_rx_fillcount == 2 - 1) {

+ /* was off, restart it on buffer just emptied */

+ sc->sc_rx_act = buffer;

+ sc->sc_intmask |= ARC_RI;

+ /* this also clears the RI flag interupt: */

+ sc->sc_base->command = ARC_RXBC(buffer);

+ sc->sc_base->status = sc->sc_intmask;

+#ifdef BAH_DEBUG

+ printf("%s: srint: restarted rx on buf %ld\n",

+ sc->sc_dev.dv_xname, buffer);

+#endif

+ }

+ splx(s);

+__inline static void

+bah_tint(sc, isr)

+ struct bah_softc *sc;

+ int isr;

+ struct ifnet *ifp;

+ int buffer;

+#ifdef BAHTIMINGS

+ int clknow;

+#endif

+ ifp = &(sc->sc_arccom.ac_if);

+ buffer = sc->sc_tx_act;

+ /*

+ * retransmit code:

+ * Normal situtations first for fast path:

+ * If acknowledgement received ok or broadcast, we're ok.

+ * else if

+ */

+ if (isr & ARC_TMA || sc->sc_broadcast[buffer])

+ sc->sc_arccom.ac_if.if_opackets++;

+#ifdef BAHRETRANSMIT

+ else if (ifp->if_flags & IFF_LINK2 && ifp->if_timer > 0

+ && --sc->sc_retransmits[buffer] > 0) {

+ /* retransmit same buffer */

+ sc->sc_base->command = ARC_TX(buffer);

+ return;

+ }

+#endif

+ else

+ ifp->if_oerrors++;

+#ifdef BAHTIMINGS

+ clknow = clkread();

+ sc->sc_stats.minsend = ulmin(sc->sc_stats.minsend,

+ clknow - sc->sc_stats.lasttxstart_mics);

+ sc->sc_stats.maxsend = ulmax(sc->sc_stats.maxsend,

+ clknow - sc->sc_stats.lasttxstart_mics);

+#endif

+ /* We know we can accept another buffer at this point. */

+ ifp->if_flags &= ~IFF_OACTIVE;

+ if (--sc->sc_tx_fillcount > 0) {

+ /*

+ * start tx on other buffer.

+ * This also clears the int flag

+ */

+ buffer ^= 1;

+ sc->sc_tx_act = buffer;

+ /*

+ * already given:

+ * sc->sc_intmask |= ARC_TA;

+ * sc->sc_base->status = sc->sc_intmask;

+ */

+ sc->sc_base->command = ARC_TX(buffer);

+ /* init watchdog timer */

+ ifp->if_timer = ARCTIMEOUT;

+#ifdef BAHTIMINGS

+ bcopy((caddr_t)&time,

+ (caddr_t)&(sc->sc_stats.lasttxstart_tv),

+ sizeof(struct timeval));

+ sc->sc_stats.lasttxstart_mics = clkread();

+#endif

+#if defined(BAH_DEBUG) && (BAH_DEBUG > 1)

+ printf("%s: tint: starting tx on buffer %d, status 0x%02x\n",

+ sc->sc_dev.dv_xname, buffer, sc->sc_base->status);

+#endif

+ } else {

+ /* have to disable TX interrupt */

+ sc->sc_intmask &= ~ARC_TA;

+ sc->sc_base->status = sc->sc_intmask;

+ /* ... and watchdog timer */

+ ifp->if_timer = 0;

+#ifdef BAH_DEBUG

+ printf("%s: tint: no more buffers to send, status 0x%02x\n",

+ sc->sc_dev.dv_xname, sc->sc_base->status);

+#endif

+ }

+#ifdef BAHSOFTCOPY

+ /* schedule soft int to fill a new buffer for us */

+ add_sicallback((sifunc_t)callstart, sc, NULL);

+#else

+ /* call it directly */

+ callstart(sc, NULL);

+#endif

+/*

+ * Our interrupt routine

+ */

+int

+bahintr(sc)

+ struct bah_softc *sc;

+ u_char isr, maskedisr;

+ int buffer;

+ u_long newsec;

+ isr = sc->sc_base->status;

+ maskedisr = isr & sc->sc_intmask;

+ if (!maskedisr)

+ return (0);

+#if defined(BAH_DEBUG) && (BAH_DEBUG>1)

+ printf("%s: intr: status 0x%02x, intmask 0x%02x\n",

+ sc->sc_dev.dv_xname, isr, sc->sc_intmask);

+#endif

+ if (maskedisr & ARC_POR) {

+ sc->sc_arccom.ac_anaddr = sc->sc_base->dipswitches;

+ sc->sc_base->command = ARC_CLR(CLR_POR);

+ log(LOG_WARNING, "%s: intr: got spurious power on reset int\n",

+ sc->sc_dev.dv_xname);

+ }

+ if (maskedisr & ARC_RECON) {

+ /*

+ * we dont need to:

+ * sc->sc_base->command = ARC_CONF(CONF_LONG);

+ */

+ sc->sc_base->command = ARC_CLR(CLR_RECONFIG);

+ sc->sc_arccom.ac_if.if_collisions++;

+ /*

+ * If more than 2 seconds per reconfig:

+ * Reset time and counter.

+ * else:

+ * If more than ARC_EXCESSIVE_RECONFIGS reconfigs

+ * since last burst, complain and set treshold for

+ * warnings to ARC_EXCESSIVE_RECONS_REWARN.

+ *

+ * This allows for, e.g., new stations on the cable, or

+ * cable switching as long as it is over after (normally)

+ * 16 seconds.

+ *

+ * XXX TODO: check timeout bits in status word and double

+ * time if necessary.

+ */

+ newsec = time.tv_sec;

+ if (newsec - sc->sc_recontime > 2 * sc->sc_reconcount) {

+ sc->sc_recontime = newsec;

+ sc->sc_reconcount = 0;

+ sc->sc_reconcount_excessive = ARC_EXCESSIVE_RECONS;

+ } else if (++sc->sc_reconcount > sc->sc_reconcount_excessive) {

+ sc->sc_reconcount_excessive =

+ ARC_EXCESSIVE_RECONS_REWARN;

+ log(LOG_WARNING,

+ "%s: excessive token losses, cable problem?\n",

+ sc->sc_dev.dv_xname);

+ sc->sc_recontime = newsec;

+ sc->sc_reconcount = 0;

+ }

+ if (maskedisr & ARC_RI) {

+#if defined(BAH_DEBUG) && (BAH_DEBUG > 1)

+ printf("%s: intr: hard rint, act %ld\n",

+ sc->sc_dev.dv_xname, sc->sc_rx_act);

+#endif

+ buffer = sc->sc_rx_act;

+ /* look if buffer is marked invalid: */

+ if (sc->sc_base->buffers[buffer*512*2] == 0) {

+ /* invalid marked buffer (or illegally configured sender) */

+ log(LOG_WARNING,

+ "%s: spurious RX interrupt or sender 0 (ignored)\n",

+ sc->sc_dev.dv_xname);

+ /*

+ * restart receiver on same buffer.

+ */

+ sc->sc_base->command = ARC_RXBC(buffer);

+ } else if (++sc->sc_rx_fillcount > 1) {

+ sc->sc_intmask &= ~ARC_RI;

+ sc->sc_base->status = sc->sc_intmask;

+ } else {

+ buffer ^= 1;

+ sc->sc_rx_act = buffer;

+ /*

+ * Start receiver on other receive buffer.

+ * This also clears the RI interupt flag.

+ */

+ sc->sc_base->command = ARC_RXBC(buffer);

+ /* we are in the RX intr, so mask is ok for RX */

+#ifdef BAH_DEBUG

+ printf("%s: started rx for buffer %ld, status 0x%02x\n",

+ sc->sc_dev.dv_xname, sc->sc_rx_act,

+ sc->sc_base->status);

+#endif

+ }

+#ifdef BAHSOFTCOPY

+ /* this one starts a soft int to copy out of the hw */

+ add_sicallback((sifunc_t)bah_srint, sc,NULL);

+#else

+ /* this one does the copy here */

+ bah_srint(sc,NULL);

+#endif

+ }

+ if (maskedisr & ARC_TA)

+ bah_tint(sc, isr);

+ return (1);

+/*

+ * Process an ioctl request.

+ * This code needs some work - it looks pretty ugly.

+ */

+int

+bah_ioctl(ifp, command, data)

+ register struct ifnet *ifp;

+ u_long command;

+ caddr_t data;

+ struct bah_softc *sc;

+ register struct ifaddr *ifa;

+ int s, error;

+ error = 0;

+ sc = bah_cd.cd_devs[ifp->if_unit];

+ ifa = (struct ifaddr *)data;

+ s = splnet();

+#if defined(BAH_DEBUG) && (BAH_DEBUG > 2)

+ printf("%s: ioctl() called, cmd = 0x%x\n",

+ sc->sc_dev.dv_xname, command);

+#endif

+ switch (command) {

+ case SIOCSIFADDR:

+ ifp->if_flags |= IFF_UP;

+ switch (ifa->ifa_addr->sa_family) {

+#ifdef INET

+ case AF_INET:

+ bah_init(sc);

+ break;

+#endif

+ default:

+ bah_init(sc);

+ break;

+ }

+ case SIOCSIFFLAGS:

+ if ((ifp->if_flags & IFF_UP) == 0 &&

+ (ifp->if_flags & IFF_RUNNING) != 0) {

+ /*

+ * If interface is marked down and it is running,

+ * then stop it.

+ */

+ bah_stop(sc);

+ ifp->if_flags &= ~IFF_RUNNING;

+ } else if ((ifp->if_flags & IFF_UP) != 0 &&

+ (ifp->if_flags & IFF_RUNNING) == 0) {

+ /*

+ * If interface is marked up and it is stopped, then

+ * start it.

+ */

+ bah_init(sc);

+ }

+ break;

+ /* Multicast not supported */

+ default:

+ error = EINVAL;

+ }

+ splx(s);

+ return (error);

+/*

+ * watchdog routine for transmitter.

+ *

+ * We need this, because else a receiver whose hardware is alive, but whose

+ * software has not enabled the Receiver, would make our hardware wait forever

+ * Discovered this after 20 times reading the docs.

+ *

+ * Only thing we do is disable transmitter. We'll get an transmit timeout,

+ * and the int handler will have to decide not to retransmit (in case

+ * retransmission is implemented).

+ *

+ * This one assumes being called inside splnet(), and that net >= ipl2

+ */

+void

+bah_watchdog(unit)

+int unit;

+ struct bah_softc *sc;

+ struct ifnet *ifp;

+ sc = bah_cd.cd_devs[unit];

+ ifp = &(sc->sc_arccom.ac_if);

+ sc->sc_base->command = ARC_TXDIS;

+ return;

diff --git a/sys/dev/ic/smc90cx6reg.h b/sys/dev/ic/smc90cx6reg.h
new file mode 100644
index 00000000000..f2ec2a06e5c
--- /dev/null
+++ b/sys/dev/ic/smc90cx6reg.h

@@ -0,0 +1,99 @@

+/* $NetBSD: smc90cx6reg.h,v 1.4 1995/06/07 00:16:59 cgd Exp $ */

+/*

+ *

+ * 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 Ignatios Souvatzis

+ * for the NetBSD project.