1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * ROHM BU21023/24 Dual touch support resistive touch screen driver
4 * Copyright (C) 2012 ROHM CO.,LTD.
5 */
6 #include <linux/delay.h>
7 #include <linux/firmware.h>
8 #include <linux/i2c.h>
9 #include <linux/input.h>
10 #include <linux/input/mt.h>
11 #include <linux/interrupt.h>
12 #include <linux/module.h>
13 #include <linux/slab.h>
14
15 #define BU21023_NAME "bu21023_ts"
16 #define BU21023_FIRMWARE_NAME "bu21023.bin"
17
18 #define MAX_CONTACTS 2
19
20 #define AXIS_ADJUST 4
21 #define AXIS_OFFSET 8
22
23 #define FIRMWARE_BLOCK_SIZE 32U
24 #define FIRMWARE_RETRY_MAX 4
25
26 #define SAMPLING_DELAY 12 /* msec */
27
28 #define CALIBRATION_RETRY_MAX 6
29
30 #define ROHM_TS_ABS_X_MIN 40
31 #define ROHM_TS_ABS_X_MAX 990
32 #define ROHM_TS_ABS_Y_MIN 160
33 #define ROHM_TS_ABS_Y_MAX 920
34 #define ROHM_TS_DISPLACEMENT_MAX 0 /* zero for infinite */
35
36 /*
37 * BU21023GUL/BU21023MUV/BU21024FV-M registers map
38 */
39 #define VADOUT_YP_H 0x00
40 #define VADOUT_YP_L 0x01
41 #define VADOUT_XP_H 0x02
42 #define VADOUT_XP_L 0x03
43 #define VADOUT_YN_H 0x04
44 #define VADOUT_YN_L 0x05
45 #define VADOUT_XN_H 0x06
46 #define VADOUT_XN_L 0x07
47
48 #define PRM1_X_H 0x08
49 #define PRM1_X_L 0x09
50 #define PRM1_Y_H 0x0a
51 #define PRM1_Y_L 0x0b
52 #define PRM2_X_H 0x0c
53 #define PRM2_X_L 0x0d
54 #define PRM2_Y_H 0x0e
55 #define PRM2_Y_L 0x0f
56
57 #define MLT_PRM_MONI_X 0x10
58 #define MLT_PRM_MONI_Y 0x11
59
60 #define DEBUG_MONI_1 0x12
61 #define DEBUG_MONI_2 0x13
62
63 #define VADOUT_ZX_H 0x14
64 #define VADOUT_ZX_L 0x15
65 #define VADOUT_ZY_H 0x16
66 #define VADOUT_ZY_L 0x17
67
68 #define Z_PARAM_H 0x18
69 #define Z_PARAM_L 0x19
70
71 /*
72 * Value for VADOUT_*_L
73 */
74 #define VADOUT_L_MASK 0x01
75
76 /*
77 * Value for PRM*_*_L
78 */
79 #define PRM_L_MASK 0x01
80
81 #define POS_X1_H 0x20
82 #define POS_X1_L 0x21
83 #define POS_Y1_H 0x22
84 #define POS_Y1_L 0x23
85 #define POS_X2_H 0x24
86 #define POS_X2_L 0x25
87 #define POS_Y2_H 0x26
88 #define POS_Y2_L 0x27
89
90 /*
91 * Value for POS_*_L
92 */
93 #define POS_L_MASK 0x01
94
95 #define TOUCH 0x28
96 #define TOUCH_DETECT 0x01
97
98 #define TOUCH_GESTURE 0x29
99 #define SINGLE_TOUCH 0x01
100 #define DUAL_TOUCH 0x03
101 #define TOUCH_MASK 0x03
102 #define CALIBRATION_REQUEST 0x04
103 #define CALIBRATION_STATUS 0x08
104 #define CALIBRATION_MASK 0x0c
105 #define GESTURE_SPREAD 0x10
106 #define GESTURE_PINCH 0x20
107 #define GESTURE_ROTATE_R 0x40
108 #define GESTURE_ROTATE_L 0x80
109
110 #define INT_STATUS 0x2a
111 #define INT_MASK 0x3d
112 #define INT_CLEAR 0x3e
113
114 /*
115 * Values for INT_*
116 */
117 #define COORD_UPDATE 0x01
118 #define CALIBRATION_DONE 0x02
119 #define SLEEP_IN 0x04
120 #define SLEEP_OUT 0x08
121 #define PROGRAM_LOAD_DONE 0x10
122 #define ERROR 0x80
123 #define INT_ALL 0x9f
124
125 #define ERR_STATUS 0x2b
126 #define ERR_MASK 0x3f
127
128 /*
129 * Values for ERR_*
130 */
131 #define ADC_TIMEOUT 0x01
132 #define CPU_TIMEOUT 0x02
133 #define CALIBRATION_ERR 0x04
134 #define PROGRAM_LOAD_ERR 0x10
135
136 #define COMMON_SETUP1 0x30
137 #define PROGRAM_LOAD_HOST 0x02
138 #define PROGRAM_LOAD_EEPROM 0x03
139 #define CENSOR_4PORT 0x04
140 #define CENSOR_8PORT 0x00 /* Not supported by BU21023 */
141 #define CALIBRATION_TYPE_DEFAULT 0x08
142 #define CALIBRATION_TYPE_SPECIAL 0x00
143 #define INT_ACTIVE_HIGH 0x10
144 #define INT_ACTIVE_LOW 0x00
145 #define AUTO_CALIBRATION 0x40
146 #define MANUAL_CALIBRATION 0x00
147 #define COMMON_SETUP1_DEFAULT 0x4e
148
149 #define COMMON_SETUP2 0x31
150 #define MAF_NONE 0x00
151 #define MAF_1SAMPLE 0x01
152 #define MAF_3SAMPLES 0x02
153 #define MAF_5SAMPLES 0x03
154 #define INV_Y 0x04
155 #define INV_X 0x08
156 #define SWAP_XY 0x10
157
158 #define COMMON_SETUP3 0x32
159 #define EN_SLEEP 0x01
160 #define EN_MULTI 0x02
161 #define EN_GESTURE 0x04
162 #define EN_INTVL 0x08
163 #define SEL_STEP 0x10
164 #define SEL_MULTI 0x20
165 #define SEL_TBL_DEFAULT 0x40
166
167 #define INTERVAL_TIME 0x33
168 #define INTERVAL_TIME_DEFAULT 0x10
169
170 #define STEP_X 0x34
171 #define STEP_X_DEFAULT 0x41
172
173 #define STEP_Y 0x35
174 #define STEP_Y_DEFAULT 0x8d
175
176 #define OFFSET_X 0x38
177 #define OFFSET_X_DEFAULT 0x0c
178
179 #define OFFSET_Y 0x39
180 #define OFFSET_Y_DEFAULT 0x0c
181
182 #define THRESHOLD_TOUCH 0x3a
183 #define THRESHOLD_TOUCH_DEFAULT 0xa0
184
185 #define THRESHOLD_GESTURE 0x3b
186 #define THRESHOLD_GESTURE_DEFAULT 0x17
187
188 #define SYSTEM 0x40
189 #define ANALOG_POWER_ON 0x01
190 #define ANALOG_POWER_OFF 0x00
191 #define CPU_POWER_ON 0x02
192 #define CPU_POWER_OFF 0x00
193
194 #define FORCE_CALIBRATION 0x42
195 #define FORCE_CALIBRATION_ON 0x01
196 #define FORCE_CALIBRATION_OFF 0x00
197
198 #define CPU_FREQ 0x50 /* 10 / (reg + 1) MHz */
199 #define CPU_FREQ_10MHZ 0x00
200 #define CPU_FREQ_5MHZ 0x01
201 #define CPU_FREQ_1MHZ 0x09
202
203 #define EEPROM_ADDR 0x51
204
205 #define CALIBRATION_ADJUST 0x52
206 #define CALIBRATION_ADJUST_DEFAULT 0x00
207
208 #define THRESHOLD_SLEEP_IN 0x53
209
210 #define EVR_XY 0x56
211 #define EVR_XY_DEFAULT 0x10
212
213 #define PRM_SWOFF_TIME 0x57
214 #define PRM_SWOFF_TIME_DEFAULT 0x04
215
216 #define PROGRAM_VERSION 0x5f
217
218 #define ADC_CTRL 0x60
219 #define ADC_DIV_MASK 0x1f /* The minimum value is 4 */
220 #define ADC_DIV_DEFAULT 0x08
221
222 #define ADC_WAIT 0x61
223 #define ADC_WAIT_DEFAULT 0x0a
224
225 #define SWCONT 0x62
226 #define SWCONT_DEFAULT 0x0f
227
228 #define EVR_X 0x63
229 #define EVR_X_DEFAULT 0x86
230
231 #define EVR_Y 0x64
232 #define EVR_Y_DEFAULT 0x64
233
234 #define TEST1 0x65
235 #define DUALTOUCH_STABILIZE_ON 0x01
236 #define DUALTOUCH_STABILIZE_OFF 0x00
237 #define DUALTOUCH_REG_ON 0x20
238 #define DUALTOUCH_REG_OFF 0x00
239
240 #define CALIBRATION_REG1 0x68
241 #define CALIBRATION_REG1_DEFAULT 0xd9
242
243 #define CALIBRATION_REG2 0x69
244 #define CALIBRATION_REG2_DEFAULT 0x36
245
246 #define CALIBRATION_REG3 0x6a
247 #define CALIBRATION_REG3_DEFAULT 0x32
248
249 #define EX_ADDR_H 0x70
250 #define EX_ADDR_L 0x71
251 #define EX_WDAT 0x72
252 #define EX_RDAT 0x73
253 #define EX_CHK_SUM1 0x74
254 #define EX_CHK_SUM2 0x75
255 #define EX_CHK_SUM3 0x76
256
257 struct rohm_ts_data {
258 struct i2c_client *client;
259 struct input_dev *input;
260
261 bool initialized;
262
263 unsigned int contact_count[MAX_CONTACTS + 1];
264 int finger_count;
265
266 u8 setup2;
267 };
268
269 /*
270 * rohm_i2c_burst_read - execute combined I2C message for ROHM BU21023/24
271 * @client: Handle to ROHM BU21023/24
272 * @start: Where to start read address from ROHM BU21023/24
273 * @buf: Where to store read data from ROHM BU21023/24
274 * @len: How many bytes to read
275 *
276 * Returns negative errno, else zero on success.
277 *
278 * Note
279 * In BU21023/24 burst read, stop condition is needed after "address write".
280 * Therefore, transmission is performed in 2 steps.
281 */
rohm_i2c_burst_read(struct i2c_client * client,u8 start,void * buf,size_t len)282 static int rohm_i2c_burst_read(struct i2c_client *client, u8 start, void *buf,
283 size_t len)
284 {
285 struct i2c_adapter *adap = client->adapter;
286 struct i2c_msg msg[2];
287 int i, ret = 0;
288
289 msg[0].addr = client->addr;
290 msg[0].flags = 0;
291 msg[0].len = 1;
292 msg[0].buf = &start;
293
294 msg[1].addr = client->addr;
295 msg[1].flags = I2C_M_RD;
296 msg[1].len = len;
297 msg[1].buf = buf;
298
299 i2c_lock_bus(adap, I2C_LOCK_SEGMENT);
300
301 for (i = 0; i < 2; i++) {
302 if (__i2c_transfer(adap, &msg[i], 1) < 0) {
303 ret = -EIO;
304 break;
305 }
306 }
307
308 i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);
309
310 return ret;
311 }
312
rohm_ts_manual_calibration(struct rohm_ts_data * ts)313 static int rohm_ts_manual_calibration(struct rohm_ts_data *ts)
314 {
315 struct i2c_client *client = ts->client;
316 struct device *dev = &client->dev;
317 u8 buf[33]; /* for PRM1_X_H(0x08)-TOUCH(0x28) */
318
319 int retry;
320 bool success = false;
321 bool first_time = true;
322 bool calibration_done;
323
324 u8 reg1, reg2, reg3;
325 s32 reg1_orig, reg2_orig, reg3_orig;
326 s32 val;
327
328 int calib_x = 0, calib_y = 0;
329 int reg_x, reg_y;
330 int err_x, err_y;
331
332 int error, error2;
333 int i;
334
335 reg1_orig = i2c_smbus_read_byte_data(client, CALIBRATION_REG1);
336 if (reg1_orig < 0)
337 return reg1_orig;
338
339 reg2_orig = i2c_smbus_read_byte_data(client, CALIBRATION_REG2);
340 if (reg2_orig < 0)
341 return reg2_orig;
342
343 reg3_orig = i2c_smbus_read_byte_data(client, CALIBRATION_REG3);
344 if (reg3_orig < 0)
345 return reg3_orig;
346
347 error = i2c_smbus_write_byte_data(client, INT_MASK,
348 COORD_UPDATE | SLEEP_IN | SLEEP_OUT |
349 PROGRAM_LOAD_DONE);
350 if (error)
351 goto out;
352
353 error = i2c_smbus_write_byte_data(client, TEST1,
354 DUALTOUCH_STABILIZE_ON);
355 if (error)
356 goto out;
357
358 for (retry = 0; retry < CALIBRATION_RETRY_MAX; retry++) {
359 /* wait 2 sampling for update */
360 mdelay(2 * SAMPLING_DELAY);
361
362 #define READ_CALIB_BUF(reg) buf[((reg) - PRM1_X_H)]
363
364 error = rohm_i2c_burst_read(client, PRM1_X_H, buf, sizeof(buf));
365 if (error)
366 goto out;
367
368 if (READ_CALIB_BUF(TOUCH) & TOUCH_DETECT)
369 continue;
370
371 if (first_time) {
372 /* generate calibration parameter */
373 calib_x = ((int)READ_CALIB_BUF(PRM1_X_H) << 2 |
374 READ_CALIB_BUF(PRM1_X_L)) - AXIS_OFFSET;
375 calib_y = ((int)READ_CALIB_BUF(PRM1_Y_H) << 2 |
376 READ_CALIB_BUF(PRM1_Y_L)) - AXIS_OFFSET;
377
378 error = i2c_smbus_write_byte_data(client, TEST1,
379 DUALTOUCH_STABILIZE_ON | DUALTOUCH_REG_ON);
380 if (error)
381 goto out;
382
383 first_time = false;
384 } else {
385 /* generate adjustment parameter */
386 err_x = (int)READ_CALIB_BUF(PRM1_X_H) << 2 |
387 READ_CALIB_BUF(PRM1_X_L);
388 err_y = (int)READ_CALIB_BUF(PRM1_Y_H) << 2 |
389 READ_CALIB_BUF(PRM1_Y_L);
390
391 /* X axis ajust */
392 if (err_x <= 4)
393 calib_x -= AXIS_ADJUST;
394 else if (err_x >= 60)
395 calib_x += AXIS_ADJUST;
396
397 /* Y axis ajust */
398 if (err_y <= 4)
399 calib_y -= AXIS_ADJUST;
400 else if (err_y >= 60)
401 calib_y += AXIS_ADJUST;
402 }
403
404 /* generate calibration setting value */
405 reg_x = calib_x + ((calib_x & 0x200) << 1);
406 reg_y = calib_y + ((calib_y & 0x200) << 1);
407
408 /* convert for register format */
409 reg1 = reg_x >> 3;
410 reg2 = (reg_y & 0x7) << 4 | (reg_x & 0x7);
411 reg3 = reg_y >> 3;
412
413 error = i2c_smbus_write_byte_data(client,
414 CALIBRATION_REG1, reg1);
415 if (error)
416 goto out;
417
418 error = i2c_smbus_write_byte_data(client,
419 CALIBRATION_REG2, reg2);
420 if (error)
421 goto out;
422
423 error = i2c_smbus_write_byte_data(client,
424 CALIBRATION_REG3, reg3);
425 if (error)
426 goto out;
427
428 /*
429 * force calibration sequcence
430 */
431 error = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
432 FORCE_CALIBRATION_OFF);
433 if (error)
434 goto out;
435
436 error = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
437 FORCE_CALIBRATION_ON);
438 if (error)
439 goto out;
440
441 /* clear all interrupts */
442 error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
443 if (error)
444 goto out;
445
446 /*
447 * Wait for the status change of calibration, max 10 sampling
448 */
449 calibration_done = false;
450
451 for (i = 0; i < 10; i++) {
452 mdelay(SAMPLING_DELAY);
453
454 val = i2c_smbus_read_byte_data(client, TOUCH_GESTURE);
455 if (!(val & CALIBRATION_MASK)) {
456 calibration_done = true;
457 break;
458 } else if (val < 0) {
459 error = val;
460 goto out;
461 }
462 }
463
464 if (calibration_done) {
465 val = i2c_smbus_read_byte_data(client, INT_STATUS);
466 if (val == CALIBRATION_DONE) {
467 success = true;
468 break;
469 } else if (val < 0) {
470 error = val;
471 goto out;
472 }
473 } else {
474 dev_warn(dev, "calibration timeout\n");
475 }
476 }
477
478 if (!success) {
479 error = i2c_smbus_write_byte_data(client, CALIBRATION_REG1,
480 reg1_orig);
481 if (error)
482 goto out;
483
484 error = i2c_smbus_write_byte_data(client, CALIBRATION_REG2,
485 reg2_orig);
486 if (error)
487 goto out;
488
489 error = i2c_smbus_write_byte_data(client, CALIBRATION_REG3,
490 reg3_orig);
491 if (error)
492 goto out;
493
494 /* calibration data enable */
495 error = i2c_smbus_write_byte_data(client, TEST1,
496 DUALTOUCH_STABILIZE_ON |
497 DUALTOUCH_REG_ON);
498 if (error)
499 goto out;
500
501 /* wait 10 sampling */
502 mdelay(10 * SAMPLING_DELAY);
503
504 error = -EBUSY;
505 }
506
507 out:
508 error2 = i2c_smbus_write_byte_data(client, INT_MASK, INT_ALL);
509 if (!error2)
510 /* Clear all interrupts */
511 error2 = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
512
513 return error ? error : error2;
514 }
515
516 static const unsigned int untouch_threshold[3] = { 0, 1, 5 };
517 static const unsigned int single_touch_threshold[3] = { 0, 0, 4 };
518 static const unsigned int dual_touch_threshold[3] = { 10, 8, 0 };
519
rohm_ts_soft_irq(int irq,void * dev_id)520 static irqreturn_t rohm_ts_soft_irq(int irq, void *dev_id)
521 {
522 struct rohm_ts_data *ts = dev_id;
523 struct i2c_client *client = ts->client;
524 struct input_dev *input_dev = ts->input;
525 struct device *dev = &client->dev;
526
527 u8 buf[10]; /* for POS_X1_H(0x20)-TOUCH_GESTURE(0x29) */
528
529 struct input_mt_pos pos[MAX_CONTACTS];
530 int slots[MAX_CONTACTS];
531 u8 touch_flags;
532 unsigned int threshold;
533 int finger_count = -1;
534 int prev_finger_count = ts->finger_count;
535 int count;
536 int error;
537 int i;
538
539 error = i2c_smbus_write_byte_data(client, INT_MASK, INT_ALL);
540 if (error)
541 return IRQ_HANDLED;
542
543 /* Clear all interrupts */
544 error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
545 if (error)
546 return IRQ_HANDLED;
547
548 #define READ_POS_BUF(reg) buf[((reg) - POS_X1_H)]
549
550 error = rohm_i2c_burst_read(client, POS_X1_H, buf, sizeof(buf));
551 if (error)
552 return IRQ_HANDLED;
553
554 touch_flags = READ_POS_BUF(TOUCH_GESTURE) & TOUCH_MASK;
555 if (touch_flags) {
556 /* generate coordinates */
557 pos[0].x = ((s16)READ_POS_BUF(POS_X1_H) << 2) |
558 READ_POS_BUF(POS_X1_L);
559 pos[0].y = ((s16)READ_POS_BUF(POS_Y1_H) << 2) |
560 READ_POS_BUF(POS_Y1_L);
561 pos[1].x = ((s16)READ_POS_BUF(POS_X2_H) << 2) |
562 READ_POS_BUF(POS_X2_L);
563 pos[1].y = ((s16)READ_POS_BUF(POS_Y2_H) << 2) |
564 READ_POS_BUF(POS_Y2_L);
565 }
566
567 switch (touch_flags) {
568 case 0:
569 threshold = untouch_threshold[prev_finger_count];
570 if (++ts->contact_count[0] >= threshold)
571 finger_count = 0;
572 break;
573
574 case SINGLE_TOUCH:
575 threshold = single_touch_threshold[prev_finger_count];
576 if (++ts->contact_count[1] >= threshold)
577 finger_count = 1;
578
579 if (finger_count == 1) {
580 if (pos[1].x != 0 && pos[1].y != 0) {
581 pos[0].x = pos[1].x;
582 pos[0].y = pos[1].y;
583 pos[1].x = 0;
584 pos[1].y = 0;
585 }
586 }
587 break;
588
589 case DUAL_TOUCH:
590 threshold = dual_touch_threshold[prev_finger_count];
591 if (++ts->contact_count[2] >= threshold)
592 finger_count = 2;
593 break;
594
595 default:
596 dev_dbg(dev,
597 "Three or more touches are not supported\n");
598 return IRQ_HANDLED;
599 }
600
601 if (finger_count >= 0) {
602 if (prev_finger_count != finger_count) {
603 count = ts->contact_count[finger_count];
604 memset(ts->contact_count, 0, sizeof(ts->contact_count));
605 ts->contact_count[finger_count] = count;
606 }
607
608 input_mt_assign_slots(input_dev, slots, pos,
609 finger_count, ROHM_TS_DISPLACEMENT_MAX);
610
611 for (i = 0; i < finger_count; i++) {
612 input_mt_slot(input_dev, slots[i]);
613 input_mt_report_slot_state(input_dev,
614 MT_TOOL_FINGER, true);
615 input_report_abs(input_dev,
616 ABS_MT_POSITION_X, pos[i].x);
617 input_report_abs(input_dev,
618 ABS_MT_POSITION_Y, pos[i].y);
619 }
620
621 input_mt_sync_frame(input_dev);
622 input_mt_report_pointer_emulation(input_dev, true);
623 input_sync(input_dev);
624
625 ts->finger_count = finger_count;
626 }
627
628 if (READ_POS_BUF(TOUCH_GESTURE) & CALIBRATION_REQUEST) {
629 error = rohm_ts_manual_calibration(ts);
630 if (error)
631 dev_warn(dev, "manual calibration failed: %d\n",
632 error);
633 }
634
635 i2c_smbus_write_byte_data(client, INT_MASK,
636 CALIBRATION_DONE | SLEEP_OUT | SLEEP_IN |
637 PROGRAM_LOAD_DONE);
638
639 return IRQ_HANDLED;
640 }
641
rohm_ts_load_firmware(struct i2c_client * client,const char * firmware_name)642 static int rohm_ts_load_firmware(struct i2c_client *client,
643 const char *firmware_name)
644 {
645 struct device *dev = &client->dev;
646 const struct firmware *fw;
647 s32 status;
648 unsigned int offset, len, xfer_len;
649 unsigned int retry = 0;
650 int error, error2;
651
652 error = request_firmware(&fw, firmware_name, dev);
653 if (error) {
654 dev_err(dev, "unable to retrieve firmware %s: %d\n",
655 firmware_name, error);
656 return error;
657 }
658
659 error = i2c_smbus_write_byte_data(client, INT_MASK,
660 COORD_UPDATE | CALIBRATION_DONE |
661 SLEEP_IN | SLEEP_OUT);
662 if (error)
663 goto out;
664
665 do {
666 if (retry) {
667 dev_warn(dev, "retrying firmware load\n");
668
669 /* settings for retry */
670 error = i2c_smbus_write_byte_data(client, EX_WDAT, 0);
671 if (error)
672 goto out;
673 }
674
675 error = i2c_smbus_write_byte_data(client, EX_ADDR_H, 0);
676 if (error)
677 goto out;
678
679 error = i2c_smbus_write_byte_data(client, EX_ADDR_L, 0);
680 if (error)
681 goto out;
682
683 error = i2c_smbus_write_byte_data(client, COMMON_SETUP1,
684 COMMON_SETUP1_DEFAULT);
685 if (error)
686 goto out;
687
688 /* firmware load to the device */
689 offset = 0;
690 len = fw->size;
691
692 while (len) {
693 xfer_len = min(FIRMWARE_BLOCK_SIZE, len);
694
695 error = i2c_smbus_write_i2c_block_data(client, EX_WDAT,
696 xfer_len, &fw->data[offset]);
697 if (error)
698 goto out;
699
700 len -= xfer_len;
701 offset += xfer_len;
702 }
703
704 /* check firmware load result */
705 status = i2c_smbus_read_byte_data(client, INT_STATUS);
706 if (status < 0) {
707 error = status;
708 goto out;
709 }
710
711 /* clear all interrupts */
712 error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
713 if (error)
714 goto out;
715
716 if (status == PROGRAM_LOAD_DONE)
717 break;
718
719 error = -EIO;
720 } while (++retry <= FIRMWARE_RETRY_MAX);
721
722 out:
723 error2 = i2c_smbus_write_byte_data(client, INT_MASK, INT_ALL);
724
725 release_firmware(fw);
726
727 return error ? error : error2;
728 }
729
swap_xy_show(struct device * dev,struct device_attribute * attr,char * buf)730 static ssize_t swap_xy_show(struct device *dev, struct device_attribute *attr,
731 char *buf)
732 {
733 struct i2c_client *client = to_i2c_client(dev);
734 struct rohm_ts_data *ts = i2c_get_clientdata(client);
735
736 return sprintf(buf, "%d\n", !!(ts->setup2 & SWAP_XY));
737 }
738
swap_xy_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)739 static ssize_t swap_xy_store(struct device *dev, struct device_attribute *attr,
740 const char *buf, size_t count)
741 {
742 struct i2c_client *client = to_i2c_client(dev);
743 struct rohm_ts_data *ts = i2c_get_clientdata(client);
744 unsigned int val;
745 int error;
746
747 error = kstrtouint(buf, 0, &val);
748 if (error)
749 return error;
750
751 error = mutex_lock_interruptible(&ts->input->mutex);
752 if (error)
753 return error;
754
755 if (val)
756 ts->setup2 |= SWAP_XY;
757 else
758 ts->setup2 &= ~SWAP_XY;
759
760 if (ts->initialized)
761 error = i2c_smbus_write_byte_data(ts->client, COMMON_SETUP2,
762 ts->setup2);
763
764 mutex_unlock(&ts->input->mutex);
765
766 return error ? error : count;
767 }
768
inv_x_show(struct device * dev,struct device_attribute * attr,char * buf)769 static ssize_t inv_x_show(struct device *dev, struct device_attribute *attr,
770 char *buf)
771 {
772 struct i2c_client *client = to_i2c_client(dev);
773 struct rohm_ts_data *ts = i2c_get_clientdata(client);
774
775 return sprintf(buf, "%d\n", !!(ts->setup2 & INV_X));
776 }
777
inv_x_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)778 static ssize_t inv_x_store(struct device *dev, struct device_attribute *attr,
779 const char *buf, size_t count)
780 {
781 struct i2c_client *client = to_i2c_client(dev);
782 struct rohm_ts_data *ts = i2c_get_clientdata(client);
783 unsigned int val;
784 int error;
785
786 error = kstrtouint(buf, 0, &val);
787 if (error)
788 return error;
789
790 error = mutex_lock_interruptible(&ts->input->mutex);
791 if (error)
792 return error;
793
794 if (val)
795 ts->setup2 |= INV_X;
796 else
797 ts->setup2 &= ~INV_X;
798
799 if (ts->initialized)
800 error = i2c_smbus_write_byte_data(ts->client, COMMON_SETUP2,
801 ts->setup2);
802
803 mutex_unlock(&ts->input->mutex);
804
805 return error ? error : count;
806 }
807
inv_y_show(struct device * dev,struct device_attribute * attr,char * buf)808 static ssize_t inv_y_show(struct device *dev, struct device_attribute *attr,
809 char *buf)
810 {
811 struct i2c_client *client = to_i2c_client(dev);
812 struct rohm_ts_data *ts = i2c_get_clientdata(client);
813
814 return sprintf(buf, "%d\n", !!(ts->setup2 & INV_Y));
815 }
816
inv_y_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)817 static ssize_t inv_y_store(struct device *dev, struct device_attribute *attr,
818 const char *buf, size_t count)
819 {
820 struct i2c_client *client = to_i2c_client(dev);
821 struct rohm_ts_data *ts = i2c_get_clientdata(client);
822 unsigned int val;
823 int error;
824
825 error = kstrtouint(buf, 0, &val);
826 if (error)
827 return error;
828
829 error = mutex_lock_interruptible(&ts->input->mutex);
830 if (error)
831 return error;
832
833 if (val)
834 ts->setup2 |= INV_Y;
835 else
836 ts->setup2 &= ~INV_Y;
837
838 if (ts->initialized)
839 error = i2c_smbus_write_byte_data(client, COMMON_SETUP2,
840 ts->setup2);
841
842 mutex_unlock(&ts->input->mutex);
843
844 return error ? error : count;
845 }
846
847 static DEVICE_ATTR_RW(swap_xy);
848 static DEVICE_ATTR_RW(inv_x);
849 static DEVICE_ATTR_RW(inv_y);
850
851 static struct attribute *rohm_ts_attrs[] = {
852 &dev_attr_swap_xy.attr,
853 &dev_attr_inv_x.attr,
854 &dev_attr_inv_y.attr,
855 NULL,
856 };
857
858 static const struct attribute_group rohm_ts_attr_group = {
859 .attrs = rohm_ts_attrs,
860 };
861
rohm_ts_device_init(struct i2c_client * client,u8 setup2)862 static int rohm_ts_device_init(struct i2c_client *client, u8 setup2)
863 {
864 struct device *dev = &client->dev;
865 int error;
866
867 disable_irq(client->irq);
868
869 /*
870 * Wait 200usec for reset
871 */
872 udelay(200);
873
874 /* Release analog reset */
875 error = i2c_smbus_write_byte_data(client, SYSTEM,
876 ANALOG_POWER_ON | CPU_POWER_OFF);
877 if (error)
878 return error;
879
880 /* Waiting for the analog warm-up, max. 200usec */
881 udelay(200);
882
883 /* clear all interrupts */
884 error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
885 if (error)
886 return error;
887
888 error = i2c_smbus_write_byte_data(client, EX_WDAT, 0);
889 if (error)
890 return error;
891
892 error = i2c_smbus_write_byte_data(client, COMMON_SETUP1, 0);
893 if (error)
894 return error;
895
896 error = i2c_smbus_write_byte_data(client, COMMON_SETUP2, setup2);
897 if (error)
898 return error;
899
900 error = i2c_smbus_write_byte_data(client, COMMON_SETUP3,
901 SEL_TBL_DEFAULT | EN_MULTI);
902 if (error)
903 return error;
904
905 error = i2c_smbus_write_byte_data(client, THRESHOLD_GESTURE,
906 THRESHOLD_GESTURE_DEFAULT);
907 if (error)
908 return error;
909
910 error = i2c_smbus_write_byte_data(client, INTERVAL_TIME,
911 INTERVAL_TIME_DEFAULT);
912 if (error)
913 return error;
914
915 error = i2c_smbus_write_byte_data(client, CPU_FREQ, CPU_FREQ_10MHZ);
916 if (error)
917 return error;
918
919 error = i2c_smbus_write_byte_data(client, PRM_SWOFF_TIME,
920 PRM_SWOFF_TIME_DEFAULT);
921 if (error)
922 return error;
923
924 error = i2c_smbus_write_byte_data(client, ADC_CTRL, ADC_DIV_DEFAULT);
925 if (error)
926 return error;
927
928 error = i2c_smbus_write_byte_data(client, ADC_WAIT, ADC_WAIT_DEFAULT);
929 if (error)
930 return error;
931
932 /*
933 * Panel setup, these values change with the panel.
934 */
935 error = i2c_smbus_write_byte_data(client, STEP_X, STEP_X_DEFAULT);
936 if (error)
937 return error;
938
939 error = i2c_smbus_write_byte_data(client, STEP_Y, STEP_Y_DEFAULT);
940 if (error)
941 return error;
942
943 error = i2c_smbus_write_byte_data(client, OFFSET_X, OFFSET_X_DEFAULT);
944 if (error)
945 return error;
946
947 error = i2c_smbus_write_byte_data(client, OFFSET_Y, OFFSET_Y_DEFAULT);
948 if (error)
949 return error;
950
951 error = i2c_smbus_write_byte_data(client, THRESHOLD_TOUCH,
952 THRESHOLD_TOUCH_DEFAULT);
953 if (error)
954 return error;
955
956 error = i2c_smbus_write_byte_data(client, EVR_XY, EVR_XY_DEFAULT);
957 if (error)
958 return error;
959
960 error = i2c_smbus_write_byte_data(client, EVR_X, EVR_X_DEFAULT);
961 if (error)
962 return error;
963
964 error = i2c_smbus_write_byte_data(client, EVR_Y, EVR_Y_DEFAULT);
965 if (error)
966 return error;
967
968 /* Fixed value settings */
969 error = i2c_smbus_write_byte_data(client, CALIBRATION_ADJUST,
970 CALIBRATION_ADJUST_DEFAULT);
971 if (error)
972 return error;
973
974 error = i2c_smbus_write_byte_data(client, SWCONT, SWCONT_DEFAULT);
975 if (error)
976 return error;
977
978 error = i2c_smbus_write_byte_data(client, TEST1,
979 DUALTOUCH_STABILIZE_ON |
980 DUALTOUCH_REG_ON);
981 if (error)
982 return error;
983
984 error = rohm_ts_load_firmware(client, BU21023_FIRMWARE_NAME);
985 if (error) {
986 dev_err(dev, "failed to load firmware: %d\n", error);
987 return error;
988 }
989
990 /*
991 * Manual calibration results are not changed in same environment.
992 * If the force calibration is performed,
993 * the controller will not require calibration request interrupt
994 * when the typical values are set to the calibration registers.
995 */
996 error = i2c_smbus_write_byte_data(client, CALIBRATION_REG1,
997 CALIBRATION_REG1_DEFAULT);
998 if (error)
999 return error;
1000
1001 error = i2c_smbus_write_byte_data(client, CALIBRATION_REG2,
1002 CALIBRATION_REG2_DEFAULT);
1003 if (error)
1004 return error;
1005
1006 error = i2c_smbus_write_byte_data(client, CALIBRATION_REG3,
1007 CALIBRATION_REG3_DEFAULT);
1008 if (error)
1009 return error;
1010
1011 error = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
1012 FORCE_CALIBRATION_OFF);
1013 if (error)
1014 return error;
1015
1016 error = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
1017 FORCE_CALIBRATION_ON);
1018 if (error)
1019 return error;
1020
1021 /* Clear all interrupts */
1022 error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
1023 if (error)
1024 return error;
1025
1026 /* Enable coordinates update interrupt */
1027 error = i2c_smbus_write_byte_data(client, INT_MASK,
1028 CALIBRATION_DONE | SLEEP_OUT |
1029 SLEEP_IN | PROGRAM_LOAD_DONE);
1030 if (error)
1031 return error;
1032
1033 error = i2c_smbus_write_byte_data(client, ERR_MASK,
1034 PROGRAM_LOAD_ERR | CPU_TIMEOUT |
1035 ADC_TIMEOUT);
1036 if (error)
1037 return error;
1038
1039 /* controller CPU power on */
1040 error = i2c_smbus_write_byte_data(client, SYSTEM,
1041 ANALOG_POWER_ON | CPU_POWER_ON);
1042
1043 enable_irq(client->irq);
1044
1045 return error;
1046 }
1047
rohm_ts_power_off(struct i2c_client * client)1048 static int rohm_ts_power_off(struct i2c_client *client)
1049 {
1050 int error;
1051
1052 error = i2c_smbus_write_byte_data(client, SYSTEM,
1053 ANALOG_POWER_ON | CPU_POWER_OFF);
1054 if (error) {
1055 dev_err(&client->dev,
1056 "failed to power off device CPU: %d\n", error);
1057 return error;
1058 }
1059
1060 error = i2c_smbus_write_byte_data(client, SYSTEM,
1061 ANALOG_POWER_OFF | CPU_POWER_OFF);
1062 if (error)
1063 dev_err(&client->dev,
1064 "failed to power off the device: %d\n", error);
1065
1066 return error;
1067 }
1068
rohm_ts_open(struct input_dev * input_dev)1069 static int rohm_ts_open(struct input_dev *input_dev)
1070 {
1071 struct rohm_ts_data *ts = input_get_drvdata(input_dev);
1072 struct i2c_client *client = ts->client;
1073 int error;
1074
1075 if (!ts->initialized) {
1076 error = rohm_ts_device_init(client, ts->setup2);
1077 if (error) {
1078 dev_err(&client->dev,
1079 "device initialization failed: %d\n", error);
1080 return error;
1081 }
1082
1083 ts->initialized = true;
1084 }
1085
1086 return 0;
1087 }
1088
rohm_ts_close(struct input_dev * input_dev)1089 static void rohm_ts_close(struct input_dev *input_dev)
1090 {
1091 struct rohm_ts_data *ts = input_get_drvdata(input_dev);
1092
1093 rohm_ts_power_off(ts->client);
1094
1095 ts->initialized = false;
1096 }
1097
rohm_bu21023_i2c_probe(struct i2c_client * client)1098 static int rohm_bu21023_i2c_probe(struct i2c_client *client)
1099 {
1100 struct device *dev = &client->dev;
1101 struct rohm_ts_data *ts;
1102 struct input_dev *input;
1103 int error;
1104
1105 if (!client->irq) {
1106 dev_err(dev, "IRQ is not assigned\n");
1107 return -EINVAL;
1108 }
1109
1110 if (!client->adapter->algo->master_xfer) {
1111 dev_err(dev, "I2C level transfers not supported\n");
1112 return -EOPNOTSUPP;
1113 }
1114
1115 /* Turn off CPU just in case */
1116 error = rohm_ts_power_off(client);
1117 if (error)
1118 return error;
1119
1120 ts = devm_kzalloc(dev, sizeof(struct rohm_ts_data), GFP_KERNEL);
1121 if (!ts)
1122 return -ENOMEM;
1123
1124 ts->client = client;
1125 ts->setup2 = MAF_1SAMPLE;
1126 i2c_set_clientdata(client, ts);
1127
1128 input = devm_input_allocate_device(dev);
1129 if (!input)
1130 return -ENOMEM;
1131
1132 input->name = BU21023_NAME;
1133 input->id.bustype = BUS_I2C;
1134 input->open = rohm_ts_open;
1135 input->close = rohm_ts_close;
1136
1137 ts->input = input;
1138 input_set_drvdata(input, ts);
1139
1140 input_set_abs_params(input, ABS_MT_POSITION_X,
1141 ROHM_TS_ABS_X_MIN, ROHM_TS_ABS_X_MAX, 0, 0);
1142 input_set_abs_params(input, ABS_MT_POSITION_Y,
1143 ROHM_TS_ABS_Y_MIN, ROHM_TS_ABS_Y_MAX, 0, 0);
1144
1145 error = input_mt_init_slots(input, MAX_CONTACTS,
1146 INPUT_MT_DIRECT | INPUT_MT_TRACK |
1147 INPUT_MT_DROP_UNUSED);
1148 if (error) {
1149 dev_err(dev, "failed to multi touch slots initialization\n");
1150 return error;
1151 }
1152
1153 error = devm_request_threaded_irq(dev, client->irq,
1154 NULL, rohm_ts_soft_irq,
1155 IRQF_ONESHOT, client->name, ts);
1156 if (error) {
1157 dev_err(dev, "failed to request IRQ: %d\n", error);
1158 return error;
1159 }
1160
1161 error = input_register_device(input);
1162 if (error) {
1163 dev_err(dev, "failed to register input device: %d\n", error);
1164 return error;
1165 }
1166
1167 error = devm_device_add_group(dev, &rohm_ts_attr_group);
1168 if (error) {
1169 dev_err(dev, "failed to create sysfs group: %d\n", error);
1170 return error;
1171 }
1172
1173 return error;
1174 }
1175
1176 static const struct i2c_device_id rohm_bu21023_i2c_id[] = {
1177 { BU21023_NAME, 0 },
1178 { /* sentinel */ }
1179 };
1180 MODULE_DEVICE_TABLE(i2c, rohm_bu21023_i2c_id);
1181
1182 static struct i2c_driver rohm_bu21023_i2c_driver = {
1183 .driver = {
1184 .name = BU21023_NAME,
1185 },
1186 .probe = rohm_bu21023_i2c_probe,
1187 .id_table = rohm_bu21023_i2c_id,
1188 };
1189 module_i2c_driver(rohm_bu21023_i2c_driver);
1190
1191 MODULE_DESCRIPTION("ROHM BU21023/24 Touchscreen driver");
1192 MODULE_LICENSE("GPL v2");
1193 MODULE_AUTHOR("ROHM Co., Ltd.");
1194