void pcic_isapnp_attach(struct device *parent, struct device *self, void *aux) { struct pcic_softc *sc = device_private(self); struct pcic_isa_softc *isc = device_private(self); struct isapnp_attach_args *ipa = aux; isa_chipset_tag_t ic = ipa->ipa_ic; bus_space_tag_t iot = ipa->ipa_iot; bus_space_tag_t memt = ipa->ipa_memt; bus_space_handle_t ioh; bus_space_handle_t memh; bus_addr_t maddr; int msize; int tmp1; printf("\n"); if (isapnp_config(iot, memt, ipa)) { aprint_error_dev(&sc->dev, "error in region allocation\n"); return; } printf("%s: %s %s", device_xname(&sc->dev), ipa->ipa_devident, ipa->ipa_devclass); /* sanity check that we get at least one hunk of IO space.. */ if (ipa->ipa_nio < 1) { aprint_error_dev(&sc->dev, "failed to get one chunk of i/o space\n"); return; } /* Find i/o space. */ ioh = ipa->ipa_io[0].h; /* sanity check to make sure we have a real PCIC there.. */ bus_space_write_1(iot, ioh, PCIC_REG_INDEX, C0SA + PCIC_IDENT); tmp1 = bus_space_read_1(iot, ioh, PCIC_REG_DATA); printf("(ident 0x%x", tmp1); if (pcic_ident_ok(tmp1)) { printf(" OK)"); } else { printf(" Not OK)\n"); return; } msize = 0x4000; if (isa_mem_alloc (memt, msize, msize, 0, 0, &maddr, &memh)) { printf(": can't alloc mem space\n"); return; } printf(": using iomem 0x%lx iosiz 0x%x", maddr, msize); sc->membase = maddr; sc->subregionmask = (1 << (msize / PCIC_MEM_PAGESIZE)) - 1; isc->sc_ic = ic; sc->pct = (pcmcia_chipset_tag_t) & pcic_isa_functions; sc->iot = iot; sc->ioh = ioh; sc->memt = memt; sc->memh = memh; /* * allocate an irq. it will be used by both controllers. I could * use two different interrupts, but interrupts are relatively * scarce, shareable, and for PCIC controllers, very infrequent. */ if (ipa->ipa_nirq > 0) sc->irq = ipa->ipa_irq[0].num; else sc->irq = -1; printf("\n"); pcic_attach(sc); pcic_isa_bus_width_probe(sc, iot, ioh, ipa->ipa_io[0].base, ipa->ipa_io[0].length); pcic_attach_sockets(sc); config_interrupts(self, pcic_isa_config_interrupts); }
void pcic_pci_attach(device_t parent, device_t self, void *aux) { struct pcic_pci_softc *psc = device_private(self); struct pcic_softc *sc = &psc->sc_pcic; struct pci_attach_args *pa = aux; pci_chipset_tag_t pc = pa->pa_pc; bus_space_tag_t memt = pa->pa_memt; bus_space_handle_t memh; const char *model; sc->dev = self; aprint_naive(": PCMCIA controller\n"); if (pci_mapreg_map(pa, PCI_CBIO, PCI_MAPREG_TYPE_IO, 0, &sc->iot, &sc->ioh, NULL, NULL)) { aprint_error(": can't map i/o space\n"); return; } /* * XXX need some memory for mapping pcmcia cards into. Ideally, this * would be completely dynamic. Practically this doesn't work, * because the extent mapper doesn't know about all the devices all * the time. With ISA we could finesse the issue by specifying the * memory region in the config line. We can't do that here, so we * cheat for now. Jason Thorpe, you are my Savior, come up with a fix * :-) */ /* Map mem space. */ if (bus_space_map(memt, 0xd0000, 0x4000, 0, &memh)) panic("pcic_pci_attach: can't map mem space"); sc->membase = 0xd0000; sc->subregionmask = (1 << (0x4000 / PCIC_MEM_PAGESIZE)) - 1; /* same deal for io allocation */ sc->iobase = 0x400; sc->iosize = 0xbff; /* end XXX */ sc->pct = &pcic_pci_functions; sc->memt = memt; sc->memh = memh; switch (PCI_PRODUCT(pa->pa_id)) { case PCI_PRODUCT_CIRRUS_CL_PD6729: model = "Cirrus Logic PD6729 PCMCIA controller"; break; default: model = "Model unknown"; break; } aprint_normal(": %s\n", model); /* Enable the card. */ pci_conf_write(pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, pci_conf_read(pc, pa->pa_tag, PCI_COMMAND_STATUS_REG) | PCI_COMMAND_MASTER_ENABLE); pcic_attach(sc); /* * Check to see if we're using PCI or ISA interrupts. I don't * know of any i386 systems that use the 6729 in PCI interrupt * mode, but maybe when the PCMCIA code runs on other platforms * we'll need to fix this. */ pcic_write(&sc->handle[0], PCIC_CIRRUS_EXTENDED_INDEX, PCIC_CIRRUS_EXT_CONTROL_1); if ((pcic_read(&sc->handle[0], PCIC_CIRRUS_EXTENDED_DATA) & PCIC_CIRRUS_EXT_CONTROL_1_PCI_INTR_MASK)) { aprint_error_dev(self, "PCI interrupts not supported\n"); return; } psc->intr_est = pcic_pci_machdep_intr_est(pc); sc->irq = -1; #if 0 /* Map and establish the interrupt. */ sc->ih = pcic_pci_machdep_pcic_intr_establish(sc, pcic_intr); if (sc->ih == NULL) { aprint_error_dev(self, "couldn't map interrupt\n"); return; } #endif /* * Defer configuration of children until ISA has had its chance * to use up whatever IO space and IRQs it wants. XXX This will * only work if ISA is attached to a pcib, AND the PCI probe finds * and defers the ISA attachment before this one. */ config_defer(self, pcic_pci_callback); config_interrupts(self, pcic_isa_config_interrupts); }