Root/target/linux/xburst/patches-2.6.37/800-n516-lpc.patch

1From 9d67bbbef07b0568d0541f79e3cd664d71d2d96c Mon Sep 17 00:00:00 2001
2From: Lars-Peter Clausen <lars@metafoo.de>
3Date: Wed, 12 May 2010 14:22:36 +0200
4Subject: [PATCH 4/5] Add n516 lpc driver
5
6---
7 drivers/misc/Kconfig | 8 +
8 drivers/misc/Makefile | 1 +
9 drivers/misc/n516-lpc.c | 471 +++++++++++++++++++++++++++++++++++++++++++++++
10 3 files changed, 480 insertions(+), 0 deletions(-)
11 create mode 100644 drivers/misc/n516-lpc.c
12
13--- a/drivers/misc/Kconfig
14+++ b/drivers/misc/Kconfig
15@@ -452,6 +452,14 @@ config PCH_PHUB
16       To compile this driver as a module, choose M here: the module will
17       be called pch_phub.
18 
19+config N516_LPC
20+ tristate "N516 keys & power controller"
21+ depends on I2C
22+ depends on INPUT
23+ depends on POWER_SUPPLY
24+ help
25+ N516 keyboard & power controller driver
26+
27 source "drivers/misc/c2port/Kconfig"
28 source "drivers/misc/eeprom/Kconfig"
29 source "drivers/misc/cb710/Kconfig"
30--- a/drivers/misc/Makefile
31+++ b/drivers/misc/Makefile
32@@ -42,3 +42,4 @@ obj-$(CONFIG_ARM_CHARLCD) += arm-charlcd
33 obj-$(CONFIG_PCH_PHUB) += pch_phub.o
34 obj-y += ti-st/
35 obj-$(CONFIG_AB8500_PWM) += ab8500-pwm.o
36+obj-$(CONFIG_N516_LPC) += n516-lpc.o
37--- /dev/null
38+++ b/drivers/misc/n516-lpc.c
39@@ -0,0 +1,471 @@
40+#include <linux/module.h>
41+#include <linux/version.h>
42+#include <linux/init.h>
43+#include <linux/fs.h>
44+#include <linux/interrupt.h>
45+#include <linux/irq.h>
46+#include <linux/sched.h>
47+#include <linux/pm.h>
48+#include <linux/sysctl.h>
49+#include <linux/proc_fs.h>
50+#include <linux/delay.h>
51+#include <linux/platform_device.h>
52+#include <linux/input.h>
53+#include <linux/power_supply.h>
54+#include <linux/suspend.h>
55+
56+#include <linux/i2c.h>
57+
58+#include <asm/mach-jz4740/irq.h>
59+#include <asm/mach-jz4740/gpio.h>
60+#include <asm/mach-jz4740/board-n516.h>
61+
62+static int batt_level=0;
63+module_param(batt_level, int, 0);
64+
65+struct n516_lpc_chip {
66+ struct i2c_client *i2c_client;
67+ struct input_dev *input;
68+ unsigned int battery_level;
69+ unsigned int suspending:1, can_sleep:1;
70+};
71+
72+static struct n516_lpc_chip *the_lpc;
73+
74+struct i2c_device_id n516_lpc_i2c_ids[] = {
75+ {"LPC524", 0},
76+ {},
77+};
78+
79+MODULE_DEVICE_TABLE(i2c, n516_lpc_i2c_ids);
80+
81+static const unsigned short normal_i2c[] = I2C_ADDRS(0x54);
82+
83+static const unsigned int n516_lpc_keymap[] = {
84+ [0x01] = KEY_4,
85+ [0x02] = KEY_3,
86+ [0x03] = KEY_2,
87+ [0x04] = KEY_1,
88+ [0x05] = KEY_0,
89+ [0x07] = KEY_9,
90+ [0x08] = KEY_8,
91+ [0x09] = KEY_7,
92+ [0x0a] = KEY_6,
93+ [0x0b] = KEY_5,
94+ [0x0d] = KEY_PLAYPAUSE,
95+ [0x0e] = KEY_MENU,
96+ [0x0f] = KEY_SEARCH,
97+ [0x10] = KEY_DIRECTION,
98+ [0x11] = KEY_SPACE,
99+ [0x13] = KEY_ENTER,
100+ [0x14] = KEY_UP,
101+ [0x15] = KEY_DOWN,
102+ [0x16] = KEY_RIGHT,
103+ [0x17] = KEY_LEFT,
104+ [0x19] = KEY_PAGEDOWN,
105+ [0x1a] = KEY_PAGEUP,
106+ [0x1c] = KEY_POWER,
107+ [0x1d] = KEY_ESC,
108+ [0x1e] = KEY_SLEEP,
109+ [0x1f] = KEY_WAKEUP,
110+};
111+
112+static const unsigned int batt_charge[] = {0, 7, 20, 45, 65, 80, 100};
113+#define MAX_BAT_LEVEL 6
114+
115+static inline int n516_bat_charging(void)
116+{
117+ return !gpio_get_value(GPIO_CHARG_STAT_N);
118+}
119+
120+static int n516_bat_get_status(struct power_supply *b)
121+{
122+ if (power_supply_am_i_supplied(b)) {
123+ if (n516_bat_charging())
124+ return POWER_SUPPLY_STATUS_CHARGING;
125+ else
126+ return POWER_SUPPLY_STATUS_FULL;
127+ } else {
128+ return POWER_SUPPLY_STATUS_DISCHARGING;
129+ }
130+}
131+
132+static int n516_bat_get_charge(struct power_supply *b)
133+{
134+ return batt_charge[the_lpc->battery_level];
135+}
136+
137+static int n516_bat_get_property(struct power_supply *b,
138+ enum power_supply_property psp,
139+ union power_supply_propval *val)
140+{
141+ switch (psp) {
142+ case POWER_SUPPLY_PROP_STATUS:
143+ val->intval = n516_bat_get_status(b);
144+ break;
145+ case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
146+ val->intval = 100;
147+ break;
148+ case POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN:
149+ val->intval = 0;
150+ break;
151+ case POWER_SUPPLY_PROP_CHARGE_NOW:
152+ val->intval = n516_bat_get_charge(b);
153+ break;
154+ default:
155+ return -EINVAL;
156+ }
157+ return 0;
158+}
159+
160+static void n516_bat_power_changed(struct power_supply *p)
161+{
162+ if (power_supply_am_i_supplied(p) && !n516_bat_charging())
163+ the_lpc->battery_level = MAX_BAT_LEVEL;
164+
165+ power_supply_changed(p);
166+}
167+
168+static enum power_supply_property n516_bat_properties[] = {
169+ POWER_SUPPLY_PROP_STATUS,
170+ POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
171+ POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN,
172+ POWER_SUPPLY_PROP_CHARGE_NOW,
173+};
174+
175+static struct power_supply n516_battery = {
176+ .name = "n516-battery",
177+ .get_property = n516_bat_get_property,
178+ .properties = n516_bat_properties,
179+ .num_properties = ARRAY_SIZE(n516_bat_properties),
180+ .external_power_changed = n516_bat_power_changed,
181+};
182+
183+static irqreturn_t n516_bat_charge_irq(int irq, void *dev)
184+{
185+ struct power_supply *psy = dev;
186+
187+ dev_dbg(psy->dev, "Battery charging IRQ\n");
188+
189+ if (power_supply_am_i_supplied(psy) && !n516_bat_charging())
190+ the_lpc->battery_level = MAX_BAT_LEVEL;
191+
192+ power_supply_changed(psy);
193+
194+ return IRQ_HANDLED;
195+}
196+
197+static int n516_lpc_send_message(struct n516_lpc_chip *chip, unsigned char val)
198+{
199+ struct i2c_client *client = chip->i2c_client;
200+ struct i2c_msg msg = {client->addr, client->flags, 1, &val};
201+ int ret = 0;
202+
203+ ret = i2c_transfer(client->adapter, &msg, 1);
204+ return ret > 0 ? 0 : ret;
205+}
206+
207+static void n516_key_event(struct n516_lpc_chip *chip, unsigned char keycode)
208+{
209+ struct i2c_client *client = chip->i2c_client;
210+ bool long_press = false;
211+
212+ if (keycode & 0x40) {
213+ keycode &= ~0x40;
214+ long_press = true;
215+ }
216+
217+ dev_dbg(&client->dev, "keycode: 0x%02x, long_press: 0x%02x\n", keycode, (unsigned int)long_press);
218+
219+ if (keycode >= ARRAY_SIZE(n516_lpc_keymap) || n516_lpc_keymap[keycode] == 0)
220+ return;
221+
222+ if (long_press)
223+ input_report_key(chip->input, KEY_LEFTALT, 1);
224+
225+ input_report_key(chip->input, n516_lpc_keymap[keycode], 1);
226+ input_sync(chip->input);
227+ input_report_key(chip->input, n516_lpc_keymap[keycode], 0);
228+
229+ if (long_press)
230+ input_report_key(chip->input, KEY_LEFTALT, 0);
231+ input_sync(chip->input);
232+}
233+
234+static void n516_battery_event(struct n516_lpc_chip *chip, unsigned char battery_level)
235+{
236+ if (battery_level != chip->battery_level) {
237+ chip->battery_level = battery_level;
238+ power_supply_changed(&n516_battery);
239+ }
240+}
241+
242+static irqreturn_t n516_lpc_irq_thread(int irq, void *devid)
243+{
244+ struct n516_lpc_chip *chip = (struct n516_lpc_chip*)devid;
245+ int ret;
246+ unsigned char raw_msg;
247+ struct i2c_client *client = chip->i2c_client;
248+ struct i2c_msg msg = {client->addr, client->flags | I2C_M_RD, 1, &raw_msg};
249+
250+ if (client->dev.power.status >= DPM_OFF)
251+ return IRQ_HANDLED;
252+
253+ ret = i2c_transfer(client->adapter, &msg, 1);
254+ if (ret != 1) {
255+ dev_dbg(&client->dev, "I2C error: %d\n", ret);
256+ return IRQ_HANDLED;
257+ }
258+
259+ dev_dbg(&client->dev, "msg: 0x%02x\n", raw_msg);
260+
261+ /* Ack wakeup event */
262+ if ((raw_msg & ~0x40) < ARRAY_SIZE(n516_lpc_keymap))
263+ n516_key_event(chip, raw_msg);
264+ else if ((raw_msg >= 0x81) && (raw_msg <= 0x87))
265+ n516_battery_event(chip, raw_msg - 0x81);
266+ else if (raw_msg == 0x7e)
267+ n516_lpc_send_message(chip, 0x00);
268+ else
269+ dev_warn(&client->dev, "Unknown message: %x\n", raw_msg);
270+
271+ if (chip->suspending)
272+ chip->can_sleep = 0;
273+
274+ return IRQ_HANDLED;
275+}
276+
277+static void n516_lpc_power_off(void)
278+{
279+ struct i2c_client *client = the_lpc->i2c_client;
280+ unsigned char val = 0x01;
281+ struct i2c_msg msg = {client->addr, client->flags, 1, &val};
282+
283+ printk("Issue LPC POWEROFF command...\n");
284+ while (1)
285+ i2c_transfer(client->adapter, &msg, 1);
286+}
287+
288+static int n516_lpc_detect(struct i2c_client *client, struct i2c_board_info *info)
289+{
290+ return 0;
291+}
292+
293+static int n516_lpc_suspend_notifier(struct notifier_block *nb,
294+ unsigned long event,
295+ void *dummy)
296+{
297+ switch(event) {
298+ case PM_SUSPEND_PREPARE:
299+ the_lpc->suspending = 1;
300+ the_lpc->can_sleep = 1;
301+ break;
302+ case PM_POST_SUSPEND:
303+ the_lpc->suspending = 0;
304+ the_lpc->can_sleep = 1;
305+ break;
306+ default:
307+ return NOTIFY_DONE;
308+ }
309+ return NOTIFY_OK;
310+}
311+
312+static struct notifier_block n516_lpc_notif_block = {
313+ .notifier_call = n516_lpc_suspend_notifier,
314+};
315+
316+static int __devinit n516_lpc_probe(struct i2c_client *client, const struct i2c_device_id *id)
317+{
318+ struct n516_lpc_chip *chip;
319+ struct input_dev *input;
320+ int ret = 0;
321+ int i;
322+
323+ chip = kzalloc(sizeof(*chip), GFP_KERNEL);
324+ if (!chip)
325+ return -ENOMEM;
326+
327+ the_lpc = chip;
328+ chip->i2c_client = client;
329+ if ((batt_level > 0) && (batt_level < ARRAY_SIZE(batt_charge)))
330+ chip->battery_level = batt_level;
331+ else
332+ chip->battery_level = 1;
333+
334+ i2c_set_clientdata(client, chip);
335+
336+ ret = gpio_request(GPIO_LPC_INT, "LPC interrupt request");
337+ if (ret) {
338+ dev_err(&client->dev, "Unable to reguest LPC INT GPIO\n");
339+ goto err_gpio_req_lpcint;
340+ }
341+
342+ ret = gpio_request(GPIO_CHARG_STAT_N, "LPC charging status");
343+ if (ret) {
344+ dev_err(&client->dev, "Unable to reguest CHARG STAT GPIO\n");
345+ goto err_gpio_req_chargstat;
346+ }
347+
348+ /* Enter normal mode */
349+ n516_lpc_send_message(chip, 0x2);
350+
351+ input = input_allocate_device();
352+ if (!input) {
353+ dev_err(&client->dev, "Unable to allocate input device\n");
354+ ret = -ENOMEM;
355+ goto err_input_alloc;
356+ }
357+
358+ chip->input = input;
359+
360+ __set_bit(EV_KEY, input->evbit);
361+
362+ for (i = 0; i < ARRAY_SIZE(n516_lpc_keymap); i++)
363+ __set_bit(n516_lpc_keymap[i], input->keybit);
364+
365+ __set_bit(KEY_LEFTALT, input->keybit);
366+
367+ input->name = "n516-keys";
368+ input->phys = "n516-keys/input0";
369+ input->dev.parent = &client->dev;
370+ input->id.bustype = BUS_I2C;
371+ input->id.vendor = 0x0001;
372+ input->id.product = 0x0001;
373+ input->id.version = 0x0100;
374+
375+ ret = input_register_device(input);
376+ if (ret < 0) {
377+ dev_err(&client->dev, "Unable to register input device\n");
378+ goto err_input_register;
379+ }
380+
381+ ret = power_supply_register(NULL, &n516_battery);
382+ if (ret) {
383+ dev_err(&client->dev, "Unable to register N516 battery\n");
384+ goto err_bat_reg;
385+ }
386+
387+ ret = request_threaded_irq(gpio_to_irq(GPIO_LPC_INT), NULL,
388+ n516_lpc_irq_thread,
389+ IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
390+ "lpc", chip);
391+ if (ret) {
392+ dev_err(&client->dev, "request_irq failed: %d\n", ret);
393+ goto err_request_lpc_irq;
394+ }
395+
396+ ret = request_irq(gpio_to_irq(GPIO_CHARG_STAT_N), n516_bat_charge_irq,
397+ IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
398+ "battery charging", &n516_battery);
399+ if (ret) {
400+ dev_err(&client->dev, "Unable to claim battery charging IRQ\n");
401+ goto err_request_chrg_irq;
402+ }
403+
404+ pm_power_off = n516_lpc_power_off;
405+ ret = register_pm_notifier(&n516_lpc_notif_block);
406+ if (ret) {
407+ dev_err(&client->dev, "Unable to register PM notify block\n");
408+ goto err_reg_pm_notifier;
409+ }
410+
411+ device_init_wakeup(&client->dev, 1);
412+
413+ return 0;
414+
415+ unregister_pm_notifier(&n516_lpc_notif_block);
416+err_reg_pm_notifier:
417+ free_irq(gpio_to_irq(GPIO_CHARG_STAT_N), &n516_battery);
418+err_request_chrg_irq:
419+ free_irq(gpio_to_irq(GPIO_LPC_INT), chip);
420+err_request_lpc_irq:
421+ power_supply_unregister(&n516_battery);
422+err_bat_reg:
423+ input_unregister_device(input);
424+err_input_register:
425+ input_free_device(input);
426+err_input_alloc:
427+ gpio_free(GPIO_CHARG_STAT_N);
428+err_gpio_req_chargstat:
429+ gpio_free(GPIO_LPC_INT);
430+err_gpio_req_lpcint:
431+ i2c_set_clientdata(client, NULL);
432+ kfree(chip);
433+
434+ return ret;
435+}
436+
437+static int __devexit n516_lpc_remove(struct i2c_client *client)
438+{
439+ struct n516_lpc_chip *chip = i2c_get_clientdata(client);
440+
441+ unregister_pm_notifier(&n516_lpc_notif_block);
442+ pm_power_off = NULL;
443+ free_irq(gpio_to_irq(GPIO_CHARG_STAT_N), &n516_battery);
444+ free_irq(gpio_to_irq(GPIO_LPC_INT), chip);
445+ power_supply_unregister(&n516_battery);
446+ input_unregister_device(chip->input);
447+ gpio_free(GPIO_CHARG_STAT_N);
448+ gpio_free(GPIO_LPC_INT);
449+ i2c_set_clientdata(client, NULL);
450+ kfree(chip);
451+
452+ return 0;
453+}
454+
455+#if CONFIG_PM
456+static int n516_lpc_suspend(struct i2c_client *client, pm_message_t msg)
457+{
458+ if (!the_lpc->can_sleep)
459+ return -EBUSY;
460+
461+ if (device_may_wakeup(&client->dev))
462+ enable_irq_wake(gpio_to_irq(GPIO_LPC_INT));
463+
464+ return 0;
465+}
466+
467+static int n516_lpc_resume(struct i2c_client *client)
468+{
469+ if (device_may_wakeup(&client->dev))
470+ disable_irq_wake(gpio_to_irq(GPIO_LPC_INT));
471+
472+ return 0;
473+}
474+#else
475+#define n516_lpc_suspend NULL
476+#define n516_lpc_resume NULL
477+#endif
478+
479+
480+static struct i2c_driver n516_lpc_driver = {
481+ .class = I2C_CLASS_HWMON,
482+ .driver = {
483+ .name = "n516-keys",
484+ .owner = THIS_MODULE,
485+ },
486+ .probe = n516_lpc_probe,
487+ .remove = __devexit_p(n516_lpc_remove),
488+ .detect = n516_lpc_detect,
489+ .id_table = n516_lpc_i2c_ids,
490+ .address_list = normal_i2c,
491+ .suspend = n516_lpc_suspend,
492+ .resume = n516_lpc_resume,
493+};
494+
495+static int __init n516_lpc_init(void)
496+{
497+ return i2c_add_driver(&n516_lpc_driver);
498+}
499+module_init(n516_lpc_init);
500+
501+static void __exit n516_lpc_exit(void)
502+{
503+ i2c_del_driver(&n516_lpc_driver);
504+}
505+module_exit(n516_lpc_exit);
506+
507+MODULE_AUTHOR("Yauhen Kharuzhy");
508+MODULE_LICENSE("GPL");
509+MODULE_DESCRIPTION("Keys and power controller driver for N516");
510+MODULE_ALIAS("platform:n516-keys");
511

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive