static int
tegra_cpufreq_freq_helper(SYSCTLFN_ARGS)
{
struct sysctlnode node;
int fq, oldfq = 0, error;
uint64_t xc;
node = *rnode;
node.sysctl_data = &fq;
fq = cpufreq_get_rate();
if (rnode->sysctl_num == cpufreq_node_target)
oldfq = fq;
error = sysctl_lookup(SYSCTLFN_CALL(&node));
if (error || newp == NULL)
return error;
if (fq == oldfq || rnode->sysctl_num != cpufreq_node_target)
return 0;
if (atomic_cas_uint(&cpufreq_busy, 0, 1) != 0)
return EBUSY;
error = cpufreq_set_rate(fq);
if (error == 0) {
xc = xc_broadcast(0, tegra_cpufreq_post, NULL, NULL);
xc_wait(xc);
pmf_event_inject(NULL, PMFE_SPEED_CHANGED);
}
atomic_dec_uint(&cpufreq_busy);
return error;
}
static void
wmi_hp_hotkey(void *aux)
{
struct wmi_hp_softc *sc;
device_t self = aux;
sc = device_private(self);
if (wmi_hp_method_read(sc, WMI_HP_METHOD_CMD_HOTKEY) != true)
return;
switch (sc->sc_val) {
case WMI_HP_HOTKEY_BRIGHTNESS_UP:
pmf_event_inject(NULL, PMFE_DISPLAY_BRIGHTNESS_UP);
break;
case WMI_HP_HOTKEY_BRIGHTNESS_DOWN:
pmf_event_inject(NULL, PMFE_DISPLAY_BRIGHTNESS_DOWN);
break;
case WMI_HP_HOTKEY_PROG1:
aprint_debug_dev(self, "PROG1 hotkey pressed\n");
break;
case WMI_HP_HOTKEY_MEDIA1:
aprint_debug_dev(self, "MEDIA1 hotkey pressed\n");
break;
case WMI_HP_HOTKEY_MEDIA2:
aprint_debug_dev(self, "MEDIA2 hotkey pressed\n");
break;
case WMI_HP_HOTKEY_INFO:
aprint_debug_dev(self, "INFO hotkey pressed\n");
break;
case WMI_HP_HOTKEY_DIRECTION:
aprint_debug_dev(self, "DIRECTION hotkey pressed\n");
break;
case WMI_HP_HOTKEY_HELP:
aprint_debug_dev(self, "HELP hotkey pressed\n");
break;
default:
aprint_debug_dev(self, "unknown hotkey 0x%02x\n", sc->sc_val);
break;
}
}
static void
tps65217pmic_power_monitor(void *aux)
{
struct tps65217pmic_softc *sc;
uint8_t status;
bool usbstatus, acstatus;
sc = aux;
mutex_enter(&sc->sc_lock);
status = tps65217pmic_reg_read(sc, TPS65217PMIC_STATUS);
usbstatus = status & TPS65217PMIC_STATUS_USBPWR;
acstatus = status & TPS65217PMIC_STATUS_ACPWR;
if (usbstatus != sc->sc_usbstatus) {
sc->sc_usbstatus = usbstatus;
pmf_event_inject(NULL, PMFE_POWER_CHANGED);
if (usbstatus)
aprint_normal_dev(sc->sc_dev,
"USB power source connected\n");
else
aprint_normal_dev(sc->sc_dev,
"USB power source disconnected\n");
}
if (acstatus != sc->sc_acstatus) {
sc->sc_acstatus = acstatus;
pmf_event_inject(NULL, PMFE_POWER_CHANGED);
if (acstatus) {
sysmon_pswitch_event(&sc->sc_smpsw,
PSWITCH_EVENT_PRESSED);
} else {
sysmon_pswitch_event(&sc->sc_smpsw,
PSWITCH_EVENT_RELEASED);
}
}
mutex_exit(&sc->sc_lock);
callout_schedule(&sc->sc_powerpollco, hz);
}
static void
asus_notify_handler(ACPI_HANDLE hdl, uint32_t notify, void *opaque)
{
struct asus_softc *sc;
device_t self = opaque;
sc = device_private(self);
if (notify >= ASUS_NOTIFY_BrightnessLow &&
notify <= ASUS_NOTIFY_BrightnessHigh) {
aprint_debug_dev(sc->sc_dev, "brightness %d percent\n",
(notify & 0xf) * 100 / 0xf);
return;
}
switch (notify) {
case ASUS_NOTIFY_WirelessSwitch: /* handled by AML */
case ASUS_NOTIFY_WindowSwitch: /* XXXJDM what is this? */
break;
case ASUS_NOTIFY_DisplayCycle:
if (sc->sc_smpsw_valid == false)
break;
sysmon_pswitch_event(&sc->sc_smpsw[ASUS_PSW_DISPLAY_CYCLE],
PSWITCH_EVENT_PRESSED);
break;
case ASUS_NOTIFY_VolumeMute:
pmf_event_inject(NULL, PMFE_AUDIO_VOLUME_TOGGLE);
break;
case ASUS_NOTIFY_VolumeDown:
pmf_event_inject(NULL, PMFE_AUDIO_VOLUME_DOWN);
break;
case ASUS_NOTIFY_VolumeUp:
pmf_event_inject(NULL, PMFE_AUDIO_VOLUME_UP);
break;
default:
aprint_debug_dev(sc->sc_dev, "unknown event 0x%02x\n", notify);
break;
}
}
static int
mpu_current_frequency_sysctl_helper(SYSCTLFN_ARGS)
{
struct sysctlnode node = *rnode;
int freq = mpu_frequency;
int old_freq = freq;
KASSERTMSG(curcpu()->ci_data.cpu_cc_freq == mpu_frequency * 1000000,
"cc_freq %"PRIu64" mpu_freq %u000000",
curcpu()->ci_data.cpu_cc_freq, mpu_frequency);
node.sysctl_data = &freq;
int error = sysctl_lookup(SYSCTLFN_CALL(&node));
if (error || newp == NULL)
return error;
KASSERT(old_freq == mpu_frequency);
error = EINVAL;
for (size_t i = 0; i < __arraycount(mpu_frequencies); i++) {
if (mpu_frequencies[i] == freq) {
error = 0;
break;
}
}
if (error)
return EINVAL;
if (freq != old_freq) {
const int s = splhigh();
prcm_mpu_pll_config(freq);
curcpu()->ci_data.cpu_cc_freq = freq * 1000000;
mpu_frequency = freq;
splx(s);
aprint_normal_dev(curcpu()->ci_dev,
"frequency changed from %d MHz to %d MHz\n",
old_freq, freq);
pmf_event_inject(NULL, PMFE_SPEED_CHANGED);
}
return 0;
}
/* Interrupt handler: some event is available */
int
spic_intr(void *v) {
struct spic_softc *sc = v;
u_int8_t v1, v2;
int dz, buttons;
v1 = INB(sc, SPIC_PORT1);
v2 = INB(sc, SPIC_PORT2);
/* Handle lid switch */
if (v2 == 0x30) {
switch (v1) {
case 0x50: /* opened */
sysmon_pswitch_event(&sc->sc_smpsw[SPIC_PSWITCH_LID],
PSWITCH_EVENT_RELEASED);
goto skip;
break;
case 0x51: /* closed */
sysmon_pswitch_event(&sc->sc_smpsw[SPIC_PSWITCH_LID],
PSWITCH_EVENT_PRESSED);
goto skip;
break;
default:
aprint_debug_dev(sc->sc_dev, "unknown lid event 0x%02x\n", v1);
goto skip;
break;
}
}
/* Handle suspend/hibernate buttons */
if (v2 == 0x20) {
switch (v1) {
case 0x10: /* suspend */
sysmon_pswitch_event(
&sc->sc_smpsw[SPIC_PSWITCH_SUSPEND],
PSWITCH_EVENT_PRESSED);
goto skip;
break;
case 0x1c: /* hibernate */
sysmon_pswitch_event(
&sc->sc_smpsw[SPIC_PSWITCH_HIBERNATE],
PSWITCH_EVENT_PRESSED);
goto skip;
break;
}
}
buttons = 0;
if (v1 & 0x40)
buttons |= 1 << 1;
if (v1 & 0x20)
buttons |= 1 << 5;
dz = v1 & 0x1f;
switch (dz) {
case 0:
case 1:
case 2:
case 3:
break;
case 0x1f:
case 0x1e:
case 0x1d:
dz -= 0x20;
break;
case SPIC_EVENT_BRIGHTNESS_UP:
pmf_event_inject(sc->sc_dev, PMFE_DISPLAY_BRIGHTNESS_UP);
break;
case SPIC_EVENT_BRIGHTNESS_DOWN:
pmf_event_inject(sc->sc_dev, PMFE_DISPLAY_BRIGHTNESS_DOWN);
break;
default:
printf("spic0: v1=0x%02x v2=0x%02x\n", v1, v2);
goto skip;
}
if (!sc->sc_enabled) {
/*printf("spic: not enabled\n");*/
goto skip;
}
if (dz != 0 || buttons != sc->sc_buttons) {
#ifdef SPIC_DEBUG
if (spicdebug)
printf("spic: but=0x%x dz=%d v1=0x%02x v2=0x%02x\n",
buttons, dz, v1, v2);
#endif
sc->sc_buttons = buttons;
if (sc->sc_wsmousedev != NULL) {
wsmouse_input(sc->sc_wsmousedev, buttons, 0, 0, dz, 0,
WSMOUSE_INPUT_DELTA);
}
}
skip:
spic_call2(sc, 0x81, 0xff); /* Clear event */
return (1);
}
static int
internal_command(struct wskbd_softc *sc, u_int *type, keysym_t ksym,
keysym_t ksym2)
{
#if NWSDISPLAY > 0 && defined(WSDISPLAY_SCROLLSUPPORT)
u_int state = 0;
#endif
switch (ksym) {
case KS_Cmd_VolumeToggle:
if (*type == WSCONS_EVENT_KEY_DOWN)
pmf_event_inject(NULL, PMFE_AUDIO_VOLUME_TOGGLE);
break;
case KS_Cmd_VolumeUp:
if (*type == WSCONS_EVENT_KEY_DOWN)
pmf_event_inject(NULL, PMFE_AUDIO_VOLUME_UP);
break;
case KS_Cmd_VolumeDown:
if (*type == WSCONS_EVENT_KEY_DOWN)
pmf_event_inject(NULL, PMFE_AUDIO_VOLUME_DOWN);
break;
#if NWSDISPLAY > 0 && defined(WSDISPLAY_SCROLLSUPPORT)
case KS_Cmd_ScrollFastUp:
case KS_Cmd_ScrollFastDown:
if (*type == WSCONS_EVENT_KEY_DOWN) {
GETMODSTATE(sc->id->t_modifiers, state);
if ((sc->sc_scroll_data.mode == WSKBD_SCROLL_MODE_HOLD
&& MOD_ONESET(sc->id, MOD_HOLDSCREEN))
|| (sc->sc_scroll_data.mode == WSKBD_SCROLL_MODE_NORMAL
&& sc->sc_scroll_data.modifier == state)) {
update_modifier(sc->id, *type, 0, MOD_COMMAND);
wsdisplay_scroll(sc->sc_base.me_dispdv,
(ksym == KS_Cmd_ScrollFastUp) ?
WSDISPLAY_SCROLL_BACKWARD :
WSDISPLAY_SCROLL_FORWARD);
return (1);
} else {
return (0);
}
}
case KS_Cmd_ScrollSlowUp:
case KS_Cmd_ScrollSlowDown:
if (*type == WSCONS_EVENT_KEY_DOWN) {
GETMODSTATE(sc->id->t_modifiers, state);
if ((sc->sc_scroll_data.mode == WSKBD_SCROLL_MODE_HOLD
&& MOD_ONESET(sc->id, MOD_HOLDSCREEN))
|| (sc->sc_scroll_data.mode == WSKBD_SCROLL_MODE_NORMAL
&& sc->sc_scroll_data.modifier == state)) {
update_modifier(sc->id, *type, 0, MOD_COMMAND);
wsdisplay_scroll(sc->sc_base.me_dispdv,
(ksym == KS_Cmd_ScrollSlowUp) ?
WSDISPLAY_SCROLL_BACKWARD | WSDISPLAY_SCROLL_LOW:
WSDISPLAY_SCROLL_FORWARD | WSDISPLAY_SCROLL_LOW);
return (1);
} else {
return (0);
}
}
#endif
case KS_Cmd:
update_modifier(sc->id, *type, 0, MOD_COMMAND);
ksym = ksym2;
break;
case KS_Cmd1:
update_modifier(sc->id, *type, 0, MOD_COMMAND1);
break;
case KS_Cmd2:
update_modifier(sc->id, *type, 0, MOD_COMMAND2);
break;
}
if (*type != WSCONS_EVENT_KEY_DOWN ||
(! MOD_ONESET(sc->id, MOD_COMMAND) &&
! MOD_ALLSET(sc->id, MOD_COMMAND1 | MOD_COMMAND2)))
return (0);
#if defined(DDB) || defined(KGDB)
if (ksym == KS_Cmd_Debugger) {
if (sc->sc_isconsole) {
#ifdef DDB
console_debugger();
#endif
#ifdef KGDB
kgdb_connect(1);
#endif
}
/* discard this key (ddb discarded command modifiers) */
*type = WSCONS_EVENT_KEY_UP;
return (1);
}
#endif
#if NWSDISPLAY > 0
if (sc->sc_base.me_dispdv == NULL)
return (0);
switch (ksym) {
case KS_Cmd_Screen0:
case KS_Cmd_Screen1:
case KS_Cmd_Screen2:
case KS_Cmd_Screen3:
case KS_Cmd_Screen4:
case KS_Cmd_Screen5:
case KS_Cmd_Screen6:
case KS_Cmd_Screen7:
case KS_Cmd_Screen8:
case KS_Cmd_Screen9:
wsdisplay_switch(sc->sc_base.me_dispdv, ksym - KS_Cmd_Screen0, 0);
return (1);
case KS_Cmd_ResetEmul:
wsdisplay_reset(sc->sc_base.me_dispdv, WSDISPLAY_RESETEMUL);
return (1);
case KS_Cmd_ResetClose:
wsdisplay_reset(sc->sc_base.me_dispdv, WSDISPLAY_RESETCLOSE);
return (1);
case KS_Cmd_BacklightOn:
case KS_Cmd_BacklightOff:
case KS_Cmd_BacklightToggle:
change_displayparam(sc, WSDISPLAYIO_PARAM_BACKLIGHT,
ksym == KS_Cmd_BacklightOff ? -1 : 1,
ksym == KS_Cmd_BacklightToggle ? 1 : 0);
return (1);
case KS_Cmd_BrightnessUp:
case KS_Cmd_BrightnessDown:
case KS_Cmd_BrightnessRotate:
change_displayparam(sc, WSDISPLAYIO_PARAM_BRIGHTNESS,
ksym == KS_Cmd_BrightnessDown ? -1 : 1,
ksym == KS_Cmd_BrightnessRotate ? 1 : 0);
return (1);
case KS_Cmd_ContrastUp:
case KS_Cmd_ContrastDown:
case KS_Cmd_ContrastRotate:
change_displayparam(sc, WSDISPLAYIO_PARAM_CONTRAST,
ksym == KS_Cmd_ContrastDown ? -1 : 1,
ksym == KS_Cmd_ContrastRotate ? 1 : 0);
return (1);
}
#endif
return (0);
}
