[linux-2.6-block.git] / drivers / input / keyboard / clps711x-keypad.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Cirrus Logic CLPS711X Keypad driver
 *
 * Copyright (C) 2014 Alexander Shiyan <shc_work@mail.ru>
 */

#include <linux/input.h>
#include <linux/mod_devicetable.h>
#include <linux/module.h>
#include <linux/gpio/consumer.h>
#include <linux/platform_device.h>
#include <linux/property.h>
#include <linux/regmap.h>
#include <linux/sched.h>
#include <linux/input/matrix_keypad.h>
#include <linux/mfd/syscon.h>
#include <linux/mfd/syscon/clps711x.h>

#define CLPS711X_KEYPAD_COL_COUNT	8

struct clps711x_gpio_data {
	struct gpio_desc *desc;
	DECLARE_BITMAP(last_state, CLPS711X_KEYPAD_COL_COUNT);
};

struct clps711x_keypad_data {
	struct regmap			*syscon;
	int				row_count;
	unsigned int			row_shift;
	struct clps711x_gpio_data	*gpio_data;
};

static void clps711x_keypad_poll(struct input_dev *input)
{
	const unsigned short *keycodes = input->keycode;
	struct clps711x_keypad_data *priv = input_get_drvdata(input);
	bool sync = false;
	int col, row;

	for (col = 0; col < CLPS711X_KEYPAD_COL_COUNT; col++) {
		/* Assert column */
		regmap_update_bits(priv->syscon, SYSCON_OFFSET,
				   SYSCON1_KBDSCAN_MASK,
				   SYSCON1_KBDSCAN(8 + col));

		/* Scan rows */
		for (row = 0; row < priv->row_count; row++) {
			struct clps711x_gpio_data *data = &priv->gpio_data[row];
			bool state, state1;

			/* Read twice for protection against fluctuations */
			do {
				state = gpiod_get_value_cansleep(data->desc);
				cond_resched();
				state1 = gpiod_get_value_cansleep(data->desc);
			} while (state != state1);

			if (test_bit(col, data->last_state) != state) {
				int code = MATRIX_SCAN_CODE(row, col,
							    priv->row_shift);

				if (state) {
					set_bit(col, data->last_state);
					input_event(input,
						    EV_MSC, MSC_SCAN, code);
				} else {
					clear_bit(col, data->last_state);
				}

				if (keycodes[code])
					input_report_key(input,
							 keycodes[code], state);
				sync = true;
			}
		}

		/* Set all columns to low */
		regmap_update_bits(priv->syscon, SYSCON_OFFSET,
				   SYSCON1_KBDSCAN_MASK, SYSCON1_KBDSCAN(1));
	}

	if (sync)
		input_sync(input);
}

static int clps711x_keypad_probe(struct platform_device *pdev)
{
	struct clps711x_keypad_data *priv;
	struct device *dev = &pdev->dev;
	struct input_dev *input;
	u32 poll_interval;
	int i, err;

	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	priv->syscon = syscon_regmap_lookup_by_phandle(dev->of_node, "syscon");
	if (IS_ERR(priv->syscon))
		return PTR_ERR(priv->syscon);

	priv->row_count = gpiod_count(dev, "row");
	if (priv->row_count < 1)
		return -EINVAL;

	priv->gpio_data = devm_kcalloc(dev,
				priv->row_count, sizeof(*priv->gpio_data),
				GFP_KERNEL);
	if (!priv->gpio_data)
		return -ENOMEM;

	priv->row_shift = get_count_order(CLPS711X_KEYPAD_COL_COUNT);

	for (i = 0; i < priv->row_count; i++) {
		struct clps711x_gpio_data *data = &priv->gpio_data[i];

		data->desc = devm_gpiod_get_index(dev, "row", i, GPIOD_IN);
		if (IS_ERR(data->desc))
			return PTR_ERR(data->desc);
	}

	err = device_property_read_u32(dev, "poll-interval", &poll_interval);
	if (err)
		return err;

	input = devm_input_allocate_device(dev);
	if (!input)
		return -ENOMEM;

	input_set_drvdata(input, priv);

	input->name		= pdev->name;
	input->dev.parent	= dev;
	input->id.bustype	= BUS_HOST;
	input->id.vendor	= 0x0001;
	input->id.product	= 0x0001;
	input->id.version	= 0x0100;

	err = matrix_keypad_build_keymap(NULL, NULL, priv->row_count,
					 CLPS711X_KEYPAD_COL_COUNT,
					 NULL, input);
	if (err)
		return err;

	input_set_capability(input, EV_MSC, MSC_SCAN);
	if (device_property_read_bool(dev, "autorepeat"))
		__set_bit(EV_REP, input->evbit);

	/* Set all columns to low */
	regmap_update_bits(priv->syscon, SYSCON_OFFSET, SYSCON1_KBDSCAN_MASK,
			   SYSCON1_KBDSCAN(1));


	err = input_setup_polling(input, clps711x_keypad_poll);
	if (err)
		return err;

	input_set_poll_interval(input, poll_interval);

	err = input_register_device(input);
	if (err)
		return err;

	return 0;
}

static const struct of_device_id clps711x_keypad_of_match[] = {
	{ .compatible = "cirrus,ep7209-keypad", },
	{ }
};
MODULE_DEVICE_TABLE(of, clps711x_keypad_of_match);

static struct platform_driver clps711x_keypad_driver = {
	.driver	= {
		.name		= "clps711x-keypad",
		.of_match_table	= clps711x_keypad_of_match,
	},
	.probe	= clps711x_keypad_probe,
};
module_platform_driver(clps711x_keypad_driver);

MODULE_AUTHOR("Alexander Shiyan <shc_work@mail.ru>");
MODULE_DESCRIPTION("Cirrus Logic CLPS711X Keypad driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
e70f18e1 AS	2	/*
	3	* Cirrus Logic CLPS711X Keypad driver
	4	*
	5	* Copyright (C) 2014 Alexander Shiyan <shc_work@mail.ru>
e70f18e1 AS	6	*/
	7
	8	#include <linux/input.h>
c5872d6a	9	#include <linux/mod_devicetable.h>
e70f18e1	10	#include <linux/module.h>
c5872d6a	11	#include <linux/gpio/consumer.h>
e70f18e1	12	#include <linux/platform_device.h>
c5872d6a	13	#include <linux/property.h>
e70f18e1 AS	14	#include <linux/regmap.h>
	15	#include <linux/sched.h>
	16	#include <linux/input/matrix_keypad.h>
	17	#include <linux/mfd/syscon.h>
	18	#include <linux/mfd/syscon/clps711x.h>
	19
	20	#define CLPS711X_KEYPAD_COL_COUNT 8
	21
	22	struct clps711x_gpio_data {
	23	struct gpio_desc *desc;
	24	DECLARE_BITMAP(last_state, CLPS711X_KEYPAD_COL_COUNT);
	25	};
	26
	27	struct clps711x_keypad_data {
	28	struct regmap *syscon;
	29	int row_count;
	30	unsigned int row_shift;
	31	struct clps711x_gpio_data *gpio_data;
	32	};
	33
ea6c52ae	34	static void clps711x_keypad_poll(struct input_dev *input)
e70f18e1	35	{
ea6c52ae DT	36	const unsigned short *keycodes = input->keycode;
ea6c52ae DT	37	struct clps711x_keypad_data *priv = input_get_drvdata(input);
e70f18e1 AS	38	bool sync = false;
	39	int col, row;
	40
	41	for (col = 0; col < CLPS711X_KEYPAD_COL_COUNT; col++) {
	42	/* Assert column */
	43	regmap_update_bits(priv->syscon, SYSCON_OFFSET,
	44	SYSCON1_KBDSCAN_MASK,
	45	SYSCON1_KBDSCAN(8 + col));
	46
	47	/* Scan rows */
	48	for (row = 0; row < priv->row_count; row++) {
	49	struct clps711x_gpio_data *data = &priv->gpio_data[row];
	50	bool state, state1;
	51
	52	/* Read twice for protection against fluctuations */
	53	do {
	54	state = gpiod_get_value_cansleep(data->desc);
	55	cond_resched();
	56	state1 = gpiod_get_value_cansleep(data->desc);
	57	} while (state != state1);
	58
	59	if (test_bit(col, data->last_state) != state) {
	60	int code = MATRIX_SCAN_CODE(row, col,
	61	priv->row_shift);
	62
	63	if (state) {
	64	set_bit(col, data->last_state);
ea6c52ae DT	65	input_event(input,
ea6c52ae DT	66	EV_MSC, MSC_SCAN, code);
e70f18e1 AS	67	} else {
	68	clear_bit(col, data->last_state);
	69	}
	70
	71	if (keycodes[code])
ea6c52ae	72	input_report_key(input,
e70f18e1 AS	73	keycodes[code], state);
	74	sync = true;
	75	}
	76	}
	77
	78	/* Set all columns to low */
	79	regmap_update_bits(priv->syscon, SYSCON_OFFSET,
	80	SYSCON1_KBDSCAN_MASK, SYSCON1_KBDSCAN(1));
	81	}
	82
	83	if (sync)
ea6c52ae	84	input_sync(input);
e70f18e1 AS	85	}
	86
	87	static int clps711x_keypad_probe(struct platform_device *pdev)
	88	{
	89	struct clps711x_keypad_data *priv;
	90	struct device *dev = &pdev->dev;
ea6c52ae	91	struct input_dev *input;
e70f18e1 AS	92	u32 poll_interval;
	93	int i, err;
	94
	95	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
	96	if (!priv)
	97	return -ENOMEM;
	98
c5872d6a	99	priv->syscon = syscon_regmap_lookup_by_phandle(dev->of_node, "syscon");
e70f18e1 AS	100	if (IS_ERR(priv->syscon))
	101	return PTR_ERR(priv->syscon);
	102
c5872d6a	103	priv->row_count = gpiod_count(dev, "row");
e70f18e1 AS	104	if (priv->row_count < 1)
	105	return -EINVAL;
	106
a86854d0 KC	107	priv->gpio_data = devm_kcalloc(dev,
a86854d0 KC	108	priv->row_count, sizeof(*priv->gpio_data),
e70f18e1 AS	109	GFP_KERNEL);
	110	if (!priv->gpio_data)
	111	return -ENOMEM;
	112
	113	priv->row_shift = get_count_order(CLPS711X_KEYPAD_COL_COUNT);
	114
	115	for (i = 0; i < priv->row_count; i++) {
	116	struct clps711x_gpio_data *data = &priv->gpio_data[i];
	117
ea0afac4	118	data->desc = devm_gpiod_get_index(dev, "row", i, GPIOD_IN);
e70f18e1 AS	119	if (IS_ERR(data->desc))
e70f18e1 AS	120	return PTR_ERR(data->desc);
e70f18e1 AS	121	}
e70f18e1 AS	122
c5872d6a	123	err = device_property_read_u32(dev, "poll-interval", &poll_interval);
e70f18e1 AS	124	if (err)
	125	return err;
	126
ea6c52ae DT	127	input = devm_input_allocate_device(dev);
ea6c52ae DT	128	if (!input)
e70f18e1 AS	129	return -ENOMEM;
e70f18e1 AS	130
ea6c52ae DT	131	input_set_drvdata(input, priv);
	132
	133	input->name = pdev->name;
	134	input->dev.parent = dev;
	135	input->id.bustype = BUS_HOST;
	136	input->id.vendor = 0x0001;
	137	input->id.product = 0x0001;
	138	input->id.version = 0x0100;
e70f18e1 AS	139
	140	err = matrix_keypad_build_keymap(NULL, NULL, priv->row_count,
	141	CLPS711X_KEYPAD_COL_COUNT,
ea6c52ae	142	NULL, input);
e70f18e1	143	if (err)
ea6c52ae	144	return err;
e70f18e1	145
ea6c52ae	146	input_set_capability(input, EV_MSC, MSC_SCAN);
c5872d6a	147	if (device_property_read_bool(dev, "autorepeat"))
ea6c52ae	148	__set_bit(EV_REP, input->evbit);
e70f18e1 AS	149
	150	/* Set all columns to low */
	151	regmap_update_bits(priv->syscon, SYSCON_OFFSET, SYSCON1_KBDSCAN_MASK,
	152	SYSCON1_KBDSCAN(1));
	153
e70f18e1	154
ea6c52ae DT	155	err = input_setup_polling(input, clps711x_keypad_poll);
	156	if (err)
	157	return err;
e70f18e1	158
ea6c52ae	159	input_set_poll_interval(input, poll_interval);
e70f18e1	160
ea6c52ae DT	161	err = input_register_device(input);
	162	if (err)
	163	return err;
e70f18e1 AS	164
	165	return 0;
	166	}
	167
af4cf6d3	168	static const struct of_device_id clps711x_keypad_of_match[] = {
e7c38f22	169	{ .compatible = "cirrus,ep7209-keypad", },
e70f18e1 AS	170	{ }
	171	};
	172	MODULE_DEVICE_TABLE(of, clps711x_keypad_of_match);
	173
	174	static struct platform_driver clps711x_keypad_driver = {
	175	.driver = {
	176	.name = "clps711x-keypad",
e70f18e1 AS	177	.of_match_table = clps711x_keypad_of_match,
	178	},
	179	.probe = clps711x_keypad_probe,
e70f18e1 AS	180	};
	181	module_platform_driver(clps711x_keypad_driver);
	182
	183	MODULE_AUTHOR("Alexander Shiyan <shc_work@mail.ru>");
	184	MODULE_DESCRIPTION("Cirrus Logic CLPS711X Keypad driver");
	185	MODULE_LICENSE("GPL");