/* $NetBSD: fujbp_acpi.c,v 1.5 2021/01/29 15:49:55 thorpej Exp $ */ /*- * Copyright (c) 2010, 2011 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Gregoire Sutre. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ /* * ACPI Fujitsu Driver. * * Together with fujhk(4), this driver provides support for the ACPI devices * FUJ02B1 and FUJ02E3 that are commonly found in Fujitsu LifeBooks. The * driver does not support all features of these devices, in particular * volume control is not implemented. * * Information regarding the behavior of these devices was obtained from the * source code of the Linux and FreeBSD drivers, as well as from experiments on * a Fujitsu LifeBook P7120. * * The FUJ02B1 device is used to control the brightness level of the internal * display, the state (on/off) of the internal pointer, and the volume level of * the internal speakers or headphones. * * The FUJ02B1 device provides the following methods (or only a subset): * * GSIF supported hotkey status bits (bitmask for GHKS) * GHKS active hotkeys (bit field) * {G,S}BLL get/set the brightness level of the internal display * {G,S}VOL get/set the volume level of the internal speakers * {G,S}MOU get/set the switch state of the internal pointer * RBLL brightness radix (number of brightness levels) * RVOL volume radix (number of volume levels) * * Notifications are delivered to the FUJ02B1 device when functions hotkeys * (brightness, pointer) are released. However, these notifications seem to be * purely informative: the BIOS already made the hardware changes corresponding * to the hotkey. * * Each bit in the value returned by GHKS remains set until the corresponding * get method (GBLL, GMOU or GVOL) is called. * * The FUJ02E3 device manages the laptop hotkeys (such as the `Eco' button) and * provides additional services (such as backlight on/off control) through the * FUNC method. * * The FUJ02E3 device provides the following methods (or only a subset): * * GIRB get next hotkey code from buffer * FUNC general-purpose method (four arguments) * * Notifications are delivered to the FUJ02E3 device when hotkeys are pressed * and when they are released. The BIOS stores the corresponding codes in a * FIFO buffer, that can be read with the GIRB method. */ #include __KERNEL_RCSID(0, "$NetBSD: fujbp_acpi.c,v 1.5 2021/01/29 15:49:55 thorpej Exp $"); #include #include #include #include #include #include #include #define _COMPONENT ACPI_RESOURCE_COMPONENT ACPI_MODULE_NAME ("fujbp_acpi") /* * Notification value, bits returned by the GHKS method, and * modification status bits (from GBLL, GMOU, GIRB), respectively. */ #define FUJITSU_BP_NOTIFY 0x80 #define FUJITSU_BP_HKS_BRIGHTNESS __BIT(0) #define FUJITSU_BP_HKS_POINTER __BIT(3) #define FUJITSU_BP_MODMASK 0xc0000000 /* * ACPI Fujitsu brightness & pointer controller capabilities (methods). */ #define FUJITSU_BP_CAP_GHKS __BIT(0) #define FUJITSU_BP_CAP_RBLL __BIT(1) #define FUJITSU_BP_CAP_GBLL __BIT(2) #define FUJITSU_BP_CAP_SBLL __BIT(3) #define FUJITSU_BP_CAP_GMOU __BIT(4) #define FUJITSU_BP_CAP_SMOU __BIT(5) /* * fujitsu_bp_softc: * * Software state of an ACPI Fujitsu brightness & pointer controller. * Valid brightness levels range from 0 to (sc_brightness_nlevels - 1). */ struct fujitsu_bp_softc { device_t sc_dev; struct acpi_devnode *sc_node; struct sysctllog *sc_log; kmutex_t sc_mtx; uint16_t sc_caps; uint8_t sc_brightness_nlevels; }; static const struct device_compatible_entry compat_data[] = { { .compat = "FUJ02B1" }, DEVICE_COMPAT_EOL }; static int fujitsu_bp_match(device_t, cfdata_t, void *); static void fujitsu_bp_attach(device_t, device_t, void *); static int fujitsu_bp_detach(device_t, int); static bool fujitsu_bp_suspend(device_t, const pmf_qual_t *); static bool fujitsu_bp_resume(device_t, const pmf_qual_t *); static void fujitsu_bp_brightness_up(device_t); static void fujitsu_bp_brightness_down(device_t); static uint16_t fujitsu_bp_capabilities(const struct acpi_devnode *); static void fujitsu_bp_notify_handler(ACPI_HANDLE, uint32_t, void *); static void fujitsu_bp_event_callback(void *); static void fujitsu_bp_sysctl_setup(struct fujitsu_bp_softc *); static int fujitsu_bp_sysctl_brightness(SYSCTLFN_PROTO); static int fujitsu_bp_sysctl_pointer(SYSCTLFN_PROTO); static int fujitsu_bp_get_hks(struct fujitsu_bp_softc *, uint32_t *); static int fujitsu_bp_init_brightness(struct fujitsu_bp_softc *,uint8_t*); static int fujitsu_bp_get_brightness(struct fujitsu_bp_softc *,uint8_t *); static int fujitsu_bp_set_brightness(struct fujitsu_bp_softc *, uint8_t); static int fujitsu_bp_get_pointer(struct fujitsu_bp_softc *, bool *); static int fujitsu_bp_set_pointer(struct fujitsu_bp_softc *, bool); static bool fujitsu_bp_cap(ACPI_HANDLE, const char *, ACPI_OBJECT_TYPE); CFATTACH_DECL_NEW(fujbp, sizeof(struct fujitsu_bp_softc), fujitsu_bp_match, fujitsu_bp_attach, fujitsu_bp_detach, NULL); static int fujitsu_bp_match(device_t parent, cfdata_t match, void *aux) { struct acpi_attach_args *aa = aux; return acpi_compatible_match(aa, compat_data); } static void fujitsu_bp_attach(device_t parent, device_t self, void *aux) { struct fujitsu_bp_softc *sc = device_private(self); struct acpi_attach_args *aa = aux; struct acpi_devnode *ad = aa->aa_node; aprint_naive(": Fujitsu Brightness & Pointer\n"); aprint_normal(": Fujitsu Brightness & Pointer\n"); sc->sc_dev = self; sc->sc_node = ad; sc->sc_log = NULL; sc->sc_caps = fujitsu_bp_capabilities(ad); mutex_init(&sc->sc_mtx, MUTEX_DEFAULT, IPL_NONE); if (fujitsu_bp_init_brightness(sc, &sc->sc_brightness_nlevels)) sc->sc_brightness_nlevels = 0; (void)acpi_register_notify(sc->sc_node, fujitsu_bp_notify_handler); (void)pmf_device_register(self, fujitsu_bp_suspend, fujitsu_bp_resume); fujitsu_bp_sysctl_setup(sc); (void)pmf_event_register(self, PMFE_DISPLAY_BRIGHTNESS_UP, fujitsu_bp_brightness_up, true); (void)pmf_event_register(self, PMFE_DISPLAY_BRIGHTNESS_DOWN, fujitsu_bp_brightness_down, true); } static int fujitsu_bp_detach(device_t self, int flags) { struct fujitsu_bp_softc *sc = device_private(self); pmf_event_deregister(self, PMFE_DISPLAY_BRIGHTNESS_DOWN, fujitsu_bp_brightness_down, true); pmf_event_deregister(self, PMFE_DISPLAY_BRIGHTNESS_UP, fujitsu_bp_brightness_up, true); pmf_device_deregister(self); if (sc->sc_log != NULL) sysctl_teardown(&sc->sc_log); acpi_deregister_notify(sc->sc_node); mutex_destroy(&sc->sc_mtx); return 0; } /* * On some LifeBook models, a call to the SMOU method is required to make the * internal pointer work after resume. On the P7120, the internal pointer is * always enabled after resume. If it was disabled before suspend, the BIOS * apparently believes that it is still disabled after resume. * * To prevent these problems, we disable the internal pointer on suspend and * enable it on resume. */ static bool fujitsu_bp_suspend(device_t self, const pmf_qual_t *qual) { struct fujitsu_bp_softc *sc = device_private(self); mutex_enter(&sc->sc_mtx); (void)fujitsu_bp_set_pointer(sc, false); mutex_exit(&sc->sc_mtx); return true; } static bool fujitsu_bp_resume(device_t self, const pmf_qual_t *qual) { struct fujitsu_bp_softc *sc = device_private(self); mutex_enter(&sc->sc_mtx); (void)fujitsu_bp_set_pointer(sc, true); mutex_exit(&sc->sc_mtx); return true; } static void fujitsu_bp_brightness_up(device_t self) { struct fujitsu_bp_softc *sc = device_private(self); uint8_t level; mutex_enter(&sc->sc_mtx); if (fujitsu_bp_get_brightness(sc, &level) == 0 && level < (uint8_t)(sc->sc_brightness_nlevels - 1)) (void)fujitsu_bp_set_brightness(sc, level + 1); mutex_exit(&sc->sc_mtx); } static void fujitsu_bp_brightness_down(device_t self) { struct fujitsu_bp_softc *sc = device_private(self); uint8_t level; mutex_enter(&sc->sc_mtx); if (fujitsu_bp_get_brightness(sc, &level) == 0 && level > 0) (void)fujitsu_bp_set_brightness(sc, level - 1); mutex_exit(&sc->sc_mtx); } static uint16_t fujitsu_bp_capabilities(const struct acpi_devnode *ad) { uint16_t caps; caps = 0; if (fujitsu_bp_cap(ad->ad_handle, "GHKS", ACPI_TYPE_INTEGER)) caps |= FUJITSU_BP_CAP_GHKS; if (fujitsu_bp_cap(ad->ad_handle, "RBLL", ACPI_TYPE_INTEGER)) caps |= FUJITSU_BP_CAP_RBLL; if (fujitsu_bp_cap(ad->ad_handle, "GBLL", ACPI_TYPE_INTEGER)) caps |= FUJITSU_BP_CAP_GBLL; if (fujitsu_bp_cap(ad->ad_handle, "SBLL", ACPI_TYPE_METHOD)) caps |= FUJITSU_BP_CAP_SBLL; if (fujitsu_bp_cap(ad->ad_handle, "GMOU", ACPI_TYPE_INTEGER)) caps |= FUJITSU_BP_CAP_GMOU; if (fujitsu_bp_cap(ad->ad_handle, "SMOU", ACPI_TYPE_METHOD)) caps |= FUJITSU_BP_CAP_SMOU; return caps; } static void fujitsu_bp_notify_handler(ACPI_HANDLE handle, uint32_t evt, void *context) { struct fujitsu_bp_softc *sc = device_private(context); static const int handler = OSL_NOTIFY_HANDLER; switch (evt) { case FUJITSU_BP_NOTIFY: (void)AcpiOsExecute(handler, fujitsu_bp_event_callback, sc); break; default: aprint_debug_dev(sc->sc_dev, "unknown notify 0x%02X\n", evt); } } static void fujitsu_bp_event_callback(void *arg) { struct fujitsu_bp_softc *sc = arg; int error; uint32_t hks; uint8_t level; bool state; if (fujitsu_bp_get_hks(sc, &hks)) return; if (hks & FUJITSU_BP_HKS_BRIGHTNESS) { mutex_enter(&sc->sc_mtx); error = fujitsu_bp_get_brightness(sc, &level); mutex_exit(&sc->sc_mtx); if (!error) aprint_verbose_dev(sc->sc_dev, "brightness level is now: %"PRIu8"\n", level); } if (hks & FUJITSU_BP_HKS_POINTER) { mutex_enter(&sc->sc_mtx); error = fujitsu_bp_get_pointer(sc, &state); mutex_exit(&sc->sc_mtx); if (!error) aprint_verbose_dev(sc->sc_dev, "internal pointer is now: %s\n", state ? "enabled" : "disabled"); } } static void fujitsu_bp_sysctl_setup(struct fujitsu_bp_softc *sc) { const struct sysctlnode *rnode; int access; uint8_t dummy_level; bool dummy_state; bool brightness, pointer; brightness = (fujitsu_bp_get_brightness(sc, &dummy_level) == 0); pointer = (fujitsu_bp_get_pointer(sc, &dummy_state) == 0); if (brightness || pointer) { if ((sysctl_createv(&sc->sc_log, 0, NULL, &rnode, 0, CTLTYPE_NODE, "acpi", NULL, NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) goto fail; if ((sysctl_createv(&sc->sc_log, 0, &rnode, &rnode, 0, CTLTYPE_NODE, device_xname(sc->sc_dev), SYSCTL_DESCR("Fujitsu brightness & pointer controls"), NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL)) != 0) goto fail; } if (brightness) { if (sc->sc_caps & FUJITSU_BP_CAP_SBLL) access = CTLFLAG_READWRITE; else access = CTLFLAG_READONLY; (void)sysctl_createv(&sc->sc_log, 0, &rnode, NULL, access, CTLTYPE_INT, "brightness", SYSCTL_DESCR("Internal DFP brightness level"), fujitsu_bp_sysctl_brightness, 0, (void *)sc, 0, CTL_CREATE, CTL_EOL); } if (pointer) { if (sc->sc_caps & FUJITSU_BP_CAP_SMOU) access = CTLFLAG_READWRITE; else access = CTLFLAG_READONLY; (void)sysctl_createv(&sc->sc_log, 0, &rnode, NULL, access, CTLTYPE_BOOL, "pointer", SYSCTL_DESCR("Internal pointer switch state"), fujitsu_bp_sysctl_pointer, 0, (void *)sc, 0, CTL_CREATE, CTL_EOL); } return; fail: aprint_error_dev(sc->sc_dev, "couldn't add sysctl nodes\n"); } static int fujitsu_bp_sysctl_brightness(SYSCTLFN_ARGS) { struct sysctlnode node; struct fujitsu_bp_softc *sc; int val, error; uint8_t level; node = *rnode; sc = node.sysctl_data; mutex_enter(&sc->sc_mtx); error = fujitsu_bp_get_brightness(sc, &level); mutex_exit(&sc->sc_mtx); if (error) return error; val = (int)level; node.sysctl_data = &val; error = sysctl_lookup(SYSCTLFN_CALL(&node)); if (error || newp == NULL) return error; if (val < 0 || val > (uint8_t)(sc->sc_brightness_nlevels - 1)) return EINVAL; mutex_enter(&sc->sc_mtx); error = fujitsu_bp_set_brightness(sc, (uint8_t)val); mutex_exit(&sc->sc_mtx); return error; } static int fujitsu_bp_sysctl_pointer(SYSCTLFN_ARGS) { struct sysctlnode node; struct fujitsu_bp_softc *sc; bool val; int error; node = *rnode; sc = node.sysctl_data; mutex_enter(&sc->sc_mtx); error = fujitsu_bp_get_pointer(sc, &val); mutex_exit(&sc->sc_mtx); if (error) return error; node.sysctl_data = &val; error = sysctl_lookup(SYSCTLFN_CALL(&node)); if (error || newp == NULL) return error; mutex_enter(&sc->sc_mtx); error = fujitsu_bp_set_pointer(sc, val); mutex_exit(&sc->sc_mtx); return error; } static int fujitsu_bp_get_hks(struct fujitsu_bp_softc *sc, uint32_t *valuep) { ACPI_HANDLE hdl = sc->sc_node->ad_handle; ACPI_INTEGER val; ACPI_STATUS rv; if (!(sc->sc_caps & FUJITSU_BP_CAP_GHKS)) return ENODEV; rv = acpi_eval_integer(hdl, "GHKS", &val); if (ACPI_FAILURE(rv)) { aprint_error_dev(sc->sc_dev, "failed to evaluate %s.%s: %s\n", acpi_name(hdl), "GHKS", AcpiFormatException(rv)); return EIO; } *valuep = (uint32_t)val; return 0; } static int fujitsu_bp_init_brightness(struct fujitsu_bp_softc *sc, uint8_t *valuep) { ACPI_HANDLE hdl = sc->sc_node->ad_handle; ACPI_INTEGER val; ACPI_STATUS rv; if (!(sc->sc_caps & FUJITSU_BP_CAP_RBLL)) return ENODEV; rv = acpi_eval_integer(hdl, "RBLL", &val); if (ACPI_FAILURE(rv)) { aprint_error_dev(sc->sc_dev, "failed to evaluate %s.%s: %s\n", acpi_name(hdl), "RBLL", AcpiFormatException(rv)); return EIO; } if (val > UINT8_MAX) return ERANGE; *valuep = (uint8_t)val; return 0; } static int fujitsu_bp_get_brightness(struct fujitsu_bp_softc *sc, uint8_t *valuep) { ACPI_HANDLE hdl = sc->sc_node->ad_handle; ACPI_INTEGER val; ACPI_STATUS rv; if (!(sc->sc_caps & FUJITSU_BP_CAP_GBLL)) return ENODEV; rv = acpi_eval_integer(hdl, "GBLL", &val); if (ACPI_FAILURE(rv)) { aprint_error_dev(sc->sc_dev, "failed to evaluate %s.%s: %s\n", acpi_name(hdl), "GBLL", AcpiFormatException(rv)); return EIO; } /* Clear modification bits. */ val &= ~FUJITSU_BP_MODMASK; if (val > UINT8_MAX) return ERANGE; *valuep = (uint8_t)val; return 0; } static int fujitsu_bp_set_brightness(struct fujitsu_bp_softc *sc, uint8_t val) { ACPI_HANDLE hdl = sc->sc_node->ad_handle; ACPI_STATUS rv; if (!(sc->sc_caps & FUJITSU_BP_CAP_SBLL)) return ENODEV; rv = acpi_eval_set_integer(hdl, "SBLL", val); if (ACPI_FAILURE(rv)) { aprint_error_dev(sc->sc_dev, "failed to evaluate %s.%s: %s\n", acpi_name(hdl), "SBLL", AcpiFormatException(rv)); return EIO; } return 0; } static int fujitsu_bp_get_pointer(struct fujitsu_bp_softc *sc, bool *valuep) { ACPI_HANDLE hdl = sc->sc_node->ad_handle; ACPI_INTEGER val; ACPI_STATUS rv; if (!(sc->sc_caps & FUJITSU_BP_CAP_GMOU)) return ENODEV; rv = acpi_eval_integer(hdl, "GMOU", &val); if (ACPI_FAILURE(rv)) { aprint_error_dev(sc->sc_dev, "failed to evaluate %s.%s: %s\n", acpi_name(hdl), "GMOU", AcpiFormatException(rv)); return EIO; } /* Clear modification bits. */ val &= ~FUJITSU_BP_MODMASK; if (val > 1) return ERANGE; *valuep = (bool)val; return 0; } static int fujitsu_bp_set_pointer(struct fujitsu_bp_softc *sc, bool val) { ACPI_HANDLE hdl = sc->sc_node->ad_handle; ACPI_STATUS rv; if (!(sc->sc_caps & FUJITSU_BP_CAP_SMOU)) return ENODEV; rv = acpi_eval_set_integer(hdl, "SMOU", val); if (ACPI_FAILURE(rv)) { aprint_error_dev(sc->sc_dev, "failed to evaluate %s.%s: %s\n", acpi_name(hdl), "SMOU", AcpiFormatException(rv)); return EIO; } return 0; } /* * fujitusu_bp_cap: * * Returns true if and only if (a) the object handle.path exists and * (b) this object is a method or has the given type. */ static bool fujitsu_bp_cap(ACPI_HANDLE handle, const char *path, ACPI_OBJECT_TYPE type) { ACPI_HANDLE hdl; ACPI_OBJECT_TYPE typ; KASSERT(handle != NULL); if (ACPI_FAILURE(AcpiGetHandle(handle, path, &hdl))) return false; if (ACPI_FAILURE(AcpiGetType(hdl, &typ))) return false; if (typ != ACPI_TYPE_METHOD && typ != type) return false; return true; } MODULE(MODULE_CLASS_DRIVER, fujbp, NULL); #ifdef _MODULE #include "ioconf.c" #endif static int fujbp_modcmd(modcmd_t cmd, void *aux) { int rv = 0; switch (cmd) { case MODULE_CMD_INIT: #ifdef _MODULE rv = config_init_component(cfdriver_ioconf_fujbp, cfattach_ioconf_fujbp, cfdata_ioconf_fujbp); #endif break; case MODULE_CMD_FINI: #ifdef _MODULE rv = config_fini_component(cfdriver_ioconf_fujbp, cfattach_ioconf_fujbp, cfdata_ioconf_fujbp); #endif break; default: rv = ENOTTY; } return rv; }