| /* |
| * quickstart.c - ACPI Direct App Launch driver |
| * |
| * |
| * Copyright (C) 2007-2010 Angelo Arrifano <miknix@gmail.com> |
| * |
| * Information gathered from disassembled dsdt and from here: |
| * <http://www.microsoft.com/whdc/system/platform/firmware/DirAppLaunch.mspx> |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| */ |
| |
| #define QUICKSTART_VERSION "1.04" |
| |
| #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| |
| #include <linux/kernel.h> |
| #include <linux/module.h> |
| #include <linux/init.h> |
| #include <linux/types.h> |
| #include <acpi/acpi_drivers.h> |
| #include <linux/platform_device.h> |
| #include <linux/input.h> |
| |
| MODULE_AUTHOR("Angelo Arrifano"); |
| MODULE_DESCRIPTION("ACPI Direct App Launch driver"); |
| MODULE_LICENSE("GPL"); |
| |
| #define QUICKSTART_ACPI_DEVICE_NAME "quickstart" |
| #define QUICKSTART_ACPI_CLASS "quickstart" |
| #define QUICKSTART_ACPI_HID "PNP0C32" |
| |
| #define QUICKSTART_PF_DRIVER_NAME "quickstart" |
| #define QUICKSTART_PF_DEVICE_NAME "quickstart" |
| |
| /* |
| * There will be two events: |
| * 0x02 - A hot button was pressed while device was off/sleeping. |
| * 0x80 - A hot button was pressed while device was up. |
| */ |
| #define QUICKSTART_EVENT_WAKE 0x02 |
| #define QUICKSTART_EVENT_RUNTIME 0x80 |
| |
| struct quickstart_button { |
| char *name; |
| unsigned int id; |
| struct list_head list; |
| }; |
| |
| struct quickstart_acpi { |
| struct acpi_device *device; |
| struct quickstart_button *button; |
| }; |
| |
| static LIST_HEAD(buttons); |
| static struct quickstart_button *pressed; |
| |
| static struct input_dev *quickstart_input; |
| |
| /* Platform driver functions */ |
| static ssize_t quickstart_buttons_show(struct device *dev, |
| struct device_attribute *attr, |
| char *buf) |
| { |
| int count = 0; |
| struct quickstart_button *b; |
| |
| if (list_empty(&buttons)) |
| return snprintf(buf, PAGE_SIZE, "none"); |
| |
| list_for_each_entry(b, &buttons, list) { |
| count += snprintf(buf + count, PAGE_SIZE - count, "%u\t%s\n", |
| b->id, b->name); |
| |
| if (count >= PAGE_SIZE) { |
| count = PAGE_SIZE; |
| break; |
| } |
| } |
| |
| return count; |
| } |
| |
| static ssize_t quickstart_pressed_button_show(struct device *dev, |
| struct device_attribute *attr, |
| char *buf) |
| { |
| return scnprintf(buf, PAGE_SIZE, "%s\n", |
| (pressed ? pressed->name : "none")); |
| } |
| |
| |
| static ssize_t quickstart_pressed_button_store(struct device *dev, |
| struct device_attribute *attr, |
| const char *buf, size_t count) |
| { |
| if (count < 2) |
| return -EINVAL; |
| |
| if (strncasecmp(buf, "none", 4) != 0) |
| return -EINVAL; |
| |
| pressed = NULL; |
| return count; |
| } |
| |
| /* Helper functions */ |
| static struct quickstart_button *quickstart_buttons_add(void) |
| { |
| struct quickstart_button *b; |
| |
| b = kzalloc(sizeof(*b), GFP_KERNEL); |
| if (!b) |
| return NULL; |
| |
| list_add_tail(&b->list, &buttons); |
| |
| return b; |
| } |
| |
| static void quickstart_button_del(struct quickstart_button *data) |
| { |
| if (!data) |
| return; |
| |
| list_del(&data->list); |
| kfree(data->name); |
| kfree(data); |
| } |
| |
| static void quickstart_buttons_free(void) |
| { |
| struct quickstart_button *b, *n; |
| |
| list_for_each_entry_safe(b, n, &buttons, list) |
| quickstart_button_del(b); |
| } |
| |
| /* ACPI Driver functions */ |
| static void quickstart_acpi_notify(acpi_handle handle, u32 event, void *data) |
| { |
| struct quickstart_acpi *quickstart = data; |
| |
| if (!quickstart) |
| return; |
| |
| switch (event) { |
| case QUICKSTART_EVENT_WAKE: |
| pressed = quickstart->button; |
| break; |
| case QUICKSTART_EVENT_RUNTIME: |
| input_report_key(quickstart_input, quickstart->button->id, 1); |
| input_sync(quickstart_input); |
| input_report_key(quickstart_input, quickstart->button->id, 0); |
| input_sync(quickstart_input); |
| break; |
| default: |
| pr_err("Unexpected ACPI event notify (%u)\n", event); |
| break; |
| } |
| } |
| |
| static int quickstart_acpi_ghid(struct quickstart_acpi *quickstart) |
| { |
| acpi_status status; |
| struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; |
| int ret = 0; |
| |
| /* |
| * This returns a buffer telling the button usage ID, |
| * and triggers pending notify events (The ones before booting). |
| */ |
| status = acpi_evaluate_object(quickstart->device->handle, "GHID", NULL, |
| &buffer); |
| if (ACPI_FAILURE(status)) { |
| pr_err("%s GHID method failed\n", quickstart->button->name); |
| return -EINVAL; |
| } |
| |
| /* |
| * <<The GHID method can return a BYTE, WORD, or DWORD. |
| * The value must be encoded in little-endian byte |
| * order (least significant byte first).>> |
| */ |
| switch (buffer.length) { |
| case 1: |
| quickstart->button->id = *(uint8_t *)buffer.pointer; |
| break; |
| case 2: |
| quickstart->button->id = *(uint16_t *)buffer.pointer; |
| break; |
| case 4: |
| quickstart->button->id = *(uint32_t *)buffer.pointer; |
| break; |
| case 8: |
| quickstart->button->id = *(uint64_t *)buffer.pointer; |
| break; |
| default: |
| pr_err("%s GHID method returned buffer of unexpected length %lu\n", |
| quickstart->button->name, |
| (unsigned long)buffer.length); |
| ret = -EINVAL; |
| break; |
| } |
| |
| kfree(buffer.pointer); |
| |
| return ret; |
| } |
| |
| static int quickstart_acpi_config(struct quickstart_acpi *quickstart) |
| { |
| char *bid = acpi_device_bid(quickstart->device); |
| char *name; |
| |
| name = kmalloc(strlen(bid) + 1, GFP_KERNEL); |
| if (!name) |
| return -ENOMEM; |
| |
| /* Add new button to list */ |
| quickstart->button = quickstart_buttons_add(); |
| if (!quickstart->button) { |
| kfree(name); |
| return -ENOMEM; |
| } |
| |
| quickstart->button->name = name; |
| strcpy(quickstart->button->name, bid); |
| |
| return 0; |
| } |
| |
| static int quickstart_acpi_add(struct acpi_device *device) |
| { |
| int ret; |
| acpi_status status; |
| struct quickstart_acpi *quickstart; |
| |
| if (!device) |
| return -EINVAL; |
| |
| quickstart = kzalloc(sizeof(*quickstart), GFP_KERNEL); |
| if (!quickstart) |
| return -ENOMEM; |
| |
| quickstart->device = device; |
| |
| strcpy(acpi_device_name(device), QUICKSTART_ACPI_DEVICE_NAME); |
| strcpy(acpi_device_class(device), QUICKSTART_ACPI_CLASS); |
| device->driver_data = quickstart; |
| |
| /* Add button to list and initialize some stuff */ |
| ret = quickstart_acpi_config(quickstart); |
| if (ret < 0) |
| goto fail_config; |
| |
| status = acpi_install_notify_handler(device->handle, ACPI_ALL_NOTIFY, |
| quickstart_acpi_notify, |
| quickstart); |
| if (ACPI_FAILURE(status)) { |
| pr_err("Notify handler install error\n"); |
| ret = -ENODEV; |
| goto fail_installnotify; |
| } |
| |
| ret = quickstart_acpi_ghid(quickstart); |
| if (ret < 0) |
| goto fail_ghid; |
| |
| return 0; |
| |
| fail_ghid: |
| acpi_remove_notify_handler(device->handle, ACPI_ALL_NOTIFY, |
| quickstart_acpi_notify); |
| |
| fail_installnotify: |
| quickstart_button_del(quickstart->button); |
| |
| fail_config: |
| |
| kfree(quickstart); |
| |
| return ret; |
| } |
| |
| static int quickstart_acpi_remove(struct acpi_device *device, int type) |
| { |
| acpi_status status; |
| struct quickstart_acpi *quickstart; |
| |
| if (!device) |
| return -EINVAL; |
| |
| quickstart = acpi_driver_data(device); |
| if (!quickstart) |
| return -EINVAL; |
| |
| status = acpi_remove_notify_handler(device->handle, ACPI_ALL_NOTIFY, |
| quickstart_acpi_notify); |
| if (ACPI_FAILURE(status)) |
| pr_err("Error removing notify handler\n"); |
| |
| kfree(quickstart); |
| |
| return 0; |
| } |
| |
| /* Platform driver structs */ |
| static DEVICE_ATTR(pressed_button, 0666, quickstart_pressed_button_show, |
| quickstart_pressed_button_store); |
| static DEVICE_ATTR(buttons, 0444, quickstart_buttons_show, NULL); |
| static struct platform_device *pf_device; |
| static struct platform_driver pf_driver = { |
| .driver = { |
| .name = QUICKSTART_PF_DRIVER_NAME, |
| .owner = THIS_MODULE, |
| } |
| }; |
| |
| static const struct acpi_device_id quickstart_device_ids[] = { |
| {QUICKSTART_ACPI_HID, 0}, |
| {"", 0}, |
| }; |
| |
| static struct acpi_driver quickstart_acpi_driver = { |
| .name = "quickstart", |
| .class = QUICKSTART_ACPI_CLASS, |
| .ids = quickstart_device_ids, |
| .ops = { |
| .add = quickstart_acpi_add, |
| .remove = quickstart_acpi_remove, |
| }, |
| }; |
| |
| /* Module functions */ |
| static void quickstart_exit(void) |
| { |
| input_unregister_device(quickstart_input); |
| |
| device_remove_file(&pf_device->dev, &dev_attr_pressed_button); |
| device_remove_file(&pf_device->dev, &dev_attr_buttons); |
| |
| platform_device_unregister(pf_device); |
| |
| platform_driver_unregister(&pf_driver); |
| |
| acpi_bus_unregister_driver(&quickstart_acpi_driver); |
| |
| quickstart_buttons_free(); |
| } |
| |
| static int __init quickstart_init_input(void) |
| { |
| struct quickstart_button *b; |
| int ret; |
| |
| quickstart_input = input_allocate_device(); |
| |
| if (!quickstart_input) |
| return -ENOMEM; |
| |
| quickstart_input->name = "Quickstart ACPI Buttons"; |
| quickstart_input->id.bustype = BUS_HOST; |
| |
| list_for_each_entry(b, &buttons, list) { |
| set_bit(EV_KEY, quickstart_input->evbit); |
| set_bit(b->id, quickstart_input->keybit); |
| } |
| |
| ret = input_register_device(quickstart_input); |
| if (ret) { |
| input_free_device(quickstart_input); |
| return ret; |
| } |
| |
| return 0; |
| } |
| |
| static int __init quickstart_init(void) |
| { |
| int ret; |
| |
| /* ACPI Check */ |
| if (acpi_disabled) |
| return -ENODEV; |
| |
| /* ACPI driver register */ |
| ret = acpi_bus_register_driver(&quickstart_acpi_driver); |
| if (ret) |
| return ret; |
| |
| /* If existing bus with no devices */ |
| if (list_empty(&buttons)) { |
| ret = -ENODEV; |
| goto fail_pfdrv_reg; |
| } |
| |
| /* Platform driver register */ |
| ret = platform_driver_register(&pf_driver); |
| if (ret) |
| goto fail_pfdrv_reg; |
| |
| /* Platform device register */ |
| pf_device = platform_device_alloc(QUICKSTART_PF_DEVICE_NAME, -1); |
| if (!pf_device) { |
| ret = -ENOMEM; |
| goto fail_pfdev_alloc; |
| } |
| ret = platform_device_add(pf_device); |
| if (ret) |
| goto fail_pfdev_add; |
| |
| /* Create device sysfs file */ |
| ret = device_create_file(&pf_device->dev, &dev_attr_pressed_button); |
| if (ret) |
| goto fail_dev_file; |
| |
| ret = device_create_file(&pf_device->dev, &dev_attr_buttons); |
| if (ret) |
| goto fail_dev_file2; |
| |
| /* Input device */ |
| ret = quickstart_init_input(); |
| if (ret) |
| goto fail_input; |
| |
| pr_info("ACPI Direct App Launch ver %s\n", QUICKSTART_VERSION); |
| |
| return 0; |
| fail_input: |
| device_remove_file(&pf_device->dev, &dev_attr_buttons); |
| |
| fail_dev_file2: |
| device_remove_file(&pf_device->dev, &dev_attr_pressed_button); |
| |
| fail_dev_file: |
| platform_device_del(pf_device); |
| |
| fail_pfdev_add: |
| platform_device_put(pf_device); |
| |
| fail_pfdev_alloc: |
| platform_driver_unregister(&pf_driver); |
| |
| fail_pfdrv_reg: |
| acpi_bus_unregister_driver(&quickstart_acpi_driver); |
| |
| return ret; |
| } |
| |
| module_init(quickstart_init); |
| module_exit(quickstart_exit); |