zte's code,first commit
Change-Id: I9a04da59e459a9bc0d67f101f700d9d7dc8d681b
diff --git a/ap/os/linux/linux-3.4.x/drivers/input/keyboard/zx29-keypad-int.c b/ap/os/linux/linux-3.4.x/drivers/input/keyboard/zx29-keypad-int.c
new file mode 100644
index 0000000..42f6dcb
--- /dev/null
+++ b/ap/os/linux/linux-3.4.x/drivers/input/keyboard/zx29-keypad-int.c
@@ -0,0 +1,534 @@
+/***********************************************************************
+* Copyright (C) 2016, Sanechips Corporation.
+*
+* File Name: zx29-keypad-int.c
+* File Mark:
+* Description:
+* Others:
+* Version: v1.0
+* Author: qihongfang yuxiang lvfei ZhouTianbao
+* Date: 2017-2-28
+*
+* History 1:
+* Date:
+* Version:
+* Author:
+* Modification:
+**********************************************************************/
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/input.h>
+#include <linux/errno.h>
+#include <linux/io.h>
+#include <linux/pm_runtime.h>
+#include <linux/slab.h>
+#include <asm/irq.h>
+#include <linux/workqueue.h>
+
+#include <linux/gpio.h>
+#include <mach/gpio.h>
+#include <mach/pcu.h>
+#include <linux/irq.h>
+#include <linux/gpio_keys.h>
+#include <linux/delay.h>
+#include <linux/wakelock.h>
+
+#include <mach/irqs.h>
+#include <linux/mfd/zx234290.h>
+#include <linux/kthread.h>
+#include <linux/soc/zte/pm/drv_idle.h>
+
+/**********************************************************************/
+//#define ERROR_REGISTER_IRQ -100
+
+#define KEY_STATUS_UP 0
+#define KEY_STATUS_DOWN 1 /*input×ÓϵͳÖÐvalueΪ1ÊÇ°´ÏÂ*/
+
+#define KEY_DELAY_TIME 30 /* ms */
+#define KEY_NUM 30
+
+static struct input_dev *button_dev = NULL;
+
+typedef struct _zx234290_keypad
+{
+ struct zx234290 *zx234290;
+}zx234290_keypad_data;
+
+static zx234290_keypad_data zx234290_keypad;
+
+static spinlock_t kpd_lock;
+static volatile unsigned int key_active_count = 0;
+static struct wake_lock keypad_wake_lock;
+static struct semaphore kpd_sem;
+
+//#ifdef KPD_DEBUG
+struct key_info
+{
+ unsigned int index;
+ unsigned int code;
+ int value;
+};
+struct key_info key_info_tab[KEY_NUM]=
+{
+ {0},
+};
+static unsigned int key_info_idx = 0;
+static unsigned int key_info_counter = 0;
+//#endif
+
+static int zx29_kpd_queue(unsigned int code, int value)
+{
+ key_info_tab[key_info_idx].code = code;
+ key_info_tab[key_info_idx].value= value;
+ key_info_tab[key_info_idx].index = key_info_counter;
+ key_info_idx++;
+ key_info_counter++;
+ if(key_info_idx >= KEY_NUM)
+ {
+ key_info_idx = 0;
+ }
+ return 0;
+}
+
+static void zx29_key_set_active(void)
+{
+ spin_lock(&kpd_lock);
+
+ if(key_active_count == 0)
+ {
+ zx_cpuidle_set_busy(IDLE_FLAG_KPD);
+ wake_lock(&keypad_wake_lock);
+ }
+ key_active_count++;
+
+ spin_unlock(&kpd_lock);
+}
+
+static void zx29_key_set_idle(void)
+{
+ spin_lock(&kpd_lock);
+
+ key_active_count--;
+ if(key_active_count == 0)
+ {
+ wake_unlock(&keypad_wake_lock);
+ zx_cpuidle_set_free(IDLE_FLAG_KPD);
+ }
+
+ spin_unlock(&kpd_lock);
+}
+
+/*******************************************************************************
+* Function: zx29_kpd_get_keystate
+* Description: Test key state
+* Parameters:
+* Input:
+* Output:
+* Returns: 0: key down µÍµçƽ(press) 1: key up ¸ßµçƽ(release)
+* Others:
+* zx29_gpio_config(unsigned int gpio, unsigned int value) ÉèÖø´ÓÃ
+* value: 0:GPIO 1:FUNCTION
+********************************************************************************/
+
+static int zx29_kpd_get_keystate(int gpioNum,unsigned int gpio_sel_gpio,unsigned int gpio_sel_int)
+{
+ unsigned int gpio_state = GPIO_HIGH;
+ int irq;
+
+ zx29_gpio_config(gpioNum, gpio_sel_gpio);
+ irq = gpio_to_irq(gpioNum);
+ //pcu_clr_irq_pending(irq);
+ zx29_gpio_set_direction(gpioNum, GPIO_IN);
+ msleep(KEY_DELAY_TIME);
+ gpio_state = gpio_get_value(gpioNum);
+ /* msleep(30); */
+ zx29_gpio_config(gpioNum, gpio_sel_int);/******qhf***int****/
+ //pcu_clr_irq_pending(irq);
+
+ //printk(KERN_INFO "gpio state=%d.\n",gpio_state);
+
+ return gpio_state; /* 0: µÍµçƽ(press), 1:¸ßµçƽ(release) */
+
+}
+
+static irqreturn_t zx29_kpd_pwron_inform(int irq, void *dev_id)
+{
+ up(&kpd_sem);
+ return IRQ_HANDLED;
+}
+
+/*******************************************************************************
+* Function: zx29_kpd_pwron_thread
+* Description:
+* Parameters:
+* Input:
+* Output:
+* Returns:
+* Others:
+********************************************************************************/
+#define USE_EXT_DEV
+#ifdef USE_EXT_DEV
+//extern struct input_dev *button5x6_dev;
+extern struct input_dev *input_dev_table[32];
+#endif
+int zx29_kpd_pwron_thread(void *dev_id)
+{
+ struct gpio_keys_button *buttons = (struct gpio_keys_button *)dev_id;
+ int ret = 0;
+ unsigned char status = 0;
+
+ struct sched_param param;
+ param.sched_priority = 33;
+ sched_setscheduler(current, SCHED_FIFO, ¶m);
+
+ while (!kthread_should_stop()) {
+ down(&kpd_sem);
+
+ zx29_key_set_active();
+
+ msleep(10);
+ ret = zx234290_i2c_read_simple(ZX234290_REG_ADDR_STSA, &status);
+ if(ret)
+ {
+ printk(KERN_INFO "kpd read reg return=%d.\n", ret);
+ }
+ else if((status >> ZX234290_STATUSA_POWERON_LSH) & 0x1)
+ {
+#ifdef USE_EXT_DEV
+ if (input_dev_table[1]) {
+ set_bit(buttons->code, input_dev_table[1]->keybit);
+ input_report_key(input_dev_table[1], buttons->code, KEY_STATUS_DOWN);
+ input_sync(input_dev_table[1]);
+ }
+#endif
+ input_report_key(button_dev, buttons->code, KEY_STATUS_DOWN);
+ input_sync(button_dev);
+
+ zx29_kpd_queue(buttons->code, KEY_STATUS_DOWN);
+ printk(KERN_INFO "kpd down code=%d .\n",buttons->code);
+
+ while(1)
+ {
+ msleep(60);
+
+ ret = zx234290_i2c_read_simple(ZX234290_REG_ADDR_STSA, &status);
+ if(ret)
+ {
+ printk(KERN_INFO "kpd read reg return=%d.\n", ret);
+ break;
+ }
+ //printk(KERN_INFO "kpd reg status=%d.\n", status);
+
+ if(((status>>ZX234290_STATUSA_POWERON_LSH)&0x1) == 0x0)
+ {
+#ifdef USE_EXT_DEV
+ if (input_dev_table[1]) {
+ input_report_key(input_dev_table[1], buttons->code, KEY_STATUS_UP);
+ input_sync(input_dev_table[1]);
+ }
+#endif
+ input_report_key(button_dev, buttons->code, KEY_STATUS_UP);
+ input_sync(button_dev);
+
+ zx29_kpd_queue(buttons->code, KEY_STATUS_UP);
+ printk(KERN_INFO "kpd up code=%d.\n",buttons->code);
+ break;
+ }
+ }
+ }
+ else
+ {
+ printk(KERN_INFO "kpd power key noise.\n");
+ }
+
+ zx29_key_set_idle();
+ }
+
+ return 0;
+}
+
+static irqreturn_t zx29_kpd_irq_thread(int irq, void *dev_id)
+{
+ struct gpio_keys_button *buttons = (struct gpio_keys_button *)dev_id;
+ int gpio_val = 0;
+ int state;
+
+ zx29_key_set_active();
+
+ //printk(KERN_INFO "handle irq=%d.\n",irq);
+ gpio_val = zx29_kpd_get_keystate(buttons->gpio,buttons->gpio_sel_gpio,buttons->gpio_sel_int);
+ state = !!gpio_val ^ !!buttons->active_low;
+
+ zx29_gpio_set_inttype(buttons->gpio,
+ (gpio_val ? IRQ_TYPE_LEVEL_LOW : IRQ_TYPE_LEVEL_HIGH));
+ //pcu_int_clear(irq);
+ //pcu_clr_irq_pending(irq);
+
+#ifdef USE_EXT_DEV
+ if (input_dev_table[1]) {
+ set_bit(buttons->code, input_dev_table[1]->keybit);
+ input_report_key(input_dev_table[1], buttons->code, state);
+ input_sync(input_dev_table[1]);
+ }
+#endif
+
+ input_report_key(button_dev, buttons->code, state); //Éϱ¨key ¼üÖµ
+ //key_info_tab[key_num].lastStatus = state;
+ input_sync(button_dev);
+ zx29_kpd_queue(buttons->code, state);
+ printk(KERN_INFO "kpd %s code=%d, irq=%d.\n",
+ (state ? "down" : "up"),
+ buttons->code,
+ irq);
+
+ //enable_irq(irq); //´ò¿ªÖжÏ
+
+ zx29_key_set_idle();
+ return IRQ_HANDLED;
+}
+
+/*******************************************************************************
+* Function: zx29_kpd_irq_handler
+* Description: clear irq , wake thread irq
+* Parameters:
+* Input:
+* Output:
+********************************************************************************/
+static irqreturn_t zx29_kpd_irq_handler(int irq, void *dev_id)
+{
+ //disable_irq_nosync(irq);
+ //pcu_int_clear(irq);
+ pcu_clr_irq_pending(irq);
+
+ //printk(KERN_INFO "kpd handler irq=%d.\n", irq);
+
+ return IRQ_WAKE_THREAD;
+}
+
+/*******************************************************************************
+* Function: zx29_kpd_request_irqs
+* Description:
+* Parameters:
+* Input:
+* Output:
+********************************************************************************/
+static int zx29_kpd_request_irqs(struct gpio_keys_platform_data *pdata )
+{
+ int ret = -1;
+ struct gpio_keys_button *buttons = pdata->buttons;
+ int keypad_num = pdata->nbuttons;
+ int irq_num = 0;
+
+ for(keypad_num = 0; keypad_num < pdata->nbuttons; keypad_num++)
+ {
+ if(buttons[keypad_num].use_pmu_pwron == 0)
+ {
+ ret = gpio_request(buttons[keypad_num].gpio, buttons[keypad_num].desc);
+ if (ret < 0) {
+ printk(KERN_ERR "kpd request gpio%d failed.\n", buttons[keypad_num].gpio);
+ break;
+ }
+ zx29_gpio_config(buttons[keypad_num].gpio,buttons[keypad_num].gpio_sel_int);
+ /* some switch may be active before booting. use level irq to avoid lack of falling edge. */
+ zx29_gpio_set_inttype(buttons[keypad_num].gpio,
+ (buttons[keypad_num].active_low ? IRQ_TYPE_LEVEL_LOW : IRQ_TYPE_LEVEL_HIGH));
+ zx29_gpio_pd_pu_set(buttons[keypad_num].gpio, 0);
+
+ msleep(1); /* wait for stable input */
+
+ irq_num = gpio_to_irq(buttons[keypad_num].gpio);
+ /*
+ if(irq_num > 0){
+ printk(KERN_INFO "zx29_kpd_request_irqs error irq_num=%d.\n",irq_num);
+ }
+ */
+
+ /* pcu_clr_irq_pending(irq_num); */
+ ret = request_threaded_irq(irq_num, NULL, zx29_kpd_irq_thread, IRQF_ONESHOT/*IRQF_TRIGGER_HIGH | IRQF_NO_THREAD*/,
+ buttons[keypad_num].desc, &buttons[keypad_num]);
+ irq_set_irq_wake(irq_num, 1);
+ }
+ else
+ {
+ sema_init(&kpd_sem, 0);
+ kthread_run(zx29_kpd_pwron_thread, &buttons[keypad_num], "kpd_pwron_thread");
+
+ irq_num = ENT_ZX234290_IRQ_BASE + ZX234290_INT_PWRON;
+ ret = request_threaded_irq(irq_num, NULL, zx29_kpd_pwron_inform, 0,
+ buttons[keypad_num].desc, &buttons[keypad_num]);
+ }
+ if(ret)
+ {
+ return ret;
+ }
+ printk(KERN_INFO "kpd request_irq irq_num=%d.\n", irq_num);
+ }
+
+ return ret;
+}
+
+/*******************************************************************************
+* Function: zx29_kpd_probe
+* Description:
+* Parameters:
+* Input:
+* Output:
+* Returns:
+********************************************************************************/
+static int zx29_kpd_probe(struct platform_device *pdev)
+{
+ int error = -1;
+ static int i = 0;
+ struct input_handle *handle;
+ struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
+ struct gpio_keys_button *buttons = pdata->buttons;
+ zx234290_keypad.zx234290 = dev_get_drvdata(pdev->dev.parent);
+
+ button_dev = input_allocate_device();
+ if(!button_dev)
+ {
+ printk("allocate_device error.\n");
+ return error;
+ }
+ button_dev->name = pdev->name;
+ button_dev->evbit[0] = BIT_MASK(EV_KEY)|BIT_MASK(EV_REP);
+
+ for(i=0; i < pdata->nbuttons; i++)
+ {
+ set_bit(buttons[i].code,button_dev->keybit);
+ }
+
+ error = input_register_device(button_dev);
+ if(error)
+ {
+ printk("register device error\n");
+ goto err_free_dev;
+ }
+ handle = container_of(button_dev->h_list.next, struct input_handle, d_node);
+ /* printk(KERN_INFO "%s registered evdev %s/%p.\n", __FUNCTION__, handle->name, handle->private); */
+
+ platform_set_drvdata(pdev, button_dev);
+
+ spin_lock_init(&kpd_lock);
+ wake_lock_init(&keypad_wake_lock, WAKE_LOCK_SUSPEND, "keypad");
+ zx29_kpd_request_irqs(pdata);
+
+ return 0;
+
+err_free_dev:
+ input_free_device(button_dev);
+ return error;
+}
+
+
+/*******************************************************************************
+* Function: zx29_kpd_remove
+* Description:
+* Parameters:
+* Input:
+* Output:
+* Returns:
+********************************************************************************/
+static int zx29_kpd_remove(struct platform_device *pdev)
+{
+ struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
+ struct gpio_keys_button *buttons = pdata->buttons;
+ static struct input_dev *button_dev = NULL;
+ int i = 0;
+ int irq_num;
+
+ for(i = 0; i < pdata->nbuttons; i++){
+ irq_num = gpio_to_irq(buttons[i].gpio);
+ if(irq_num < 0){
+ printk(KERN_INFO "%s error keypad_num=%d.\n", __FUNCTION__, i);
+ }
+
+ free_irq(irq_num,NULL);
+ gpio_free(buttons[i].gpio);
+ }
+ button_dev = (struct input_dev *)platform_get_drvdata(pdev);
+ input_free_device(button_dev);
+ button_dev = NULL;
+
+ zx234290_keypad.zx234290 = NULL;
+
+ wake_lock_destroy(&keypad_wake_lock);
+
+ return 0;
+}
+
+static int zx29_kpd_resume(struct platform_device *pdev)
+{
+ struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
+ struct gpio_keys_button *buttons = pdata->buttons;
+ int i = 0;
+ int irq_num = 0;
+
+ for(i = 0; i < pdata->nbuttons; i++){
+
+ irq_num = gpio_to_irq(buttons[i].gpio);
+ if(irq_num < 0){
+ printk(KERN_INFO "%s error keypad_num=%d.\n", __FUNCTION__, i);
+ }
+ if(irq_num != 0){
+ enable_irq(irq_num);
+ }
+
+ }
+ printk(KERN_INFO "%s\n", __FUNCTION__);
+ return 0;
+}
+
+static int zx29_kpd_suspend(struct platform_device *pdev, pm_message_t state)
+{
+ struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
+ struct gpio_keys_button *buttons = pdata->buttons;
+ int i = 0;
+ int irq_num = 0;
+
+ for(i = 0; i < pdata->nbuttons; i++){
+ irq_num = gpio_to_irq(buttons[i].gpio);
+ if(irq_num < 0){
+ printk(KERN_INFO "%s error keypad_num=%d.\n", __FUNCTION__, i);
+ }
+ if(irq_num != 0){
+ disable_irq(irq_num);
+ }
+
+ }
+ printk(KERN_INFO "%s\n", __FUNCTION__);
+ return 0;
+}
+
+static struct platform_driver zx29_kpd_driver =
+{
+ .probe = zx29_kpd_probe,
+ .remove = zx29_kpd_remove,
+ .driver =
+ {
+ .name = "zx29_keypad_int",
+ .owner = THIS_MODULE,
+ },
+ //.resume = zx29_kpd_resume,
+ //.suspend = zx29_kpd_suspend,
+};
+
+static int __init zx29_kpd_init(void)
+{
+ return platform_driver_register(&zx29_kpd_driver);
+}
+
+static void __exit zx29_kpd_exit(void)
+{
+ platform_driver_unregister(&zx29_kpd_driver);
+}
+
+module_init(zx29_kpd_init);
+module_exit(zx29_kpd_exit);
+
+MODULE_AUTHOR("Sanechips");
+MODULE_DESCRIPTION("Sanechips Keypad Driver");
+MODULE_LICENSE("GPL");
+