1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Cirrus Logic CLPS711X Keypad driver |
4 | * |
5 | * Copyright (C) 2014 Alexander Shiyan <shc_work@mail.ru> |
6 | */ |
7 | |
8 | #include <linux/input.h> |
9 | #include <linux/mod_devicetable.h> |
10 | #include <linux/module.h> |
11 | #include <linux/gpio/consumer.h> |
12 | #include <linux/platform_device.h> |
13 | #include <linux/property.h> |
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 | |
34 | static void clps711x_keypad_poll(struct input_dev *input) |
35 | { |
36 | const unsigned short *keycodes = input->keycode; |
37 | struct clps711x_keypad_data *priv = input_get_drvdata(dev: input); |
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(map: 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(desc: data->desc); |
55 | cond_resched(); |
56 | state1 = gpiod_get_value_cansleep(desc: 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(nr: col, addr: data->last_state); |
65 | input_event(dev: input, |
66 | EV_MSC, MSC_SCAN, value: code); |
67 | } else { |
68 | clear_bit(nr: col, addr: data->last_state); |
69 | } |
70 | |
71 | if (keycodes[code]) |
72 | input_report_key(dev: input, |
73 | code: keycodes[code], value: state); |
74 | sync = true; |
75 | } |
76 | } |
77 | |
78 | /* Set all columns to low */ |
79 | regmap_update_bits(map: priv->syscon, SYSCON_OFFSET, |
80 | SYSCON1_KBDSCAN_MASK, SYSCON1_KBDSCAN(1)); |
81 | } |
82 | |
83 | if (sync) |
84 | input_sync(dev: input); |
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; |
91 | struct input_dev *input; |
92 | u32 poll_interval; |
93 | int i, err; |
94 | |
95 | priv = devm_kzalloc(dev, size: sizeof(*priv), GFP_KERNEL); |
96 | if (!priv) |
97 | return -ENOMEM; |
98 | |
99 | priv->syscon = syscon_regmap_lookup_by_phandle(np: dev->of_node, property: "syscon" ); |
100 | if (IS_ERR(ptr: priv->syscon)) |
101 | return PTR_ERR(ptr: priv->syscon); |
102 | |
103 | priv->row_count = gpiod_count(dev, con_id: "row" ); |
104 | if (priv->row_count < 1) |
105 | return -EINVAL; |
106 | |
107 | priv->gpio_data = devm_kcalloc(dev, |
108 | n: priv->row_count, size: sizeof(*priv->gpio_data), |
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 | |
118 | data->desc = devm_gpiod_get_index(dev, con_id: "row" , idx: i, flags: GPIOD_IN); |
119 | if (IS_ERR(ptr: data->desc)) |
120 | return PTR_ERR(ptr: data->desc); |
121 | } |
122 | |
123 | err = device_property_read_u32(dev, propname: "poll-interval" , val: &poll_interval); |
124 | if (err) |
125 | return err; |
126 | |
127 | input = devm_input_allocate_device(dev); |
128 | if (!input) |
129 | return -ENOMEM; |
130 | |
131 | input_set_drvdata(dev: input, data: 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; |
139 | |
140 | err = matrix_keypad_build_keymap(NULL, NULL, rows: priv->row_count, |
141 | CLPS711X_KEYPAD_COL_COUNT, |
142 | NULL, input_dev: input); |
143 | if (err) |
144 | return err; |
145 | |
146 | input_set_capability(dev: input, EV_MSC, MSC_SCAN); |
147 | if (device_property_read_bool(dev, propname: "autorepeat" )) |
148 | __set_bit(EV_REP, input->evbit); |
149 | |
150 | /* Set all columns to low */ |
151 | regmap_update_bits(map: priv->syscon, SYSCON_OFFSET, SYSCON1_KBDSCAN_MASK, |
152 | SYSCON1_KBDSCAN(1)); |
153 | |
154 | |
155 | err = input_setup_polling(dev: input, poll_fn: clps711x_keypad_poll); |
156 | if (err) |
157 | return err; |
158 | |
159 | input_set_poll_interval(dev: input, interval: poll_interval); |
160 | |
161 | err = input_register_device(input); |
162 | if (err) |
163 | return err; |
164 | |
165 | return 0; |
166 | } |
167 | |
168 | static const struct of_device_id clps711x_keypad_of_match[] = { |
169 | { .compatible = "cirrus,ep7209-keypad" , }, |
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" , |
177 | .of_match_table = clps711x_keypad_of_match, |
178 | }, |
179 | .probe = clps711x_keypad_probe, |
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" ); |
186 | |