int
zts_enable(void *v)
{
struct zts_softc *sc = v;
if (sc->sc_enabled)
return EBUSY;
timeout_del(&sc->sc_ts_poll);
pxa2x0_gpio_set_function(GPIO_TP_INT_C3K, GPIO_IN);
/* XXX */
if (sc->sc_gh == NULL)
sc->sc_gh = pxa2x0_gpio_intr_establish(GPIO_TP_INT_C3K,
IST_EDGE_FALLING, IPL_TTY, zts_irq, sc,
sc->sc_dev.dv_xname);
else
pxa2x0_gpio_intr_unmask(sc->sc_gh);
/* enable interrupts */
sc->sc_enabled = 1;
sc->sc_running = 1;
sc->sc_buttons = 0;
return 0;
}
static void *
gxpcic_intr_establish(struct pxapcic_socket *so, int level,
int (* ih_fun)(void *), void *ih_arg)
{
return pxa2x0_gpio_intr_establish(so->irqpin, IST_EDGE_FALLING,
level, ih_fun, ih_arg);
}
void
pxapcic_attach(struct pxapcic_softc *sc,
void (*socket_setup_hook)(struct pxapcic_socket *))
{
struct pcmciabus_attach_args paa;
struct pxapcic_socket *so;
int i;
printf(": %d slot%s\n", sc->sc_nslots, sc->sc_nslots==1 ? "" : "s");
if (bus_space_map(sc->sc_iot, PXA2X0_MEMCTL_BASE, PXA2X0_MEMCTL_SIZE,
0, &sc->sc_memctl_ioh)) {
printf("%s: failed to map MEMCTL\n", sc->sc_dev.dv_xname);
return;
}
/* Clear CIT (card present) and set NOS correctly. */
bus_space_write_4(sc->sc_iot, sc->sc_memctl_ioh, MEMCTL_MECR,
sc->sc_nslots == 2 ? MECR_NOS : 0);
/* zaurus: configure slot 1 first to make internal drive be wd0. */
for (i = sc->sc_nslots-1; i >= 0; i--) {
so = &sc->sc_socket[i];
so->sc = sc;
so->socket = i;
so->flags = 0;
socket_setup_hook(so);
paa.paa_busname = "pcmcia";
paa.pct = (pcmcia_chipset_tag_t)&pxapcic_pcmcia_functions;
paa.pch = (pcmcia_chipset_handle_t)so;
paa.iobase = 0;
paa.iosize = 0x4000000;
so->pcmcia = config_found_sm(&sc->sc_dev, &paa,
pxapcic_print, pxapcic_submatch);
pxa2x0_gpio_set_function(sc->sc_irqpin[i], GPIO_IN);
pxa2x0_gpio_set_function(sc->sc_irqcfpin[i], GPIO_IN);
/* Card slot interrupt */
so->irq = pxa2x0_gpio_intr_establish(sc->sc_irqcfpin[i],
IST_EDGE_BOTH, IPL_BIO /* XXX */, pxapcic_intr, so,
sc->sc_dev.dv_xname);
/* GPIO pin for interrupt */
so->irqpin = sc->sc_irqpin[i];
#ifdef DO_CONFIG_PENDING
config_pending_incr();
#endif
kthread_create_deferred(pxapcic_create_event_thread, so);
}
}
void *
pxapcic_intr_establish(pcmcia_chipset_handle_t pch,
struct pcmcia_function *pf, int ipl, int (*fct)(void *), void *arg,
char *name)
{
struct pxapcic_socket *so = pch;
/* XXX need to check if something should be done here */
return (pxa2x0_gpio_intr_establish(so->irqpin, IST_EDGE_FALLING,
ipl, fct, arg, name));
}
void
apm_attach(struct device *parent, struct device *self, void *aux)
{
struct zapm_softc *sc = (struct zapm_softc *)self;
pxa2x0_gpio_set_function(GPIO_AC_IN_C3000, GPIO_IN);
pxa2x0_gpio_set_function(GPIO_CHRG_CO_C3000, GPIO_IN);
pxa2x0_gpio_set_function(GPIO_BATT_COVER_C3000, GPIO_IN);
(void)pxa2x0_gpio_intr_establish(GPIO_AC_IN_C3000,
IST_EDGE_BOTH, IPL_BIO, zapm_acintr, sc, "apm_ac");
(void)pxa2x0_gpio_intr_establish(GPIO_BATT_COVER_C3000,
IST_EDGE_BOTH, IPL_BIO, zapm_bcintr, sc, "apm_bc");
sc->sc_event = APM_NOEVENT;
sc->sc.sc_get_event = zapm_get_event;
sc->sc.sc_power_info = zapm_power_info;
sc->sc.sc_suspend = zapm_suspend;
sc->sc.sc_resume = zapm_resume;
timeout_set(&sc->sc_poll, &zapm_poll, sc);
/* Get initial battery voltage. */
zapm_enable_charging(sc, 0);
if (zapm_ac_on()) {
/* C3000: discharge 100 ms when AC is on. */
scoop_discharge_battery(1);
delay(100000);
}
sc->sc_batt_volt = zapm_batt_volt();
scoop_discharge_battery(0);
pxa2x0_apm_attach_sub(&sc->sc);
#if 0
(void)shutdownhook_establish(zapm_shutdown, NULL);
#endif
cpu_setperf = pxa2x0_setperf;
cpu_cpuspeed = pxa2x0_cpuspeed;
}
static void
pxamci_attach(device_t parent, device_t self, void *aux)
{
struct wzero3mci_softc *sc = device_private(self);
struct pxaip_attach_args *pxa = aux;
const struct wzero3mci_model *model;
sc->sc.sc_dev = self;
model = wzero3mci_lookup();
if (model == NULL) {
aprint_error(": Unknown model.");
return;
}
sc->sc_detect_pin = model->detect_pin;
sc->sc_power_pin = model->power_pin;
/* Establish SD detect interrupt */
if (sc->sc_detect_pin >= 0) {
pxa2x0_gpio_set_function(sc->sc_detect_pin, GPIO_IN);
sc->sc_detect_ih = pxa2x0_gpio_intr_establish(sc->sc_detect_pin,
IST_EDGE_BOTH, IPL_BIO, wzero3mci_intr, sc);
if (sc->sc_detect_ih == NULL) {
aprint_error_dev(self,
"unable to establish card detect interrupt\n");
return;
}
}
sc->sc.sc_tag.cookie = sc;
sc->sc.sc_tag.get_ocr = wzero3mci_get_ocr;
sc->sc.sc_tag.set_power = wzero3mci_set_power;
sc->sc.sc_tag.card_detect = wzero3mci_card_detect;
sc->sc.sc_tag.write_protect = wzero3mci_write_protect;
sc->sc.sc_caps = PMC_CAPS_4BIT;
if (pxamci_attach_sub(self, pxa)) {
aprint_error_dev(self, "unable to attach MMC controller\n");
goto free_intr;
}
if (!pmf_device_register(self, NULL, NULL)) {
aprint_error_dev(self, "couldn't establish power handler\n");
}
return;
free_intr:
pxa2x0_gpio_intr_disestablish(sc->sc_detect_ih);
sc->sc_detect_ih = NULL;
}
int
zts_activate(struct device *self, int act)
{
struct zts_softc *sc = (struct zts_softc *)self;
switch (act) {
case DVACT_SUSPEND:
if (sc->sc_enabled == 0)
break;
sc->sc_running = 0;
#if 0
pxa2x0_gpio_intr_disestablish(sc->sc_gh);
#endif
timeout_del(&sc->sc_ts_poll);
pxa2x0_gpio_intr_mask(sc->sc_gh);
/* Turn off reference voltage but leave ADC on. */
(void)zssp_ic_send(ZSSP_IC_ADS7846, (1 << ADSCTRL_PD1_SH) |
(1 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH));
pxa2x0_gpio_set_function(GPIO_TP_INT_C3K,
GPIO_OUT | GPIO_SET);
break;
case DVACT_RESUME:
if (sc->sc_enabled == 0)
break;
pxa2x0_gpio_set_function(GPIO_TP_INT_C3K, GPIO_IN);
pxa2x0_gpio_intr_mask(sc->sc_gh);
/* Enable automatic low power mode. */
(void)zssp_ic_send(ZSSP_IC_ADS7846,
(4 << ADSCTRL_ADR_SH) | (1 << ADSCTRL_STS_SH));
#if 0
sc->sc_gh = pxa2x0_gpio_intr_establish(GPIO_TP_INT_C3K,
IST_EDGE_FALLING, IPL_TTY, zts_irq, sc,
sc->sc_dev.dv_xname);
#else
pxa2x0_gpio_intr_unmask(sc->sc_gh);
#endif
sc->sc_running = 1;
break;
}
return 0;
}
static int
wzero3kbd_power_intr(void *arg)
{
struct wzero3kbd_softc *sc = (struct wzero3kbd_softc *)arg;
#if defined(KEYTEST) || defined(KEYTEST2) || defined(KEYTEST3) || defined(KEYTEST4)
printf("wzero3kbd_power_intr: status = %s\n",
pxa2x0_gpio_get_bit(sc->sc_power_pin) ? "on" : "off");
#endif
#if defined(KEYTEST)
if (pxa2x0_gpio_get_bit(sc->sc_power_pin)) {
if (sc->sc_test_pin >= 0) {
int orig_pin = sc->sc_test_pin;
pxa2x0_gpio_intr_disestablish(sc->sc_test_ih);
sc->sc_test_ih = NULL;
for (;;) {
if (++sc->sc_test_pin >= PXA270_GPIO_NPINS)
sc->sc_test_pin = 2;
if (sc->sc_test_pin == orig_pin)
break;
if (sc->sc_test_pin != sc->sc_nouse_pin
&& sc->sc_test_pin != sc->sc_nouse_pin2
&& sc->sc_test_pin != sc->sc_nouse_pin3
&& sc->sc_test_pin != sc->sc_key_pin
&& sc->sc_test_pin != sc->sc_power_pin
&& sc->sc_test_pin != sc->sc_reset_pin
&& GPIO_IS_GPIO_IN(pxa2x0_gpio_get_function(sc->sc_test_pin)))
break;
}
if (sc->sc_test_pin != orig_pin) {
printf("GPIO_IN: GPIO pin #%d\n",
sc->sc_test_pin);
sc->sc_test_ih =
pxa2x0_gpio_intr_establish(sc->sc_test_pin,
IST_EDGE_BOTH, IPL_TTY, wzero3kbd_intr2,sc);
} else {
sc->sc_test_pin = -1;
}
}
}
#endif
#if defined(KEYTEST2)
if (pxa2x0_gpio_get_bit(sc->sc_power_pin)) {
sc->sc_enabled ^= 2;
if (sc->sc_enabled & 2) {
printf("print col/row\n");
} else {
printf("keyscan\n");
}
}
#endif
#if defined(KEYTEST4)
if (pxa2x0_gpio_get_bit(sc->sc_power_pin)) {
if (sc->sc_test_pin >= 0) {
int orig_pin = sc->sc_test_pin;
for (;;) {
if (++sc->sc_test_pin >= PXA270_GPIO_NPINS)
sc->sc_test_pin = 2;
if (sc->sc_test_pin == orig_pin)
break;
if (sc->sc_test_pin != sc->sc_nouse_pin
&& sc->sc_test_pin != sc->sc_nouse_pin2
&& sc->sc_test_pin != sc->sc_nouse_pin3
&& sc->sc_test_pin != sc->sc_key_pin
&& sc->sc_test_pin != sc->sc_power_pin
&& sc->sc_test_pin != sc->sc_reset_pin
&& GPIO_IS_GPIO_OUT(pxa2x0_gpio_get_function(sc->sc_test_pin)))
break;
}
if (sc->sc_test_pin != orig_pin) {
printf("GPIO_OUT: GPIO pin #%d\n", sc->sc_test_pin);
} else {
sc->sc_test_pin = -1;
}
}
}
#endif
#if defined(KEYTEST5)
if (pxa2x0_gpio_get_bit(sc->sc_power_pin)) {
sc->sc_bit <<= 1;
if (sc->sc_bit & ~0xff) {
sc->sc_bit = 0x01;
sc->sc_test_pin += 0x4;
if (sc->sc_test_pin >= 0x20) {
sc->sc_test_pin = 0x00;
}
}
printf("CPLD(%#x), mask=%#x\n", sc->sc_test_pin, sc->sc_bit);
}
#endif
pxa2x0_gpio_clear_intr(sc->sc_power_pin);
return 1;
}
static void
wzero3kbd_attach(device_t parent, device_t self, void *aux)
{
struct wzero3kbd_softc *sc = device_private(self);
struct pxaip_attach_args *pxa = (struct pxaip_attach_args *)aux;
struct hpckbd_attach_args haa;
const struct wzero3kbd_model *model;
sc->sc_dev = self;
model = wzero3kbd_lookup();
if (model == NULL) {
aprint_error(": unknown model\n");
return;
}
aprint_normal(": keyboard\n");
aprint_naive("\n");
sc->sc_key_pin = model->key_pin;
sc->sc_power_pin = model->power_pin;
sc->sc_reset_pin = model->reset_pin;
sc->sc_ncolumn = model->ncolumn;
sc->sc_nrow = model->nrow;
sc->sc_iot = pxa->pxa_iot;
if (bus_space_map(sc->sc_iot, PXA2X0_CS2_START, REGMAPSIZE, 0,
&sc->sc_ioh)) {
aprint_error_dev(self, "couldn't map registers.\n");
return;
}
sc->sc_okeystat = malloc(sc->sc_nrow * sc->sc_ncolumn, M_DEVBUF,
M_NOWAIT | M_ZERO);
sc->sc_keystat = malloc(sc->sc_nrow * sc->sc_ncolumn, M_DEVBUF,
M_NOWAIT | M_ZERO);
if (sc->sc_okeystat == NULL || sc->sc_keystat == NULL) {
aprint_error_dev(self, "couldn't alloc memory.\n");
if (sc->sc_okeystat)
free(sc->sc_okeystat, M_DEVBUF);
if (sc->sc_keystat)
free(sc->sc_keystat, M_DEVBUF);
return;
}
sc->sc_if.hii_ctx = sc;
sc->sc_if.hii_establish = wzero3kbd_input_establish;
sc->sc_if.hii_poll = wzero3kbd_poll;
/* Attach console if not using serial. */
if (!(bootinfo->bi_cnuse & BI_CNUSE_SERIAL))
hpckbd_cnattach(&sc->sc_if);
/* Install interrupt handler. */
if (sc->sc_key_pin >= 0) {
pxa2x0_gpio_set_function(sc->sc_key_pin, GPIO_IN);
sc->sc_key_ih = pxa2x0_gpio_intr_establish(sc->sc_key_pin,
IST_EDGE_BOTH, IPL_TTY, wzero3kbd_intr, sc);
if (sc->sc_key_ih == NULL) {
aprint_error_dev(sc->sc_dev,
"couldn't establish key interrupt\n");
}
} else {
sc->sc_interval = KEY_INTERVAL / (1000 / hz);
if (sc->sc_interval < 1)
sc->sc_interval = 1;
callout_init(&sc->sc_keyscan_ch, 0);
callout_reset(&sc->sc_keyscan_ch, sc->sc_interval,
wzero3kbd_tick, sc);
}
/* power key */
if (sc->sc_power_pin >= 0) {
pxa2x0_gpio_set_function(sc->sc_power_pin, GPIO_IN);
sc->sc_power_ih = pxa2x0_gpio_intr_establish(
sc->sc_power_pin, IST_EDGE_BOTH, IPL_TTY,
wzero3kbd_power_intr, sc);
if (sc->sc_power_ih == NULL) {
aprint_error_dev(sc->sc_dev,
"couldn't establish power key interrupt\n");
}
}
/* reset button */
if (sc->sc_reset_pin >= 0) {
pxa2x0_gpio_set_function(sc->sc_reset_pin, GPIO_IN);
sc->sc_reset_ih = pxa2x0_gpio_intr_establish(
sc->sc_reset_pin, IST_EDGE_BOTH, IPL_TTY,
wzero3kbd_reset_intr, sc);
if (sc->sc_reset_ih == NULL) {
aprint_error_dev(sc->sc_dev,
"couldn't establish reset key interrupt\n");
}
sc->sc_smpsw.smpsw_name = device_xname(self);
sc->sc_smpsw.smpsw_type = PSWITCH_TYPE_RESET;
if (sysmon_pswitch_register(&sc->sc_smpsw) != 0) {
aprint_error_dev(sc->sc_dev,
"unable to register reset event handler\n");
}
}
/* Attach hpckbd. */
haa.haa_ic = &sc->sc_if;
config_found(self, &haa, hpckbd_print);
#if defined(KEYTEST) || defined(KEYTEST2) || defined(KEYTEST3) || defined(KEYTEST4) || defined(KEYTEST5)
sc->sc_test_ih = NULL;
sc->sc_test_pin = -1;
sc->sc_nouse_pin = -1;
sc->sc_nouse_pin2 = -1;
sc->sc_nouse_pin3 = -1;
sc->sc_bit = 0x01;
if (platid_match(&platid, &platid_mask_MACH_SHARP_WZERO3_WS003SH)
|| platid_match(&platid, &platid_mask_MACH_SHARP_WZERO3_WS004SH)) {
sc->sc_nouse_pin = GPIO_WS003SH_SD_DETECT; /* SD_DETECT */
sc->sc_nouse_pin2 = 86; /* Vsync? */
sc->sc_nouse_pin3 = 89; /* RESET? */
}
if (platid_match(&platid, &platid_mask_MACH_SHARP_WZERO3_WS007SH)) {
sc->sc_nouse_pin = GPIO_WS007SH_SD_DETECT; /* SD_DETECT */
sc->sc_nouse_pin2 = 77; /* Vsync? */
}
if (platid_match(&platid, &platid_mask_MACH_SHARP_WZERO3_WS011SH)) {
sc->sc_nouse_pin = GPIO_WS011SH_SD_DETECT; /* SD_DETECT */
sc->sc_nouse_pin2 = 77; /* Vsync? */
}
if (platid_match(&platid, &platid_mask_MACH_SHARP_WZERO3_WS020SH)) {
sc->sc_nouse_pin = GPIO_WS020SH_SD_DETECT; /* SD_DETECT */
sc->sc_nouse_pin2 = 77; /* Vsync? */
}
#ifdef KEYTEST
for (sc->sc_test_pin = 2; sc->sc_test_pin < PXA270_GPIO_NPINS; sc->sc_test_pin++) {
if (sc->sc_test_pin != sc->sc_nouse_pin
&& sc->sc_test_pin != sc->sc_nouse_pin2
&& sc->sc_test_pin != sc->sc_nouse_pin3
&& sc->sc_test_pin != sc->sc_key_pin
&& sc->sc_test_pin != sc->sc_power_pin
&& sc->sc_test_pin != sc->sc_reset_pin
&& GPIO_IS_GPIO_IN(pxa2x0_gpio_get_function(sc->sc_test_pin)))
break;
}
if (sc->sc_test_pin < PXA270_GPIO_NPINS) {
printf("GPIO_IN: GPIO pin #%d\n", sc->sc_test_pin);
sc->sc_test_ih = pxa2x0_gpio_intr_establish(sc->sc_test_pin,
IST_EDGE_BOTH, IPL_TTY, wzero3kbd_intr2, sc);
} else {
sc->sc_test_pin = -1;
}
#endif
#ifdef KEYTEST3
{
int i;
printf("pin: ");
for (i = 0; i < PXA270_GPIO_NPINS; i++) {
if (i == sc->sc_nouse_pin
|| i == sc->sc_nouse_pin2
|| i == sc->sc_nouse_pin3
|| i == sc->sc_key_pin
|| i == sc->sc_power_pin
|| i == sc->sc_reset_pin)
continue;
printf("%d, ", i);
if (GPIO_IS_GPIO_IN(pxa2x0_gpio_get_function(i))) {
pxa2x0_gpio_intr_establish(i, IST_EDGE_BOTH,
IPL_TTY, wzero3kbd_intr3, (void *)(long)i);
}
}
}
#endif
#ifdef KEYTEST4
for (sc->sc_test_pin = 2; sc->sc_test_pin < PXA270_GPIO_NPINS; sc->sc_test_pin++) {
if (sc->sc_test_pin != sc->sc_nouse_pin
&& sc->sc_test_pin != sc->sc_nouse_pin2
&& sc->sc_test_pin != sc->sc_nouse_pin3
&& sc->sc_test_pin != sc->sc_key_pin
&& sc->sc_test_pin != sc->sc_power_pin
&& sc->sc_test_pin != sc->sc_reset_pin
&& GPIO_IS_GPIO_OUT(pxa2x0_gpio_get_function(sc->sc_test_pin)))
break;
}
if (sc->sc_test_pin < PXA270_GPIO_NPINS) {
printf("GPIO_OUT: GPIO pin #%d\n", sc->sc_test_pin);
} else {
sc->sc_test_pin = -1;
}
#endif
#ifdef KEYTEST5
sc->sc_test_pin = 0x00;
sc->sc_bit = 0x01;
#endif
#endif
}
static void
zkbd_attach(device_t parent, device_t self, void *aux)
{
struct zkbd_softc *sc = device_private(self);
struct wskbddev_attach_args a;
int pin, i;
sc->sc_dev = self;
zkbd_sc = sc;
aprint_normal("\n");
aprint_naive("\n");
sc->sc_polling = 0;
#ifdef WSDISPLAY_COMPAT_RAWKBD
sc->sc_rawkbd = 0;
#endif
callout_init(&sc->sc_roll_to, 0);
callout_setfunc(&sc->sc_roll_to, zkbd_poll, sc);
#ifdef WSDISPLAY_COMPAT_RAWKBD
callout_init(&sc->sc_rawrepeat_ch, 0);
callout_setfunc(&sc->sc_rawrepeat_ch, zkbd_rawrepeat, sc);
#endif
if (ZAURUS_ISC1000 || ZAURUS_ISC3000) {
sc->sc_sense_array = gpio_sense_pins_c3000;
sc->sc_strobe_array = gpio_strobe_pins_c3000;
sc->sc_nsense = __arraycount(gpio_sense_pins_c3000);
sc->sc_nstrobe = __arraycount(gpio_strobe_pins_c3000);
sc->sc_stuck_keys = stuck_keys_c3000;
sc->sc_nstuck = __arraycount(stuck_keys_c3000);
sc->sc_maxkbdcol = 10;
sc->sc_onkey_pin = 95;
sc->sc_sync_pin = 16;
sc->sc_swa_pin = 97;
sc->sc_swb_pin = 96;
sc->sc_keymapdata = &zkbd_keymapdata;
#ifdef WSDISPLAY_COMPAT_RAWKBD
sc->sc_xt_keymap = xt_keymap;
#endif
} else if (ZAURUS_ISC860) {
sc->sc_sense_array = gpio_sense_pins_c860;
sc->sc_strobe_array = gpio_strobe_pins_c860;
sc->sc_nsense = __arraycount(gpio_sense_pins_c860);
sc->sc_nstrobe = __arraycount(gpio_strobe_pins_c860);
sc->sc_stuck_keys = stuck_keys_c860;
sc->sc_nstuck = __arraycount(stuck_keys_c860);
sc->sc_maxkbdcol = 0;
sc->sc_onkey_pin = -1;
sc->sc_sync_pin = -1;
sc->sc_swa_pin = -1;
sc->sc_swb_pin = -1;
sc->sc_keymapdata = &zkbd_keymapdata_c860;
#ifdef WSDISPLAY_COMPAT_RAWKBD
sc->sc_xt_keymap = xt_keymap_c860;
#endif
} else {
/* XXX */
return;
}
if (!pmf_device_register(sc->sc_dev, NULL, zkbd_resume))
aprint_error_dev(sc->sc_dev,
"couldn't establish power handler\n");
sc->sc_okeystate = malloc(sc->sc_nsense * sc->sc_nstrobe,
M_DEVBUF, M_NOWAIT);
memset(sc->sc_okeystate, 0, sc->sc_nsense * sc->sc_nstrobe);
sc->sc_keystate = malloc(sc->sc_nsense * sc->sc_nstrobe,
M_DEVBUF, M_NOWAIT);
memset(sc->sc_keystate, 0, sc->sc_nsense * sc->sc_nstrobe);
/* set all the strobe bits */
for (i = 0; i < sc->sc_nstrobe; i++) {
pin = sc->sc_strobe_array[i];
if (pin == -1)
continue;
pxa2x0_gpio_set_function(pin, GPIO_SET|GPIO_OUT);
}
/* set all the sense bits */
for (i = 0; i < sc->sc_nsense; i++) {
pin = sc->sc_sense_array[i];
if (pin == -1)
continue;
pxa2x0_gpio_set_function(pin, GPIO_IN);
if (ZAURUS_ISC1000 || ZAURUS_ISC3000) {
pxa2x0_gpio_intr_establish(pin, IST_EDGE_BOTH,
IPL_TTY, zkbd_irq_c3000, sc);
} else if (ZAURUS_ISC860) {
pxa2x0_gpio_intr_establish(pin, IST_EDGE_RISING,
IPL_TTY, zkbd_irq_c860, sc);
}
}
if (sc->sc_onkey_pin >= 0)
pxa2x0_gpio_intr_establish(sc->sc_onkey_pin, IST_EDGE_BOTH,
IPL_TTY, zkbd_on, sc);
if (sc->sc_sync_pin >= 0)
pxa2x0_gpio_intr_establish(sc->sc_sync_pin, IST_EDGE_RISING,
IPL_TTY, zkbd_sync, sc);
if (sc->sc_swa_pin >= 0)
pxa2x0_gpio_intr_establish(sc->sc_swa_pin, IST_EDGE_BOTH,
IPL_TTY, zkbd_hinge, sc);
if (sc->sc_swb_pin >= 0)
pxa2x0_gpio_intr_establish(sc->sc_swb_pin, IST_EDGE_BOTH,
IPL_TTY, zkbd_hinge, sc);
if (glass_console) {
wskbd_cnattach(&zkbd_consops, sc, sc->sc_keymapdata);
a.console = 1;
} else {
a.console = 0;
}
a.keymap = sc->sc_keymapdata;
a.accessops = &zkbd_accessops;
a.accesscookie = sc;
zkbd_hinge(sc); /* to initialize sc_hinge */
sc->sc_wskbddev = config_found(self, &a, wskbddevprint);
}
static void
zapm_attach(device_t parent, device_t self, void *aux)
{
struct zapm_softc *sc = device_private(self);
struct apmdev_attach_args aaa;
sc->sc_dev = self;
aprint_normal(": pseudo power management module\n");
aprint_naive("\n");
/* machine-depent part */
callout_init(&sc->sc_cyclic_poll, 0);
callout_setfunc(&sc->sc_cyclic_poll, zapm_cyclic, sc);
callout_init(&sc->sc_discharge_poll, 0);
callout_setfunc(&sc->sc_discharge_poll, zapm_poll, sc);
mutex_init(&sc->sc_mtx, MUTEX_DEFAULT, IPL_NONE);
if (ZAURUS_ISC1000 || ZAURUS_ISC3000) {
sc->sc_ac_detect_pin = GPIO_AC_IN_C3000;
sc->sc_batt_cover_pin = GPIO_BATT_COVER_C3000;
sc->sc_charge_comp_pin = GPIO_CHRG_CO_C3000;
} else {
/* XXX */
return;
}
pxa2x0_gpio_set_function(sc->sc_ac_detect_pin, GPIO_IN);
pxa2x0_gpio_set_function(sc->sc_charge_comp_pin, GPIO_IN);
pxa2x0_gpio_set_function(sc->sc_batt_cover_pin, GPIO_IN);
(void)pxa2x0_gpio_intr_establish(sc->sc_ac_detect_pin,
IST_EDGE_BOTH, IPL_BIO, zapm_acintr, sc);
(void)pxa2x0_gpio_intr_establish(sc->sc_charge_comp_pin,
IST_EDGE_BOTH, IPL_BIO, zapm_bcintr, sc);
/* machine-independent part */
sc->events = 0;
sc->power_state = APM_SYS_READY;
sc->battery_state = APM_BATT_FLAG_UNKNOWN;
sc->ac_state = APM_AC_UNKNOWN;
sc->battery_life = APM_BATT_LIFE_UNKNOWN;
sc->minutes_left = 0;
sc->sc_standby_hook = config_hook(CONFIG_HOOK_PMEVENT,
CONFIG_HOOK_PMEVENT_STANDBYREQ,
CONFIG_HOOK_EXCLUSIVE,
zapm_hook, sc);
sc->sc_suspend_hook = config_hook(CONFIG_HOOK_PMEVENT,
CONFIG_HOOK_PMEVENT_SUSPENDREQ,
CONFIG_HOOK_EXCLUSIVE,
zapm_hook, sc);
sc->sc_battery_hook = config_hook(CONFIG_HOOK_PMEVENT,
CONFIG_HOOK_PMEVENT_BATTERY,
CONFIG_HOOK_SHARE,
zapm_hook, sc);
sc->sc_ac_hook = config_hook(CONFIG_HOOK_PMEVENT,
CONFIG_HOOK_PMEVENT_AC,
CONFIG_HOOK_SHARE,
zapm_hook, sc);
aaa.accessops = &zapm_accessops;
aaa.accesscookie = sc;
aaa.apm_detail = 0x0102;
sc->sc_apmdev = config_found_ia(self, "apmdevif", &aaa, apmprint);
if (sc->sc_apmdev != NULL) {
zapm_poll1(sc, 0);
callout_schedule(&sc->sc_cyclic_poll, CYCLIC_TIME);
}
}
