/*
* Interface exists: make available by filling in network interface
* record. System will initialize the interface when it is ready
* to accept packets.
*/
void
dmcattach(device_t parent, device_t self, void *aux)
{
struct uba_attach_args *ua = aux;
struct dmc_softc *sc = device_private(self);
sc->sc_dev = self;
sc->sc_iot = ua->ua_iot;
sc->sc_ioh = ua->ua_ioh;
sc->sc_dmat = ua->ua_dmat;
strlcpy(sc->sc_if.if_xname, device_xname(sc->sc_dev), IFNAMSIZ);
sc->sc_if.if_mtu = DMCMTU;
sc->sc_if.if_init = dmcinit;
sc->sc_if.if_output = dmcoutput;
sc->sc_if.if_ioctl = dmcioctl;
sc->sc_if.if_watchdog = dmctimeout;
sc->sc_if.if_flags = IFF_POINTOPOINT;
sc->sc_if.if_softc = sc;
IFQ_SET_READY(&sc->sc_if.if_snd);
uba_intr_establish(ua->ua_icookie, ua->ua_cvec, dmcrint, sc,
&sc->sc_rintrcnt);
uba_intr_establish(ua->ua_icookie, ua->ua_cvec+4, dmcxint, sc,
&sc->sc_tintrcnt);
uba_reset_establish(dmcreset, sc->sc_dev);
evcnt_attach_dynamic(&sc->sc_rintrcnt, EVCNT_TYPE_INTR, ua->ua_evcnt,
device_xname(sc->sc_dev), "intr");
evcnt_attach_dynamic(&sc->sc_tintrcnt, EVCNT_TYPE_INTR, ua->ua_evcnt,
device_xname(sc->sc_dev), "intr");
if_attach(&sc->sc_if);
}
void
rlattach(struct device *parent, struct device *self, void *aux)
{
struct rl_softc *rc = (struct rl_softc *)self;
struct rlc_attach_args *ra = aux;
struct disklabel *dl;
uba_reset_establish(rlreset, self);
rc->rc_hwid = ra->hwid;
rc->rc_disk.dk_name = rc->rc_dev.dv_xname;
disk_attach(&rc->rc_disk);
dl = rc->rc_disk.dk_label;
dl->d_npartitions = 3;
strcpy(dl->d_typename, "RL01");
if (ra->type & RLMP_DT)
dl->d_typename[3] = '2';
dl->d_secsize = DEV_BSIZE; /* XXX - wrong, but OK for now */
dl->d_nsectors = RL_SPT/2;
dl->d_ntracks = RL_SPD;
dl->d_ncylinders = ra->type & RLMP_DT ? RL_TPS02 : RL_TPS01;
dl->d_secpercyl = dl->d_nsectors * dl->d_ntracks;
dl->d_secperunit = dl->d_ncylinders * dl->d_secpercyl;
dl->d_partitions[0].p_size = dl->d_partitions[2].p_size =
dl->d_secperunit;
dl->d_partitions[0].p_offset = dl->d_partitions[2].p_offset = 0;
dl->d_interleave = dl->d_headswitch = 1;
dl->d_bbsize = BBSIZE;
dl->d_sbsize = SBSIZE;
dl->d_rpm = 2400;
dl->d_type = DTYPE_DEC;
printf(": %s\n", dl->d_typename);
}
/*
* Interface exists: make available by filling in network interface
* record. System will initialize the interface when it is ready
* to accept packets. A STATUS command is done to get the ethernet
* address and other interesting data.
*/
void
ilattach(device_t parent, device_t self, void *aux)
{
struct uba_attach_args *ua = aux;
struct il_softc *sc = device_private(self);
struct ifnet *ifp = &sc->sc_if;
int error;
sc->sc_dev = self;
sc->sc_iot = ua->ua_iot;
sc->sc_ioh = ua->ua_ioh;
sc->sc_dmat = ua->ua_dmat;
/*
* Map interrupt vectors and reset function.
*/
uba_intr_establish(ua->ua_icookie, ua->ua_cvec, ilcint,
sc, &sc->sc_cintrcnt);
evcnt_attach_dynamic(&sc->sc_cintrcnt, EVCNT_TYPE_INTR, ua->ua_evcnt,
device_xname(sc->sc_dev), "intr");
uba_intr_establish(ua->ua_icookie, ua->ua_cvec-4, ilrint,
sc, &sc->sc_rintrcnt);
evcnt_attach_dynamic(&sc->sc_rintrcnt, EVCNT_TYPE_INTR, ua->ua_evcnt,
device_xname(sc->sc_dev), "intr");
uba_reset_establish(ilreset, sc->sc_dev);
/*
* Reset the board and map the statistics
* buffer onto the Unibus.
*/
IL_WCSR(IL_CSR, ILC_RESET);
(void)ilwait(sc, "reset");
sc->sc_ui.ui_size = sizeof(struct il_stats);
sc->sc_ui.ui_vaddr = (void *)&sc->sc_stats;
if ((error = uballoc(device_private(parent), &sc->sc_ui, 0)))
return printf(": failed uballoc, error = %d\n", error);
IL_WCSR(IL_BAR, LOWORD(sc->sc_ui.ui_baddr));
IL_WCSR(IL_BCR, sizeof(struct il_stats));
IL_WCSR(IL_CSR, ((sc->sc_ui.ui_baddr >> 2) & IL_EUA)|ILC_STAT);
(void)ilwait(sc, "status");
ubfree(device_private(parent), &sc->sc_ui);
printf("%s: module=%s firmware=%s\n", device_xname(sc->sc_dev),
sc->sc_stats.ils_module, sc->sc_stats.ils_firmware);
printf("%s: hardware address %s\n", device_xname(sc->sc_dev),
ether_sprintf(sc->sc_stats.ils_addr));
strlcpy(ifp->if_xname, device_xname(sc->sc_dev), IFNAMSIZ);
ifp->if_softc = sc;
ifp->if_flags = IFF_BROADCAST;
ifp->if_init = ilinit;
ifp->if_stop = ilstop;
ifp->if_ioctl = ether_ioctl;
ifp->if_start = ilstart;
ifp->if_watchdog = ilwatch;
IFQ_SET_READY(&ifp->if_snd);
if_attach(ifp);
ether_ifattach(ifp, sc->sc_stats.ils_addr);
}
void
rlcattach(device_t parent, device_t self, void *aux)
{
struct rlc_softc *sc = device_private(self);
struct uba_attach_args *ua = aux;
struct rlc_attach_args ra;
int i, error;
sc->sc_dev = self;
sc->sc_uh = device_private(parent);
sc->sc_iot = ua->ua_iot;
sc->sc_ioh = ua->ua_ioh;
sc->sc_dmat = ua->ua_dmat;
uba_intr_establish(ua->ua_icookie, ua->ua_cvec,
rlcintr, sc, &sc->sc_intrcnt);
evcnt_attach_dynamic(&sc->sc_intrcnt, EVCNT_TYPE_INTR, ua->ua_evcnt,
device_xname(sc->sc_dev), "intr");
uba_reset_establish(rlcreset, self);
printf("\n");
/*
* The RL11 can only have one transfer going at a time,
* and max transfer size is one track, so only one dmamap
* is needed.
*/
error = bus_dmamap_create(sc->sc_dmat, MAXRLXFER, 1, MAXRLXFER, 0,
BUS_DMA_ALLOCNOW, &sc->sc_dmam);
if (error) {
aprint_error(": Failed to allocate DMA map, error %d\n", error);
return;
}
bufq_alloc(&sc->sc_q, "disksort", BUFQ_SORT_CYLINDER);
for (i = 0; i < RL_MAXDPC; i++) {
waitcrdy(sc);
RL_WREG(RL_DA, RLDA_GS|RLDA_RST);
RL_WREG(RL_CS, RLCS_GS|(i << RLCS_USHFT));
waitcrdy(sc);
ra.type = RL_RREG(RL_MP);
ra.hwid = i;
if ((RL_RREG(RL_CS) & RLCS_ERR) == 0)
config_found(sc->sc_dev, &ra, rlcprint);
}
}
/*
* Interface exists: make available by filling in network interface
* record. System will initialize the interface when it is ready
* to accept packets. We get the ethernet address here.
*/
void
deattach(struct device *parent, struct device *self, void *aux)
{
struct uba_attach_args *ua = aux;
struct de_softc *sc = (struct de_softc *)self;
struct ifnet *ifp = &sc->sc_if;
u_int8_t myaddr[ETHER_ADDR_LEN];
int csr1, error;
char *c;
sc->sc_iot = ua->ua_iot;
sc->sc_ioh = ua->ua_ioh;
sc->sc_dmat = ua->ua_dmat;
/*
* What kind of a board is this?
* The error bits 4-6 in pcsr1 are a device id as long as
* the high byte is zero.
*/
csr1 = DE_RCSR(DE_PCSR1);
if (csr1 & 0xff60)
c = "broken";
else if (csr1 & 0x10)
c = "delua";
else
c = "deuna";
/*
* Reset the board and temporarily map
* the pcbb buffer onto the Unibus.
*/
DE_WCSR(DE_PCSR0, 0); /* reset INTE */
DELAY(100);
DE_WCSR(DE_PCSR0, PCSR0_RSET);
dewait(sc, "reset");
sc->sc_ui.ui_size = sizeof(struct de_cdata);
if ((error = ubmemalloc((struct uba_softc *)parent, &sc->sc_ui, 0)))
return printf(": failed ubmemalloc(), error = %d\n", error);
sc->sc_dedata = (struct de_cdata *)sc->sc_ui.ui_vaddr;
/*
* Tell the DEUNA about our PCB
*/
DE_WCSR(DE_PCSR2, LOWORD(sc->sc_ui.ui_baddr));
DE_WCSR(DE_PCSR3, HIWORD(sc->sc_ui.ui_baddr));
DE_WLOW(CMD_GETPCBB);
dewait(sc, "pcbb");
sc->sc_dedata->dc_pcbb.pcbb0 = FC_RDPHYAD;
DE_WLOW(CMD_GETCMD);
dewait(sc, "read addr ");
bcopy((caddr_t)&sc->sc_dedata->dc_pcbb.pcbb2, myaddr, sizeof (myaddr));
printf(": %s, address %s\n", c, ether_sprintf(myaddr));
uba_intr_establish(ua->ua_icookie, ua->ua_cvec, deintr, sc,
&sc->sc_intrcnt);
uba_reset_establish(dereset, &sc->sc_dev);
evcnt_attach_dynamic(&sc->sc_intrcnt, EVCNT_TYPE_INTR, ua->ua_evcnt,
sc->sc_dev.dv_xname, "intr");
strlcpy(ifp->if_xname, sc->sc_dev.dv_xname, sizeof ifp->if_xname);
ifp->if_softc = sc;
ifp->if_flags = IFF_BROADCAST|IFF_SIMPLEX|IFF_MULTICAST|IFF_ALLMULTI;
ifp->if_ioctl = deioctl;
ifp->if_start = destart;
ifp->if_init = deinit;
ifp->if_stop = destop;
IFQ_SET_READY(&ifp->if_snd);
if_attach(ifp);
ether_ifattach(ifp, myaddr);
ubmemfree((struct uba_softc *)parent, &sc->sc_ui);
sc->sc_sh = shutdownhook_establish(deshutdown, sc);
}
