Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0-only
2
3#include <linux/delay.h>
4#include <linux/i2c.h>
5#include <linux/input.h>
6#include <linux/input/mt.h>
7#include <linux/input/touchscreen.h>
8#include <linux/interrupt.h>
9#include <linux/irq.h>
10#include <linux/kernel.h>
11#include <linux/module.h>
12#include <linux/of.h>
13#include <linux/regulator/consumer.h>
14#include <linux/slab.h>
15
16/* Register Map */
17
18#define BT541_SWRESET_CMD 0x0000
19#define BT541_WAKEUP_CMD 0x0001
20
21#define BT541_IDLE_CMD 0x0004
22#define BT541_SLEEP_CMD 0x0005
23
24#define BT541_CLEAR_INT_STATUS_CMD 0x0003
25#define BT541_CALIBRATE_CMD 0x0006
26#define BT541_SAVE_STATUS_CMD 0x0007
27#define BT541_SAVE_CALIBRATION_CMD 0x0008
28#define BT541_RECALL_FACTORY_CMD 0x000f
29
30#define BT541_THRESHOLD 0x0020
31
32#define BT541_LARGE_PALM_REJECT_AREA_TH 0x003F
33
34#define BT541_DEBUG_REG 0x0115 /* 0~7 */
35
36#define BT541_TOUCH_MODE 0x0010
37#define BT541_CHIP_REVISION 0x0011
38#define BT541_FIRMWARE_VERSION 0x0012
39
40#define ZINITIX_USB_DETECT 0x116
41
42#define BT541_MINOR_FW_VERSION 0x0121
43
44#define BT541_VENDOR_ID 0x001C
45#define BT541_HW_ID 0x0014
46
47#define BT541_DATA_VERSION_REG 0x0013
48#define BT541_SUPPORTED_FINGER_NUM 0x0015
49#define BT541_EEPROM_INFO 0x0018
50#define BT541_INITIAL_TOUCH_MODE 0x0019
51
52#define BT541_TOTAL_NUMBER_OF_X 0x0060
53#define BT541_TOTAL_NUMBER_OF_Y 0x0061
54
55#define BT541_DELAY_RAW_FOR_HOST 0x007f
56
57#define BT541_BUTTON_SUPPORTED_NUM 0x00B0
58#define BT541_BUTTON_SENSITIVITY 0x00B2
59#define BT541_DUMMY_BUTTON_SENSITIVITY 0X00C8
60
61#define BT541_X_RESOLUTION 0x00C0
62#define BT541_Y_RESOLUTION 0x00C1
63
64#define BT541_POINT_STATUS_REG 0x0080
65#define BT541_ICON_STATUS_REG 0x00AA
66
67#define BT541_POINT_COORD_REG (BT541_POINT_STATUS_REG + 2)
68
69#define BT541_AFE_FREQUENCY 0x0100
70#define BT541_DND_N_COUNT 0x0122
71#define BT541_DND_U_COUNT 0x0135
72
73#define BT541_RAWDATA_REG 0x0200
74
75#define BT541_EEPROM_INFO_REG 0x0018
76
77#define BT541_INT_ENABLE_FLAG 0x00f0
78#define BT541_PERIODICAL_INTERRUPT_INTERVAL 0x00f1
79
80#define BT541_BTN_WIDTH 0x016d
81
82#define BT541_CHECKSUM_RESULT 0x012c
83
84#define BT541_INIT_FLASH 0x01d0
85#define BT541_WRITE_FLASH 0x01d1
86#define BT541_READ_FLASH 0x01d2
87
88#define ZINITIX_INTERNAL_FLAG_02 0x011e
89#define ZINITIX_INTERNAL_FLAG_03 0x011f
90
91#define ZINITIX_I2C_CHECKSUM_WCNT 0x016a
92#define ZINITIX_I2C_CHECKSUM_RESULT 0x016c
93
94/* Interrupt & status register flags */
95
96#define BIT_PT_CNT_CHANGE BIT(0)
97#define BIT_DOWN BIT(1)
98#define BIT_MOVE BIT(2)
99#define BIT_UP BIT(3)
100#define BIT_PALM BIT(4)
101#define BIT_PALM_REJECT BIT(5)
102#define BIT_RESERVED_0 BIT(6)
103#define BIT_RESERVED_1 BIT(7)
104#define BIT_WEIGHT_CHANGE BIT(8)
105#define BIT_PT_NO_CHANGE BIT(9)
106#define BIT_REJECT BIT(10)
107#define BIT_PT_EXIST BIT(11)
108#define BIT_RESERVED_2 BIT(12)
109#define BIT_ERROR BIT(13)
110#define BIT_DEBUG BIT(14)
111#define BIT_ICON_EVENT BIT(15)
112
113#define SUB_BIT_EXIST BIT(0)
114#define SUB_BIT_DOWN BIT(1)
115#define SUB_BIT_MOVE BIT(2)
116#define SUB_BIT_UP BIT(3)
117#define SUB_BIT_UPDATE BIT(4)
118#define SUB_BIT_WAIT BIT(5)
119
120#define DEFAULT_TOUCH_POINT_MODE 2
121#define MAX_SUPPORTED_FINGER_NUM 5
122
123#define CHIP_ON_DELAY 15 // ms
124#define FIRMWARE_ON_DELAY 40 // ms
125
126struct point_coord {
127 __le16 x;
128 __le16 y;
129 u8 width;
130 u8 sub_status;
131 // currently unused, but needed as padding:
132 u8 minor_width;
133 u8 angle;
134};
135
136struct touch_event {
137 __le16 status;
138 u8 finger_cnt;
139 u8 time_stamp;
140 struct point_coord point_coord[MAX_SUPPORTED_FINGER_NUM];
141};
142
143struct bt541_ts_data {
144 struct i2c_client *client;
145 struct input_dev *input_dev;
146 struct touchscreen_properties prop;
147 struct regulator_bulk_data supplies[2];
148 u32 zinitix_mode;
149};
150
151static int zinitix_read_data(struct i2c_client *client,
152 u16 reg, void *values, size_t length)
153{
154 __le16 reg_le = cpu_to_le16(reg);
155 int ret;
156
157 /* A single i2c_transfer() transaction does not work here. */
158 ret = i2c_master_send(client, (u8 *)®_le, sizeof(reg_le));
159 if (ret != sizeof(reg_le))
160 return ret < 0 ? ret : -EIO;
161
162 ret = i2c_master_recv(client, (u8 *)values, length);
163 if (ret != length)
164 return ret < 0 ? ret : -EIO;
165
166 return 0;
167}
168
169static int zinitix_write_u16(struct i2c_client *client, u16 reg, u16 value)
170{
171 __le16 packet[2] = {cpu_to_le16(reg), cpu_to_le16(value)};
172 int ret;
173
174 ret = i2c_master_send(client, (u8 *)packet, sizeof(packet));
175 if (ret != sizeof(packet))
176 return ret < 0 ? ret : -EIO;
177
178 return 0;
179}
180
181static int zinitix_write_cmd(struct i2c_client *client, u16 reg)
182{
183 __le16 reg_le = cpu_to_le16(reg);
184 int ret;
185
186 ret = i2c_master_send(client, (u8 *)®_le, sizeof(reg_le));
187 if (ret != sizeof(reg_le))
188 return ret < 0 ? ret : -EIO;
189
190 return 0;
191}
192
193static int zinitix_init_touch(struct bt541_ts_data *bt541)
194{
195 struct i2c_client *client = bt541->client;
196 int i;
197 int error;
198
199 error = zinitix_write_cmd(client, BT541_SWRESET_CMD);
200 if (error) {
201 dev_err(&client->dev, "Failed to write reset command\n");
202 return error;
203 }
204
205 error = zinitix_write_u16(client, BT541_INT_ENABLE_FLAG, 0x0);
206 if (error) {
207 dev_err(&client->dev,
208 "Failed to reset interrupt enable flag\n");
209 return error;
210 }
211
212 /* initialize */
213 error = zinitix_write_u16(client, BT541_X_RESOLUTION,
214 bt541->prop.max_x);
215 if (error)
216 return error;
217
218 error = zinitix_write_u16(client, BT541_Y_RESOLUTION,
219 bt541->prop.max_y);
220 if (error)
221 return error;
222
223 error = zinitix_write_u16(client, BT541_SUPPORTED_FINGER_NUM,
224 MAX_SUPPORTED_FINGER_NUM);
225 if (error)
226 return error;
227
228 error = zinitix_write_u16(client, BT541_INITIAL_TOUCH_MODE,
229 bt541->zinitix_mode);
230 if (error)
231 return error;
232
233 error = zinitix_write_u16(client, BT541_TOUCH_MODE,
234 bt541->zinitix_mode);
235 if (error)
236 return error;
237
238 error = zinitix_write_u16(client, BT541_INT_ENABLE_FLAG,
239 BIT_PT_CNT_CHANGE | BIT_DOWN | BIT_MOVE |
240 BIT_UP);
241 if (error)
242 return error;
243
244 /* clear queue */
245 for (i = 0; i < 10; i++) {
246 zinitix_write_cmd(client, BT541_CLEAR_INT_STATUS_CMD);
247 udelay(10);
248 }
249
250 return 0;
251}
252
253static int zinitix_init_regulators(struct bt541_ts_data *bt541)
254{
255 struct i2c_client *client = bt541->client;
256 int error;
257
258 bt541->supplies[0].supply = "vdd";
259 bt541->supplies[1].supply = "vddo";
260 error = devm_regulator_bulk_get(&client->dev,
261 ARRAY_SIZE(bt541->supplies),
262 bt541->supplies);
263 if (error < 0) {
264 dev_err(&client->dev, "Failed to get regulators: %d\n", error);
265 return error;
266 }
267
268 return 0;
269}
270
271static int zinitix_send_power_on_sequence(struct bt541_ts_data *bt541)
272{
273 int error;
274 struct i2c_client *client = bt541->client;
275
276 error = zinitix_write_u16(client, 0xc000, 0x0001);
277 if (error) {
278 dev_err(&client->dev,
279 "Failed to send power sequence(vendor cmd enable)\n");
280 return error;
281 }
282 udelay(10);
283
284 error = zinitix_write_cmd(client, 0xc004);
285 if (error) {
286 dev_err(&client->dev,
287 "Failed to send power sequence (intn clear)\n");
288 return error;
289 }
290 udelay(10);
291
292 error = zinitix_write_u16(client, 0xc002, 0x0001);
293 if (error) {
294 dev_err(&client->dev,
295 "Failed to send power sequence (nvm init)\n");
296 return error;
297 }
298 mdelay(2);
299
300 error = zinitix_write_u16(client, 0xc001, 0x0001);
301 if (error) {
302 dev_err(&client->dev,
303 "Failed to send power sequence (program start)\n");
304 return error;
305 }
306 msleep(FIRMWARE_ON_DELAY);
307
308 return 0;
309}
310
311static void zinitix_report_finger(struct bt541_ts_data *bt541, int slot,
312 const struct point_coord *p)
313{
314 input_mt_slot(bt541->input_dev, slot);
315 input_mt_report_slot_state(bt541->input_dev, MT_TOOL_FINGER, true);
316 touchscreen_report_pos(bt541->input_dev, &bt541->prop,
317 le16_to_cpu(p->x), le16_to_cpu(p->y), true);
318 input_report_abs(bt541->input_dev, ABS_MT_TOUCH_MAJOR, p->width);
319}
320
321static irqreturn_t zinitix_ts_irq_handler(int irq, void *bt541_handler)
322{
323 struct bt541_ts_data *bt541 = bt541_handler;
324 struct i2c_client *client = bt541->client;
325 struct touch_event touch_event;
326 int error;
327 int i;
328
329 memset(&touch_event, 0, sizeof(struct touch_event));
330
331 error = zinitix_read_data(bt541->client, BT541_POINT_STATUS_REG,
332 &touch_event, sizeof(struct touch_event));
333 if (error) {
334 dev_err(&client->dev, "Failed to read in touchpoint struct\n");
335 goto out;
336 }
337
338 for (i = 0; i < MAX_SUPPORTED_FINGER_NUM; i++)
339 if (touch_event.point_coord[i].sub_status & SUB_BIT_EXIST)
340 zinitix_report_finger(bt541, i,
341 &touch_event.point_coord[i]);
342
343 input_mt_sync_frame(bt541->input_dev);
344 input_sync(bt541->input_dev);
345
346out:
347 zinitix_write_cmd(bt541->client, BT541_CLEAR_INT_STATUS_CMD);
348 return IRQ_HANDLED;
349}
350
351static int zinitix_start(struct bt541_ts_data *bt541)
352{
353 int error;
354
355 error = regulator_bulk_enable(ARRAY_SIZE(bt541->supplies),
356 bt541->supplies);
357 if (error) {
358 dev_err(&bt541->client->dev,
359 "Failed to enable regulators: %d\n", error);
360 return error;
361 }
362
363 msleep(CHIP_ON_DELAY);
364
365 error = zinitix_send_power_on_sequence(bt541);
366 if (error) {
367 dev_err(&bt541->client->dev,
368 "Error while sending power-on sequence: %d\n", error);
369 return error;
370 }
371
372 error = zinitix_init_touch(bt541);
373 if (error) {
374 dev_err(&bt541->client->dev,
375 "Error while configuring touch IC\n");
376 return error;
377 }
378
379 enable_irq(bt541->client->irq);
380
381 return 0;
382}
383
384static int zinitix_stop(struct bt541_ts_data *bt541)
385{
386 int error;
387
388 disable_irq(bt541->client->irq);
389
390 error = regulator_bulk_disable(ARRAY_SIZE(bt541->supplies),
391 bt541->supplies);
392 if (error) {
393 dev_err(&bt541->client->dev,
394 "Failed to disable regulators: %d\n", error);
395 return error;
396 }
397
398 return 0;
399}
400
401static int zinitix_input_open(struct input_dev *dev)
402{
403 struct bt541_ts_data *bt541 = input_get_drvdata(dev);
404
405 return zinitix_start(bt541);
406}
407
408static void zinitix_input_close(struct input_dev *dev)
409{
410 struct bt541_ts_data *bt541 = input_get_drvdata(dev);
411
412 zinitix_stop(bt541);
413}
414
415static int zinitix_init_input_dev(struct bt541_ts_data *bt541)
416{
417 struct input_dev *input_dev;
418 int error;
419
420 input_dev = devm_input_allocate_device(&bt541->client->dev);
421 if (!input_dev) {
422 dev_err(&bt541->client->dev,
423 "Failed to allocate input device.");
424 return -ENOMEM;
425 }
426
427 input_set_drvdata(input_dev, bt541);
428 bt541->input_dev = input_dev;
429
430 input_dev->name = "Zinitix Capacitive TouchScreen";
431 input_dev->phys = "input/ts";
432 input_dev->id.bustype = BUS_I2C;
433 input_dev->open = zinitix_input_open;
434 input_dev->close = zinitix_input_close;
435
436 input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_X);
437 input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_Y);
438 input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
439 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
440
441 touchscreen_parse_properties(input_dev, true, &bt541->prop);
442 if (!bt541->prop.max_x || !bt541->prop.max_y) {
443 dev_err(&bt541->client->dev,
444 "Touchscreen-size-x and/or touchscreen-size-y not set in dts\n");
445 return -EINVAL;
446 }
447
448 error = input_mt_init_slots(input_dev, MAX_SUPPORTED_FINGER_NUM,
449 INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
450 if (error) {
451 dev_err(&bt541->client->dev,
452 "Failed to initialize MT slots: %d", error);
453 return error;
454 }
455
456 error = input_register_device(input_dev);
457 if (error) {
458 dev_err(&bt541->client->dev,
459 "Failed to register input device: %d", error);
460 return error;
461 }
462
463 return 0;
464}
465
466static int zinitix_ts_probe(struct i2c_client *client)
467{
468 struct bt541_ts_data *bt541;
469 int error;
470
471 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
472 dev_err(&client->dev,
473 "Failed to assert adapter's support for plain I2C.\n");
474 return -ENXIO;
475 }
476
477 bt541 = devm_kzalloc(&client->dev, sizeof(*bt541), GFP_KERNEL);
478 if (!bt541)
479 return -ENOMEM;
480
481 bt541->client = client;
482 i2c_set_clientdata(client, bt541);
483
484 error = zinitix_init_regulators(bt541);
485 if (error) {
486 dev_err(&client->dev,
487 "Failed to initialize regulators: %d\n", error);
488 return error;
489 }
490
491 error = zinitix_init_input_dev(bt541);
492 if (error) {
493 dev_err(&client->dev,
494 "Failed to initialize input device: %d\n", error);
495 return error;
496 }
497
498 error = device_property_read_u32(&client->dev, "zinitix,mode",
499 &bt541->zinitix_mode);
500 if (error < 0) {
501 /* fall back to mode 2 */
502 bt541->zinitix_mode = DEFAULT_TOUCH_POINT_MODE;
503 }
504
505 if (bt541->zinitix_mode != 2) {
506 /*
507 * If there are devices that don't support mode 2, support
508 * for other modes (0, 1) will be needed.
509 */
510 dev_err(&client->dev,
511 "Malformed zinitix,mode property, must be 2 (supplied: %d)\n",
512 bt541->zinitix_mode);
513 return -EINVAL;
514 }
515
516 error = devm_request_threaded_irq(&client->dev, client->irq,
517 NULL, zinitix_ts_irq_handler,
518 IRQF_ONESHOT | IRQF_NO_AUTOEN,
519 client->name, bt541);
520 if (error) {
521 dev_err(&client->dev, "Failed to request IRQ: %d\n", error);
522 return error;
523 }
524
525 return 0;
526}
527
528static int __maybe_unused zinitix_suspend(struct device *dev)
529{
530 struct i2c_client *client = to_i2c_client(dev);
531 struct bt541_ts_data *bt541 = i2c_get_clientdata(client);
532
533 mutex_lock(&bt541->input_dev->mutex);
534
535 if (input_device_enabled(bt541->input_dev))
536 zinitix_stop(bt541);
537
538 mutex_unlock(&bt541->input_dev->mutex);
539
540 return 0;
541}
542
543static int __maybe_unused zinitix_resume(struct device *dev)
544{
545 struct i2c_client *client = to_i2c_client(dev);
546 struct bt541_ts_data *bt541 = i2c_get_clientdata(client);
547 int ret = 0;
548
549 mutex_lock(&bt541->input_dev->mutex);
550
551 if (input_device_enabled(bt541->input_dev))
552 ret = zinitix_start(bt541);
553
554 mutex_unlock(&bt541->input_dev->mutex);
555
556 return ret;
557}
558
559static SIMPLE_DEV_PM_OPS(zinitix_pm_ops, zinitix_suspend, zinitix_resume);
560
561#ifdef CONFIG_OF
562static const struct of_device_id zinitix_of_match[] = {
563 { .compatible = "zinitix,bt541" },
564 { }
565};
566MODULE_DEVICE_TABLE(of, zinitix_of_match);
567#endif
568
569static struct i2c_driver zinitix_ts_driver = {
570 .probe_new = zinitix_ts_probe,
571 .driver = {
572 .name = "Zinitix-TS",
573 .pm = &zinitix_pm_ops,
574 .of_match_table = of_match_ptr(zinitix_of_match),
575 },
576};
577module_i2c_driver(zinitix_ts_driver);
578
579MODULE_AUTHOR("Michael Srba <Michael.Srba@seznam.cz>");
580MODULE_DESCRIPTION("Zinitix touchscreen driver");
581MODULE_LICENSE("GPL v2");