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  */
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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_new = 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