/*
* Check the slots looking for a board we recognise
* If we find one, note it's address (slot) and call
* the actual probe routine to check it out.
*/
static int
bha_eisa_match(device_t parent, cfdata_t match, void *aux)
{
struct eisa_attach_args *ea = aux;
bus_space_tag_t iot = ea->ea_iot;
bus_space_handle_t ioh, ioh2;
int port;
int rv;
/* must match one of our known ID strings */
if (strcmp(ea->ea_idstring, "BUS4201") &&
strcmp(ea->ea_idstring, "BUS4202"))
return (0);
if (bus_space_map(iot,
EISA_SLOT_ADDR(ea->ea_slot) + BHA_EISA_SLOT_OFFSET, BHA_EISA_IOSIZE,
0, &ioh))
return (0);
if (bha_eisa_address(iot, ioh, &port) ||
bus_space_map(iot, port, BHA_ISA_IOSIZE, 0, &ioh2)) {
bus_space_unmap(iot, ioh, BHA_EISA_IOSIZE);
return (0);
}
rv = bha_find(iot, ioh2);
bus_space_unmap(iot, ioh2, BHA_ISA_IOSIZE);
bus_space_unmap(iot, ioh, BHA_EISA_IOSIZE);
return (rv);
}
/*
* Attach all the sub-devices we can find
*/
static void
bha_eisa_attach(device_t parent, device_t self, void *aux)
{
struct eisa_attach_args *ea = aux;
struct bha_softc *sc = device_private(self);
bus_space_tag_t iot = ea->ea_iot;
bus_space_handle_t ioh, ioh2;
int port;
struct bha_probe_data bpd;
eisa_chipset_tag_t ec = ea->ea_ec;
eisa_intr_handle_t ih;
const char *model, *intrstr;
sc->sc_dev = self;
if (!strcmp(ea->ea_idstring, "BUS4201"))
model = EISA_PRODUCT_BUS4201;
else if (!strcmp(ea->ea_idstring, "BUS4202"))
model = EISA_PRODUCT_BUS4202;
else
model = "unknown model!";
printf(": %s\n", model);
if (bus_space_map(iot,
EISA_SLOT_ADDR(ea->ea_slot) + BHA_EISA_SLOT_OFFSET, BHA_EISA_IOSIZE,
0, &ioh))
panic("bha_eisa_attach: could not map EISA slot");
if (bha_eisa_address(iot, ioh, &port) ||
bus_space_map(iot, port, BHA_ISA_IOSIZE, 0, &ioh2))
panic("bha_eisa_attach: could not map ISA address");
sc->sc_iot = iot;
sc->sc_ioh = ioh2;
sc->sc_dmat = ea->ea_dmat;
if (!bha_probe_inquiry(iot, ioh2, &bpd))
panic("bha_eisa_attach failed");
sc->sc_dmaflags = 0;
if (eisa_intr_map(ec, bpd.sc_irq, &ih)) {
aprint_error_dev(sc->sc_dev, "couldn't map interrupt (%d)\n",
bpd.sc_irq);
return;
}
intrstr = eisa_intr_string(ec, ih);
sc->sc_ih = eisa_intr_establish(ec, ih, IST_LEVEL, IPL_BIO,
bha_intr, sc);
if (sc->sc_ih == NULL) {
aprint_error_dev(sc->sc_dev, "couldn't establish interrupt");
if (intrstr != NULL)
aprint_error(" at %s", intrstr);
aprint_error("\n");
return;
}
aprint_normal_dev(sc->sc_dev, "interrupting at %s\n", intrstr);
bha_attach(sc);
}
/*
* Check the slots looking for a board we recognise
* If we find one, note its address (slot) and call
* the actual probe routine to check it out.
*/
int
ahc_isa_probe(device_t parent, cfdata_t match, void *aux)
{
struct isa_attach_args *ia = aux;
struct ahc_isa_slot *as;
if (ahc_isa_slot_initialized == 0) {
LIST_INIT(&ahc_isa_all_slots);
ahc_isa_slot_initialized = 1;
}
if (ia->ia_nio < 1)
return (0);
if (ia->ia_nirq < 1)
return (0);
if (ISA_DIRECT_CONFIG(ia))
return (0);
if (ia->ia_io[0].ir_addr != ISA_UNKNOWN_PORT)
return (ahc_isa_match(ia, ia->ia_io[0].ir_addr));
/*
* Find this bus's state. If we don't yet have a slot
* marker, allocate and initialize one.
*/
for (as = ahc_isa_all_slots.lh_first; as != NULL;
as = as->link.le_next)
if (as->bus == device_unit(parent))
goto found_slot_marker;
/*
* Don't have one, so make one.
*/
as = (struct ahc_isa_slot *)
malloc(sizeof(struct ahc_isa_slot), M_DEVBUF, M_NOWAIT);
if (as == NULL)
panic("ahc_isa_probe: can't allocate slot marker");
as->bus = device_unit(parent);
as->slot = AHC_ISA_MIN_SLOT;
LIST_INSERT_HEAD(&ahc_isa_all_slots, as, link);
found_slot_marker:
for (; as->slot <= AHC_ISA_MAX_SLOT; as->slot++) {
if (ahc_isa_match(ia, EISA_SLOT_ADDR(as->slot) +
AHC_ISA_SLOT_OFFSET)) {
as->slot++; /* next slot to search */
return (1);
}
}
/* No matching cards were found. */
return (0);
}
/*
* Attach all the sub-devices we can find
*/
static void
uha_eisa_attach(struct device *parent, struct device *self, void *aux)
{
struct eisa_attach_args *ea = aux;
struct uha_softc *sc = device_private(self);
bus_space_tag_t iot = ea->ea_iot;
bus_dma_tag_t dmat = ea->ea_dmat;
bus_space_handle_t ioh;
struct uha_probe_data upd;
eisa_chipset_tag_t ec = ea->ea_ec;
eisa_intr_handle_t ih;
const char *model, *intrstr;
if (!strncmp(ea->ea_idstring, "USC024", 6))
model = EISA_PRODUCT_USC0240;
else
model = "unknown model!";
printf(": %s\n", model);
if (bus_space_map(iot, EISA_SLOT_ADDR(ea->ea_slot) +
UHA_EISA_SLOT_OFFSET, UHA_EISA_IOSIZE, 0, &ioh))
panic("uha_eisa_attach: could not map I/O addresses");
sc->sc_iot = iot;
sc->sc_ioh = ioh;
sc->sc_dmat = dmat;
if (!u24_find(iot, ioh, &upd))
panic("uha_eisa_attach: u24_find failed!");
sc->sc_dmaflags = 0;
if (eisa_intr_map(ec, upd.sc_irq, &ih)) {
aprint_error_dev(&sc->sc_dev, "couldn't map interrupt (%d)\n",
upd.sc_irq);
return;
}
intrstr = eisa_intr_string(ec, ih);
sc->sc_ih = eisa_intr_establish(ec, ih, IST_LEVEL, IPL_BIO,
u24_intr, sc);
if (sc->sc_ih == NULL) {
aprint_error_dev(&sc->sc_dev, "couldn't establish interrupt");
if (intrstr != NULL)
printf(" at %s", intrstr);
printf("\n");
return;
}
printf("%s: interrupting at %s\n", device_xname(&sc->sc_dev), intrstr);
/* Save function pointers for later use. */
sc->start_mbox = u24_start_mbox;
sc->poll = u24_poll;
sc->init = u24_init;
uha_attach(sc, &upd);
}
/*
* Check the slots looking for a board we recognise
* If we find one, note its address (slot) and call
* the actual probe routine to check it out.
*/
int
ahc_isa_probe(struct device *parent, void *match, void *aux)
{
struct isa_attach_args *ia = aux;
struct ahc_isa_slot *as;
if (ahc_isa_slot_initialized == 0) {
LIST_INIT(&ahc_isa_all_slots);
ahc_isa_slot_initialized = 1;
}
if (ia->ia_iobase != IOBASEUNK)
return (ahc_isa_match(ia, ia->ia_iobase));
/*
* Find this bus's state. If we don't yet have a slot
* marker, allocate and initialize one.
*/
LIST_FOREACH(as, &ahc_isa_all_slots, link)
if (as->bus == parent->dv_unit)
goto found_slot_marker;
/*
* Don't have one, so make one.
*/
as = (struct ahc_isa_slot *)
malloc(sizeof(struct ahc_isa_slot), M_DEVBUF, M_NOWAIT);
if (as == NULL)
panic("ahc_isa_probe: can't allocate slot marker");
as->bus = parent->dv_unit;
as->slot = AHC_ISA_MIN_SLOT;
LIST_INSERT_HEAD(&ahc_isa_all_slots, as, link);
found_slot_marker:
for (; as->slot <= AHC_ISA_MAX_SLOT; as->slot++) {
if (ahc_isa_match(ia, EISA_SLOT_ADDR(as->slot) +
AHC_ISA_SLOT_OFFSET)) {
as->slot++; /* next slot to search */
return (1);
}
}
/* No matching cards were found. */
return (0);
}
/*
* Check the slots looking for a board we recognise
* If we find one, note its address (slot) and call
* the actual probe routine to check it out.
*/
static int
ahc_eisa_match(device_t parent, cfdata_t match, void *aux)
{
struct eisa_attach_args *ea = aux;
bus_space_tag_t iot = ea->ea_iot;
bus_space_handle_t ioh;
int irq;
/* must match one of our known ID strings */
if (strcmp(ea->ea_idstring, "ADP7770") &&
strcmp(ea->ea_idstring, "ADP7771"))
return (0);
if (bus_space_map(iot, EISA_SLOT_ADDR(ea->ea_slot) +
AHC_EISA_SLOT_OFFSET, AHC_EISA_IOSIZE, 0, &ioh))
return (0);
irq = ahc_aic77xx_irq(iot, ioh);
bus_space_unmap(iot, ioh, AHC_EISA_IOSIZE);
return (irq >= 0);
}
/*
* Check the slots looking for a board we recognise
* If we find one, note it's address (slot) and call
* the actual probe routine to check it out.
*/
static int
uha_eisa_match(struct device *parent, struct cfdata *match,
void *aux)
{
struct eisa_attach_args *ea = aux;
bus_space_tag_t iot = ea->ea_iot;
bus_space_handle_t ioh;
int rv;
/* must match one of our known ID strings */
if (strncmp(ea->ea_idstring, "USC024", 6))
return (0);
if (bus_space_map(iot, EISA_SLOT_ADDR(ea->ea_slot) +
UHA_EISA_SLOT_OFFSET, UHA_EISA_IOSIZE, 0, &ioh))
return (0);
rv = u24_find(iot, ioh, NULL);
bus_space_unmap(iot, ioh, UHA_EISA_IOSIZE);
return (rv);
}
static void
eisaattach(device_t parent, device_t self, void *aux)
{
struct eisabus_attach_args *eba = aux;
bus_space_tag_t iot, memt;
bus_dma_tag_t dmat;
eisa_chipset_tag_t ec;
int slot, maxnslots;
eisa_attach_hook(parent, self, eba);
printf("\n");
iot = eba->eba_iot;
memt = eba->eba_memt;
ec = eba->eba_ec;
dmat = eba->eba_dmat;
/*
* Search for and attach subdevices.
*
* Slot 0 is the "motherboard" slot, and the code attaching
* the EISA bus should have already attached an ISA bus there.
*/
maxnslots = eisa_maxslots(ec);
for (slot = 1; slot < maxnslots; slot++) {
struct eisa_attach_args ea;
u_int slotaddr;
bus_space_handle_t slotioh;
int i;
int locs[EISACF_NLOCS];
ea.ea_iot = iot;
ea.ea_memt = memt;
ea.ea_ec = ec;
ea.ea_dmat = dmat;
ea.ea_slot = slot;
slotaddr = EISA_SLOT_ADDR(slot);
/*
* Get a mapping for the whole slot-specific address
* space. If we can't, assume nothing's there but warn
* about it.
*/
if (bus_space_map(iot, slotaddr, EISA_SLOT_SIZE, 0, &slotioh)) {
aprint_error_dev(self,
"can't map I/O space for slot %d\n", slot);
continue;
}
/* Get the vendor ID bytes */
for (i = 0; i < EISA_NVIDREGS; i++)
ea.ea_vid[i] = bus_space_read_1(iot, slotioh,
EISA_SLOTOFF_VID + i);
/* Check for device existence */
if (EISA_VENDID_NODEV(ea.ea_vid)) {
#if 0
printf("no device at %s slot %d\n", device_xname(self),
slot);
printf("\t(0x%x, 0x%x)\n", ea.ea_vid[0], ea.ea_vid[1]);
#endif
bus_space_unmap(iot, slotioh, EISA_SLOT_SIZE);
continue;
}
/* And check that the firmware didn't biff something badly */
if (EISA_VENDID_IDDELAY(ea.ea_vid)) {
printf("%s slot %d not configured by BIOS?\n",
device_xname(self), slot);
bus_space_unmap(iot, slotioh, EISA_SLOT_SIZE);
continue;
}
/* Get the product ID bytes */
for (i = 0; i < EISA_NPIDREGS; i++)
ea.ea_pid[i] = bus_space_read_1(iot, slotioh,
EISA_SLOTOFF_PID + i);
/* Create the ID string from the vendor and product IDs */
ea.ea_idstring[0] = EISA_VENDID_0(ea.ea_vid);
ea.ea_idstring[1] = EISA_VENDID_1(ea.ea_vid);
ea.ea_idstring[2] = EISA_VENDID_2(ea.ea_vid);
ea.ea_idstring[3] = EISA_PRODID_0(ea.ea_pid);
ea.ea_idstring[4] = EISA_PRODID_1(ea.ea_pid);
ea.ea_idstring[5] = EISA_PRODID_2(ea.ea_pid);
ea.ea_idstring[6] = EISA_PRODID_3(ea.ea_pid);
ea.ea_idstring[7] = '\0'; /* sanity */
/* We no longer need the I/O handle; free it. */
bus_space_unmap(iot, slotioh, EISA_SLOT_SIZE);
locs[EISACF_SLOT] = slot;
/* Attach matching device. */
config_found_sm_loc(self, "eisa", locs, &ea,
eisaprint, config_stdsubmatch);
}
}
static void
mlx_eisa_attach(device_t parent, device_t self, void *aux)
{
struct eisa_attach_args *ea;
bus_space_handle_t ioh;
eisa_chipset_tag_t ec;
eisa_intr_handle_t ih;
struct mlx_softc *mlx;
bus_space_tag_t iot;
const char *intrstr;
int irq, i, icfg;
ea = aux;
mlx = device_private(self);
iot = ea->ea_iot;
ec = ea->ea_ec;
if (bus_space_map(iot, EISA_SLOT_ADDR(ea->ea_slot) +
MLX_EISA_SLOT_OFFSET, MLX_EISA_IOSIZE, 0, &ioh)) {
printf("can't map i/o space\n");
return;
}
mlx->mlx_dv = self;
mlx->mlx_iot = iot;
mlx->mlx_ioh = ioh;
mlx->mlx_dmat = ea->ea_dmat;
/*
* Map and establish the interrupt.
*/
icfg = bus_space_read_1(iot, ioh, MLX_EISA_CFG03);
switch (icfg & 0xf0) {
case 0xa0:
irq = 11;
break;
case 0xc0:
irq = 12;
break;
case 0xe0:
irq = 14;
break;
case 0x80:
irq = 15;
break;
default:
printf("controller on invalid IRQ\n");
return;
}
if (eisa_intr_map(ec, irq, &ih)) {
printf("can't map interrupt (%d)\n", irq);
return;
}
intrstr = eisa_intr_string(ec, ih);
mlx->mlx_ih = eisa_intr_establish(ec, ih,
((icfg & 0x08) != 0 ? IST_LEVEL : IST_EDGE),
IPL_BIO, mlx_intr, mlx);
if (mlx->mlx_ih == NULL) {
printf("can't establish interrupt");
if (intrstr != NULL)
printf(" at %s", intrstr);
printf("\n");
return;
}
for (i = 0; i < sizeof(mlx_eisa_prod) / sizeof(mlx_eisa_prod[0]); i++)
if (strcmp(ea->ea_idstring, mlx_eisa_prod[i].mp_idstr) == 0) {
mlx->mlx_ci.ci_nchan = mlx_eisa_prod[i].mp_nchan;
break;
}
mlx->mlx_ci.ci_iftype = 1;
mlx->mlx_submit = mlx_v1_submit;
mlx->mlx_findcomplete = mlx_v1_findcomplete;
mlx->mlx_intaction = mlx_v1_intaction;
mlx->mlx_fw_handshake = mlx_v1_fw_handshake;
#ifdef MLX_RESET
mlx->mlx_reset = mlx_v1_reset;
#endif
printf(": Mylex RAID\n");
mlx_init(mlx, intrstr);
}
static void
ahc_eisa_attach(device_t parent, device_t self, void *aux)
{
struct ahc_softc *ahc = device_private(self);
struct eisa_attach_args *ea = aux;
eisa_chipset_tag_t ec = ea->ea_ec;
eisa_intr_handle_t ih;
bus_space_tag_t iot = ea->ea_iot;
bus_space_handle_t ioh;
int irq, intrtype;
const char *intrstr, *intrtypestr;
u_int biosctrl;
u_int scsiconf;
u_int scsiconf1;
u_char intdef;
#ifdef AHC_DEBUG
int i;
#endif
char intrbuf[EISA_INTRSTR_LEN];
ahc->sc_dev = self;
if (bus_space_map(iot, EISA_SLOT_ADDR(ea->ea_slot) +
AHC_EISA_SLOT_OFFSET, AHC_EISA_IOSIZE, 0, &ioh)) {
aprint_error_dev(ahc->sc_dev, "could not map I/O addresses");
return;
}
if ((irq = ahc_aic77xx_irq(iot, ioh)) < 0) {
aprint_error_dev(ahc->sc_dev, "ahc_aic77xx_irq failed!");
goto free_io;
}
if (strcmp(ea->ea_idstring, "ADP7770") == 0) {
printf(": %s\n", EISA_PRODUCT_ADP7770);
} else if (strcmp(ea->ea_idstring, "ADP7771") == 0) {
printf(": %s\n", EISA_PRODUCT_ADP7771);
} else {
printf(": Unknown device type %s", ea->ea_idstring);
goto free_io;
}
ahc_set_name(ahc, device_xname(ahc->sc_dev));
ahc->parent_dmat = ea->ea_dmat;
ahc->chip = AHC_AIC7770|AHC_EISA;
ahc->features = AHC_AIC7770_FE;
ahc->flags = AHC_PAGESCBS;
ahc->bugs = AHC_TMODE_WIDEODD_BUG;
ahc->tag = iot;
ahc->bsh = ioh;
ahc->channel = 'A';
if (ahc_softc_init(ahc) != 0)
goto free_io;
ahc_intr_enable(ahc, FALSE);
if (ahc_reset(ahc) != 0)
goto free_io;
if (eisa_intr_map(ec, irq, &ih)) {
aprint_error_dev(ahc->sc_dev, "couldn't map interrupt (%d)\n",
irq);
goto free_io;
}
intdef = bus_space_read_1(iot, ioh, INTDEF);
if (intdef & EDGE_TRIG) {
intrtype = IST_EDGE;
intrtypestr = "edge triggered";
} else {
intrtype = IST_LEVEL;
intrtypestr = "level sensitive";
}
intrstr = eisa_intr_string(ec, ih, intrbuf, sizeof(intrbuf));
ahc->ih = eisa_intr_establish(ec, ih,
intrtype, IPL_BIO, ahc_intr, ahc);
if (ahc->ih == NULL) {
aprint_error_dev(ahc->sc_dev, "couldn't establish %s interrupt",
intrtypestr);
if (intrstr != NULL)
aprint_error(" at %s", intrstr);
aprint_error("\n");
goto free_io;
}
if (intrstr != NULL)
aprint_normal_dev(ahc->sc_dev, "%s interrupting at %s\n",
intrtypestr, intrstr);
/*
* Now that we know we own the resources we need, do the
* card initialization.
*
* First, the aic7770 card specific setup.
*/
biosctrl = ahc_inb(ahc, HA_274_BIOSCTRL);
scsiconf = ahc_inb(ahc, SCSICONF);
scsiconf1 = ahc_inb(ahc, SCSICONF + 1);
#ifdef AHC_DEBUG
for (i = TARG_SCSIRATE; i <= HA_274_BIOSCTRL; i+=8) {
printf("0x%x, 0x%x, 0x%x, 0x%x, "
"0x%x, 0x%x, 0x%x, 0x%x\n",
ahc_inb(ahc, i),
ahc_inb(ahc, i+1),
ahc_inb(ahc, i+2),
ahc_inb(ahc, i+3),
ahc_inb(ahc, i+4),
ahc_inb(ahc, i+5),
ahc_inb(ahc, i+6),
ahc_inb(ahc, i+7));
}
#endif
/* Get the primary channel information */
if ((biosctrl & CHANNEL_B_PRIMARY) != 0)
ahc->flags |= AHC_PRIMARY_CHANNEL;
if ((biosctrl & BIOSMODE) == BIOSDISABLED) {
ahc->flags |= AHC_USEDEFAULTS;
} else if ((ahc->features & AHC_WIDE) != 0) {
ahc->our_id = scsiconf1 & HWSCSIID;
if (scsiconf & TERM_ENB)
ahc->flags |= AHC_TERM_ENB_A;
} else {
ahc->our_id = scsiconf & HSCSIID;
ahc->our_id_b = scsiconf1 & HSCSIID;
if (scsiconf & TERM_ENB)
ahc->flags |= AHC_TERM_ENB_A;
if (scsiconf1 & TERM_ENB)
ahc->flags |= AHC_TERM_ENB_B;
}
if ((ahc_inb(ahc, HA_274_BIOSGLOBAL) & HA_274_EXTENDED_TRANS))
ahc->flags |= AHC_EXTENDED_TRANS_A|AHC_EXTENDED_TRANS_B;
/* Attach sub-devices */
if (ahc_aic77xx_attach(ahc) == 0)
return; /* succeed */
/* failed */
eisa_intr_disestablish(ec, ahc->ih);
free_io:
bus_space_unmap(iot, ioh, AHC_EISA_IOSIZE);
}
static void
mlx_eisa_attach(struct device *parent, struct device *self, void *aux)
{
struct eisa_attach_args *ea;
bus_space_handle_t ioh;
eisa_chipset_tag_t ec;
eisa_intr_handle_t ih;
struct mlx_softc *mlx;
bus_space_tag_t iot;
const char *intrstr;
int irq, le;
ea = aux;
mlx = (struct mlx_softc *)self;
iot = ea->ea_iot;
ec = ea->ea_ec;
if (bus_space_map(iot, EISA_SLOT_ADDR(ea->ea_slot) +
MLX_EISA_SLOT_OFFSET, MLX_EISA_IOSIZE, 0, &ioh)) {
printf("can't map i/o space\n");
return;
}
mlx->mlx_iot = iot;
mlx->mlx_ioh = ioh;
mlx->mlx_dmat = ea->ea_dmat;
/*
* Map and establish the interrupt.
*/
switch (bus_space_read_1(iot, ioh, MLX_EISA_IOCONF1) & 0xf0) {
case 0xa0:
irq = 11;
break;
case 0xc0:
irq = 12;
break;
case 0xe0:
irq = 14;
break;
case 0x80:
irq = 15;
break;
default:
printf("controller on invalid IRQ\n");
return;
}
if (eisa_intr_map(ec, irq, &ih)) {
printf("can't map interrupt (%d)\n", irq);
return;
}
if ((bus_space_read_1(iot, ioh, MLX_EISA_IOCONF1) & 0x08) != 0)
le = IST_LEVEL;
else
le = IST_EDGE;
intrstr = eisa_intr_string(ec, ih);
mlx->mlx_ih = eisa_intr_establish(ec, ih, le, IPL_BIO, mlx_intr, mlx);
if (mlx->mlx_ih == NULL) {
printf("can't establish interrupt");
if (intrstr != NULL)
printf(" at %s", intrstr);
printf("\n");
return;
}
mlx->mlx_flags = MLXF_EISA;
mlx->mlx_submit = mlx_v1_submit;
mlx->mlx_findcomplete = mlx_v1_findcomplete;
mlx->mlx_intaction = mlx_v1_intaction;
mlx->mlx_fw_handshake = mlx_v1_fw_handshake;
#ifdef MLX_RESET
mlx->mlx_reset = mlx_v1_reset;
#endif
printf(": Mylex RAID\n");
mlx_init(mlx, intrstr);
}
static void
dpt_eisa_attach(device_t parent, device_t self, void *aux)
{
struct eisa_attach_args *ea;
bus_space_handle_t ioh;
eisa_chipset_tag_t ec;
eisa_intr_handle_t ih;
struct dpt_softc *sc;
bus_space_tag_t iot;
const char *intrstr;
int irq;
char intrbuf[EISA_INTRSTR_LEN];
ea = aux;
sc = device_private(self);
sc->sc_dev = self;
iot = ea->ea_iot;
ec = ea->ea_ec;
printf(": ");
if (bus_space_map(iot, EISA_SLOT_ADDR(ea->ea_slot) +
DPT_EISA_SLOT_OFFSET, DPT_EISA_IOSIZE, 0, &ioh)) {
printf("can't map i/o space\n");
return;
}
sc->sc_iot = iot;
sc->sc_ioh = ioh;
sc->sc_dmat = ea->ea_dmat;
/* Map and establish the interrupt. */
if (dpt_eisa_irq(iot, ioh, &irq)) {
printf("HBA on invalid IRQ\n");
return;
}
if (eisa_intr_map(ec, irq, &ih)) {
printf("can't map interrupt (%d)\n", irq);
return;
}
intrstr = eisa_intr_string(ec, ih, intrbuf, sizeof(intrbuf));
sc->sc_ih = eisa_intr_establish(ec, ih, IST_LEVEL, IPL_BIO,
dpt_intr, sc);
if (sc->sc_ih == NULL) {
printf("can't establish interrupt");
if (intrstr != NULL)
printf(" at %s", intrstr);
printf("\n");
return;
}
/* Read the EATA configuration. */
if (dpt_readcfg(sc)) {
aprint_error_dev(sc->sc_dev, "readcfg failed - see dpt(4)\n");
return;
}
sc->sc_bustype = SI_EISA_BUS;
sc->sc_isaport = EISA_SLOT_ADDR(ea->ea_slot) + DPT_EISA_SLOT_OFFSET;
sc->sc_isairq = irq;
/* Now attach to the bus-independent code. */
dpt_init(sc, intrstr);
}
static void
tlp_eisa_attach(device_t parent, device_t self, void *aux)
{
static const u_int8_t testpat[] =
{ 0xff, 0, 0x55, 0xaa, 0xff, 0, 0x55, 0xaa };
struct tulip_eisa_softc *esc = device_private(self);
struct tulip_softc *sc = &esc->sc_tulip;
struct eisa_attach_args *ea = aux;
eisa_chipset_tag_t ec = ea->ea_ec;
eisa_intr_handle_t ih;
bus_space_tag_t iot = ea->ea_iot;
bus_space_handle_t ioh;
const char *intrstr;
const struct tulip_eisa_product *tep;
u_int8_t enaddr[ETHER_ADDR_LEN], tmpbuf[sizeof(testpat)];
u_int32_t val;
int irq, i, cnt;
char intrbuf[EISA_INTRSTR_LEN];
/*
* Map the device.
*/
if (bus_space_map(iot, EISA_SLOT_ADDR(ea->ea_slot),
EISA_SLOT_SIZE, 0, &ioh)) {
printf(": unable to map I/O space\n");
return;
}
sc->sc_dev = self;
sc->sc_st = iot;
sc->sc_sh = ioh;
tep = tlp_eisa_lookup(ea);
if (tep == NULL) {
printf("\n");
panic("tlp_eisa_attach: impossible");
}
sc->sc_chip = tep->tep_chip;
/*
* DE425's registers are 16 bytes long; the PCI configuration
* space registers are interleaved in the I/O space.
*/
sc->sc_regshift = 4;
/*
* No power management hooks.
*/
sc->sc_flags |= TULIPF_ENABLED;
/*
* CBIO must map the EISA slot, and I/O access and Bus Mastering
* must be enabled.
*/
bus_space_write_4(iot, ioh, DE425_CBIO, EISA_SLOT_ADDR(ea->ea_slot));
bus_space_write_4(iot, ioh, DE425_CFCS,
bus_space_read_4(iot, ioh, DE425_CFCS) |
PCI_COMMAND_IO_ENABLE | PCI_COMMAND_MASTER_ENABLE);
/*
* Get revision info.
*/
sc->sc_rev = bus_space_read_4(iot, ioh, DE425_CFRV) & 0xff;
printf(": %s Ethernet, pass %d.%d\n",
tep->tep_name, (sc->sc_rev >> 4) & 0xf, sc->sc_rev & 0xf);
sc->sc_dmat = ea->ea_dmat;
/*
* EISA doesn't have a cache line register.
*/
sc->sc_cacheline = 0;
/*
* Find the beginning of the Ethernet Address ROM.
*/
for (i = 0, cnt = 0; i < sizeof(testpat) && cnt < 32; cnt++) {
tmpbuf[i] = bus_space_read_1(iot, ioh, DE425_ENETROM);
if (tmpbuf[i] == testpat[i])
i++;
else
i = 0;
}
/*
* ...and now read the contents of the Ethernet Address ROM.
*/
sc->sc_srom = malloc(32, M_DEVBUF, M_WAITOK|M_ZERO);
for (i = 0; i < 32; i++)
sc->sc_srom[i] = bus_space_read_1(iot, ioh, DE425_ENETROM);
/*
* None of the DE425 boards have the new-style SROMs.
*/
if (tlp_parse_old_srom(sc, enaddr) == 0) {
aprint_error_dev(self, "unable to decode old-style SROM\n");
return;
}
/*
* All DE425 boards use the 21040 media switch.
*/
sc->sc_mediasw = &tlp_21040_mediasw;
/*
* Figure out which IRQ we want to use, and determine if it's
* edge- or level-triggered.
*/
val = bus_space_read_4(iot, ioh, DE425_CFG0);
irq = tlp_eisa_irqs[(val >> 1) & 0x03];
/*
* Map and establish our interrupt.
*/
if (eisa_intr_map(ec, irq, &ih)) {
aprint_error_dev(self, "unable to map interrupt (%u)\n",
irq);
return;
}
intrstr = eisa_intr_string(ec, ih, intrbuf, sizeof(intrbuf));
esc->sc_ih = eisa_intr_establish(ec, ih,
(val & 0x01) ? IST_EDGE : IST_LEVEL, IPL_NET, tlp_intr, sc);
if (esc->sc_ih == NULL) {
aprint_error_dev(self, "unable to establish interrupt");
if (intrstr != NULL)
aprint_error(" at %s", intrstr);
aprint_error("\n");
return;
}
if (intrstr != NULL)
aprint_normal_dev(self, "interrupting at %s\n", intrstr);
/*
* Finish off the attach.
*/
tlp_attach(sc, enaddr);
}
