projects/linux·blob master · refs

766 lines · 18.8 KiB

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/property.h>
14#include <linux/regulator/consumer.h>
15#include <linux/slab.h>
16
17/* Register Map */
18
19#define ZINITIX_SWRESET_CMD 0x0000
20#define ZINITIX_WAKEUP_CMD 0x0001
21
22#define ZINITIX_IDLE_CMD 0x0004
23#define ZINITIX_SLEEP_CMD 0x0005
24
25#define ZINITIX_CLEAR_INT_STATUS_CMD 0x0003
26#define ZINITIX_CALIBRATE_CMD 0x0006
27#define ZINITIX_SAVE_STATUS_CMD 0x0007
28#define ZINITIX_SAVE_CALIBRATION_CMD 0x0008
29#define ZINITIX_RECALL_FACTORY_CMD 0x000f
30
31#define ZINITIX_THRESHOLD 0x0020
32
33#define ZINITIX_LARGE_PALM_REJECT_AREA_TH 0x003F
34
35#define ZINITIX_DEBUG_REG 0x0115 /* 0~7 */
36
37#define ZINITIX_TOUCH_MODE 0x0010
38
39#define ZINITIX_CHIP_REVISION 0x0011
40#define ZINITIX_CHIP_BTX0X_MASK 0xF0F0
41#define ZINITIX_CHIP_BT4X2 0x4020
42#define ZINITIX_CHIP_BT4X3 0x4030
43#define ZINITIX_CHIP_BT4X4 0x4040
44
45#define ZINITIX_FIRMWARE_VERSION 0x0012
46
47#define ZINITIX_USB_DETECT 0x116
48
49#define ZINITIX_MINOR_FW_VERSION 0x0121
50
51#define ZINITIX_VENDOR_ID 0x001C
52#define ZINITIX_HW_ID 0x0014
53
54#define ZINITIX_DATA_VERSION_REG 0x0013
55#define ZINITIX_SUPPORTED_FINGER_NUM 0x0015
56#define ZINITIX_EEPROM_INFO 0x0018
57#define ZINITIX_INITIAL_TOUCH_MODE 0x0019
58
59#define ZINITIX_TOTAL_NUMBER_OF_X 0x0060
60#define ZINITIX_TOTAL_NUMBER_OF_Y 0x0061
61
62#define ZINITIX_DELAY_RAW_FOR_HOST 0x007f
63
64#define ZINITIX_BUTTON_SUPPORTED_NUM 0x00B0
65#define ZINITIX_BUTTON_SENSITIVITY 0x00B2
66#define ZINITIX_DUMMY_BUTTON_SENSITIVITY 0X00C8
67
68#define ZINITIX_X_RESOLUTION 0x00C0
69#define ZINITIX_Y_RESOLUTION 0x00C1
70
71#define ZINITIX_POINT_STATUS_REG 0x0080
72
73#define ZINITIX_BT4X2_ICON_STATUS_REG 0x009A
74#define ZINITIX_BT4X3_ICON_STATUS_REG 0x00A0
75#define ZINITIX_BT4X4_ICON_STATUS_REG 0x00A0
76#define ZINITIX_BT5XX_ICON_STATUS_REG 0x00AA
77
78#define ZINITIX_POINT_COORD_REG (ZINITIX_POINT_STATUS_REG + 2)
79
80#define ZINITIX_AFE_FREQUENCY 0x0100
81#define ZINITIX_DND_N_COUNT 0x0122
82#define ZINITIX_DND_U_COUNT 0x0135
83
84#define ZINITIX_RAWDATA_REG 0x0200
85
86#define ZINITIX_EEPROM_INFO_REG 0x0018
87
88#define ZINITIX_INT_ENABLE_FLAG 0x00f0
89#define ZINITIX_PERIODICAL_INTERRUPT_INTERVAL 0x00f1
90
91#define ZINITIX_BTN_WIDTH 0x016d
92
93#define ZINITIX_CHECKSUM_RESULT 0x012c
94
95#define ZINITIX_INIT_FLASH 0x01d0
96#define ZINITIX_WRITE_FLASH 0x01d1
97#define ZINITIX_READ_FLASH 0x01d2
98
99#define ZINITIX_INTERNAL_FLAG_02 0x011e
100#define ZINITIX_INTERNAL_FLAG_03 0x011f
101
102#define ZINITIX_I2C_CHECKSUM_WCNT 0x016a
103#define ZINITIX_I2C_CHECKSUM_RESULT 0x016c
104
105/* Interrupt & status register flags */
106
107#define BIT_PT_CNT_CHANGE BIT(0)
108#define BIT_DOWN BIT(1)
109#define BIT_MOVE BIT(2)
110#define BIT_UP BIT(3)
111#define BIT_PALM BIT(4)
112#define BIT_PALM_REJECT BIT(5)
113#define BIT_RESERVED_0 BIT(6)
114#define BIT_RESERVED_1 BIT(7)
115#define BIT_WEIGHT_CHANGE BIT(8)
116#define BIT_PT_NO_CHANGE BIT(9)
117#define BIT_REJECT BIT(10)
118#define BIT_PT_EXIST BIT(11)
119#define BIT_RESERVED_2 BIT(12)
120#define BIT_ERROR BIT(13)
121#define BIT_DEBUG BIT(14)
122#define BIT_ICON_EVENT BIT(15)
123
124#define SUB_BIT_EXIST BIT(0)
125#define SUB_BIT_DOWN BIT(1)
126#define SUB_BIT_MOVE BIT(2)
127#define SUB_BIT_UP BIT(3)
128#define SUB_BIT_UPDATE BIT(4)
129#define SUB_BIT_WAIT BIT(5)
130
131#define DEFAULT_TOUCH_POINT_MODE 2
132#define MAX_SUPPORTED_FINGER_NUM 5
133#define MAX_SUPPORTED_BUTTON_NUM 8
134
135#define CHIP_ON_DELAY 15 // ms
136#define FIRMWARE_ON_DELAY 40 // ms
137
138struct point_coord {
139 __le16 x;
140 __le16 y;
141 u8 width;
142 u8 sub_status;
143 // currently unused, but needed as padding:
144 u8 minor_width;
145 u8 angle;
146};
147
148struct touch_event {
149 __le16 status;
150 u8 finger_mask;
151 u8 time_stamp;
152 struct point_coord point_coord[MAX_SUPPORTED_FINGER_NUM];
153};
154
155struct bt541_ts_data {
156 struct i2c_client *client;
157 struct input_dev *input_dev;
158 struct touchscreen_properties prop;
159 struct regulator_bulk_data supplies[2];
160 u32 zinitix_mode;
161 u32 keycodes[MAX_SUPPORTED_BUTTON_NUM];
162 int num_keycodes;
163 bool have_versioninfo;
164 u16 chip_revision;
165 u16 firmware_version;
166 u16 regdata_version;
167 u16 icon_status_reg;
168};
169
170static int zinitix_read_data(struct i2c_client *client,
171 u16 reg, void *values, size_t length)
172{
173 __le16 reg_le = cpu_to_le16(reg);
174 int ret;
175
176 /* A single i2c_transfer() transaction does not work here. */
177 ret = i2c_master_send(client, (u8 *)&reg_le, sizeof(reg_le));
178 if (ret != sizeof(reg_le))
179 return ret < 0 ? ret : -EIO;
180
181 ret = i2c_master_recv(client, (u8 *)values, length);
182 if (ret != length)
183 return ret < 0 ? ret : -EIO;
184
185 return 0;
186}
187
188static int zinitix_write_u16(struct i2c_client *client, u16 reg, u16 value)
189{
190 __le16 packet[2] = {cpu_to_le16(reg), cpu_to_le16(value)};
191 int ret;
192
193 ret = i2c_master_send(client, (u8 *)packet, sizeof(packet));
194 if (ret != sizeof(packet))
195 return ret < 0 ? ret : -EIO;
196
197 return 0;
198}
199
200static int zinitix_write_cmd(struct i2c_client *client, u16 reg)
201{
202 __le16 reg_le = cpu_to_le16(reg);
203 int ret;
204
205 ret = i2c_master_send(client, (u8 *)&reg_le, sizeof(reg_le));
206 if (ret != sizeof(reg_le))
207 return ret < 0 ? ret : -EIO;
208
209 return 0;
210}
211
212static u16 zinitix_get_u16_reg(struct bt541_ts_data *bt541, u16 vreg)
213{
214 struct i2c_client *client = bt541->client;
215 int error;
216 __le16 val;
217
218 error = zinitix_read_data(client, vreg, (void *)&val, 2);
219 if (error)
220 return U8_MAX;
221
222 return le16_to_cpu(val);
223}
224
225static int zinitix_init_touch(struct bt541_ts_data *bt541)
226{
227 struct i2c_client *client = bt541->client;
228 int i;
229 int error;
230 u16 int_flags;
231
232 error = zinitix_write_cmd(client, ZINITIX_SWRESET_CMD);
233 if (error) {
234 dev_err(&client->dev, "Failed to write reset command\n");
235 return error;
236 }
237
238 /*
239 * Read and cache the chip revision and firmware version the first time
240 * we get here.
241 */
242 if (!bt541->have_versioninfo) {
243 bt541->chip_revision = zinitix_get_u16_reg(bt541,
244 ZINITIX_CHIP_REVISION);
245 bt541->firmware_version = zinitix_get_u16_reg(bt541,
246 ZINITIX_FIRMWARE_VERSION);
247 bt541->regdata_version = zinitix_get_u16_reg(bt541,
248 ZINITIX_DATA_VERSION_REG);
249 bt541->have_versioninfo = true;
250
251 dev_dbg(&client->dev,
252 "chip revision %04x firmware version %04x regdata version %04x\n",
253 bt541->chip_revision, bt541->firmware_version,
254 bt541->regdata_version);
255
256 /*
257 * Determine the "icon" status register which varies by the
258 * chip.
259 */
260 switch (bt541->chip_revision & ZINITIX_CHIP_BTX0X_MASK) {
261 case ZINITIX_CHIP_BT4X2:
262 bt541->icon_status_reg = ZINITIX_BT4X2_ICON_STATUS_REG;
263 break;
264
265 case ZINITIX_CHIP_BT4X3:
266 bt541->icon_status_reg = ZINITIX_BT4X3_ICON_STATUS_REG;
267 break;
268
269 case ZINITIX_CHIP_BT4X4:
270 bt541->icon_status_reg = ZINITIX_BT4X4_ICON_STATUS_REG;
271 break;
272
273 default:
274 bt541->icon_status_reg = ZINITIX_BT5XX_ICON_STATUS_REG;
275 break;
276 }
277 }
278
279 error = zinitix_write_u16(client, ZINITIX_INT_ENABLE_FLAG, 0x0);
280 if (error) {
281 dev_err(&client->dev,
282 "Failed to reset interrupt enable flag\n");
283 return error;
284 }
285
286 /* initialize */
287 error = zinitix_write_u16(client, ZINITIX_X_RESOLUTION,
288 bt541->prop.max_x);
289 if (error)
290 return error;
291
292 error = zinitix_write_u16(client, ZINITIX_Y_RESOLUTION,
293 bt541->prop.max_y);
294 if (error)
295 return error;
296
297 error = zinitix_write_u16(client, ZINITIX_SUPPORTED_FINGER_NUM,
298 MAX_SUPPORTED_FINGER_NUM);
299 if (error)
300 return error;
301
302 error = zinitix_write_u16(client, ZINITIX_BUTTON_SUPPORTED_NUM,
303 bt541->num_keycodes);
304 if (error)
305 return error;
306
307 error = zinitix_write_u16(client, ZINITIX_INITIAL_TOUCH_MODE,
308 bt541->zinitix_mode);
309 if (error)
310 return error;
311
312 error = zinitix_write_u16(client, ZINITIX_TOUCH_MODE,
313 bt541->zinitix_mode);
314 if (error)
315 return error;
316
317 int_flags = BIT_PT_CNT_CHANGE | BIT_DOWN | BIT_MOVE | BIT_UP;
318 if (bt541->num_keycodes)
319 int_flags |= BIT_ICON_EVENT;
320
321 error = zinitix_write_u16(client, ZINITIX_INT_ENABLE_FLAG, int_flags);
322 if (error)
323 return error;
324
325 /* clear queue */
326 for (i = 0; i < 10; i++) {
327 zinitix_write_cmd(client, ZINITIX_CLEAR_INT_STATUS_CMD);
328 udelay(10);
329 }
330
331 return 0;
332}
333
334static int zinitix_init_regulators(struct bt541_ts_data *bt541)
335{
336 struct device *dev = &bt541->client->dev;
337 int error;
338
339 /*
340 * Some older device trees have erroneous names for the regulators,
341 * so check if "vddo" is present and in that case use these names.
342 * Else use the proper supply names on the component.
343 */
344 if (of_property_present(dev->of_node, "vddo-supply")) {
345 bt541->supplies[0].supply = "vdd";
346 bt541->supplies[1].supply = "vddo";
347 } else {
348 /* Else use the proper supply names */
349 bt541->supplies[0].supply = "vcca";
350 bt541->supplies[1].supply = "vdd";
351 }
352 error = devm_regulator_bulk_get(dev,
353 ARRAY_SIZE(bt541->supplies),
354 bt541->supplies);
355 if (error < 0) {
356 dev_err(dev, "Failed to get regulators: %d\n", error);
357 return error;
358 }
359
360 return 0;
361}
362
363static int zinitix_send_power_on_sequence(struct bt541_ts_data *bt541)
364{
365 int error;
366 struct i2c_client *client = bt541->client;
367
368 error = zinitix_write_u16(client, 0xc000, 0x0001);
369 if (error) {
370 dev_err(&client->dev,
371 "Failed to send power sequence(vendor cmd enable)\n");
372 return error;
373 }
374 udelay(10);
375
376 error = zinitix_write_cmd(client, 0xc004);
377 if (error) {
378 dev_err(&client->dev,
379 "Failed to send power sequence (intn clear)\n");
380 return error;
381 }
382 udelay(10);
383
384 error = zinitix_write_u16(client, 0xc002, 0x0001);
385 if (error) {
386 dev_err(&client->dev,
387 "Failed to send power sequence (nvm init)\n");
388 return error;
389 }
390 mdelay(2);
391
392 error = zinitix_write_u16(client, 0xc001, 0x0001);
393 if (error) {
394 dev_err(&client->dev,
395 "Failed to send power sequence (program start)\n");
396 return error;
397 }
398 msleep(FIRMWARE_ON_DELAY);
399
400 return 0;
401}
402
403static void zinitix_report_finger(struct bt541_ts_data *bt541, int slot,
404 const struct point_coord *p)
405{
406 u16 x, y;
407
408 if (unlikely(!(p->sub_status &
409 (SUB_BIT_UP | SUB_BIT_DOWN | SUB_BIT_MOVE)))) {
410 dev_dbg(&bt541->client->dev, "unknown finger event %#02x\n",
411 p->sub_status);
412 return;
413 }
414
415 x = le16_to_cpu(p->x);
416 y = le16_to_cpu(p->y);
417
418 input_mt_slot(bt541->input_dev, slot);
419 if (input_mt_report_slot_state(bt541->input_dev, MT_TOOL_FINGER,
420 !(p->sub_status & SUB_BIT_UP))) {
421 touchscreen_report_pos(bt541->input_dev,
422 &bt541->prop, x, y, true);
423 input_report_abs(bt541->input_dev,
424 ABS_MT_TOUCH_MAJOR, p->width);
425 dev_dbg(&bt541->client->dev, "finger %d %s (%u, %u)\n",
426 slot, p->sub_status & SUB_BIT_DOWN ? "down" : "move",
427 x, y);
428 } else {
429 dev_dbg(&bt541->client->dev, "finger %d up (%u, %u)\n",
430 slot, x, y);
431 }
432}
433
434static void zinitix_report_keys(struct bt541_ts_data *bt541, u16 icon_events)
435{
436 int i;
437
438 for (i = 0; i < bt541->num_keycodes; i++)
439 input_report_key(bt541->input_dev,
440 bt541->keycodes[i], icon_events & BIT(i));
441}
442
443static irqreturn_t zinitix_ts_irq_handler(int irq, void *bt541_handler)
444{
445 struct bt541_ts_data *bt541 = bt541_handler;
446 struct i2c_client *client = bt541->client;
447 struct touch_event touch_event;
448 unsigned long finger_mask;
449 __le16 icon_events;
450 int error;
451 int i;
452
453 memset(&touch_event, 0, sizeof(struct touch_event));
454
455 error = zinitix_read_data(bt541->client, ZINITIX_POINT_STATUS_REG,
456 &touch_event, sizeof(struct touch_event));
457 if (error) {
458 dev_err(&client->dev, "Failed to read in touchpoint struct\n");
459 goto out;
460 }
461
462 if (le16_to_cpu(touch_event.status) & BIT_ICON_EVENT) {
463 error = zinitix_read_data(bt541->client, bt541->icon_status_reg,
464 &icon_events, sizeof(icon_events));
465 if (error) {
466 dev_err(&client->dev, "Failed to read icon events\n");
467 goto out;
468 }
469
470 zinitix_report_keys(bt541, le16_to_cpu(icon_events));
471 }
472
473 finger_mask = touch_event.finger_mask;
474 for_each_set_bit(i, &finger_mask, MAX_SUPPORTED_FINGER_NUM) {
475 const struct point_coord *p = &touch_event.point_coord[i];
476
477 /* Only process contacts that are actually reported */
478 if (p->sub_status & SUB_BIT_EXIST)
479 zinitix_report_finger(bt541, i, p);
480 }
481
482 input_mt_sync_frame(bt541->input_dev);
483 input_sync(bt541->input_dev);
484
485out:
486 zinitix_write_cmd(bt541->client, ZINITIX_CLEAR_INT_STATUS_CMD);
487 return IRQ_HANDLED;
488}
489
490static int zinitix_start(struct bt541_ts_data *bt541)
491{
492 int error;
493
494 error = regulator_bulk_enable(ARRAY_SIZE(bt541->supplies),
495 bt541->supplies);
496 if (error) {
497 dev_err(&bt541->client->dev,
498 "Failed to enable regulators: %d\n", error);
499 return error;
500 }
501
502 msleep(CHIP_ON_DELAY);
503
504 error = zinitix_send_power_on_sequence(bt541);
505 if (error) {
506 dev_err(&bt541->client->dev,
507 "Error while sending power-on sequence: %d\n", error);
508 return error;
509 }
510
511 error = zinitix_init_touch(bt541);
512 if (error) {
513 dev_err(&bt541->client->dev,
514 "Error while configuring touch IC\n");
515 return error;
516 }
517
518 enable_irq(bt541->client->irq);
519
520 return 0;
521}
522
523static int zinitix_stop(struct bt541_ts_data *bt541)
524{
525 int error;
526
527 disable_irq(bt541->client->irq);
528
529 error = regulator_bulk_disable(ARRAY_SIZE(bt541->supplies),
530 bt541->supplies);
531 if (error) {
532 dev_err(&bt541->client->dev,
533 "Failed to disable regulators: %d\n", error);
534 return error;
535 }
536
537 return 0;
538}
539
540static int zinitix_input_open(struct input_dev *dev)
541{
542 struct bt541_ts_data *bt541 = input_get_drvdata(dev);
543
544 return zinitix_start(bt541);
545}
546
547static void zinitix_input_close(struct input_dev *dev)
548{
549 struct bt541_ts_data *bt541 = input_get_drvdata(dev);
550
551 zinitix_stop(bt541);
552}
553
554static int zinitix_init_input_dev(struct bt541_ts_data *bt541)
555{
556 struct input_dev *input_dev;
557 int error;
558 int i;
559
560 input_dev = devm_input_allocate_device(&bt541->client->dev);
561 if (!input_dev) {
562 dev_err(&bt541->client->dev,
563 "Failed to allocate input device.");
564 return -ENOMEM;
565 }
566
567 input_set_drvdata(input_dev, bt541);
568 bt541->input_dev = input_dev;
569
570 input_dev->name = "Zinitix Capacitive TouchScreen";
571 input_dev->phys = "input/ts";
572 input_dev->id.bustype = BUS_I2C;
573 input_dev->open = zinitix_input_open;
574 input_dev->close = zinitix_input_close;
575
576 if (bt541->num_keycodes) {
577 input_dev->keycode = bt541->keycodes;
578 input_dev->keycodemax = bt541->num_keycodes;
579 input_dev->keycodesize = sizeof(bt541->keycodes[0]);
580 for (i = 0; i < bt541->num_keycodes; i++)
581 input_set_capability(input_dev, EV_KEY, bt541->keycodes[i]);
582 }
583
584 input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_X);
585 input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_Y);
586 input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
587 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
588
589 touchscreen_parse_properties(input_dev, true, &bt541->prop);
590 if (!bt541->prop.max_x || !bt541->prop.max_y) {
591 dev_err(&bt541->client->dev,
592 "Touchscreen-size-x and/or touchscreen-size-y not set in dts\n");
593 return -EINVAL;
594 }
595
596 error = input_mt_init_slots(input_dev, MAX_SUPPORTED_FINGER_NUM,
597 INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
598 if (error) {
599 dev_err(&bt541->client->dev,
600 "Failed to initialize MT slots: %d", error);
601 return error;
602 }
603
604 error = input_register_device(input_dev);
605 if (error) {
606 dev_err(&bt541->client->dev,
607 "Failed to register input device: %d", error);
608 return error;
609 }
610
611 return 0;
612}
613
614static int zinitix_ts_probe(struct i2c_client *client)
615{
616 struct bt541_ts_data *bt541;
617 int error;
618
619 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
620 dev_err(&client->dev,
621 "Failed to assert adapter's support for plain I2C.\n");
622 return -ENXIO;
623 }
624
625 bt541 = devm_kzalloc(&client->dev, sizeof(*bt541), GFP_KERNEL);
626 if (!bt541)
627 return -ENOMEM;
628
629 bt541->client = client;
630 i2c_set_clientdata(client, bt541);
631
632 error = zinitix_init_regulators(bt541);
633 if (error) {
634 dev_err(&client->dev,
635 "Failed to initialize regulators: %d\n", error);
636 return error;
637 }
638
639 error = devm_request_threaded_irq(&client->dev, client->irq,
640 NULL, zinitix_ts_irq_handler,
641 IRQF_ONESHOT | IRQF_NO_AUTOEN,
642 client->name, bt541);
643 if (error) {
644 dev_err(&client->dev, "Failed to request IRQ: %d\n", error);
645 return error;
646 }
647
648 if (device_property_present(&client->dev, "linux,keycodes")) {
649 bt541->num_keycodes = device_property_count_u32(&client->dev,
650 "linux,keycodes");
651 if (bt541->num_keycodes < 0) {
652 dev_err(&client->dev, "Failed to count keys (%d)\n",
653 bt541->num_keycodes);
654 return bt541->num_keycodes;
655 } else if (bt541->num_keycodes > ARRAY_SIZE(bt541->keycodes)) {
656 dev_err(&client->dev, "Too many keys defined (%d)\n",
657 bt541->num_keycodes);
658 return -EINVAL;
659 }
660
661 error = device_property_read_u32_array(&client->dev,
662 "linux,keycodes",
663 bt541->keycodes,
664 bt541->num_keycodes);
665 if (error) {
666 dev_err(&client->dev,
667 "Unable to parse \"linux,keycodes\" property: %d\n",
668 error);
669 return error;
670 }
671 }
672
673 error = zinitix_init_input_dev(bt541);
674 if (error) {
675 dev_err(&client->dev,
676 "Failed to initialize input device: %d\n", error);
677 return error;
678 }
679
680 error = device_property_read_u32(&client->dev, "zinitix,mode",
681 &bt541->zinitix_mode);
682 if (error < 0) {
683 /* fall back to mode 2 */
684 bt541->zinitix_mode = DEFAULT_TOUCH_POINT_MODE;
685 }
686
687 if (bt541->zinitix_mode != 2) {
688 /*
689 * If there are devices that don't support mode 2, support
690 * for other modes (0, 1) will be needed.
691 */
692 dev_err(&client->dev,
693 "Malformed zinitix,mode property, must be 2 (supplied: %d)\n",
694 bt541->zinitix_mode);
695 return -EINVAL;
696 }
697
698 return 0;
699}
700
701static int zinitix_suspend(struct device *dev)
702{
703 struct i2c_client *client = to_i2c_client(dev);
704 struct bt541_ts_data *bt541 = i2c_get_clientdata(client);
705
706 guard(mutex)(&bt541->input_dev->mutex);
707
708 if (input_device_enabled(bt541->input_dev))
709 zinitix_stop(bt541);
710
711 return 0;
712}
713
714static int zinitix_resume(struct device *dev)
715{
716 struct i2c_client *client = to_i2c_client(dev);
717 struct bt541_ts_data *bt541 = i2c_get_clientdata(client);
718 int error;
719
720 guard(mutex)(&bt541->input_dev->mutex);
721
722 if (input_device_enabled(bt541->input_dev)) {
723 error = zinitix_start(bt541);
724 if (error)
725 return error;
726 }
727
728 return 0;
729}
730
731static DEFINE_SIMPLE_DEV_PM_OPS(zinitix_pm_ops, zinitix_suspend, zinitix_resume);
732
733#ifdef CONFIG_OF
734static const struct of_device_id zinitix_of_match[] = {
735 { .compatible = "zinitix,bt402" },
736 { .compatible = "zinitix,bt403" },
737 { .compatible = "zinitix,bt404" },
738 { .compatible = "zinitix,bt412" },
739 { .compatible = "zinitix,bt413" },
740 { .compatible = "zinitix,bt431" },
741 { .compatible = "zinitix,bt432" },
742 { .compatible = "zinitix,bt531" },
743 { .compatible = "zinitix,bt532" },
744 { .compatible = "zinitix,bt538" },
745 { .compatible = "zinitix,bt541" },
746 { .compatible = "zinitix,bt548" },
747 { .compatible = "zinitix,bt554" },
748 { .compatible = "zinitix,at100" },
749 { }
750};
751MODULE_DEVICE_TABLE(of, zinitix_of_match);
752#endif
753
754static struct i2c_driver zinitix_ts_driver = {
755 .probe = zinitix_ts_probe,
756 .driver = {
757 .name = "Zinitix-TS",
758 .pm = pm_sleep_ptr(&zinitix_pm_ops),
759 .of_match_table = of_match_ptr(zinitix_of_match),
760 },
761};
762module_i2c_driver(zinitix_ts_driver);
763
764MODULE_AUTHOR("Michael Srba <[email protected]>");
765MODULE_DESCRIPTION("Zinitix touchscreen driver");
766MODULE_LICENSE("GPL v2");