drivers/input/misc/ambarella_input_adc.c - nest-cam/v350/linux - Git at Google

 /*
  * drivers/input/misc/ambarella_input_adc.c
  *
  * Author: Qiao Wang <qwang@ambarella.com>
  * Copyright (C) 2004-2009, Ambarella, Inc.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  *
  */
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/platform_device.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/input.h>
 #include <linux/slab.h>

 #include <asm/irq.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
 #include <asm/mach-types.h>

 #include <mach/hardware.h>
 #include <plat/adc.h>

 #include <plat/ambinput.h>

 /* ========================================================================= */
 #define CONFIG_AMBARELLA_ADC_WAIT_COUNTER_LIMIT	(100000)
 #define	AMBA_ADC_NO_KEY_PRESSED			(0)

 /* ========================================================================= */
 extern struct ambarella_input_board_info *ambarella_input_get_board_info(void);

 /* ========================================================================= */
 int ambarella_setup_adc_key(struct ambarella_adc_info *pinfo)
 {
 	int				retval = 0;
 	int				i;

 	pinfo->adc_channel_num = pinfo->pcontroller_info->get_channel_num();
 	if (pinfo->adc_channel_num == 0) {
 		dev_err(&pinfo->dev->dev, "Wrong adc_channel_num\n");
 		retval = -EINVAL;
 		goto ambarella_setup_adc_key_exit;
 	}

 	pinfo->adc_channel_info = kzalloc(sizeof(struct ambarella_adc_channel_info) *
 		pinfo->adc_channel_num, GFP_KERNEL);
 	if (!pinfo->adc_channel_info) {
 		dev_err(&pinfo->dev->dev,
 			"Fail to malloc adc_channel_info info\n");
 		retval = -ENOMEM;
 		goto ambarella_setup_adc_key_exit;
 	}

 	pinfo->adc_key_pressed = kzalloc(sizeof(u32) * pinfo->adc_channel_num, GFP_KERNEL);
 	if (!pinfo->adc_key_pressed) {
 		dev_err(&pinfo->dev->dev, "Failed to allocate adc_key_pressed!\n");
 		retval = -ENOMEM;
 		goto ambarella_setup_adc_key_free_adc_channel_info;
 	}

 	pinfo->adc_data = kzalloc(sizeof(u32) * pinfo->adc_channel_num, GFP_KERNEL);
 	if (!pinfo->adc_data) {
 		dev_err(&pinfo->dev->dev, "Failed to allocate adc_data!\n");
 		retval = -ENOMEM;
 		goto ambarella_setup_adc_key_free_adc_key_pressed;
 	}

 	for (i = 0; i < AMBINPUT_TABLE_SIZE; i++) {
 		if (pinfo->pkeymap[i].type == AMBINPUT_END)
 			break;

 		if ((pinfo->pkeymap[i].type & AMBINPUT_SOURCE_MASK) != AMBINPUT_SOURCE_ADC)
 			continue;

 		if (pinfo->pkeymap[i].adc_key.chan < pinfo->adc_channel_num) {
 			pinfo->adc_channel_info[pinfo->pkeymap[i].adc_key.chan].adc_channel_used = 1;
 		} else {
 			dev_err(&pinfo->dev->dev, "The adc adc_channel_info [%d] is not exist\n",
 				pinfo->pkeymap[i].adc_key.chan);
 			continue;
 		}

 		if (pinfo->pkeymap[i].adc_key.key_code == KEY_RESERVED) {
 			if (pinfo->pkeymap[i].adc_key.irq_trig) {
 				pinfo->adc_channel_info[pinfo->pkeymap[i].adc_key.chan].adc_high_trig
 					= pinfo->pkeymap[i].adc_key.high_level;
 				pinfo->adc_channel_info[pinfo->pkeymap[i].adc_key.chan].adc_low_trig
 					= 0;
 			} else {
 				pinfo->adc_channel_info[pinfo->pkeymap[i].adc_key.chan].adc_low_trig
 					= pinfo->pkeymap[i].adc_key.low_level;
 				pinfo->adc_channel_info[pinfo->pkeymap[i].adc_key.chan].adc_high_trig
 					= 0;
 			}
 		}
 	}

 	if (pinfo->support_irq) {
 		for (i = 0; i < pinfo->adc_channel_num; i++) {
 			if (pinfo->adc_channel_info[i].adc_channel_used) {
 				pinfo->pcontroller_info->set_irq_threshold(i,
 					pinfo->adc_channel_info[i].adc_high_trig,
 					pinfo->adc_channel_info[i].adc_low_trig);
 				dev_dbg(&pinfo->dev->dev, "adc_channel_info %d is used\n", i);
 				dev_dbg(&pinfo->dev->dev, "adc_high_trig [%d], adc_low_trig [%d]\n",
 					pinfo->adc_channel_info[i].adc_high_trig,
 					pinfo->adc_channel_info[i].adc_low_trig);

 				/* here, we suppose that all the adc_channel_info use the same trigger */
 				pinfo->irqflags = (!!pinfo->adc_channel_info[i].adc_high_trig) * IRQF_TRIGGER_HIGH
 					+ (!!pinfo->adc_channel_info[i].adc_low_trig) * IRQF_TRIGGER_LOW;
 			}
 		}
 	}

 	goto ambarella_setup_adc_key_exit;

 ambarella_setup_adc_key_free_adc_key_pressed:
 	kfree(pinfo->adc_key_pressed);
 	pinfo->adc_key_pressed = NULL;

 ambarella_setup_adc_key_free_adc_channel_info:
 	kfree(pinfo->adc_channel_info);
 	pinfo->adc_channel_info = NULL;

 ambarella_setup_adc_key_exit:
 	return retval;
 }

 void ambarella_scan_adc(struct work_struct *work)
 {
 	int				i;
 	struct ambarella_adc_info	*pinfo;
 	int				adc_index;
 	u32				adc_size;

 	pinfo = container_of(work, struct ambarella_adc_info, detect_adc.work);

 	if (unlikely(pinfo->pkeymap == NULL)) {
 		dev_err(&pinfo->dev->dev, "pinfo->pkeymap is null");
 		return;
 	}

 	adc_size = pinfo->adc_channel_num;
 	pinfo->pcontroller_info->read_channels(pinfo->adc_data, &adc_size);

 	for (i = 0; i < AMBINPUT_TABLE_SIZE; i++) {
 		if (pinfo->pkeymap[i].type == AMBINPUT_END)
 			break;

 		if ((pinfo->pkeymap[i].type & AMBINPUT_SOURCE_MASK) != AMBINPUT_SOURCE_ADC)
 			continue;

 		adc_index = pinfo->pkeymap[i].adc_key.chan;
 		if (adc_index >= adc_size)
 			continue;

 		if ((pinfo->pkeymap[i].adc_key.low_level > pinfo->adc_data[adc_index]) ||
 			(pinfo->pkeymap[i].adc_key.high_level < pinfo->adc_data[adc_index]))
 			continue;

 		/* scan the key and stop when the first key action is detected. If you want to
 		   monitor multi-key in different ADC channels, remove "break" */
 		if (pinfo->pkeymap[i].type == AMBINPUT_ADC_KEY) {
 			if (pinfo->adc_key_pressed[adc_index] != AMBA_ADC_NO_KEY_PRESSED
 				&& pinfo->pkeymap[i].adc_key.key_code == KEY_RESERVED) {
 				input_report_key(pinfo->dev,
 					pinfo->adc_key_pressed[adc_index], 0);//key relase
 				dev_dbg(&pinfo->dev->dev, "key[%d:%d] released %d\n", adc_index,
 					pinfo->adc_key_pressed[adc_index],
 					pinfo->adc_data[adc_index]);
 				pinfo->adc_key_pressed[adc_index] = AMBA_ADC_NO_KEY_PRESSED;
 				if (pinfo->support_irq) {
 					pinfo->work_mode = AMBA_ADC_IRQ_MODE;
 				}
 				break;
 			} else if (pinfo->adc_key_pressed[adc_index] == AMBA_ADC_NO_KEY_PRESSED
 				&& pinfo->pkeymap[i].adc_key.key_code != KEY_RESERVED) {
 				input_report_key(pinfo->dev,
 					pinfo->pkeymap[i].adc_key.key_code, 1);// key press
 				pinfo->adc_key_pressed[adc_index] =
 					pinfo->pkeymap[i].adc_key.key_code;
 				if (pinfo->support_irq) {
 					pinfo->work_mode = AMBA_ADC_POL_MODE;
 				}
 				dev_dbg(&pinfo->dev->dev, "key[%d:%d] pressed %d\n", adc_index,
 					pinfo->adc_key_pressed[adc_index],
 					pinfo->adc_data[adc_index]);
 				break;
 			}
 		}

 		if (pinfo->pkeymap[i].type == AMBINPUT_ADC_REL) {
 			if (pinfo->pkeymap[i].adc_rel.key_code == REL_X) {
 				input_report_rel(pinfo->dev,
 					REL_X,
 					pinfo->pkeymap[i].adc_rel.rel_step);
 				input_report_rel(pinfo->dev,
 					REL_Y, 0);
 				input_sync(pinfo->dev);
 				dev_dbg(&pinfo->dev->dev, "report REL_X %d & %d\n",
 					pinfo->pkeymap[i].adc_rel.rel_step,
 					pinfo->adc_data[adc_index]);
 				break;
 			} else if (pinfo->pkeymap[i].adc_rel.key_code == REL_Y) {
 				input_report_rel(pinfo->dev,
 					REL_X, 0);
 				input_report_rel(pinfo->dev,
 					REL_Y,
 					pinfo->pkeymap[i].adc_rel.rel_step);
 				input_sync(pinfo->dev);
 				dev_dbg(&pinfo->dev->dev, "report REL_Y %d & %d\n",
 					pinfo->pkeymap[i].adc_rel.rel_step,
 					pinfo->adc_data[adc_index]);
 				break;
 			}
 		}

 		if (pinfo->pkeymap[i].type == AMBINPUT_ADC_REL) {
 			input_report_abs(pinfo->dev,
 				ABS_X, pinfo->pkeymap[i].adc_abs.abs_x);
 			input_report_abs(pinfo->dev,
 				ABS_Y, pinfo->pkeymap[i].adc_abs.abs_y);
 			input_sync(pinfo->dev);
 			dev_dbg(&pinfo->dev->dev, "report ABS %d:%d & %d\n",
 				pinfo->pkeymap[i].adc_abs.abs_x,
 				pinfo->pkeymap[i].adc_abs.abs_y,
 				pinfo->adc_data[adc_index]);
 			break;
 		}
 	}

 	if (pinfo->work_mode == AMBA_ADC_POL_MODE)
 		queue_delayed_work(pinfo->workqueue, &pinfo->detect_adc,
 			pinfo->pcontroller_info->scan_delay);
 	else
 		enable_irq(pinfo->irq);
 }

 static irqreturn_t ambarella_input_adc_irq(int irq, void *devid)
 {
 	struct ambarella_adc_info	*pinfo;

 	pinfo = (struct ambarella_adc_info *)devid;

 	dev_dbg(&pinfo->dev->dev, "%s:%d\n", __func__, __LINE__);

 	disable_irq_nosync(pinfo->irq);
 	queue_delayed_work(pinfo->workqueue, &pinfo->detect_adc, 0);

 	return IRQ_HANDLED;
 }

 static int __devinit ambarella_input_adc_probe(struct platform_device *pdev)
 {
 	int					retval = 0;
 	struct ambarella_adc_info		*pinfo;
 	int					irq;
 	struct resource 			*mem;
 	struct resource 			*ioarea;
 	struct ambarella_input_board_info	*pboard_info;

 	pboard_info = ambarella_input_get_board_info();
 	if (pboard_info == NULL){
 		dev_err(&pdev->dev, "pboard_info is NULL!\n");
 		retval = -ENOMEM;
 		goto adc_errorCode_na;
 	}

 	pinfo = kmalloc(sizeof(struct ambarella_adc_info), GFP_KERNEL);
 	if (!pinfo) {
 		dev_err(&pdev->dev, "Failed to allocate pinfo!\n");
 		retval = -ENOMEM;
 		goto adc_errorCode_na;
 	}

 	pinfo->pcontroller_info =
 		(struct ambarella_adc_controller *)pdev->dev.platform_data;
 	if ((pinfo->pcontroller_info == NULL) ||
 		(pinfo->pcontroller_info->read_channels == NULL) ||
 		(pinfo->pcontroller_info->is_irq_supported == NULL) ||
 		(pinfo->pcontroller_info->set_irq_threshold == NULL) ||
 		(pinfo->pcontroller_info->reset == NULL) ||
 		(pinfo->pcontroller_info->stop == NULL) ||
 		(pinfo->pcontroller_info->open == NULL) ||
 		(pinfo->pcontroller_info->close == NULL) ||
 		(pinfo->pcontroller_info->get_channel_num == NULL) ) {
 		dev_err(&pdev->dev, "Platform data is NULL!\n");
 		retval = -ENXIO;
 		goto adc_errorCode_pinfo;
 	}

 	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	if (mem == NULL) {
 		dev_err(&pdev->dev, "Get mem resource failed!\n");
 		retval = -ENXIO;
 		goto adc_errorCode_pinfo;
 	}
 	ioarea = request_mem_region(mem->start,
 			(mem->end - mem->start) + 1, pdev->name);
 	if (ioarea == NULL) {
 		dev_err(&pdev->dev, "Request ioarea failed!\n");
 		retval = -EBUSY;
 		goto adc_errorCode_pinfo;
 	}

 	pinfo->support_irq = pinfo->pcontroller_info->is_irq_supported();
 	if (pinfo->support_irq) {
 		irq = platform_get_irq_byname(pdev, "adc-level-irq");
 		if (irq == -ENXIO) {
 			dev_err(&pdev->dev, "Get irq resource failed!\n");
 			retval = -ENXIO;
 			goto adc_errorCode_mem;
 		} else {
 			pinfo->irq = irq;
 		}
 	}

 	pinfo->regbase = (unsigned char __iomem *)mem->start;
 	pinfo->id = pdev->id;
 	pinfo->mem = mem;
 	pinfo->dev = pboard_info->pinput_dev;
 	pinfo->pkeymap = pboard_info->pkeymap;

 	pinfo->pcontroller_info->open();

 	retval = ambarella_setup_adc_key(pinfo);
 	if (retval) {
 		dev_err(&pdev->dev, "ambarella_setup_adc_key failed!\n");
 		goto adc_errorCode_mem;
 	}

 	pinfo->workqueue = create_singlethread_workqueue("amba_adc");
 	if (!pinfo->workqueue) {
 		retval = -ENOMEM;
 		dev_err(&pdev->dev, "Create ADC workqueue failed!\n");
 		goto adc_errorCode_setup_adc_key;
 	}
 	INIT_DELAYED_WORK(&pinfo->detect_adc, ambarella_scan_adc);

 	if (pinfo->support_irq) {// irq mode
 		pinfo->work_mode = AMBA_ADC_IRQ_MODE;
 		retval = request_irq(pinfo->irq, ambarella_input_adc_irq,
 			pinfo->irqflags, dev_name(&pdev->dev), pinfo);
 		if (retval) {
 			dev_err(&pdev->dev, "Request IRQ failed!\n");
 			goto adc_errorCode_free_queue;
 		}
 	} else {//polling mode
 		pinfo->work_mode = AMBA_ADC_POL_MODE;
 		queue_delayed_work(pinfo->workqueue, &pinfo->detect_adc,
 			pinfo->pcontroller_info->scan_delay);
 	}

 	platform_set_drvdata(pdev, pinfo);
 	dev_notice(&pdev->dev, "ADC Host Controller [%s mode] probed!\n",
 		(pinfo->support_irq) ? "interrupt" : "polling");

 	goto adc_errorCode_na;

 adc_errorCode_free_queue:
 	destroy_workqueue(pinfo->workqueue);
 adc_errorCode_setup_adc_key:
 	kfree(pinfo->adc_key_pressed);
 	pinfo->adc_key_pressed = NULL;
 	kfree(pinfo->adc_channel_info);
 	pinfo->adc_channel_info = NULL;
 adc_errorCode_mem:
 	release_mem_region(pinfo->mem->start, (pinfo->mem->end - pinfo->mem->start) + 1);
 adc_errorCode_pinfo:
 	kfree(pinfo);
 adc_errorCode_na:
 	return retval;
 }

 static int __devexit ambarella_input_adc_remove(struct platform_device *pdev)
 {
 	struct ambarella_adc_info	*pinfo;
 	int				retval = 0;

 	pinfo = platform_get_drvdata(pdev);

 	if (pinfo) {
 		if (pinfo->support_irq)
 			free_irq(pinfo->irq, pinfo);
 		pinfo->pcontroller_info->close();
 		platform_set_drvdata(pdev, NULL);
 		cancel_delayed_work(&pinfo->detect_adc);
 		flush_workqueue(pinfo->workqueue);
 		destroy_workqueue(pinfo->workqueue);
 		release_mem_region(pinfo->mem->start, (pinfo->mem->end - pinfo->mem->start) + 1);
 		kfree(pinfo->adc_data);
 		kfree(pinfo->adc_key_pressed);
 		kfree(pinfo->adc_channel_info);
 		kfree(pinfo);
 	}

 	dev_notice(&pdev->dev, "Remove Ambarella Media Processor ADC Host Controller.\n");

 	return retval;
 }

 #if (defined CONFIG_PM)
 static int ambarella_input_adc_suspend(struct platform_device *pdev,
 	pm_message_t state)
 {
 	int					retval = 0;
 	struct ambarella_adc_info		*pinfo;

 	pinfo = platform_get_drvdata(pdev);

 	if (pinfo->support_irq)
 		disable_irq(pinfo->irq);

 	dev_dbg(&pdev->dev, "%s exit with %d @ %d\n",
 		__func__, retval, state.event);
 	return retval;
 }

 static int ambarella_input_adc_resume(struct platform_device *pdev)
 {
 	int					retval = 0;
 	struct ambarella_adc_info		*pinfo;

 	pinfo = platform_get_drvdata(pdev);

 	if (pinfo->support_irq)
 		enable_irq(pinfo->irq);

 	dev_dbg(&pdev->dev, "%s exit with %d\n", __func__, retval);

 	return retval;
 }
 #endif

 static struct platform_driver ambarella_adc_driver = {
 	.probe		= ambarella_input_adc_probe,
 	.remove		= __devexit_p(ambarella_input_adc_remove),
 #ifdef CONFIG_PM
 	.suspend	= ambarella_input_adc_suspend,
 	.resume		= ambarella_input_adc_resume,
 #endif
 	.driver		= {
 		.name	= "ambarella-adc",
 		.owner	= THIS_MODULE,
 	},
 };

 int platform_driver_register_adc(void)
 {
 	return platform_driver_register(&ambarella_adc_driver);
 }
 void platform_driver_unregister_adc(void)
 {
 	platform_driver_unregister(&ambarella_adc_driver);
 }
	/*
	* drivers/input/misc/ambarella_input_adc.c
	*
	* Author: Qiao Wang <qwang@ambarella.com>
	* Copyright (C) 2004-2009, Ambarella, Inc.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*
	*/
	#include <linux/kernel.h>
	#include <linux/module.h>
	#include <linux/moduleparam.h>
	#include <linux/platform_device.h>
	#include <linux/interrupt.h>
	#include <linux/delay.h>
	#include <linux/input.h>
	#include <linux/slab.h>

	#include <asm/irq.h>
	#include <asm/io.h>
	#include <asm/uaccess.h>
	#include <asm/mach-types.h>

	#include <mach/hardware.h>
	#include <plat/adc.h>

	#include <plat/ambinput.h>

	/* ========================================================================= */
	#define CONFIG_AMBARELLA_ADC_WAIT_COUNTER_LIMIT (100000)
	#define AMBA_ADC_NO_KEY_PRESSED (0)

	/* ========================================================================= */
	extern struct ambarella_input_board_info *ambarella_input_get_board_info(void);

	/* ========================================================================= */
	int ambarella_setup_adc_key(struct ambarella_adc_info *pinfo)
	{
	int retval = 0;
	int i;

	pinfo->adc_channel_num = pinfo->pcontroller_info->get_channel_num();
	if (pinfo->adc_channel_num == 0) {
	dev_err(&pinfo->dev->dev, "Wrong adc_channel_num\n");
	retval = -EINVAL;
	goto ambarella_setup_adc_key_exit;
	}

	pinfo->adc_channel_info = kzalloc(sizeof(struct ambarella_adc_channel_info) *
	pinfo->adc_channel_num, GFP_KERNEL);
	if (!pinfo->adc_channel_info) {
	dev_err(&pinfo->dev->dev,
	"Fail to malloc adc_channel_info info\n");
	retval = -ENOMEM;
	goto ambarella_setup_adc_key_exit;
	}

	pinfo->adc_key_pressed = kzalloc(sizeof(u32) * pinfo->adc_channel_num, GFP_KERNEL);
	if (!pinfo->adc_key_pressed) {
	dev_err(&pinfo->dev->dev, "Failed to allocate adc_key_pressed!\n");
	retval = -ENOMEM;
	goto ambarella_setup_adc_key_free_adc_channel_info;
	}

	pinfo->adc_data = kzalloc(sizeof(u32) * pinfo->adc_channel_num, GFP_KERNEL);
	if (!pinfo->adc_data) {
	dev_err(&pinfo->dev->dev, "Failed to allocate adc_data!\n");
	retval = -ENOMEM;
	goto ambarella_setup_adc_key_free_adc_key_pressed;
	}

	for (i = 0; i < AMBINPUT_TABLE_SIZE; i++) {
	if (pinfo->pkeymap[i].type == AMBINPUT_END)
	break;

	if ((pinfo->pkeymap[i].type & AMBINPUT_SOURCE_MASK) != AMBINPUT_SOURCE_ADC)
	continue;

	if (pinfo->pkeymap[i].adc_key.chan < pinfo->adc_channel_num) {
	pinfo->adc_channel_info[pinfo->pkeymap[i].adc_key.chan].adc_channel_used = 1;
	} else {
	dev_err(&pinfo->dev->dev, "The adc adc_channel_info [%d] is not exist\n",
	pinfo->pkeymap[i].adc_key.chan);
	continue;
	}

	if (pinfo->pkeymap[i].adc_key.key_code == KEY_RESERVED) {
	if (pinfo->pkeymap[i].adc_key.irq_trig) {
	pinfo->adc_channel_info[pinfo->pkeymap[i].adc_key.chan].adc_high_trig
	= pinfo->pkeymap[i].adc_key.high_level;
	pinfo->adc_channel_info[pinfo->pkeymap[i].adc_key.chan].adc_low_trig
	= 0;
	} else {
	pinfo->adc_channel_info[pinfo->pkeymap[i].adc_key.chan].adc_low_trig
	= pinfo->pkeymap[i].adc_key.low_level;
	pinfo->adc_channel_info[pinfo->pkeymap[i].adc_key.chan].adc_high_trig
	= 0;
	}
	}
	}

	if (pinfo->support_irq) {
	for (i = 0; i < pinfo->adc_channel_num; i++) {
	if (pinfo->adc_channel_info[i].adc_channel_used) {
	pinfo->pcontroller_info->set_irq_threshold(i,
	pinfo->adc_channel_info[i].adc_high_trig,
	pinfo->adc_channel_info[i].adc_low_trig);
	dev_dbg(&pinfo->dev->dev, "adc_channel_info %d is used\n", i);
	dev_dbg(&pinfo->dev->dev, "adc_high_trig [%d], adc_low_trig [%d]\n",
	pinfo->adc_channel_info[i].adc_high_trig,
	pinfo->adc_channel_info[i].adc_low_trig);

	/* here, we suppose that all the adc_channel_info use the same trigger */
	pinfo->irqflags = (!!pinfo->adc_channel_info[i].adc_high_trig) * IRQF_TRIGGER_HIGH
	+ (!!pinfo->adc_channel_info[i].adc_low_trig) * IRQF_TRIGGER_LOW;
	}
	}
	}

	goto ambarella_setup_adc_key_exit;

	ambarella_setup_adc_key_free_adc_key_pressed:
	kfree(pinfo->adc_key_pressed);
	pinfo->adc_key_pressed = NULL;

	ambarella_setup_adc_key_free_adc_channel_info:
	kfree(pinfo->adc_channel_info);
	pinfo->adc_channel_info = NULL;

	ambarella_setup_adc_key_exit:
	return retval;
	}

	void ambarella_scan_adc(struct work_struct *work)
	{
	int i;
	struct ambarella_adc_info *pinfo;
	int adc_index;
	u32 adc_size;

	pinfo = container_of(work, struct ambarella_adc_info, detect_adc.work);

	if (unlikely(pinfo->pkeymap == NULL)) {
	dev_err(&pinfo->dev->dev, "pinfo->pkeymap is null");
	return;
	}

	adc_size = pinfo->adc_channel_num;
	pinfo->pcontroller_info->read_channels(pinfo->adc_data, &adc_size);

	for (i = 0; i < AMBINPUT_TABLE_SIZE; i++) {
	if (pinfo->pkeymap[i].type == AMBINPUT_END)
	break;

	if ((pinfo->pkeymap[i].type & AMBINPUT_SOURCE_MASK) != AMBINPUT_SOURCE_ADC)
	continue;

	adc_index = pinfo->pkeymap[i].adc_key.chan;
	if (adc_index >= adc_size)
	continue;

	if ((pinfo->pkeymap[i].adc_key.low_level > pinfo->adc_data[adc_index]) \|\|
	(pinfo->pkeymap[i].adc_key.high_level < pinfo->adc_data[adc_index]))
	continue;

	/* scan the key and stop when the first key action is detected. If you want to
	monitor multi-key in different ADC channels, remove "break" */
	if (pinfo->pkeymap[i].type == AMBINPUT_ADC_KEY) {
	if (pinfo->adc_key_pressed[adc_index] != AMBA_ADC_NO_KEY_PRESSED
	&& pinfo->pkeymap[i].adc_key.key_code == KEY_RESERVED) {
	input_report_key(pinfo->dev,
	pinfo->adc_key_pressed[adc_index], 0);//key relase
	dev_dbg(&pinfo->dev->dev, "key[%d:%d] released %d\n", adc_index,
	pinfo->adc_key_pressed[adc_index],
	pinfo->adc_data[adc_index]);
	pinfo->adc_key_pressed[adc_index] = AMBA_ADC_NO_KEY_PRESSED;
	if (pinfo->support_irq) {
	pinfo->work_mode = AMBA_ADC_IRQ_MODE;
	}
	break;
	} else if (pinfo->adc_key_pressed[adc_index] == AMBA_ADC_NO_KEY_PRESSED
	&& pinfo->pkeymap[i].adc_key.key_code != KEY_RESERVED) {
	input_report_key(pinfo->dev,
	pinfo->pkeymap[i].adc_key.key_code, 1);// key press
	pinfo->adc_key_pressed[adc_index] =
	pinfo->pkeymap[i].adc_key.key_code;
	if (pinfo->support_irq) {
	pinfo->work_mode = AMBA_ADC_POL_MODE;
	}
	dev_dbg(&pinfo->dev->dev, "key[%d:%d] pressed %d\n", adc_index,
	pinfo->adc_key_pressed[adc_index],
	pinfo->adc_data[adc_index]);
	break;
	}
	}

	if (pinfo->pkeymap[i].type == AMBINPUT_ADC_REL) {
	if (pinfo->pkeymap[i].adc_rel.key_code == REL_X) {
	input_report_rel(pinfo->dev,
	REL_X,
	pinfo->pkeymap[i].adc_rel.rel_step);
	input_report_rel(pinfo->dev,
	REL_Y, 0);
	input_sync(pinfo->dev);
	dev_dbg(&pinfo->dev->dev, "report REL_X %d & %d\n",
	pinfo->pkeymap[i].adc_rel.rel_step,
	pinfo->adc_data[adc_index]);
	break;
	} else if (pinfo->pkeymap[i].adc_rel.key_code == REL_Y) {
	input_report_rel(pinfo->dev,
	REL_X, 0);
	input_report_rel(pinfo->dev,
	REL_Y,
	pinfo->pkeymap[i].adc_rel.rel_step);
	input_sync(pinfo->dev);
	dev_dbg(&pinfo->dev->dev, "report REL_Y %d & %d\n",
	pinfo->pkeymap[i].adc_rel.rel_step,
	pinfo->adc_data[adc_index]);
	break;
	}
	}

	if (pinfo->pkeymap[i].type == AMBINPUT_ADC_REL) {
	input_report_abs(pinfo->dev,
	ABS_X, pinfo->pkeymap[i].adc_abs.abs_x);
	input_report_abs(pinfo->dev,
	ABS_Y, pinfo->pkeymap[i].adc_abs.abs_y);
	input_sync(pinfo->dev);
	dev_dbg(&pinfo->dev->dev, "report ABS %d:%d & %d\n",
	pinfo->pkeymap[i].adc_abs.abs_x,
	pinfo->pkeymap[i].adc_abs.abs_y,
	pinfo->adc_data[adc_index]);
	break;
	}
	}

	if (pinfo->work_mode == AMBA_ADC_POL_MODE)
	queue_delayed_work(pinfo->workqueue, &pinfo->detect_adc,
	pinfo->pcontroller_info->scan_delay);
	else
	enable_irq(pinfo->irq);
	}

	static irqreturn_t ambarella_input_adc_irq(int irq, void *devid)
	{
	struct ambarella_adc_info *pinfo;

	pinfo = (struct ambarella_adc_info *)devid;

	dev_dbg(&pinfo->dev->dev, "%s:%d\n", __func__, __LINE__);

	disable_irq_nosync(pinfo->irq);
	queue_delayed_work(pinfo->workqueue, &pinfo->detect_adc, 0);

	return IRQ_HANDLED;
	}

	static int __devinit ambarella_input_adc_probe(struct platform_device *pdev)
	{
	int retval = 0;
	struct ambarella_adc_info *pinfo;
	int irq;
	struct resource *mem;
	struct resource *ioarea;
	struct ambarella_input_board_info *pboard_info;

	pboard_info = ambarella_input_get_board_info();
	if (pboard_info == NULL){
	dev_err(&pdev->dev, "pboard_info is NULL!\n");
	retval = -ENOMEM;
	goto adc_errorCode_na;
	}

	pinfo = kmalloc(sizeof(struct ambarella_adc_info), GFP_KERNEL);
	if (!pinfo) {
	dev_err(&pdev->dev, "Failed to allocate pinfo!\n");
	retval = -ENOMEM;
	goto adc_errorCode_na;
	}

	pinfo->pcontroller_info =
	(struct ambarella_adc_controller *)pdev->dev.platform_data;
	if ((pinfo->pcontroller_info == NULL) \|\|
	(pinfo->pcontroller_info->read_channels == NULL) \|\|
	(pinfo->pcontroller_info->is_irq_supported == NULL) \|\|
	(pinfo->pcontroller_info->set_irq_threshold == NULL) \|\|
	(pinfo->pcontroller_info->reset == NULL) \|\|
	(pinfo->pcontroller_info->stop == NULL) \|\|
	(pinfo->pcontroller_info->open == NULL) \|\|
	(pinfo->pcontroller_info->close == NULL) \|\|
	(pinfo->pcontroller_info->get_channel_num == NULL) ) {
	dev_err(&pdev->dev, "Platform data is NULL!\n");
	retval = -ENXIO;
	goto adc_errorCode_pinfo;
	}

	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (mem == NULL) {
	dev_err(&pdev->dev, "Get mem resource failed!\n");
	retval = -ENXIO;
	goto adc_errorCode_pinfo;
	}
	ioarea = request_mem_region(mem->start,
	(mem->end - mem->start) + 1, pdev->name);
	if (ioarea == NULL) {
	dev_err(&pdev->dev, "Request ioarea failed!\n");
	retval = -EBUSY;
	goto adc_errorCode_pinfo;
	}

	pinfo->support_irq = pinfo->pcontroller_info->is_irq_supported();
	if (pinfo->support_irq) {
	irq = platform_get_irq_byname(pdev, "adc-level-irq");
	if (irq == -ENXIO) {
	dev_err(&pdev->dev, "Get irq resource failed!\n");
	retval = -ENXIO;
	goto adc_errorCode_mem;
	} else {
	pinfo->irq = irq;
	}
	}

	pinfo->regbase = (unsigned char __iomem *)mem->start;
	pinfo->id = pdev->id;
	pinfo->mem = mem;
	pinfo->dev = pboard_info->pinput_dev;
	pinfo->pkeymap = pboard_info->pkeymap;

	pinfo->pcontroller_info->open();

	retval = ambarella_setup_adc_key(pinfo);
	if (retval) {
	dev_err(&pdev->dev, "ambarella_setup_adc_key failed!\n");
	goto adc_errorCode_mem;
	}

	pinfo->workqueue = create_singlethread_workqueue("amba_adc");
	if (!pinfo->workqueue) {
	retval = -ENOMEM;
	dev_err(&pdev->dev, "Create ADC workqueue failed!\n");
	goto adc_errorCode_setup_adc_key;
	}
	INIT_DELAYED_WORK(&pinfo->detect_adc, ambarella_scan_adc);

	if (pinfo->support_irq) {// irq mode
	pinfo->work_mode = AMBA_ADC_IRQ_MODE;
	retval = request_irq(pinfo->irq, ambarella_input_adc_irq,
	pinfo->irqflags, dev_name(&pdev->dev), pinfo);
	if (retval) {
	dev_err(&pdev->dev, "Request IRQ failed!\n");
	goto adc_errorCode_free_queue;
	}
	} else {//polling mode
	pinfo->work_mode = AMBA_ADC_POL_MODE;
	queue_delayed_work(pinfo->workqueue, &pinfo->detect_adc,
	pinfo->pcontroller_info->scan_delay);
	}

	platform_set_drvdata(pdev, pinfo);
	dev_notice(&pdev->dev, "ADC Host Controller [%s mode] probed!\n",
	(pinfo->support_irq) ? "interrupt" : "polling");

	goto adc_errorCode_na;

	adc_errorCode_free_queue:
	destroy_workqueue(pinfo->workqueue);
	adc_errorCode_setup_adc_key:
	kfree(pinfo->adc_key_pressed);
	pinfo->adc_key_pressed = NULL;
	kfree(pinfo->adc_channel_info);
	pinfo->adc_channel_info = NULL;
	adc_errorCode_mem:
	release_mem_region(pinfo->mem->start, (pinfo->mem->end - pinfo->mem->start) + 1);
	adc_errorCode_pinfo:
	kfree(pinfo);
	adc_errorCode_na:
	return retval;
	}

	static int __devexit ambarella_input_adc_remove(struct platform_device *pdev)
	{
	struct ambarella_adc_info *pinfo;
	int retval = 0;

	pinfo = platform_get_drvdata(pdev);

	if (pinfo) {
	if (pinfo->support_irq)
	free_irq(pinfo->irq, pinfo);
	pinfo->pcontroller_info->close();
	platform_set_drvdata(pdev, NULL);
	cancel_delayed_work(&pinfo->detect_adc);
	flush_workqueue(pinfo->workqueue);
	destroy_workqueue(pinfo->workqueue);
	release_mem_region(pinfo->mem->start, (pinfo->mem->end - pinfo->mem->start) + 1);
	kfree(pinfo->adc_data);
	kfree(pinfo->adc_key_pressed);
	kfree(pinfo->adc_channel_info);
	kfree(pinfo);
	}

	dev_notice(&pdev->dev, "Remove Ambarella Media Processor ADC Host Controller.\n");

	return retval;
	}

	#if (defined CONFIG_PM)
	static int ambarella_input_adc_suspend(struct platform_device *pdev,
	pm_message_t state)
	{
	int retval = 0;
	struct ambarella_adc_info *pinfo;

	pinfo = platform_get_drvdata(pdev);

	if (pinfo->support_irq)
	disable_irq(pinfo->irq);

	dev_dbg(&pdev->dev, "%s exit with %d @ %d\n",
	__func__, retval, state.event);
	return retval;
	}

	static int ambarella_input_adc_resume(struct platform_device *pdev)
	{
	int retval = 0;
	struct ambarella_adc_info *pinfo;

	pinfo = platform_get_drvdata(pdev);

	if (pinfo->support_irq)
	enable_irq(pinfo->irq);

	dev_dbg(&pdev->dev, "%s exit with %d\n", __func__, retval);

	return retval;
	}
	#endif

	static struct platform_driver ambarella_adc_driver = {
	.probe = ambarella_input_adc_probe,
	.remove = __devexit_p(ambarella_input_adc_remove),
	#ifdef CONFIG_PM
	.suspend = ambarella_input_adc_suspend,
	.resume = ambarella_input_adc_resume,
	#endif
	.driver = {
	.name = "ambarella-adc",
	.owner = THIS_MODULE,
	},
	};

	int platform_driver_register_adc(void)
	{
	return platform_driver_register(&ambarella_adc_driver);
	}
	void platform_driver_unregister_adc(void)
	{
	platform_driver_unregister(&ambarella_adc_driver);
	}