[deliverable/linux.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/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).
 *
 * 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);
	int i;
	int error;

	input_dev->keycode = keymap;
	input_dev->keycodesize = sizeof(*keymap);
	input_dev->keycodemax = rows << row_shift;

	__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>
2cd36877 OJ	21	#include <linux/kernel.h>
	22	#include <linux/types.h>
	23	#include <linux/input.h>
	24	#include <linux/of.h>
2cd36877	25	#include <linux/export.h>
55220bb3	26	#include <linux/module.h>
1932811f DT	27	#include <linux/input/matrix_keypad.h>
1932811f DT	28
b45c8f35 DT	29	static bool matrix_keypad_map_key(struct input_dev *input_dev,
	30	unsigned int rows, unsigned int cols,
	31	unsigned int row_shift, unsigned int key)
	32	{
86809173	33	unsigned short *keymap = input_dev->keycode;
b45c8f35 DT	34	unsigned int row = KEY_ROW(key);
	35	unsigned int col = KEY_COL(key);
	36	unsigned short code = KEY_VAL(key);
	37
	38	if (row >= rows \|\| col >= cols) {
	39	dev_err(input_dev->dev.parent,
	40	"%s: invalid keymap entry 0x%x (row: %d, col: %d, rows: %d, cols: %d)\n",
	41	__func__, key, row, col, rows, cols);
	42	return false;
	43	}
	44
	45	keymap[MATRIX_SCAN_CODE(row, col, row_shift)] = code;
	46	__set_bit(code, input_dev->keybit);
	47
	48	return true;
	49	}
	50
	51	#ifdef CONFIG_OF
	52	static int matrix_keypad_parse_of_keymap(const char *propname,
	53	unsigned int rows, unsigned int cols,
	54	struct input_dev *input_dev)
	55	{
	56	struct device *dev = input_dev->dev.parent;
	57	struct device_node *np = dev->of_node;
	58	unsigned int row_shift = get_count_order(cols);
	59	unsigned int max_keys = rows << row_shift;
	60	unsigned int proplen, i, size;
	61	const __be32 *prop;
	62
	63	if (!np)
	64	return -ENOENT;
	65
	66	if (!propname)
	67	propname = "linux,keymap";
	68
	69	prop = of_get_property(np, propname, &proplen);
	70	if (!prop) {
	71	dev_err(dev, "OF: %s property not defined in %s\n",
	72	propname, np->full_name);
	73	return -ENOENT;
	74	}
	75
	76	if (proplen % sizeof(u32)) {
	77	dev_err(dev, "OF: Malformed keycode property %s in %s\n",
	78	propname, np->full_name);
	79	return -EINVAL;
	80	}
	81
	82	size = proplen / sizeof(u32);
	83	if (size > max_keys) {
	84	dev_err(dev, "OF: %s size overflow\n", propname);
	85	return -EINVAL;
	86	}
	87
	88	for (i = 0; i < size; i++) {
	89	unsigned int key = be32_to_cpup(prop + i);
	90
	91	if (!matrix_keypad_map_key(input_dev, rows, cols,
	92	row_shift, key))
	93	return -EINVAL;
	94	}
	95
	96	return 0;
	97	}
98	#else
99	static int matrix_keypad_parse_of_keymap(const char *propname,
100	unsigned int rows, unsigned int cols,
101	struct input_dev *input_dev)
102	{
103	return -ENOSYS;
104	}
105	#endif
1932811f DT	106
	107	/**
	108	* matrix_keypad_build_keymap - convert platform keymap into matrix keymap
	109	* @keymap_data: keymap supplied by the platform code
	110	* @keymap_name: name of device tree property containing keymap (if device
	111	* tree support is enabled).
	112	* @rows: number of rows in target keymap array
	113	* @cols: number of cols in target keymap array
	114	* @keymap: expanded version of keymap that is suitable for use by
	115	* matrix keyboard driver
	116	* @input_dev: input devices for which we are setting up the keymap
	117	*
	118	* This function converts platform keymap (encoded with KEY() macro) into
	119	* an array of keycodes that is suitable for using in a standard matrix
	120	* keyboard driver that uses row and col as indices.
b45c8f35 DT	121	*
	122	* If @keymap_data is not supplied and device tree support is enabled
	123	* it will attempt load the keymap from property specified by @keymap_name
	124	* argument (or "linux,keymap" if @keymap_name is %NULL).
	125	*
	126	* Callers are expected to set up input_dev->dev.parent before calling this
	127	* function.
1932811f DT	128	*/
	129	int matrix_keypad_build_keymap(const struct matrix_keymap_data *keymap_data,
	130	const char *keymap_name,
	131	unsigned int rows, unsigned int cols,
	132	unsigned short *keymap,
	133	struct input_dev *input_dev)
	134	{
	135	unsigned int row_shift = get_count_order(cols);
	136	int i;
b45c8f35	137	int error;
1932811f DT	138
	139	input_dev->keycode = keymap;
	140	input_dev->keycodesize = sizeof(*keymap);
	141	input_dev->keycodemax = rows << row_shift;
	142
	143	__set_bit(EV_KEY, input_dev->evbit);
	144
b45c8f35 DT	145	if (keymap_data) {
	146	for (i = 0; i < keymap_data->keymap_size; i++) {
	147	unsigned int key = keymap_data->keymap[i];
1932811f	148
b45c8f35 DT	149	if (!matrix_keypad_map_key(input_dev, rows, cols,
	150	row_shift, key))
	151	return -EINVAL;
1932811f	152	}
b45c8f35 DT	153	} else {
	154	error = matrix_keypad_parse_of_keymap(keymap_name, rows, cols,
	155	input_dev);
	156	if (error)
	157	return error;
1932811f	158	}
b45c8f35	159
1932811f DT	160	__clear_bit(KEY_RESERVED, input_dev->keybit);
	161
	162	return 0;
	163	}
	164	EXPORT_SYMBOL(matrix_keypad_build_keymap);
55220bb3 FF	165
55220bb3 FF	166	MODULE_LICENSE("GPL");