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