drivers/input/misc/ambarella_input_adc.c - nest-hello/linux-3.10 - Git at Google

 /*
  * drivers/input/misc/ambarella_input_adc.c
  *
  * Author: Qiao Wang <qwang@ambarella.com>
  * Copyright (C) 2004-2009, Ambarella, Inc.
  *
  *  @History        ::
  *      Date        Name             Comments
  *      07/16/2014  Bing-Liang Hu    irq or polling depend on adc irq support
  *      07/21/2014  Cao Rongrong     re-design the mechanism with ADC
  *
  * 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/platform_device.h>
 #include <linux/input.h>
 #include <linux/slab.h>
 #include <linux/of.h>
 #include <plat/adc.h>

 struct ambadc_keymap {
 	u32 key_code;
 	u32 channel : 4;
 	u32 low_level : 12;
 	u32 high_level : 12;
 };

 struct ambarella_adckey {
 	struct input_dev *input;
 	struct ambadc_client *adc_client;

 	struct ambadc_keymap *keymap;
 	u32 key_num;
 	u32 key_saved[ADC_NUM_CHANNELS]; /* save the key currently pressed */
 	u32 print_key : 1;
 };

 static void ambarella_adckey_filter_out(struct ambadc_client *client,
 		struct ambadc_keymap *keymap)
 {
 	/* we expect the adc level which is out of current key's range. */
 	ambarella_adc_set_threshold(client,
 		keymap->channel, keymap->low_level, keymap->high_level);
 }

 static int ambarella_adckey_callback(struct ambadc_client *client,
 		u32 ch, u32 level)
 {
 	struct ambarella_adckey *adckey;
 	struct ambadc_keymap *keymap;
 	struct input_dev *input;
 	u32 i;

 	adckey = dev_get_drvdata(client->dev);
 	if(adckey == NULL)
 		return -EAGAIN;

 	keymap = adckey->keymap;
 	input = adckey->input;

 	for (i = 0; i < adckey->key_num; i++, keymap++) {
 		if (ch != keymap->channel
 			|| level < keymap->low_level
 			|| level > keymap->high_level)
 			continue;

 		if (adckey->key_saved[ch] == KEY_RESERVED
 			&& keymap->key_code != KEY_RESERVED) {
 			input_report_key(input, keymap->key_code, 1);
 			input_sync(input);
 			adckey->key_saved[ch] = keymap->key_code;
 			ambarella_adckey_filter_out(client, keymap);

 			if (adckey->print_key) {
 				dev_info(&input->dev, "key[%d:%d] pressed %d\n",
 					ch, adckey->key_saved[ch], level);
 			}
 			break;
 		} else if (adckey->key_saved[ch] != KEY_RESERVED
 			&& keymap->key_code == KEY_RESERVED) {
 			input_report_key(input, adckey->key_saved[ch], 0);
 			input_sync(input);
 			adckey->key_saved[ch] = KEY_RESERVED;
 			ambarella_adckey_filter_out(client, keymap);

 			if (adckey->print_key) {
 				dev_info(&input->dev, "key[%d:%d] released %d\n",
 					ch, adckey->key_saved[ch], level);
 			}
 			break;
 		}
 	}

 	return 0;
 }

 static int ambarella_adckey_of_parse(struct platform_device *pdev,
 		struct ambarella_adckey *adckey)
 {
 	struct device_node *np = pdev->dev.of_node;
 	struct ambadc_keymap *keymap;
 	const __be32 *prop;
 	u32 propval, i, size;

 	adckey->print_key = !!of_find_property(np, "amb,print-key", NULL);

 	prop = of_get_property(np, "amb,keymap", &size);
 	if (!prop || size % (sizeof(__be32) * 2)) {
 		dev_err(&pdev->dev, "Invalid keymap!\n");
 		return -ENOENT;
 	}

 	/* cells is 2 for each keymap */
 	size /= sizeof(__be32) * 2;
 	adckey->key_num = size;

 	adckey->keymap = devm_kzalloc(&pdev->dev,
 			sizeof(struct ambadc_keymap) * size, GFP_KERNEL);
 	if (adckey->keymap == NULL){
 		dev_err(&pdev->dev, "No memory for keymap!\n");
 		return -ENOMEM;
 	}

 	keymap = adckey->keymap;

 	for (i = 0; i < adckey->key_num; i++, keymap++) {
 		propval = be32_to_cpup(prop + i * 2);
 		keymap->low_level = propval & 0xfff;
 		keymap->high_level = (propval >> 16) & 0xfff;
 		keymap->channel = propval >> 28;
 		if (keymap->channel >= ADC_NUM_CHANNELS) {
 			dev_err(&pdev->dev, "Invalid channel: %d\n", keymap->channel);
 			return -EINVAL;
 		}

 		propval = be32_to_cpup(prop + i * 2 + 1);
 		keymap->key_code = propval;

 		if (keymap->key_code == KEY_RESERVED)
 			ambarella_adckey_filter_out(adckey->adc_client, keymap);

 		input_set_capability(adckey->input, EV_KEY, keymap->key_code);
 	}

 	for (i = 0; i < ADC_NUM_CHANNELS; i++)
 		adckey->key_saved[i] = KEY_RESERVED;

 	return 0;
 }

 static int ambarella_adckey_probe(struct platform_device *pdev)
 {
 	struct ambarella_adckey *adckey;
 	struct input_dev *input;
 	int rval = 0;

 	adckey = devm_kzalloc(&pdev->dev,
 			     sizeof(struct ambarella_adckey),
 			     GFP_KERNEL);
 	if (!adckey) {
 		dev_err(&pdev->dev, "Failed to allocate adckey!\n");
 		return -ENOMEM;
 	}

 	input = input_allocate_device();
 	if (!input) {
 		dev_err(&pdev->dev, "input_allocate_device fail!\n");
 		return -ENOMEM;
 	}

 	input->name = "AmbADCkey";
 	input->phys = "ambadckey/input0";
 	input->id.bustype = BUS_HOST;
 	input->dev.parent = &pdev->dev;

 	rval = input_register_device(input);
 	if (rval < 0) {
 		dev_err(&pdev->dev, "Register input_dev failed!\n");
 		goto adckey_probe_err0;
 	}

 	adckey->input = input;

 	adckey->adc_client = ambarella_adc_register_client(&pdev->dev,
 					AMBADC_CONTINUOUS,
 					ambarella_adckey_callback);
 	if (!adckey->adc_client) {
 		dev_err(&pdev->dev, "Register adc client failed!\n");
 		goto adckey_probe_err1;
 	}

 	rval = ambarella_adckey_of_parse(pdev, adckey);
 	if (rval < 0)
 		goto adckey_probe_err2;

 	platform_set_drvdata(pdev, adckey);

 	dev_info(&pdev->dev, "ADC key input driver probed!\n");

 	return 0;

 adckey_probe_err2:
 	ambarella_adc_unregister_client(adckey->adc_client);
 adckey_probe_err1:
 	input_unregister_device(adckey->input);
 adckey_probe_err0:
 	input_free_device(input);
 	return rval;
 }

 static int ambarella_adckey_remove(struct platform_device *pdev)
 {
 	struct ambarella_adckey *adckey;
 	int rval = 0;

 	adckey = platform_get_drvdata(pdev);

 	ambarella_adc_unregister_client(adckey->adc_client);
 	input_unregister_device(adckey->input);
 	input_free_device(adckey->input);

 	dev_info(&pdev->dev, "Remove Ambarella ADC Key driver.\n");

 	return rval;
 }

 #ifdef CONFIG_PM
 static int ambarella_adckey_suspend(struct platform_device *pdev,
 		pm_message_t state)
 {
 	return 0;
 }

 static int ambarella_adckey_resume(struct platform_device *pdev)
 {
 	return 0;
 }
 #endif

 static const struct of_device_id ambarella_adckey_dt_ids[] = {
 	{.compatible = "ambarella,input_adckey", },
 	{},
 };
 MODULE_DEVICE_TABLE(of, ambarella_adckey_dt_ids);

 static struct platform_driver ambarella_adckey_driver = {
 	.probe		= ambarella_adckey_probe,
 	.remove		= ambarella_adckey_remove,
 #ifdef CONFIG_PM
 	.suspend	= ambarella_adckey_suspend,
 	.resume		= ambarella_adckey_resume,
 #endif
 	.driver		= {
 		.name	= "ambarella-adckey",
 		.owner	= THIS_MODULE,
 		.of_match_table = ambarella_adckey_dt_ids,
 	},
 };

 module_platform_driver(ambarella_adckey_driver);

 MODULE_AUTHOR("Bing-Liang Hu <blhu@ambarella.com>");
 MODULE_DESCRIPTION("Ambarella ADC key Driver");
 MODULE_LICENSE("GPL");
	/*
	* drivers/input/misc/ambarella_input_adc.c
	*
	* Author: Qiao Wang <qwang@ambarella.com>
	* Copyright (C) 2004-2009, Ambarella, Inc.
	*
	* @History ::
	* Date Name Comments
	* 07/16/2014 Bing-Liang Hu irq or polling depend on adc irq support
	* 07/21/2014 Cao Rongrong re-design the mechanism with ADC
	*
	* 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/platform_device.h>
	#include <linux/input.h>
	#include <linux/slab.h>
	#include <linux/of.h>
	#include <plat/adc.h>

	struct ambadc_keymap {
	u32 key_code;
	u32 channel : 4;
	u32 low_level : 12;
	u32 high_level : 12;
	};

	struct ambarella_adckey {
	struct input_dev *input;
	struct ambadc_client *adc_client;

	struct ambadc_keymap *keymap;
	u32 key_num;
	u32 key_saved[ADC_NUM_CHANNELS]; /* save the key currently pressed */
	u32 print_key : 1;
	};

	static void ambarella_adckey_filter_out(struct ambadc_client *client,
	struct ambadc_keymap *keymap)
	{
	/* we expect the adc level which is out of current key's range. */
	ambarella_adc_set_threshold(client,
	keymap->channel, keymap->low_level, keymap->high_level);
	}

	static int ambarella_adckey_callback(struct ambadc_client *client,
	u32 ch, u32 level)
	{
	struct ambarella_adckey *adckey;
	struct ambadc_keymap *keymap;
	struct input_dev *input;
	u32 i;

	adckey = dev_get_drvdata(client->dev);
	if(adckey == NULL)
	return -EAGAIN;

	keymap = adckey->keymap;
	input = adckey->input;

	for (i = 0; i < adckey->key_num; i++, keymap++) {
	if (ch != keymap->channel
	\|\| level < keymap->low_level
	\|\| level > keymap->high_level)
	continue;

	if (adckey->key_saved[ch] == KEY_RESERVED
	&& keymap->key_code != KEY_RESERVED) {
	input_report_key(input, keymap->key_code, 1);
	input_sync(input);
	adckey->key_saved[ch] = keymap->key_code;
	ambarella_adckey_filter_out(client, keymap);

	if (adckey->print_key) {
	dev_info(&input->dev, "key[%d:%d] pressed %d\n",
	ch, adckey->key_saved[ch], level);
	}
	break;
	} else if (adckey->key_saved[ch] != KEY_RESERVED
	&& keymap->key_code == KEY_RESERVED) {
	input_report_key(input, adckey->key_saved[ch], 0);
	input_sync(input);
	adckey->key_saved[ch] = KEY_RESERVED;
	ambarella_adckey_filter_out(client, keymap);

	if (adckey->print_key) {
	dev_info(&input->dev, "key[%d:%d] released %d\n",
	ch, adckey->key_saved[ch], level);
	}
	break;
	}
	}

	return 0;
	}

	static int ambarella_adckey_of_parse(struct platform_device *pdev,
	struct ambarella_adckey *adckey)
	{
	struct device_node *np = pdev->dev.of_node;
	struct ambadc_keymap *keymap;
	const __be32 *prop;
	u32 propval, i, size;

	adckey->print_key = !!of_find_property(np, "amb,print-key", NULL);

	prop = of_get_property(np, "amb,keymap", &size);
	if (!prop \|\| size % (sizeof(__be32) * 2)) {
	dev_err(&pdev->dev, "Invalid keymap!\n");
	return -ENOENT;
	}

	/* cells is 2 for each keymap */
	size /= sizeof(__be32) * 2;
	adckey->key_num = size;

	adckey->keymap = devm_kzalloc(&pdev->dev,
	sizeof(struct ambadc_keymap) * size, GFP_KERNEL);
	if (adckey->keymap == NULL){
	dev_err(&pdev->dev, "No memory for keymap!\n");
	return -ENOMEM;
	}

	keymap = adckey->keymap;

	for (i = 0; i < adckey->key_num; i++, keymap++) {
	propval = be32_to_cpup(prop + i * 2);
	keymap->low_level = propval & 0xfff;
	keymap->high_level = (propval >> 16) & 0xfff;
	keymap->channel = propval >> 28;
	if (keymap->channel >= ADC_NUM_CHANNELS) {
	dev_err(&pdev->dev, "Invalid channel: %d\n", keymap->channel);
	return -EINVAL;
	}

	propval = be32_to_cpup(prop + i * 2 + 1);
	keymap->key_code = propval;

	if (keymap->key_code == KEY_RESERVED)
	ambarella_adckey_filter_out(adckey->adc_client, keymap);

	input_set_capability(adckey->input, EV_KEY, keymap->key_code);
	}

	for (i = 0; i < ADC_NUM_CHANNELS; i++)
	adckey->key_saved[i] = KEY_RESERVED;

	return 0;
	}

	static int ambarella_adckey_probe(struct platform_device *pdev)
	{
	struct ambarella_adckey *adckey;
	struct input_dev *input;
	int rval = 0;

	adckey = devm_kzalloc(&pdev->dev,
	sizeof(struct ambarella_adckey),
	GFP_KERNEL);
	if (!adckey) {
	dev_err(&pdev->dev, "Failed to allocate adckey!\n");
	return -ENOMEM;
	}

	input = input_allocate_device();
	if (!input) {
	dev_err(&pdev->dev, "input_allocate_device fail!\n");
	return -ENOMEM;
	}

	input->name = "AmbADCkey";
	input->phys = "ambadckey/input0";
	input->id.bustype = BUS_HOST;
	input->dev.parent = &pdev->dev;

	rval = input_register_device(input);
	if (rval < 0) {
	dev_err(&pdev->dev, "Register input_dev failed!\n");
	goto adckey_probe_err0;
	}

	adckey->input = input;

	adckey->adc_client = ambarella_adc_register_client(&pdev->dev,
	AMBADC_CONTINUOUS,
	ambarella_adckey_callback);
	if (!adckey->adc_client) {
	dev_err(&pdev->dev, "Register adc client failed!\n");
	goto adckey_probe_err1;
	}

	rval = ambarella_adckey_of_parse(pdev, adckey);
	if (rval < 0)
	goto adckey_probe_err2;

	platform_set_drvdata(pdev, adckey);

	dev_info(&pdev->dev, "ADC key input driver probed!\n");

	return 0;

	adckey_probe_err2:
	ambarella_adc_unregister_client(adckey->adc_client);
	adckey_probe_err1:
	input_unregister_device(adckey->input);
	adckey_probe_err0:
	input_free_device(input);
	return rval;
	}

	static int ambarella_adckey_remove(struct platform_device *pdev)
	{
	struct ambarella_adckey *adckey;
	int rval = 0;

	adckey = platform_get_drvdata(pdev);

	ambarella_adc_unregister_client(adckey->adc_client);
	input_unregister_device(adckey->input);
	input_free_device(adckey->input);

	dev_info(&pdev->dev, "Remove Ambarella ADC Key driver.\n");

	return rval;
	}

	#ifdef CONFIG_PM
	static int ambarella_adckey_suspend(struct platform_device *pdev,
	pm_message_t state)
	{
	return 0;
	}

	static int ambarella_adckey_resume(struct platform_device *pdev)
	{
	return 0;
	}
	#endif

	static const struct of_device_id ambarella_adckey_dt_ids[] = {
	{.compatible = "ambarella,input_adckey", },
	{},
	};
	MODULE_DEVICE_TABLE(of, ambarella_adckey_dt_ids);

	static struct platform_driver ambarella_adckey_driver = {
	.probe = ambarella_adckey_probe,
	.remove = ambarella_adckey_remove,
	#ifdef CONFIG_PM
	.suspend = ambarella_adckey_suspend,
	.resume = ambarella_adckey_resume,
	#endif
	.driver = {
	.name = "ambarella-adckey",
	.owner = THIS_MODULE,
	.of_match_table = ambarella_adckey_dt_ids,
	},
	};

	module_platform_driver(ambarella_adckey_driver);

	MODULE_AUTHOR("Bing-Liang Hu <blhu@ambarella.com>");
	MODULE_DESCRIPTION("Ambarella ADC key Driver");
	MODULE_LICENSE("GPL");