[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / input / matrix-keymap.c

/*
 * Helpers for matrix keyboard bindings
 *
 * Copyright (C) 2012 Google, Inc
 *
 * Author:
 *	Olof Johansson <olof@lixom.net>
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * 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.
 *
 */

#include <linux/device.h>
#include <linux/gfp.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/input.h>
#include <linux/of.h>
#include <linux/export.h>
#include <linux/module.h>
#include <linux/input/matrix_keypad.h>

static bool matrix_keypad_map_key(struct input_dev *input_dev,
				  unsigned int rows, unsigned int cols,
				  unsigned int row_shift, unsigned int key)
{
	unsigned short *keymap = input_dev->keycode;
	unsigned int row = KEY_ROW(key);
	unsigned int col = KEY_COL(key);
	unsigned short code = KEY_VAL(key);

	if (row >= rows || col >= cols) {
		dev_err(input_dev->dev.parent,
			"%s: invalid keymap entry 0x%x (row: %d, col: %d, rows: %d, cols: %d)\n",
			__func__, key, row, col, rows, cols);
		return false;
	}

	keymap[MATRIX_SCAN_CODE(row, col, row_shift)] = code;
	__set_bit(code, input_dev->keybit);

	return true;
}

#ifdef CONFIG_OF
static int matrix_keypad_parse_of_keymap(const char *propname,
					 unsigned int rows, unsigned int cols,
					 struct input_dev *input_dev)
{
	struct device *dev = input_dev->dev.parent;
	struct device_node *np = dev->of_node;
	unsigned int row_shift = get_count_order(cols);
	unsigned int max_keys = rows << row_shift;
	unsigned int proplen, i, size;
	const __be32 *prop;

	if (!np)
		return -ENOENT;

	if (!propname)
		propname = "linux,keymap";

	prop = of_get_property(np, propname, &proplen);
	if (!prop) {
		dev_err(dev, "OF: %s property not defined in %s\n",
			propname, np->full_name);
		return -ENOENT;
	}

	if (proplen % sizeof(u32)) {
		dev_err(dev, "OF: Malformed keycode property %s in %s\n",
			propname, np->full_name);
		return -EINVAL;
	}

	size = proplen / sizeof(u32);
	if (size > max_keys) {
		dev_err(dev, "OF: %s size overflow\n", propname);
		return -EINVAL;
	}

	for (i = 0; i < size; i++) {
		unsigned int key = be32_to_cpup(prop + i);

		if (!matrix_keypad_map_key(input_dev, rows, cols,
					   row_shift, key))
			return -EINVAL;
	}

	return 0;
}
#else
static int matrix_keypad_parse_of_keymap(const char *propname,
					 unsigned int rows, unsigned int cols,
					 struct input_dev *input_dev)
{
	return -ENOSYS;
}
#endif

/**
 * matrix_keypad_build_keymap - convert platform keymap into matrix keymap
 * @keymap_data: keymap supplied by the platform code
 * @keymap_name: name of device tree property containing keymap (if device
 *	tree support is enabled).
 * @rows: number of rows in target keymap array
 * @cols: number of cols in target keymap array
 * @keymap: expanded version of keymap that is suitable for use by
 * matrix keyboard driver
 * @input_dev: input devices for which we are setting up the keymap
 *
 * This function converts platform keymap (encoded with KEY() macro) into
 * an array of keycodes that is suitable for using in a standard matrix
 * keyboard driver that uses row and col as indices.
 *
 * If @keymap_data is not supplied and device tree support is enabled
 * it will attempt load the keymap from property specified by @keymap_name
 * argument (or "linux,keymap" if @keymap_name is %NULL).
 *
 * If @keymap is %NULL the function will automatically allocate managed
 * block of memory to store the keymap. This memory will be associated with
 * the parent device and automatically freed when device unbinds from the
 * driver.
 *
 * Callers are expected to set up input_dev->dev.parent before calling this
 * function.
 */
int matrix_keypad_build_keymap(const struct matrix_keymap_data *keymap_data,
			       const char *keymap_name,
			       unsigned int rows, unsigned int cols,
			       unsigned short *keymap,
			       struct input_dev *input_dev)
{
	unsigned int row_shift = get_count_order(cols);
	size_t max_keys = rows << row_shift;
	int i;
	int error;

	if (WARN_ON(!input_dev->dev.parent))
		return -EINVAL;

	if (!keymap) {
		keymap = devm_kzalloc(input_dev->dev.parent,
				      max_keys * sizeof(*keymap),
				      GFP_KERNEL);
		if (!keymap) {
			dev_err(input_dev->dev.parent,
				"Unable to allocate memory for keymap");
			return -ENOMEM;
		}
	}

	input_dev->keycode = keymap;
	input_dev->keycodesize = sizeof(*keymap);
	input_dev->keycodemax = max_keys;

	__set_bit(EV_KEY, input_dev->evbit);

	if (keymap_data) {
		for (i = 0; i < keymap_data->keymap_size; i++) {
			unsigned int key = keymap_data->keymap[i];

			if (!matrix_keypad_map_key(input_dev, rows, cols,
						   row_shift, key))
				return -EINVAL;
		}
	} else {
		error = matrix_keypad_parse_of_keymap(keymap_name, rows, cols,
						      input_dev);
		if (error)
			return error;
	}

	__clear_bit(KEY_RESERVED, input_dev->keybit);

	return 0;
}
EXPORT_SYMBOL(matrix_keypad_build_keymap);

MODULE_LICENSE("GPL");
Commit	Line	Data
2cd36877	1	/*
1932811f	2	* Helpers for matrix keyboard bindings
2cd36877 OJ	3	*
	4	* Copyright (C) 2012 Google, Inc
	5	*
	6	* Author:
	7	* Olof Johansson <olof@lixom.net>
	8	*
	9	* This software is licensed under the terms of the GNU General Public
	10	* License version 2, as published by the Free Software Foundation, and
	11	* may be copied, distributed, and modified under those terms.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	*/
	19
b45c8f35	20	#include <linux/device.h>
5383116b	21	#include <linux/gfp.h>
2cd36877 OJ	22	#include <linux/kernel.h>
	23	#include <linux/types.h>
	24	#include <linux/input.h>
	25	#include <linux/of.h>
2cd36877	26	#include <linux/export.h>
516d798f	27	#include <linux/module.h>
1932811f DT	28	#include <linux/input/matrix_keypad.h>
1932811f DT	29
b45c8f35 DT	30	static bool matrix_keypad_map_key(struct input_dev *input_dev,
	31	unsigned int rows, unsigned int cols,
	32	unsigned int row_shift, unsigned int key)
	33	{
86809173	34	unsigned short *keymap = input_dev->keycode;
b45c8f35 DT	35	unsigned int row = KEY_ROW(key);
	36	unsigned int col = KEY_COL(key);
	37	unsigned short code = KEY_VAL(key);
	38
	39	if (row >= rows \|\| col >= cols) {
	40	dev_err(input_dev->dev.parent,
	41	"%s: invalid keymap entry 0x%x (row: %d, col: %d, rows: %d, cols: %d)\n",
	42	__func__, key, row, col, rows, cols);
	43	return false;
	44	}
	45
	46	keymap[MATRIX_SCAN_CODE(row, col, row_shift)] = code;
	47	__set_bit(code, input_dev->keybit);
	48
	49	return true;
	50	}
	51
	52	#ifdef CONFIG_OF
	53	static int matrix_keypad_parse_of_keymap(const char *propname,
	54	unsigned int rows, unsigned int cols,
	55	struct input_dev *input_dev)
	56	{
	57	struct device *dev = input_dev->dev.parent;
	58	struct device_node *np = dev->of_node;
	59	unsigned int row_shift = get_count_order(cols);
	60	unsigned int max_keys = rows << row_shift;
	61	unsigned int proplen, i, size;
	62	const __be32 *prop;
	63
	64	if (!np)
	65	return -ENOENT;
	66
	67	if (!propname)
	68	propname = "linux,keymap";
	69
	70	prop = of_get_property(np, propname, &proplen);
	71	if (!prop) {
	72	dev_err(dev, "OF: %s property not defined in %s\n",
	73	propname, np->full_name);
	74	return -ENOENT;
	75	}
	76
	77	if (proplen % sizeof(u32)) {
	78	dev_err(dev, "OF: Malformed keycode property %s in %s\n",
	79	propname, np->full_name);
	80	return -EINVAL;
	81	}
	82
	83	size = proplen / sizeof(u32);
	84	if (size > max_keys) {
	85	dev_err(dev, "OF: %s size overflow\n", propname);
	86	return -EINVAL;
	87	}
	88
	89	for (i = 0; i < size; i++) {
	90	unsigned int key = be32_to_cpup(prop + i);
	91
	92	if (!matrix_keypad_map_key(input_dev, rows, cols,
	93	row_shift, key))
	94	return -EINVAL;
	95	}
	96
	97	return 0;
	98	}
99	#else
100	static int matrix_keypad_parse_of_keymap(const char *propname,
101	unsigned int rows, unsigned int cols,
102	struct input_dev *input_dev)
103	{
104	return -ENOSYS;
105	}
106	#endif
1932811f DT	107
	108	/**
	109	* matrix_keypad_build_keymap - convert platform keymap into matrix keymap
	110	* @keymap_data: keymap supplied by the platform code
	111	* @keymap_name: name of device tree property containing keymap (if device
	112	* tree support is enabled).
	113	* @rows: number of rows in target keymap array
	114	* @cols: number of cols in target keymap array
	115	* @keymap: expanded version of keymap that is suitable for use by
	116	* matrix keyboard driver
	117	* @input_dev: input devices for which we are setting up the keymap
	118	*
	119	* This function converts platform keymap (encoded with KEY() macro) into
	120	* an array of keycodes that is suitable for using in a standard matrix
	121	* keyboard driver that uses row and col as indices.
b45c8f35 DT	122	*
	123	* If @keymap_data is not supplied and device tree support is enabled
	124	* it will attempt load the keymap from property specified by @keymap_name
	125	* argument (or "linux,keymap" if @keymap_name is %NULL).
	126	*
5383116b DT	127	* If @keymap is %NULL the function will automatically allocate managed
	128	* block of memory to store the keymap. This memory will be associated with
	129	* the parent device and automatically freed when device unbinds from the
	130	* driver.
	131	*
b45c8f35 DT	132	* Callers are expected to set up input_dev->dev.parent before calling this
b45c8f35 DT	133	* function.
1932811f DT	134	*/
	135	int matrix_keypad_build_keymap(const struct matrix_keymap_data *keymap_data,
	136	const char *keymap_name,
	137	unsigned int rows, unsigned int cols,
	138	unsigned short *keymap,
	139	struct input_dev *input_dev)
	140	{
	141	unsigned int row_shift = get_count_order(cols);
5383116b	142	size_t max_keys = rows << row_shift;
1932811f	143	int i;
b45c8f35	144	int error;
1932811f	145
5383116b DT	146	if (WARN_ON(!input_dev->dev.parent))
	147	return -EINVAL;
	148
	149	if (!keymap) {
	150	keymap = devm_kzalloc(input_dev->dev.parent,
	151	max_keys * sizeof(*keymap),
	152	GFP_KERNEL);
	153	if (!keymap) {
	154	dev_err(input_dev->dev.parent,
	155	"Unable to allocate memory for keymap");
	156	return -ENOMEM;
	157	}
	158	}
	159
1932811f DT	160	input_dev->keycode = keymap;
1932811f DT	161	input_dev->keycodesize = sizeof(*keymap);
5383116b	162	input_dev->keycodemax = max_keys;
1932811f DT	163
	164	__set_bit(EV_KEY, input_dev->evbit);
	165
b45c8f35 DT	166	if (keymap_data) {
	167	for (i = 0; i < keymap_data->keymap_size; i++) {
	168	unsigned int key = keymap_data->keymap[i];
1932811f	169
b45c8f35 DT	170	if (!matrix_keypad_map_key(input_dev, rows, cols,
	171	row_shift, key))
	172	return -EINVAL;
1932811f	173	}
b45c8f35 DT	174	} else {
	175	error = matrix_keypad_parse_of_keymap(keymap_name, rows, cols,
	176	input_dev);
	177	if (error)
	178	return error;
1932811f	179	}
b45c8f35	180
1932811f DT	181	__clear_bit(KEY_RESERVED, input_dev->keybit);
	182
	183	return 0;
	184	}
	185	EXPORT_SYMBOL(matrix_keypad_build_keymap);
516d798f FF	186
516d798f FF	187	MODULE_LICENSE("GPL");