2 * Copyright (C) 2012 Simon Budig, <simon.budig@kernelconcepts.de>
3 * Daniel Wagener <daniel.wagener@kernelconcepts.de> (M09 firmware support)
4 * Lothar Waßmann <LW@KARO-electronics.de> (DT support)
6 * This software is licensed under the terms of the GNU General Public
7 * License version 2, as published by the Free Software Foundation, and
8 * may be copied, distributed, and modified under those terms.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 * This is a driver for the EDT "Polytouch" family of touch controllers
22 * based on the FocalTech FT5x06 line of chips.
24 * Development of this driver has been sponsored by Glyn:
25 * http://www.glyn.com/Products/Displays
28 #include <linux/module.h>
29 #include <linux/ratelimit.h>
30 #include <linux/interrupt.h>
31 #include <linux/input.h>
32 #include <linux/i2c.h>
33 #include <linux/uaccess.h>
34 #include <linux/delay.h>
35 #include <linux/debugfs.h>
36 #include <linux/slab.h>
37 #include <linux/gpio.h>
38 #include <linux/of_gpio.h>
39 #include <linux/input/mt.h>
40 #include <linux/input/edt-ft5x06.h>
42 #define MAX_SUPPORT_POINTS 5
44 #define WORK_REGISTER_THRESHOLD 0x00
45 #define WORK_REGISTER_REPORT_RATE 0x08
46 #define WORK_REGISTER_GAIN 0x30
47 #define WORK_REGISTER_OFFSET 0x31
48 #define WORK_REGISTER_NUM_X 0x33
49 #define WORK_REGISTER_NUM_Y 0x34
51 #define M09_REGISTER_THRESHOLD 0x80
52 #define M09_REGISTER_GAIN 0x92
53 #define M09_REGISTER_OFFSET 0x93
54 #define M09_REGISTER_NUM_X 0x94
55 #define M09_REGISTER_NUM_Y 0x95
57 #define NO_REGISTER 0xff
59 #define WORK_REGISTER_OPMODE 0x3c
60 #define FACTORY_REGISTER_OPMODE 0x01
62 #define TOUCH_EVENT_DOWN 0x00
63 #define TOUCH_EVENT_UP 0x01
64 #define TOUCH_EVENT_ON 0x02
65 #define TOUCH_EVENT_RESERVED 0x03
67 #define EDT_NAME_LEN 23
68 #define EDT_SWITCH_MODE_RETRIES 10
69 #define EDT_SWITCH_MODE_DELAY 5 /* msec */
70 #define EDT_RAW_DATA_RETRIES 100
71 #define EDT_RAW_DATA_DELAY 1 /* msec */
87 struct edt_ft5x06_ts_data
{
88 struct i2c_client
*client
;
89 struct input_dev
*input
;
97 #if defined(CONFIG_DEBUG_FS)
98 struct dentry
*debug_dir
;
110 char name
[EDT_NAME_LEN
];
112 struct edt_reg_addr reg_addr
;
113 enum edt_ver version
;
116 static int edt_ft5x06_ts_readwrite(struct i2c_client
*client
,
117 u16 wr_len
, u8
*wr_buf
,
118 u16 rd_len
, u8
*rd_buf
)
120 struct i2c_msg wrmsg
[2];
125 wrmsg
[i
].addr
= client
->addr
;
127 wrmsg
[i
].len
= wr_len
;
128 wrmsg
[i
].buf
= wr_buf
;
132 wrmsg
[i
].addr
= client
->addr
;
133 wrmsg
[i
].flags
= I2C_M_RD
;
134 wrmsg
[i
].len
= rd_len
;
135 wrmsg
[i
].buf
= rd_buf
;
139 ret
= i2c_transfer(client
->adapter
, wrmsg
, i
);
148 static bool edt_ft5x06_ts_check_crc(struct edt_ft5x06_ts_data
*tsdata
,
154 for (i
= 0; i
< buflen
- 1; i
++)
157 if (crc
!= buf
[buflen
-1]) {
158 dev_err_ratelimited(&tsdata
->client
->dev
,
159 "crc error: 0x%02x expected, got 0x%02x\n",
167 static irqreturn_t
edt_ft5x06_ts_isr(int irq
, void *dev_id
)
169 struct edt_ft5x06_ts_data
*tsdata
= dev_id
;
170 struct device
*dev
= &tsdata
->client
->dev
;
173 int i
, type
, x
, y
, id
;
174 int offset
, tplen
, datalen
;
177 switch (tsdata
->version
) {
179 cmd
= 0xf9; /* tell the controller to send touch data */
180 offset
= 5; /* where the actual touch data starts */
181 tplen
= 4; /* data comes in so called frames */
182 datalen
= 26; /* how much bytes to listen for */
196 memset(rdbuf
, 0, sizeof(rdbuf
));
198 error
= edt_ft5x06_ts_readwrite(tsdata
->client
,
202 dev_err_ratelimited(dev
, "Unable to fetch data, error: %d\n",
207 /* M09 does not send header or CRC */
208 if (tsdata
->version
== M06
) {
209 if (rdbuf
[0] != 0xaa || rdbuf
[1] != 0xaa ||
210 rdbuf
[2] != datalen
) {
211 dev_err_ratelimited(dev
,
212 "Unexpected header: %02x%02x%02x!\n",
213 rdbuf
[0], rdbuf
[1], rdbuf
[2]);
217 if (!edt_ft5x06_ts_check_crc(tsdata
, rdbuf
, datalen
))
221 for (i
= 0; i
< MAX_SUPPORT_POINTS
; i
++) {
222 u8
*buf
= &rdbuf
[i
* tplen
+ offset
];
226 /* ignore Reserved events */
227 if (type
== TOUCH_EVENT_RESERVED
)
230 /* M06 sometimes sends bogus coordinates in TOUCH_DOWN */
231 if (tsdata
->version
== M06
&& type
== TOUCH_EVENT_DOWN
)
234 x
= ((buf
[0] << 8) | buf
[1]) & 0x0fff;
235 y
= ((buf
[2] << 8) | buf
[3]) & 0x0fff;
236 id
= (buf
[2] >> 4) & 0x0f;
237 down
= type
!= TOUCH_EVENT_UP
;
239 input_mt_slot(tsdata
->input
, id
);
240 input_mt_report_slot_state(tsdata
->input
, MT_TOOL_FINGER
, down
);
245 input_report_abs(tsdata
->input
, ABS_MT_POSITION_X
, x
);
246 input_report_abs(tsdata
->input
, ABS_MT_POSITION_Y
, y
);
249 input_mt_report_pointer_emulation(tsdata
->input
, true);
250 input_sync(tsdata
->input
);
256 static int edt_ft5x06_register_write(struct edt_ft5x06_ts_data
*tsdata
,
261 switch (tsdata
->version
) {
263 wrbuf
[0] = tsdata
->factory_mode
? 0xf3 : 0xfc;
264 wrbuf
[1] = tsdata
->factory_mode
? addr
& 0x7f : addr
& 0x3f;
266 wrbuf
[3] = wrbuf
[0] ^ wrbuf
[1] ^ wrbuf
[2];
267 return edt_ft5x06_ts_readwrite(tsdata
->client
, 4,
273 return edt_ft5x06_ts_readwrite(tsdata
->client
, 2,
281 static int edt_ft5x06_register_read(struct edt_ft5x06_ts_data
*tsdata
,
284 u8 wrbuf
[2], rdbuf
[2];
287 switch (tsdata
->version
) {
289 wrbuf
[0] = tsdata
->factory_mode
? 0xf3 : 0xfc;
290 wrbuf
[1] = tsdata
->factory_mode
? addr
& 0x7f : addr
& 0x3f;
291 wrbuf
[1] |= tsdata
->factory_mode
? 0x80 : 0x40;
293 error
= edt_ft5x06_ts_readwrite(tsdata
->client
, 2, wrbuf
, 2,
298 if ((wrbuf
[0] ^ wrbuf
[1] ^ rdbuf
[0]) != rdbuf
[1]) {
299 dev_err(&tsdata
->client
->dev
,
300 "crc error: 0x%02x expected, got 0x%02x\n",
301 wrbuf
[0] ^ wrbuf
[1] ^ rdbuf
[0],
309 error
= edt_ft5x06_ts_readwrite(tsdata
->client
, 1,
322 struct edt_ft5x06_attribute
{
323 struct device_attribute dattr
;
331 #define EDT_ATTR(_field, _mode, _addr_m06, _addr_m09, \
332 _limit_low, _limit_high) \
333 struct edt_ft5x06_attribute edt_ft5x06_attr_##_field = { \
334 .dattr = __ATTR(_field, _mode, \
335 edt_ft5x06_setting_show, \
336 edt_ft5x06_setting_store), \
337 .field_offset = offsetof(struct edt_ft5x06_ts_data, _field), \
338 .addr_m06 = _addr_m06, \
339 .addr_m09 = _addr_m09, \
340 .limit_low = _limit_low, \
341 .limit_high = _limit_high, \
344 static ssize_t
edt_ft5x06_setting_show(struct device
*dev
,
345 struct device_attribute
*dattr
,
348 struct i2c_client
*client
= to_i2c_client(dev
);
349 struct edt_ft5x06_ts_data
*tsdata
= i2c_get_clientdata(client
);
350 struct edt_ft5x06_attribute
*attr
=
351 container_of(dattr
, struct edt_ft5x06_attribute
, dattr
);
352 u8
*field
= (u8
*)tsdata
+ attr
->field_offset
;
358 mutex_lock(&tsdata
->mutex
);
360 if (tsdata
->factory_mode
) {
365 switch (tsdata
->version
) {
367 addr
= attr
->addr_m06
;
371 addr
= attr
->addr_m09
;
379 if (addr
!= NO_REGISTER
) {
380 val
= edt_ft5x06_register_read(tsdata
, addr
);
383 dev_err(&tsdata
->client
->dev
,
384 "Failed to fetch attribute %s, error %d\n",
385 dattr
->attr
.name
, error
);
393 dev_warn(&tsdata
->client
->dev
,
394 "%s: read (%d) and stored value (%d) differ\n",
395 dattr
->attr
.name
, val
, *field
);
399 count
= scnprintf(buf
, PAGE_SIZE
, "%d\n", val
);
401 mutex_unlock(&tsdata
->mutex
);
402 return error
?: count
;
405 static ssize_t
edt_ft5x06_setting_store(struct device
*dev
,
406 struct device_attribute
*dattr
,
407 const char *buf
, size_t count
)
409 struct i2c_client
*client
= to_i2c_client(dev
);
410 struct edt_ft5x06_ts_data
*tsdata
= i2c_get_clientdata(client
);
411 struct edt_ft5x06_attribute
*attr
=
412 container_of(dattr
, struct edt_ft5x06_attribute
, dattr
);
413 u8
*field
= (u8
*)tsdata
+ attr
->field_offset
;
418 mutex_lock(&tsdata
->mutex
);
420 if (tsdata
->factory_mode
) {
425 error
= kstrtouint(buf
, 0, &val
);
429 if (val
< attr
->limit_low
|| val
> attr
->limit_high
) {
434 switch (tsdata
->version
) {
436 addr
= attr
->addr_m06
;
440 addr
= attr
->addr_m09
;
448 if (addr
!= NO_REGISTER
) {
449 error
= edt_ft5x06_register_write(tsdata
, addr
, val
);
451 dev_err(&tsdata
->client
->dev
,
452 "Failed to update attribute %s, error: %d\n",
453 dattr
->attr
.name
, error
);
460 mutex_unlock(&tsdata
->mutex
);
461 return error
?: count
;
464 static EDT_ATTR(gain
, S_IWUSR
| S_IRUGO
, WORK_REGISTER_GAIN
,
465 M09_REGISTER_GAIN
, 0, 31);
466 static EDT_ATTR(offset
, S_IWUSR
| S_IRUGO
, WORK_REGISTER_OFFSET
,
467 M09_REGISTER_OFFSET
, 0, 31);
468 static EDT_ATTR(threshold
, S_IWUSR
| S_IRUGO
, WORK_REGISTER_THRESHOLD
,
469 M09_REGISTER_THRESHOLD
, 20, 80);
470 static EDT_ATTR(report_rate
, S_IWUSR
| S_IRUGO
, WORK_REGISTER_REPORT_RATE
,
473 static struct attribute
*edt_ft5x06_attrs
[] = {
474 &edt_ft5x06_attr_gain
.dattr
.attr
,
475 &edt_ft5x06_attr_offset
.dattr
.attr
,
476 &edt_ft5x06_attr_threshold
.dattr
.attr
,
477 &edt_ft5x06_attr_report_rate
.dattr
.attr
,
481 static const struct attribute_group edt_ft5x06_attr_group
= {
482 .attrs
= edt_ft5x06_attrs
,
485 #ifdef CONFIG_DEBUG_FS
486 static int edt_ft5x06_factory_mode(struct edt_ft5x06_ts_data
*tsdata
)
488 struct i2c_client
*client
= tsdata
->client
;
489 int retries
= EDT_SWITCH_MODE_RETRIES
;
493 disable_irq(client
->irq
);
495 if (!tsdata
->raw_buffer
) {
496 tsdata
->raw_bufsize
= tsdata
->num_x
* tsdata
->num_y
*
498 tsdata
->raw_buffer
= kzalloc(tsdata
->raw_bufsize
, GFP_KERNEL
);
499 if (!tsdata
->raw_buffer
) {
505 /* mode register is 0x3c when in the work mode */
506 if (tsdata
->version
== M09
)
509 error
= edt_ft5x06_register_write(tsdata
, WORK_REGISTER_OPMODE
, 0x03);
511 dev_err(&client
->dev
,
512 "failed to switch to factory mode, error %d\n", error
);
516 tsdata
->factory_mode
= true;
518 mdelay(EDT_SWITCH_MODE_DELAY
);
519 /* mode register is 0x01 when in factory mode */
520 ret
= edt_ft5x06_register_read(tsdata
, FACTORY_REGISTER_OPMODE
);
523 } while (--retries
> 0);
526 dev_err(&client
->dev
, "not in factory mode after %dms.\n",
527 EDT_SWITCH_MODE_RETRIES
* EDT_SWITCH_MODE_DELAY
);
535 kfree(tsdata
->raw_buffer
);
536 tsdata
->raw_buffer
= NULL
;
537 tsdata
->factory_mode
= false;
538 enable_irq(client
->irq
);
543 dev_err(&client
->dev
, "No factory mode support for M09\n");
548 static int edt_ft5x06_work_mode(struct edt_ft5x06_ts_data
*tsdata
)
550 struct i2c_client
*client
= tsdata
->client
;
551 int retries
= EDT_SWITCH_MODE_RETRIES
;
552 struct edt_reg_addr
*reg_addr
= &tsdata
->reg_addr
;
556 /* mode register is 0x01 when in the factory mode */
557 error
= edt_ft5x06_register_write(tsdata
, FACTORY_REGISTER_OPMODE
, 0x1);
559 dev_err(&client
->dev
,
560 "failed to switch to work mode, error: %d\n", error
);
564 tsdata
->factory_mode
= false;
567 mdelay(EDT_SWITCH_MODE_DELAY
);
568 /* mode register is 0x01 when in factory mode */
569 ret
= edt_ft5x06_register_read(tsdata
, WORK_REGISTER_OPMODE
);
572 } while (--retries
> 0);
575 dev_err(&client
->dev
, "not in work mode after %dms.\n",
576 EDT_SWITCH_MODE_RETRIES
* EDT_SWITCH_MODE_DELAY
);
577 tsdata
->factory_mode
= true;
581 kfree(tsdata
->raw_buffer
);
582 tsdata
->raw_buffer
= NULL
;
584 /* restore parameters */
585 edt_ft5x06_register_write(tsdata
, reg_addr
->reg_threshold
,
587 edt_ft5x06_register_write(tsdata
, reg_addr
->reg_gain
,
589 edt_ft5x06_register_write(tsdata
, reg_addr
->reg_offset
,
591 if (reg_addr
->reg_report_rate
)
592 edt_ft5x06_register_write(tsdata
, reg_addr
->reg_report_rate
,
593 tsdata
->report_rate
);
595 enable_irq(client
->irq
);
600 static int edt_ft5x06_debugfs_mode_get(void *data
, u64
*mode
)
602 struct edt_ft5x06_ts_data
*tsdata
= data
;
604 *mode
= tsdata
->factory_mode
;
609 static int edt_ft5x06_debugfs_mode_set(void *data
, u64 mode
)
611 struct edt_ft5x06_ts_data
*tsdata
= data
;
617 mutex_lock(&tsdata
->mutex
);
619 if (mode
!= tsdata
->factory_mode
) {
620 retval
= mode
? edt_ft5x06_factory_mode(tsdata
) :
621 edt_ft5x06_work_mode(tsdata
);
624 mutex_unlock(&tsdata
->mutex
);
629 DEFINE_SIMPLE_ATTRIBUTE(debugfs_mode_fops
, edt_ft5x06_debugfs_mode_get
,
630 edt_ft5x06_debugfs_mode_set
, "%llu\n");
632 static ssize_t
edt_ft5x06_debugfs_raw_data_read(struct file
*file
,
633 char __user
*buf
, size_t count
, loff_t
*off
)
635 struct edt_ft5x06_ts_data
*tsdata
= file
->private_data
;
636 struct i2c_client
*client
= tsdata
->client
;
637 int retries
= EDT_RAW_DATA_RETRIES
;
644 if (*off
< 0 || *off
>= tsdata
->raw_bufsize
)
647 mutex_lock(&tsdata
->mutex
);
649 if (!tsdata
->factory_mode
|| !tsdata
->raw_buffer
) {
654 error
= edt_ft5x06_register_write(tsdata
, 0x08, 0x01);
656 dev_dbg(&client
->dev
,
657 "failed to write 0x08 register, error %d\n", error
);
662 msleep(EDT_RAW_DATA_DELAY
);
663 val
= edt_ft5x06_register_read(tsdata
, 0x08);
666 } while (--retries
> 0);
670 dev_dbg(&client
->dev
,
671 "failed to read 0x08 register, error %d\n", error
);
676 dev_dbg(&client
->dev
,
677 "timed out waiting for register to settle\n");
682 rdbuf
= tsdata
->raw_buffer
;
683 colbytes
= tsdata
->num_y
* sizeof(u16
);
687 for (i
= 0; i
< tsdata
->num_x
; i
++) {
688 wrbuf
[2] = i
; /* column index */
689 error
= edt_ft5x06_ts_readwrite(tsdata
->client
,
690 sizeof(wrbuf
), wrbuf
,
698 read
= min_t(size_t, count
, tsdata
->raw_bufsize
- *off
);
699 if (copy_to_user(buf
, tsdata
->raw_buffer
+ *off
, read
)) {
706 mutex_unlock(&tsdata
->mutex
);
707 return error
?: read
;
710 static const struct file_operations debugfs_raw_data_fops
= {
712 .read
= edt_ft5x06_debugfs_raw_data_read
,
716 edt_ft5x06_ts_prepare_debugfs(struct edt_ft5x06_ts_data
*tsdata
,
717 const char *debugfs_name
)
719 tsdata
->debug_dir
= debugfs_create_dir(debugfs_name
, NULL
);
720 if (!tsdata
->debug_dir
)
723 debugfs_create_u16("num_x", S_IRUSR
, tsdata
->debug_dir
, &tsdata
->num_x
);
724 debugfs_create_u16("num_y", S_IRUSR
, tsdata
->debug_dir
, &tsdata
->num_y
);
726 debugfs_create_file("mode", S_IRUSR
| S_IWUSR
,
727 tsdata
->debug_dir
, tsdata
, &debugfs_mode_fops
);
728 debugfs_create_file("raw_data", S_IRUSR
,
729 tsdata
->debug_dir
, tsdata
, &debugfs_raw_data_fops
);
733 edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data
*tsdata
)
735 debugfs_remove_recursive(tsdata
->debug_dir
);
736 kfree(tsdata
->raw_buffer
);
742 edt_ft5x06_ts_prepare_debugfs(struct edt_ft5x06_ts_data
*tsdata
,
743 const char *debugfs_name
)
748 edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data
*tsdata
)
752 #endif /* CONFIG_DEBUGFS */
754 static int edt_ft5x06_ts_reset(struct i2c_client
*client
,
755 struct edt_ft5x06_ts_data
*tsdata
)
759 if (gpio_is_valid(tsdata
->wake_pin
)) {
760 error
= devm_gpio_request_one(&client
->dev
,
761 tsdata
->wake_pin
, GPIOF_OUT_INIT_LOW
,
764 dev_err(&client
->dev
,
765 "Failed to request GPIO %d as wake pin, error %d\n",
766 tsdata
->wake_pin
, error
);
771 gpio_set_value(tsdata
->wake_pin
, 1);
773 if (gpio_is_valid(tsdata
->reset_pin
)) {
774 /* this pulls reset down, enabling the low active reset */
775 error
= devm_gpio_request_one(&client
->dev
,
776 tsdata
->reset_pin
, GPIOF_OUT_INIT_LOW
,
779 dev_err(&client
->dev
,
780 "Failed to request GPIO %d as reset pin, error %d\n",
781 tsdata
->reset_pin
, error
);
786 gpio_set_value(tsdata
->reset_pin
, 1);
793 static int edt_ft5x06_ts_identify(struct i2c_client
*client
,
794 struct edt_ft5x06_ts_data
*tsdata
,
797 u8 rdbuf
[EDT_NAME_LEN
];
800 char *model_name
= tsdata
->name
;
802 /* see what we find if we assume it is a M06 *
803 * if we get less than EDT_NAME_LEN, we don't want
804 * to have garbage in there
806 memset(rdbuf
, 0, sizeof(rdbuf
));
807 error
= edt_ft5x06_ts_readwrite(client
, 1, "\xbb",
808 EDT_NAME_LEN
- 1, rdbuf
);
812 /* if we find something consistent, stay with that assumption
813 * at least M09 won't send 3 bytes here
815 if (!(strncasecmp(rdbuf
+ 1, "EP0", 3))) {
816 tsdata
->version
= M06
;
818 /* remove last '$' end marker */
819 rdbuf
[EDT_NAME_LEN
- 1] = '\0';
820 if (rdbuf
[EDT_NAME_LEN
- 2] == '$')
821 rdbuf
[EDT_NAME_LEN
- 2] = '\0';
823 /* look for Model/Version separator */
824 p
= strchr(rdbuf
, '*');
827 strlcpy(model_name
, rdbuf
+ 1, EDT_NAME_LEN
);
828 strlcpy(fw_version
, p
? p
: "", EDT_NAME_LEN
);
830 /* since there are only two versions around (M06, M09) */
831 tsdata
->version
= M09
;
833 error
= edt_ft5x06_ts_readwrite(client
, 1, "\xA6",
838 strlcpy(fw_version
, rdbuf
, 2);
840 error
= edt_ft5x06_ts_readwrite(client
, 1, "\xA8",
845 snprintf(model_name
, EDT_NAME_LEN
, "EP0%i%i0M09",
846 rdbuf
[0] >> 4, rdbuf
[0] & 0x0F);
852 #define EDT_ATTR_CHECKSET(name, reg) \
854 if (pdata->name >= edt_ft5x06_attr_##name.limit_low && \
855 pdata->name <= edt_ft5x06_attr_##name.limit_high) \
856 edt_ft5x06_register_write(tsdata, reg, pdata->name); \
859 #define EDT_GET_PROP(name, reg) { \
861 if (of_property_read_u32(np, #name, &val) == 0) \
862 edt_ft5x06_register_write(tsdata, reg, val); \
865 static void edt_ft5x06_ts_get_dt_defaults(struct device_node
*np
,
866 struct edt_ft5x06_ts_data
*tsdata
)
868 struct edt_reg_addr
*reg_addr
= &tsdata
->reg_addr
;
870 EDT_GET_PROP(threshold
, reg_addr
->reg_threshold
);
871 EDT_GET_PROP(gain
, reg_addr
->reg_gain
);
872 EDT_GET_PROP(offset
, reg_addr
->reg_offset
);
876 edt_ft5x06_ts_get_defaults(struct edt_ft5x06_ts_data
*tsdata
,
877 const struct edt_ft5x06_platform_data
*pdata
)
879 struct edt_reg_addr
*reg_addr
= &tsdata
->reg_addr
;
881 if (!pdata
->use_parameters
)
884 /* pick up defaults from the platform data */
885 EDT_ATTR_CHECKSET(threshold
, reg_addr
->reg_threshold
);
886 EDT_ATTR_CHECKSET(gain
, reg_addr
->reg_gain
);
887 EDT_ATTR_CHECKSET(offset
, reg_addr
->reg_offset
);
888 if (reg_addr
->reg_report_rate
!= NO_REGISTER
)
889 EDT_ATTR_CHECKSET(report_rate
, reg_addr
->reg_report_rate
);
893 edt_ft5x06_ts_get_parameters(struct edt_ft5x06_ts_data
*tsdata
)
895 struct edt_reg_addr
*reg_addr
= &tsdata
->reg_addr
;
897 tsdata
->threshold
= edt_ft5x06_register_read(tsdata
,
898 reg_addr
->reg_threshold
);
899 tsdata
->gain
= edt_ft5x06_register_read(tsdata
, reg_addr
->reg_gain
);
900 tsdata
->offset
= edt_ft5x06_register_read(tsdata
, reg_addr
->reg_offset
);
901 if (reg_addr
->reg_report_rate
!= NO_REGISTER
)
902 tsdata
->report_rate
= edt_ft5x06_register_read(tsdata
,
903 reg_addr
->reg_report_rate
);
904 tsdata
->num_x
= edt_ft5x06_register_read(tsdata
, reg_addr
->reg_num_x
);
905 tsdata
->num_y
= edt_ft5x06_register_read(tsdata
, reg_addr
->reg_num_y
);
909 edt_ft5x06_ts_set_regs(struct edt_ft5x06_ts_data
*tsdata
)
911 struct edt_reg_addr
*reg_addr
= &tsdata
->reg_addr
;
913 switch (tsdata
->version
) {
915 reg_addr
->reg_threshold
= WORK_REGISTER_THRESHOLD
;
916 reg_addr
->reg_report_rate
= WORK_REGISTER_REPORT_RATE
;
917 reg_addr
->reg_gain
= WORK_REGISTER_GAIN
;
918 reg_addr
->reg_offset
= WORK_REGISTER_OFFSET
;
919 reg_addr
->reg_num_x
= WORK_REGISTER_NUM_X
;
920 reg_addr
->reg_num_y
= WORK_REGISTER_NUM_Y
;
924 reg_addr
->reg_threshold
= M09_REGISTER_THRESHOLD
;
925 reg_addr
->reg_gain
= M09_REGISTER_GAIN
;
926 reg_addr
->reg_offset
= M09_REGISTER_OFFSET
;
927 reg_addr
->reg_num_x
= M09_REGISTER_NUM_X
;
928 reg_addr
->reg_num_y
= M09_REGISTER_NUM_Y
;
934 static int edt_ft5x06_i2c_ts_probe_dt(struct device
*dev
,
935 struct edt_ft5x06_ts_data
*tsdata
)
937 struct device_node
*np
= dev
->of_node
;
940 * irq_pin is not needed for DT setup.
941 * irq is associated via 'interrupts' property in DT
943 tsdata
->irq_pin
= -EINVAL
;
944 tsdata
->reset_pin
= of_get_named_gpio(np
, "reset-gpios", 0);
945 tsdata
->wake_pin
= of_get_named_gpio(np
, "wake-gpios", 0);
950 static inline int edt_ft5x06_i2c_ts_probe_dt(struct device
*dev
,
951 struct edt_ft5x06_ts_data
*tsdata
)
957 static int edt_ft5x06_ts_probe(struct i2c_client
*client
,
958 const struct i2c_device_id
*id
)
960 const struct edt_ft5x06_platform_data
*pdata
=
961 dev_get_platdata(&client
->dev
);
962 struct edt_ft5x06_ts_data
*tsdata
;
963 struct input_dev
*input
;
965 char fw_version
[EDT_NAME_LEN
];
967 dev_dbg(&client
->dev
, "probing for EDT FT5x06 I2C\n");
969 tsdata
= devm_kzalloc(&client
->dev
, sizeof(*tsdata
), GFP_KERNEL
);
971 dev_err(&client
->dev
, "failed to allocate driver data.\n");
976 error
= edt_ft5x06_i2c_ts_probe_dt(&client
->dev
, tsdata
);
978 dev_err(&client
->dev
,
979 "DT probe failed and no platform data present\n");
983 tsdata
->reset_pin
= pdata
->reset_pin
;
984 tsdata
->irq_pin
= pdata
->irq_pin
;
985 tsdata
->wake_pin
= -EINVAL
;
988 error
= edt_ft5x06_ts_reset(client
, tsdata
);
992 if (gpio_is_valid(tsdata
->irq_pin
)) {
993 error
= devm_gpio_request_one(&client
->dev
, tsdata
->irq_pin
,
994 GPIOF_IN
, "edt-ft5x06 irq");
996 dev_err(&client
->dev
,
997 "Failed to request GPIO %d, error %d\n",
998 tsdata
->irq_pin
, error
);
1003 input
= devm_input_allocate_device(&client
->dev
);
1005 dev_err(&client
->dev
, "failed to allocate input device.\n");
1009 mutex_init(&tsdata
->mutex
);
1010 tsdata
->client
= client
;
1011 tsdata
->input
= input
;
1012 tsdata
->factory_mode
= false;
1014 error
= edt_ft5x06_ts_identify(client
, tsdata
, fw_version
);
1016 dev_err(&client
->dev
, "touchscreen probe failed\n");
1020 edt_ft5x06_ts_set_regs(tsdata
);
1023 edt_ft5x06_ts_get_dt_defaults(client
->dev
.of_node
, tsdata
);
1025 edt_ft5x06_ts_get_defaults(tsdata
, pdata
);
1027 edt_ft5x06_ts_get_parameters(tsdata
);
1029 dev_dbg(&client
->dev
,
1030 "Model \"%s\", Rev. \"%s\", %dx%d sensors\n",
1031 tsdata
->name
, fw_version
, tsdata
->num_x
, tsdata
->num_y
);
1033 input
->name
= tsdata
->name
;
1034 input
->id
.bustype
= BUS_I2C
;
1035 input
->dev
.parent
= &client
->dev
;
1037 __set_bit(EV_SYN
, input
->evbit
);
1038 __set_bit(EV_KEY
, input
->evbit
);
1039 __set_bit(EV_ABS
, input
->evbit
);
1040 __set_bit(BTN_TOUCH
, input
->keybit
);
1041 input_set_abs_params(input
, ABS_X
, 0, tsdata
->num_x
* 64 - 1, 0, 0);
1042 input_set_abs_params(input
, ABS_Y
, 0, tsdata
->num_y
* 64 - 1, 0, 0);
1043 input_set_abs_params(input
, ABS_MT_POSITION_X
,
1044 0, tsdata
->num_x
* 64 - 1, 0, 0);
1045 input_set_abs_params(input
, ABS_MT_POSITION_Y
,
1046 0, tsdata
->num_y
* 64 - 1, 0, 0);
1047 error
= input_mt_init_slots(input
, MAX_SUPPORT_POINTS
, 0);
1049 dev_err(&client
->dev
, "Unable to init MT slots.\n");
1053 input_set_drvdata(input
, tsdata
);
1054 i2c_set_clientdata(client
, tsdata
);
1056 error
= devm_request_threaded_irq(&client
->dev
, client
->irq
, NULL
,
1058 IRQF_TRIGGER_FALLING
| IRQF_ONESHOT
,
1059 client
->name
, tsdata
);
1061 dev_err(&client
->dev
, "Unable to request touchscreen IRQ.\n");
1065 error
= sysfs_create_group(&client
->dev
.kobj
, &edt_ft5x06_attr_group
);
1069 error
= input_register_device(input
);
1071 goto err_remove_attrs
;
1073 edt_ft5x06_ts_prepare_debugfs(tsdata
, dev_driver_string(&client
->dev
));
1074 device_init_wakeup(&client
->dev
, 1);
1076 dev_dbg(&client
->dev
,
1077 "EDT FT5x06 initialized: IRQ %d, WAKE pin %d, Reset pin %d.\n",
1078 client
->irq
, tsdata
->wake_pin
, tsdata
->reset_pin
);
1083 sysfs_remove_group(&client
->dev
.kobj
, &edt_ft5x06_attr_group
);
1087 static int edt_ft5x06_ts_remove(struct i2c_client
*client
)
1089 struct edt_ft5x06_ts_data
*tsdata
= i2c_get_clientdata(client
);
1091 edt_ft5x06_ts_teardown_debugfs(tsdata
);
1092 sysfs_remove_group(&client
->dev
.kobj
, &edt_ft5x06_attr_group
);
1097 static int __maybe_unused
edt_ft5x06_ts_suspend(struct device
*dev
)
1099 struct i2c_client
*client
= to_i2c_client(dev
);
1101 if (device_may_wakeup(dev
))
1102 enable_irq_wake(client
->irq
);
1107 static int __maybe_unused
edt_ft5x06_ts_resume(struct device
*dev
)
1109 struct i2c_client
*client
= to_i2c_client(dev
);
1111 if (device_may_wakeup(dev
))
1112 disable_irq_wake(client
->irq
);
1117 static SIMPLE_DEV_PM_OPS(edt_ft5x06_ts_pm_ops
,
1118 edt_ft5x06_ts_suspend
, edt_ft5x06_ts_resume
);
1120 static const struct i2c_device_id edt_ft5x06_ts_id
[] = {
1121 { "edt-ft5x06", 0, },
1124 MODULE_DEVICE_TABLE(i2c
, edt_ft5x06_ts_id
);
1127 static const struct of_device_id edt_ft5x06_of_match
[] = {
1128 { .compatible
= "edt,edt-ft5206", },
1129 { .compatible
= "edt,edt-ft5306", },
1130 { .compatible
= "edt,edt-ft5406", },
1133 MODULE_DEVICE_TABLE(of
, edt_ft5x06_of_match
);
1136 static struct i2c_driver edt_ft5x06_ts_driver
= {
1138 .owner
= THIS_MODULE
,
1139 .name
= "edt_ft5x06",
1140 .of_match_table
= of_match_ptr(edt_ft5x06_of_match
),
1141 .pm
= &edt_ft5x06_ts_pm_ops
,
1143 .id_table
= edt_ft5x06_ts_id
,
1144 .probe
= edt_ft5x06_ts_probe
,
1145 .remove
= edt_ft5x06_ts_remove
,
1148 module_i2c_driver(edt_ft5x06_ts_driver
);
1150 MODULE_AUTHOR("Simon Budig <simon.budig@kernelconcepts.de>");
1151 MODULE_DESCRIPTION("EDT FT5x06 I2C Touchscreen Driver");
1152 MODULE_LICENSE("GPL");