int
cfxga_match(struct device *parent, void *match, void *aux)
{
struct pcmcia_attach_args *pa = aux;
struct pcmcia_function *pf = pa->pf;
struct pcmcia_mem_handle h;
int rc;
int win;
bus_addr_t ptr;
u_int8_t id = 0;
if (pa->product != PCMCIA_PRODUCT_INVALID ||
pa->manufacturer != PCMCIA_VENDOR_INVALID)
return (0);
/* Only a card with no CIS will have a fake function... */
if ((pf->pf_flags & PFF_FAKE) == 0)
return (0);
if (cfxga_install_function(pf) != 0)
return (0);
if (pcmcia_function_enable(pf) != 0) {
DPRINTF(("%s: function enable failed\n"));
return (0);
}
rc = pcmcia_mem_alloc(pf, CFXGA_MEM_RANGE, &h);
if (rc != 0)
goto out;
rc = pcmcia_mem_map(pf, PCMCIA_MEM_ATTR, 0, CFXGA_MEM_RANGE,
&h, &ptr, &win);
if (rc != 0)
goto out2;
id = (bus_space_read_1(h.memt, h.memh, ptr + CFREG_REV) &
CR_PRODUCT_MASK) >> CR_PRODUCT_SHIFT;
pcmcia_mem_unmap(pa->pf, win);
out2:
pcmcia_mem_free(pa->pf, &h);
out:
pcmcia_function_disable(pf);
cfxga_remove_function(pf);
/*
* Be sure to return a value greater than pccom's if we match,
* otherwise it can win due to the way config(8) will order devices...
*/
return (id == PRODUCT_S1D13806 ? 10 : 0);
}
void
cfxga_attach(struct device *parent, struct device *self, void *aux)
{
struct cfxga_softc *sc = (void *)self;
struct pcmcia_attach_args *pa = aux;
struct pcmcia_function *pf = pa->pf;
struct wsemuldisplaydev_attach_args waa;
struct wsscreen_descr *wsd;
u_int i;
LIST_INIT(&sc->sc_scr);
sc->sc_nscreens = 0;
sc->sc_pf = pf;
if (cfxga_install_function(pf) != 0) {
printf(": pcmcia function setup failed\n");
return;
}
if (pcmcia_function_enable(pf)) {
printf(": function enable failed\n");
return;
}
if (pcmcia_mem_alloc(pf, CFXGA_MEM_RANGE, &sc->sc_pmemh) != 0) {
printf(": can't allocate memory space\n");
return;
}
if (pcmcia_mem_map(pf, PCMCIA_MEM_ATTR, 0, CFXGA_MEM_RANGE,
&sc->sc_pmemh, &sc->sc_offset, &sc->sc_memwin) != 0) {
printf(": can't map frame buffer registers\n");
pcmcia_mem_free(pf, &sc->sc_pmemh);
return;
}
SET(sc->sc_state, CS_MAPPED);
printf("\n");
sc->sc_mode = WSDISPLAYIO_MODE_EMUL;
/*
* We actually defer real initialization to the creation of the
* first wsdisplay screen, since we do not know which mode to pick
* yet.
*/
for (wsd = sc->sc_wsd, i = 0; i < CFXGA_NMODES; wsd++, i++) {
strlcpy(wsd->name, cfxga_modenames[i], sizeof(wsd->name));
wsd->textops = &sc->sc_ops;
sc->sc_scrlist[i] = wsd;
}
sc->sc_wsl.nscreens = CFXGA_NMODES;
sc->sc_wsl.screens = (const struct wsscreen_descr **)sc->sc_scrlist;
waa.console = 0;
waa.scrdata = &sc->sc_wsl;
waa.accessops = &cfxga_accessops;
waa.accesscookie = sc;
waa.defaultscreens = 1;
if ((sc->sc_wsdisplay =
config_found(self, &waa, wsemuldisplaydevprint)) == NULL) {
/* otherwise wscons will do this */
if (sc->sc_active != NULL)
cfxga_clear_screen(sc->sc_active);
else
cfxga_burner(sc, 0, 0);
}
}
static void
tr_pcmcia_attach(device_t parent, device_t self, void *aux)
{
struct tr_pcmcia_softc *psc = device_private(self);
struct tr_softc *sc = &psc->sc_tr;
struct pcmcia_attach_args *pa = aux;
struct pcmcia_config_entry *cfe;
bus_size_t offset;
psc->sc_pf = pa->pf;
cfe = SIMPLEQ_FIRST(&pa->pf->cfe_head);
pcmcia_function_init(pa->pf, cfe);
if (pcmcia_function_enable(pa->pf) != 0) {
aprint_error_dev(self, "function enable failed\n");
return;
}
if (pcmcia_io_alloc(pa->pf, cfe->iospace[0].start,
cfe->iospace[0].length, cfe->iospace[0].length, &psc->sc_pioh)
!= 0) {
aprint_error_dev(self, "can't allocate pio space\n");
goto fail1;
}
if (pcmcia_io_map(psc->sc_pf, PCMCIA_WIDTH_IO8, /* XXX _AUTO? */
&psc->sc_pioh, &psc->sc_pio_window) != 0) {
aprint_error_dev(self, "can't map pio space\n");
goto fail2;
}
if (pcmcia_mem_alloc(psc->sc_pf, TR_SRAM_SIZE, &psc->sc_sramh) != 0) {
aprint_error_dev(self, "can't allocate sram space\n");
goto fail3;
}
if (pcmcia_mem_map(psc->sc_pf, PCMCIA_MEM_COMMON, TR_PCMCIA_SRAM_ADDR,
TR_SRAM_SIZE, &psc->sc_sramh, &offset, &psc->sc_sram_window) != 0) {
aprint_error_dev(self, "can't map sram space\n");
goto fail4;
}
if (pcmcia_mem_alloc(psc->sc_pf, TR_MMIO_SIZE, &psc->sc_mmioh) != 0) {
aprint_error_dev(self, "can't allocate mmio space\n");
goto fail5;
return;
}
if (pcmcia_mem_map(psc->sc_pf, PCMCIA_MEM_COMMON, TR_PCMCIA_MMIO_ADDR,
TR_MMIO_SIZE, &psc->sc_mmioh, &offset, &psc->sc_mmio_window) != 0) {
aprint_error_dev(self, "can't map mmio space\n");
goto fail6;
}
sc->sc_piot = psc->sc_pioh.iot;
sc->sc_pioh = psc->sc_pioh.ioh;
sc->sc_memt = psc->sc_sramh.memt;
sc->sc_sramh = psc->sc_sramh.memh;
sc->sc_mmioh = psc->sc_mmioh.memh;
sc->sc_init_status = RSP_16;
sc->sc_memwinsz = TR_SRAM_SIZE;
sc->sc_memsize = TR_SRAM_SIZE;
sc->sc_memreserved = 0;
sc->sc_aca = TR_ACA_OFFSET;
sc->sc_maddr = TR_PCMCIA_SRAM_ADDR;
sc->sc_mediastatus = tr_pcmcia_mediastatus;
sc->sc_mediachange = tr_pcmcia_mediachange;
sc->sc_enable = tr_pcmcia_enable;
sc->sc_disable = tr_pcmcia_disable;
tr_pcmcia_setup(sc);
if (tr_reset(sc) == 0)
(void)tr_attach(sc);
pcmcia_function_disable(pa->pf);
sc->sc_enabled = 0;
return;
fail6:
pcmcia_mem_free(psc->sc_pf, &psc->sc_mmioh);
fail5:
pcmcia_mem_unmap(psc->sc_pf, psc->sc_sram_window);
fail4:
pcmcia_mem_free(psc->sc_pf, &psc->sc_sramh);
fail3:
pcmcia_io_unmap(psc->sc_pf, psc->sc_pio_window);
fail2:
pcmcia_io_free(psc->sc_pf, &psc->sc_pioh);
fail1:
pcmcia_function_disable(pa->pf);
sc->sc_enabled = 0;
}
void
gpr_attach(struct device *parent, struct device *self, void *aux)
{
struct gpr_softc *sc = (void *)self;
struct pcmcia_attach_args *pa = aux;
struct pcmcia_config_entry *cfe;
const char *intrstr;
for (cfe = SIMPLEQ_FIRST(&pa->pf->cfe_head); cfe;
cfe = SIMPLEQ_NEXT(cfe, cfe_list)) {
if (!pcmcia_io_alloc(pa->pf, cfe->iospace[0].start,
cfe->iospace[0].length, cfe->iospace[0].length,
&sc->sc_pioh))
break;
}
if (cfe == NULL) {
printf(": can't alloc i/o space\n");
goto fail_io_alloc;
}
pcmcia_function_init(pa->pf, cfe);
if (pcmcia_function_enable(pa->pf)) {
printf(": function enable failed\n");
goto fail_enable;
}
if (pcmcia_io_map(pa->pf, PCMCIA_WIDTH_AUTO, 0,
sc->sc_pioh.size, &sc->sc_pioh, &sc->sc_iowin)) {
printf(": can't map i/o space\n");
goto fail_io_map;
}
/*
* GPR400 has some registers in attribute memory as well.
*/
if (pcmcia_mem_alloc(pa->pf, GPR400_MEM_LEN, &sc->sc_pmemh)) {
printf(": can't map mem space\n");
goto fail_mem_alloc;
}
if (pcmcia_mem_map(pa->pf, PCMCIA_MEM_ATTR, pa->pf->ccr_base,
GPR400_MEM_LEN, &sc->sc_pmemh, &sc->sc_offset, &sc->sc_memwin)) {
printf(": can't map memory\n");
goto fail_mem_map;
}
sc->sc_pf = pa->pf;
sc->sc_iot = sc->sc_pioh.iot;
sc->sc_ioh = sc->sc_pioh.ioh;
sc->sc_memt = sc->sc_pmemh.memt;
sc->sc_memh = sc->sc_pmemh.memh;
printf(" port 0x%lx/%d", sc->sc_pioh.addr, sc->sc_pioh.size);
sc->sc_ih = pcmcia_intr_establish(pa->pf, IPL_TTY, gpr_intr, sc,
sc->sc_dev.dv_xname);
intrstr = pcmcia_intr_string(sc->sc_pf, sc->sc_ih);
printf("%s%s\n", *intrstr ? ", " : "", intrstr);
if (sc->sc_ih != NULL)
return;
pcmcia_mem_unmap(pa->pf, sc->sc_memwin);
fail_mem_map:
pcmcia_mem_free(pa->pf, &sc->sc_pmemh);
fail_mem_alloc:
pcmcia_io_unmap(pa->pf, sc->sc_iowin);
fail_io_map:
pcmcia_function_disable(pa->pf);
fail_enable:
pcmcia_io_free(pa->pf, &sc->sc_pioh);
fail_io_alloc:
return;
}