I'm really sorry, I just realized the changes are a lot and unreadable.
Changes should be splitted into a series and resubmitted.
On Thu, 2019-05-23 at 05:31 -0400, Ayman Bagabas wrote:
> This patch introduces new features to the driver and also moves the
> driver from wmi_driver to platform_driver.
>
> This move is necessary because the driver is no longer only a hotkeys
> driver and platform_driver offers easier future extensibility. The
> patch
> introduces a WMI BIOS interface that brings on new features and
> enables
> controlling micmute LED through this interface on supported models.
> New
> features are controlling battery charging thresholds and fn-lock
> state
> among with module parameters and quirks check.
>
> Currently, micmute LED is controlled through an ACPI method under EC.
> This method ("SPIN", "WPIN") is specific to some models and wouldn't
> work on all Huawei laptops.
>
> Using this interface, controlling this LED should work with any
> model.
> Except `MateBook X` from 2017, this one doesn't provide controlling
> the
> LED through this interface instead it uses another "legacy" interface
> that is not "fully" implemented yet due to lack of hardware.
> Currently,
> this "legacy" interface is used for hotkeys on this specific model. A
> quirk is set to use ACPI method to control micmute LED on this model.
>
> Some models that implement the new WMI BIOS interface can control
> battery charging thresholds where it limits charging the battery once
> it
> reaches certain thresholds.
>
> The behavior of hotkeys is not the same among all models. Some models
> require fn-lock to do things like `Ctrl-Ins` or `Alt-PrtSc`. By
> default,
> hotkeys behave as special keys (media keys, Ins, etc), but if a
> modifier
> is used (ctrl, alt, shift) these keys behave as F1-F12 keys. If the
> Fn
> key is toggled on, the hotkeys with or without a modifier, behave as
> F1-F12 keys. This makes it impossible to use a modifier and `PrtSc`
> or
> `Ins`.
>
> Now, some models fix this by excluding `PrtSc` and `Ins` keys from
> being treated as F11 and F12 keys with the use of a modifier.
> However,
> some models do not, and fixes this by the so called fn-lock.
>
> Fn-lock inverts the behavior of the top row from special keys to F1-
> F12
> keys. So a modifier and a special key would be possible which make
> things like `Alt-Ins` possible. Now, with fn-lock we would have 4
> modes:
> * Fn-key off & fn-lock off - hotkeys treated as special keys using a
> modifier gives F1-F12 keys.
> * Fn-key on & fn-lock off - hotkeys treated as F1-F12 keys and using
> a
> modifier gives F1-F12.
> * Fn-key off & fn-lock on - hotkeys are treated as F1-F12 keys and
> using
> a modifier gives special keys.
> * Fn-key on & fn-lock on - hotkeys are treated as special keys and
> using
> a modifier gives special keys.
>
> The driver introduces two parameters to force reporting brightness
> keys
> and sleeping after setting a threshold value.
>
> All newer models that "fully" implement the new interface report
> brightness key events twice, once through WMI and once through
> acpi-video. Older models, such as `MateBook X`, don't report
> brightness
> events using WMI. This is implemented as a quirk and can be forced
> using
> module parameters.
>
> Some models don't allow setting thresholds to (0, 100), due to bad
> ASL
> code, which indicates reset values, instead, it only turns off
> battery
> charging protection. This would return the previously set values even
> though battery protection is off which doesn't make sense. A sane
> value
> like (0, 100) indicates no charging protection, but since it's not
> possible to set such values, (0, 0) is set before turning protection
> off with (0, 100). This requires a delay after setting (0, 0) and
> after
> (0, 100) so that these values make their way to EC memory.
>
> These parameters are implemented as quirks along with `ec_micmute`
> quirk
> which controls the micmute LED through ACPI EC interface.
>
> Signed-off-by: Ayman Bagabas <ayman.bagabas@xxxxxxxxx>
> ---
> drivers/platform/x86/huawei-wmi.c | 630 +++++++++++++++++++++++++---
> --
> 1 file changed, 541 insertions(+), 89 deletions(-)
>
> diff --git a/drivers/platform/x86/huawei-wmi.c
> b/drivers/platform/x86/huawei-wmi.c
> index 52fcac5b393a..3f945b4cf115 100644
> --- a/drivers/platform/x86/huawei-wmi.c
> +++ b/drivers/platform/x86/huawei-wmi.c
> @@ -1,32 +1,65 @@
> // SPDX-License-Identifier: GPL-2.0
> /*
> - * Huawei WMI hotkeys
> + * Huawei WMI laptop extras driver
> *
> * Copyright (C) 2018 Ayman Bagabas <
> ayman.bagabas@xxxxxxxxx>
> */
>
> #include <linux/acpi.h>
> +#include <linux/delay.h>
> +#include <linux/dmi.h>
> #include <linux/input.h>
> #include <linux/input/sparse-keymap.h>
> #include <linux/leds.h>
> #include <linux/module.h>
> +#include <linux/mutex.h>
> +#include <linux/platform_device.h>
> +#include <linux/sysfs.h>
> #include <linux/wmi.h>
>
> /*
> * Huawei WMI GUIDs
> */
> -#define WMI0_EVENT_GUID "59142400-C6A3-40fa-BADB-8A2652834100"
> +#define AMW0_METHOD_GUID "ABBC0F5B-8EA1-11D1-A000-C90629100000"
> #define AMW0_EVENT_GUID "ABBC0F5C-8EA1-11D1-A000-C90629100000"
>
> +/* Legacy GUIDs */
> #define WMI0_EXPENSIVE_GUID "39142400-C6A3-40fa-BADB-8A2652834100"
> +#define WMI0_EVENT_GUID "59142400-C6A3-40fa-BADB-8A2652834100"
> +
> +/* AMW0_commands */
> +
> +enum wmaa_cmd {
> + BATTERY_GET, /* \GBTT 0x00001103 */
> + BATTERY_SET, /* \SBTT 0xXXYY1003 */
> + FN_LOCK_GET, /* \GFRS 0x00000604 */
> + FN_LOCK_SET, /* \SFRS 0x000X0704 */
> + MICMUTE_LED, /* \SMLS 0x000X0b04 */
> +};
> +
> +enum fn_state {
> + FN_LOCK_OFF = 0x01,
> + FN_LOCK_ON = 0x02,
> +};
> +
> +struct quirk_entry {
> + bool battery_sleep;
> + bool ec_micmute;
> + bool report_brightness;
> +};
>
> -struct huawei_wmi_priv {
> - struct input_dev *idev;
> +static struct quirk_entry *quirks;
> +
> +struct huawei_wmi {
> struct led_classdev cdev;
> - acpi_handle handle;
> - char *acpi_method;
> + struct mutex wmi_lock;
> + struct mutex battery_lock;
> + struct input_dev *idev[2];
> + struct platform_device *pdev;
> };
>
> +struct platform_device *huawei_wmi_pdev;
> +
> static const struct key_entry huawei_wmi_keymap[] = {
> { KE_KEY, 0x281, { KEY_BRIGHTNESSDOWN } },
> { KE_KEY, 0x282, { KEY_BRIGHTNESSUP } },
> @@ -37,73 +70,183 @@ static const struct key_entry
> huawei_wmi_keymap[] = {
> { KE_KEY, 0x289, { KEY_WLAN } },
> // Huawei |M| key
> { KE_KEY, 0x28a, { KEY_CONFIG } },
> - // Keyboard backlight
> + // Keyboard backlit
> { KE_IGNORE, 0x293, { KEY_KBDILLUMTOGGLE } },
> { KE_IGNORE, 0x294, { KEY_KBDILLUMUP } },
> { KE_IGNORE, 0x295, { KEY_KBDILLUMUP } },
> { KE_END, 0 }
> };
>
> -static int huawei_wmi_micmute_led_set(struct led_classdev *led_cdev,
> - enum led_brightness brightness)
> +static bool battery_sleep;
> +static bool report_brightness;
> +
> +module_param(battery_sleep, bool, 0444);
> +MODULE_PARM_DESC(battery_sleep,
> + "Delay after setting battery charging thresholds.");
> +module_param(report_brightness, bool, 0444);
> +MODULE_PARM_DESC(report_brightness,
> + "Report brightness key events.");
> +
> +/* Quirks */
> +
> +static int __init dmi_matched(const struct dmi_system_id *dmi)
> {
> - struct huawei_wmi_priv *priv = dev_get_drvdata(led_cdev->dev-
> >parent);
> + quirks = dmi->driver_data;
> + return 1;
> +}
> +
> +static struct quirk_entry quirk_unknown = {
> +};
> +
> +static struct quirk_entry quirk_battery_sleep = {
> + .battery_sleep = true,
> +};
> +
> +static struct quirk_entry quirk_matebook_x = {
> + .ec_micmute = true,
> + .report_brightness = true,
> +};
> +
> +static const struct dmi_system_id huawei_quirks[] = {
> + {
> + .callback = dmi_matched,
> + .ident = "Huawei MACH-WX9",
> + .matches = {
> + DMI_MATCH(DMI_SYS_VENDOR, "HUAWEI"),
> + DMI_MATCH(DMI_PRODUCT_NAME, "MACH-WX9"),
> + },
> + .driver_data = &quirk_battery_sleep
> + },
> + {
> + .callback = dmi_matched,
> + .ident = "Huawei MateBook X",
> + .matches = {
> + DMI_MATCH(DMI_SYS_VENDOR, "HUAWEI"),
> + DMI_MATCH(DMI_PRODUCT_NAME, "HUAWEI MateBook
> X")
> + },
> + .driver_data = &quirk_matebook_x
> + },
> + { }
> +};
> +
> +/* Utils */
> +
> +static int huawei_wmi_eval(struct device *dev, u8 *arg,
> + u8 *buf, size_t buflen)
> +{
> + struct huawei_wmi *huawei = dev_get_drvdata(dev);
> + struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
> + struct acpi_buffer in;
> + union acpi_object *obj;
> acpi_status status;
> - union acpi_object args[3];
> - struct acpi_object_list arg_list = {
> - .pointer = args,
> - .count = ARRAY_SIZE(args),
> - };
> -
> - args[0].type = args[1].type = args[2].type = ACPI_TYPE_INTEGER;
> - args[1].integer.value = 0x04;
> -
> - if (strcmp(priv->acpi_method, "SPIN") == 0) {
> - args[0].integer.value = 0;
> - args[2].integer.value = brightness ? 1 : 0;
> - } else if (strcmp(priv->acpi_method, "WPIN") == 0) {
> - args[0].integer.value = 1;
> - args[2].integer.value = brightness ? 0 : 1;
> - } else {
> - return -EINVAL;
> + size_t len;
> + int err = -EIO;
> +
> + in.length = sizeof(u8) * 4;
> + in.pointer = (u32 *)arg;
> + mutex_lock(&huawei->wmi_lock);
> + status = wmi_evaluate_method(AMW0_METHOD_GUID, 0, 1, &in,
> &out);
> + if (ACPI_FAILURE(status)) {
> + dev_err(dev, "Failed to evaluate wmi method\n");
> + err = -ENODEV;
> + goto wmi_eval_fail;
> + }
> +
> + /* WMAA takes a 4 bytes buffer as an input. It returns a
> package
> + * with two buffer elements. The first buffer is 4 bytes long
> and
> + * the second is 0x100 (256) bytes long. The first buffer is
> always
> + * zeros. The second stores the output from every call. The
> first
> + * byte of the second buffer always have the return status of
> the
> + * called command.
> + */
> + obj = out.pointer;
> + if (!obj)
> + goto wmi_eval_fail;
> + if (obj->type != ACPI_TYPE_PACKAGE || obj->package.count != 2)
> {
> + dev_err(dev, "Unknown response type %d\n", obj->type);
> + goto wmi_eval_fail;
> }
>
> - status = acpi_evaluate_object(priv->handle, priv->acpi_method,
> &arg_list, NULL);
> - if (ACPI_FAILURE(status))
> - return -ENXIO;
> + obj = &(obj->package.elements[1]);
> + if (!obj || obj->type != ACPI_TYPE_BUFFER)
> + goto wmi_eval_fail;
>
> - return 0;
> + if (buf) {
> + len = min(buflen, obj->buffer.length);
> + memcpy(buf, obj->buffer.pointer, len);
> + }
> + err = 0;
> +
> +wmi_eval_fail:
> + mutex_unlock(&huawei->wmi_lock);
> + kfree(out.pointer);
> + return err;
> }
>
> -static int huawei_wmi_leds_setup(struct wmi_device *wdev)
> +static int huawei_wmi_cmd(struct device *dev, enum wmaa_cmd cmd, u8
> *arg,
> + u8 *out, size_t outlen)
> {
> - struct huawei_wmi_priv *priv = dev_get_drvdata(&wdev->dev);
> -
> - priv->handle = ec_get_handle();
> - if (!priv->handle)
> - return 0;
> + u8 parm[4] = { 0 };
> + u8 buf[0x100] = { 0xff };
> + int err;
>
> - if (acpi_has_method(priv->handle, "SPIN"))
> - priv->acpi_method = "SPIN";
> - else if (acpi_has_method(priv->handle, "WPIN"))
> - priv->acpi_method = "WPIN";
> - else
> - return 0;
> + if (!arg)
> + arg = parm;
> +
> + switch (cmd) {
> + case BATTERY_SET:
> + arg[0] = 0x03;
> + arg[1] = 0x10;
> + break;
> + case BATTERY_GET:
> + arg[0] = 0x03;
> + arg[1] = 0x11;
> + break;
> + case FN_LOCK_GET:
> + arg[0] = 0x04;
> + arg[1] = 0x06;
> + break;
> + case FN_LOCK_SET:
> + arg[0] = 0x04;
> + arg[1] = 0x07;
> + break;
> + case MICMUTE_LED:
> + arg[0] = 0x04;
> + arg[1] = 0x0b;
> + break;
> + default:
> + dev_err(dev, "Unsupported command, got: 0x%08x\n",
> *(u32 *)arg);
> + return -EINVAL;
> + }
>
> - priv->cdev.name = "platform::micmute";
> - priv->cdev.max_brightness = 1;
> - priv->cdev.brightness_set_blocking =
> huawei_wmi_micmute_led_set;
> - priv->cdev.default_trigger = "audio-micmute";
> - priv->cdev.brightness = ledtrig_audio_get(LED_AUDIO_MICMUTE);
> - priv->cdev.dev = &wdev->dev;
> - priv->cdev.flags = LED_CORE_SUSPENDRESUME;
> + /* Some models require calling WMAA twice to execute
> + * a command. We call WMAA and if we get a non-zero return
> + * status we evaluate WMAA again. If we get another non-zero
> + * return, we return -EIO. This way we don't need to
> + * check for return status anywhere we call huawei_wmi_cmd.
> + */
> + err = huawei_wmi_eval(dev, arg, buf, 0x100);
> + if (err)
> + return err;
> + if (buf[0]) {
> + err = huawei_wmi_eval(dev, arg, buf, 0x100);
> + if (err)
> + return err;
> + if (buf[0]) {
> + dev_err(dev, "Invalid response, got: %d\n",
> buf[0]);
> + return -EIO;
> + }
> + }
> + if (out)
> + memcpy(out, buf, outlen);
>
> - return devm_led_classdev_register(&wdev->dev, &priv->cdev);
> + return 0;
> }
>
> -static void huawei_wmi_process_key(struct wmi_device *wdev, int
> code)
> +/* Input */
> +
> +static void huawei_wmi_process_key(struct input_dev *idev, int code)
> {
> - struct huawei_wmi_priv *priv = dev_get_drvdata(&wdev->dev);
> const struct key_entry *key;
>
> /*
> @@ -127,81 +270,390 @@ static void huawei_wmi_process_key(struct
> wmi_device *wdev, int code)
> kfree(response.pointer);
> }
>
> - key = sparse_keymap_entry_from_scancode(priv->idev, code);
> + key = sparse_keymap_entry_from_scancode(idev, code);
> if (!key) {
> - dev_info(&wdev->dev, "Unknown key pressed, code:
> 0x%04x\n", code);
> + dev_info(&idev->dev, "Unknown key pressed, code:
> 0x%04x\n", code);
> return;
> }
>
> - sparse_keymap_report_entry(priv->idev, key, 1, true);
> + if (quirks && !quirks->report_brightness &&
> + (key->sw.code == KEY_BRIGHTNESSDOWN ||
> + key->sw.code == KEY_BRIGHTNESSUP))
> + return;
> +
> + sparse_keymap_report_entry(idev, key, 1, true);
> }
>
> -static void huawei_wmi_notify(struct wmi_device *wdev,
> - union acpi_object *obj)
> +static void huawei_wmi_input_notify(u32 value, void *context)
> {
> - if (obj->type == ACPI_TYPE_INTEGER)
> - huawei_wmi_process_key(wdev, obj->integer.value);
> + struct input_dev *idev = (struct input_dev *)context;
> + struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
> + union acpi_object *obj;
> + acpi_status status;
> +
> + if (!idev) {
> + dev_err(&huawei_wmi_pdev->dev, "No input_dev\n");
> + return;
> + }
> +
> + status = wmi_get_event_data(value, &response);
> + if (ACPI_FAILURE(status)) {
> + dev_err(&idev->dev, "Unable to get event data\n");
> + return;
> + }
> +
> + obj = (union acpi_object *)response.pointer;
> + if (obj && obj->type == ACPI_TYPE_INTEGER)
> + huawei_wmi_process_key(idev, obj->integer.value);
> else
> - dev_info(&wdev->dev, "Bad response type %d\n", obj-
> >type);
> + dev_err(&idev->dev, "Bad response type\n");
> +
> + kfree(response.pointer);
> }
>
> -static int huawei_wmi_input_setup(struct wmi_device *wdev)
> +static int huawei_wmi_input_setup(struct platform_device *pdev,
> + struct input_dev **idev)
> {
> - struct huawei_wmi_priv *priv = dev_get_drvdata(&wdev->dev);
> int err;
>
> - priv->idev = devm_input_allocate_device(&wdev->dev);
> - if (!priv->idev)
> + *idev = devm_input_allocate_device(&pdev->dev);
> + if (!*idev)
> return -ENOMEM;
>
> - priv->idev->name = "Huawei WMI hotkeys";
> - priv->idev->phys = "wmi/input0";
> - priv->idev->id.bustype = BUS_HOST;
> - priv->idev->dev.parent = &wdev->dev;
> + (*idev)->name = "Huawei WMI hotkeys";
> + (*idev)->phys = "wmi/input0";
> + (*idev)->id.bustype = BUS_HOST;
> + (*idev)->dev.parent = &pdev->dev;
> +
> + err = sparse_keymap_setup(*idev, huawei_wmi_keymap, NULL);
> + if (err)
> + return err;
> +
> + return input_register_device(*idev);
> +}
> +
> +/* LEDs */
> +
> +static void huawei_wmi_micmute_led_set(struct led_classdev
> *led_cdev,
> + enum led_brightness brightness)
> +{
> + /* This is a workaround until the "legacy" interface is
> implemented. */
> + if (quirks && quirks->ec_micmute) {
> + char *acpi_method;
> + acpi_handle handle;
> + union acpi_object args[3];
> + struct acpi_object_list arg_list = {
> + .pointer = args,
> + .count = ARRAY_SIZE(args),
> + };
> +
> + handle = ec_get_handle();
> + if (!handle) {
> + dev_err(led_cdev->dev->parent, "Failed to get
> EC handle\n");
> + return;
> + }
> +
> + args[0].type = args[1].type = args[2].type =
> ACPI_TYPE_INTEGER;
> + args[1].integer.value = 0x04;
> +
> + if (acpi_has_method(handle, "SPIN")) {
> + acpi_method = "SPIN";
> + args[0].integer.value = 0;
> + args[2].integer.value = brightness ? 1 : 0;
> + } else if (acpi_has_method(handle, "WPIN")) {
> + acpi_method = "WPIN";
> + args[0].integer.value = 1;
> + args[2].integer.value = brightness ? 0 : 1;
> + } else {
> + return;
> + }
> +
> + acpi_evaluate_object(handle, acpi_method, &arg_list,
> NULL);
> + } else {
> + u8 arg[] = { 0, 0, brightness, 0 };
> +
> + huawei_wmi_cmd(led_cdev->dev->parent, MICMUTE_LED, arg,
> NULL, NULL);
> + }
> +}
> +
> +static int huawei_wmi_leds_setup(struct device *dev)
> +{
> + struct huawei_wmi *huawei = dev_get_drvdata(dev);
>
> - err = sparse_keymap_setup(priv->idev, huawei_wmi_keymap, NULL);
> + huawei->cdev.name = "platform::micmute";
> + huawei->cdev.max_brightness = 1;
> + huawei->cdev.brightness_set = huawei_wmi_micmute_led_set;
> + huawei->cdev.default_trigger = "audio-micmute";
> + huawei->cdev.brightness = ledtrig_audio_get(LED_AUDIO_MICMUTE);
> + huawei->cdev.dev = dev->parent;
> + huawei->cdev.flags = LED_CORE_SUSPENDRESUME;
> +
> + return devm_led_classdev_register(dev, &huawei->cdev);
> +}
> +
> +/* Battery protection */
> +
> +static int huawei_wmi_battery_get(struct device *dev, int *low, int
> *high)
> +{
> + struct huawei_wmi *huawei = dev_get_drvdata(dev);
> + u8 ret[0x100] = { 0 };
> + int err, i = 0x100;
> +
> + mutex_lock(&huawei->battery_lock);
> + err = huawei_wmi_cmd(dev, BATTERY_GET, NULL, ret, 0x100);
> + mutex_unlock(&huawei->battery_lock);
> if (err)
> return err;
>
> - return input_register_device(priv->idev);
> + /* Returned buffer positions battery thresholds either in index
> + * 3 and 2 or in 2 and 1. 0 reserved for return status. We
> + * find the first non-zero value.
> + */
> + while (i > 0 && !ret[i--])
> + ;
> + *low = ret[i];
> + *high = ret[i+1];
> +
> + return 0;
> }
>
> -static int huawei_wmi_probe(struct wmi_device *wdev)
> +static int huawei_wmi_battery_set(struct device *dev, int low, int
> high)
> {
> - struct huawei_wmi_priv *priv;
> + struct huawei_wmi *huawei = dev_get_drvdata(dev);
> + u8 arg[] = { 0, 0, low, high };
> int err;
>
> - priv = devm_kzalloc(&wdev->dev, sizeof(struct huawei_wmi_priv),
> GFP_KERNEL);
> - if (!priv)
> - return -ENOMEM;
> + /* This is an edge case were some models turn battery
> protection
> + * off without changing their thresholds values. We clear the
> + * values before turning off protection. We need a blocking
> delay to
> + * make sure these values make their way to EC.
> + */
> + if (low == 0 && high == 100)
> + huawei_wmi_battery_set(dev, 0, 0);
>
> - dev_set_drvdata(&wdev->dev, priv);
> + mutex_lock(&huawei->battery_lock);
> + err = huawei_wmi_cmd(dev, BATTERY_SET, arg, NULL, NULL);
> + if (quirks && quirks->battery_sleep)
> + msleep(1000);
> + mutex_unlock(&huawei->battery_lock);
>
> - err = huawei_wmi_input_setup(wdev);
> + return err;
> +}
> +
> +/* Fn lock */
> +
> +static int huawei_wmi_fn_lock_get(struct device *dev, int *on)
> +{
> + u8 ret[0x100] = { 0 };
> + int err, i = 0;
> +
> + err = huawei_wmi_cmd(dev, FN_LOCK_GET, NULL, ret, 0x100);
> if (err)
> return err;
>
> - return huawei_wmi_leds_setup(wdev);
> + /* Find the first non-zero value */
> + while (i <= 0x100 && !ret[i++])
> + ;
> + *on = (ret[i-1] == FN_LOCK_OFF) ? 0 : 1;
> +
> + return 0;
> }
>
> -static const struct wmi_device_id huawei_wmi_id_table[] = {
> - { .guid_string = WMI0_EVENT_GUID },
> - { .guid_string = AMW0_EVENT_GUID },
> - { }
> +static int huawei_wmi_fn_lock_set(struct device *dev, int on)
> +{
> + u8 arg[] = { 0, 0, (on) ? FN_LOCK_ON : FN_LOCK_OFF, 0 };
> +
> + return huawei_wmi_cmd(dev, FN_LOCK_SET, arg, NULL, NULL);
> +}
> +
> +/* sysfs */
> +
> +static ssize_t charge_thresholds_store(struct device *dev,
> + struct device_attribute *attr,
> + const char *buf, size_t size)
> +{
> + int low, high, err;
> +
> + if (sscanf(buf, "%d %d", &low, &high) != 2 ||
> + low < 0 || high > 100 ||
> + low > high)
> + return -EINVAL;
> +
> + err = huawei_wmi_battery_set(dev, low, high);
> + if (err)
> + return err;
> +
> + return size;
> +}
> +
> +static ssize_t fn_lock_state_store(struct device *dev,
> + struct device_attribute *attr,
> + const char *buf, size_t size)
> +{
> + int on, err;
> +
> + if (kstrtoint(buf, 10, &on) ||
> + on < 0 || on > 1)
> + return -EINVAL;
> +
> + err = huawei_wmi_fn_lock_set(dev, on);
> + if (err)
> + return err;
> +
> + return size;
> +}
> +
> +static ssize_t charge_thresholds_show(struct device *dev,
> + struct device_attribute *attr,
> + char *buf)
> +{
> + int err, low = -1, high = -1;
> +
> + err = huawei_wmi_battery_get(dev, &low, &high);
> + if (err)
> + return err;
> +
> + return sprintf(buf, "%d %d\n", low, high);
> +}
> +
> +static ssize_t fn_lock_state_show(struct device *dev,
> + struct device_attribute *attr,
> + char *buf)
> +{
> + int err, on = -1;
> +
> + err = huawei_wmi_fn_lock_get(dev, &on);
> + if (err)
> + return err;
> +
> + return sprintf(buf, "%d\n", on);
> +}
> +
> +static DEVICE_ATTR_RW(charge_thresholds);
> +static DEVICE_ATTR_RW(fn_lock_state);
> +
> +static struct attribute *huawei_wmi_attrs[] = {
> + &dev_attr_charge_thresholds.attr,
> + &dev_attr_fn_lock_state.attr,
> + NULL
> +};
> +
> +static const struct attribute_group huawei_wmi_group = {
> + .attrs = huawei_wmi_attrs
> };
>
> -static struct wmi_driver huawei_wmi_driver = {
> +/* Huawei driver */
> +
> +static int huawei_wmi_probe(struct platform_device *pdev)
> +{
> + struct huawei_wmi *huawei;
> + int err;
> +
> + huawei = devm_kzalloc(&pdev->dev, sizeof(struct huawei_wmi),
> GFP_KERNEL);
> + if (!huawei)
> + return -ENOMEM;
> +
> + huawei->pdev = pdev;
> + dev_set_drvdata(&pdev->dev, huawei);
> +
> + if (wmi_has_guid(WMI0_EVENT_GUID)) {
> + err = huawei_wmi_input_setup(pdev, &huawei->idev[0]);
> + if (err)
> + dev_err(&pdev->dev, "Failed to setup input
> device\n");
> + err = wmi_install_notify_handler(WMI0_EVENT_GUID,
> + huawei_wmi_input_notify, huawei-
> >idev[0]);
> + if (err)
> + dev_err(&pdev->dev, "Failed to install notify
> handler\n");
> + }
> +
> + if (wmi_has_guid(AMW0_EVENT_GUID)) {
> + err = huawei_wmi_input_setup(pdev, &huawei->idev[1]);
> + if (err)
> + dev_err(&pdev->dev, "Failed to setup input
> device\n");
> + err = wmi_install_notify_handler(AMW0_EVENT_GUID,
> + huawei_wmi_input_notify, huawei-
> >idev[1]);
> + if (err)
> + dev_err(&pdev->dev, "Failed to install notify
> handler\n");
> + }
> +
> + if (wmi_has_guid(AMW0_METHOD_GUID)) {
> +
> + mutex_init(&huawei->wmi_lock);
> + mutex_init(&huawei->battery_lock);
> +
> + err = sysfs_create_group(&pdev->dev.kobj,
> &huawei_wmi_group);
> + if (err) {
> + dev_err(&pdev->dev, "Failed to create sysfs
> interface\n");
> + return err;
> + }
> +
> + err = huawei_wmi_leds_setup(&pdev->dev);
> + if (err)
> + dev_err(&pdev->dev, "Failed to setup leds\n");
> + }
> +
> + return 0;
> +}
> +
> +static int huawei_wmi_remove(struct platform_device *pdev)
> +{
> + if (wmi_has_guid(WMI0_EVENT_GUID))
> + wmi_remove_notify_handler(WMI0_EVENT_GUID);
> +
> + if (wmi_has_guid(AMW0_EVENT_GUID))
> + wmi_remove_notify_handler(AMW0_EVENT_GUID);
> +
> + if (wmi_has_guid(AMW0_METHOD_GUID))
> + sysfs_remove_group(&pdev->dev.kobj, &huawei_wmi_group);
> +
> + return 0;
> +}
> +
> +static struct platform_driver huawei_wmi_driver = {
> .driver = {
> .name = "huawei-wmi",
> },
> - .id_table = huawei_wmi_id_table,
> .probe = huawei_wmi_probe,
> - .notify = huawei_wmi_notify,
> + .remove = huawei_wmi_remove,
> };
>
> -module_wmi_driver(huawei_wmi_driver);
> +static __init int huawei_wmi_init(void)
> +{
> + int err;
> +
> + quirks = &quirk_unknown;
> + dmi_check_system(huawei_quirks);
> + quirks->battery_sleep |= battery_sleep;
> + quirks->report_brightness |= report_brightness;
> +
> + err = platform_driver_register(&huawei_wmi_driver);
> + if (err) {
> + pr_err("Failed to register platform driver\n");
> + return err;
> + }
> +
> + huawei_wmi_pdev = platform_device_register_simple("huawei-wmi",
> -1, NULL, 0);
> + if (IS_ERR(huawei_wmi_pdev)) {
> + pr_err("Failed to register platform device\n");
> + platform_driver_unregister(&huawei_wmi_driver);
> + return PTR_ERR(huawei_wmi_pdev);
> + }
> +
> + return 0;
> +}
> +
> +static __exit void huawei_wmi_exit(void)
> +{
> + platform_device_unregister(huawei_wmi_pdev);
> + platform_driver_unregister(&huawei_wmi_driver);
> +}
> +
> +module_init(huawei_wmi_init);
> +module_exit(huawei_wmi_exit);
>
> -MODULE_DEVICE_TABLE(wmi, huawei_wmi_id_table);
> +MODULE_ALIAS("wmi:"WMI0_EVENT_GUID);
> +MODULE_ALIAS("wmi:"AMW0_EVENT_GUID);
> +MODULE_ALIAS("wmi:"AMW0_METHOD_GUID);
> MODULE_AUTHOR("Ayman Bagabas <ayman.bagabas@xxxxxxxxx>");
> -MODULE_DESCRIPTION("Huawei WMI hotkeys");
> +MODULE_DESCRIPTION("Huawei WMI laptop extras driver");
> MODULE_LICENSE("GPL v2");
