1/*
  2 * ACPI driver for Topstar notebooks (hotkeys support only)
  3 *
  4 * Copyright (c) 2009 Herton Ronaldo Krzesinski <herton@mandriva.com.br>
  5 *
  6 * Implementation inspired by existing x86 platform drivers, in special
  7 * asus/eepc/fujitsu-laptop, thanks to their authors
  8 *
  9 * This program is free software; you can redistribute it and/or modify
 10 * it under the terms of the GNU General Public License version 2 as
 11 * published by the Free Software Foundation.
 12 */
 13
 14#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 15
 16#include <linux/kernel.h>
 17#include <linux/module.h>
 18#include <linux/init.h>
 19#include <linux/slab.h>
 20#include <linux/acpi.h>
 21#include <linux/input.h>
 22#include <linux/input/sparse-keymap.h>
 23
 24#define ACPI_TOPSTAR_CLASS "topstar"
 25
 26struct topstar_hkey {
 27	struct input_dev *inputdev;
 28};
 29
 30static const struct key_entry topstar_keymap[] = {
 31	{ KE_KEY, 0x80, { KEY_BRIGHTNESSUP } },
 32	{ KE_KEY, 0x81, { KEY_BRIGHTNESSDOWN } },
 33	{ KE_KEY, 0x83, { KEY_VOLUMEUP } },
 34	{ KE_KEY, 0x84, { KEY_VOLUMEDOWN } },
 35	{ KE_KEY, 0x85, { KEY_MUTE } },
 36	{ KE_KEY, 0x86, { KEY_SWITCHVIDEOMODE } },
 37	{ KE_KEY, 0x87, { KEY_F13 } }, /* touchpad enable/disable key */
 38	{ KE_KEY, 0x88, { KEY_WLAN } },
 39	{ KE_KEY, 0x8a, { KEY_WWW } },
 40	{ KE_KEY, 0x8b, { KEY_MAIL } },
 41	{ KE_KEY, 0x8c, { KEY_MEDIA } },
 42
 43	/* Known non hotkey events don't handled or that we don't care yet */
 
 44	{ KE_IGNORE, 0x8e, },
 45	{ KE_IGNORE, 0x8f, },
 46	{ KE_IGNORE, 0x90, },
 47
 48	/*
 49	 * 'G key' generate two event codes, convert to only
 50	 * one event/key code for now, consider replacing by
 51	 * a switch (3G switch - SW_3G?)
 52	 */
 53	{ KE_KEY, 0x96, { KEY_F14 } },
 54	{ KE_KEY, 0x97, { KEY_F14 } },
 55
 56	{ KE_END, 0 }
 57};
 58
 59static void acpi_topstar_notify(struct acpi_device *device, u32 event)
 60{
 61	static bool dup_evnt[2];
 62	bool *dup;
 63	struct topstar_hkey *hkey = acpi_driver_data(device);
 64
 65	/* 0x83 and 0x84 key events comes duplicated... */
 66	if (event == 0x83 || event == 0x84) {
 67		dup = &dup_evnt[event - 0x83];
 68		if (*dup) {
 69			*dup = false;
 70			return;
 71		}
 72		*dup = true;
 73	}
 74
 75	if (!sparse_keymap_report_event(hkey->inputdev, event, 1, true))
 76		pr_info("unknown event = 0x%02x\n", event);
 77}
 78
 79static int acpi_topstar_fncx_switch(struct acpi_device *device, bool state)
 80{
 81	acpi_status status;
 82	union acpi_object fncx_params[1] = {
 83		{ .type = ACPI_TYPE_INTEGER }
 84	};
 85	struct acpi_object_list fncx_arg_list = { 1, &fncx_params[0] };
 86
 87	fncx_params[0].integer.value = state ? 0x86 : 0x87;
 88	status = acpi_evaluate_object(device->handle, "FNCX", &fncx_arg_list, NULL);
 89	if (ACPI_FAILURE(status)) {
 90		pr_err("Unable to switch FNCX notifications\n");
 91		return -ENODEV;
 92	}
 93
 94	return 0;
 95}
 96
 97static int acpi_topstar_init_hkey(struct topstar_hkey *hkey)
 98{
 99	struct input_dev *input;
100	int error;
101
102	input = input_allocate_device();
103	if (!input) {
104		pr_err("Unable to allocate input device\n");
105		return -ENOMEM;
106	}
107
108	input->name = "Topstar Laptop extra buttons";
109	input->phys = "topstar/input0";
110	input->id.bustype = BUS_HOST;
111
112	error = sparse_keymap_setup(input, topstar_keymap, NULL);
113	if (error) {
114		pr_err("Unable to setup input device keymap\n");
115		goto err_free_dev;
116	}
117
118	error = input_register_device(input);
119	if (error) {
120		pr_err("Unable to register input device\n");
121		goto err_free_keymap;
122	}
123
124	hkey->inputdev = input;
125	return 0;
126
127 err_free_keymap:
128	sparse_keymap_free(input);
129 err_free_dev:
130	input_free_device(input);
131	return error;
132}
133
134static int acpi_topstar_add(struct acpi_device *device)
135{
136	struct topstar_hkey *tps_hkey;
137
138	tps_hkey = kzalloc(sizeof(struct topstar_hkey), GFP_KERNEL);
139	if (!tps_hkey)
140		return -ENOMEM;
141
142	strcpy(acpi_device_name(device), "Topstar TPSACPI");
143	strcpy(acpi_device_class(device), ACPI_TOPSTAR_CLASS);
144
145	if (acpi_topstar_fncx_switch(device, true))
146		goto add_err;
147
148	if (acpi_topstar_init_hkey(tps_hkey))
149		goto add_err;
150
151	device->driver_data = tps_hkey;
152	return 0;
153
154add_err:
155	kfree(tps_hkey);
156	return -ENODEV;
157}
158
159static int acpi_topstar_remove(struct acpi_device *device, int type)
160{
161	struct topstar_hkey *tps_hkey = acpi_driver_data(device);
162
163	acpi_topstar_fncx_switch(device, false);
164
165	sparse_keymap_free(tps_hkey->inputdev);
166	input_unregister_device(tps_hkey->inputdev);
167	kfree(tps_hkey);
168
169	return 0;
170}
171
172static const struct acpi_device_id topstar_device_ids[] = {
173	{ "TPSACPI01", 0 },
174	{ "", 0 },
175};
176MODULE_DEVICE_TABLE(acpi, topstar_device_ids);
177
178static struct acpi_driver acpi_topstar_driver = {
179	.name = "Topstar laptop ACPI driver",
180	.class = ACPI_TOPSTAR_CLASS,
181	.ids = topstar_device_ids,
182	.ops = {
183		.add = acpi_topstar_add,
184		.remove = acpi_topstar_remove,
185		.notify = acpi_topstar_notify,
186	},
187};
188
189static int __init topstar_laptop_init(void)
190{
191	int ret;
192
193	ret = acpi_bus_register_driver(&acpi_topstar_driver);
194	if (ret < 0)
195		return ret;
196
197	pr_info("ACPI extras driver loaded\n");
198
199	return 0;
200}
201
202static void __exit topstar_laptop_exit(void)
203{
204	acpi_bus_unregister_driver(&acpi_topstar_driver);
205}
206
207module_init(topstar_laptop_init);
208module_exit(topstar_laptop_exit);
209
210MODULE_AUTHOR("Herton Ronaldo Krzesinski");
211MODULE_DESCRIPTION("Topstar Laptop ACPI Extras driver");
212MODULE_LICENSE("GPL");

  1/*
  2 * ACPI driver for Topstar notebooks (hotkeys support only)
  3 *
  4 * Copyright (c) 2009 Herton Ronaldo Krzesinski <herton@mandriva.com.br>
  5 *
  6 * Implementation inspired by existing x86 platform drivers, in special
  7 * asus/eepc/fujitsu-laptop, thanks to their authors
  8 *
  9 * This program is free software; you can redistribute it and/or modify
 10 * it under the terms of the GNU General Public License version 2 as
 11 * published by the Free Software Foundation.
 12 */
 13
 14#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 15
 16#include <linux/kernel.h>
 17#include <linux/module.h>
 18#include <linux/init.h>
 19#include <linux/slab.h>
 20#include <linux/acpi.h>
 21#include <linux/input.h>
 22#include <linux/input/sparse-keymap.h>
 23
 24#define ACPI_TOPSTAR_CLASS "topstar"
 25
 26struct topstar_hkey {
 27	struct input_dev *inputdev;
 28};
 29
 30static const struct key_entry topstar_keymap[] = {
 31	{ KE_KEY, 0x80, { KEY_BRIGHTNESSUP } },
 32	{ KE_KEY, 0x81, { KEY_BRIGHTNESSDOWN } },
 33	{ KE_KEY, 0x83, { KEY_VOLUMEUP } },
 34	{ KE_KEY, 0x84, { KEY_VOLUMEDOWN } },
 35	{ KE_KEY, 0x85, { KEY_MUTE } },
 36	{ KE_KEY, 0x86, { KEY_SWITCHVIDEOMODE } },
 37	{ KE_KEY, 0x87, { KEY_F13 } }, /* touchpad enable/disable key */
 38	{ KE_KEY, 0x88, { KEY_WLAN } },
 39	{ KE_KEY, 0x8a, { KEY_WWW } },
 40	{ KE_KEY, 0x8b, { KEY_MAIL } },
 41	{ KE_KEY, 0x8c, { KEY_MEDIA } },
 42
 43	/* Known non hotkey events don't handled or that we don't care yet */
 44	{ KE_IGNORE, 0x82, }, /* backlight event */
 45	{ KE_IGNORE, 0x8e, },
 46	{ KE_IGNORE, 0x8f, },
 47	{ KE_IGNORE, 0x90, },
 48
 49	/*
 50	 * 'G key' generate two event codes, convert to only
 51	 * one event/key code for now, consider replacing by
 52	 * a switch (3G switch - SW_3G?)
 53	 */
 54	{ KE_KEY, 0x96, { KEY_F14 } },
 55	{ KE_KEY, 0x97, { KEY_F14 } },
 56
 57	{ KE_END, 0 }
 58};
 59
 60static void acpi_topstar_notify(struct acpi_device *device, u32 event)
 61{
 62	static bool dup_evnt[2];
 63	bool *dup;
 64	struct topstar_hkey *hkey = acpi_driver_data(device);
 65
 66	/* 0x83 and 0x84 key events comes duplicated... */
 67	if (event == 0x83 || event == 0x84) {
 68		dup = &dup_evnt[event - 0x83];
 69		if (*dup) {
 70			*dup = false;
 71			return;
 72		}
 73		*dup = true;
 74	}
 75
 76	if (!sparse_keymap_report_event(hkey->inputdev, event, 1, true))
 77		pr_info("unknown event = 0x%02x\n", event);
 78}
 79
 80static int acpi_topstar_fncx_switch(struct acpi_device *device, bool state)
 81{
 82	acpi_status status;
 83	union acpi_object fncx_params[1] = {
 84		{ .type = ACPI_TYPE_INTEGER }
 85	};
 86	struct acpi_object_list fncx_arg_list = { 1, &fncx_params[0] };
 87
 88	fncx_params[0].integer.value = state ? 0x86 : 0x87;
 89	status = acpi_evaluate_object(device->handle, "FNCX", &fncx_arg_list, NULL);
 90	if (ACPI_FAILURE(status)) {
 91		pr_err("Unable to switch FNCX notifications\n");
 92		return -ENODEV;
 93	}
 94
 95	return 0;
 96}
 97
 98static int acpi_topstar_init_hkey(struct topstar_hkey *hkey)
 99{
100	struct input_dev *input;
101	int error;
102
103	input = input_allocate_device();
104	if (!input) {
105		pr_err("Unable to allocate input device\n");
106		return -ENOMEM;
107	}
108
109	input->name = "Topstar Laptop extra buttons";
110	input->phys = "topstar/input0";
111	input->id.bustype = BUS_HOST;
112
113	error = sparse_keymap_setup(input, topstar_keymap, NULL);
114	if (error) {
115		pr_err("Unable to setup input device keymap\n");
116		goto err_free_dev;
117	}
118
119	error = input_register_device(input);
120	if (error) {
121		pr_err("Unable to register input device\n");
122		goto err_free_keymap;
123	}
124
125	hkey->inputdev = input;
126	return 0;
127
128 err_free_keymap:
129	sparse_keymap_free(input);
130 err_free_dev:
131	input_free_device(input);
132	return error;
133}
134
135static int acpi_topstar_add(struct acpi_device *device)
136{
137	struct topstar_hkey *tps_hkey;
138
139	tps_hkey = kzalloc(sizeof(struct topstar_hkey), GFP_KERNEL);
140	if (!tps_hkey)
141		return -ENOMEM;
142
143	strcpy(acpi_device_name(device), "Topstar TPSACPI");
144	strcpy(acpi_device_class(device), ACPI_TOPSTAR_CLASS);
145
146	if (acpi_topstar_fncx_switch(device, true))
147		goto add_err;
148
149	if (acpi_topstar_init_hkey(tps_hkey))
150		goto add_err;
151
152	device->driver_data = tps_hkey;
153	return 0;
154
155add_err:
156	kfree(tps_hkey);
157	return -ENODEV;
158}
159
160static int acpi_topstar_remove(struct acpi_device *device, int type)
161{
162	struct topstar_hkey *tps_hkey = acpi_driver_data(device);
163
164	acpi_topstar_fncx_switch(device, false);
165
166	sparse_keymap_free(tps_hkey->inputdev);
167	input_unregister_device(tps_hkey->inputdev);
168	kfree(tps_hkey);
169
170	return 0;
171}
172
173static const struct acpi_device_id topstar_device_ids[] = {
174	{ "TPSACPI01", 0 },
175	{ "", 0 },
176};
177MODULE_DEVICE_TABLE(acpi, topstar_device_ids);
178
179static struct acpi_driver acpi_topstar_driver = {
180	.name = "Topstar laptop ACPI driver",
181	.class = ACPI_TOPSTAR_CLASS,
182	.ids = topstar_device_ids,
183	.ops = {
184		.add = acpi_topstar_add,
185		.remove = acpi_topstar_remove,
186		.notify = acpi_topstar_notify,
187	},
188};
189
190static int __init topstar_laptop_init(void)
191{
192	int ret;
193
194	ret = acpi_bus_register_driver(&acpi_topstar_driver);
195	if (ret < 0)
196		return ret;
197
198	pr_info("ACPI extras driver loaded\n");
199
200	return 0;
201}
202
203static void __exit topstar_laptop_exit(void)
204{
205	acpi_bus_unregister_driver(&acpi_topstar_driver);
206}
207
208module_init(topstar_laptop_init);
209module_exit(topstar_laptop_exit);
210
211MODULE_AUTHOR("Herton Ronaldo Krzesinski");
212MODULE_DESCRIPTION("Topstar Laptop ACPI Extras driver");
213MODULE_LICENSE("GPL");