| /* |
| * quickstart.c - ACPI Direct App Launch driver |
| * |
| * |
| * Copyright (C) 2007-2010 Angelo Arrifano <miknix@gmail.com> |
| * |
| * Information gathered from disassebled 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.03" |
| |
| #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" |
| #define QUICKSTART_PF_DEVATTR_NAME "pressed_button" |
| |
| #define QUICKSTART_MAX_BTN_NAME_LEN 16 |
| |
| /* 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_btn { |
| char *name; |
| unsigned int id; |
| struct quickstart_btn *next; |
| }; |
| |
| static struct quickstart_driver_data { |
| struct quickstart_btn *btn_lst; |
| struct quickstart_btn *pressed; |
| } quickstart_data; |
| |
| /* ACPI driver Structs */ |
| struct quickstart_acpi { |
| struct acpi_device *device; |
| struct quickstart_btn *btn; |
| }; |
| static int quickstart_acpi_add(struct acpi_device *device); |
| static int quickstart_acpi_remove(struct acpi_device *device, int type); |
| 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, |
| }, |
| }; |
| |
| /* Input device structs */ |
| struct input_dev *quickstart_input; |
| |
| /* Platform driver structs */ |
| static ssize_t buttons_show(struct device *dev, |
| struct device_attribute *attr, |
| char *buf); |
| static ssize_t pressed_button_show(struct device *dev, |
| struct device_attribute *attr, |
| char *buf); |
| static ssize_t pressed_button_store(struct device *dev, |
| struct device_attribute *attr, |
| const char *buf, |
| size_t count); |
| static DEVICE_ATTR(pressed_button, 0666, pressed_button_show, |
| pressed_button_store); |
| static DEVICE_ATTR(buttons, 0444, buttons_show, NULL); |
| static struct platform_device *pf_device; |
| static struct platform_driver pf_driver = { |
| .driver = { |
| .name = QUICKSTART_PF_DRIVER_NAME, |
| .owner = THIS_MODULE, |
| } |
| }; |
| |
| /* |
| * Platform driver functions |
| */ |
| static ssize_t buttons_show(struct device *dev, |
| struct device_attribute *attr, |
| char *buf) |
| { |
| int count = 0; |
| struct quickstart_btn *ptr = quickstart_data.btn_lst; |
| |
| if (!ptr) |
| return snprintf(buf, PAGE_SIZE, "none"); |
| |
| while (ptr && (count < PAGE_SIZE)) { |
| if (ptr->name) { |
| count += snprintf(buf + count, |
| PAGE_SIZE - count, |
| "%d\t%s\n", ptr->id, ptr->name); |
| } |
| ptr = ptr->next; |
| } |
| |
| return count; |
| } |
| |
| static ssize_t pressed_button_show(struct device *dev, |
| struct device_attribute *attr, |
| char *buf) |
| { |
| return snprintf(buf, PAGE_SIZE, "%s\n", |
| (quickstart_data.pressed?quickstart_data.pressed->name:"none")); |
| } |
| |
| |
| static ssize_t 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; |
| |
| quickstart_data.pressed = NULL; |
| return count; |
| } |
| |
| /* Hotstart Helper functions */ |
| static int quickstart_btnlst_add(struct quickstart_btn **data) |
| { |
| struct quickstart_btn **ptr = &quickstart_data.btn_lst; |
| |
| while (*ptr) |
| ptr = &((*ptr)->next); |
| |
| *ptr = kzalloc(sizeof(struct quickstart_btn), GFP_KERNEL); |
| if (!*ptr) { |
| *data = NULL; |
| return -ENOMEM; |
| } |
| *data = *ptr; |
| |
| return 0; |
| } |
| |
| static void quickstart_btnlst_del(struct quickstart_btn *data) |
| { |
| struct quickstart_btn **ptr = &quickstart_data.btn_lst; |
| |
| if (!data) |
| return; |
| |
| while (*ptr) { |
| if (*ptr == data) { |
| *ptr = (*ptr)->next; |
| kfree(data); |
| return; |
| } |
| ptr = &((*ptr)->next); |
| } |
| |
| return; |
| } |
| |
| static void quickstart_btnlst_free(void) |
| { |
| struct quickstart_btn *ptr = quickstart_data.btn_lst; |
| struct quickstart_btn *lptr = NULL; |
| |
| while (ptr) { |
| lptr = ptr; |
| ptr = ptr->next; |
| kfree(lptr->name); |
| kfree(lptr); |
| } |
| |
| return; |
| } |
| |
| /* ACPI Driver functions */ |
| static void quickstart_acpi_notify(acpi_handle handle, u32 event, void *data) |
| { |
| struct quickstart_acpi *quickstart = data; |
| |
| if (!quickstart) |
| return; |
| |
| if (event == QUICKSTART_EVENT_WAKE) |
| quickstart_data.pressed = quickstart->btn; |
| else if (event == QUICKSTART_EVENT_RUNTIME) { |
| input_report_key(quickstart_input, quickstart->btn->id, 1); |
| input_sync(quickstart_input); |
| input_report_key(quickstart_input, quickstart->btn->id, 0); |
| input_sync(quickstart_input); |
| } |
| return; |
| } |
| |
| static void quickstart_acpi_ghid(struct quickstart_acpi *quickstart) |
| { |
| acpi_status status; |
| struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; |
| uint32_t usageid = 0; |
| |
| if (!quickstart) |
| return; |
| |
| /* 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) || !buffer.pointer) { |
| printk(KERN_ERR "quickstart: %s GHID method failed.\n", |
| quickstart->btn->name); |
| return; |
| } |
| |
| if (buffer.length < 8) |
| return; |
| |
| /* <<The GHID method can return a BYTE, WORD, or DWORD. |
| * The value must be encoded in little-endian byte |
| * order (least significant byte first).>> */ |
| usageid = *((uint32_t *)(buffer.pointer + (buffer.length - 8))); |
| quickstart->btn->id = usageid; |
| |
| kfree(buffer.pointer); |
| } |
| |
| static int quickstart_acpi_config(struct quickstart_acpi *quickstart, char *bid) |
| { |
| int len = strlen(bid); |
| int ret; |
| |
| /* Add button to list */ |
| ret = quickstart_btnlst_add(&quickstart->btn); |
| if (ret) |
| return ret; |
| |
| quickstart->btn->name = kzalloc(len + 1, GFP_KERNEL); |
| if (!quickstart->btn->name) { |
| quickstart_btnlst_free(); |
| return -ENOMEM; |
| } |
| strcpy(quickstart->btn->name, bid); |
| |
| return 0; |
| } |
| |
| static int quickstart_acpi_add(struct acpi_device *device) |
| { |
| int ret = 0; |
| acpi_status status = AE_OK; |
| struct quickstart_acpi *quickstart = NULL; |
| |
| if (!device) |
| return -EINVAL; |
| |
| quickstart = kzalloc(sizeof(struct quickstart_acpi), 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, acpi_device_bid(device)); |
| if (ret) |
| goto fail_config; |
| |
| status = acpi_install_notify_handler(device->handle, |
| ACPI_ALL_NOTIFY, |
| quickstart_acpi_notify, |
| quickstart); |
| if (ACPI_FAILURE(status)) { |
| printk(KERN_ERR "quickstart: Notify handler install error\n"); |
| ret = -ENODEV; |
| goto fail_installnotify; |
| } |
| |
| quickstart_acpi_ghid(quickstart); |
| |
| return 0; |
| |
| fail_installnotify: |
| quickstart_btnlst_del(quickstart->btn); |
| |
| fail_config: |
| |
| kfree(quickstart); |
| |
| return ret; |
| } |
| |
| static int quickstart_acpi_remove(struct acpi_device *device, int type) |
| { |
| acpi_status status = 0; |
| struct quickstart_acpi *quickstart = NULL; |
| |
| if (!device || !acpi_driver_data(device)) |
| return -EINVAL; |
| |
| quickstart = acpi_driver_data(device); |
| |
| status = acpi_remove_notify_handler(device->handle, |
| ACPI_ALL_NOTIFY, |
| quickstart_acpi_notify); |
| if (ACPI_FAILURE(status)) |
| printk(KERN_ERR "quickstart: Error removing notify handler\n"); |
| |
| |
| kfree(quickstart); |
| |
| return 0; |
| } |
| |
| /* 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_btnlst_free(); |
| |
| return; |
| } |
| |
| static int __init quickstart_init_input(void) |
| { |
| struct quickstart_btn **ptr = &quickstart_data.btn_lst; |
| int count; |
| int ret; |
| |
| quickstart_input = input_allocate_device(); |
| |
| if (!quickstart_input) |
| return -ENOMEM; |
| |
| quickstart_input->name = "Quickstart ACPI Buttons"; |
| quickstart_input->id.bustype = BUS_HOST; |
| |
| while (*ptr) { |
| count++; |
| set_bit(EV_KEY, quickstart_input->evbit); |
| set_bit((*ptr)->id, quickstart_input->keybit); |
| ptr = &((*ptr)->next); |
| } |
| |
| 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 (!quickstart_data.btn_lst) { |
| 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; |
| |
| printk(KERN_INFO "quickstart: 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); |