adp5585-keys.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Analog Devices ADP5585 Keys driver
  4 *
  5 * Copyright (C) 2025 Analog Devices, Inc.
  6 */
  7
  8#include <linux/bitmap.h>
  9#include <linux/container_of.h>
 10#include <linux/device.h>
 11#include <linux/find.h>
 12#include <linux/input.h>
 13#include <linux/input/matrix_keypad.h>
 14#include <linux/mfd/adp5585.h>
 15#include <linux/module.h>
 16#include <linux/mod_devicetable.h>
 17#include <linux/notifier.h>
 18#include <linux/platform_device.h>
 19#include <linux/property.h>
 20#include <linux/regmap.h>
 21#include <linux/types.h>
 22
 23/* As needed for the matrix parsing code */
 24#define ADP5589_MAX_KEYMAPSIZE		123
 25
 26struct adp5585_kpad_chip {
 27	u8 key_ev_min;
 28	u8 key_ev_max;
 29	u8 max_rows;
 30	u8 max_cols;
 31};
 32
 33struct adp5585_kpad {
 34	const struct adp5585_kpad_chip *info;
 35	struct notifier_block nb;
 36	struct input_dev *input;
 37	unsigned short keycode[ADP5589_MAX_KEYMAPSIZE];
 38	struct device *dev;
 39	unsigned long keypad;
 40	int row_shift;
 41};
 42
 43static int adp5585_keys_validate_events(const struct adp5585_kpad *kpad,
 44					const u32 *events, u32 n_events)
 45{
 46	unsigned int ev;
 47	u32 row, col;
 48
 49	for (ev = 0; ev < n_events; ev++) {
 50		if (events[ev] < kpad->info->key_ev_min ||
 51		    events[ev] > kpad->info->key_ev_max)
 52			continue;
 53
 54		/*
 55		 * if the event is to be generated by the keymap, we need to make
 56		 * sure that the pins are part of it!
 57		 */
 58		row = (events[ev] - 1) / kpad->info->max_cols;
 59		col = (events[ev] - 1) % kpad->info->max_cols;
 60
 61		if (test_bit(row, &kpad->keypad) &&
 62		    test_bit(col + kpad->info->max_rows, &kpad->keypad))
 63			continue;
 64
 65		return dev_err_probe(kpad->dev, -EINVAL,
 66				     "Invalid unlock/reset event(%u) not used in the keypad\n",
 67				     events[ev]);
 68	}
 69
 70	return 0;
 71}
 72
 73static int adp5585_keys_check_special_events(const struct adp5585_dev *adp5585,
 74					     const struct adp5585_kpad *kpad)
 75{
 76	int error;
 77
 78	error = adp5585_keys_validate_events(kpad, adp5585->unlock_keys,
 79					     adp5585->nkeys_unlock);
 80	if (error)
 81		return error;
 82
 83	error = adp5585_keys_validate_events(kpad, adp5585->reset1_keys,
 84					     adp5585->nkeys_reset1);
 85	if (error)
 86		return error;
 87
 88	return adp5585_keys_validate_events(kpad, adp5585->reset2_keys,
 89					    adp5585->nkeys_reset2);
 90}
 91
 92static void adp5585_keys_pins_free(void *data)
 93{
 94	struct adp5585_kpad *kpad = data;
 95	struct adp5585_dev *adp5585 = dev_get_drvdata(kpad->dev->parent);
 96	unsigned int pin;
 97
 98	for_each_set_bit(pin, &kpad->keypad, adp5585->n_pins)
 99		clear_bit(pin, adp5585->pin_usage);
100}
101
102static int adp5585_keys_parse_fw(const struct adp5585_dev *adp5585,
103				 struct adp5585_kpad *kpad)
104{
105	struct device *dev = kpad->dev;
106	u32 cols = 0, rows = 0, pin;
107	int error, n_pins;
108
109	/*
110	 * We do not check for errors (or no value) since the input device is
111	 * only added if this property is present in the first place.
112	 */
113	n_pins = device_property_count_u32(dev, "adi,keypad-pins");
114	if (n_pins > adp5585->n_pins)
115		return dev_err_probe(dev, -EINVAL,
116				     "Too many keypad pins (%d) defined (max=%d)\n",
117				     n_pins, adp5585->n_pins);
118
119	unsigned int *keypad_pins __free(kfree) = kcalloc(n_pins, sizeof(*keypad_pins),
120							  GFP_KERNEL);
121	if (!keypad_pins)
122		return -ENOMEM;
123
124	error = device_property_read_u32_array(dev, "adi,keypad-pins",
125					       keypad_pins, n_pins);
126	if (error)
127		return error;
128
129	/*
130	 * We can add the action here since it makes the code easier and nothing
131	 * "bad" will happen out of it. Worst case, it will be a no-op and no
132	 * bit will set.
133	 */
134	error = devm_add_action_or_reset(dev, adp5585_keys_pins_free, kpad);
135	if (error)
136		return error;
137
138	for (pin = 0; pin < n_pins; pin++) {
139		if (keypad_pins[pin] >= adp5585->n_pins)
140			return dev_err_probe(dev, -EINVAL,
141					     "Invalid keypad pin(%u) defined\n",
142					     keypad_pins[pin]);
143
144		if (test_and_set_bit(keypad_pins[pin], adp5585->pin_usage))
145			return dev_err_probe(dev, -EBUSY,
146					     "Keypad pin(%u) already used\n",
147					     keypad_pins[pin]);
148
149		__set_bit(keypad_pins[pin], &kpad->keypad);
150	}
151
152	/*
153	 * Note that given that we get a mask (and the HW allows it), we
154	 * can have holes in our keypad (eg: row0, row1 and row7 enabled).
155	 * However, for the matrix parsing functions we need to pass the
156	 * number of rows/cols as the maximum row/col used plus 1. This
157	 * pretty much means we will also have holes in our SW keypad.
158	 */
159
160	rows = find_last_bit(&kpad->keypad, kpad->info->max_rows) + 1;
161	if (rows == kpad->info->max_rows + 1)
162		return dev_err_probe(dev, -EINVAL,
163				     "Now rows defined in the keypad!\n");
164
165	cols = find_last_bit(&kpad->keypad, kpad->info->max_cols + kpad->info->max_rows);
166	if (cols < kpad->info->max_rows)
167		return dev_err_probe(dev, -EINVAL,
168				     "No columns defined in the keypad!\n");
169
170	cols = cols + 1 - kpad->info->max_rows;
171
172	error = matrix_keypad_build_keymap(NULL, NULL, rows, cols,
173					   kpad->keycode, kpad->input);
174	if (error)
175		return error;
176
177	kpad->row_shift = get_count_order(cols);
178
179	if (device_property_read_bool(kpad->dev, "autorepeat"))
180		__set_bit(EV_REP, kpad->input->evbit);
181
182	error = adp5585_keys_check_special_events(adp5585, kpad);
183	if (error)
184		return error;
185
186	return 0;
187}
188
189static int adp5585_keys_setup(const struct adp5585_dev *adp5585,
190			      struct adp5585_kpad *kpad)
191{
192	unsigned long keys_bits, start = 0, nbits = kpad->info->max_rows;
193	const struct adp5585_regs *regs = adp5585->regs;
194	unsigned int i = 0, max_cols = kpad->info->max_cols;
195	int error;
196
197	/*
198	 * Take care as the below assumes max_rows is always less or equal than
199	 * 8 which is true for the supported devices. If we happen to add
200	 * another device we need to make sure this still holds true. Although
201	 * adding a new device is very unlikely.
202	 */
203	do {
204		keys_bits = bitmap_read(&kpad->keypad, start, nbits);
205		if (keys_bits) {
206			error = regmap_write(adp5585->regmap, regs->pin_cfg_a + i,
207					     keys_bits);
208			if (error)
209				return error;
210		}
211
212		start += nbits;
213		if (max_cols > 8) {
214			nbits = 8;
215			max_cols -= nbits;
216		} else {
217			nbits = max_cols;
218		}
219
220		i++;
221	} while (start < kpad->info->max_rows + kpad->info->max_cols);
222
223	return 0;
224}
225
226static int adp5585_keys_ev_handle(struct notifier_block *nb, unsigned long key,
227				  void *data)
228{
229	struct adp5585_kpad *kpad = container_of(nb, struct adp5585_kpad, nb);
230	unsigned long key_press = (unsigned long)data;
231	unsigned int row, col, code;
232
233	/* make sure the event is for us */
234	if (key < kpad->info->key_ev_min || key > kpad->info->key_ev_max)
235		return NOTIFY_DONE;
236
237	/*
238	 * Unlikely but lets be on the safe side! We do not return any error
239	 * because the event was indeed for us but with some weird value. So,
240	 * we still want the caller know that the right handler was called.
241	 */
242	if (!key)
243		return NOTIFY_BAD;
244
245	row = (key - 1) / (kpad->info->max_cols);
246	col = (key - 1) % (kpad->info->max_cols);
247	code = MATRIX_SCAN_CODE(row, col, kpad->row_shift);
248
249	dev_dbg_ratelimited(kpad->dev, "report key(%lu) r(%d) c(%d) code(%d)\n",
250			    key, row, col, kpad->keycode[code]);
251
252	input_report_key(kpad->input, kpad->keycode[code], key_press);
253	input_sync(kpad->input);
254
255	return NOTIFY_STOP;
256}
257
258static void adp5585_keys_unreg_notifier(void *data)
259{
260	struct adp5585_kpad *kpad = data;
261	struct adp5585_dev *adp5585 = dev_get_drvdata(kpad->dev->parent);
262
263	blocking_notifier_chain_unregister(&adp5585->event_notifier,
264					   &kpad->nb);
265}
266
267static int adp5585_keys_probe(struct platform_device *pdev)
268{
269	const struct platform_device_id *id = platform_get_device_id(pdev);
270	struct adp5585_dev *adp5585 = dev_get_drvdata(pdev->dev.parent);
271	struct device *dev = &pdev->dev;
272	struct adp5585_kpad *kpad;
273	unsigned int revid;
274	const char *phys;
275	int error;
276
277	kpad = devm_kzalloc(dev, sizeof(*kpad), GFP_KERNEL);
278	if (!kpad)
279		return -ENOMEM;
280
281	if (!adp5585->irq)
282		return dev_err_probe(dev, -EINVAL,
283				     "IRQ is mandatory for the keypad\n");
284
285	kpad->dev = dev;
286
287	kpad->input = devm_input_allocate_device(dev);
288	if (!kpad->input)
289		return -ENOMEM;
290
291	kpad->info = (const struct adp5585_kpad_chip *)id->driver_data;
292	if (!kpad->info)
293		return -ENODEV;
294
295	error = regmap_read(adp5585->regmap, ADP5585_ID, &revid);
296	if (error)
297		return dev_err_probe(dev, error, "Failed to read device ID\n");
298
299	phys = devm_kasprintf(dev, GFP_KERNEL, "%s/input0", pdev->name);
300	if (!phys)
301		return -ENOMEM;
302
303	kpad->input->name = pdev->name;
304	kpad->input->phys = phys;
305
306	kpad->input->id.bustype = BUS_I2C;
307	kpad->input->id.vendor = 0x0001;
308	kpad->input->id.product = 0x0001;
309	kpad->input->id.version = revid & ADP5585_REV_ID_MASK;
310
311	device_set_of_node_from_dev(dev, dev->parent);
312
313	error = adp5585_keys_parse_fw(adp5585, kpad);
314	if (error)
315		return error;
316
317	error = adp5585_keys_setup(adp5585, kpad);
318	if (error)
319		return error;
320
321	kpad->nb.notifier_call = adp5585_keys_ev_handle;
322	error = blocking_notifier_chain_register(&adp5585->event_notifier,
323						 &kpad->nb);
324	if (error)
325		return error;
326
327	error = devm_add_action_or_reset(dev, adp5585_keys_unreg_notifier, kpad);
328	if (error)
329		return error;
330
331	error = input_register_device(kpad->input);
332	if (error)
333		return dev_err_probe(dev, error,
334				     "Failed to register input device\n");
335
336	return 0;
337}
338
339static const struct adp5585_kpad_chip adp5585_kpad_chip_info = {
340	.max_rows = 6,
341	.max_cols = 5,
342	.key_ev_min = ADP5585_ROW5_KEY_EVENT_START,
343	.key_ev_max = ADP5585_ROW5_KEY_EVENT_END,
344};
345
346static const struct adp5585_kpad_chip adp5589_kpad_chip_info = {
347	.max_rows = 8,
348	.max_cols = 11,
349	.key_ev_min = ADP5589_KEY_EVENT_START,
350	.key_ev_max = ADP5589_KEY_EVENT_END,
351};
352
353static const struct platform_device_id adp5585_keys_id_table[] = {
354	{ "adp5585-keys", (kernel_ulong_t)&adp5585_kpad_chip_info },
355	{ "adp5589-keys", (kernel_ulong_t)&adp5589_kpad_chip_info },
356	{ }
357};
358MODULE_DEVICE_TABLE(platform, adp5585_keys_id_table);
359
360static struct platform_driver adp5585_keys_driver = {
361	.driver	= {
362		.name = "adp5585-keys",
363	},
364	.probe = adp5585_keys_probe,
365	.id_table = adp5585_keys_id_table,
366};
367module_platform_driver(adp5585_keys_driver);
368
369MODULE_AUTHOR("Nuno Sá <nuno.sa@analog.com>");
370MODULE_DESCRIPTION("ADP5585 Keys Driver");
371MODULE_LICENSE("GPL");