int
toshiba_hotkey(struct aml_node *node, int notify, void *arg)
{
struct acpitoshiba_softc *sc = arg;
int event, ret;
event = toshiba_read_events(sc);
if (!event)
return (0);
switch (event) {
case FN_KEY_BRIGHTNESS_UP:
/* Increase brightness */
ret = toshiba_fn_key_brightness_up(sc);
break;
case FN_KEY_BRIGHTNESS_DOWN:
/* Decrease brightness */
ret = toshiba_fn_key_brightness_down(sc);
break;
case FN_KEY_SUSPEND:
#ifndef SMALL_KERNEL
if (acpi_record_event(sc->sc_acpi, APM_USER_SUSPEND_REQ)) {
acpi_addtask(sc->sc_acpi, acpi_sleep_task,
sc->sc_acpi, ACPI_STATE_S3);
ret = HCI_SUCCESS;
}
#endif
break;
case FN_KEY_HIBERNATE:
#if defined(HIBERNATE) && !defined(SMALL_KERNEL)
if (acpi_record_event(sc->sc_acpi, APM_USER_HIBERNATE_REQ)) {
acpi_addtask(sc->sc_acpi, acpi_sleep_task,
sc->sc_acpi, ACPI_STATE_S4);
ret = HCI_SUCCESS;
}
#endif
break;
case FN_KEY_VIDEO_OUTPUT:
/* Cycle through video outputs. */
ret = toshiba_fn_key_video_output(sc);
break;
default:
break;
}
if ( ret != HCI_SUCCESS)
return (1);
return (0);
}
void
acpibat_refresh(void *arg)
{
struct acpibat_softc *sc = arg;
int i;
dnprintf(30, "%s: %s: refresh\n", DEVNAME(sc),
sc->sc_devnode->name);
if (!sc->sc_bat_present) {
for (i = 0; i < 8; i++) {
sc->sc_sens[i].value = 0;
sc->sc_sens[i].status = SENSOR_S_UNSPEC;
sc->sc_sens[i].flags = SENSOR_FINVALID;
}
/* override state */
strlcpy(sc->sc_sens[4].desc, "battery removed",
sizeof(sc->sc_sens[4].desc));
return;
}
/* _BIF values are static, sensor 0..3 */
if (sc->sc_bif.bif_last_capacity == BIF_UNKNOWN) {
sc->sc_sens[0].value = 0;
sc->sc_sens[0].status = SENSOR_S_UNKNOWN;
sc->sc_sens[0].flags = SENSOR_FUNKNOWN;
} else {
sc->sc_sens[0].value = sc->sc_bif.bif_last_capacity * 1000;
sc->sc_sens[0].status = SENSOR_S_UNSPEC;
sc->sc_sens[0].flags = 0;
}
sc->sc_sens[1].value = sc->sc_bif.bif_warning * 1000;
sc->sc_sens[1].flags = 0;
sc->sc_sens[2].value = sc->sc_bif.bif_low * 1000;
sc->sc_sens[2].flags = 0;
if (sc->sc_bif.bif_voltage == BIF_UNKNOWN) {
sc->sc_sens[3].value = 0;
sc->sc_sens[3].status = SENSOR_S_UNKNOWN;
sc->sc_sens[3].flags = SENSOR_FUNKNOWN;
} else {
sc->sc_sens[3].value = sc->sc_bif.bif_voltage * 1000;
sc->sc_sens[3].status = SENSOR_S_UNSPEC;
sc->sc_sens[3].flags = 0;
}
/* _BST values are dynamic, sensor 4..7 */
sc->sc_sens[4].status = SENSOR_S_OK;
sc->sc_sens[4].flags = 0;
if (sc->sc_bif.bif_last_capacity == BIF_UNKNOWN ||
sc->sc_bst.bst_capacity == BST_UNKNOWN) {
sc->sc_sens[4].status = SENSOR_S_UNKNOWN;
sc->sc_sens[4].flags = SENSOR_FUNKNOWN;
strlcpy(sc->sc_sens[4].desc, "battery unknown",
sizeof(sc->sc_sens[4].desc));
} else if (sc->sc_bst.bst_capacity >= sc->sc_bif.bif_last_capacity)
strlcpy(sc->sc_sens[4].desc, "battery full",
sizeof(sc->sc_sens[4].desc));
else if (sc->sc_bst.bst_state & BST_DISCHARGE)
strlcpy(sc->sc_sens[4].desc, "battery discharging",
sizeof(sc->sc_sens[4].desc));
else if (sc->sc_bst.bst_state & BST_CHARGE)
strlcpy(sc->sc_sens[4].desc, "battery charging",
sizeof(sc->sc_sens[4].desc));
else if (sc->sc_bst.bst_state & BST_CRITICAL) {
strlcpy(sc->sc_sens[4].desc, "battery critical",
sizeof(sc->sc_sens[4].desc));
sc->sc_sens[4].status = SENSOR_S_CRIT;
} else
strlcpy(sc->sc_sens[4].desc, "battery idle",
sizeof(sc->sc_sens[4].desc));
sc->sc_sens[4].value = sc->sc_bst.bst_state;
if (sc->sc_bst.bst_rate == BST_UNKNOWN) {
sc->sc_sens[5].value = 0;
sc->sc_sens[5].status = SENSOR_S_UNKNOWN;
sc->sc_sens[5].flags = SENSOR_FUNKNOWN;
} else {
sc->sc_sens[5].value = sc->sc_bst.bst_rate;
sc->sc_sens[5].status = SENSOR_S_UNSPEC;
sc->sc_sens[5].flags = 0;
}
if (sc->sc_bst.bst_capacity == BST_UNKNOWN) {
sc->sc_sens[6].value = 0;
sc->sc_sens[6].status = SENSOR_S_UNKNOWN;
sc->sc_sens[6].flags = SENSOR_FUNKNOWN;
} else {
sc->sc_sens[6].value = sc->sc_bst.bst_capacity * 1000;
sc->sc_sens[6].flags = 0;
if (sc->sc_bst.bst_capacity < sc->sc_bif.bif_low)
/* XXX we should shutdown the system */
sc->sc_sens[6].status = SENSOR_S_CRIT;
else if (sc->sc_bst.bst_capacity < sc->sc_bif.bif_warning)
sc->sc_sens[6].status = SENSOR_S_WARN;
else
sc->sc_sens[6].status = SENSOR_S_OK;
}
if (sc->sc_bst.bst_voltage == BST_UNKNOWN) {
sc->sc_sens[7].value = 0;
sc->sc_sens[7].status = SENSOR_S_UNKNOWN;
sc->sc_sens[7].flags = SENSOR_FUNKNOWN;
} else {
sc->sc_sens[7].value = sc->sc_bst.bst_voltage * 1000;
sc->sc_sens[7].status = SENSOR_S_UNSPEC;
sc->sc_sens[7].flags = 0;
}
acpi_record_event(sc->sc_acpi, APM_POWER_CHANGE);
}
int
acpisony_notify(struct aml_node *node, int notify, void *arg)
{
struct acpisony_softc *sc = arg;
int val, key = 0;
if (notify == SONY_NOTIFY_FN_KEY) {
notify -= 0x90;
DPRINTF(("notify = %X", notify));
if (notify == acpisony_find_offset(sc, 0x100)) {
DPRINTF(("key = 0x100\n"));
key = 0x100;
}
if (notify == acpisony_find_offset(sc, 0x127)) {
DPRINTF(("key = 0x127\n"));
key = 0x127;
}
if (key) {
val = acpisony_set_hotkey(sc, key, 0x200);
if (val < 0) {
printf("returned val = %X", val);
return 1;
}
notify = val & 0xff;
DPRINTF(("Treat %X events, notify %X\n", key, notify));
} else
DPRINTF(("rfkill update, notify %X\n", notify));
}
switch (notify) {
case SONY_NOTIFY_BRIGHTNESS_DOWN_PRESSED:
DPRINTF(("br-down-pressed\n"));
acpisony_brightness_down(sc);
break;
case SONY_NOTIFY_BRIGHTNESS_DOWN_RELEASED:
DPRINTF(("br-down-released\n"));
break;
case SONY_NOTIFY_BRIGHTNESS_UP_PRESSED:
DPRINTF(("br-up-pressed\n"));
break;
case SONY_NOTIFY_BRIGHTNESS_UP_RELEASED:
DPRINTF(("br-up-released\n"));
break;
case SONY_NOTIFY_DISPLAY_SWITCH_PRESSED:
DPRINTF(("display-pressed\n"));
break;
case SONY_NOTIFY_DISPLAY_SWITCH_RELEASED:
DPRINTF(("display-released\n"));
break;
case SONY_NOTIFY_ZOOM_IN_PRESSED:
DPRINTF(("zoom-in-pressed\n"));
break;
case SONY_NOTIFY_ZOOM_IN_RELEASED:
DPRINTF(("zoom-in-released\n"));
break;
case SONY_NOTIFY_ZOOM_OUT_PRESSED:
DPRINTF(("zoom-out-pressed\n"));
break;
case SONY_NOTIFY_ZOOM_OUT_RELEASED:
DPRINTF(("zoom-out-released\n"));
break;
case SONY_NOTIFY_SUSPEND_PRESSED:
DPRINTF(("suspend-pressed\n"));
#ifndef SMALL_KERNEL
if (acpi_record_event(sc->sc_acpi, APM_USER_SUSPEND_REQ))
acpi_addtask(sc->sc_acpi, acpi_sleep_task,
sc->sc_acpi, ACPI_STATE_S3);
#endif
break;
case SONY_NOTIFY_SUSPEND_RELEASED:
DPRINTF(("suspend-released\n"));
break;
default:
printf("%s: unknown event 0x%02x\n", DEVNAME(sc), notify);
break;
}
return 0;
}
int
thinkpad_hotkey(struct aml_node *node, int notify_type, void *arg)
{
struct acpithinkpad_softc *sc = arg;
int handled = 0;
int64_t event;
if (notify_type == 0x00) {
/* Poll sensors */
thinkpad_sensor_refresh(sc);
return (0);
}
if (notify_type != 0x80)
return (1);
for (;;) {
if (aml_evalinteger(sc->sc_acpi, sc->sc_devnode, "MHKP",
0, NULL, &event))
break;
if (event == 0)
break;
switch (event) {
case THINKPAD_BUTTON_BRIGHTNESS_UP:
thinkpad_brightness_up(sc);
handled = 1;
break;
case THINKPAD_BUTTON_BRIGHTNESS_DOWN:
thinkpad_brightness_down(sc);
handled = 1;
break;
case THINKPAD_BUTTON_WIRELESS:
thinkpad_toggle_bluetooth(sc);
handled = 1;
break;
case THINKPAD_BUTTON_SUSPEND:
#ifndef SMALL_KERNEL
if (acpi_record_event(sc->sc_acpi, APM_USER_SUSPEND_REQ))
acpi_addtask(sc->sc_acpi, acpi_sleep_task,
sc->sc_acpi, ACPI_STATE_S3);
#endif
handled = 1;
break;
case THINKPAD_BUTTON_VOLUME_MUTE:
thinkpad_volume_mute(sc);
handled = 1;
break;
case THINKPAD_BUTTON_VOLUME_DOWN:
thinkpad_volume_down(sc);
handled = 1;
break;
case THINKPAD_BUTTON_VOLUME_UP:
thinkpad_volume_up(sc);
handled = 1;
break;
case THINKPAD_BUTTON_MICROPHONE_MUTE:
#if NAUDIO > 0 && NWSKBD > 0
wskbd_set_mixervolume(0, 0);
#endif
handled = 1;
break;
case THINKPAD_BUTTON_HIBERNATE:
#ifndef SMALL_KERNEL
acpi_addtask(sc->sc_acpi, acpi_sleep_task,
sc->sc_acpi, ACPI_STATE_S4);
#endif
handled = 1;
break;
case THINKPAD_ADAPTIVE_NEXT:
case THINKPAD_ADAPTIVE_QUICK:
thinkpad_adaptive_change(sc);
handled = 1;
break;
case THINKPAD_ADAPTIVE_BACK:
case THINKPAD_ADAPTIVE_GESTURES:
case THINKPAD_ADAPTIVE_REFRESH:
case THINKPAD_ADAPTIVE_SETTINGS:
case THINKPAD_ADAPTIVE_SNIP:
case THINKPAD_ADAPTIVE_TAB:
case THINKPAD_ADAPTIVE_VOICE:
case THINKPAD_BACKLIGHT_CHANGED:
case THINKPAD_BRIGHTNESS_CHANGED:
case THINKPAD_BUTTON_BATTERY_INFO:
case THINKPAD_BUTTON_EJECT:
case THINKPAD_BUTTON_EXTERNAL_SCREEN:
case THINKPAD_BUTTON_FN_F11:
case THINKPAD_BUTTON_FN_F1:
case THINKPAD_BUTTON_FN_F6:
case THINKPAD_BUTTON_FN_SPACE:
case THINKPAD_BUTTON_LOCK_SCREEN:
case THINKPAD_BUTTON_POINTER_SWITCH:
case THINKPAD_BUTTON_THINKLIGHT:
case THINKPAD_BUTTON_THINKVANTAGE:
case THINKPAD_LID_CLOSED:
case THINKPAD_LID_OPEN:
case THINKPAD_PORT_REPL_DOCKED:
case THINKPAD_PORT_REPL_UNDOCKED:
case THINKPAD_POWER_CHANGED:
case THINKPAD_SWITCH_WIRELESS:
case THINKPAD_TABLET_PEN_INSERTED:
case THINKPAD_TABLET_PEN_REMOVED:
case THINKPAD_TABLET_SCREEN_NORMAL:
case THINKPAD_TABLET_SCREEN_ROTATED:
case THINKPAD_THERMAL_TABLE_CHANGED:
handled = 1;
break;
default:
printf("%s: unknown event 0x%03llx\n",
DEVNAME(sc), event);
}
}
return (handled);
}
