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); } }