static int __init msi_wmi_init(void)
{
int err;
int i;
for (i = 0; i < ARRAY_SIZE(event_wmis); i++) {
if (!wmi_has_guid(event_wmis[i].guid))
continue;
err = msi_wmi_input_setup();
if (err) {
pr_err("Unable to setup input device\n");
return err;
}
err = wmi_install_notify_handler(event_wmis[i].guid,
msi_wmi_notify, NULL);
if (ACPI_FAILURE(err)) {
pr_err("Unable to setup WMI notify handler\n");
goto err_free_input;
}
pr_debug("Event handler installed\n");
event_wmi = &event_wmis[i];
break;
}
if (wmi_has_guid(MSIWMI_BIOS_GUID) &&
acpi_video_get_backlight_type() == acpi_backlight_vendor) {
err = msi_wmi_backlight_setup();
if (err) {
pr_err("Unable to setup backlight device\n");
goto err_uninstall_handler;
}
pr_debug("Backlight device created\n");
}
if (!event_wmi && !backlight) {
pr_err("This machine doesn't have neither MSI-hotkeys nor backlight through WMI\n");
return -ENODEV;
}
return 0;
err_uninstall_handler:
if (event_wmi)
wmi_remove_notify_handler(event_wmi->guid);
err_free_input:
if (event_wmi)
input_unregister_device(msi_wmi_input_dev);
return err;
}
static int __init dell_wmi_init(void)
{
int err;
acpi_status status;
if (!wmi_has_guid(DELL_EVENT_GUID)) {
printk(KERN_WARNING "dell-wmi: No known WMI GUID found\n");
return -ENODEV;
}
dmi_walk(find_hk_type, NULL);
acpi_video = acpi_video_backlight_support();
err = dell_wmi_input_setup();
if (err)
return err;
status = wmi_install_notify_handler(DELL_EVENT_GUID,
dell_wmi_notify, NULL);
if (ACPI_FAILURE(status)) {
input_unregister_device(dell_wmi_input_dev);
printk(KERN_ERR
"dell-wmi: Unable to register notify handler - %d\n",
status);
return -ENODEV;
}
return 0;
}
static void __exit peaq_wmi_exit(void)
{
if (!wmi_has_guid(PEAQ_DOLBY_BUTTON_GUID))
return;
input_unregister_polled_device(peaq_poll_dev);
}
static int __init dell_wmi_init(void)
{
int err;
if (wmi_has_guid(DELL_EVENT_GUID)) {
dmi_walk(find_hk_type, NULL);
err = dell_wmi_input_setup();
if (err)
return err;
err = wmi_install_notify_handler(DELL_EVENT_GUID,
dell_wmi_notify, NULL);
if (err) {
input_unregister_device(dell_wmi_input_dev);
printk(KERN_ERR "dell-wmi: Unable to register"
" notify handler - %d\n", err);
return err;
}
acpi_video = acpi_video_backlight_support();
} else
printk(KERN_WARNING "dell-wmi: No known WMI GUID found\n");
return 0;
}
static int __init toshiba_acpi_init(void)
{
int ret;
/*
*/
if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID))
return -ENODEV;
toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir);
if (!toshiba_proc_dir) {
pr_err("Unable to create proc dir " PROC_TOSHIBA "\n");
return -ENODEV;
}
ret = acpi_bus_register_driver(&toshiba_acpi_driver);
if (ret) {
pr_err("Failed to register ACPI driver: %d\n", ret);
remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
}
return ret;
}
static int __init toshiba_acpi_init(void)
{
int ret;
/*
* Machines with this WMI guid aren't supported due to bugs in
* their AML. This check relies on wmi initializing before
* toshiba_acpi to guarantee guids have been identified.
*/
if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID))
return -ENODEV;
toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir);
if (!toshiba_proc_dir) {
pr_err("Unable to create proc dir " PROC_TOSHIBA "\n");
return -ENODEV;
}
ret = acpi_bus_register_driver(&toshiba_acpi_driver);
if (ret) {
pr_err("Failed to register ACPI driver: %d\n", ret);
remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
}
return ret;
}
static int __init tc1100_init(void)
{
int error;
if (!wmi_has_guid(GUID))
return -ENODEV;
tc1100_device = platform_device_alloc("tc1100-wmi", -1);
if (!tc1100_device)
return -ENOMEM;
error = platform_device_add(tc1100_device);
if (error)
goto err_device_put;
error = platform_driver_probe(&tc1100_driver, tc1100_probe);
if (error)
goto err_device_del;
pr_info("HP Compaq TC1100 Tablet WMI Extras loaded\n");
return 0;
err_device_del:
platform_device_del(tc1100_device);
err_device_put:
platform_device_put(tc1100_device);
return error;
}
static void __exit dell_wmi_exit(void)
{
if (wmi_has_guid(DELL_EVENT_GUID)) {
wmi_remove_notify_handler(DELL_EVENT_GUID);
input_unregister_device(dell_wmi_input_dev);
}
}
static void __exit gb_wmi_exit(void)
{
if (wmi_has_guid(GB_WMI_EVENT_GUID)) {
wmi_remove_notify_handler(GB_WMI_EVENT_GUID);
sparse_keymap_free(gb_wmi_input_dev);
input_unregister_device(gb_wmi_input_dev);
}
}
static void __exit msi_wmi_exit(void)
{
if (wmi_has_guid(MSIWMI_EVENT_GUID)) {
wmi_remove_notify_handler(MSIWMI_EVENT_GUID);
sparse_keymap_free(msi_wmi_input_dev);
input_unregister_device(msi_wmi_input_dev);
backlight_device_unregister(backlight);
}
}
static int __init thinkpad_wmi_probe(struct platform_device *pdev)
{
if (!wmi_has_guid(LENOVO_BIOS_SETTING_GUID)) {
pr_warning("Lenovo_BiosSetting GUID missing\n");
return -ENODEV;
}
return thinkpad_wmi_add(pdev);
}
static const char *dell_wmi_aio_find(void)
{
int i;
for (i = 0; dell_wmi_aio_guids[i] != NULL; i++)
if (wmi_has_guid(dell_wmi_aio_guids[i]))
return dell_wmi_aio_guids[i];
return NULL;
}
static void __exit hp_wmi_exit(void)
{
if (wmi_has_guid(HPWMI_EVENT_GUID))
hp_wmi_input_destroy();
if (hp_wmi_platform_dev) {
platform_device_unregister(hp_wmi_platform_dev);
platform_driver_unregister(&hp_wmi_driver);
}
}
static int __init dell_led_init(void)
{
int error = 0;
if (!wmi_has_guid(DELL_LED_BIOS_GUID))
return -ENODEV;
error = led_off();
if (error != 0)
return -ENODEV;
return led_classdev_register(NULL, &dell_led);
}
static int __init hp_wmi_init(void)
{
int event_capable = wmi_has_guid(HPWMI_EVENT_GUID);
int bios_capable = wmi_has_guid(HPWMI_BIOS_GUID);
int err;
if (!bios_capable && !event_capable)
return -ENODEV;
if (event_capable) {
err = hp_wmi_input_setup();
if (err)
return err;
}
if (bios_capable) {
hp_wmi_platform_dev =
platform_device_register_simple("hp-wmi", -1, NULL, 0);
if (IS_ERR(hp_wmi_platform_dev)) {
err = PTR_ERR(hp_wmi_platform_dev);
goto err_destroy_input;
}
err = platform_driver_probe(&hp_wmi_driver, hp_wmi_bios_setup);
if (err)
goto err_unregister_device;
}
return 0;
err_unregister_device:
platform_device_unregister(hp_wmi_platform_dev);
err_destroy_input:
if (event_capable)
hp_wmi_input_destroy();
return err;
}
static int __init msi_wmi_init(void)
{
int err;
if (!wmi_has_guid(MSIWMI_EVENT_GUID)) {
pr_err("This machine doesn't have MSI-hotkeys through WMI\n");
return -ENODEV;
}
err = wmi_install_notify_handler(MSIWMI_EVENT_GUID,
msi_wmi_notify, NULL);
if (ACPI_FAILURE(err))
return -EINVAL;
err = msi_wmi_input_setup();
if (err)
goto err_uninstall_notifier;
if (!acpi_video_backlight_support()) {
struct backlight_properties props;
memset(&props, 0, sizeof(struct backlight_properties));
props.type = BACKLIGHT_PLATFORM;
props.max_brightness = ARRAY_SIZE(backlight_map) - 1;
backlight = backlight_device_register(DRV_NAME, NULL, NULL,
&msi_backlight_ops,
&props);
if (IS_ERR(backlight)) {
err = PTR_ERR(backlight);
goto err_free_input;
}
err = bl_get(NULL);
if (err < 0)
goto err_free_backlight;
backlight->props.brightness = err;
}
pr_debug("Event handler installed\n");
return 0;
err_free_backlight:
backlight_device_unregister(backlight);
err_free_input:
sparse_keymap_free(msi_wmi_input_dev);
input_unregister_device(msi_wmi_input_dev);
err_uninstall_notifier:
wmi_remove_notify_handler(MSIWMI_EVENT_GUID);
return err;
}
static int __init toshiba_wmi_init(void)
{
int ret;
if (!wmi_has_guid(TOSHIBA_WMI_EVENT_GUID))
return -ENODEV;
ret = toshiba_wmi_input_setup();
if (ret) {
pr_err("Failed to setup input device\n");
return ret;
}
pr_info("Toshiba WMI Hotkey Driver\n");
return 0;
}
/* Base driver */
static void __init thinkpad_wmi_analyze(struct thinkpad_wmi *thinkpad)
{
acpi_status status;
int i = 0;
/* Try to find the number of valid settings of this machine
* and use it to create sysfs attributes */
for (i = 0; i < 0xFF; ++i) {
char *item = NULL;
char *p;
status = thinkpad_wmi_bios_setting(i, &item);
if (ACPI_FAILURE(status))
break ;
if (!item || !*item)
break ;
/* Remove the value part */
p = strchr(item, ',');
if (p)
*p = '\0';
thinkpad->settings[i] = item; /* Cache setting name */
}
thinkpad->settings_count = i;
pr_info("Found %d settings", thinkpad->settings_count);
if (wmi_has_guid(LENOVO_SET_BIOS_SETTINGS_GUID) &&
wmi_has_guid(LENOVO_SAVE_BIOS_SETTINGS_GUID)) {
thinkpad->can_set_bios_settings = true;
}
if (wmi_has_guid(LENOVO_DISCARD_BIOS_SETTINGS_GUID))
thinkpad->can_discard_bios_settings = true;
if (wmi_has_guid(LENOVO_LOAD_DEFAULT_SETTINGS_GUID))
thinkpad->can_load_default_settings = true;
if (wmi_has_guid(LENOVO_GET_BIOS_SELECTIONS_GUID))
thinkpad->can_get_bios_selections = true;
if (wmi_has_guid(LENOVO_SET_BIOS_PASSWORD_GUID))
thinkpad->can_set_bios_password = true;
if (wmi_has_guid(LENOVO_BIOS_PASSWORD_SETTINGS_GUID))
thinkpad->can_get_password_settings = true;
}
static int __init msi_wmi_init(void)
{
int err;
if (!wmi_has_guid(MSIWMI_EVENT_GUID)) {
printk(KERN_ERR
"This machine doesn't have MSI-hotkeys through WMI\n");
return -ENODEV;
}
err = wmi_install_notify_handler(MSIWMI_EVENT_GUID,
msi_wmi_notify, NULL);
if (err)
return -EINVAL;
err = msi_wmi_input_setup();
if (err)
goto err_uninstall_notifier;
if (!acpi_video_backlight_support()) {
backlight = backlight_device_register(DRV_NAME,
NULL, NULL, &msi_backlight_ops);
if (IS_ERR(backlight))
goto err_free_input;
backlight->props.max_brightness = ARRAY_SIZE(backlight_map) - 1;
err = bl_get(NULL);
if (err < 0)
goto err_free_backlight;
backlight->props.brightness = err;
}
dprintk("Event handler installed\n");
return 0;
err_free_backlight:
backlight_device_unregister(backlight);
err_free_input:
input_unregister_device(msi_wmi_input_dev);
err_uninstall_notifier:
wmi_remove_notify_handler(MSIWMI_EVENT_GUID);
return err;
}
static int __init gb_wmi_init(void)
{
int err;
if (!wmi_has_guid(GB_WMI_EVENT_GUID)) {
pr_err("This machine doesn't have GB input through WMI\n");
return -ENODEV;
}
err = gb_wmi_input_setup();
if (err)
return err;
err = wmi_install_notify_handler(GB_WMI_EVENT_GUID, gb_wmi_notify, NULL);
if (ACPI_FAILURE(err)) {
return -ENODEV;
}
pr_info("GB WMI driver loaded\n");
return 0;
}
static int __init peaq_wmi_init(void)
{
if (!wmi_has_guid(PEAQ_DOLBY_BUTTON_GUID))
return -ENODEV;
peaq_poll_dev = input_allocate_polled_device();
if (!peaq_poll_dev)
return -ENOMEM;
peaq_poll_dev->poll = peaq_wmi_poll;
peaq_poll_dev->poll_interval = PEAQ_POLL_INTERVAL_MS;
peaq_poll_dev->poll_interval_max = PEAQ_POLL_MAX_MS;
peaq_poll_dev->input->name = "PEAQ WMI hotkeys";
peaq_poll_dev->input->phys = "wmi/input0";
peaq_poll_dev->input->id.bustype = BUS_HOST;
input_set_capability(peaq_poll_dev->input, EV_KEY, KEY_SOUND);
return input_register_polled_device(peaq_poll_dev);
}
static int __init hello_start(void)
{
int status;
printk(KERN_INFO "Loading hello module...\n");
printk(KERN_INFO "Hello world\n");
if (!wmi_has_guid(EEEPC_WMI_EVENT_GUID)) {
printk("No known WMI GUID found\n");
return -ENODEV;
}
status = wmi_install_notify_handler(EEEPC_WMI_EVENT_GUID,
eeepc_wmi_notify, NULL);
if (ACPI_FAILURE(status)) {
return -ENODEV;
}
return 0;
}
static int __init dell_wmi_init(void)
{
int err;
if (wmi_has_guid(DELL_EVENT_GUID)) {
err = dell_wmi_input_setup();
if (err)
return err;
err = wmi_install_notify_handler(DELL_EVENT_GUID,
dell_wmi_notify, NULL);
if (err) {
input_unregister_device(dell_wmi_input_dev);
printk(KERN_ERR "dell-wmi: Unable to register"
" notify handler - %d\n", err);
return err;
}
} else
printk(KERN_WARNING "dell-wmi: No known WMI GUID found\n");
return 0;
}
static void __exit toshiba_wmi_exit(void)
{
if (wmi_has_guid(TOSHIBA_WMI_EVENT_GUID))
toshiba_wmi_input_destroy();
}
