if (PCI_VENDOR(pa->pa_id) != PCI_VENDOR_SMC)
return NULL;
for (epp = epic_pci_products; epp->epp_name != NULL; epp++)
if (PCI_PRODUCT(pa->pa_id) == epp->epp_prodid)
return epp;
return NULL;
}
static const struct epic_pci_subsys_info {
pcireg_t subsysid;
int flags;
} epic_pci_subsys_info[] = {
{ PCI_ID_CODE(PCI_VENDOR_SMC, 0xa015), /* SMC9432BTX */
EPIC_HAS_BNC },
{ PCI_ID_CODE(PCI_VENDOR_SMC, 0xa024), /* SMC9432BTX1 */
EPIC_HAS_BNC },
{ PCI_ID_CODE(PCI_VENDOR_SMC, 0xa016), /* SMC9432FTX */
EPIC_HAS_MII_FIBER | EPIC_DUPLEXLED_ON_694 },
{ 0xffffffff,
0 }
};
static const struct epic_pci_subsys_info *
epic_pci_subsys_lookup(const struct pci_attach_args *pa)
{
pci_chipset_tag_t pc = pa->pa_pc;
pcireg_t reg;
const struct epic_pci_subsys_info *esp;
/*
* Try to figure out what particular machine we run on, depending on the
* scarce PMON version information and whatever else we can figure.
*/
const struct platform *
loongson_identify(const char *version, int envtype)
{
const struct bonito_flavour *f;
switch (envtype) {
case PMON_ENVTYPE_EFI:
return NULL;
break;
default:
case PMON_ENVTYPE_ENVP:
if (version == NULL) {
/*
* If there is no `Version' variable, we expect to be
* running on a 2E system, use the generic code and
* hope for the best.
*/
if (loongson_ver == 0x2e) {
return &generic2e_platform;
} else {
pmon_printf("Unable to figure out model!\n");
return NULL;
}
}
for (f = bonito_flavours; f->prefix != NULL; f++)
if (strncmp(version, f->prefix, strlen(f->prefix)) == 0)
return f->platform;
/*
* Early Lemote designs shipped without a model prefix.
*
* We can reasonably expect these to be close enough to either
* the first generation Fuloong 2F design (LM6002), or the 7
* inch first netbook model; we can tell them apart by looking
* at which video chip they embed.
*
* Note that this is only worth doing if the version string is
* 1.2.something (1.3 onwards are expected to have a model
* prefix, and there are currently no reports of 1.1 and
* below being 2F systems).
*
* LM6002 users are encouraged to add the system model prefix to
* the `Version' variable.
*/
if (strncmp(version, "1.2.", 4) == 0) {
const struct platform *p = NULL;
pcitag_t tag;
pcireg_t id, class;
int dev;
pmon_printf("No model prefix "
"in version string \"%s\".\n", version);
if (loongson_ver == 0x2f)
for (dev = 0; dev < 32; dev++) {
tag = pci_make_tag_early(0, dev, 0);
id = pci_conf_read_early(tag,
PCI_ID_REG);
if (id == 0 || PCI_VENDOR(id) ==
PCI_VENDOR_INVALID)
continue;
/*
* No need to check for
* DEVICE_IS_VGA_PCI here, since we
* expect a linear framebuffer.
*/
class = pci_conf_read_early(tag,
PCI_CLASS_REG);
if (PCI_CLASS(class) !=
PCI_CLASS_DISPLAY ||
(PCI_SUBCLASS(class) !=
PCI_SUBCLASS_DISPLAY_VGA &&
PCI_SUBCLASS(class) !=
PCI_SUBCLASS_DISPLAY_MISC))
continue;
switch (id) {
case PCI_ID_CODE(PCI_VENDOR_SIS,
PCI_PRODUCT_SIS_315PRO_VGA):
p = &fuloong_platform;
break;
case PCI_ID_CODE(PCI_VENDOR_SMI,
PCI_PRODUCT_SMI_SM712):
p = &ebenton_platform;
break;
}
}
if (p != NULL) {
pmon_printf("Attempting to match as "
"%s %s\n", p->vendor, p->product);
return p;
}
}
}
pmon_printf("This kernel doesn't support model \"%s\"." "\n", version);
return NULL;
}
void
gdium_attach_hook(device_t parent, device_t self,
struct pcibus_attach_args *pba)
{
pci_chipset_tag_t pc = pba->pba_pc;
pcireg_t id;
pcitag_t tag;
#ifdef notyet
int bar;
#endif
#if 0
pcireg_t reg;
int dev, func;
#endif
if (pba->pba_bus != 0)
return;
#ifdef notyet
/*
* Clear all BAR of the mini PCI slot; PMON did not initialize
* it, and we do not want it to conflict with anything.
*/
tag = pci_make_tag(pc, 0, 13, 0);
for (bar = PCI_MAPREG_START; bar < PCI_MAPREG_END; bar += 4)
pci_conf_write(pc, tag, bar, 0);
#else
/*
* Force a non conflicting BAR for the wireless controller,
* until proper resource configuration code is added to
* bonito (work in progress).
*/
tag = pci_make_tag(pc, 0, 13, 0);
pci_conf_write(pc, tag, PCI_MAPREG_START, 0x06228000);
#endif
/*
* Figure out which motherboard we are running on.
* Might not be good enough...
*/
tag = pci_make_tag(pc, 0, 17, 0);
id = pci_conf_read(pc, tag, PCI_ID_REG);
if (id == PCI_ID_CODE(PCI_VENDOR_NEC, PCI_PRODUCT_NEC_USB))
gdium_revision = 1;
#if 0
/*
* Tweak the usb controller capabilities.
*/
for (dev = pci_bus_maxdevs(pc, 0); dev >= 0; dev--) {
tag = pci_make_tag(pc, 0, dev, 0);
id = pci_conf_read(pc, tag, PCI_ID_REG);
if (id != PCI_ID_CODE(PCI_VENDOR_NEC, PCI_PRODUCT_NEC_USB))
continue;
if (gdium_revision != 0) {
reg = pci_conf_read(pc, tag, 0xe0);
/* enable ports 1 and 2 */
reg |= 0x00000003;
pci_conf_write(pc, tag, 0xe0, reg);
} else {
for (func = 0; func < 2; func++) {
tag = pci_make_tag(pc, 0, dev, func);
id = pci_conf_read(pc, tag, PCI_ID_REG);
if (PCI_VENDOR(id) != PCI_VENDOR_NEC)
continue;
if (PCI_PRODUCT(id) != PCI_PRODUCT_NEC_USB &&
PCI_PRODUCT(id) != PCI_PRODUCT_NEC_USB2)
continue;
reg = pci_conf_read(pc, tag, 0xe0);
/* enable ports 1 and 3, disable port 2 */
reg &= ~0x00000007;
reg |= 0x00000005;
pci_conf_write(pc, tag, 0xe0, reg);
pci_conf_write(pc, tag, 0xe4, 0x00000020);
}
}
}
#endif
}
void
mpi_pci_attach(struct device *parent, struct device *self, void *aux)
{
struct mpi_pci_softc *psc = (void *)self;
struct mpi_softc *sc = &psc->psc_mpi;
struct pci_attach_args *pa = aux;
pcireg_t memtype;
int r;
pci_intr_handle_t ih;
const char *intrstr;
#ifdef __sparc64__
int node;
#endif
psc->psc_pc = pa->pa_pc;
psc->psc_tag = pa->pa_tag;
psc->psc_ih = NULL;
sc->sc_dmat = pa->pa_dmat;
sc->sc_ios = 0;
sc->sc_target = -1;
/* find the appropriate memory base */
for (r = PCI_MAPREG_START; r < PCI_MAPREG_END; r += sizeof(memtype)) {
memtype = pci_mapreg_type(psc->psc_pc, psc->psc_tag, r);
if ((memtype & PCI_MAPREG_TYPE_MASK) == PCI_MAPREG_TYPE_MEM)
break;
}
if (r >= PCI_MAPREG_END) {
printf(": unable to locate system interface registers\n");
return;
}
if (pci_mapreg_map(pa, r, memtype, 0, &sc->sc_iot, &sc->sc_ioh,
NULL, &sc->sc_ios, 0) != 0) {
printf(": unable to map system interface registers\n");
return;
}
/* disable the expansion rom */
PWRITE(psc, PCI_ROM_REG, PREAD(psc, PCI_ROM_REG) & ~PCI_ROM_ENABLE);
/* hook up the interrupt */
if (pci_intr_map(pa, &ih)) {
printf(": unable to map interrupt\n");
goto unmap;
}
intrstr = pci_intr_string(psc->psc_pc, ih);
psc->psc_ih = pci_intr_establish(psc->psc_pc, ih, IPL_BIO,
mpi_intr, sc, sc->sc_dev.dv_xname);
if (psc->psc_ih == NULL) {
printf(": unable to map interrupt%s%s\n",
intrstr == NULL ? "" : " at ",
intrstr == NULL ? "" : intrstr);
goto unmap;
}
printf(": %s", intrstr);
if (pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_ID_REG) ==
PCI_ID_CODE(PCI_VENDOR_SYMBIOS, PCI_PRODUCT_SYMBIOS_1030)) {
sc->sc_flags |= MPI_F_SPI;
#ifdef __sparc64__
/*
* Walk up the Open Firmware device tree until we find a
* "scsi-initiator-id" property.
*/
node = PCITAG_NODE(pa->pa_tag);
while (node) {
if (OF_getprop(node, "scsi-initiator-id",
&sc->sc_target, sizeof(sc->sc_target)) ==
sizeof(sc->sc_target))
break;
node = OF_parent(node);
}
#endif
}
if (mpi_attach(sc) != 0) {
/* error printed by mpi_attach */
goto deintr;
}
return;
deintr:
pci_intr_disestablish(psc->psc_pc, psc->psc_ih);
psc->psc_ih = NULL;
unmap:
bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
sc->sc_ios = 0;
}
