| /* |
| * 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); |
| } |
| |