2 * Copyright (C) 2012 Simon Budig, <simon.budig@kernelconcepts.de>
4 * This software is licensed under the terms of the GNU General Public
5 * License version 2, as published by the Free Software Foundation, and
6 * may be copied, distributed, and modified under those terms.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public
14 * License along with this library; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 * This is a driver for the EDT "Polytouch" family of touch controllers
20 * based on the FocalTech FT5x06 line of chips.
22 * Development of this driver has been sponsored by Glyn:
23 * http://www.glyn.com/Products/Displays
26 #include <linux/module.h>
27 #include <linux/ratelimit.h>
28 #include <linux/interrupt.h>
29 #include <linux/input.h>
30 #include <linux/i2c.h>
31 #include <linux/uaccess.h>
32 #include <linux/delay.h>
33 #include <linux/debugfs.h>
34 #include <linux/slab.h>
35 #include <linux/gpio.h>
36 #include <linux/input/mt.h>
37 #include <linux/input/edt-ft5x06.h>
39 #define MAX_SUPPORT_POINTS 5
41 #define WORK_REGISTER_THRESHOLD 0x00
42 #define WORK_REGISTER_REPORT_RATE 0x08
43 #define WORK_REGISTER_GAIN 0x30
44 #define WORK_REGISTER_OFFSET 0x31
45 #define WORK_REGISTER_NUM_X 0x33
46 #define WORK_REGISTER_NUM_Y 0x34
48 #define WORK_REGISTER_OPMODE 0x3c
49 #define FACTORY_REGISTER_OPMODE 0x01
51 #define TOUCH_EVENT_DOWN 0x00
52 #define TOUCH_EVENT_UP 0x01
53 #define TOUCH_EVENT_ON 0x02
54 #define TOUCH_EVENT_RESERVED 0x03
56 #define EDT_NAME_LEN 23
57 #define EDT_SWITCH_MODE_RETRIES 10
58 #define EDT_SWITCH_MODE_DELAY 5 /* msec */
59 #define EDT_RAW_DATA_RETRIES 100
60 #define EDT_RAW_DATA_DELAY 1 /* msec */
62 struct edt_ft5x06_ts_data
{
63 struct i2c_client
*client
;
64 struct input_dev
*input
;
68 #if defined(CONFIG_DEBUG_FS)
69 struct dentry
*debug_dir
;
81 char name
[EDT_NAME_LEN
];
84 static int edt_ft5x06_ts_readwrite(struct i2c_client
*client
,
85 u16 wr_len
, u8
*wr_buf
,
86 u16 rd_len
, u8
*rd_buf
)
88 struct i2c_msg wrmsg
[2];
93 wrmsg
[i
].addr
= client
->addr
;
95 wrmsg
[i
].len
= wr_len
;
96 wrmsg
[i
].buf
= wr_buf
;
100 wrmsg
[i
].addr
= client
->addr
;
101 wrmsg
[i
].flags
= I2C_M_RD
;
102 wrmsg
[i
].len
= rd_len
;
103 wrmsg
[i
].buf
= rd_buf
;
107 ret
= i2c_transfer(client
->adapter
, wrmsg
, i
);
116 static bool edt_ft5x06_ts_check_crc(struct edt_ft5x06_ts_data
*tsdata
,
122 for (i
= 0; i
< buflen
- 1; i
++)
125 if (crc
!= buf
[buflen
-1]) {
126 dev_err_ratelimited(&tsdata
->client
->dev
,
127 "crc error: 0x%02x expected, got 0x%02x\n",
135 static irqreturn_t
edt_ft5x06_ts_isr(int irq
, void *dev_id
)
137 struct edt_ft5x06_ts_data
*tsdata
= dev_id
;
138 struct device
*dev
= &tsdata
->client
->dev
;
141 int i
, type
, x
, y
, id
;
144 memset(rdbuf
, 0, sizeof(rdbuf
));
146 error
= edt_ft5x06_ts_readwrite(tsdata
->client
,
148 sizeof(rdbuf
), rdbuf
);
150 dev_err_ratelimited(dev
, "Unable to fetch data, error: %d\n",
155 if (rdbuf
[0] != 0xaa || rdbuf
[1] != 0xaa || rdbuf
[2] != 26) {
156 dev_err_ratelimited(dev
, "Unexpected header: %02x%02x%02x!\n",
157 rdbuf
[0], rdbuf
[1], rdbuf
[2]);
161 if (!edt_ft5x06_ts_check_crc(tsdata
, rdbuf
, 26))
164 for (i
= 0; i
< MAX_SUPPORT_POINTS
; i
++) {
165 u8
*buf
= &rdbuf
[i
* 4 + 5];
169 /* ignore Reserved events */
170 if (type
== TOUCH_EVENT_RESERVED
)
173 x
= ((buf
[0] << 8) | buf
[1]) & 0x0fff;
174 y
= ((buf
[2] << 8) | buf
[3]) & 0x0fff;
175 id
= (buf
[2] >> 4) & 0x0f;
176 down
= (type
!= TOUCH_EVENT_UP
);
178 input_mt_slot(tsdata
->input
, id
);
179 input_mt_report_slot_state(tsdata
->input
, MT_TOOL_FINGER
, down
);
184 input_report_abs(tsdata
->input
, ABS_MT_POSITION_X
, x
);
185 input_report_abs(tsdata
->input
, ABS_MT_POSITION_Y
, y
);
188 input_mt_report_pointer_emulation(tsdata
->input
, true);
189 input_sync(tsdata
->input
);
195 static int edt_ft5x06_register_write(struct edt_ft5x06_ts_data
*tsdata
,
200 wrbuf
[0] = tsdata
->factory_mode
? 0xf3 : 0xfc;
201 wrbuf
[1] = tsdata
->factory_mode
? addr
& 0x7f : addr
& 0x3f;
203 wrbuf
[3] = wrbuf
[0] ^ wrbuf
[1] ^ wrbuf
[2];
205 return edt_ft5x06_ts_readwrite(tsdata
->client
, 4, wrbuf
, 0, NULL
);
208 static int edt_ft5x06_register_read(struct edt_ft5x06_ts_data
*tsdata
,
211 u8 wrbuf
[2], rdbuf
[2];
214 wrbuf
[0] = tsdata
->factory_mode
? 0xf3 : 0xfc;
215 wrbuf
[1] = tsdata
->factory_mode
? addr
& 0x7f : addr
& 0x3f;
216 wrbuf
[1] |= tsdata
->factory_mode
? 0x80 : 0x40;
218 error
= edt_ft5x06_ts_readwrite(tsdata
->client
, 2, wrbuf
, 2, rdbuf
);
222 if ((wrbuf
[0] ^ wrbuf
[1] ^ rdbuf
[0]) != rdbuf
[1]) {
223 dev_err(&tsdata
->client
->dev
,
224 "crc error: 0x%02x expected, got 0x%02x\n",
225 wrbuf
[0] ^ wrbuf
[1] ^ rdbuf
[0], rdbuf
[1]);
232 struct edt_ft5x06_attribute
{
233 struct device_attribute dattr
;
240 #define EDT_ATTR(_field, _mode, _addr, _limit_low, _limit_high) \
241 struct edt_ft5x06_attribute edt_ft5x06_attr_##_field = { \
242 .dattr = __ATTR(_field, _mode, \
243 edt_ft5x06_setting_show, \
244 edt_ft5x06_setting_store), \
246 offsetof(struct edt_ft5x06_ts_data, _field), \
247 .limit_low = _limit_low, \
248 .limit_high = _limit_high, \
252 static ssize_t
edt_ft5x06_setting_show(struct device
*dev
,
253 struct device_attribute
*dattr
,
256 struct i2c_client
*client
= to_i2c_client(dev
);
257 struct edt_ft5x06_ts_data
*tsdata
= i2c_get_clientdata(client
);
258 struct edt_ft5x06_attribute
*attr
=
259 container_of(dattr
, struct edt_ft5x06_attribute
, dattr
);
260 u8
*field
= (u8
*)((char *)tsdata
+ attr
->field_offset
);
265 mutex_lock(&tsdata
->mutex
);
267 if (tsdata
->factory_mode
) {
272 val
= edt_ft5x06_register_read(tsdata
, attr
->addr
);
275 dev_err(&tsdata
->client
->dev
,
276 "Failed to fetch attribute %s, error %d\n",
277 dattr
->attr
.name
, error
);
282 dev_warn(&tsdata
->client
->dev
,
283 "%s: read (%d) and stored value (%d) differ\n",
284 dattr
->attr
.name
, val
, *field
);
288 count
= scnprintf(buf
, PAGE_SIZE
, "%d\n", val
);
290 mutex_unlock(&tsdata
->mutex
);
291 return error
?: count
;
294 static ssize_t
edt_ft5x06_setting_store(struct device
*dev
,
295 struct device_attribute
*dattr
,
296 const char *buf
, size_t count
)
298 struct i2c_client
*client
= to_i2c_client(dev
);
299 struct edt_ft5x06_ts_data
*tsdata
= i2c_get_clientdata(client
);
300 struct edt_ft5x06_attribute
*attr
=
301 container_of(dattr
, struct edt_ft5x06_attribute
, dattr
);
302 u8
*field
= (u8
*)((char *)tsdata
+ attr
->field_offset
);
306 mutex_lock(&tsdata
->mutex
);
308 if (tsdata
->factory_mode
) {
313 error
= kstrtouint(buf
, 0, &val
);
317 if (val
< attr
->limit_low
|| val
> attr
->limit_high
) {
322 error
= edt_ft5x06_register_write(tsdata
, attr
->addr
, val
);
324 dev_err(&tsdata
->client
->dev
,
325 "Failed to update attribute %s, error: %d\n",
326 dattr
->attr
.name
, error
);
333 mutex_unlock(&tsdata
->mutex
);
334 return error
?: count
;
337 static EDT_ATTR(gain
, S_IWUSR
| S_IRUGO
, WORK_REGISTER_GAIN
, 0, 31);
338 static EDT_ATTR(offset
, S_IWUSR
| S_IRUGO
, WORK_REGISTER_OFFSET
, 0, 31);
339 static EDT_ATTR(threshold
, S_IWUSR
| S_IRUGO
,
340 WORK_REGISTER_THRESHOLD
, 20, 80);
341 static EDT_ATTR(report_rate
, S_IWUSR
| S_IRUGO
,
342 WORK_REGISTER_REPORT_RATE
, 3, 14);
344 static struct attribute
*edt_ft5x06_attrs
[] = {
345 &edt_ft5x06_attr_gain
.dattr
.attr
,
346 &edt_ft5x06_attr_offset
.dattr
.attr
,
347 &edt_ft5x06_attr_threshold
.dattr
.attr
,
348 &edt_ft5x06_attr_report_rate
.dattr
.attr
,
352 static const struct attribute_group edt_ft5x06_attr_group
= {
353 .attrs
= edt_ft5x06_attrs
,
356 #ifdef CONFIG_DEBUG_FS
357 static int edt_ft5x06_factory_mode(struct edt_ft5x06_ts_data
*tsdata
)
359 struct i2c_client
*client
= tsdata
->client
;
360 int retries
= EDT_SWITCH_MODE_RETRIES
;
364 disable_irq(client
->irq
);
366 if (!tsdata
->raw_buffer
) {
367 tsdata
->raw_bufsize
= tsdata
->num_x
* tsdata
->num_y
*
369 tsdata
->raw_buffer
= kzalloc(tsdata
->raw_bufsize
, GFP_KERNEL
);
370 if (!tsdata
->raw_buffer
) {
376 /* mode register is 0x3c when in the work mode */
377 error
= edt_ft5x06_register_write(tsdata
, WORK_REGISTER_OPMODE
, 0x03);
379 dev_err(&client
->dev
,
380 "failed to switch to factory mode, error %d\n", error
);
384 tsdata
->factory_mode
= true;
386 mdelay(EDT_SWITCH_MODE_DELAY
);
387 /* mode register is 0x01 when in factory mode */
388 ret
= edt_ft5x06_register_read(tsdata
, FACTORY_REGISTER_OPMODE
);
391 } while (--retries
> 0);
394 dev_err(&client
->dev
, "not in factory mode after %dms.\n",
395 EDT_SWITCH_MODE_RETRIES
* EDT_SWITCH_MODE_DELAY
);
403 kfree(tsdata
->raw_buffer
);
404 tsdata
->raw_buffer
= NULL
;
405 tsdata
->factory_mode
= false;
406 enable_irq(client
->irq
);
411 static int edt_ft5x06_work_mode(struct edt_ft5x06_ts_data
*tsdata
)
413 struct i2c_client
*client
= tsdata
->client
;
414 int retries
= EDT_SWITCH_MODE_RETRIES
;
418 /* mode register is 0x01 when in the factory mode */
419 error
= edt_ft5x06_register_write(tsdata
, FACTORY_REGISTER_OPMODE
, 0x1);
421 dev_err(&client
->dev
,
422 "failed to switch to work mode, error: %d\n", error
);
426 tsdata
->factory_mode
= false;
429 mdelay(EDT_SWITCH_MODE_DELAY
);
430 /* mode register is 0x01 when in factory mode */
431 ret
= edt_ft5x06_register_read(tsdata
, WORK_REGISTER_OPMODE
);
434 } while (--retries
> 0);
437 dev_err(&client
->dev
, "not in work mode after %dms.\n",
438 EDT_SWITCH_MODE_RETRIES
* EDT_SWITCH_MODE_DELAY
);
439 tsdata
->factory_mode
= true;
443 if (tsdata
->raw_buffer
)
444 kfree(tsdata
->raw_buffer
);
445 tsdata
->raw_buffer
= NULL
;
447 /* restore parameters */
448 edt_ft5x06_register_write(tsdata
, WORK_REGISTER_THRESHOLD
,
450 edt_ft5x06_register_write(tsdata
, WORK_REGISTER_GAIN
,
452 edt_ft5x06_register_write(tsdata
, WORK_REGISTER_OFFSET
,
454 edt_ft5x06_register_write(tsdata
, WORK_REGISTER_REPORT_RATE
,
455 tsdata
->report_rate
);
457 enable_irq(client
->irq
);
462 static int edt_ft5x06_debugfs_mode_get(void *data
, u64
*mode
)
464 struct edt_ft5x06_ts_data
*tsdata
= data
;
466 *mode
= tsdata
->factory_mode
;
471 static int edt_ft5x06_debugfs_mode_set(void *data
, u64 mode
)
473 struct edt_ft5x06_ts_data
*tsdata
= data
;
479 mutex_lock(&tsdata
->mutex
);
481 if (mode
!= tsdata
->factory_mode
) {
482 retval
= mode
? edt_ft5x06_factory_mode(tsdata
) :
483 edt_ft5x06_work_mode(tsdata
);
486 mutex_unlock(&tsdata
->mutex
);
491 DEFINE_SIMPLE_ATTRIBUTE(debugfs_mode_fops
, edt_ft5x06_debugfs_mode_get
,
492 edt_ft5x06_debugfs_mode_set
, "%llu\n");
494 static int edt_ft5x06_debugfs_raw_data_open(struct inode
*inode
,
497 file
->private_data
= inode
->i_private
;
502 static ssize_t
edt_ft5x06_debugfs_raw_data_read(struct file
*file
,
503 char __user
*buf
, size_t count
, loff_t
*off
)
505 struct edt_ft5x06_ts_data
*tsdata
= file
->private_data
;
506 struct i2c_client
*client
= tsdata
->client
;
507 int retries
= EDT_RAW_DATA_RETRIES
;
514 if (*off
< 0 || *off
>= tsdata
->raw_bufsize
)
517 mutex_lock(&tsdata
->mutex
);
519 if (!tsdata
->factory_mode
|| !tsdata
->raw_buffer
) {
524 error
= edt_ft5x06_register_write(tsdata
, 0x08, 0x01);
526 dev_dbg(&client
->dev
,
527 "failed to write 0x08 register, error %d\n", error
);
532 msleep(EDT_RAW_DATA_DELAY
);
533 val
= edt_ft5x06_register_read(tsdata
, 0x08);
536 } while (--retries
> 0);
540 dev_dbg(&client
->dev
,
541 "failed to read 0x08 register, error %d\n", error
);
546 dev_dbg(&client
->dev
,
547 "timed out waiting for register to settle\n");
552 rdbuf
= tsdata
->raw_buffer
;
553 colbytes
= tsdata
->num_y
* sizeof(u16
);
557 for (i
= 0; i
< tsdata
->num_x
; i
++) {
558 wrbuf
[2] = i
; /* column index */
559 error
= edt_ft5x06_ts_readwrite(tsdata
->client
,
560 sizeof(wrbuf
), wrbuf
,
568 read
= min_t(size_t, count
, tsdata
->raw_bufsize
- *off
);
569 if (copy_to_user(buf
, tsdata
->raw_buffer
+ *off
, read
)) {
576 mutex_unlock(&tsdata
->mutex
);
577 return error
?: read
;
581 static const struct file_operations debugfs_raw_data_fops
= {
582 .open
= edt_ft5x06_debugfs_raw_data_open
,
583 .read
= edt_ft5x06_debugfs_raw_data_read
,
586 static void __devinit
587 edt_ft5x06_ts_prepare_debugfs(struct edt_ft5x06_ts_data
*tsdata
,
588 const char *debugfs_name
)
590 tsdata
->debug_dir
= debugfs_create_dir(debugfs_name
, NULL
);
591 if (!tsdata
->debug_dir
)
594 debugfs_create_u16("num_x", S_IRUSR
, tsdata
->debug_dir
, &tsdata
->num_x
);
595 debugfs_create_u16("num_y", S_IRUSR
, tsdata
->debug_dir
, &tsdata
->num_y
);
597 debugfs_create_file("mode", S_IRUSR
| S_IWUSR
,
598 tsdata
->debug_dir
, tsdata
, &debugfs_mode_fops
);
599 debugfs_create_file("raw_data", S_IRUSR
,
600 tsdata
->debug_dir
, tsdata
, &debugfs_raw_data_fops
);
603 static void __devexit
604 edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data
*tsdata
)
606 if (tsdata
->debug_dir
)
607 debugfs_remove_recursive(tsdata
->debug_dir
);
608 kfree(tsdata
->raw_buffer
);
614 edt_ft5x06_ts_prepare_debugfs(struct edt_ft5x06_ts_data
*tsdata
,
615 const char *debugfs_name
)
620 edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data
*tsdata
)
624 #endif /* CONFIG_DEBUGFS */
628 static int __devinit
edt_ft5x06_ts_reset(struct i2c_client
*client
,
633 if (gpio_is_valid(reset_pin
)) {
634 /* this pulls reset down, enabling the low active reset */
635 error
= gpio_request_one(reset_pin
, GPIOF_OUT_INIT_LOW
,
638 dev_err(&client
->dev
,
639 "Failed to request GPIO %d as reset pin, error %d\n",
645 gpio_set_value(reset_pin
, 1);
652 static int __devinit
edt_ft5x06_ts_identify(struct i2c_client
*client
,
656 u8 rdbuf
[EDT_NAME_LEN
];
660 error
= edt_ft5x06_ts_readwrite(client
, 1, "\xbb",
661 EDT_NAME_LEN
- 1, rdbuf
);
665 /* remove last '$' end marker */
666 rdbuf
[EDT_NAME_LEN
- 1] = '\0';
667 if (rdbuf
[EDT_NAME_LEN
- 2] == '$')
668 rdbuf
[EDT_NAME_LEN
- 2] = '\0';
670 /* look for Model/Version separator */
671 p
= strchr(rdbuf
, '*');
675 strlcpy(model_name
, rdbuf
+ 1, EDT_NAME_LEN
);
676 strlcpy(fw_version
, p
? p
: "", EDT_NAME_LEN
);
681 #define EDT_ATTR_CHECKSET(name, reg) \
682 if (pdata->name >= edt_ft5x06_attr_##name.limit_low && \
683 pdata->name <= edt_ft5x06_attr_##name.limit_high) \
684 edt_ft5x06_register_write(tsdata, reg, pdata->name)
686 static void __devinit
687 edt_ft5x06_ts_get_defaults(struct edt_ft5x06_ts_data
*tsdata
,
688 const struct edt_ft5x06_platform_data
*pdata
)
690 if (!pdata
->use_parameters
)
693 /* pick up defaults from the platform data */
694 EDT_ATTR_CHECKSET(threshold
, WORK_REGISTER_THRESHOLD
);
695 EDT_ATTR_CHECKSET(gain
, WORK_REGISTER_GAIN
);
696 EDT_ATTR_CHECKSET(offset
, WORK_REGISTER_OFFSET
);
697 EDT_ATTR_CHECKSET(report_rate
, WORK_REGISTER_REPORT_RATE
);
700 static void __devinit
701 edt_ft5x06_ts_get_parameters(struct edt_ft5x06_ts_data
*tsdata
)
703 tsdata
->threshold
= edt_ft5x06_register_read(tsdata
,
704 WORK_REGISTER_THRESHOLD
);
705 tsdata
->gain
= edt_ft5x06_register_read(tsdata
, WORK_REGISTER_GAIN
);
706 tsdata
->offset
= edt_ft5x06_register_read(tsdata
, WORK_REGISTER_OFFSET
);
707 tsdata
->report_rate
= edt_ft5x06_register_read(tsdata
,
708 WORK_REGISTER_REPORT_RATE
);
709 tsdata
->num_x
= edt_ft5x06_register_read(tsdata
, WORK_REGISTER_NUM_X
);
710 tsdata
->num_y
= edt_ft5x06_register_read(tsdata
, WORK_REGISTER_NUM_Y
);
713 static int __devinit
edt_ft5x06_ts_probe(struct i2c_client
*client
,
714 const struct i2c_device_id
*id
)
716 const struct edt_ft5x06_platform_data
*pdata
=
717 client
->dev
.platform_data
;
718 struct edt_ft5x06_ts_data
*tsdata
;
719 struct input_dev
*input
;
721 char fw_version
[EDT_NAME_LEN
];
723 dev_dbg(&client
->dev
, "probing for EDT FT5x06 I2C\n");
726 dev_err(&client
->dev
, "no platform data?\n");
730 error
= edt_ft5x06_ts_reset(client
, pdata
->reset_pin
);
734 if (gpio_is_valid(pdata
->irq_pin
)) {
735 error
= gpio_request_one(pdata
->irq_pin
,
736 GPIOF_IN
, "edt-ft5x06 irq");
738 dev_err(&client
->dev
,
739 "Failed to request GPIO %d, error %d\n",
740 pdata
->irq_pin
, error
);
745 tsdata
= kzalloc(sizeof(*tsdata
), GFP_KERNEL
);
746 input
= input_allocate_device();
747 if (!tsdata
|| !input
) {
748 dev_err(&client
->dev
, "failed to allocate driver data.\n");
753 mutex_init(&tsdata
->mutex
);
754 tsdata
->client
= client
;
755 tsdata
->input
= input
;
756 tsdata
->factory_mode
= false;
758 error
= edt_ft5x06_ts_identify(client
, tsdata
->name
, fw_version
);
760 dev_err(&client
->dev
, "touchscreen probe failed\n");
764 edt_ft5x06_ts_get_defaults(tsdata
, pdata
);
765 edt_ft5x06_ts_get_parameters(tsdata
);
767 dev_dbg(&client
->dev
,
768 "Model \"%s\", Rev. \"%s\", %dx%d sensors\n",
769 tsdata
->name
, fw_version
, tsdata
->num_x
, tsdata
->num_y
);
771 input
->name
= tsdata
->name
;
772 input
->id
.bustype
= BUS_I2C
;
773 input
->dev
.parent
= &client
->dev
;
775 __set_bit(EV_SYN
, input
->evbit
);
776 __set_bit(EV_KEY
, input
->evbit
);
777 __set_bit(EV_ABS
, input
->evbit
);
778 __set_bit(BTN_TOUCH
, input
->keybit
);
779 input_set_abs_params(input
, ABS_X
, 0, tsdata
->num_x
* 64 - 1, 0, 0);
780 input_set_abs_params(input
, ABS_Y
, 0, tsdata
->num_y
* 64 - 1, 0, 0);
781 input_set_abs_params(input
, ABS_MT_POSITION_X
,
782 0, tsdata
->num_x
* 64 - 1, 0, 0);
783 input_set_abs_params(input
, ABS_MT_POSITION_Y
,
784 0, tsdata
->num_y
* 64 - 1, 0, 0);
785 error
= input_mt_init_slots(input
, MAX_SUPPORT_POINTS
);
787 dev_err(&client
->dev
, "Unable to init MT slots.\n");
791 input_set_drvdata(input
, tsdata
);
792 i2c_set_clientdata(client
, tsdata
);
794 error
= request_threaded_irq(client
->irq
, NULL
, edt_ft5x06_ts_isr
,
795 IRQF_TRIGGER_FALLING
| IRQF_ONESHOT
,
796 client
->name
, tsdata
);
798 dev_err(&client
->dev
, "Unable to request touchscreen IRQ.\n");
802 error
= sysfs_create_group(&client
->dev
.kobj
, &edt_ft5x06_attr_group
);
806 error
= input_register_device(input
);
808 goto err_remove_attrs
;
810 edt_ft5x06_ts_prepare_debugfs(tsdata
, dev_driver_string(&client
->dev
));
811 device_init_wakeup(&client
->dev
, 1);
813 dev_dbg(&client
->dev
,
814 "EDT FT5x06 initialized: IRQ pin %d, Reset pin %d.\n",
815 pdata
->irq_pin
, pdata
->reset_pin
);
820 sysfs_remove_group(&client
->dev
.kobj
, &edt_ft5x06_attr_group
);
822 free_irq(client
->irq
, tsdata
);
824 input_free_device(input
);
827 if (gpio_is_valid(pdata
->irq_pin
))
828 gpio_free(pdata
->irq_pin
);
833 static int __devexit
edt_ft5x06_ts_remove(struct i2c_client
*client
)
835 const struct edt_ft5x06_platform_data
*pdata
=
836 dev_get_platdata(&client
->dev
);
837 struct edt_ft5x06_ts_data
*tsdata
= i2c_get_clientdata(client
);
839 edt_ft5x06_ts_teardown_debugfs(tsdata
);
840 sysfs_remove_group(&client
->dev
.kobj
, &edt_ft5x06_attr_group
);
842 free_irq(client
->irq
, tsdata
);
843 input_unregister_device(tsdata
->input
);
845 if (gpio_is_valid(pdata
->irq_pin
))
846 gpio_free(pdata
->irq_pin
);
847 if (gpio_is_valid(pdata
->reset_pin
))
848 gpio_free(pdata
->reset_pin
);
855 #ifdef CONFIG_PM_SLEEP
856 static int edt_ft5x06_ts_suspend(struct device
*dev
)
858 struct i2c_client
*client
= to_i2c_client(dev
);
860 if (device_may_wakeup(dev
))
861 enable_irq_wake(client
->irq
);
866 static int edt_ft5x06_ts_resume(struct device
*dev
)
868 struct i2c_client
*client
= to_i2c_client(dev
);
870 if (device_may_wakeup(dev
))
871 disable_irq_wake(client
->irq
);
877 static SIMPLE_DEV_PM_OPS(edt_ft5x06_ts_pm_ops
,
878 edt_ft5x06_ts_suspend
, edt_ft5x06_ts_resume
);
880 static const struct i2c_device_id edt_ft5x06_ts_id
[] = {
884 MODULE_DEVICE_TABLE(i2c
, edt_ft5x06_ts_id
);
886 static struct i2c_driver edt_ft5x06_ts_driver
= {
888 .owner
= THIS_MODULE
,
889 .name
= "edt_ft5x06",
890 .pm
= &edt_ft5x06_ts_pm_ops
,
892 .id_table
= edt_ft5x06_ts_id
,
893 .probe
= edt_ft5x06_ts_probe
,
894 .remove
= __devexit_p(edt_ft5x06_ts_remove
),
897 module_i2c_driver(edt_ft5x06_ts_driver
);
899 MODULE_AUTHOR("Simon Budig <simon.budig@kernelconcepts.de>");
900 MODULE_DESCRIPTION("EDT FT5x06 I2C Touchscreen Driver");
901 MODULE_LICENSE("GPL");