static void
slugbutt_deferred(device_t self)
{
struct slugbutt_softc *sc = device_private(self);
struct ixp425_softc *ixsc = ixp425_softc;
uint32_t reg;
sc->sc_dev = self;
/* Configure the GPIO pins as inputs */
reg = GPIO_CONF_READ_4(ixsc, IXP425_GPIO_GPOER);
reg |= SLUGBUTT_PWR_BIT | SLUGBUTT_RST_BIT;
GPIO_CONF_WRITE_4(ixsc, IXP425_GPIO_GPOER, reg);
/* Configure the input type: Falling edge */
reg = GPIO_CONF_READ_4(ixsc, GPIO_TYPE_REG(GPIO_BUTTON_PWR));
reg &= ~GPIO_TYPE(GPIO_BUTTON_PWR, GPIO_TYPE_MASK);
reg |= GPIO_TYPE(GPIO_BUTTON_PWR, GPIO_TYPE_EDG_FALLING);
GPIO_CONF_WRITE_4(ixsc, GPIO_TYPE_REG(GPIO_BUTTON_PWR), reg);
reg = GPIO_CONF_READ_4(ixsc, GPIO_TYPE_REG(GPIO_BUTTON_RST));
reg &= ~GPIO_TYPE(GPIO_BUTTON_RST, GPIO_TYPE_MASK);
reg |= GPIO_TYPE(GPIO_BUTTON_RST, GPIO_TYPE_EDG_FALLING);
GPIO_CONF_WRITE_4(ixsc, GPIO_TYPE_REG(GPIO_BUTTON_RST), reg);
/* Clear any existing interrupt */
GPIO_CONF_WRITE_4(ixsc, IXP425_GPIO_GPISR, SLUGBUTT_PWR_BIT |
SLUGBUTT_RST_BIT);
sysmon_task_queue_init();
sc->sc_smpwr.smpsw_name = device_xname(sc->sc_dev);
sc->sc_smpwr.smpsw_type = PSWITCH_TYPE_POWER;
if (sysmon_pswitch_register(&sc->sc_smpwr) != 0) {
printf("%s: unable to register power button with sysmon\n",
device_xname(sc->sc_dev));
return;
}
sc->sc_smrst.smpsw_name = device_xname(sc->sc_dev);
sc->sc_smrst.smpsw_type = PSWITCH_TYPE_RESET;
if (sysmon_pswitch_register(&sc->sc_smrst) != 0) {
printf("%s: unable to register reset button with sysmon\n",
device_xname(sc->sc_dev));
return;
}
/* Hook the interrupts */
ixp425_intr_establish(BUTTON_PWR_INT, IPL_TTY, power_intr, sc);
ixp425_intr_establish(BUTTON_RST_INT, IPL_TTY, reset_intr, sc);
}
static void
slugled_defer(device_t self)
{
struct slugled_softc *sc = device_private(self);
struct ixp425_softc *ixsc = ixp425_softc;
uint32_t reg;
int s;
s = splhigh();
/* Configure LED GPIO pins as output */
reg = GPIO_CONF_READ_4(ixsc, IXP425_GPIO_GPOER);
reg &= ~(LEDBITS_USB0 | LEDBITS_USB1);
reg &= ~(LEDBITS_READY | LEDBITS_STATUS);
GPIO_CONF_WRITE_4(ixsc, IXP425_GPIO_GPOER, reg);
/* All LEDs off */
reg = GPIO_CONF_READ_4(ixsc, IXP425_GPIO_GPOUTR);
reg |= LEDBITS_USB0 | LEDBITS_USB1;
reg &= ~(LEDBITS_STATUS | LEDBITS_READY);
GPIO_CONF_WRITE_4(ixsc, IXP425_GPIO_GPOUTR, reg);
splx(s);
if (shutdownhook_establish(slugled_shutdown, sc) == NULL)
aprint_error_dev(self, "WARNING - Failed to register shutdown hook\n");
callout_init(&sc->sc_usb0, 0);
callout_setfunc(&sc->sc_usb0, slugled_callout,
(void *)(uintptr_t)LEDBITS_USB0);
callout_init(&sc->sc_usb1, 0);
callout_setfunc(&sc->sc_usb1, slugled_callout,
(void *)(uintptr_t)LEDBITS_USB1);
callout_init(&sc->sc_usb2, 0);
callout_setfunc(&sc->sc_usb2, slugled_callout,
(void *)(uintptr_t)(LEDBITS_USB0 | LEDBITS_USB1));
sc->sc_usb0_ih = ixp425_intr_establish(PCI_INT_A, IPL_USB,
slugled_intr0, sc);
KDASSERT(sc->sc_usb0_ih != NULL);
sc->sc_usb1_ih = ixp425_intr_establish(PCI_INT_B, IPL_USB,
slugled_intr1, sc);
KDASSERT(sc->sc_usb1_ih != NULL);
sc->sc_usb2_ih = ixp425_intr_establish(PCI_INT_C, IPL_USB,
slugled_intr2, sc);
KDASSERT(sc->sc_usb2_ih != NULL);
sc->sc_tmr_ih = ixp425_intr_establish(IXP425_INT_TMR0, IPL_CLOCK,
slugled_tmr, NULL);
KDASSERT(sc->sc_tmr_ih != NULL);
}
static void
ixsipcom_attach(device_t parent, device_t self, void *aux)
{
struct com_softc *sc = device_private(self);
struct ixpsip_attach_args *sa = aux;
bus_space_tag_t iot;
bus_space_handle_t ioh;
bus_addr_t iobase;
sc->sc_dev = self;
iot = &ixp425_a4x_bs_tag;
iobase = sa->sa_addr;
sc->sc_frequency = IXP425_UART_FREQ;
sc->sc_type = COM_TYPE_PXA2x0;
if (com_is_console(iot, iobase, &ioh) == 0 &&
bus_space_map(iot, iobase, sa->sa_size, 0, &ioh)) {
aprint_error(": can't map registers\n");
return;
}
COM_INIT_REGS(sc->sc_regs, iot, ioh, iobase);
com_attach_subr(sc);
ixp425_intr_establish(uart_irq[sa->sa_index], IPL_SERIAL, comintr, sc);
}
static void *
nslu2_pci_intr_establish(void *v, pci_intr_handle_t ih, int ipl,
int (*func)(void *), void *arg)
{
return (ixp425_intr_establish(ih, ipl, func, arg));
}
static void
ixsipcom_attach(struct device *parent, struct device *self, void *aux)
{
struct com_softc *sc = (struct com_softc *)self;
struct ixpsip_attach_args *sa = aux;
sc->sc_iot = &ixp425_a4x_bs_tag;
sc->sc_iobase = sa->sa_addr;
sc->sc_frequency = IXP425_UART_FREQ;
sc->sc_type = COM_TYPE_PXA2x0;
if (com_is_console(sc->sc_iot, sc->sc_iobase, &sc->sc_ioh) == 0 &&
bus_space_map(sc->sc_iot, sa->sa_addr, sa->sa_size, 0,
&sc->sc_ioh)) {
printf(": can't map registers\n");
return;
}
com_attach_subr(sc);
ixp425_intr_establish(uart_irq[sa->sa_index], IPL_SERIAL, comintr, sc);
}
/*
* cpu_initclocks:
*
* Initialize the clock and get them going.
*/
void
cpu_initclocks(void)
{
struct ixpclk_softc* sc = ixpclk_sc;
u_int oldirqstate;
#if defined(PERFCTRS)
void *pmu_ih;
#endif
if (hz < 50 || COUNTS_PER_SEC % hz) {
aprint_error("Cannot get %d Hz clock; using 100 Hz\n", hz);
hz = 100;
}
tick = 1000000 / hz; /* number of microseconds between interrupts */
tickfix = 1000000 - (hz * tick);
if (tickfix) {
int ftp;
ftp = min(ffs(tickfix), ffs(hz));
tickfix >>= (ftp - 1);
tickfixinterval = hz >> (ftp - 1);
}
/*
* We only have one timer available; stathz and profhz are
* always left as 0 (the upper-layer clock code deals with
* this situation).
*/
if (stathz != 0)
aprint_error("Cannot get %d Hz statclock\n", stathz);
stathz = 0;
if (profhz != 0)
aprint_error("Cannot get %d Hz profclock\n", profhz);
profhz = 0;
/* Report the clock frequency. */
aprint_normal("clock: hz=%d stathz=%d profhz=%d\n", hz, stathz, profhz);
oldirqstate = disable_interrupts(I32_bit);
/* Hook up the clock interrupt handler. */
clock_ih = ixp425_intr_establish(IXP425_INT_TMR0, IPL_CLOCK,
ixpclk_intr, NULL);
if (clock_ih == NULL)
panic("cpu_initclocks: unable to register timer interrupt");
#if defined(PERFCTRS)
pmu_ih = ixp425_intr_establish(IXP425_INT_XPMU, IPL_STATCLOCK,
xscale_pmc_dispatch, NULL);
if (pmu_ih == NULL)
panic("cpu_initclocks: unable to register timer interrupt");
#endif
/* Set up the new clock parameters. */
/* clear interrupt */
bus_space_write_4(sc->sc_iot, sc->sc_ioh, IXP425_OST_STATUS,
OST_WARM_RESET | OST_WDOG_INT | OST_TS_INT |
OST_TIM1_INT | OST_TIM0_INT);
counts_per_hz = COUNTS_PER_SEC / hz;
/* reload value & Timer enable */
bus_space_write_4(sc->sc_iot, sc->sc_ioh, IXP425_OST_TIM0_RELOAD,
(counts_per_hz & TIMERRELOAD_MASK) | OST_TIMER_EN);
restore_interrupts(oldirqstate);
}
