1053 lines
28 KiB
C
1053 lines
28 KiB
C
/* $NetBSD: plumpcmcia.c,v 1.5 2000/10/04 13:53:55 uch Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 1999, 2000 UCHIYAMA Yasushi. All rights reserved.
|
|
* Copyright (c) 1997 Marc Horowitz. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
* must display the following acknowledgement:
|
|
* This product includes software developed by Marc Horowitz.
|
|
* 4. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "opt_tx39_debug.h"
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/device.h>
|
|
#include <sys/kthread.h>
|
|
|
|
#include <machine/bus.h>
|
|
#include <machine/config_hook.h>
|
|
|
|
#include <dev/pcmcia/pcmciareg.h>
|
|
#include <dev/pcmcia/pcmciavar.h>
|
|
#include <dev/pcmcia/pcmciachip.h>
|
|
|
|
#include <hpcmips/tx/tx39var.h>
|
|
#include <hpcmips/dev/plumvar.h>
|
|
#include <hpcmips/dev/plumicuvar.h>
|
|
#include <hpcmips/dev/plumpowervar.h>
|
|
#include <hpcmips/dev/plumpcmciareg.h>
|
|
|
|
#ifdef PLUMPCMCIADEBUG
|
|
#define DPRINTF(arg) printf arg
|
|
#else
|
|
#define DPRINTF(arg)
|
|
#endif
|
|
|
|
int plumpcmcia_match(struct device *, struct cfdata *, void *);
|
|
void plumpcmcia_attach(struct device *, struct device *, void *);
|
|
int plumpcmcia_print(void *, const char *);
|
|
int plumpcmcia_submatch(struct device *, struct cfdata *, void *);
|
|
|
|
int plumpcmcia_power(void *, int, long, void *);
|
|
|
|
struct plumpcmcia_softc;
|
|
|
|
struct plumpcmcia_handle {
|
|
/* parent */
|
|
struct device *ph_parent;
|
|
/* child */
|
|
struct device *ph_pcmcia;
|
|
|
|
/* PCMCIA controller register space */
|
|
bus_space_tag_t ph_regt;
|
|
bus_space_handle_t ph_regh;
|
|
|
|
/* I/O port space */
|
|
int ph_ioarea; /* not PCMCIA window */
|
|
struct {
|
|
bus_addr_t pi_addr;
|
|
bus_size_t pi_size;
|
|
int pi_width;
|
|
} ph_io[PLUM_PCMCIA_IO_WINS];
|
|
int ph_ioalloc;
|
|
bus_space_tag_t ph_iot;
|
|
bus_space_handle_t ph_ioh;
|
|
bus_addr_t ph_iobase;
|
|
bus_size_t ph_iosize;
|
|
|
|
/* I/O Memory space */
|
|
int ph_memarea; /* not PCMCIA window */
|
|
struct {
|
|
bus_addr_t pm_addr;
|
|
bus_size_t pm_size;
|
|
int32_t pm_offset;
|
|
int pm_kind;
|
|
} ph_mem[PLUM_PCMCIA_MEM_WINS];
|
|
int ph_memalloc;
|
|
bus_space_tag_t ph_memt;
|
|
bus_space_handle_t ph_memh;
|
|
bus_addr_t ph_membase;
|
|
bus_size_t ph_memsize;
|
|
|
|
/* Card interrupt handler */
|
|
int ph_plum_irq;
|
|
void *ph_card_ih;
|
|
};
|
|
|
|
enum plumpcmcia_event_type {
|
|
PLUM_PCMCIA_EVENT_INSERT,
|
|
PLUM_PCMCIA_EVENT_REMOVE,
|
|
};
|
|
|
|
struct plumpcmcia_event {
|
|
int __queued;
|
|
enum plumpcmcia_event_type pe_type;
|
|
struct plumpcmcia_handle *pe_ph;
|
|
SIMPLEQ_ENTRY(plumpcmcia_event) pe_link;
|
|
};
|
|
|
|
struct plumpcmcia_softc {
|
|
struct device sc_dev;
|
|
plum_chipset_tag_t sc_pc;
|
|
|
|
/* Register space */
|
|
bus_space_tag_t sc_regt;
|
|
bus_space_handle_t sc_regh;
|
|
|
|
/* power management hook */
|
|
void *sc_powerhook;
|
|
|
|
/* CSC event */
|
|
struct proc *sc_event_thread;
|
|
SIMPLEQ_HEAD (, plumpcmcia_event) sc_event_head;
|
|
|
|
/* for each slot */
|
|
struct plumpcmcia_handle sc_ph[PLUMPCMCIA_NSLOTS];
|
|
};
|
|
|
|
static void plumpcmcia_attach_socket(struct plumpcmcia_handle *);
|
|
static int plumpcmcia_chip_mem_alloc(pcmcia_chipset_handle_t, bus_size_t,
|
|
struct pcmcia_mem_handle *);
|
|
static void plumpcmcia_chip_mem_free(pcmcia_chipset_handle_t,
|
|
struct pcmcia_mem_handle *);
|
|
static int plumpcmcia_chip_mem_map(pcmcia_chipset_handle_t, int, bus_addr_t,
|
|
bus_size_t, struct pcmcia_mem_handle *,
|
|
bus_addr_t *, int *);
|
|
static void plumpcmcia_chip_mem_unmap(pcmcia_chipset_handle_t, int);
|
|
static int plumpcmcia_chip_io_alloc(pcmcia_chipset_handle_t, bus_addr_t,
|
|
bus_size_t, bus_size_t,
|
|
struct pcmcia_io_handle *);
|
|
static void plumpcmcia_chip_io_free(pcmcia_chipset_handle_t,
|
|
struct pcmcia_io_handle *);
|
|
static int plumpcmcia_chip_io_map(pcmcia_chipset_handle_t, int, bus_addr_t,
|
|
bus_size_t, struct pcmcia_io_handle *,
|
|
int *);
|
|
static void plumpcmcia_chip_io_unmap(pcmcia_chipset_handle_t, int);
|
|
static void plumpcmcia_chip_socket_enable(pcmcia_chipset_handle_t);
|
|
static void plumpcmcia_chip_socket_disable(pcmcia_chipset_handle_t);
|
|
static void *plumpcmcia_chip_intr_establish(pcmcia_chipset_handle_t,
|
|
struct pcmcia_function *, int,
|
|
int (*)(void *), void *);
|
|
static void plumpcmcia_chip_intr_disestablish(pcmcia_chipset_handle_t, void *);
|
|
static void plumpcmcia_wait_ready( struct plumpcmcia_handle *);
|
|
static void plumpcmcia_chip_do_mem_map(struct plumpcmcia_handle *, int);
|
|
static void plumpcmcia_chip_do_io_map(struct plumpcmcia_handle *, int);
|
|
|
|
static struct pcmcia_chip_functions plumpcmcia_functions = {
|
|
plumpcmcia_chip_mem_alloc,
|
|
plumpcmcia_chip_mem_free,
|
|
plumpcmcia_chip_mem_map,
|
|
plumpcmcia_chip_mem_unmap,
|
|
plumpcmcia_chip_io_alloc,
|
|
plumpcmcia_chip_io_free,
|
|
plumpcmcia_chip_io_map,
|
|
plumpcmcia_chip_io_unmap,
|
|
plumpcmcia_chip_intr_establish,
|
|
plumpcmcia_chip_intr_disestablish,
|
|
plumpcmcia_chip_socket_enable,
|
|
plumpcmcia_chip_socket_disable
|
|
};
|
|
|
|
/* CSC */
|
|
#define PLUM_PCMCIA_EVENT_QUEUE_MAX 5
|
|
static struct plumpcmcia_event __event_queue_pool[PLUM_PCMCIA_EVENT_QUEUE_MAX];
|
|
static struct plumpcmcia_event *plumpcmcia_event_alloc(void);
|
|
static void plumpcmcia_event_free(struct plumpcmcia_event *);
|
|
static void plum_csc_intr_setup(struct plumpcmcia_softc *,
|
|
struct plumpcmcia_handle *, int);
|
|
static int plum_csc_intr(void *);
|
|
static void plumpcmcia_create_event_thread(void *);
|
|
static void plumpcmcia_event_thread(void *);
|
|
|
|
/* debug */
|
|
#define __DEBUG_FUNC __attribute__((__unused__))
|
|
static void __ioareadump(plumreg_t) __DEBUG_FUNC;
|
|
static void __memareadump(plumreg_t) __DEBUG_FUNC;
|
|
static void plumpcmcia_dump(struct plumpcmcia_softc *) __DEBUG_FUNC;
|
|
|
|
struct cfattach plumpcmcia_ca = {
|
|
sizeof(struct plumpcmcia_softc), plumpcmcia_match, plumpcmcia_attach
|
|
};
|
|
|
|
int
|
|
plumpcmcia_match(struct device *parent, struct cfdata *cf, void *aux)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
void
|
|
plumpcmcia_attach(struct device *parent, struct device *self, void *aux)
|
|
{
|
|
struct plum_attach_args *pa = aux;
|
|
struct plumpcmcia_softc *sc = (void*)self;
|
|
struct plumpcmcia_handle *ph;
|
|
|
|
sc->sc_pc = pa->pa_pc;
|
|
sc->sc_regt = pa->pa_regt;
|
|
|
|
/* map register area */
|
|
if (bus_space_map(sc->sc_regt, PLUM_PCMCIA_REGBASE,
|
|
PLUM_PCMCIA_REGSIZE, 0, &sc->sc_regh)) {
|
|
printf(": register map failed\n");
|
|
}
|
|
|
|
/* power control */
|
|
plumpcmcia_power(sc, 0, 0, (void *)PWR_RESUME);
|
|
/* Add a hard power hook to power saving */
|
|
#if notyet
|
|
sc->sc_powerhook = config_hook(CONFIG_HOOK_PMEVENT,
|
|
CONFIG_HOOK_PMEVENT_HARDPOWER,
|
|
CONFIG_HOOK_SHARE,
|
|
plumpcmcia_power, sc);
|
|
if (sc->sc_powerhook == 0)
|
|
printf(": WARNING unable to establish hard power hook");
|
|
#endif
|
|
printf("\n");
|
|
|
|
/* Slot0/1 CSC event queue */
|
|
SIMPLEQ_INIT (&sc->sc_event_head);
|
|
kthread_create(plumpcmcia_create_event_thread, sc);
|
|
|
|
/* Slot 0 */
|
|
ph = &sc->sc_ph[0];
|
|
ph->ph_plum_irq = PLUM_INT_C1IO;
|
|
ph->ph_memarea = PLUM_PCMCIA_MEMWINCTRL_MAP_AREA1;
|
|
ph->ph_membase = PLUM_PCMCIA_MEMBASE1;
|
|
ph->ph_memsize = PLUM_PCMCIA_MEMSIZE1;
|
|
ph->ph_ioarea = PLUM_PCMCIA_IOWINADDRCTRL_AREA1;
|
|
ph->ph_iobase = PLUM_PCMCIA_IOBASE1;
|
|
ph->ph_iosize = PLUM_PCMCIA_IOSIZE1;
|
|
ph->ph_regt = sc->sc_regt;
|
|
bus_space_subregion(sc->sc_regt, sc->sc_regh,
|
|
PLUM_PCMCIA_REGSPACE_SLOT0,
|
|
PLUM_PCMCIA_REGSPACE_SIZE,
|
|
&ph->ph_regh);
|
|
ph->ph_iot = pa->pa_iot;
|
|
ph->ph_memt = pa->pa_iot;
|
|
ph->ph_parent = (void*)sc;
|
|
|
|
plum_csc_intr_setup(sc, ph, PLUM_INT_C1SC);
|
|
plum_power_establish(sc->sc_pc, PLUM_PWR_PCC1);
|
|
plumpcmcia_attach_socket(ph);
|
|
|
|
/* Slot 1 */
|
|
ph = &sc->sc_ph[1];
|
|
ph->ph_plum_irq = PLUM_INT_C2IO;
|
|
ph->ph_memarea = PLUM_PCMCIA_MEMWINCTRL_MAP_AREA2;
|
|
ph->ph_membase = PLUM_PCMCIA_MEMBASE2;
|
|
ph->ph_memsize = PLUM_PCMCIA_MEMSIZE2;
|
|
ph->ph_ioarea = PLUM_PCMCIA_IOWINADDRCTRL_AREA2;
|
|
ph->ph_iobase = PLUM_PCMCIA_IOBASE2;
|
|
ph->ph_iosize = PLUM_PCMCIA_IOSIZE2;
|
|
ph->ph_regt = sc->sc_regt;
|
|
bus_space_subregion(sc->sc_regt, sc->sc_regh,
|
|
PLUM_PCMCIA_REGSPACE_SLOT1,
|
|
PLUM_PCMCIA_REGSPACE_SIZE,
|
|
&ph->ph_regh);
|
|
ph->ph_iot = pa->pa_iot;
|
|
ph->ph_memt = pa->pa_iot;
|
|
ph->ph_parent = (void*)sc;
|
|
|
|
plum_csc_intr_setup(sc, ph, PLUM_INT_C2SC);
|
|
plum_power_establish(sc->sc_pc, PLUM_PWR_PCC2);
|
|
plumpcmcia_attach_socket(ph);
|
|
}
|
|
|
|
int
|
|
plumpcmcia_print(void *arg, const char *pnp)
|
|
{
|
|
if (pnp) {
|
|
printf("pcmcia at %s", pnp);
|
|
}
|
|
|
|
return UNCONF;
|
|
}
|
|
|
|
int
|
|
plumpcmcia_submatch(struct device *parent, struct cfdata *cf, void *aux)
|
|
{
|
|
return ((*cf->cf_attach->ca_match)(parent, cf, aux));
|
|
}
|
|
|
|
static void
|
|
plumpcmcia_attach_socket(struct plumpcmcia_handle *ph)
|
|
{
|
|
struct pcmciabus_attach_args paa;
|
|
struct plumpcmcia_softc *sc = (void*)ph->ph_parent;
|
|
|
|
paa.paa_busname = "pcmcia";
|
|
paa.pct = (pcmcia_chipset_tag_t)&plumpcmcia_functions;
|
|
paa.pch = (pcmcia_chipset_handle_t)ph;
|
|
paa.iobase = 0; /* I don't use them */
|
|
paa.iosize = 0;
|
|
|
|
|
|
if ((ph->ph_pcmcia = config_found_sm((void*)sc, &paa,
|
|
plumpcmcia_print,
|
|
plumpcmcia_submatch))) {
|
|
/* Enable slot */
|
|
plum_conf_write(ph->ph_regt, ph->ph_regh,
|
|
PLUM_PCMCIA_SLOTCTRL,
|
|
PLUM_PCMCIA_SLOTCTRL_ENABLE);
|
|
/* Support 3.3V card & enable Voltage Sense Status */
|
|
plum_conf_write(ph->ph_regt, ph->ph_regh,
|
|
PLUM_PCMCIA_FUNCCTRL,
|
|
PLUM_PCMCIA_FUNCCTRL_VSSEN |
|
|
PLUM_PCMCIA_FUNCCTRL_3VSUPPORT);
|
|
pcmcia_card_attach(ph->ph_pcmcia);
|
|
}
|
|
}
|
|
|
|
static void *
|
|
plumpcmcia_chip_intr_establish(pcmcia_chipset_handle_t pch,
|
|
struct pcmcia_function *pf, int ipl,
|
|
int (*ih_fun)(void *), void *ih_arg)
|
|
{
|
|
struct plumpcmcia_handle *ph = (void*)pch;
|
|
struct plumpcmcia_softc *sc = (void*)ph->ph_parent;
|
|
|
|
if (!(ph->ph_card_ih =
|
|
plum_intr_establish(sc->sc_pc, ph->ph_plum_irq,
|
|
IST_EDGE, IPL_BIO, ih_fun, ih_arg))) {
|
|
printf("plumpcmcia_chip_intr_establish: can't establish\n");
|
|
return 0;
|
|
}
|
|
|
|
return ph->ph_card_ih;
|
|
}
|
|
|
|
static void
|
|
plumpcmcia_chip_intr_disestablish(pcmcia_chipset_handle_t pch, void *ih)
|
|
{
|
|
struct plumpcmcia_handle *ph = (void*)pch;
|
|
struct plumpcmcia_softc *sc = (void*)ph->ph_parent;
|
|
|
|
plum_intr_disestablish(sc->sc_pc, ih);
|
|
}
|
|
|
|
static int
|
|
plumpcmcia_chip_mem_alloc(pcmcia_chipset_handle_t pch, bus_size_t size,
|
|
struct pcmcia_mem_handle *pcmhp)
|
|
{
|
|
struct plumpcmcia_handle *ph = (void*)pch;
|
|
bus_size_t realsize;
|
|
|
|
/* convert size to PCIC pages */
|
|
realsize = ((size + (PLUM_PCMCIA_MEM_PAGESIZE - 1)) /
|
|
PLUM_PCMCIA_MEM_PAGESIZE) * PLUM_PCMCIA_MEM_PAGESIZE;
|
|
|
|
if (bus_space_alloc(ph->ph_memt, ph->ph_membase,
|
|
ph->ph_membase + ph->ph_memsize,
|
|
realsize, PLUM_PCMCIA_MEM_PAGESIZE,
|
|
0, 0, 0, &pcmhp->memh)) {
|
|
return 1;
|
|
}
|
|
|
|
pcmhp->memt = ph->ph_memt;
|
|
/* Address offset from MEM area base */
|
|
pcmhp->addr = pcmhp->memh - ph->ph_membase - ph->ph_memt->t_base;
|
|
pcmhp->size = size;
|
|
pcmhp->realsize = realsize;
|
|
|
|
DPRINTF(("plumpcmcia_chip_mem_alloc: size %#x->%#x addr %#x->%#x\n",
|
|
(unsigned)size, (unsigned)realsize, (unsigned)pcmhp->addr,
|
|
(unsigned)pcmhp->memh));
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
plumpcmcia_chip_mem_free(pcmcia_chipset_handle_t pch,
|
|
struct pcmcia_mem_handle *pcmhp)
|
|
{
|
|
bus_space_free(pcmhp->memt, pcmhp->memh, pcmhp->size);
|
|
}
|
|
|
|
static int
|
|
plumpcmcia_chip_mem_map(pcmcia_chipset_handle_t pch, int kind,
|
|
bus_addr_t card_addr, bus_size_t size,
|
|
struct pcmcia_mem_handle *pcmhp,
|
|
bus_addr_t *offsetp, int *windowp)
|
|
{
|
|
struct plumpcmcia_handle *ph = (void*)pch;
|
|
bus_addr_t busaddr;
|
|
int32_t card_offset;
|
|
int i, win;
|
|
|
|
for (win = -1, i = 0; i < PLUM_PCMCIA_MEM_WINS; i++) {
|
|
if ((ph->ph_memalloc & (1 << i)) == 0) {
|
|
win = i;
|
|
ph->ph_memalloc |= (1 << i);
|
|
break;
|
|
}
|
|
}
|
|
if (win == -1) {
|
|
DPRINTF(("plumpcmcia_chip_mem_map: no window\n"));
|
|
return 1;
|
|
}
|
|
|
|
busaddr = pcmhp->addr;
|
|
|
|
*offsetp = card_addr % PLUM_PCMCIA_MEM_PAGESIZE;
|
|
card_addr -= *offsetp;
|
|
size += *offsetp - 1;
|
|
*windowp = win;
|
|
card_offset = (((int32_t)card_addr) - ((int32_t)busaddr));
|
|
|
|
DPRINTF(("plumpcmcia_chip_mem_map window %d bus %#x(kv:%#x)+%#x"
|
|
" size %#x at card addr %#x offset %#x\n", win,
|
|
(unsigned)busaddr, (unsigned)pcmhp->memh, (unsigned)*offsetp,
|
|
(unsigned)size, (unsigned)card_addr, (unsigned)card_offset));
|
|
|
|
ph->ph_mem[win].pm_addr = busaddr;
|
|
ph->ph_mem[win].pm_size = size;
|
|
ph->ph_mem[win].pm_offset = card_offset;
|
|
ph->ph_mem[win].pm_kind = kind;
|
|
ph->ph_memalloc |= (1 << win);
|
|
|
|
plumpcmcia_chip_do_mem_map(ph, win);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
plumpcmcia_chip_do_mem_map(struct plumpcmcia_handle *ph, int win)
|
|
{
|
|
bus_space_tag_t regt = ph->ph_regt;
|
|
bus_space_handle_t regh = ph->ph_regh;
|
|
plumreg_t reg, addr, offset, size;
|
|
|
|
if (win < 0 || win > 4) {
|
|
panic("plumpcmcia_chip_do_mem_map: bogus window %d", win);
|
|
}
|
|
|
|
addr = (ph->ph_mem[win].pm_addr) >> PLUM_PCMCIA_MEM_SHIFT;
|
|
size = (ph->ph_mem[win].pm_size) >> PLUM_PCMCIA_MEM_SHIFT;
|
|
offset = (ph->ph_mem[win].pm_offset) >> PLUM_PCMCIA_MEM_SHIFT;
|
|
|
|
/* Attribute memory or not */
|
|
reg = ph->ph_mem[win].pm_kind == PCMCIA_MEM_ATTR ?
|
|
PLUM_PCMCIA_MEMWINCTRL_REGACTIVE : 0;
|
|
|
|
/* Notify I/O area to select for PCMCIA controller */
|
|
reg = PLUM_PCMCIA_MEMWINCTRL_MAP_SET(reg, ph->ph_memarea);
|
|
|
|
/* Zero wait & 16bit access */
|
|
reg |= (PLUM_PCMCIA_MEMWINCTRL_ZERO_WS |
|
|
PLUM_PCMCIA_MEMWINCTRL_DATASIZE16);
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_MEMWINCTRL(win), reg);
|
|
|
|
/* Map Host <-> PC-Card address */
|
|
|
|
/* host-side */
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_MEMWINSTARTADDR(win),
|
|
addr);
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_MEMWINSTOPADDR(win),
|
|
addr + size);
|
|
|
|
/* card-side */
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_MEMWINOFSADDR(win), offset);
|
|
|
|
/* Enable memory window */
|
|
reg = plum_conf_read(regt, regh, PLUM_PCMCIA_WINEN);
|
|
reg |= PLUM_PCMCIA_WINEN_MEM(win);
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_WINEN, reg);
|
|
|
|
DPRINTF(("plumpcmcia_chip_do_mem_map: window:%d %#x(%#x)+%#x\n",
|
|
win, offset, addr, size));
|
|
|
|
delay(100);
|
|
}
|
|
|
|
static void
|
|
plumpcmcia_chip_mem_unmap(pcmcia_chipset_handle_t pch, int window)
|
|
{
|
|
struct plumpcmcia_handle *ph = (void*)pch;
|
|
bus_space_tag_t regt = ph->ph_regt;
|
|
bus_space_handle_t regh = ph->ph_regh;
|
|
plumreg_t reg;
|
|
|
|
reg = plum_conf_read(regt, regh, PLUM_PCMCIA_WINEN);
|
|
reg &= ~PLUM_PCMCIA_WINEN_MEM(window);
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_WINEN, reg);
|
|
|
|
ph->ph_memalloc &= ~(1 << window);
|
|
}
|
|
|
|
static int
|
|
plumpcmcia_chip_io_alloc(pcmcia_chipset_handle_t pch, bus_addr_t start,
|
|
bus_size_t size, bus_size_t align,
|
|
struct pcmcia_io_handle *pcihp)
|
|
{
|
|
struct plumpcmcia_handle *ph = (void*)pch;
|
|
|
|
DPRINTF(("plumpcmcia_chip_io_alloc: start=%#x size=%#x ",
|
|
(unsigned)start, (unsigned)size));
|
|
if (start) {
|
|
if (bus_space_map(ph->ph_iot, ph->ph_iobase + start,
|
|
size, 0, &pcihp->ioh)) {
|
|
DPRINTF(("bus_space_map failed\n"));
|
|
return 1;
|
|
}
|
|
pcihp->flags = 0;
|
|
pcihp->addr = start;
|
|
DPRINTF(("(mapped) %#x+%#x\n", (unsigned)start,
|
|
(unsigned)size));
|
|
} else {
|
|
if (bus_space_alloc(ph->ph_iot, ph->ph_iobase,
|
|
ph->ph_iobase + ph->ph_iosize, size,
|
|
align, 0, 0, 0, &pcihp->ioh)) {
|
|
DPRINTF(("bus_space_alloc failed\n"));
|
|
return 1;
|
|
}
|
|
/* Address offset from IO area base */
|
|
pcihp->addr = pcihp->ioh - ph->ph_iobase -
|
|
ph->ph_iot->t_base;
|
|
pcihp->flags = PCMCIA_IO_ALLOCATED;
|
|
DPRINTF(("(allocated) %#x+%#x\n", (unsigned)pcihp->addr,
|
|
(unsigned)size));
|
|
}
|
|
|
|
pcihp->iot = ph->ph_iot;
|
|
pcihp->size = size;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
plumpcmcia_chip_io_map(pcmcia_chipset_handle_t pch, int width,
|
|
bus_addr_t offset, bus_size_t size,
|
|
struct pcmcia_io_handle *pcihp, int *windowp)
|
|
{
|
|
#ifdef PLUMPCMCIADEBUG
|
|
static char *width_names[] = { "auto", "io8", "io16" };
|
|
#endif /* PLUMPCMCIADEBUG */
|
|
struct plumpcmcia_handle *ph = (void*)pch;
|
|
bus_addr_t winofs;
|
|
int i, win;
|
|
|
|
winofs = pcihp->addr + offset;
|
|
|
|
if (winofs > 0x3ff) {
|
|
printf("plumpcmcia_chip_io_map: WARNING port %#lx > 0x3ff\n",
|
|
winofs);
|
|
}
|
|
|
|
for (win = -1, i = 0; i < PLUM_PCMCIA_IO_WINS; i++) {
|
|
if ((ph->ph_ioalloc & (1 << i)) == 0) {
|
|
win = i;
|
|
ph->ph_ioalloc |= (1 << i);
|
|
break;
|
|
}
|
|
}
|
|
if (win == -1) {
|
|
DPRINTF(("plumpcmcia_chip_io_map: no window\n"));
|
|
return 1;
|
|
}
|
|
*windowp = win;
|
|
|
|
ph->ph_io[win].pi_addr = winofs;
|
|
ph->ph_io[win].pi_size = size;
|
|
ph->ph_io[win].pi_width = width;
|
|
|
|
plumpcmcia_chip_do_io_map(ph, win);
|
|
|
|
DPRINTF(("plumpcmcia_chip_io_map: %#x(kv:%#x)+%#x %s\n",
|
|
(unsigned)offset, (unsigned)pcihp->ioh, (unsigned)size,
|
|
width_names[width]));
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
plumpcmcia_chip_do_io_map(struct plumpcmcia_handle *ph, int win)
|
|
{
|
|
bus_space_tag_t regt = ph->ph_regt;
|
|
bus_space_handle_t regh = ph->ph_regh;
|
|
plumreg_t reg;
|
|
bus_addr_t addr;
|
|
bus_size_t size;
|
|
int shift;
|
|
plumreg_t ioctlbits[3] = {
|
|
PLUM_PCMCIA_IOWINCTRL_IOCS16SRC,
|
|
0,
|
|
PLUM_PCMCIA_IOWINCTRL_DATASIZE16
|
|
};
|
|
|
|
if (win < 0 || win > 1) {
|
|
panic("plumpcmcia_chip_do_io_map: bogus window %d", win);
|
|
}
|
|
|
|
addr = ph->ph_io[win].pi_addr;
|
|
size = ph->ph_io[win].pi_size;
|
|
|
|
/* Notify I/O area to select for PCMCIA controller */
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_IOWINADDRCTRL(win),
|
|
ph->ph_ioarea);
|
|
|
|
/* Start/Stop addr */
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_IOWINSTARTADDR(win), addr);
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_IOWINSTOPADDR(win),
|
|
addr + size - 1);
|
|
|
|
/* Set bus width */
|
|
reg = plum_conf_read(regt, regh, PLUM_PCMCIA_IOWINCTRL);
|
|
shift = win == 0 ? PLUM_PCMCIA_IOWINCTRL_WIN0SHIFT :
|
|
PLUM_PCMCIA_IOWINCTRL_WIN1SHIFT;
|
|
|
|
reg &= ~(PLUM_PCMCIA_IOWINCTRL_WINMASK << shift);
|
|
reg |= ((ioctlbits[ph->ph_io[win].pi_width] |
|
|
PLUM_PCMCIA_IOWINCTRL_ZEROWAIT) << shift);
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_IOWINCTRL, reg);
|
|
|
|
/* Enable window */
|
|
reg = plum_conf_read(regt, regh, PLUM_PCMCIA_WINEN);
|
|
reg |= (win == 0 ? PLUM_PCMCIA_WINEN_IO0 :
|
|
PLUM_PCMCIA_WINEN_IO1);
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_WINEN, reg);
|
|
|
|
delay(100);
|
|
}
|
|
|
|
static void
|
|
plumpcmcia_chip_io_free(pcmcia_chipset_handle_t pch,
|
|
struct pcmcia_io_handle *pcihp)
|
|
{
|
|
if (pcihp->flags & PCMCIA_IO_ALLOCATED) {
|
|
bus_space_free(pcihp->iot, pcihp->ioh, pcihp->size);
|
|
} else {
|
|
bus_space_unmap(pcihp->iot, pcihp->ioh, pcihp->size);
|
|
}
|
|
|
|
DPRINTF(("plumpcmcia_chip_io_free %#x+%#x\n", pcihp->ioh,
|
|
(unsigned)pcihp->size));
|
|
}
|
|
|
|
static void
|
|
plumpcmcia_chip_io_unmap(pcmcia_chipset_handle_t pch, int window)
|
|
{
|
|
struct plumpcmcia_handle *ph = (void*)pch;
|
|
bus_space_tag_t regt = ph->ph_regt;
|
|
bus_space_handle_t regh = ph->ph_regh;
|
|
plumreg_t reg;
|
|
|
|
reg = plum_conf_read(regt, regh, PLUM_PCMCIA_WINEN);
|
|
switch (window) {
|
|
default:
|
|
panic("plumpcmcia_chip_io_unmap: bogus window");
|
|
case 0:
|
|
reg &= ~PLUM_PCMCIA_WINEN_IO0;
|
|
break;
|
|
case 1:
|
|
reg &= ~PLUM_PCMCIA_WINEN_IO1;
|
|
break;
|
|
}
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_WINEN, reg);
|
|
ph->ph_ioalloc &= ~(1 << window);
|
|
}
|
|
|
|
static void
|
|
plumpcmcia_wait_ready(struct plumpcmcia_handle *ph)
|
|
{
|
|
bus_space_tag_t regt = ph->ph_regt;
|
|
bus_space_handle_t regh = ph->ph_regh;
|
|
int i;
|
|
|
|
for (i = 0; i < 10000; i++) {
|
|
if ((plum_conf_read(regt, regh, PLUM_PCMCIA_STATUS) &
|
|
PLUM_PCMCIA_STATUS_READY) &&
|
|
(plum_conf_read(regt, regh, PLUM_PCMCIA_STATUS) &
|
|
PLUM_PCMCIA_STATUS_PWROK)) {
|
|
return;
|
|
}
|
|
delay(500);
|
|
|
|
if ((i > 5000) && (i % 100 == 99)) {
|
|
printf(".");
|
|
}
|
|
}
|
|
printf("plumpcmcia_wait_ready: failed\n");
|
|
}
|
|
|
|
static void
|
|
plumpcmcia_chip_socket_enable(pcmcia_chipset_handle_t pch)
|
|
{
|
|
struct plumpcmcia_handle *ph = (void*)pch;
|
|
bus_space_tag_t regt = ph->ph_regt;
|
|
bus_space_handle_t regh = ph->ph_regh;
|
|
plumreg_t reg, power;
|
|
int win, cardtype;
|
|
|
|
/* this bit is mostly stolen from pcic_attach_card */
|
|
|
|
/* power down the socket to reset it, clear the card reset pin */
|
|
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_PWRCTRL, 0);
|
|
|
|
/*
|
|
* wait 300ms until power fails (Tpf). Then, wait 100ms since
|
|
* we are changing Vcc (Toff).
|
|
*/
|
|
delay((300 + 100) * 1000);
|
|
|
|
/*
|
|
* power up the socket
|
|
*/
|
|
/* detect voltage */
|
|
reg = plum_conf_read(regt, regh, PLUM_PCMCIA_GENCTRL2);
|
|
if ((reg & PLUM_PCMCIA_GENCTRL2_VCC5V) ==
|
|
PLUM_PCMCIA_GENCTRL2_VCC5V) {
|
|
power = PLUM_PCMCIA_PWRCTRL_VCC_CTRLBIT1; /* 5V */
|
|
} else {
|
|
power = PLUM_PCMCIA_PWRCTRL_VCC_CTRLBIT0; /* 3.3V */
|
|
}
|
|
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_PWRCTRL,
|
|
PLUM_PCMCIA_PWRCTRL_DISABLE_RESETDRV |
|
|
power |
|
|
PLUM_PCMCIA_PWRCTRL_PWR_ENABLE);
|
|
|
|
/*
|
|
* wait 100ms until power raise (Tpr) and 20ms to become
|
|
* stable (Tsu(Vcc)).
|
|
*
|
|
* some machines require some more time to be settled
|
|
* (300ms is added here).
|
|
*/
|
|
delay((100 + 20 + 300) * 1000);
|
|
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_PWRCTRL,
|
|
PLUM_PCMCIA_PWRCTRL_DISABLE_RESETDRV |
|
|
power |
|
|
PLUM_PCMCIA_PWRCTRL_OE |
|
|
PLUM_PCMCIA_PWRCTRL_PWR_ENABLE);
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_GENCTRL, 0);
|
|
|
|
/*
|
|
* hold RESET at least 10us.
|
|
*/
|
|
delay(10);
|
|
|
|
/* clear the reset flag */
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_GENCTRL,
|
|
PLUM_PCMCIA_GENCTRL_RESET);
|
|
|
|
/* wait 20ms as per pc card standard (r2.01) section 4.3.6 */
|
|
|
|
delay(20000);
|
|
|
|
/* wait for the chip to finish initializing */
|
|
plumpcmcia_wait_ready(ph);
|
|
|
|
/* zero out the address windows */
|
|
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_WINEN, 0);
|
|
|
|
/* set the card type */
|
|
|
|
cardtype = pcmcia_card_gettype(ph->ph_pcmcia);
|
|
|
|
reg = (cardtype == PCMCIA_IFTYPE_IO) ?
|
|
PLUM_PCMCIA_GENCTRL_CARDTYPE_IO :
|
|
PLUM_PCMCIA_GENCTRL_CARDTYPE_MEM;
|
|
reg |= plum_conf_read(regt, regh, PLUM_PCMCIA_GENCTRL);
|
|
DPRINTF(("%s: plumpcmcia_chip_socket_enable cardtype %s\n",
|
|
ph->ph_parent->dv_xname,
|
|
((cardtype == PCMCIA_IFTYPE_IO) ? "io" : "mem")));
|
|
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_GENCTRL, reg);
|
|
|
|
/* reinstall all the memory and io mappings */
|
|
|
|
for (win = 0; win < PLUM_PCMCIA_MEM_WINS; win++) {
|
|
if (ph->ph_memalloc & (1 << win)) {
|
|
plumpcmcia_chip_do_mem_map(ph, win);
|
|
}
|
|
}
|
|
|
|
for (win = 0; win < PLUM_PCMCIA_IO_WINS; win++) {
|
|
if (ph->ph_ioalloc & (1 << win)) {
|
|
plumpcmcia_chip_do_io_map(ph, win);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
static void
|
|
plumpcmcia_chip_socket_disable(pcmcia_chipset_handle_t pch)
|
|
{
|
|
struct plumpcmcia_handle *ph = (void*)pch;
|
|
bus_space_tag_t regt = ph->ph_regt;
|
|
bus_space_handle_t regh = ph->ph_regh;
|
|
|
|
/* power down the socket */
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_PWRCTRL, 0);
|
|
|
|
/*
|
|
* wait 300ms until power fails (Tpf).
|
|
*/
|
|
delay(300 * 1000);
|
|
}
|
|
|
|
static void
|
|
plum_csc_intr_setup(struct plumpcmcia_softc *sc, struct plumpcmcia_handle *ph,
|
|
int irq)
|
|
{
|
|
bus_space_tag_t regt = ph->ph_regt;
|
|
bus_space_handle_t regh = ph->ph_regh;
|
|
plumreg_t reg;
|
|
void *ih;
|
|
|
|
/* enable CARD DETECT ENABLE only */
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_CSCINT,
|
|
PLUM_PCMCIA_CSCINT_CARD_DETECT);
|
|
|
|
/* don't use explicit writeback csc interrupt status */
|
|
reg = plum_conf_read(regt, regh, PLUM_PCMCIA_GLOBALCTRL);
|
|
reg &= ~PLUM_PCMCIA_GLOBALCTRL_EXPLICIT_WB_CSC_INT;
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_GLOBALCTRL, reg);
|
|
|
|
/* install interrupt handler (don't fail) */
|
|
ih = plum_intr_establish(sc->sc_pc, irq, IST_EDGE, IPL_TTY,
|
|
plum_csc_intr, ph);
|
|
KASSERT(ih != 0);
|
|
}
|
|
|
|
static int
|
|
plum_csc_intr(void *arg)
|
|
{
|
|
struct plumpcmcia_handle *ph = arg;
|
|
struct plumpcmcia_softc *sc = (void *)ph->ph_parent;
|
|
struct plumpcmcia_event *pe;
|
|
bus_space_tag_t regt = ph->ph_regt;
|
|
bus_space_handle_t regh = ph->ph_regh;
|
|
plumreg_t reg;
|
|
int flag;
|
|
|
|
/* read and clear interrupt status */
|
|
reg = plum_conf_read(regt, regh, PLUM_PCMCIA_CSCINT_STAT);
|
|
if (reg & PLUM_PCMCIA_CSCINT_CARD_DETECT) {
|
|
DPRINTF(("%s: card status change.\n", __FUNCTION__));
|
|
} else {
|
|
DPRINTF(("%s: unhandled csc event. 0x%02x\n",
|
|
__FUNCTION__, reg));
|
|
return 0;
|
|
}
|
|
|
|
/* inquire card status (insert or remove) */
|
|
reg = plum_conf_read(regt, regh, PLUM_PCMCIA_STATUS);
|
|
reg &= (PLUM_PCMCIA_STATUS_CD1 | PLUM_PCMCIA_STATUS_CD2);
|
|
if (reg == (PLUM_PCMCIA_STATUS_CD1 | PLUM_PCMCIA_STATUS_CD2)) {
|
|
/* insert */
|
|
flag = PLUM_PCMCIA_EVENT_INSERT;
|
|
} else {
|
|
/* remove */
|
|
flag = PLUM_PCMCIA_EVENT_REMOVE;
|
|
}
|
|
|
|
/* queue event to event thread and wakeup. */
|
|
pe = plumpcmcia_event_alloc();
|
|
if (pe == 0) {
|
|
printf("%s: event FIFO overflow (%d).\n", __FUNCTION__,
|
|
PLUM_PCMCIA_EVENT_QUEUE_MAX);
|
|
return 0;
|
|
}
|
|
pe->pe_type = flag;
|
|
pe->pe_ph = ph;
|
|
SIMPLEQ_INSERT_TAIL(&sc->sc_event_head, pe, pe_link);
|
|
wakeup(sc);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
__memareadump(plumreg_t reg)
|
|
{
|
|
int maparea;
|
|
|
|
maparea = PLUM_PCMCIA_MEMWINCTRL_MAP(reg);
|
|
switch (maparea) {
|
|
case PLUM_PCMCIA_MEMWINCTRL_MAP_AREA1:
|
|
printf("MEM Area1\n");
|
|
break;
|
|
case PLUM_PCMCIA_MEMWINCTRL_MAP_AREA2:
|
|
printf("MEM Area2\n");
|
|
break;
|
|
case PLUM_PCMCIA_MEMWINCTRL_MAP_AREA3:
|
|
printf("MEM Area3\n");
|
|
break;
|
|
case PLUM_PCMCIA_MEMWINCTRL_MAP_AREA4:
|
|
printf("MEM Area4\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
static struct plumpcmcia_event *
|
|
plumpcmcia_event_alloc()
|
|
{
|
|
int i;
|
|
/* I assume called from interrupt context only. so don't lock */
|
|
for (i = 0; i < PLUM_PCMCIA_EVENT_QUEUE_MAX; i++) {
|
|
if (!__event_queue_pool[i].__queued) {
|
|
__event_queue_pool[i].__queued = 1;
|
|
return &__event_queue_pool[i];
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
plumpcmcia_event_free(struct plumpcmcia_event *pe)
|
|
{
|
|
/* I assume context is already locked */
|
|
pe->__queued = 0;
|
|
}
|
|
|
|
static void
|
|
plumpcmcia_create_event_thread(void *arg)
|
|
{
|
|
struct plumpcmcia_softc *sc = arg;
|
|
int error;
|
|
|
|
error = kthread_create1(plumpcmcia_event_thread, sc,
|
|
&sc->sc_event_thread, "%s",
|
|
sc->sc_dev.dv_xname);
|
|
KASSERT(error == 0);
|
|
}
|
|
|
|
static void
|
|
plumpcmcia_event_thread(void *arg)
|
|
{
|
|
struct plumpcmcia_softc *sc = arg;
|
|
struct plumpcmcia_event *pe;
|
|
int s;
|
|
|
|
while (/*CONSTCOND*/1) { /* XXX shutdown. -uch */
|
|
tsleep(sc, PWAIT, "CSC wait", 0);
|
|
s = spltty();
|
|
while ((pe = SIMPLEQ_FIRST(&sc->sc_event_head))) {
|
|
splx(s);
|
|
switch (pe->pe_type) {
|
|
default:
|
|
printf("%s: unknown event.\n", __FUNCTION__);
|
|
break;
|
|
case PLUM_PCMCIA_EVENT_INSERT:
|
|
DPRINTF(("%s: insert event.\n", __FUNCTION__));
|
|
pcmcia_card_attach(pe->pe_ph->ph_pcmcia);
|
|
break;
|
|
case PLUM_PCMCIA_EVENT_REMOVE:
|
|
DPRINTF(("%s: remove event.\n", __FUNCTION__));
|
|
pcmcia_card_detach(pe->pe_ph->ph_pcmcia,
|
|
DETACH_FORCE);
|
|
break;
|
|
}
|
|
s = spltty();
|
|
SIMPLEQ_REMOVE_HEAD(&sc->sc_event_head, pe, pe_link);
|
|
plumpcmcia_event_free(pe);
|
|
}
|
|
splx(s);
|
|
}
|
|
/* NOTREACHED */
|
|
}
|
|
|
|
/* power XXX notyet */
|
|
int
|
|
plumpcmcia_power(void *ctx, int type, long id, void *msg)
|
|
{
|
|
struct plumpcmcia_softc *sc = ctx;
|
|
bus_space_tag_t regt = sc->sc_regt;
|
|
bus_space_handle_t regh = sc->sc_regh;
|
|
int why = (int)msg;
|
|
|
|
switch (why) {
|
|
case PWR_RESUME:
|
|
DPRINTF(("%s: ON\n", sc->sc_dev.dv_xname));
|
|
/* power on */
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_CARDPWRCTRL,
|
|
PLUM_PCMCIA_CARDPWRCTRL_ON);
|
|
break;
|
|
case PWR_SUSPEND:
|
|
/* FALLTHROUGH */
|
|
case PWR_STANDBY:
|
|
plum_conf_write(regt, regh, PLUM_PCMCIA_CARDPWRCTRL,
|
|
PLUM_PCMCIA_CARDPWRCTRL_OFF);
|
|
DPRINTF(("%s: OFF\n", sc->sc_dev.dv_xname));
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
__ioareadump(plumreg_t reg)
|
|
{
|
|
if (reg & PLUM_PCMCIA_IOWINADDRCTRL_AREA2) {
|
|
printf("I/O Area 2\n");
|
|
} else {
|
|
printf("I/O Area 1\n");
|
|
}
|
|
}
|
|
|
|
static void
|
|
plumpcmcia_dump(struct plumpcmcia_softc *sc)
|
|
{
|
|
bus_space_tag_t regt = sc->sc_regt;
|
|
bus_space_handle_t regh = sc->sc_regh;
|
|
plumreg_t reg;
|
|
|
|
int i, j;
|
|
|
|
__memareadump(plum_conf_read(regt, regh, PLUM_PCMCIA_MEMWIN0CTRL));
|
|
__memareadump(plum_conf_read(regt, regh, PLUM_PCMCIA_MEMWIN1CTRL));
|
|
__memareadump(plum_conf_read(regt, regh, PLUM_PCMCIA_MEMWIN2CTRL));
|
|
__memareadump(plum_conf_read(regt, regh, PLUM_PCMCIA_MEMWIN3CTRL));
|
|
__memareadump(plum_conf_read(regt, regh, PLUM_PCMCIA_MEMWIN4CTRL));
|
|
|
|
__ioareadump(plum_conf_read(regt, regh, PLUM_PCMCIA_IOWIN0ADDRCTRL));
|
|
__ioareadump(plum_conf_read(regt, regh, PLUM_PCMCIA_IOWIN1ADDRCTRL));
|
|
|
|
for (j = 0; j < 2; j++) {
|
|
printf("[slot %d]\n", j);
|
|
for (i = 0; i < 0x120; i += 4) {
|
|
reg = plum_conf_read(sc->sc_regt, sc->sc_regh, i + 0x800 * j);
|
|
printf("%03x %08x", i, reg);
|
|
bitdisp(reg);
|
|
}
|
|
}
|
|
printf("\n");
|
|
}
|