ENGR00136874-1 pwrkey: enhance the driver to support key press status

Add get keypad press status callback and desired send key value
to the platform data.

Signed-off-by: Xinyu Chen <xinyu.chen@freescale.com>

2 files changed, 76 insertions, 50 deletions

diff --git a/drivers/input/keyboard/mxc_pwrkey.c b/drivers/input/keyboard/mxc_pwrkey.c
index 378cb4f7663e..7e8ae02c8fee 100755
--- a/drivers/input/keyboard/mxc_pwrkey.c
+++ b/drivers/input/keyboard/mxc_pwrkey.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010 Freescale Semiconductor, Inc. All Rights Reserved.
+ * Copyright (C) 2010-2011 Freescale Semiconductor, Inc. All Rights Reserved.
  */
 
 /*
@@ -19,6 +19,7 @@
  */
 #include <linux/module.h>
 #include <linux/sched.h>
+#include <linux/slab.h>
 #include <linux/mm.h>
 #include <linux/init.h>
 #include <asm/io.h>
@@ -32,95 +33,120 @@
 #include <linux/platform_device.h>
 #include <linux/powerkey.h>
 
-#define KEYCODE_ONOFF            KEY_F4
+struct mxc_pwrkey_priv {
 
-/*! Input device structure. */
-static struct input_dev *mxcpwrkey_dev;
-static bool key_press;
-static void power_key_event_handler(void *param)
+	struct input_dev *input;
+	int value;
+	int (*get_status) (int);
+};
+
+static struct mxc_pwrkey_priv *mxc_pwrkey;
+
+static void pwrkey_event_handler(void *param)
 {
-	if (!key_press) {
-		key_press = true;
-		input_report_key(mxcpwrkey_dev, KEYCODE_ONOFF, 1);
-		pr_info("%s_KeyUP\n", __func__);
+	int pressed;
+
+	pressed = mxc_pwrkey->get_status((int)param);
+
+	if (pressed) {
+		input_report_key(
+			mxc_pwrkey->input, mxc_pwrkey->value, 1);
+		pr_info("%s_Keydown\n", __func__);
 	} else {
-		if (key_press) {
-			key_press = false;
-			input_report_key(mxcpwrkey_dev, KEYCODE_ONOFF, 0);
-			pr_info("%s_KeyDown\n", __func__);
-		}
+		input_report_key(
+			mxc_pwrkey->input, mxc_pwrkey->value, 0);
+		pr_info("%s_Keyup\n", __func__);
 	}
 }
+
 static int mxcpwrkey_probe(struct platform_device *pdev)
 {
-	int retval, err;
+	int retval;
+	struct input_dev *input;
 	struct power_key_platform_data *pdata = pdev->dev.platform_data;
 
-	if (!pdata) {
-		printk(KERN_DEBUG "power key platform data is NULL, there is no power key\n");
-		return 0;
+	if (mxc_pwrkey) {
+		dev_warn(&pdev->dev, "two power key??\n");
+		return -EBUSY;
 	}
-	printk(KERN_INFO "PMIC powerkey probe\n");
 
-	key_press = false;
-	mxcpwrkey_dev = input_allocate_device();
-	if (!mxcpwrkey_dev) {
-		printk(KERN_ERR "mxcpwrkey_dev: not enough memory for input device\n");
+	if (!pdata || !pdata->get_key_status) {
+		dev_err(&pdev->dev, "can not get platform data\n");
+		return -EINVAL;
+	}
+
+	mxc_pwrkey = kmalloc(sizeof(struct mxc_pwrkey_priv), GFP_KERNEL);
+	if (!mxc_pwrkey) {
+		dev_err(&pdev->dev, "can not allocate private data");
+		return -ENOMEM;
+	}
+
+	input = input_allocate_device();
+	if (!input) {
+		dev_err(&pdev->dev, "no memory for input device\n");
 		retval = -ENOMEM;
 		goto err1;
 	}
 
-	mxcpwrkey_dev->name = "mxc_power_key";
-	mxcpwrkey_dev->phys = "mxcpwrkey/input0";
-	mxcpwrkey_dev->id.bustype = BUS_HOST;
-	mxcpwrkey_dev->evbit[0] = BIT_MASK(EV_KEY);
+	input->name = "mxc_power_key";
+	input->phys = "mxcpwrkey/input0";
+	input->id.bustype = BUS_HOST;
+	input->evbit[0] = BIT_MASK(EV_KEY);
 
-	pdata->register_key_press_handler(power_key_event_handler, NULL);
+	mxc_pwrkey->value = pdata->key_value;
+	mxc_pwrkey->get_status = pdata->get_key_status;
+	mxc_pwrkey->input = input;
+	pdata->register_pwrkey(pwrkey_event_handler);
 
-	input_set_capability(mxcpwrkey_dev, EV_KEY, KEYCODE_ONOFF);
+	input_set_capability(input, EV_KEY, mxc_pwrkey->value);
 
-	retval = input_register_device(mxcpwrkey_dev);
+	retval = input_register_device(input);
 	if (retval < 0) {
-		printk(KERN_ERR "mxcpwrkey_dev: failed to register input device\n");
+		dev_err(&pdev->dev, "failed to register input device\n");
 		goto err2;
 	}
+
+	printk(KERN_INFO "PMIC powerkey probe\n");
+
 	return 0;
+
 err2:
-	input_free_device(mxcpwrkey_dev);
+	input_free_device(input);
 err1:
+	kfree(mxc_pwrkey);
+	mxc_pwrkey = NULL;
+
 	return retval;
 }
+
 static int mxcpwrkey_remove(struct platform_device *pdev)
 {
+	input_unregister_device(mxc_pwrkey->input);
+	input_free_device(mxc_pwrkey->input);
+	kfree(mxc_pwrkey);
+	mxc_pwrkey = NULL;
+
 	return 0;
 }
-static int mxc_pwrkey_suspend(struct platform_device *pdev, pm_message_t state)
-{
-	return 0;
-}
-static int mxc_pwrkey_resume(struct platform_device *pdev)
-{
-	return 0;
-}
+
 static struct platform_driver mxcpwrkey_driver = {
 	.driver = {
 		.name = "mxcpwrkey",
 	},
 	.probe = mxcpwrkey_probe,
 	.remove = mxcpwrkey_remove,
-	.suspend = mxc_pwrkey_suspend,
-	.resume = mxc_pwrkey_resume,
 };
+
 static int __init mxcpwrkey_init(void)
 {
-	platform_driver_register(&mxcpwrkey_driver);
-	return 0;
+	return platform_driver_register(&mxcpwrkey_driver);
 }
 
 static void __exit mxcpwrkey_exit(void)
 {
 	platform_driver_unregister(&mxcpwrkey_driver);
 }
+
 module_init(mxcpwrkey_init);
 module_exit(mxcpwrkey_exit);
 
diff --git a/include/linux/powerkey.h b/include/linux/powerkey.h
index b59cb69c31ed..f947a51e9595 100644
--- a/include/linux/powerkey.h
+++ b/include/linux/powerkey.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010 Freescale Semiconductor, Inc. All Rights Reserved.
+ * Copyright (C) 2010-2011 Freescale Semiconductor, Inc. All Rights Reserved.
  */
 /*
  * This program is free software; you can redistribute it and/or modify
@@ -19,12 +19,12 @@
 #ifndef POWER_KEY_H
 #define POWER_KEY_H
 
-typedef void (*key_press_call_back)(void *);
-typedef void (*register_key_press_call_back)(key_press_call_back, void *);
+typedef void (*pwrkey_callback)(void *);
 
 struct power_key_platform_data {
-	register_key_press_call_back register_key_press_handler;
-	void *param; /* param of the handler */
+	int key_value;
+	void (*register_pwrkey) (pwrkey_callback);
+	int (*get_key_status) (int);
 };
 
 #endif /* POWER_KEY_H */