1 // SPDX-License-Identifier: GPL-2.0-only
3 #include <linux/delay.h>
5 #include <linux/input.h>
6 #include <linux/input/mt.h>
7 #include <linux/input/touchscreen.h>
8 #include <linux/interrupt.h>
10 #include <linux/kernel.h>
11 #include <linux/module.h>
13 #include <linux/regulator/consumer.h>
14 #include <linux/slab.h>
18 #define BT541_SWRESET_CMD 0x0000
19 #define BT541_WAKEUP_CMD 0x0001
21 #define BT541_IDLE_CMD 0x0004
22 #define BT541_SLEEP_CMD 0x0005
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
30 #define BT541_THRESHOLD 0x0020
32 #define BT541_LARGE_PALM_REJECT_AREA_TH 0x003F
34 #define BT541_DEBUG_REG 0x0115 /* 0~7 */
36 #define BT541_TOUCH_MODE 0x0010
37 #define BT541_CHIP_REVISION 0x0011
38 #define BT541_FIRMWARE_VERSION 0x0012
40 #define ZINITIX_USB_DETECT 0x116
42 #define BT541_MINOR_FW_VERSION 0x0121
44 #define BT541_VENDOR_ID 0x001C
45 #define BT541_HW_ID 0x0014
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
52 #define BT541_TOTAL_NUMBER_OF_X 0x0060
53 #define BT541_TOTAL_NUMBER_OF_Y 0x0061
55 #define BT541_DELAY_RAW_FOR_HOST 0x007f
57 #define BT541_BUTTON_SUPPORTED_NUM 0x00B0
58 #define BT541_BUTTON_SENSITIVITY 0x00B2
59 #define BT541_DUMMY_BUTTON_SENSITIVITY 0X00C8
61 #define BT541_X_RESOLUTION 0x00C0
62 #define BT541_Y_RESOLUTION 0x00C1
64 #define BT541_POINT_STATUS_REG 0x0080
65 #define BT541_ICON_STATUS_REG 0x00AA
67 #define BT541_POINT_COORD_REG (BT541_POINT_STATUS_REG + 2)
69 #define BT541_AFE_FREQUENCY 0x0100
70 #define BT541_DND_N_COUNT 0x0122
71 #define BT541_DND_U_COUNT 0x0135
73 #define BT541_RAWDATA_REG 0x0200
75 #define BT541_EEPROM_INFO_REG 0x0018
77 #define BT541_INT_ENABLE_FLAG 0x00f0
78 #define BT541_PERIODICAL_INTERRUPT_INTERVAL 0x00f1
80 #define BT541_BTN_WIDTH 0x016d
82 #define BT541_CHECKSUM_RESULT 0x012c
84 #define BT541_INIT_FLASH 0x01d0
85 #define BT541_WRITE_FLASH 0x01d1
86 #define BT541_READ_FLASH 0x01d2
88 #define ZINITIX_INTERNAL_FLAG_02 0x011e
89 #define ZINITIX_INTERNAL_FLAG_03 0x011f
91 #define ZINITIX_I2C_CHECKSUM_WCNT 0x016a
92 #define ZINITIX_I2C_CHECKSUM_RESULT 0x016c
94 /* Interrupt & status register flags */
96 #define BIT_PT_CNT_CHANGE BIT(0)
97 #define BIT_DOWN BIT(1)
98 #define BIT_MOVE BIT(2)
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)
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)
120 #define DEFAULT_TOUCH_POINT_MODE 2
121 #define MAX_SUPPORTED_FINGER_NUM 5
123 #define CHIP_ON_DELAY 15 // ms
124 #define FIRMWARE_ON_DELAY 40 // ms
131 // currently unused, but needed as padding:
140 struct point_coord point_coord[MAX_SUPPORTED_FINGER_NUM];
143 struct 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];
151 static int zinitix_read_data(struct i2c_client *client,
152 u16 reg, void *values, size_t length)
154 __le16 reg_le = cpu_to_le16(reg);
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;
162 ret = i2c_master_recv(client, (u8 *)values, length);
164 return ret < 0 ? ret : -EIO;
169 static int zinitix_write_u16(struct i2c_client *client, u16 reg, u16 value)
171 __le16 packet[2] = {cpu_to_le16(reg), cpu_to_le16(value)};
174 ret = i2c_master_send(client, (u8 *)packet, sizeof(packet));
175 if (ret != sizeof(packet))
176 return ret < 0 ? ret : -EIO;
181 static int zinitix_write_cmd(struct i2c_client *client, u16 reg)
183 __le16 reg_le = cpu_to_le16(reg);
186 ret = i2c_master_send(client, (u8 *)®_le, sizeof(reg_le));
187 if (ret != sizeof(reg_le))
188 return ret < 0 ? ret : -EIO;
193 static int zinitix_init_touch(struct bt541_ts_data *bt541)
195 struct i2c_client *client = bt541->client;
199 error = zinitix_write_cmd(client, BT541_SWRESET_CMD);
201 dev_err(&client->dev, "Failed to write reset command\n");
205 error = zinitix_write_u16(client, BT541_INT_ENABLE_FLAG, 0x0);
207 dev_err(&client->dev,
208 "Failed to reset interrupt enable flag\n");
213 error = zinitix_write_u16(client, BT541_X_RESOLUTION,
218 error = zinitix_write_u16(client, BT541_Y_RESOLUTION,
223 error = zinitix_write_u16(client, BT541_SUPPORTED_FINGER_NUM,
224 MAX_SUPPORTED_FINGER_NUM);
228 error = zinitix_write_u16(client, BT541_INITIAL_TOUCH_MODE,
229 bt541->zinitix_mode);
233 error = zinitix_write_u16(client, BT541_TOUCH_MODE,
234 bt541->zinitix_mode);
238 error = zinitix_write_u16(client, BT541_INT_ENABLE_FLAG,
239 BIT_PT_CNT_CHANGE | BIT_DOWN | BIT_MOVE |
245 for (i = 0; i < 10; i++) {
246 zinitix_write_cmd(client, BT541_CLEAR_INT_STATUS_CMD);
253 static int zinitix_init_regulators(struct bt541_ts_data *bt541)
255 struct device *dev = &bt541->client->dev;
259 * Some older device trees have erroneous names for the regulators,
260 * so check if "vddo" is present and in that case use these names.
261 * Else use the proper supply names on the component.
263 if (of_find_property(dev->of_node, "vddo-supply", NULL)) {
264 bt541->supplies[0].supply = "vdd";
265 bt541->supplies[1].supply = "vddo";
267 /* Else use the proper supply names */
268 bt541->supplies[0].supply = "vcca";
269 bt541->supplies[1].supply = "vdd";
271 error = devm_regulator_bulk_get(dev,
272 ARRAY_SIZE(bt541->supplies),
275 dev_err(dev, "Failed to get regulators: %d\n", error);
282 static int zinitix_send_power_on_sequence(struct bt541_ts_data *bt541)
285 struct i2c_client *client = bt541->client;
287 error = zinitix_write_u16(client, 0xc000, 0x0001);
289 dev_err(&client->dev,
290 "Failed to send power sequence(vendor cmd enable)\n");
295 error = zinitix_write_cmd(client, 0xc004);
297 dev_err(&client->dev,
298 "Failed to send power sequence (intn clear)\n");
303 error = zinitix_write_u16(client, 0xc002, 0x0001);
305 dev_err(&client->dev,
306 "Failed to send power sequence (nvm init)\n");
311 error = zinitix_write_u16(client, 0xc001, 0x0001);
313 dev_err(&client->dev,
314 "Failed to send power sequence (program start)\n");
317 msleep(FIRMWARE_ON_DELAY);
322 static void zinitix_report_finger(struct bt541_ts_data *bt541, int slot,
323 const struct point_coord *p)
325 input_mt_slot(bt541->input_dev, slot);
326 input_mt_report_slot_state(bt541->input_dev, MT_TOOL_FINGER, true);
327 touchscreen_report_pos(bt541->input_dev, &bt541->prop,
328 le16_to_cpu(p->x), le16_to_cpu(p->y), true);
329 input_report_abs(bt541->input_dev, ABS_MT_TOUCH_MAJOR, p->width);
332 static irqreturn_t zinitix_ts_irq_handler(int irq, void *bt541_handler)
334 struct bt541_ts_data *bt541 = bt541_handler;
335 struct i2c_client *client = bt541->client;
336 struct touch_event touch_event;
340 memset(&touch_event, 0, sizeof(struct touch_event));
342 error = zinitix_read_data(bt541->client, BT541_POINT_STATUS_REG,
343 &touch_event, sizeof(struct touch_event));
345 dev_err(&client->dev, "Failed to read in touchpoint struct\n");
349 for (i = 0; i < MAX_SUPPORTED_FINGER_NUM; i++)
350 if (touch_event.point_coord[i].sub_status & SUB_BIT_EXIST)
351 zinitix_report_finger(bt541, i,
352 &touch_event.point_coord[i]);
354 input_mt_sync_frame(bt541->input_dev);
355 input_sync(bt541->input_dev);
358 zinitix_write_cmd(bt541->client, BT541_CLEAR_INT_STATUS_CMD);
362 static int zinitix_start(struct bt541_ts_data *bt541)
366 error = regulator_bulk_enable(ARRAY_SIZE(bt541->supplies),
369 dev_err(&bt541->client->dev,
370 "Failed to enable regulators: %d\n", error);
374 msleep(CHIP_ON_DELAY);
376 error = zinitix_send_power_on_sequence(bt541);
378 dev_err(&bt541->client->dev,
379 "Error while sending power-on sequence: %d\n", error);
383 error = zinitix_init_touch(bt541);
385 dev_err(&bt541->client->dev,
386 "Error while configuring touch IC\n");
390 enable_irq(bt541->client->irq);
395 static int zinitix_stop(struct bt541_ts_data *bt541)
399 disable_irq(bt541->client->irq);
401 error = regulator_bulk_disable(ARRAY_SIZE(bt541->supplies),
404 dev_err(&bt541->client->dev,
405 "Failed to disable regulators: %d\n", error);
412 static int zinitix_input_open(struct input_dev *dev)
414 struct bt541_ts_data *bt541 = input_get_drvdata(dev);
416 return zinitix_start(bt541);
419 static void zinitix_input_close(struct input_dev *dev)
421 struct bt541_ts_data *bt541 = input_get_drvdata(dev);
426 static int zinitix_init_input_dev(struct bt541_ts_data *bt541)
428 struct input_dev *input_dev;
431 input_dev = devm_input_allocate_device(&bt541->client->dev);
433 dev_err(&bt541->client->dev,
434 "Failed to allocate input device.");
438 input_set_drvdata(input_dev, bt541);
439 bt541->input_dev = input_dev;
441 input_dev->name = "Zinitix Capacitive TouchScreen";
442 input_dev->phys = "input/ts";
443 input_dev->id.bustype = BUS_I2C;
444 input_dev->open = zinitix_input_open;
445 input_dev->close = zinitix_input_close;
447 input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_X);
448 input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_Y);
449 input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
450 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
452 touchscreen_parse_properties(input_dev, true, &bt541->prop);
453 if (!bt541->prop.max_x || !bt541->prop.max_y) {
454 dev_err(&bt541->client->dev,
455 "Touchscreen-size-x and/or touchscreen-size-y not set in dts\n");
459 error = input_mt_init_slots(input_dev, MAX_SUPPORTED_FINGER_NUM,
460 INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
462 dev_err(&bt541->client->dev,
463 "Failed to initialize MT slots: %d", error);
467 error = input_register_device(input_dev);
469 dev_err(&bt541->client->dev,
470 "Failed to register input device: %d", error);
477 static int zinitix_ts_probe(struct i2c_client *client)
479 struct bt541_ts_data *bt541;
482 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
483 dev_err(&client->dev,
484 "Failed to assert adapter's support for plain I2C.\n");
488 bt541 = devm_kzalloc(&client->dev, sizeof(*bt541), GFP_KERNEL);
492 bt541->client = client;
493 i2c_set_clientdata(client, bt541);
495 error = zinitix_init_regulators(bt541);
497 dev_err(&client->dev,
498 "Failed to initialize regulators: %d\n", error);
502 error = devm_request_threaded_irq(&client->dev, client->irq,
503 NULL, zinitix_ts_irq_handler,
504 IRQF_ONESHOT | IRQF_NO_AUTOEN,
505 client->name, bt541);
507 dev_err(&client->dev, "Failed to request IRQ: %d\n", error);
511 error = zinitix_init_input_dev(bt541);
513 dev_err(&client->dev,
514 "Failed to initialize input device: %d\n", error);
518 error = device_property_read_u32(&client->dev, "zinitix,mode",
519 &bt541->zinitix_mode);
521 /* fall back to mode 2 */
522 bt541->zinitix_mode = DEFAULT_TOUCH_POINT_MODE;
525 if (bt541->zinitix_mode != 2) {
527 * If there are devices that don't support mode 2, support
528 * for other modes (0, 1) will be needed.
530 dev_err(&client->dev,
531 "Malformed zinitix,mode property, must be 2 (supplied: %d)\n",
532 bt541->zinitix_mode);
539 static int __maybe_unused zinitix_suspend(struct device *dev)
541 struct i2c_client *client = to_i2c_client(dev);
542 struct bt541_ts_data *bt541 = i2c_get_clientdata(client);
544 mutex_lock(&bt541->input_dev->mutex);
546 if (input_device_enabled(bt541->input_dev))
549 mutex_unlock(&bt541->input_dev->mutex);
554 static int __maybe_unused zinitix_resume(struct device *dev)
556 struct i2c_client *client = to_i2c_client(dev);
557 struct bt541_ts_data *bt541 = i2c_get_clientdata(client);
560 mutex_lock(&bt541->input_dev->mutex);
562 if (input_device_enabled(bt541->input_dev))
563 ret = zinitix_start(bt541);
565 mutex_unlock(&bt541->input_dev->mutex);
570 static SIMPLE_DEV_PM_OPS(zinitix_pm_ops, zinitix_suspend, zinitix_resume);
573 static const struct of_device_id zinitix_of_match[] = {
574 { .compatible = "zinitix,bt532" },
575 { .compatible = "zinitix,bt541" },
578 MODULE_DEVICE_TABLE(of, zinitix_of_match);
581 static struct i2c_driver zinitix_ts_driver = {
582 .probe_new = zinitix_ts_probe,
584 .name = "Zinitix-TS",
585 .pm = &zinitix_pm_ops,
586 .of_match_table = of_match_ptr(zinitix_of_match),
589 module_i2c_driver(zinitix_ts_driver);
591 MODULE_AUTHOR("Michael Srba <Michael.Srba@seznam.cz>");
592 MODULE_DESCRIPTION("Zinitix touchscreen driver");
593 MODULE_LICENSE("GPL v2");