static int
btnmgr_hook(void *ctx, int type, long id, void *msg)
{
struct btnmgr_softc *sc = ctx;
DPRINTF(("%s button: %s\n", btnmgr_name(id), msg ? "ON" : "OFF"));
if (button_config[id].kevent) {
u_int evtype;
evtype = msg ? WSCONS_EVENT_KEY_DOWN : WSCONS_EVENT_KEY_UP;
#ifdef WSDISPLAY_COMPAT_RAWKBD
if (sc->sc_rawkbd) {
int n;
u_char data[16];
n = pckbd_encode(evtype, button_config[id].keycode,
data);
wskbd_rawinput(sc->sc_wskbddev, data, n);
} else
#endif
wskbd_input(sc->sc_wskbddev, evtype,
button_config[id].keycode);
}
if (id == CONFIG_HOOK_BUTTONEVENT_POWER && msg)
config_hook_call(CONFIG_HOOK_PMEVENT,
CONFIG_HOOK_PMEVENT_SUSPENDREQ, NULL);
else if (id == CONFIG_HOOK_BUTTONEVENT_COVER)
config_hook_call(CONFIG_HOOK_POWERCONTROL,
CONFIG_HOOK_POWERCONTROL_LCDLIGHT, (void*)(msg ? 0: 1));
return (0);
}
static int
hpcapm_get_powstat(void *scx, u_int batteryid, struct apm_power_info *pinfo)
{
struct apmhpc_softc *sc;
int val;
sc = scx;
pinfo->nbattery = 0;
pinfo->batteryid = 0;
pinfo->minutes_valid = 0;
pinfo->minutes_left = 0;
pinfo->battery_state = APM_BATT_UNKNOWN; /* XXX: ignored */
if (config_hook_call(CONFIG_HOOK_GET,
CONFIG_HOOK_ACADAPTER, &val) != -1)
pinfo->ac_state = val;
else
pinfo->ac_state = sc->ac_state;
if (config_hook_call(CONFIG_HOOK_GET,
CONFIG_HOOK_CHARGE, &val) != -1)
pinfo->battery_flags = val;
else
pinfo->battery_flags = sc->battery_flags;
if (config_hook_call(CONFIG_HOOK_GET,
CONFIG_HOOK_BATTERYVAL, &val) != -1)
pinfo->battery_life = val;
else
pinfo->battery_life = sc->battery_life;
return (0);
}
static int
hpcapm_set_powstate(void *scx, u_int devid, u_int powstat)
{
struct apmhpc_softc *sc;
int s;
sc = scx;
if (devid != APM_DEV_ALLDEVS)
return APM_ERR_UNRECOG_DEV;
switch (powstat) {
case APM_SYS_READY:
DPRINTF(("hpcapm: set power state READY\n"));
sc->power_state = APM_SYS_READY;
break;
case APM_SYS_STANDBY:
DPRINTF(("hpcapm: set power state STANDBY\n"));
s = splhigh();
config_hook_call(CONFIG_HOOK_PMEVENT,
CONFIG_HOOK_PMEVENT_HARDPOWER,
(void *)PWR_STANDBY);
sc->power_state = APM_SYS_STANDBY;
machine_standby();
config_hook_call_reverse(CONFIG_HOOK_PMEVENT,
CONFIG_HOOK_PMEVENT_HARDPOWER,
(void *)PWR_RESUME);
DPRINTF(("hpcapm: resume\n"));
splx(s);
break;
case APM_SYS_SUSPEND:
DPRINTF(("hpcapm: set power state SUSPEND...\n"));
s = splhigh();
config_hook_call(CONFIG_HOOK_PMEVENT,
CONFIG_HOOK_PMEVENT_HARDPOWER,
(void *)PWR_SUSPEND);
sc->power_state = APM_SYS_SUSPEND;
machine_sleep();
config_hook_call_reverse(CONFIG_HOOK_PMEVENT,
CONFIG_HOOK_PMEVENT_HARDPOWER,
(void *)PWR_RESUME);
DPRINTF(("hpcapm: resume\n"));
splx(s);
break;
case APM_SYS_OFF:
DPRINTF(("hpcapm: set power state OFF\n"));
sc->power_state = APM_SYS_OFF;
break;
case APM_LASTREQ_INPROG:
/*DPRINTF(("hpcapm: set power state INPROG\n"));
*/
break;
case APM_LASTREQ_REJECTED:
DPRINTF(("hpcapm: set power state REJECTED\n"));
break;
}
return (0);
}
int
j720lcd_power(void *ctx, int type, long id, void *msg)
{
struct sed1356_softc *sc = ctx;
struct sa11x0_softc *psc = sc->sc_parent;
uint32_t reg;
int val;
if (type != CONFIG_HOOK_POWERCONTROL ||
id != CONFIG_HOOK_POWERCONTROL_LCDLIGHT)
return 0;
sed1356_init_brightness(sc, 0);
sed1356_init_contrast(sc, 0);
if (msg) {
bus_space_write_1(sc->sc_iot, sc->sc_regh, 0x1f0, 0);
reg = bus_space_read_4(psc->sc_iot, psc->sc_ppch, SAPPC_PSR);
reg |= 0x1;
bus_space_write_4(psc->sc_iot, psc->sc_ppch, SAPPC_PSR, reg);
delay(50000);
val = sc->sc_contrast;
config_hook_call(CONFIG_HOOK_SET, CONFIG_HOOK_CONTRAST, &val);
delay(100000);
reg = bus_space_read_4(psc->sc_iot, psc->sc_ppch, SAPPC_PSR);
reg |= 0x4;
bus_space_write_4(psc->sc_iot, psc->sc_ppch, SAPPC_PSR, reg);
val = sc->sc_brightness;
config_hook_call(CONFIG_HOOK_SET, CONFIG_HOOK_BRIGHTNESS, &val);
reg = bus_space_read_4(psc->sc_iot, psc->sc_ppch, SAPPC_PSR);
reg |= 0x2;
bus_space_write_4(psc->sc_iot, psc->sc_ppch, SAPPC_PSR, reg);
} else {
reg = bus_space_read_4(psc->sc_iot, psc->sc_ppch, SAPPC_PSR);
reg &= ~0x2;
bus_space_write_4(psc->sc_iot, psc->sc_ppch, SAPPC_PSR, reg);
reg &= ~0x4;
bus_space_write_4(psc->sc_iot, psc->sc_ppch, SAPPC_PSR, reg);
delay(100000);
val = -2;
config_hook_call(CONFIG_HOOK_SET, CONFIG_HOOK_BRIGHTNESS, &val);
bus_space_write_1(sc->sc_iot, sc->sc_regh, 0x1f0, 1);
delay(100000);
reg = bus_space_read_4(psc->sc_iot, psc->sc_ppch, SAPPC_PSR);
reg &= ~0x1;
bus_space_write_4(psc->sc_iot, psc->sc_ppch, SAPPC_PSR, reg);
}
return 1;
}
void
mq200_set_contrast(struct mq200_softc *sc, int val)
{
sc->sc_contrast = val;
config_hook_call(CONFIG_HOOK_SET, CONFIG_HOOK_CONTRAST, &val);
if (config_hook_call(CONFIG_HOOK_GET,
CONFIG_HOOK_CONTRAST, &val) != -1) {
sc->sc_contrast = val;
}
}
void
mq200_set_brightness(struct mq200_softc *sc, int val)
{
sc->sc_brightness = val;
config_hook_call(CONFIG_HOOK_SET, CONFIG_HOOK_BRIGHTNESS, &val);
if (config_hook_call(CONFIG_HOOK_GET,
CONFIG_HOOK_BRIGHTNESS, &val) != -1) {
sc->sc_brightness = val;
}
}
void
mq200_init_backlight(struct mq200_softc *sc, int inattach)
{
int val = -1;
if (sc->sc_lcd_inited&BACKLIGHT_INITED)
return;
if (config_hook_call(CONFIG_HOOK_GET,
CONFIG_HOOK_POWER_LCDLIGHT, &val) != -1) {
/* we can get real light state */
VPRINTF("init_backlight: real backlight=%d\n", val);
if (val == 0)
sc->sc_powerstate &= ~PWRSTAT_BACKLIGHT;
else
sc->sc_powerstate |= PWRSTAT_BACKLIGHT;
sc->sc_lcd_inited |= BACKLIGHT_INITED;
} else if (inattach) {
/*
we cannot get real light state in attach time
because light device not yet attached.
we will retry in !inattach.
temporary assume light is on.
*/
sc->sc_powerstate |= PWRSTAT_BACKLIGHT;
} else {
/* we cannot get real light state, so work by myself state */
sc->sc_lcd_inited |= BACKLIGHT_INITED;
}
}
void
j720kbdsoft(void *arg)
{
struct j720ssp_softc *sc = arg;
int s, type, value;
char buf[9], *p;
j720kbd_read(sc, buf);
for(p = buf; *p; p++) {
type = *p & 0x80 ? WSCONS_EVENT_KEY_UP :
WSCONS_EVENT_KEY_DOWN;
value = *p & 0x7f;
s = spltty();
wskbd_input(sc->sc_wskbddev, type, value);
splx(s);
if (type == WSCONS_EVENT_KEY_DOWN &&
value == 0x7f) {
j720ssp_powerstate = ! j720ssp_powerstate;
config_hook_call(CONFIG_HOOK_POWERCONTROL,
CONFIG_HOOK_POWERCONTROL_LCDLIGHT,
(void *)j720ssp_powerstate);
}
}
return;
}
static void
sed1356_update_powerstate(struct sed1356_softc *sc, int updates)
{
if (updates & PWRSTAT_LCD)
config_hook_call(CONFIG_HOOK_POWERCONTROL,
CONFIG_HOOK_POWERCONTROL_LCD,
(void *)!(sc->sc_powerstate &
(PWRSTAT_VIDEOOFF|PWRSTAT_SUSPEND)));
if (updates & PWRSTAT_BACKLIGHT)
config_hook_call(CONFIG_HOOK_POWERCONTROL,
CONFIG_HOOK_POWERCONTROL_LCDLIGHT,
(void *)(!(sc->sc_powerstate &
(PWRSTAT_VIDEOOFF|PWRSTAT_SUSPEND)) &&
(sc->sc_powerstate & PWRSTAT_BACKLIGHT)));
}
void
mq200_init_brightness(struct mq200_softc *sc, int inattach)
{
int val = -1;
if (sc->sc_lcd_inited&BRIGHTNESS_INITED)
return;
VPRINTF("init_brightness\n");
if (config_hook_call(CONFIG_HOOK_GET,
CONFIG_HOOK_BRIGHTNESS_MAX, &val) != -1) {
/* we can get real brightness max */
VPRINTF("init_brightness: real brightness max=%d\n", val);
sc->sc_max_brightness = val;
val = -1;
if (config_hook_call(CONFIG_HOOK_GET,
CONFIG_HOOK_BRIGHTNESS, &val) != -1) {
/* we can get real brightness */
VPRINTF("init_brightness: real brightness=%d\n", val);
sc->sc_brightness_save = sc->sc_brightness = val;
} else {
sc->sc_brightness_save =
sc->sc_brightness = sc->sc_max_brightness;
}
sc->sc_lcd_inited |= BRIGHTNESS_INITED;
} else if (inattach) {
/*
we cannot get real brightness in attach time
because brightness device not yet attached.
we will retry in !inattach.
*/
sc->sc_max_brightness = -1;
sc->sc_brightness = -1;
sc->sc_brightness_save = -1;
} else {
/* we cannot get real brightness */
sc->sc_lcd_inited |= BRIGHTNESS_INITED;
}
return;
}
static int
zapm_get_powstat(void *v, u_int batteryid, struct apm_power_info *pinfo)
{
struct zapm_softc *sc = (struct zapm_softc *)v;
int val;
if (config_hook_call(CONFIG_HOOK_GET,
CONFIG_HOOK_ACADAPTER, &val) != -1)
pinfo->ac_state = val;
else
pinfo->ac_state = sc->ac_state;
DPRINTF(("zapm: pinfo->ac_state: %d\n", pinfo->ac_state));
if (config_hook_call(CONFIG_HOOK_GET,
CONFIG_HOOK_CHARGE, &val) != -1)
pinfo->battery_state = val;
else {
DPRINTF(("zapm: sc->battery_state: %#x\n", sc->battery_state));
if (sc->battery_state & APM_BATT_FLAG_CHARGING)
pinfo->battery_flags = APM_BATT_FLAG_CHARGING;
else if (sc->battery_state & APM_BATT_FLAG_CRITICAL)
pinfo->battery_flags = APM_BATT_FLAG_CRITICAL;
else if (sc->battery_state & APM_BATT_FLAG_LOW)
pinfo->battery_flags = APM_BATT_FLAG_LOW;
else if (sc->battery_state & APM_BATT_FLAG_HIGH)
pinfo->battery_flags = APM_BATT_FLAG_HIGH;
else
pinfo->battery_flags = APM_BATT_FLAG_UNKNOWN;
}
DPRINTF(("zapm: pinfo->battery_flags: %#x\n", pinfo->battery_flags));
if (config_hook_call(CONFIG_HOOK_GET,
CONFIG_HOOK_BATTERYVAL, &val) != -1)
pinfo->battery_life = val;
else
pinfo->battery_life = sc->battery_life;
DPRINTF(("zapm: pinfo->battery_life: %d\n", pinfo->battery_life));
return 0;
}
void
mq200_init_contrast(struct mq200_softc *sc, int inattach)
{
int val = -1;
if (sc->sc_lcd_inited&CONTRAST_INITED)
return;
VPRINTF("init_contrast\n");
if (config_hook_call(CONFIG_HOOK_GET,
CONFIG_HOOK_CONTRAST_MAX, &val) != -1) {
/* we can get real contrast max */
VPRINTF("init_contrast: real contrast max=%d\n", val);
sc->sc_max_contrast = val;
val = -1;
if (config_hook_call(CONFIG_HOOK_GET,
CONFIG_HOOK_CONTRAST, &val) != -1) {
/* we can get real contrast */
VPRINTF("init_contrast: real contrast=%d\n", val);
sc->sc_contrast = val;
} else {
sc->sc_contrast = sc->sc_max_contrast;
}
sc->sc_lcd_inited |= CONTRAST_INITED;
} else if (inattach) {
/*
we cannot get real contrast in attach time
because contrast device not yet attached.
we will retry in !inattach.
*/
sc->sc_max_contrast = -1;
sc->sc_contrast = -1;
} else {
/* we cannot get real contrast */
sc->sc_lcd_inited |= CONTRAST_INITED;
}
return;
}
static void
j720lcd_attach(device_t parent, device_t self, void *aux)
{
struct j720lcd_softc *sc = device_private(self);
int brightness, contrast;
sc->sc_dev = self;
sc->sc_ssp = device_private(parent);
/* LCD brightness hooks. */
config_hook(CONFIG_HOOK_SET, CONFIG_HOOK_BRIGHTNESS,
CONFIG_HOOK_SHARE, j720lcd_param, sc);
config_hook(CONFIG_HOOK_GET, CONFIG_HOOK_BRIGHTNESS,
CONFIG_HOOK_SHARE, j720lcd_param, sc);
config_hook(CONFIG_HOOK_GET, CONFIG_HOOK_BRIGHTNESS_MAX,
CONFIG_HOOK_SHARE, j720lcd_param, sc);
/* LCD contrast hooks. */
config_hook(CONFIG_HOOK_SET, CONFIG_HOOK_CONTRAST,
CONFIG_HOOK_SHARE, j720lcd_param, sc);
config_hook(CONFIG_HOOK_GET, CONFIG_HOOK_CONTRAST,
CONFIG_HOOK_SHARE, j720lcd_param, sc);
config_hook(CONFIG_HOOK_GET, CONFIG_HOOK_CONTRAST_MAX,
CONFIG_HOOK_SHARE, j720lcd_param, sc);
/* LCD power hook. */
#if 0
config_hook(CONFIG_HOOK_POWERCONTROL,
CONFIG_HOOK_POWERCONTROL_LCDLIGHT,
CONFIG_HOOK_SHARE, j720lcd_power, sc);
#endif
/* Get default brightness/contrast values. */
config_hook_call(CONFIG_HOOK_GET, CONFIG_HOOK_BRIGHTNESS, &brightness);
config_hook_call(CONFIG_HOOK_GET, CONFIG_HOOK_CONTRAST, &contrast);
aprint_normal(": brightness %d, contrast %d\n", brightness, contrast);
}
/*
* PMU interrupt handler.
* XXX
*
* In the following interrupt routine we should actually DO something
* with the knowledge that we've gained. For now we just report it.
*/
int
vrpmu_intr(void *arg)
{
struct vrpmu_softc *sc = arg;
unsigned int intstat1;
unsigned int intstat2;
intstat1 = vrpmu_read(sc, PMUINT_REG_W);
/* clear interrupt status */
vrpmu_write(sc, PMUINT_REG_W, intstat1);
intstat2 = vrpmu_read(sc, PMUINT2_REG_W);
/* clear interrupt status */
vrpmu_write(sc, PMUINT2_REG_W, intstat2);
DDUMP_INTR2(DEBUG_INTR, intstat1, intstat2);
if (intstat1 & PMUINT_GPIO3)
;
if (intstat1 & PMUINT_GPIO2)
;
if (intstat1 & PMUINT_GPIO1)
;
if (intstat1 & PMUINT_GPIO0)
;
if (intstat1 & PMUINT_RTC)
;
if (intstat1 & PMUINT_BATT)
config_hook_call(CONFIG_HOOK_PMEVENT,
CONFIG_HOOK_PMEVENT_SUSPENDREQ, NULL);
if (intstat1 & PMUINT_TIMOUTRST)
;
if (intstat1 & PMUINT_RTCRST)
;
if (intstat1 & PMUINT_RSTSWRST)
;
if (intstat1 & PMUINT_DMSWRST)
;
if (intstat1 & PMUINT_BATTINTR)
config_hook_call(CONFIG_HOOK_PMEVENT,
CONFIG_HOOK_PMEVENT_SUSPENDREQ, NULL);
if (intstat1 & PMUINT_POWERSW) {
/*
* you can't detect when the button is released
*/
config_hook_call(CONFIG_HOOK_BUTTONEVENT,
CONFIG_HOOK_BUTTONEVENT_POWER,
(void*)1 /* on */);
config_hook_call(CONFIG_HOOK_BUTTONEVENT,
CONFIG_HOOK_BUTTONEVENT_POWER,
(void*)0 /* off */);
}
if (intstat2 & PMUINT_GPIO12)
;
if (intstat2 & PMUINT_GPIO11)
;
if (intstat2 & PMUINT_GPIO10)
;
if (intstat2 & PMUINT_GPIO9)
;
return (0);
}
/*
* Poll power-management related GPIO inputs, update battery life
* in softc, and/or control battery charging.
*/
static void
zapm_poll1(void *v, int do_suspend)
{
struct zapm_softc *sc = (struct zapm_softc *)v;
int ac_state;
int bc_lock;
int charging;
int volt;
if (!mutex_tryenter(&sc->sc_mtx))
return;
ac_state = zapm_get_ac_state(sc);
bc_lock = zapm_get_battery_compartment_state(sc);
/* Stop discharging. */
if (sc->discharging) {
sc->discharging = 0;
charging = 0;
volt = zapm_get_battery_volt();
DPRINTF(("zapm_poll: discharge off volt %d\n", volt));
} else {
charging = sc->battery_state & APM_BATT_FLAG_CHARGING;
volt = sc->battery_volt;
}
/* Start or stop charging as necessary. */
if (ac_state && bc_lock) {
int charge_completed = zapm_charge_complete(sc);
if (charging) {
if (charge_completed) {
DPRINTF(("zapm_poll: battery is full\n"));
charging = 0;
zapm_set_charging(sc, 0);
}
} else if (!charge_completed) {
charging = APM_BATT_FLAG_CHARGING;
volt = zapm_get_battery_volt();
zapm_set_charging(sc, 1);
DPRINTF(("zapm_poll: start charging volt %d\n", volt));
}
} else {
if (charging) {
charging = 0;
zapm_set_charging(sc, 0);
timerclear(&sc->sc_lastbattchk);
DPRINTF(("zapm_poll: stop charging\n"));
}
sc->battery_full_cnt = 0;
}
/*
* Restart charging once in a while. Discharge a few milliseconds
* before updating the voltage in our softc if A/C is connected.
*/
if (bc_lock && ratecheck(&sc->sc_lastbattchk, &zapm_battchkrate)) {
if (do_suspend && sc->suspended) {
/* XXX */
#if 0
DPRINTF(("zapm_poll: suspended %lu %lu\n",
sc->lastbattchk.tv_sec,
pxa2x0_rtc_getsecs()));
if (charging) {
zapm_set_charging(sc, 0);
delay(15000);
zapm_set_charging(sc, 1);
pxa2x0_rtc_setalarm(pxa2x0_rtc_getsecs() +
zapm_battchkrate.tv_sec + 1);
}
#endif
} else if (ac_state && sc->battery_full_cnt == 0) {
DPRINTF(("zapm_poll: discharge on\n"));
if (charging)
zapm_set_charging(sc, 0);
sc->discharging = 1;
if (ZAURUS_ISC1000 || ZAURUS_ISC3000)
scoop_discharge_battery(1);
callout_schedule(&sc->sc_discharge_poll,
DISCHARGE_TIMEOUT);
} else if (!ac_state) {
volt = zapm_get_battery_volt();
DPRINTF(("zapm_poll: volt %d\n", volt));
}
}
/* Update the cached power state in our softc. */
if ((ac_state != sc->ac_state)
|| (charging != (sc->battery_state & APM_BATT_FLAG_CHARGING))) {
config_hook_call(CONFIG_HOOK_PMEVENT,
CONFIG_HOOK_PMEVENT_AC,
(void *)((ac_state == APM_AC_OFF)
? CONFIG_HOOK_AC_OFF
: (charging ? CONFIG_HOOK_AC_ON_CHARGE
: CONFIG_HOOK_AC_ON_NOCHARGE)));
}
if (volt != sc->battery_volt) {
sc->battery_volt = volt;
sc->battery_life = zapm_battery_life(volt);
config_hook_call(CONFIG_HOOK_PMEVENT,
CONFIG_HOOK_PMEVENT_BATTERY,
(void *)zapm_battery_state(volt));
}
mutex_exit(&sc->sc_mtx);
}
