1b886d83cSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 261cd4822SLejun Zhu /* 361cd4822SLejun Zhu * Supports for the button array on SoC tablets originally running 461cd4822SLejun Zhu * Windows 8. 561cd4822SLejun Zhu * 661cd4822SLejun Zhu * (C) Copyright 2014 Intel Corporation 761cd4822SLejun Zhu */ 861cd4822SLejun Zhu 961cd4822SLejun Zhu #include <linux/module.h> 1061cd4822SLejun Zhu #include <linux/input.h> 1161cd4822SLejun Zhu #include <linux/init.h> 12fa248db0SDmitry Torokhov #include <linux/irq.h> 1361cd4822SLejun Zhu #include <linux/kernel.h> 1461cd4822SLejun Zhu #include <linux/acpi.h> 1578a5b53eSHans de Goede #include <linux/dmi.h> 1661cd4822SLejun Zhu #include <linux/gpio/consumer.h> 1761cd4822SLejun Zhu #include <linux/gpio_keys.h> 18be8e7a7eSBenjamin Tissoires #include <linux/gpio.h> 1961cd4822SLejun Zhu #include <linux/platform_device.h> 2061cd4822SLejun Zhu 2161cd4822SLejun Zhu struct soc_button_info { 2261cd4822SLejun Zhu const char *name; 2361cd4822SLejun Zhu int acpi_index; 2461cd4822SLejun Zhu unsigned int event_type; 2561cd4822SLejun Zhu unsigned int event_code; 2661cd4822SLejun Zhu bool autorepeat; 2761cd4822SLejun Zhu bool wakeup; 28838fc808SHans de Goede bool active_low; 2961cd4822SLejun Zhu }; 3061cd4822SLejun Zhu 31c3941593SMaximilian Luz struct soc_device_data { 32c3941593SMaximilian Luz const struct soc_button_info *button_info; 33c3941593SMaximilian Luz int (*check)(struct device *dev); 34c3941593SMaximilian Luz }; 35c3941593SMaximilian Luz 3661cd4822SLejun Zhu /* 3761cd4822SLejun Zhu * Some of the buttons like volume up/down are auto repeat, while others 3861cd4822SLejun Zhu * are not. To support both, we register two platform devices, and put 3961cd4822SLejun Zhu * buttons into them based on whether the key should be auto repeat. 4061cd4822SLejun Zhu */ 4161cd4822SLejun Zhu #define BUTTON_TYPES 2 4261cd4822SLejun Zhu 4361cd4822SLejun Zhu struct soc_button_data { 4461cd4822SLejun Zhu struct platform_device *children[BUTTON_TYPES]; 4561cd4822SLejun Zhu }; 4661cd4822SLejun Zhu 4761cd4822SLejun Zhu /* 4878a5b53eSHans de Goede * Some 2-in-1s which use the soc_button_array driver have this ugly issue in 4978a5b53eSHans de Goede * their DSDT where the _LID method modifies the irq-type settings of the GPIOs 5078a5b53eSHans de Goede * used for the power and home buttons. The intend of this AML code is to 5178a5b53eSHans de Goede * disable these buttons when the lid is closed. 5278a5b53eSHans de Goede * The AML does this by directly poking the GPIO controllers registers. This is 5378a5b53eSHans de Goede * problematic because when re-enabling the irq, which happens whenever _LID 5478a5b53eSHans de Goede * gets called with the lid open (e.g. on boot and on resume), it sets the 5578a5b53eSHans de Goede * irq-type to IRQ_TYPE_LEVEL_LOW. Where as the gpio-keys driver programs the 5678a5b53eSHans de Goede * type to, and expects it to be, IRQ_TYPE_EDGE_BOTH. 5778a5b53eSHans de Goede * To work around this we don't set gpio_keys_button.gpio on these 2-in-1s, 5878a5b53eSHans de Goede * instead we get the irq for the GPIO ourselves, configure it as 5978a5b53eSHans de Goede * IRQ_TYPE_LEVEL_LOW (to match how the _LID AML code configures it) and pass 6078a5b53eSHans de Goede * the irq in gpio_keys_button.irq. Below is a list of affected devices. 6178a5b53eSHans de Goede */ 6278a5b53eSHans de Goede static const struct dmi_system_id dmi_use_low_level_irq[] = { 6378a5b53eSHans de Goede { 6478a5b53eSHans de Goede /* 6578a5b53eSHans de Goede * Acer Switch 10 SW5-012. _LID method messes with home- and 6678a5b53eSHans de Goede * power-button GPIO IRQ settings. When (re-)enabling the irq 6778a5b53eSHans de Goede * it ors in its own flags without clearing the previous set 6878a5b53eSHans de Goede * ones, leading to an irq-type of IRQ_TYPE_LEVEL_LOW | 6978a5b53eSHans de Goede * IRQ_TYPE_LEVEL_HIGH causing a continuous interrupt storm. 7078a5b53eSHans de Goede */ 7178a5b53eSHans de Goede .matches = { 7278a5b53eSHans de Goede DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 7378a5b53eSHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "Aspire SW5-012"), 7478a5b53eSHans de Goede }, 7578a5b53eSHans de Goede }, 7678a5b53eSHans de Goede { 7778a5b53eSHans de Goede /* 7878a5b53eSHans de Goede * Acer One S1003. _LID method messes with power-button GPIO 7978a5b53eSHans de Goede * IRQ settings, leading to a non working power-button. 8078a5b53eSHans de Goede */ 8178a5b53eSHans de Goede .matches = { 8278a5b53eSHans de Goede DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 8378a5b53eSHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "One S1003"), 8478a5b53eSHans de Goede }, 8578a5b53eSHans de Goede }, 86223f61b8SHans de Goede { 87223f61b8SHans de Goede /* 88223f61b8SHans de Goede * Lenovo Yoga Tab2 1051L, something messes with the home-button 89223f61b8SHans de Goede * IRQ settings, leading to a non working home-button. 90223f61b8SHans de Goede */ 91223f61b8SHans de Goede .matches = { 92223f61b8SHans de Goede DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 93223f61b8SHans de Goede DMI_MATCH(DMI_PRODUCT_NAME, "60073"), 94223f61b8SHans de Goede DMI_MATCH(DMI_PRODUCT_VERSION, "1051L"), 95223f61b8SHans de Goede }, 96223f61b8SHans de Goede }, 9778a5b53eSHans de Goede {} /* Terminating entry */ 9878a5b53eSHans de Goede }; 9978a5b53eSHans de Goede 10078a5b53eSHans de Goede /* 10161cd4822SLejun Zhu * Get the Nth GPIO number from the ACPI object. 10261cd4822SLejun Zhu */ 10378a5b53eSHans de Goede static int soc_button_lookup_gpio(struct device *dev, int acpi_index, 10478a5b53eSHans de Goede int *gpio_ret, int *irq_ret) 10561cd4822SLejun Zhu { 10661cd4822SLejun Zhu struct gpio_desc *desc; 10761cd4822SLejun Zhu 108a01cd170SHans de Goede desc = gpiod_get_index(dev, NULL, acpi_index, GPIOD_ASIS); 10961cd4822SLejun Zhu if (IS_ERR(desc)) 11061cd4822SLejun Zhu return PTR_ERR(desc); 11161cd4822SLejun Zhu 11278a5b53eSHans de Goede *gpio_ret = desc_to_gpio(desc); 11378a5b53eSHans de Goede *irq_ret = gpiod_to_irq(desc); 11461cd4822SLejun Zhu 11561cd4822SLejun Zhu gpiod_put(desc); 11661cd4822SLejun Zhu 11778a5b53eSHans de Goede return 0; 11861cd4822SLejun Zhu } 11961cd4822SLejun Zhu 12061cd4822SLejun Zhu static struct platform_device * 121042e1c79SJin Yao soc_button_device_create(struct platform_device *pdev, 12261cd4822SLejun Zhu const struct soc_button_info *button_info, 12361cd4822SLejun Zhu bool autorepeat) 12461cd4822SLejun Zhu { 12561cd4822SLejun Zhu const struct soc_button_info *info; 12661cd4822SLejun Zhu struct platform_device *pd; 12761cd4822SLejun Zhu struct gpio_keys_button *gpio_keys; 12861cd4822SLejun Zhu struct gpio_keys_platform_data *gpio_keys_pdata; 12978a5b53eSHans de Goede int error, gpio, irq; 13061cd4822SLejun Zhu int n_buttons = 0; 13161cd4822SLejun Zhu 1327283b47dSHans de Goede for (info = button_info; info->name; info++) 1337283b47dSHans de Goede if (info->autorepeat == autorepeat) 1347283b47dSHans de Goede n_buttons++; 1357283b47dSHans de Goede 13661cd4822SLejun Zhu gpio_keys_pdata = devm_kzalloc(&pdev->dev, 13761cd4822SLejun Zhu sizeof(*gpio_keys_pdata) + 1387283b47dSHans de Goede sizeof(*gpio_keys) * n_buttons, 13961cd4822SLejun Zhu GFP_KERNEL); 14091cf07cdSPramod Gurav if (!gpio_keys_pdata) 14191cf07cdSPramod Gurav return ERR_PTR(-ENOMEM); 14291cf07cdSPramod Gurav 14361cd4822SLejun Zhu gpio_keys = (void *)(gpio_keys_pdata + 1); 1447283b47dSHans de Goede n_buttons = 0; 14561cd4822SLejun Zhu 14661cd4822SLejun Zhu for (info = button_info; info->name; info++) { 14761cd4822SLejun Zhu if (info->autorepeat != autorepeat) 14861cd4822SLejun Zhu continue; 14961cd4822SLejun Zhu 15078a5b53eSHans de Goede error = soc_button_lookup_gpio(&pdev->dev, info->acpi_index, &gpio, &irq); 15178a5b53eSHans de Goede if (error || irq < 0) { 152bcf05957SHans de Goede /* 153bcf05957SHans de Goede * Skip GPIO if not present. Note we deliberately 154bcf05957SHans de Goede * ignore -EPROBE_DEFER errors here. On some devices 155bcf05957SHans de Goede * Intel is using so called virtual GPIOs which are not 156bcf05957SHans de Goede * GPIOs at all but some way for AML code to check some 157bcf05957SHans de Goede * random status bits without need a custom opregion. 158bcf05957SHans de Goede * In some cases the resources table we parse points to 159bcf05957SHans de Goede * such a virtual GPIO, since these are not real GPIOs 160bcf05957SHans de Goede * we do not have a driver for these so they will never 161bcf05957SHans de Goede * show up, therefore we ignore -EPROBE_DEFER. 162bcf05957SHans de Goede */ 16361cd4822SLejun Zhu continue; 164c3941593SMaximilian Luz } 16561cd4822SLejun Zhu 16678a5b53eSHans de Goede /* See dmi_use_low_level_irq[] comment */ 16778a5b53eSHans de Goede if (!autorepeat && dmi_check_system(dmi_use_low_level_irq)) { 16878a5b53eSHans de Goede irq_set_irq_type(irq, IRQ_TYPE_LEVEL_LOW); 16978a5b53eSHans de Goede gpio_keys[n_buttons].irq = irq; 17078a5b53eSHans de Goede gpio_keys[n_buttons].gpio = -ENOENT; 17178a5b53eSHans de Goede } else { 17278a5b53eSHans de Goede gpio_keys[n_buttons].gpio = gpio; 17378a5b53eSHans de Goede } 17478a5b53eSHans de Goede 17561cd4822SLejun Zhu gpio_keys[n_buttons].type = info->event_type; 17661cd4822SLejun Zhu gpio_keys[n_buttons].code = info->event_code; 177838fc808SHans de Goede gpio_keys[n_buttons].active_low = info->active_low; 17861cd4822SLejun Zhu gpio_keys[n_buttons].desc = info->name; 17961cd4822SLejun Zhu gpio_keys[n_buttons].wakeup = info->wakeup; 1805c4fa2a6SHans de Goede /* These devices often use cheap buttons, use 50 ms debounce */ 1815c4fa2a6SHans de Goede gpio_keys[n_buttons].debounce_interval = 50; 18261cd4822SLejun Zhu n_buttons++; 18361cd4822SLejun Zhu } 18461cd4822SLejun Zhu 18561cd4822SLejun Zhu if (n_buttons == 0) { 18661cd4822SLejun Zhu error = -ENODEV; 18761cd4822SLejun Zhu goto err_free_mem; 18861cd4822SLejun Zhu } 18961cd4822SLejun Zhu 19061cd4822SLejun Zhu gpio_keys_pdata->buttons = gpio_keys; 19161cd4822SLejun Zhu gpio_keys_pdata->nbuttons = n_buttons; 19261cd4822SLejun Zhu gpio_keys_pdata->rep = autorepeat; 19361cd4822SLejun Zhu 19453119e51SEnrico Weigelt pd = platform_device_register_resndata(&pdev->dev, "gpio-keys", 19553119e51SEnrico Weigelt PLATFORM_DEVID_AUTO, NULL, 0, 19653119e51SEnrico Weigelt gpio_keys_pdata, 19753119e51SEnrico Weigelt sizeof(*gpio_keys_pdata)); 19853119e51SEnrico Weigelt error = PTR_ERR_OR_ZERO(pd); 19953119e51SEnrico Weigelt if (error) { 20053119e51SEnrico Weigelt dev_err(&pdev->dev, 20153119e51SEnrico Weigelt "failed registering gpio-keys: %d\n", error); 20261cd4822SLejun Zhu goto err_free_mem; 20361cd4822SLejun Zhu } 20461cd4822SLejun Zhu 20561cd4822SLejun Zhu return pd; 20661cd4822SLejun Zhu 20761cd4822SLejun Zhu err_free_mem: 20861cd4822SLejun Zhu devm_kfree(&pdev->dev, gpio_keys_pdata); 20961cd4822SLejun Zhu return ERR_PTR(error); 21061cd4822SLejun Zhu } 21161cd4822SLejun Zhu 2124c3362f4SHans de Goede static int soc_button_get_acpi_object_int(const union acpi_object *obj) 2134c3362f4SHans de Goede { 2144c3362f4SHans de Goede if (obj->type != ACPI_TYPE_INTEGER) 2154c3362f4SHans de Goede return -1; 2164c3362f4SHans de Goede 2174c3362f4SHans de Goede return obj->integer.value; 2184c3362f4SHans de Goede } 2194c3362f4SHans de Goede 2204c3362f4SHans de Goede /* Parse a single ACPI0011 _DSD button descriptor */ 2214c3362f4SHans de Goede static int soc_button_parse_btn_desc(struct device *dev, 2224c3362f4SHans de Goede const union acpi_object *desc, 2234c3362f4SHans de Goede int collection_uid, 2244c3362f4SHans de Goede struct soc_button_info *info) 2254c3362f4SHans de Goede { 2264c3362f4SHans de Goede int upage, usage; 2274c3362f4SHans de Goede 2284c3362f4SHans de Goede if (desc->type != ACPI_TYPE_PACKAGE || 2294c3362f4SHans de Goede desc->package.count != 5 || 2304c3362f4SHans de Goede /* First byte should be 1 (control) */ 2314c3362f4SHans de Goede soc_button_get_acpi_object_int(&desc->package.elements[0]) != 1 || 2324c3362f4SHans de Goede /* Third byte should be collection uid */ 2334c3362f4SHans de Goede soc_button_get_acpi_object_int(&desc->package.elements[2]) != 2344c3362f4SHans de Goede collection_uid) { 2354c3362f4SHans de Goede dev_err(dev, "Invalid ACPI Button Descriptor\n"); 2364c3362f4SHans de Goede return -ENODEV; 2374c3362f4SHans de Goede } 2384c3362f4SHans de Goede 2394c3362f4SHans de Goede info->event_type = EV_KEY; 240838fc808SHans de Goede info->active_low = true; 2414c3362f4SHans de Goede info->acpi_index = 2424c3362f4SHans de Goede soc_button_get_acpi_object_int(&desc->package.elements[1]); 2434c3362f4SHans de Goede upage = soc_button_get_acpi_object_int(&desc->package.elements[3]); 2444c3362f4SHans de Goede usage = soc_button_get_acpi_object_int(&desc->package.elements[4]); 2454c3362f4SHans de Goede 2464c3362f4SHans de Goede /* 2474c3362f4SHans de Goede * The UUID: fa6bd625-9ce8-470d-a2c7-b3ca36c4282e descriptors use HID 2484c3362f4SHans de Goede * usage page and usage codes, but otherwise the device is not HID 2494c3362f4SHans de Goede * compliant: it uses one irq per button instead of generating HID 2504c3362f4SHans de Goede * input reports and some buttons should generate wakeups where as 2514c3362f4SHans de Goede * others should not, so we cannot use the HID subsystem. 2524c3362f4SHans de Goede * 2534c3362f4SHans de Goede * Luckily all devices only use a few usage page + usage combinations, 2544c3362f4SHans de Goede * so we can simply check for the known combinations here. 2554c3362f4SHans de Goede */ 2564c3362f4SHans de Goede if (upage == 0x01 && usage == 0x81) { 2574c3362f4SHans de Goede info->name = "power"; 2584c3362f4SHans de Goede info->event_code = KEY_POWER; 2594c3362f4SHans de Goede info->wakeup = true; 26039be9b6dSHans de Goede } else if (upage == 0x01 && usage == 0xca) { 26139be9b6dSHans de Goede info->name = "rotation lock switch"; 26239be9b6dSHans de Goede info->event_type = EV_SW; 26339be9b6dSHans de Goede info->event_code = SW_ROTATE_LOCK; 2644c3362f4SHans de Goede } else if (upage == 0x07 && usage == 0xe3) { 2654c3362f4SHans de Goede info->name = "home"; 266dd224085SHans de Goede info->event_code = KEY_LEFTMETA; 2674c3362f4SHans de Goede info->wakeup = true; 2684c3362f4SHans de Goede } else if (upage == 0x0c && usage == 0xe9) { 2694c3362f4SHans de Goede info->name = "volume_up"; 2704c3362f4SHans de Goede info->event_code = KEY_VOLUMEUP; 2714c3362f4SHans de Goede info->autorepeat = true; 2724c3362f4SHans de Goede } else if (upage == 0x0c && usage == 0xea) { 2734c3362f4SHans de Goede info->name = "volume_down"; 2744c3362f4SHans de Goede info->event_code = KEY_VOLUMEDOWN; 2754c3362f4SHans de Goede info->autorepeat = true; 2764c3362f4SHans de Goede } else { 2774c3362f4SHans de Goede dev_warn(dev, "Unknown button index %d upage %02x usage %02x, ignoring\n", 2784c3362f4SHans de Goede info->acpi_index, upage, usage); 2794c3362f4SHans de Goede info->name = "unknown"; 2804c3362f4SHans de Goede info->event_code = KEY_RESERVED; 2814c3362f4SHans de Goede } 2824c3362f4SHans de Goede 2834c3362f4SHans de Goede return 0; 2844c3362f4SHans de Goede } 2854c3362f4SHans de Goede 2864c3362f4SHans de Goede /* ACPI0011 _DSD btns descriptors UUID: fa6bd625-9ce8-470d-a2c7-b3ca36c4282e */ 2874c3362f4SHans de Goede static const u8 btns_desc_uuid[16] = { 2884c3362f4SHans de Goede 0x25, 0xd6, 0x6b, 0xfa, 0xe8, 0x9c, 0x0d, 0x47, 2894c3362f4SHans de Goede 0xa2, 0xc7, 0xb3, 0xca, 0x36, 0xc4, 0x28, 0x2e 2904c3362f4SHans de Goede }; 2914c3362f4SHans de Goede 2924c3362f4SHans de Goede /* Parse ACPI0011 _DSD button descriptors */ 2934c3362f4SHans de Goede static struct soc_button_info *soc_button_get_button_info(struct device *dev) 2944c3362f4SHans de Goede { 2954c3362f4SHans de Goede struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER }; 2964c3362f4SHans de Goede const union acpi_object *desc, *el0, *uuid, *btns_desc = NULL; 2974c3362f4SHans de Goede struct soc_button_info *button_info; 2984c3362f4SHans de Goede acpi_status status; 2994c3362f4SHans de Goede int i, btn, collection_uid = -1; 3004c3362f4SHans de Goede 3014c3362f4SHans de Goede status = acpi_evaluate_object_typed(ACPI_HANDLE(dev), "_DSD", NULL, 3024c3362f4SHans de Goede &buf, ACPI_TYPE_PACKAGE); 3034c3362f4SHans de Goede if (ACPI_FAILURE(status)) { 3044c3362f4SHans de Goede dev_err(dev, "ACPI _DSD object not found\n"); 3054c3362f4SHans de Goede return ERR_PTR(-ENODEV); 3064c3362f4SHans de Goede } 3074c3362f4SHans de Goede 3084c3362f4SHans de Goede /* Look for the Button Descriptors UUID */ 3094c3362f4SHans de Goede desc = buf.pointer; 3104c3362f4SHans de Goede for (i = 0; (i + 1) < desc->package.count; i += 2) { 3114c3362f4SHans de Goede uuid = &desc->package.elements[i]; 3124c3362f4SHans de Goede 3134c3362f4SHans de Goede if (uuid->type != ACPI_TYPE_BUFFER || 3144c3362f4SHans de Goede uuid->buffer.length != 16 || 3154c3362f4SHans de Goede desc->package.elements[i + 1].type != ACPI_TYPE_PACKAGE) { 3164c3362f4SHans de Goede break; 3174c3362f4SHans de Goede } 3184c3362f4SHans de Goede 3194c3362f4SHans de Goede if (memcmp(uuid->buffer.pointer, btns_desc_uuid, 16) == 0) { 3204c3362f4SHans de Goede btns_desc = &desc->package.elements[i + 1]; 3214c3362f4SHans de Goede break; 3224c3362f4SHans de Goede } 3234c3362f4SHans de Goede } 3244c3362f4SHans de Goede 3254c3362f4SHans de Goede if (!btns_desc) { 3264c3362f4SHans de Goede dev_err(dev, "ACPI Button Descriptors not found\n"); 327779f19acSHans de Goede button_info = ERR_PTR(-ENODEV); 328779f19acSHans de Goede goto out; 3294c3362f4SHans de Goede } 3304c3362f4SHans de Goede 3314c3362f4SHans de Goede /* The first package describes the collection */ 3324c3362f4SHans de Goede el0 = &btns_desc->package.elements[0]; 3334c3362f4SHans de Goede if (el0->type == ACPI_TYPE_PACKAGE && 3344c3362f4SHans de Goede el0->package.count == 5 && 3354c3362f4SHans de Goede /* First byte should be 0 (collection) */ 3364c3362f4SHans de Goede soc_button_get_acpi_object_int(&el0->package.elements[0]) == 0 && 3374c3362f4SHans de Goede /* Third byte should be 0 (top level collection) */ 3384c3362f4SHans de Goede soc_button_get_acpi_object_int(&el0->package.elements[2]) == 0) { 3394c3362f4SHans de Goede collection_uid = soc_button_get_acpi_object_int( 3404c3362f4SHans de Goede &el0->package.elements[1]); 3414c3362f4SHans de Goede } 3424c3362f4SHans de Goede if (collection_uid == -1) { 3434c3362f4SHans de Goede dev_err(dev, "Invalid Button Collection Descriptor\n"); 344779f19acSHans de Goede button_info = ERR_PTR(-ENODEV); 345779f19acSHans de Goede goto out; 3464c3362f4SHans de Goede } 3474c3362f4SHans de Goede 3484c3362f4SHans de Goede /* There are package.count - 1 buttons + 1 terminating empty entry */ 3494c3362f4SHans de Goede button_info = devm_kcalloc(dev, btns_desc->package.count, 3504c3362f4SHans de Goede sizeof(*button_info), GFP_KERNEL); 351779f19acSHans de Goede if (!button_info) { 352779f19acSHans de Goede button_info = ERR_PTR(-ENOMEM); 353779f19acSHans de Goede goto out; 354779f19acSHans de Goede } 3554c3362f4SHans de Goede 3564c3362f4SHans de Goede /* Parse the button descriptors */ 3574c3362f4SHans de Goede for (i = 1, btn = 0; i < btns_desc->package.count; i++, btn++) { 3584c3362f4SHans de Goede if (soc_button_parse_btn_desc(dev, 3594c3362f4SHans de Goede &btns_desc->package.elements[i], 3604c3362f4SHans de Goede collection_uid, 361779f19acSHans de Goede &button_info[btn])) { 362779f19acSHans de Goede button_info = ERR_PTR(-ENODEV); 363779f19acSHans de Goede goto out; 364779f19acSHans de Goede } 3654c3362f4SHans de Goede } 3664c3362f4SHans de Goede 367779f19acSHans de Goede out: 368779f19acSHans de Goede kfree(buf.pointer); 3694c3362f4SHans de Goede return button_info; 3704c3362f4SHans de Goede } 3714c3362f4SHans de Goede 372042e1c79SJin Yao static int soc_button_remove(struct platform_device *pdev) 37361cd4822SLejun Zhu { 374042e1c79SJin Yao struct soc_button_data *priv = platform_get_drvdata(pdev); 375042e1c79SJin Yao 37661cd4822SLejun Zhu int i; 37761cd4822SLejun Zhu 37861cd4822SLejun Zhu for (i = 0; i < BUTTON_TYPES; i++) 37961cd4822SLejun Zhu if (priv->children[i]) 38061cd4822SLejun Zhu platform_device_unregister(priv->children[i]); 381042e1c79SJin Yao 382042e1c79SJin Yao return 0; 38361cd4822SLejun Zhu } 38461cd4822SLejun Zhu 385042e1c79SJin Yao static int soc_button_probe(struct platform_device *pdev) 38661cd4822SLejun Zhu { 387042e1c79SJin Yao struct device *dev = &pdev->dev; 388c3941593SMaximilian Luz const struct soc_device_data *device_data; 389c3941593SMaximilian Luz const struct soc_button_info *button_info; 39061cd4822SLejun Zhu struct soc_button_data *priv; 39161cd4822SLejun Zhu struct platform_device *pd; 39261cd4822SLejun Zhu int i; 39361cd4822SLejun Zhu int error; 39461cd4822SLejun Zhu 395c3941593SMaximilian Luz device_data = acpi_device_get_match_data(dev); 396c3941593SMaximilian Luz if (device_data && device_data->check) { 397c3941593SMaximilian Luz error = device_data->check(dev); 398c3941593SMaximilian Luz if (error) 399c3941593SMaximilian Luz return error; 400c3941593SMaximilian Luz } 401042e1c79SJin Yao 402c3941593SMaximilian Luz if (device_data && device_data->button_info) { 403c3941593SMaximilian Luz button_info = device_data->button_info; 404c3941593SMaximilian Luz } else { 4054c3362f4SHans de Goede button_info = soc_button_get_button_info(dev); 4064c3362f4SHans de Goede if (IS_ERR(button_info)) 4074c3362f4SHans de Goede return PTR_ERR(button_info); 4084c3362f4SHans de Goede } 409042e1c79SJin Yao 410c5097538SAndy Shevchenko error = gpiod_count(dev, NULL); 411c5097538SAndy Shevchenko if (error < 0) { 412aa45590aSGuenter Roeck dev_dbg(dev, "no GPIO attached, ignoring...\n"); 413d912366aSHans de Goede return -ENODEV; 4143d5a9437SBenjamin Tissoires } 4153d5a9437SBenjamin Tissoires 416aa45590aSGuenter Roeck priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 41761cd4822SLejun Zhu if (!priv) 41861cd4822SLejun Zhu return -ENOMEM; 41961cd4822SLejun Zhu 420042e1c79SJin Yao platform_set_drvdata(pdev, priv); 42161cd4822SLejun Zhu 42261cd4822SLejun Zhu for (i = 0; i < BUTTON_TYPES; i++) { 42361cd4822SLejun Zhu pd = soc_button_device_create(pdev, button_info, i == 0); 42461cd4822SLejun Zhu if (IS_ERR(pd)) { 42561cd4822SLejun Zhu error = PTR_ERR(pd); 42661cd4822SLejun Zhu if (error != -ENODEV) { 42761cd4822SLejun Zhu soc_button_remove(pdev); 42861cd4822SLejun Zhu return error; 42961cd4822SLejun Zhu } 4307740fc52SLejun Zhu continue; 43161cd4822SLejun Zhu } 43261cd4822SLejun Zhu 43361cd4822SLejun Zhu priv->children[i] = pd; 43461cd4822SLejun Zhu } 43561cd4822SLejun Zhu 43661cd4822SLejun Zhu if (!priv->children[0] && !priv->children[1]) 43761cd4822SLejun Zhu return -ENODEV; 43861cd4822SLejun Zhu 439c3941593SMaximilian Luz if (!device_data || !device_data->button_info) 4404c3362f4SHans de Goede devm_kfree(dev, button_info); 4414c3362f4SHans de Goede 44261cd4822SLejun Zhu return 0; 44361cd4822SLejun Zhu } 44461cd4822SLejun Zhu 4457283b47dSHans de Goede /* 4467283b47dSHans de Goede * Definition of buttons on the tablet. The ACPI index of each button 4477283b47dSHans de Goede * is defined in section 2.8.7.2 of "Windows ACPI Design Guide for SoC 4487283b47dSHans de Goede * Platforms" 4497283b47dSHans de Goede */ 450c3941593SMaximilian Luz static const struct soc_button_info soc_button_PNP0C40[] = { 451838fc808SHans de Goede { "power", 0, EV_KEY, KEY_POWER, false, true, true }, 452838fc808SHans de Goede { "home", 1, EV_KEY, KEY_LEFTMETA, false, true, true }, 453838fc808SHans de Goede { "volume_up", 2, EV_KEY, KEY_VOLUMEUP, true, false, true }, 454838fc808SHans de Goede { "volume_down", 3, EV_KEY, KEY_VOLUMEDOWN, true, false, true }, 455838fc808SHans de Goede { "rotation_lock", 4, EV_KEY, KEY_ROTATE_LOCK_TOGGLE, false, false, true }, 45661cd4822SLejun Zhu { } 45761cd4822SLejun Zhu }; 45861cd4822SLejun Zhu 459c3941593SMaximilian Luz static const struct soc_device_data soc_device_PNP0C40 = { 460c3941593SMaximilian Luz .button_info = soc_button_PNP0C40, 461c3941593SMaximilian Luz }; 462c3941593SMaximilian Luz 4634e5d9c19SHans de Goede static const struct soc_button_info soc_button_INT33D3[] = { 4644e5d9c19SHans de Goede { "tablet_mode", 0, EV_SW, SW_TABLET_MODE, false, false, false }, 4654e5d9c19SHans de Goede { } 4664e5d9c19SHans de Goede }; 4674e5d9c19SHans de Goede 4684e5d9c19SHans de Goede static const struct soc_device_data soc_device_INT33D3 = { 4694e5d9c19SHans de Goede .button_info = soc_button_INT33D3, 4704e5d9c19SHans de Goede }; 4714e5d9c19SHans de Goede 472c3941593SMaximilian Luz /* 473*60c7353cSHans de Goede * Button info for Microsoft Surface 3 (non pro), this is indentical to 474*60c7353cSHans de Goede * the PNP0C40 info except that the home button is active-high. 475*60c7353cSHans de Goede * 476*60c7353cSHans de Goede * The Surface 3 Pro also has a MSHW0028 ACPI device, but that uses a custom 477*60c7353cSHans de Goede * version of the drivers/platform/x86/intel/hid.c 5 button array ACPI API 478*60c7353cSHans de Goede * instead. A check() callback is not necessary though as the Surface 3 Pro 479*60c7353cSHans de Goede * MSHW0028 ACPI device's resource table does not contain any GPIOs. 480*60c7353cSHans de Goede */ 481*60c7353cSHans de Goede static const struct soc_button_info soc_button_MSHW0028[] = { 482*60c7353cSHans de Goede { "power", 0, EV_KEY, KEY_POWER, false, true, true }, 483*60c7353cSHans de Goede { "home", 1, EV_KEY, KEY_LEFTMETA, false, true, false }, 484*60c7353cSHans de Goede { "volume_up", 2, EV_KEY, KEY_VOLUMEUP, true, false, true }, 485*60c7353cSHans de Goede { "volume_down", 3, EV_KEY, KEY_VOLUMEDOWN, true, false, true }, 486*60c7353cSHans de Goede { } 487*60c7353cSHans de Goede }; 488*60c7353cSHans de Goede 489*60c7353cSHans de Goede static const struct soc_device_data soc_device_MSHW0028 = { 490*60c7353cSHans de Goede .button_info = soc_button_MSHW0028, 491*60c7353cSHans de Goede }; 492*60c7353cSHans de Goede 493*60c7353cSHans de Goede /* 494c3941593SMaximilian Luz * Special device check for Surface Book 2 and Surface Pro (2017). 495c3941593SMaximilian Luz * Both, the Surface Pro 4 (surfacepro3_button.c) and the above mentioned 496c3941593SMaximilian Luz * devices use MSHW0040 for power and volume buttons, however the way they 497c3941593SMaximilian Luz * have to be addressed differs. Make sure that we only load this drivers 498c3941593SMaximilian Luz * for the correct devices by checking the OEM Platform Revision provided by 499c3941593SMaximilian Luz * the _DSM method. 500c3941593SMaximilian Luz */ 501c3941593SMaximilian Luz #define MSHW0040_DSM_REVISION 0x01 502c3941593SMaximilian Luz #define MSHW0040_DSM_GET_OMPR 0x02 // get OEM Platform Revision 503c3941593SMaximilian Luz static const guid_t MSHW0040_DSM_UUID = 504c3941593SMaximilian Luz GUID_INIT(0x6fd05c69, 0xcde3, 0x49f4, 0x95, 0xed, 0xab, 0x16, 0x65, 505c3941593SMaximilian Luz 0x49, 0x80, 0x35); 506c3941593SMaximilian Luz 507c3941593SMaximilian Luz static int soc_device_check_MSHW0040(struct device *dev) 508c3941593SMaximilian Luz { 509c3941593SMaximilian Luz acpi_handle handle = ACPI_HANDLE(dev); 510c3941593SMaximilian Luz union acpi_object *result; 511c3941593SMaximilian Luz u64 oem_platform_rev = 0; // valid revisions are nonzero 512c3941593SMaximilian Luz 513c3941593SMaximilian Luz // get OEM platform revision 514c3941593SMaximilian Luz result = acpi_evaluate_dsm_typed(handle, &MSHW0040_DSM_UUID, 515c3941593SMaximilian Luz MSHW0040_DSM_REVISION, 516c3941593SMaximilian Luz MSHW0040_DSM_GET_OMPR, NULL, 517c3941593SMaximilian Luz ACPI_TYPE_INTEGER); 518c3941593SMaximilian Luz 519c3941593SMaximilian Luz if (result) { 520c3941593SMaximilian Luz oem_platform_rev = result->integer.value; 521c3941593SMaximilian Luz ACPI_FREE(result); 522c3941593SMaximilian Luz } 523c3941593SMaximilian Luz 524c3941593SMaximilian Luz /* 525c3941593SMaximilian Luz * If the revision is zero here, the _DSM evaluation has failed. This 526c3941593SMaximilian Luz * indicates that we have a Pro 4 or Book 1 and this driver should not 527c3941593SMaximilian Luz * be used. 528c3941593SMaximilian Luz */ 529c3941593SMaximilian Luz if (oem_platform_rev == 0) 530c3941593SMaximilian Luz return -ENODEV; 531c3941593SMaximilian Luz 532c3941593SMaximilian Luz dev_dbg(dev, "OEM Platform Revision %llu\n", oem_platform_rev); 533c3941593SMaximilian Luz 534c3941593SMaximilian Luz return 0; 535c3941593SMaximilian Luz } 536c3941593SMaximilian Luz 537c3941593SMaximilian Luz /* 538c3941593SMaximilian Luz * Button infos for Microsoft Surface Book 2 and Surface Pro (2017). 539c3941593SMaximilian Luz * Obtained from DSDT/testing. 540c3941593SMaximilian Luz */ 541c3941593SMaximilian Luz static const struct soc_button_info soc_button_MSHW0040[] = { 542838fc808SHans de Goede { "power", 0, EV_KEY, KEY_POWER, false, true, true }, 543838fc808SHans de Goede { "volume_up", 2, EV_KEY, KEY_VOLUMEUP, true, false, true }, 544838fc808SHans de Goede { "volume_down", 4, EV_KEY, KEY_VOLUMEDOWN, true, false, true }, 545c3941593SMaximilian Luz { } 546c3941593SMaximilian Luz }; 547c3941593SMaximilian Luz 548c3941593SMaximilian Luz static const struct soc_device_data soc_device_MSHW0040 = { 549c3941593SMaximilian Luz .button_info = soc_button_MSHW0040, 550c3941593SMaximilian Luz .check = soc_device_check_MSHW0040, 551c3941593SMaximilian Luz }; 552c3941593SMaximilian Luz 553042e1c79SJin Yao static const struct acpi_device_id soc_button_acpi_match[] = { 554c3941593SMaximilian Luz { "PNP0C40", (unsigned long)&soc_device_PNP0C40 }, 5554e5d9c19SHans de Goede { "INT33D3", (unsigned long)&soc_device_INT33D3 }, 5564e5d9c19SHans de Goede { "ID9001", (unsigned long)&soc_device_INT33D3 }, 5574c3362f4SHans de Goede { "ACPI0011", 0 }, 558c3941593SMaximilian Luz 559*60c7353cSHans de Goede /* Microsoft Surface Devices (3th, 5th and 6th generation) */ 560*60c7353cSHans de Goede { "MSHW0028", (unsigned long)&soc_device_MSHW0028 }, 561c3941593SMaximilian Luz { "MSHW0040", (unsigned long)&soc_device_MSHW0040 }, 562c3941593SMaximilian Luz 563042e1c79SJin Yao { } 56461cd4822SLejun Zhu }; 56561cd4822SLejun Zhu 566042e1c79SJin Yao MODULE_DEVICE_TABLE(acpi, soc_button_acpi_match); 567042e1c79SJin Yao 568042e1c79SJin Yao static struct platform_driver soc_button_driver = { 569042e1c79SJin Yao .probe = soc_button_probe, 57061cd4822SLejun Zhu .remove = soc_button_remove, 571042e1c79SJin Yao .driver = { 572042e1c79SJin Yao .name = KBUILD_MODNAME, 573042e1c79SJin Yao .acpi_match_table = ACPI_PTR(soc_button_acpi_match), 574042e1c79SJin Yao }, 57561cd4822SLejun Zhu }; 576042e1c79SJin Yao module_platform_driver(soc_button_driver); 57761cd4822SLejun Zhu 57861cd4822SLejun Zhu MODULE_LICENSE("GPL"); 579