1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/delay.h>
15#include <linux/gpio/consumer.h>
16#include <linux/i2c.h>
17#include <linux/input.h>
18#include <linux/input/mt.h>
19#include <linux/input/touchscreen.h>
20#include <linux/interrupt.h>
21#include <linux/kernel.h>
22#include <linux/mod_devicetable.h>
23#include <linux/module.h>
24#include <linux/regulator/consumer.h>
25#include <linux/slab.h>
26
27#define MODE_DATA_RAW 0x5A
28
29#define MAX_SUPPORTED_FINGER_NUM 5
30
31#define CHIP_ON_DELAY_MS 15
32#define FIRMWARE_ON_DELAY_MS 50
33#define RESET_DELAY_MIN_US 10000
34#define RESET_DELAY_MAX_US 11000
35
36struct packet {
37 u8 xy_hi;
38 u8 x_low;
39 u8 y_low;
40 u8 pressure;
41};
42
43struct touch_event {
44 u8 mode;
45 struct packet pkt[MAX_SUPPORTED_FINGER_NUM];
46 u8 proximity;
47 u8 checksum;
48};
49
50struct msg2638_ts_data {
51 struct i2c_client *client;
52 struct input_dev *input_dev;
53 struct touchscreen_properties prop;
54 struct regulator_bulk_data supplies[2];
55 struct gpio_desc *reset_gpiod;
56};
57
58static u8 msg2638_checksum(u8 *data, u32 length)
59{
60 s32 sum = 0;
61 u32 i;
62
63 for (i = 0; i < length; i++)
64 sum += data[i];
65
66 return (u8)((-sum) & 0xFF);
67}
68
69static irqreturn_t msg2638_ts_irq_handler(int irq, void *msg2638_handler)
70{
71 struct msg2638_ts_data *msg2638 = msg2638_handler;
72 struct i2c_client *client = msg2638->client;
73 struct input_dev *input = msg2638->input_dev;
74 struct touch_event touch_event;
75 u32 len = sizeof(touch_event);
76 struct i2c_msg msg[] = {
77 {
78 .addr = client->addr,
79 .flags = I2C_M_RD,
80 .len = sizeof(touch_event),
81 .buf = (u8 *)&touch_event,
82 },
83 };
84 struct packet *p;
85 u16 x, y;
86 int ret;
87 int i;
88
89 ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
90 if (ret != ARRAY_SIZE(msg)) {
91 dev_err(&client->dev,
92 "Failed I2C transfer in irq handler: %d\n",
93 ret < 0 ? ret : -EIO);
94 goto out;
95 }
96
97 if (touch_event.mode != MODE_DATA_RAW)
98 goto out;
99
100 if (msg2638_checksum((u8 *)&touch_event, len - 1) !=
101 touch_event.checksum) {
102 dev_err(&client->dev, "Failed checksum!\n");
103 goto out;
104 }
105
106 for (i = 0; i < MAX_SUPPORTED_FINGER_NUM; i++) {
107 p = &touch_event.pkt[i];
108
109
110 if (p->xy_hi == 0xFF && p->x_low == 0xFF && p->y_low == 0xFF)
111 continue;
112
113 x = (((p->xy_hi & 0xF0) << 4) | p->x_low);
114 y = (((p->xy_hi & 0x0F) << 8) | p->y_low);
115
116 input_mt_slot(input, i);
117 input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
118 touchscreen_report_pos(input, &msg2638->prop, x, y, true);
119 }
120
121 input_mt_sync_frame(msg2638->input_dev);
122 input_sync(msg2638->input_dev);
123
124out:
125 return IRQ_HANDLED;
126}
127
128static void msg2638_reset(struct msg2638_ts_data *msg2638)
129{
130 gpiod_set_value_cansleep(msg2638->reset_gpiod, 1);
131 usleep_range(RESET_DELAY_MIN_US, RESET_DELAY_MAX_US);
132 gpiod_set_value_cansleep(msg2638->reset_gpiod, 0);
133 msleep(FIRMWARE_ON_DELAY_MS);
134}
135
136static int msg2638_start(struct msg2638_ts_data *msg2638)
137{
138 int error;
139
140 error = regulator_bulk_enable(ARRAY_SIZE(msg2638->supplies),
141 msg2638->supplies);
142 if (error) {
143 dev_err(&msg2638->client->dev,
144 "Failed to enable regulators: %d\n", error);
145 return error;
146 }
147
148 msleep(CHIP_ON_DELAY_MS);
149
150 msg2638_reset(msg2638);
151
152 enable_irq(msg2638->client->irq);
153
154 return 0;
155}
156
157static int msg2638_stop(struct msg2638_ts_data *msg2638)
158{
159 int error;
160
161 disable_irq(msg2638->client->irq);
162
163 error = regulator_bulk_disable(ARRAY_SIZE(msg2638->supplies),
164 msg2638->supplies);
165 if (error) {
166 dev_err(&msg2638->client->dev,
167 "Failed to disable regulators: %d\n", error);
168 return error;
169 }
170
171 return 0;
172}
173
174static int msg2638_input_open(struct input_dev *dev)
175{
176 struct msg2638_ts_data *msg2638 = input_get_drvdata(dev);
177
178 return msg2638_start(msg2638);
179}
180
181static void msg2638_input_close(struct input_dev *dev)
182{
183 struct msg2638_ts_data *msg2638 = input_get_drvdata(dev);
184
185 msg2638_stop(msg2638);
186}
187
188static int msg2638_init_input_dev(struct msg2638_ts_data *msg2638)
189{
190 struct device *dev = &msg2638->client->dev;
191 struct input_dev *input_dev;
192 int error;
193
194 input_dev = devm_input_allocate_device(dev);
195 if (!input_dev) {
196 dev_err(dev, "Failed to allocate input device.\n");
197 return -ENOMEM;
198 }
199
200 input_set_drvdata(input_dev, msg2638);
201 msg2638->input_dev = input_dev;
202
203 input_dev->name = "MStar TouchScreen";
204 input_dev->phys = "input/ts";
205 input_dev->id.bustype = BUS_I2C;
206 input_dev->open = msg2638_input_open;
207 input_dev->close = msg2638_input_close;
208
209 input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_X);
210 input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_Y);
211
212 touchscreen_parse_properties(input_dev, true, &msg2638->prop);
213 if (!msg2638->prop.max_x || !msg2638->prop.max_y) {
214 dev_err(dev, "touchscreen-size-x and/or touchscreen-size-y not set in properties\n");
215 return -EINVAL;
216 }
217
218 error = input_mt_init_slots(input_dev, MAX_SUPPORTED_FINGER_NUM,
219 INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
220 if (error) {
221 dev_err(dev, "Failed to initialize MT slots: %d\n", error);
222 return error;
223 }
224
225 error = input_register_device(input_dev);
226 if (error) {
227 dev_err(dev, "Failed to register input device: %d\n", error);
228 return error;
229 }
230
231 return 0;
232}
233
234static int msg2638_ts_probe(struct i2c_client *client)
235{
236 struct device *dev = &client->dev;
237 struct msg2638_ts_data *msg2638;
238 int error;
239
240 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
241 dev_err(dev, "Failed to assert adapter's support for plain I2C.\n");
242 return -ENXIO;
243 }
244
245 msg2638 = devm_kzalloc(dev, sizeof(*msg2638), GFP_KERNEL);
246 if (!msg2638)
247 return -ENOMEM;
248
249 msg2638->client = client;
250 i2c_set_clientdata(client, msg2638);
251
252 msg2638->supplies[0].supply = "vdd";
253 msg2638->supplies[1].supply = "vddio";
254 error = devm_regulator_bulk_get(dev, ARRAY_SIZE(msg2638->supplies),
255 msg2638->supplies);
256 if (error) {
257 dev_err(dev, "Failed to get regulators: %d\n", error);
258 return error;
259 }
260
261 msg2638->reset_gpiod = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
262 if (IS_ERR(msg2638->reset_gpiod)) {
263 error = PTR_ERR(msg2638->reset_gpiod);
264 dev_err(dev, "Failed to request reset GPIO: %d\n", error);
265 return error;
266 }
267
268 error = msg2638_init_input_dev(msg2638);
269 if (error) {
270 dev_err(dev, "Failed to initialize input device: %d\n", error);
271 return error;
272 }
273
274 error = devm_request_threaded_irq(dev, client->irq,
275 NULL, msg2638_ts_irq_handler,
276 IRQF_ONESHOT | IRQF_NO_AUTOEN,
277 client->name, msg2638);
278 if (error) {
279 dev_err(dev, "Failed to request IRQ: %d\n", error);
280 return error;
281 }
282
283 return 0;
284}
285
286static int __maybe_unused msg2638_suspend(struct device *dev)
287{
288 struct i2c_client *client = to_i2c_client(dev);
289 struct msg2638_ts_data *msg2638 = i2c_get_clientdata(client);
290
291 mutex_lock(&msg2638->input_dev->mutex);
292
293 if (input_device_enabled(msg2638->input_dev))
294 msg2638_stop(msg2638);
295
296 mutex_unlock(&msg2638->input_dev->mutex);
297
298 return 0;
299}
300
301static int __maybe_unused msg2638_resume(struct device *dev)
302{
303 struct i2c_client *client = to_i2c_client(dev);
304 struct msg2638_ts_data *msg2638 = i2c_get_clientdata(client);
305 int ret = 0;
306
307 mutex_lock(&msg2638->input_dev->mutex);
308
309 if (input_device_enabled(msg2638->input_dev))
310 ret = msg2638_start(msg2638);
311
312 mutex_unlock(&msg2638->input_dev->mutex);
313
314 return ret;
315}
316
317static SIMPLE_DEV_PM_OPS(msg2638_pm_ops, msg2638_suspend, msg2638_resume);
318
319static const struct of_device_id msg2638_of_match[] = {
320 { .compatible = "mstar,msg2638" },
321 { }
322};
323MODULE_DEVICE_TABLE(of, msg2638_of_match);
324
325static struct i2c_driver msg2638_ts_driver = {
326 .probe_new = msg2638_ts_probe,
327 .driver = {
328 .name = "MStar-TS",
329 .pm = &msg2638_pm_ops,
330 .of_match_table = msg2638_of_match,
331 },
332};
333module_i2c_driver(msg2638_ts_driver);
334
335MODULE_AUTHOR("Vincent Knecht <vincent.knecht@mailoo.org>");
336MODULE_DESCRIPTION("MStar MSG2638 touchscreen driver");
337MODULE_LICENSE("GPL v2");
338
