1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * ACPI Direct App Launch driver 4 * 5 * Copyright (C) 2024 Armin Wolf <W_Armin@gmx.de> 6 * Copyright (C) 2022 Arvid Norlander <lkml@vorapal.se> 7 * Copyright (C) 2007-2010 Angelo Arrifano <miknix@gmail.com> 8 * 9 * Information gathered from disassembled dsdt and from here: 10 * <https://archive.org/details/microsoft-acpi-dirapplaunch> 11 */ 12 13 #include <linux/acpi.h> 14 #include <linux/device.h> 15 #include <linux/errno.h> 16 #include <linux/init.h> 17 #include <linux/input.h> 18 #include <linux/input/sparse-keymap.h> 19 #include <linux/mod_devicetable.h> 20 #include <linux/module.h> 21 #include <linux/mutex.h> 22 #include <linux/platform_device.h> 23 #include <linux/pm_wakeup.h> 24 #include <linux/printk.h> 25 #include <linux/slab.h> 26 #include <linux/sysfs.h> 27 #include <linux/types.h> 28 29 #include <linux/unaligned.h> 30 31 #define DRIVER_NAME "quickstart" 32 33 /* 34 * There will be two events: 35 * 0x02 - Button was pressed while device was off/sleeping. 36 * 0x80 - Button was pressed while device was up. 37 */ 38 #define QUICKSTART_EVENT_RUNTIME 0x80 39 40 struct quickstart_data { 41 struct device *dev; 42 struct mutex input_lock; /* Protects input sequence during notify */ 43 struct input_dev *input_device; 44 char input_name[32]; 45 char phys[32]; 46 u32 id; 47 }; 48 49 /* 50 * Knowing what these buttons do require system specific knowledge. 51 * This could be done by matching on DMI data in a long quirk table. 52 * However, it is easier to leave it up to user space to figure this out. 53 * 54 * Using for example udev hwdb the scancode 0x1 can be remapped suitably. 55 */ 56 static const struct key_entry quickstart_keymap[] = { 57 { KE_KEY, 0x1, { KEY_UNKNOWN } }, 58 { KE_END, 0 }, 59 }; 60 61 static ssize_t button_id_show(struct device *dev, struct device_attribute *attr, char *buf) 62 { 63 struct quickstart_data *data = dev_get_drvdata(dev); 64 65 return sysfs_emit(buf, "%u\n", data->id); 66 } 67 static DEVICE_ATTR_RO(button_id); 68 69 static struct attribute *quickstart_attrs[] = { 70 &dev_attr_button_id.attr, 71 NULL 72 }; 73 ATTRIBUTE_GROUPS(quickstart); 74 75 static void quickstart_notify(acpi_handle handle, u32 event, void *context) 76 { 77 struct quickstart_data *data = context; 78 79 switch (event) { 80 case QUICKSTART_EVENT_RUNTIME: 81 mutex_lock(&data->input_lock); 82 sparse_keymap_report_event(data->input_device, 0x1, 1, true); 83 mutex_unlock(&data->input_lock); 84 85 acpi_bus_generate_netlink_event(DRIVER_NAME, dev_name(data->dev), event, 0); 86 break; 87 default: 88 dev_err(data->dev, FW_INFO "Unexpected ACPI notify event (%u)\n", event); 89 break; 90 } 91 } 92 93 /* 94 * The GHID ACPI method is used to indicate the "role" of the button. 95 * However, all the meanings of these values are vendor defined. 96 * 97 * We do however expose this value to user space. 98 */ 99 static int quickstart_get_ghid(struct quickstart_data *data) 100 { 101 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 102 acpi_handle handle = ACPI_HANDLE(data->dev); 103 union acpi_object *obj; 104 acpi_status status; 105 int ret = 0; 106 107 /* 108 * This returns a buffer telling the button usage ID, 109 * and triggers pending notify events (The ones before booting). 110 */ 111 status = acpi_evaluate_object_typed(handle, "GHID", NULL, &buffer, ACPI_TYPE_BUFFER); 112 if (ACPI_FAILURE(status)) 113 return -EIO; 114 115 obj = buffer.pointer; 116 if (!obj) 117 return -ENODATA; 118 119 /* 120 * Quoting the specification: 121 * "The GHID method can return a BYTE, WORD, or DWORD. 122 * The value must be encoded in little-endian byte 123 * order (least significant byte first)." 124 */ 125 switch (obj->buffer.length) { 126 case 1: 127 data->id = obj->buffer.pointer[0]; 128 break; 129 case 2: 130 data->id = get_unaligned_le16(obj->buffer.pointer); 131 break; 132 case 4: 133 data->id = get_unaligned_le32(obj->buffer.pointer); 134 break; 135 default: 136 dev_err(data->dev, 137 FW_BUG "GHID method returned buffer of unexpected length %u\n", 138 obj->buffer.length); 139 ret = -EIO; 140 break; 141 } 142 143 kfree(obj); 144 145 return ret; 146 } 147 148 static void quickstart_notify_remove(void *context) 149 { 150 struct quickstart_data *data = context; 151 acpi_handle handle; 152 153 handle = ACPI_HANDLE(data->dev); 154 155 acpi_remove_notify_handler(handle, ACPI_DEVICE_NOTIFY, quickstart_notify); 156 } 157 158 static void quickstart_mutex_destroy(void *data) 159 { 160 struct mutex *lock = data; 161 162 mutex_destroy(lock); 163 } 164 165 static int quickstart_probe(struct platform_device *pdev) 166 { 167 struct quickstart_data *data; 168 acpi_handle handle; 169 acpi_status status; 170 int ret; 171 172 handle = ACPI_HANDLE(&pdev->dev); 173 if (!handle) 174 return -ENODEV; 175 176 data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); 177 if (!data) 178 return -ENOMEM; 179 180 data->dev = &pdev->dev; 181 dev_set_drvdata(&pdev->dev, data); 182 183 mutex_init(&data->input_lock); 184 ret = devm_add_action_or_reset(&pdev->dev, quickstart_mutex_destroy, &data->input_lock); 185 if (ret < 0) 186 return ret; 187 188 /* 189 * We have to initialize the device wakeup before evaluating GHID because 190 * doing so will notify the device if the button was used to wake the machine 191 * from S5. 192 */ 193 device_init_wakeup(&pdev->dev, true); 194 195 ret = quickstart_get_ghid(data); 196 if (ret < 0) 197 return ret; 198 199 data->input_device = devm_input_allocate_device(&pdev->dev); 200 if (!data->input_device) 201 return -ENOMEM; 202 203 ret = sparse_keymap_setup(data->input_device, quickstart_keymap, NULL); 204 if (ret < 0) 205 return ret; 206 207 snprintf(data->input_name, sizeof(data->input_name), "Quickstart Button %u", data->id); 208 snprintf(data->phys, sizeof(data->phys), DRIVER_NAME "/input%u", data->id); 209 210 data->input_device->name = data->input_name; 211 data->input_device->phys = data->phys; 212 data->input_device->id.bustype = BUS_HOST; 213 214 ret = input_register_device(data->input_device); 215 if (ret < 0) 216 return ret; 217 218 status = acpi_install_notify_handler(handle, ACPI_DEVICE_NOTIFY, quickstart_notify, data); 219 if (ACPI_FAILURE(status)) 220 return -EIO; 221 222 return devm_add_action_or_reset(&pdev->dev, quickstart_notify_remove, data); 223 } 224 225 static const struct acpi_device_id quickstart_device_ids[] = { 226 { "PNP0C32" }, 227 { } 228 }; 229 MODULE_DEVICE_TABLE(acpi, quickstart_device_ids); 230 231 static struct platform_driver quickstart_platform_driver = { 232 .driver = { 233 .name = DRIVER_NAME, 234 .dev_groups = quickstart_groups, 235 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 236 .acpi_match_table = quickstart_device_ids, 237 }, 238 .probe = quickstart_probe, 239 }; 240 module_platform_driver(quickstart_platform_driver); 241 242 MODULE_AUTHOR("Armin Wolf <W_Armin@gmx.de>"); 243 MODULE_AUTHOR("Arvid Norlander <lkml@vorpal.se>"); 244 MODULE_AUTHOR("Angelo Arrifano"); 245 MODULE_DESCRIPTION("ACPI Direct App Launch driver"); 246 MODULE_LICENSE("GPL"); 247