projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
import PULS_20160108
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / input / touchscreen / mediatek / ft5x06tb / ft5x06_driver.c
1 //#define TPD_HAVE_BUTTON
2
3 #include "tpd.h"
4 #include <linux/interrupt.h>
5 #include <cust_eint.h>
6 #include <linux/i2c.h>
7 #include <linux/i2c-dev.h>
8 #include <linux/cdev.h>
9 #include <linux/sched.h>
10 #include <linux/kthread.h>
11 #include <linux/rtpm_prio.h>
12 #include <linux/wait.h>
13 #include <linux/time.h>
14 #include <linux/delay.h>
15 #include <mach/mt_pm_ldo.h>
16 //#include <mach/mt6575_pll.h>
17 #include <linux/dma-mapping.h>
18
19 #ifdef TPD_GPT_TIMER_RESUME
20 #include <mach/hardware.h>
21 #include <mach/mt_gpt.h>
22 #include <linux/timer.h>
23 #endif
24 #include "tpd_custom_ft5x06.h"
25
26 #include "cust_gpio_usage.h"
27
28 //#define FTS_APK_DEBUG
29 #define SYSFS_DEBUG
30 //#define FTS_AUTO_UPGRADE
31 #if defined(SYSFS_DEBUG) || defined(FTS_AUTO_UPGRADE)
32 #include "ft5x06_ex_fun.h"
33 #endif
34
35 #define TPD_INFO(fmt, arg...) printk("[tpd info:5x06]" "[%s]" fmt "\r\n", __FUNCTION__ ,##arg)
36 //#define TP_DEBUG
37 #undef TPD_DEBUG
38 #undef TPD_DMESG
39 #if defined(TP_DEBUG)
40 #define TPD_DEBUG(fmt, arg...) printk("[tpd debug:5x06]" "[%s]" fmt "\r\n", __FUNCTION__ ,##arg)
41 #define TPD_DMESG(fmt, arg...) printk("[tpd dmesg:5x06]" "[%s]" fmt "\r\n", __FUNCTION__ ,##arg)
42 #else
43 #define TPD_DEBUG(fmt, arg...)
44 #define TPD_DMESG(fmt, arg...)
45 #endif
46
47 extern struct tpd_device *tpd;
48
49 struct i2c_client *i2c_client = NULL;
50 struct task_struct *thread = NULL;
51
52 static DECLARE_WAIT_QUEUE_HEAD(waiter);
53
54 static void tpd_eint_interrupt_handler(void);
55
56 static int tpd_probe(struct i2c_client *client, const struct i2c_device_id *id);
57 static int tpd_detect(struct i2c_client *client, struct i2c_board_info *info);
58 static int tpd_remove(struct i2c_client *client);
59 static int touch_event_handler(void *unused);
60
61 static int tpd_flag = 0;
62 static int point_num = 0;
63 static int p_point_num = 0;
64
65 #define TPD_CLOSE_POWER_IN_SLEEP
66
67 #define TPD_OK 0
68 //register define
69
70 #define DEVICE_MODE 0x00
71 #define GEST_ID 0x01
72 #define TD_STATUS 0x02
73 #define FW_ID_ADDR 0xA6
74
75
76 //register define
77
78 #define FINGER_NUM_MAX 10
79
80 struct touch_info {
81 int y[FINGER_NUM_MAX];
82 int x[FINGER_NUM_MAX];
83 int p[FINGER_NUM_MAX];
84 int count;
85 };
86
87 static const struct i2c_device_id tpd_id[] = {{"mtk-tpd",0},{}};
88
89 #if defined(E1910) && !defined(TP_CFG_FOR_E1910_SMT)
90 unsigned short force[] = {0,0x72,I2C_CLIENT_END,I2C_CLIENT_END};
91 static const unsigned short * const forces[] = { force, NULL };
92 //static struct i2c_client_address_data addr_data = { .forces = forces, };
93 static struct i2c_board_info __initdata i2c_tpd = { I2C_BOARD_INFO("mtk-tpd", (0x72>>1))};
94 #else
95 unsigned short force[] = {0,0x70,I2C_CLIENT_END,I2C_CLIENT_END};
96 static const unsigned short * const forces[] = { force, NULL };
97 //static struct i2c_client_address_data addr_data = { .forces = forces, };
98 static struct i2c_board_info __initdata i2c_tpd = { I2C_BOARD_INFO("mtk-tpd", (0x70>>1))};
99 #endif
100
101 static struct kobject *touchdebug_kobj;
102 static struct kobject *touchdebug_kobj_info;
103 static int sensitivity_level = 1;
104 static int EnableWakeUp = 0;
105
106 /* Waiting for deivce resume and write back touch sensitivity level */
107 static struct timer_list sensitivity_write_timer;
108
109 /* Touch panel resume delay */
110 #define TOUCH_RESUME_INTERVAL 500
111
112 /* Workqueue for set touch sensitivity level */
113 static struct workqueue_struct *sensitivity_wq;
114 static struct work_struct *sensitivity_work;
115
116 struct sensitivity_mapping {
117 int symbol;
118 int value;
119 };
120
121 enum {
122 TOUCH_SENSITIVITY_SYMBOL_HIGH = 0,
123 TOUCH_SENSITIVITY_SYMBOL_MEDIUM,
124 TOUCH_SENSITIVITY_SYMBOL_LOW,
125 TOUCH_SENSITIVITY_SYMBOL_COUNT,
126 };
127
128 static struct sensitivity_mapping sensitivity_table[] = {
129 {TOUCH_SENSITIVITY_SYMBOL_HIGH, 14},
130 {TOUCH_SENSITIVITY_SYMBOL_MEDIUM, 16},
131 {TOUCH_SENSITIVITY_SYMBOL_LOW, 19},
132 };
133
134 #define TOUCH_SENSITIVITY_SYMBOL_DEFAULT TOUCH_SENSITIVITY_SYMBOL_MEDIUM;
135
136 #define I2C_DEV_NUMBER 8
137 #define DRIVER_DEV_NAME "fts_ts"
138
139 struct fts_dev{
140 dev_t dev;
141 struct cdev cdev;
142 struct class *class;
143 unsigned char *buf;
144 struct fts_info *ts;
145 };
146
147 struct fts_info{
148 struct i2c_client *client;
149 struct input_dev *input_dev;
150 };
151
152 struct i2c_msg_formal{
153 __u16 addr; /* slave address */
154 __u16 flags;
155 #define I2C_M_TEN 0x0010 /* this is a ten bit chip address */
156 #define I2C_M_RD 0x0001 /* read data, from slave to master */
157 #define I2C_M_NOSTART 0x4000 /* if I2C_FUNC_PROTOCOL_MANGLING */
158 #define I2C_M_REV_DIR_ADDR 0x2000 /* if I2C_FUNC_PROTOCOL_MANGLING */
159 #define I2C_M_IGNORE_NAK 0x1000 /* if I2C_FUNC_PROTOCOL_MANGLING */
160 #define I2C_M_NO_RD_ACK 0x0800 /* if I2C_FUNC_PROTOCOL_MANGLING */
161 #define I2C_M_RECV_LEN 0x0400 /* length will be first received byte */
162 __u16 len; /* msg length */
163 __u8 *buf; /* pointer to msg data */
164 };
165
166 static struct fts_dev ts_dev;
167
168 #include <mach/mt_boot.h>
169 static int boot_mode = 0;
170
171 #ifdef TPD_HAVE_BUTTON
172 extern void tpd_button(unsigned int x, unsigned int y, unsigned int down);
173 #if 0
174 #if 1
175 #define TPD_KEYS {KEY_HOME,KEY_MENU,KEY_BACK,KEY_SEARCH}
176 #define TPD_KEYS_DIM {{30,850,60,100},{180,850,60,100},{320,850,60,100},{450,850,60,100}}
177 #define TPD_KEY_COUNT 4
178 #else
179 #define TPD_KEYS {KEY_HOME,KEY_MENU,KEY_BACK}
180 #define TPD_KEYS_DIM {{80,850,60,100},{240,850,60,100},{400,850,60,100}}
181 #define TPD_KEY_COUNT 3
182 #endif
183 #endif
184 static int tpd_keys_local[TPD_KEY_COUNT] = TPD_KEYS;
185 static int tpd_keys_dim_local[TPD_KEY_COUNT][4] = TPD_KEYS_DIM;
186 #endif
187
188 #if (defined(TPD_HAVE_CALIBRATION) && !defined(TPD_CUSTOM_CALIBRATION))
189 //static int tpd_calmat_local[8] = TPD_CALIBRATION_MATRIX;
190 static int tpd_calmat_driver[8] = {0};
191 static int tpd_def_calmat_local_normal[8] = TPD_CALIBRATION_MATRIX_ROTATION_NORMAL;
192 static int tpd_def_calmat_local_factory[8] = TPD_CALIBRATION_MATRIX_ROTATION_FACTORY;
193 #endif
194
195 static struct i2c_driver tpd_i2c_driver = {
196 .driver.name = "mtk-tpd",
197 .probe = tpd_probe,
198 .remove = tpd_remove,
199 .id_table = tpd_id,
200 .detect = tpd_detect,
201 .address_list = (const unsigned short*) forces,
202 };
203
204 #if 0
205 static unsigned short i2c_addr[] = {0x72};
206 #endif
207
208 static u8 *gpDMABuf_va = NULL;
209 static u32 gpDMABuf_pa = 0;
210
211 int fts_dma_i2c_read(struct i2c_client *client, u16 addr, int len, u32 rxbuf)
212 {
213 int ret;
214 u8 buffer[1];
215
216 struct i2c_msg msg[2] =
217 {
218 {
219 .addr = client->addr,
220 .flags = 0,
221 .buf = buffer,
222 .len = 1,
223 .timing = 400
224 },
225 {
226 .addr = client->addr,
227 .ext_flag = (client->ext_flag | I2C_ENEXT_FLAG | I2C_DMA_FLAG),
228 .flags = I2C_M_RD,
229 .buf = (u8 *)rxbuf,
230 .len = len,
231 .timing = 400
232 },
233 };
234
235 buffer[0] = addr;
236
237 if ((u8 *)rxbuf == NULL)
238 return -1;
239
240 ret = i2c_transfer(client->adapter, &msg[0], 2);
241 if (ret < 0)
242 dev_err(&client->dev, "%s i2c dma read error.\n", __func__);
243
244 return 0;
245 }
246
247 static ssize_t fts_i2cdev_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
248 {
249 char *tmp;
250 int ret;
251 /* struct fts_info *ts = ts_dev.ts; */
252 struct i2c_client *client = ts_dev.ts->client;
253
254 TPD_DMESG("called\n");
255
256 if (count > 8192)
257 count = 8192;
258
259 tmp = kmalloc(count, GFP_KERNEL);
260 if (tmp == NULL)
261 return -ENOMEM;
262
263 pr_debug("i2c-dev: i2c-%d reading %zu bytes.\n",
264 iminor(file->f_path.dentry->d_inode), count);
265
266 ret = i2c_master_recv(client, tmp, count);
267 if (ret >= 0)
268 ret = copy_to_user(buf, tmp, count) ? -EFAULT : ret;
269 kfree(tmp);
270 return ret;
271 }
272
273 static ssize_t fts_i2cdev_write(struct file *file, const char __user *buf, size_t count, loff_t *offset)
274 {
275 int ret;
276 char *tmp;
277 /* struct fts_info *ts = ts_dev.ts; */
278 struct i2c_client *client = ts_dev.ts->client;
279
280 TPD_DMESG("called\n");
281
282 if (count > 8192)
283 count = 8192;
284 /*
285 tmp = memdup_user(buf, count);
286 if (IS_ERR(tmp))
287 return PTR_ERR(tmp);
288 */
289 tmp = kmalloc(count,GFP_KERNEL);
290 if (tmp==NULL)
291 return -ENOMEM;
292 if (copy_from_user(tmp,buf,count)) {
293 kfree(tmp);
294 return -EFAULT;
295 }
296
297 pr_debug("i2c-dev: i2c-%d writing %zu bytes.\n",
298 iminor(file->f_path.dentry->d_inode), count);
299
300 ret = i2c_master_send(client, tmp, count);
301 kfree(tmp);
302 return ret;
303 }
304
305 static int i2cdev_check(struct device *dev, void *addrp)
306 {
307 struct i2c_client *client = i2c_verify_client(dev);
308 /* struct fts_info *ts = ts_dev.ts; */
309
310 TPD_DMESG("called\n");
311
312 if (!client || client->addr != *(unsigned int *)addrp)
313 return 0;
314
315 return dev->driver ? -EBUSY : 0;
316 }
317
318 static int i2cdev_check_addr(struct i2c_adapter *adapter, unsigned int addr)
319 {
320 return device_for_each_child(&adapter->dev, &addr, i2cdev_check);
321 }
322
323 static noinline int i2cdev_ioctl_rdrw(struct i2c_client *client,
324 unsigned long arg)
325 {
326 struct i2c_rdwr_ioctl_data rdwr_arg;
327 struct i2c_msg *rdwr_pa, *rdwr_pa_tmp;
328 struct i2c_msg_formal *rdwr_pa_formal;
329 u8 __user **data_ptrs;
330 int i, res;
331 /* struct fts_info *ts = ts_dev.ts; */
332
333 TPD_DMESG("called\n");
334
335 if (copy_from_user(&rdwr_arg,
336 (struct i2c_rdwr_ioctl_data __user *)arg,
337 sizeof(rdwr_arg)))
338 return -EFAULT;
339
340 /* Put an arbitrary limit on the number of messages that can
341 * be sent at once */
342 if (rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS)
343 return -EINVAL;
344
345 rdwr_pa = kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg), GFP_KERNEL);
346 if (!rdwr_pa)
347 return -ENOMEM;
348
349 rdwr_pa_formal = kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg_formal), GFP_KERNEL);
350 if (!rdwr_pa)
351 return -ENOMEM;
352
353 if (copy_from_user(rdwr_pa_formal, rdwr_arg.msgs,
354 rdwr_arg.nmsgs * sizeof(struct i2c_msg_formal))) {
355 kfree(rdwr_pa);
356 return -EFAULT;
357 }
358
359 data_ptrs = kmalloc(rdwr_arg.nmsgs * sizeof(u8 __user *), GFP_KERNEL);
360 if (data_ptrs == NULL) {
361 kfree(rdwr_pa);
362 kfree(rdwr_pa_formal);
363 return -ENOMEM;
364 }
365
366 res = 0;
367 for (i = 0, rdwr_pa_tmp = rdwr_pa; i < rdwr_arg.nmsgs; i++, rdwr_pa_tmp++) {
368 rdwr_pa_tmp->addr = rdwr_pa_formal->addr;
369 rdwr_pa_tmp->flags = rdwr_pa_formal->flags;
370 rdwr_pa_tmp->len = rdwr_pa_formal->len;
371 rdwr_pa_tmp->timing = client->timing;
372 rdwr_pa_tmp->ext_flag = 0;
373
374 /* Limit the size of the message to a sane amount;
375 * and don't let length change either. */
376 if ((rdwr_pa[i].len > 8192) ||
377 (rdwr_pa[i].flags & I2C_M_RECV_LEN)) {
378 res = -EINVAL;
379 break;
380 }
381 data_ptrs[i] = (u8 __user *)rdwr_pa_formal[i].buf;
382
383 rdwr_pa[i].buf = kmalloc(rdwr_pa[i].len, GFP_KERNEL);
384 if (rdwr_pa[i].buf == NULL) {
385 res = -ENOMEM;
386 break;
387 }
388 if (copy_from_user(rdwr_pa[i].buf, data_ptrs[i],
389 rdwr_pa[i].len)) {
390 ++i; /* Needs to be kfreed too */
391 res = -EFAULT;
392 break;
393 }
394 /*
395 rdwr_pa[i].buf = memdup_user(data_ptrs[i], rdwr_pa[i].len);
396 if (IS_ERR(rdwr_pa[i].buf)) {
397 res = PTR_ERR(rdwr_pa[i].buf);
398 break;
399 }
400 */
401 }
402 if (res < 0) {
403 int j;
404 for (j = 0; j < i; ++j)
405 kfree(rdwr_pa[j].buf);
406 kfree(data_ptrs);
407 kfree(rdwr_pa);
408 kfree(rdwr_pa_formal);
409 return res;
410 }
411
412 res = i2c_transfer(client->adapter, rdwr_pa, rdwr_arg.nmsgs);
413 while (i-- > 0) {
414 if (res >= 0 && (rdwr_pa[i].flags & I2C_M_RD)) {
415 if (copy_to_user(data_ptrs[i], rdwr_pa[i].buf,
416 rdwr_pa[i].len))
417 res = -EFAULT;
418 }
419 kfree(rdwr_pa[i].buf);
420 }
421 kfree(data_ptrs);
422 kfree(rdwr_pa);
423 kfree(rdwr_pa_formal);
424 return res;
425 }
426
427 static noinline int i2cdev_ioctl_smbus(struct i2c_client *client,
428 unsigned long arg)
429 {
430 struct i2c_smbus_ioctl_data data_arg;
431 union i2c_smbus_data temp;
432 int datasize, res;
433
434 if (copy_from_user(&data_arg,
435 (struct i2c_smbus_ioctl_data __user *) arg,
436 sizeof(struct i2c_smbus_ioctl_data)))
437 return -EFAULT;
438 if ((data_arg.size != I2C_SMBUS_BYTE) &&
439 (data_arg.size != I2C_SMBUS_QUICK) &&
440 (data_arg.size != I2C_SMBUS_BYTE_DATA) &&
441 (data_arg.size != I2C_SMBUS_WORD_DATA) &&
442 (data_arg.size != I2C_SMBUS_PROC_CALL) &&
443 (data_arg.size != I2C_SMBUS_BLOCK_DATA) &&
444 (data_arg.size != I2C_SMBUS_I2C_BLOCK_BROKEN) &&
445 (data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA) &&
446 (data_arg.size != I2C_SMBUS_BLOCK_PROC_CALL)) {
447 dev_dbg(&client->adapter->dev,
448 "size out of range (%x) in ioctl I2C_SMBUS.\n",
449 data_arg.size);
450 return -EINVAL;
451 }
452 /* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1,
453 so the check is valid if size==I2C_SMBUS_QUICK too. */
454 if ((data_arg.read_write != I2C_SMBUS_READ) &&
455 (data_arg.read_write != I2C_SMBUS_WRITE)) {
456 dev_dbg(&client->adapter->dev,
457 "read_write out of range (%x) in ioctl I2C_SMBUS.\n",
458 data_arg.read_write);
459 return -EINVAL;
460 }
461
462 /* Note that command values are always valid! */
463
464 if ((data_arg.size == I2C_SMBUS_QUICK) ||
465 ((data_arg.size == I2C_SMBUS_BYTE) &&
466 (data_arg.read_write == I2C_SMBUS_WRITE)))
467 /* These are special: we do not use data */
468 return i2c_smbus_xfer(client->adapter, client->addr,
469 client->flags, data_arg.read_write,
470 data_arg.command, data_arg.size, NULL);
471
472 if (data_arg.data == NULL) {
473 dev_dbg(&client->adapter->dev,
474 "data is NULL pointer in ioctl I2C_SMBUS.\n");
475 return -EINVAL;
476 }
477
478 if ((data_arg.size == I2C_SMBUS_BYTE_DATA) ||
479 (data_arg.size == I2C_SMBUS_BYTE))
480 datasize = sizeof(data_arg.data->byte);
481 else if ((data_arg.size == I2C_SMBUS_WORD_DATA) ||
482 (data_arg.size == I2C_SMBUS_PROC_CALL))
483 datasize = sizeof(data_arg.data->word);
484 else /* size == smbus block, i2c block, or block proc. call */
485 datasize = sizeof(data_arg.data->block);
486
487 if ((data_arg.size == I2C_SMBUS_PROC_CALL) ||
488 (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) ||
489 (data_arg.size == I2C_SMBUS_I2C_BLOCK_DATA) ||
490 (data_arg.read_write == I2C_SMBUS_WRITE)) {
491 if (copy_from_user(&temp, data_arg.data, datasize))
492 return -EFAULT;
493 }
494 if (data_arg.size == I2C_SMBUS_I2C_BLOCK_BROKEN) {
495 /* Convert old I2C block commands to the new
496 convention. This preserves binary compatibility. */
497 data_arg.size = I2C_SMBUS_I2C_BLOCK_DATA;
498 if (data_arg.read_write == I2C_SMBUS_READ)
499 temp.block[0] = I2C_SMBUS_BLOCK_MAX;
500 }
501 res = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
502 data_arg.read_write, data_arg.command, data_arg.size, &temp);
503 if (!res && ((data_arg.size == I2C_SMBUS_PROC_CALL) ||
504 (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) ||
505 (data_arg.read_write == I2C_SMBUS_READ))) {
506 if (copy_to_user(data_arg.data, &temp, datasize))
507 return -EFAULT;
508 }
509 return res;
510 }
511
512 static long fts_i2cdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
513 {
514 struct i2c_client *client = ts_dev.ts->client;
515 unsigned long funcs;
516 /* struct fts_info *ts = ts_dev.ts; */
517
518 TPD_DMESG( "ioctl, cmd=0x%02x, arg=0x%02lx\n", cmd, arg);
519
520 switch (cmd) {
521 case I2C_SLAVE:
522 case I2C_SLAVE_FORCE:
523 /* NOTE: devices set up to work with "new style" drivers
524 * can't use I2C_SLAVE, even when the device node is not
525 * bound to a driver. Only I2C_SLAVE_FORCE will work.
526 *
527 * Setting the PEC flag here won't affect kernel drivers,
528 * which will be using the i2c_client node registered with
529 * the driver model core. Likewise, when that client has
530 * the PEC flag already set, the i2c-dev driver won't see
531 * (or use) this setting.
532 */
533 if ((arg > 0x3ff) ||
534 (((client->flags & I2C_M_TEN) == 0) && arg > 0x7f))
535 return -EINVAL;
536 if (cmd == I2C_SLAVE && i2cdev_check_addr(client->adapter, arg))
537 return -EBUSY;
538 /* REVISIT: address could become busy later */
539 client->addr = arg;
540 return 0;
541 case I2C_TENBIT:
542 if (arg)
543 client->flags |= I2C_M_TEN;
544 else
545 client->flags &= ~I2C_M_TEN;
546 return 0;
547 case I2C_PEC:
548 if (arg)
549 client->flags |= I2C_CLIENT_PEC;
550 else
551 client->flags &= ~I2C_CLIENT_PEC;
552 return 0;
553 case I2C_FUNCS:
554 funcs = i2c_get_functionality(client->adapter);
555 return put_user(funcs, (unsigned long __user *)arg);
556
557 case I2C_RDWR:
558 return i2cdev_ioctl_rdrw(client, arg);
559
560 case I2C_SMBUS:
561 return i2cdev_ioctl_smbus(client, arg);
562
563 case I2C_RETRIES:
564 client->adapter->retries = arg;
565 break;
566 case I2C_TIMEOUT:
567 /* For historical reasons, user-space sets the timeout
568 * value in units of 10 ms.
569 */
570 client->adapter->timeout = msecs_to_jiffies(arg * 10);
571 break;
572 default:
573 /* NOTE: returning a fault code here could cause trouble
574 * in buggy userspace code. Some old kernel bugs returned
575 * zero in this case, and userspace code might accidentally
576 * have depended on that bug.
577 */
578 return -ENOTTY;
579 }
580 return 0;
581 }
582
583 static int fts_i2cdev_open(struct inode *inode, struct file *file)
584 {
585
586 /* struct fts_info *ts = ts_dev.ts; */
587
588 TPD_DMESG("called\n");
589
590 if(ts_dev.ts){
591 disable_irq(ts_dev.ts->client->irq);
592 printk("[i2c-8] [fts_i2cdev_open][success]\n");
593 }
594 else{
595 printk("[i2c-8] [fts_i2cdev_open][fail]\n");
596 return -ENOMEM;
597 }
598
599 return 0;
600 }
601
602 static int fts_i2cdev_release(struct inode *inode, struct file *file)
603 {
604
605 /* struct fts_info *ts = ts_dev.ts; */
606
607 /*
608 struct i2c_client *client = file->private_data;
609
610 i2c_put_adapter(client->adapter);
611 kfree(client);
612 file->private_data = NULL;
613 */
614 TPD_DMESG("called\n");
615 if(ts_dev.ts)
616 enable_irq(ts_dev.ts->client->irq);
617 else
618 return -ENOMEM;
619
620 return 0;
621 }
622
623 static const struct file_operations fts_fops = {
624 .owner = THIS_MODULE,
625 //.llseek = no_llseek,
626 .read = fts_i2cdev_read,
627 .write = fts_i2cdev_write,
628 .unlocked_ioctl = fts_i2cdev_ioctl,
629 .open = fts_i2cdev_open,
630 .release = fts_i2cdev_release,
631 };
632
633 int fts_i2cdev_init(struct fts_info *ts)
634 {
635
636 int ret;
637 struct device *dev;
638
639 memset(&ts_dev, 0, sizeof(struct fts_dev));
640
641 ret = alloc_chrdev_region(&ts_dev.dev, 0, 1, DRIVER_DEV_NAME);
642 if(ret){
643 TPD_DMESG("Unable to get a dynamic major for %s.\n", DRIVER_DEV_NAME);
644 return ret;
645 }
646
647 cdev_init(&ts_dev.cdev, &fts_fops);
648 ts_dev.cdev.owner = THIS_MODULE;
649 ret = cdev_add(&ts_dev.cdev, ts_dev.dev, 1);
650 if (ret) {
651 TPD_DMESG("Unable to register character device !\n");
652 goto fail_add;
653 }
654
655 ts_dev.class = class_create(THIS_MODULE, DRIVER_DEV_NAME);
656
657 if(IS_ERR(ts_dev.class)){
658 TPD_DMESG("Unable to register i2c device class !\n");
659 ret = PTR_ERR(ts_dev.class);
660 goto err_class;
661 }
662
663 dev = device_create(ts_dev.class, NULL, ts_dev.dev, NULL, "i2c-%d", I2C_DEV_NUMBER);
664
665 if(IS_ERR(dev)){
666 TPD_DMESG("Failed to create device !\n");
667 ret = PTR_ERR(dev);
668 goto err_device;
669 }
670
671 ts_dev.ts = ts;
672
673 return 0;
674
675 err_device:
676 class_destroy(ts_dev.class);
677 err_class:
678 cdev_del(&ts_dev.cdev);
679 fail_add:
680 unregister_chrdev_region(ts_dev.dev, 1);
681
682 return ret;
683 }
684
685 void fts_i2cdev_exit(void)
686 {
687
688 cdev_del(&ts_dev.cdev);
689 unregister_chrdev_region(ts_dev.dev, 1);
690 device_destroy(ts_dev.class, ts_dev.dev);
691 class_destroy(ts_dev.class);
692 }
693
694 int myatoi(const char *a)
695 {
696 int s = 0;
697
698 while(*a >= '0' && *a <= '9')
699 s = (s << 3) + (s << 1) + *a++ - '0';
700 return s;
701 }
702
703 static void sensitivity_set_func(struct work_struct *work)
704 {
705 uint8_t wdata[1] = {0};
706 int ret;
707
708 TPD_INFO("sensitivity_set_func value:%d\n", sensitivity_level);
709
710 wdata[0] = sensitivity_table[sensitivity_level].value;
711 ret = ft5x0x_write_reg(i2c_client, 0x80, wdata[0]);
712 if(ret < 0)
713 TPD_INFO("Can not write sensitivity\n");
714
715 if (EnableWakeUp) {
716 #ifdef MODIFY_SCANRATE_TO_DEFAULT_VALUE
717 /* Modify scan rate to default value */
718 wdata[0] = 40;
719 ret = ft5x0x_write_reg(i2c_client, 0x89, wdata[0]);
720 if(ret < 0)
721 TPD_INFO("Can not write scan rate\n");
722 #endif
723 }
724
725 return;
726 }
727
728 static void sensitivity_func(long unsigned unused)
729 {
730 TPD_INFO("sensitivity_func \n");
731
732 queue_work(sensitivity_wq, sensitivity_work);
733
734 return;
735 }
736
737 static ssize_t firmware_show(struct kobject *kobj,
738 struct kobj_attribute *attr,
739 char * buf)
740 {
741 unsigned char reg_version = 0;
742 i2c_smbus_read_i2c_block_data(i2c_client, FW_ID_ADDR, 1, &reg_version);
743 return sprintf(buf, "FT0-%x0-13032500\n", reg_version);
744 }
745
746 static ssize_t wakeup_store(struct kobject *kobj,
747 struct kobj_attribute *attr,
748 const char * buf, size_t n)
749 {
750 int symbol = -1;
751 int ret;
752
753 symbol = myatoi(buf);
754 if (EnableWakeUp != symbol) {
755 EnableWakeUp = symbol;
756 /* Modify wake up mode:
757 0: disable
758 1: only 2 fingers
759 2: only 5 fingers
760 3: 2 or 5 fingers*/
761 ret = ft5x0x_write_reg(i2c_client, 0xac, EnableWakeUp);
762 if(ret < 0)
763 TPD_INFO("Can not write wake up mode\n");
764 }
765
766 TPD_INFO("wakeup_store value:%d\n", EnableWakeUp);
767
768 return n;
769 }
770
771 static ssize_t wakeup_show(struct kobject *kobj,
772 struct kobj_attribute *attr,
773 char * buf)
774 {
775 return sprintf(buf, "%d\n", EnableWakeUp);
776 }
777
778 static ssize_t sensitivity_store(struct kobject *kobj,
779 struct kobj_attribute *attr,
780 const char * buf, size_t n)
781 {
782 uint8_t wdata[1] = {0};
783 int symbol = -1;
784 int ret;
785
786 symbol = myatoi(buf);
787 sensitivity_level = symbol;
788 TPD_INFO("sensitive_store value:%d\n", symbol);
789
790 wdata[0] = sensitivity_table[symbol].value;
791
792 ret = ft5x0x_write_reg(i2c_client, 0x80, wdata[0]);
793 if(ret < 0)
794 TPD_INFO("Can not write sensitivity\n");
795
796 return n;
797 }
798
799 static ssize_t sensitivity_show(struct kobject *kobj,
800 struct kobj_attribute *attr,
801 char * buf)
802 {
803 uint8_t rdata[1] = {0};
804 int i, symbol = -1;
805
806 if (!i2c_smbus_read_i2c_block_data(i2c_client, 0x80, 1, rdata)) {
807 goto i2c_err;
808 }
809
810 for (i = 0; i < TOUCH_SENSITIVITY_SYMBOL_COUNT; i++) {
811 if (sensitivity_table[i].value == rdata[0]) {
812 symbol = sensitivity_table[i].symbol;
813 break;
814 }
815 }
816
817 i2c_err:
818 if (symbol == -1) {
819 TPD_INFO("touch sensitivity default value\n");
820 symbol = TOUCH_SENSITIVITY_SYMBOL_DEFAULT;
821 }
822
823 return sprintf(buf, "%d\n", symbol);
824 }
825
826 static struct kobj_attribute firmware_attr = { \
827 .attr = { \
828 .name = __stringify(firmware), \
829 .mode = 0644, \
830 }, \
831 .show = firmware_show, \
832 };
833
834 static struct kobj_attribute wakeup_attr = { \
835 .attr = { \
836 .name = __stringify(wakeup), \
837 .mode = 0644, \
838 }, \
839 .show = wakeup_show, \
840 .store = wakeup_store, \
841 };
842
843 static struct kobj_attribute sensitivity_attr = { \
844 .attr = { \
845 .name = __stringify(sensitivity), \
846 .mode = 0644, \
847 }, \
848 .show = sensitivity_show, \
849 .store = sensitivity_store, \
850 };
851
852 static struct attribute * g[] = {
853 &sensitivity_attr.attr,
854 &wakeup_attr.attr,
855 NULL,
856 };
857
858 static struct attribute * g_info[] = {
859 &firmware_attr.attr,
860 NULL,
861 };
862
863 static struct attribute_group attr_group = {
864 .attrs = g,
865 };
866
867 static struct attribute_group attr_group_info = {
868 .attrs = g_info,
869 };
870
871 static void tpd_down(int x, int y, int p) {
872
873 #ifdef TPD_HAVE_BUTTON
874 #if defined(TP_CFG_FOR_E1910_SMT) || defined(ROTATION_FOR_E1910_CQ)
875 if(MTK_LCM_PHYSICAL_ROTATION == 270 || MTK_LCM_PHYSICAL_ROTATION == 90)
876 {
877 #if defined(TP_HEIGHT)
878 if(boot_mode!=NORMAL_BOOT && x>=TP_HEIGHT) {
879 tpd_button(x, y, 1);
880 #else
881 if(boot_mode!=NORMAL_BOOT && x>=TPD_RES_Y) {
882 tpd_button(x, y, 1);
883 #endif
884
885 return;
886 }
887 }
888 else
889 #endif
890 {
891 #if defined(TP_HEIGHT)
892 if(boot_mode!=NORMAL_BOOT && y>=TP_HEIGHT) {
893 tpd_button(x, y, 1);
894 #else
895 if(boot_mode!=NORMAL_BOOT && y>=TPD_RES_Y) {
896 tpd_button(x, y, 1);
897 #endif
898
899 return;
900 }
901 }
902
903 #endif
904
905 // input_report_abs(tpd->dev, ABS_PRESSURE, p);
906 input_report_key(tpd->dev, BTN_TOUCH, 1);
907 input_report_abs(tpd->dev, ABS_MT_TOUCH_MAJOR, 1);
908
909 #if defined(TP_CFG_FOR_E1910_SMT) || defined(ROTATION_FOR_E1910_CQ)
910 if(boot_mode!=NORMAL_BOOT && (MTK_LCM_PHYSICAL_ROTATION == 270 || MTK_LCM_PHYSICAL_ROTATION == 90) )
911 {
912 int temp;
913
914 temp = y;
915 y = x;
916 x = TPD_RES_X-temp;
917 }
918 #endif
919
920 input_report_abs(tpd->dev, ABS_MT_POSITION_X, x);
921 input_report_abs(tpd->dev, ABS_MT_POSITION_Y, y);
922 TPD_DEBUG("D[%4d %4d %4d] ", x, y, p);
923 TPD_EM_PRINT(x, y, x, y, p-1, 1);
924 input_mt_sync(tpd->dev);
925 TPD_DOWN_DEBUG_TRACK(x,y);
926 }
927
928 static void tpd_up(int x, int y,int p) {
929 //input_report_abs(tpd->dev, ABS_PRESSURE, 0);
930 input_report_key(tpd->dev, BTN_TOUCH, 0);
931 //input_report_abs(tpd->dev, ABS_MT_TOUCH_MAJOR, 0);
932 //input_report_abs(tpd->dev, ABS_MT_POSITION_X, x);
933 //input_report_abs(tpd->dev, ABS_MT_POSITION_Y, y);
934 //printk("U[%4d %4d %4d] ", x, y, 0);
935 TPD_EM_PRINT(x, y, x, y, 0, 0);
936 input_mt_sync(tpd->dev);
937 TPD_UP_DEBUG_TRACK(x,y);
938 }
939
940 static int tpd_touchinfo(struct touch_info *cinfo, struct touch_info *pinfo)
941 {
942 int i = 0;
943 char *data = gpDMABuf_va;
944 u16 high_byte,low_byte;
945
946 p_point_num = point_num;
947 memcpy(pinfo, cinfo, sizeof(struct touch_info));
948 memset(cinfo, 0, sizeof(struct touch_info));
949
950 fts_dma_i2c_read(i2c_client, 0x00, 64, gpDMABuf_pa);
951 //TPD_DEBUG("FW version=%x]\n",data[24]);
952
953 //TPD_DEBUG("received raw data from touch panel as following:\n");
954 //TPD_DEBUG("[data[0]=%x,data[1]= %x ,data[2]=%x ,data[3]=%x ,data[4]=%x ,data[5]=%x]\n",data[0],data[1],data[2],data[3],data[4],data[5]);
955 //TPD_DEBUG("[data[9]=%x,data[10]= %x ,data[11]=%x ,data[12]=%x]\n",data[9],data[10],data[11],data[12]);
956 //TPD_DEBUG("[data[15]=%x,data[16]= %x ,data[17]=%x ,data[18]=%x]\n",data[15],data[16],data[17],data[18]);
957
958 /* Device Mode[2:0] == 0 :Normal operating Mode*/
959 if((data[0] & 0x70) != 0) return false;
960
961 /*get the number of the touch points*/
962 point_num= data[2] & 0x0f;
963
964 TPD_DEBUG("point_num =%d\n",point_num);
965
966 if(FINGER_NUM_MAX < point_num)
967 {
968 TPD_DEBUG("point_num is error\n");
969 return false;
970 }
971
972 // if(point_num == 0) return false;
973
974 //TPD_DEBUG("Procss raw data...\n");
975
976
977 for(i = 0; i < point_num; i++)
978 {
979 cinfo->p[i] = data[3+6*i] >> 6; //event flag
980
981 /*get the X coordinate, 2 bytes*/
982 high_byte = data[3+6*i];
983 high_byte <<= 8;
984 high_byte &= 0x0f00;
985 low_byte = data[3+6*i + 1];
986 cinfo->x[i] = high_byte |low_byte;
987
988 //cinfo->x[i] = cinfo->x[i] * 480 >> 11; //calibra
989 /*get the Y coordinate, 2 bytes*/
990 high_byte = data[3+6*i+2];
991 high_byte <<= 8;
992 high_byte &= 0x0f00;
993 low_byte = data[3+6*i+3];
994 cinfo->y[i] = high_byte |low_byte;
995
996 //cinfo->y[i]= cinfo->y[i] * 800 >> 11;
997 cinfo->count++;
998
999 #if defined(TPD_RES_X) && defined(TP_WIDTH)
1000 cinfo->x[i] = cinfo->x[i]*TP_WIDTH/TPD_RES_X;
1001 #endif
1002 #if defined(TPD_RES_Y) && defined(TP_HEIGHT)
1003 cinfo->y[i] = cinfo->y[i]*TP_HEIGHT/TPD_RES_Y;
1004 #endif
1005
1006 TPD_DEBUG(" cinfo->x[i=%d] = %d, cinfo->y[i] = %d, cinfo->p[i] = %d\n", i,cinfo->x[i], cinfo->y[i], cinfo->p[i]);
1007 }
1008
1009 //TPD_DEBUG(" cinfo->x[0] = %d, cinfo->y[0] = %d, cinfo->p[0] = %d\n", cinfo->x[0], cinfo->y[0], cinfo->p[0]);
1010 //TPD_DEBUG(" cinfo->x[1] = %d, cinfo->y[1] = %d, cinfo->p[1] = %d\n", cinfo->x[1], cinfo->y[1], cinfo->p[1]);
1011 //TPD_DEBUG(" cinfo->x[2]= %d, cinfo->y[2]= %d, cinfo->p[2] = %d\n", cinfo->x[2], cinfo->y[2], cinfo->p[2]);
1012
1013 #if defined(SMT_TP_CONFIG)
1014 for(i = 0; i < point_num; i++)
1015 {
1016 cinfo->x[i] = cinfo->x[i] *36/51;//5.1CM/5.4CM
1017 cinfo->y[i] = cinfo->y[i] *27/37;//7.4CM/9.0CM
1018 }
1019 #endif
1020
1021 #if 0/*!defined(TP_CFG_FOR_E1910_SMT) && !defined(ROTATION_FOR_E1910_CQ)*/
1022 if(MTK_LCM_PHYSICAL_ROTATION == 270 || MTK_LCM_PHYSICAL_ROTATION == 90)
1023 {
1024 for(i = 0; i < point_num; i++)
1025 {
1026 int temp;
1027
1028 temp = cinfo->x[i];
1029 cinfo->x[i] = TPD_RES_X-cinfo->y[i];
1030 cinfo->y[i] = temp;
1031 }
1032
1033 TPD_DEBUG("rot cinfo->x[0] = %d, cinfo->y[0] = %d, cinfo->p[0] = %d\n", cinfo->x[0], cinfo->y[0], cinfo->p[0]);
1034 TPD_DEBUG("rot cinfo->x[1] = %d, cinfo->y[1] = %d, cinfo->p[1] = %d\n", cinfo->x[1], cinfo->y[1], cinfo->p[1]);
1035 }
1036 #endif
1037
1038 return true;
1039 };
1040
1041 /*Coordination mapping*/
1042 static void tpd_calibrate_driver(int *x, int *y)
1043 {
1044 int tx;
1045
1046 TPD_DEBUG("Call tpd_calibrate of this driver ..\n");
1047 tx = ((tpd_calmat_driver[0] * (*x)) + (tpd_calmat_driver[1] * (*y)) + (tpd_calmat_driver[2])) >> 12;
1048 *y = ((tpd_calmat_driver[3] * (*x)) + (tpd_calmat_driver[4] * (*y)) + (tpd_calmat_driver[5])) >> 12;
1049 *x = tx;
1050 }
1051
1052 static int touch_event_handler(void *unused)
1053 {
1054 struct touch_info cinfo, pinfo;
1055 int i = 0;
1056 int input_x = 0;
1057 int input_y = 0;
1058
1059 struct sched_param param = { .sched_priority = RTPM_PRIO_TPD };
1060 sched_setscheduler(current, SCHED_RR, &param);
1061
1062 do
1063 {
1064 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
1065 set_current_state(TASK_INTERRUPTIBLE);
1066 wait_event_interruptible(waiter,tpd_flag!=0);
1067
1068 tpd_flag = 0;
1069
1070 set_current_state(TASK_RUNNING);
1071
1072 if (tpd_touchinfo(&cinfo, &pinfo))
1073 {
1074 TPD_DEBUG("point_num = %d\n",point_num);
1075
1076 if(point_num >0)
1077 {
1078 #if 0
1079 tpd_down(cinfo.x[0], cinfo.y[0], 1);
1080 if(point_num>1)
1081 {
1082 tpd_down(cinfo.x[1], cinfo.y[1], 1);
1083 if(point_num >2)
1084 tpd_down(cinfo.x[2], cinfo.y[2], 1);
1085 }
1086 #else
1087 while(i<point_num)
1088 {
1089 //tpd_down(cinfo.x[i], cinfo.y[i], 1);
1090 input_x = cinfo.x[i];
1091 input_y = cinfo.y[i];
1092 tpd_calibrate_driver(&input_x, &input_y);
1093 tpd_down(input_x, input_y, 1);
1094 i++;
1095 }
1096 i = 0;
1097 #endif
1098 TPD_DEBUG("press --->\n");
1099
1100 }
1101 else
1102 {
1103 TPD_DEBUG("release --->\n");
1104
1105 if(p_point_num >1)
1106 {
1107 i = 0;
1108 while(i<p_point_num){
1109 tpd_up(pinfo.x[i], pinfo.y[i], 1);
1110 i++;
1111 }
1112 }
1113 else
1114 {
1115 tpd_up(pinfo.x[0], pinfo.y[0], 1);
1116 }
1117 i = 0;
1118
1119 #ifdef TPD_HAVE_BUTTON
1120 if(boot_mode!=NORMAL_BOOT && tpd->btn_state)
1121 {
1122 tpd_button(pinfo.x[0], pinfo.y[0], 0);
1123 }
1124 #endif
1125
1126 }
1127
1128 input_sync(tpd->dev);
1129 }
1130
1131 }while(!kthread_should_stop());
1132
1133 return 0;
1134 }
1135
1136 static int tpd_detect (struct i2c_client *client, struct i2c_board_info *info)
1137 {
1138 TPD_DEBUG("tpd_detect\n");
1139 strcpy(info->type, TPD_DEVICE);
1140 return 0;
1141 }
1142
1143 static void tpd_eint_interrupt_handler(void)
1144 {
1145 TPD_DEBUG("TPD interrupt has been triggered\n");
1146 tpd_flag = 1;
1147 mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
1148 wake_up_interruptible(&waiter);
1149 }
1150
1151 static void tpd_gpio_config(void)
1152 {
1153
1154 mt_set_gpio_pull_enable(GPIO_CTP_RST_PIN, GPIO_PULL_ENABLE);
1155 mt_set_gpio_pull_select(GPIO_CTP_RST_PIN, GPIO_PULL_UP);
1156 mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
1157 mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);
1158 mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);
1159
1160 mt_set_gpio_mode(GPIO_CTP_EINT_PIN, GPIO_CTP_EINT_PIN_M_EINT);
1161 mt_set_gpio_dir(GPIO_CTP_EINT_PIN, GPIO_DIR_IN);
1162 mt_set_gpio_pull_enable(GPIO_CTP_EINT_PIN, GPIO_PULL_ENABLE);
1163 mt_set_gpio_pull_select(GPIO_CTP_EINT_PIN, GPIO_PULL_UP);
1164
1165 msleep(50);
1166 }
1167
1168 static int tpd_probe(struct i2c_client *client, const struct i2c_device_id *id)
1169 {
1170 int retval = TPD_OK;
1171 char data;
1172 /* int i; */
1173 struct fts_info *ts;
1174 int err = 0;
1175
1176 i2c_client = client;
1177 TPD_INFO("tpd_probe\n");
1178
1179 tpd_gpio_config();
1180
1181 #ifdef TPD_CLOSE_POWER_IN_SLEEP
1182
1183 #ifdef TPD_POWER_SOURCE_CUSTOM
1184 hwPowerOn(TPD_POWER_SOURCE_CUSTOM, VOL_2800, "TP");
1185 #else
1186 #ifndef TPD_LDO_VOL
1187 hwPowerOn(TPD_POWER_SOURCE, VOL_2800, "TP");
1188 #else
1189 hwPowerOn(TPD_POWER_SOURCE, TPD_LDO_VOL, "TP");
1190 #endif //TPD_LDO_VOL
1191 #endif
1192 #ifdef TPD_POWER_SOURCE_1800
1193 hwPowerOn(TPD_POWER_SOURCE_1800, VOL_1800, "TP");
1194 #endif
1195 msleep(100);
1196 mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);
1197 mdelay(200);
1198
1199 #if 0
1200 mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
1201 mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);
1202 mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);
1203 TPD_INFO("TPD_CLOSE_POWER_IN_SLEEP\n");
1204 for(i = 0; i < 2; i++) /*Do Power on again to avoid tp bug*/
1205 {
1206 #ifdef TPD_POWER_SOURCE_CUSTOM
1207 hwPowerDown(TPD_POWER_SOURCE_CUSTOM, "TP");
1208 #else
1209 hwPowerDown(TPD_POWER_SOURCE, "TP");
1210 #endif
1211 #ifdef TPD_POWER_SOURCE_1800
1212 hwPowerDown(TPD_POWER_SOURCE_1800, "TP");
1213 #endif
1214 mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);
1215 mdelay(10);
1216 mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);
1217 mdelay(50);
1218 #ifdef TPD_POWER_SOURCE_CUSTOM
1219 hwPowerOn(TPD_POWER_SOURCE_CUSTOM, VOL_2800, "TP");
1220 #else
1221 hwPowerOn(TPD_POWER_SOURCE, VOL_2800, "TP");
1222 #endif
1223 #ifdef TPD_POWER_SOURCE_1800
1224 hwPowerOn(TPD_POWER_SOURCE_1800, VOL_1800, "TP");
1225 #endif
1226
1227 msleep(100);
1228 }
1229 #endif
1230 #else
1231 #if 1
1232 #ifdef TPD_POWER_SOURCE_CUSTOM
1233 hwPowerDown(TPD_POWER_SOURCE_CUSTOM, "TP");
1234 #else
1235 hwPowerDown(TPD_POWER_SOURCE, "TP");
1236 #endif
1237 #ifdef TPD_POWER_SOURCE_1800
1238 hwPowerDown(TPD_POWER_SOURCE_1800, "TP");
1239 #endif
1240
1241 TPD_INFO("tpd power on!\n");
1242 #ifdef TPD_POWER_SOURCE_CUSTOM
1243 hwPowerOn(TPD_POWER_SOURCE_CUSTOM, VOL_2800, "TP");
1244 #else
1245 #ifndef TPD_LDO_VOL
1246 hwPowerOn(TPD_POWER_SOURCE, VOL_2800, "TP");
1247 #else
1248 hwPowerOn(TPD_POWER_SOURCE, TPD_LDO_VOL, "TP");
1249 #endif //TPD_LDO_VOL
1250 #endif
1251 #ifdef TPD_POWER_SOURCE_1800
1252 hwPowerOn(TPD_POWER_SOURCE_1800, VOL_1800, "TP");
1253 #endif
1254 msleep(100);
1255 #endif
1256 /*
1257 mt_set_gpio_mode(GPIO_CTP_EN_PIN, GPIO_CTP_EN_PIN_M_GPIO);
1258 mt_set_gpio_dir(GPIO_CTP_EN_PIN, GPIO_DIR_OUT);
1259 mt_set_gpio_out(GPIO_CTP_EN_PIN, GPIO_OUT_ONE);
1260 msleep(100);
1261 */
1262 mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
1263 mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);
1264 mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);
1265 #endif
1266
1267 TPD_INFO("addr:0x%02x",i2c_client->addr);
1268
1269 if((i2c_smbus_read_i2c_block_data(i2c_client, FW_ID_ADDR, 1, &data))< 0)
1270 {
1271 #if 0
1272 for(i = 0; i < sizeof(i2c_addr)/ sizeof(i2c_addr[0]); i++)
1273 {
1274 i2c_client->addr = i2c_addr[i];
1275 TPD_INFO("addr:0x%02x",i2c_client->addr);
1276 if((i2c_smbus_read_i2c_block_data(i2c_client, 0x00, 1, &data))>= 0)
1277 {
1278 goto i2c_transfer_sucess;
1279 }
1280 }
1281 #endif
1282
1283 TPD_INFO("I2C transfer error, line: %d\n", __LINE__);
1284 return -1;
1285 }
1286 #if 0
1287 i2c_transfer_sucess:
1288 #endif
1289 tpd_load_status = 1;
1290
1291 touchdebug_kobj = kobject_create_and_add("Touch", NULL);
1292 if (touchdebug_kobj == NULL)
1293 TPD_INFO("%s: subsystem_register failed\n", __func__);
1294
1295 if (sysfs_create_group(touchdebug_kobj, &attr_group))
1296 TPD_INFO("%s:sysfs_create_group failed\n", __func__);
1297
1298 touchdebug_kobj_info = kobject_create_and_add("dev-info_touch", NULL);
1299 if (touchdebug_kobj_info == NULL)
1300 TPD_INFO("%s: subsystem_register failed\n", __func__);
1301
1302 if (sysfs_create_group(touchdebug_kobj_info, &attr_group_info))
1303 TPD_INFO("%s:sysfs_create_group failed\n", __func__);
1304
1305 sensitivity_work = kzalloc(sizeof(typeof(*sensitivity_work)), GFP_KERNEL);
1306 if (!sensitivity_work) {
1307 TPD_INFO("create work queue error, line: %d\n", __LINE__);
1308 return -1;
1309 }
1310 INIT_WORK(sensitivity_work, sensitivity_set_func);
1311
1312 sensitivity_wq = create_singlethread_workqueue("sensitivity_wq");
1313 if (!sensitivity_wq) {
1314 kfree(sensitivity_work);
1315 TPD_INFO("create thread error, line: %d\n", __LINE__);
1316 return -1;
1317 }
1318 setup_timer(&sensitivity_write_timer, sensitivity_func, 0);
1319
1320 thread = kthread_run(touch_event_handler, 0, TPD_DEVICE);
1321 if (IS_ERR(thread))
1322 {
1323 retval = PTR_ERR(thread);
1324 TPD_DMESG(TPD_DEVICE " failed to create kernel thread: %d\n", retval);
1325 }
1326
1327 //mt_eint_set_sens(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_SENSITIVE);
1328
1329 mt_eint_set_hw_debounce(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_CN);
1330 mt_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_TYPE, tpd_eint_interrupt_handler, 1);
1331 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
1332 msleep(50);
1333
1334 ts = kzalloc (sizeof(struct fts_info), GFP_KERNEL);
1335 if (!ts)
1336 return err;
1337
1338 ts->client = client;
1339 i2c_set_clientdata(client, ts);
1340
1341 err = fts_i2cdev_init(ts);
1342 if(err<0)
1343 TPD_DMESG("[i2c-8][Fail]\n");
1344 else
1345 TPD_DMESG("[i2c-8][Success]\n");
1346
1347 #ifdef SYSFS_DEBUG
1348 ft5x0x_create_sysfs(i2c_client);
1349 #endif
1350
1351 #ifdef FTS_APK_DEBUG
1352 ft5x0x_create_apk_debug_channel(i2c_client);
1353 #endif
1354 #ifdef FTS_AUTO_UPGRADE
1355 fts_ctpm_auto_upgrade(i2c_client);
1356 #endif
1357 TPD_DMESG("Touch Panel Device Probe %s\n", (retval < TPD_OK) ? "FAIL" : "PASS");
1358 TPD_DMESG("[i2c-8] i2c_client->timing:%d\n", i2c_client->timing);
1359 return 0;
1360 }
1361
1362 static int tpd_remove(struct i2c_client *client)
1363 {
1364 struct fts_info *ts = i2c_get_clientdata(client);
1365 #ifdef FTS_APK_DEBUG
1366 ft5x0x_release_apk_debug_channel();
1367 #endif
1368 #ifdef SYSFS_DEBUG
1369 ft5x0x_release_sysfs(client);
1370 #endif
1371 TPD_INFO("TPD removed\n");
1372
1373 del_timer_sync(&sensitivity_write_timer);
1374 cancel_work_sync(sensitivity_work);
1375 destroy_workqueue(sensitivity_wq);
1376 kfree(sensitivity_work);
1377
1378 fts_i2cdev_exit();
1379 kfree(ts);
1380
1381 return 0;
1382 }
1383
1384
1385 static int tpd_local_init(void)
1386 {
1387 TPD_DMESG("Focaltech FT5x06 I2C Touchscreen Driver (Built %s @ %s)\n", __DATE__, __TIME__);
1388
1389 gpDMABuf_va = (u8 *)dma_alloc_coherent(NULL, 64, &gpDMABuf_pa, GFP_KERNEL);
1390 if(!gpDMABuf_va){
1391 DBG("[Error] Allocate DMA I2C Buffer failed!\n");
1392 }
1393
1394 boot_mode = get_boot_mode();
1395 if(boot_mode==3) boot_mode = NORMAL_BOOT;
1396 #ifdef TPD_HAVE_BUTTON
1397 tpd_button_setting(TPD_KEY_COUNT, tpd_keys_local, tpd_keys_dim_local);// initialize tpd button data
1398 #endif
1399
1400 if(i2c_add_driver(&tpd_i2c_driver)!=0)
1401 {
1402 TPD_DMESG("unable to add i2c driver.\n");
1403 return -1;
1404 }
1405
1406 #if (defined(TPD_HAVE_CALIBRATION) && !defined(TPD_CUSTOM_CALIBRATION))
1407
1408 if (FACTORY_BOOT == get_boot_mode())
1409 {
1410 TPD_INFO("Factory mode is detected! \n");
1411 memcpy(tpd_calmat_driver, tpd_def_calmat_local_factory, sizeof(tpd_calmat_driver));
1412 }
1413 else
1414 {
1415 TPD_INFO("Normal mode is detected! \n");
1416 memcpy(tpd_calmat_driver, tpd_def_calmat_local_normal, sizeof(tpd_calmat_driver));
1417 }
1418 #endif
1419
1420
1421 input_set_abs_params(tpd->dev, ABS_MT_TRACKING_ID, 0, FINGER_NUM_MAX-1, 0, 0);//for linux3.8
1422
1423 TPD_DMESG("end %s, %d\n", __FUNCTION__, __LINE__);
1424 tpd_type_cap = 1;
1425
1426 return 0;
1427 }
1428
1429 #ifdef TPD_GPT_TIMER_RESUME
1430 // GPTimer
1431 void ctp_thread_wakeup(UINT16 i)
1432 {
1433 //printk("**** ctp_thread_wakeup****\n" );
1434 GPT_NUM gpt_num = GPT6;
1435 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
1436 GPT_Stop(gpt_num);
1437 }
1438
1439 void CTP_Thread_XGPTConfig(void)
1440 {
1441 GPT_CONFIG config;
1442 GPT_NUM gpt_num = GPT6;
1443 GPT_CLK_SRC clkSrc = GPT_CLK_SRC_RTC;
1444 //GPT_CLK_DIV clkDiv = GPT_CLK_DIV_128;
1445 GPT_CLK_DIV clkDiv = GPT_CLK_DIV_64;
1446
1447 //printk("***CTP_Thread_XGPTConfig***\n" );
1448
1449 GPT_Init (gpt_num, ctp_thread_wakeup);
1450 config.num = gpt_num;
1451 config.mode = GPT_REPEAT;
1452 config.clkSrc = clkSrc;
1453 config.clkDiv = clkDiv;
1454 //config.u4Timeout = 10*128;
1455 config.u4CompareL = 256; // 10s : 512*64=32768
1456 config.u4CompareH = 0;
1457 config.bIrqEnable = TRUE;
1458
1459 if (GPT_Config(config) == FALSE )
1460 return;
1461
1462 GPT_Start(gpt_num);
1463
1464 return ;
1465 }
1466 #endif
1467
1468 static void tpd_resume(struct early_suspend *h)
1469 {
1470 /* int retval = TPD_OK; */
1471 char data = 0;
1472 int ret = 0;/* retry_num = 0, */
1473
1474 TPD_INFO("TPD wake up\n");
1475
1476 if (!EnableWakeUp) {
1477 #ifdef TPD_GPT_TIMER_RESUME
1478 mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
1479
1480 mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
1481 mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);
1482 mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);
1483
1484 msleep(10);
1485 #ifdef TPD_POWER_SOURCE_CUSTOM
1486 hwPowerDown(TPD_POWER_SOURCE_CUSTOM, "TP");
1487 #else
1488 hwPowerDown(TPD_POWER_SOURCE, "TP");
1489 #endif
1490 #ifdef TPD_POWER_SOURCE_1800
1491 hwPowerDown(TPD_POWER_SOURCE_1800, "TP");
1492 #endif
1493 #ifdef TPD_POWER_SOURCE_CUSTOM
1494 hwPowerOn(TPD_POWER_SOURCE_CUSTOM, VOL_2800, "TP");
1495 #else
1496 #ifndef TPD_LDO_VOL
1497 hwPowerOn(TPD_POWER_SOURCE, VOL_2800, "TP");
1498 #else
1499 hwPowerOn(TPD_POWER_SOURCE, TPD_LDO_VOL, "TP");
1500 #endif //TPD_LDO_VOL
1501 #endif
1502 #ifdef TPD_POWER_SOURCE_1800
1503 hwPowerOn(TPD_POWER_SOURCE_1800, VOL_1800, "TP");
1504 #endif
1505 // Run GPT timer
1506 CTP_Thread_XGPTConfig();
1507 #else
1508 #ifdef TPD_CLOSE_POWER_IN_SLEEP
1509 mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);
1510 mdelay(1);
1511 #ifdef TPD_POWER_SOURCE_CUSTOM
1512 hwPowerOn(TPD_POWER_SOURCE_CUSTOM, VOL_2800, "TP");
1513 #else
1514 #ifndef TPD_LDO_VOL
1515 hwPowerOn(TPD_POWER_SOURCE, VOL_2800, "TP");
1516 #else
1517 hwPowerOn(TPD_POWER_SOURCE, TPD_LDO_VOL, "TP");
1518 #endif //TPD_LDO_VOL
1519 #endif
1520 #ifdef TPD_POWER_SOURCE_1800
1521 hwPowerOn(TPD_POWER_SOURCE_1800, VOL_1800, "TP");
1522 #endif
1523 msleep(300);
1524 mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);
1525 msleep(2);
1526 mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);
1527 msleep(200);
1528 #if 0
1529 mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
1530 mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);
1531 mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);
1532
1533 do{
1534 msleep(10);
1535 #ifdef TPD_POWER_SOURCE_CUSTOM
1536 hwPowerOn(TPD_POWER_SOURCE_CUSTOM, VOL_2800, "TP");
1537 #else
1538 hwPowerOn(TPD_POWER_SOURCE, VOL_2800, "TP");
1539 #endif
1540 #ifdef TPD_POWER_SOURCE_1800
1541 hwPowerOn(TPD_POWER_SOURCE_1800, VOL_1800, "TP");
1542 #endif
1543 msleep(300);
1544
1545 if((ret = i2c_smbus_read_i2c_block_data(i2c_client, FW_ID_ADDR, 1, &data))< 0)
1546 {
1547 TPD_DEBUG("i2c transf error before reset :ret=%d,retry_num == %d\n",ret,retry_num);
1548
1549 #ifdef TPD_POWER_SOURCE_CUSTOM
1550 hwPowerDown(TPD_POWER_SOURCE_CUSTOM, "TP");
1551 #else
1552 hwPowerDown(TPD_POWER_SOURCE, "TP");
1553 #endif
1554 #ifdef TPD_POWER_SOURCE_1800
1555 hwPowerDown(TPD_POWER_SOURCE_1800, "TP");
1556 #endif
1557 }
1558 else
1559 {
1560 TPD_DEBUG("i2c transfer success after reset :ret=%d,retry_num == %d\n",ret,retry_num);
1561 break;
1562 }
1563 retry_num++;
1564 }while(retry_num < 10);
1565
1566 if((ret = i2c_smbus_read_i2c_block_data(i2c_client, FW_ID_ADDR, 1, &data))< 0)
1567 {
1568 TPD_DEBUG("i2c transf error before reset :ret=%d,retry_num == %d\n",ret,retry_num);
1569
1570 mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
1571 mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);
1572 mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);
1573 msleep(100);
1574
1575 mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
1576 mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);
1577 mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);
1578 msleep(50);
1579 mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
1580 mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);
1581 mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);
1582 msleep(400);
1583
1584 if((ret = i2c_smbus_read_i2c_block_data(i2c_client, FW_ID_ADDR, 1, &data))< 0)
1585 {
1586 TPD_DEBUG("i2c transf error after reset :ret = %d,retry_num == %d\n",ret,retry_num);
1587 }
1588 else
1589 {
1590 TPD_DEBUG("i2c transfer success after reset :ret = %d,retry_num == %d\n",ret,retry_num);
1591 }
1592 }
1593 TPD_DEBUG("retry_num == %d\n",retry_num);
1594 #endif
1595 #else
1596 mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
1597 mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);
1598 mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);
1599 msleep(100);
1600
1601 mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
1602 mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);
1603 mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);
1604 msleep(50);
1605 mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
1606 mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);
1607 mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);
1608 msleep(400);
1609 #endif
1610 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
1611 #endif
1612 } else {
1613 data = 0;
1614 ret = ft5x0x_write_reg(i2c_client, 0xab, data);
1615 if(ret < 0)
1616 TPD_INFO("Resume can not write 0xAB\n");
1617 }
1618
1619 mod_timer(&sensitivity_write_timer,
1620 jiffies + msecs_to_jiffies(TOUCH_RESUME_INTERVAL));
1621
1622 /* return retval; */
1623 }
1624
1625 static void tpd_suspend(struct early_suspend *h)
1626 {
1627 /* int retval = TPD_OK; */
1628 static char data = 0x3;
1629 int ret;
1630
1631 TPD_INFO("TPD enter sleep\n");
1632
1633 if (!EnableWakeUp) {
1634 mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
1635 #ifdef TPD_CLOSE_POWER_IN_SLEEP
1636 mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ZERO);
1637 mdelay(1);
1638 #ifdef TPD_POWER_SOURCE_CUSTOM
1639 hwPowerDown(TPD_POWER_SOURCE_CUSTOM, "TP");
1640 #else
1641 hwPowerDown(TPD_POWER_SOURCE, "TP");
1642 #endif
1643 #ifdef TPD_POWER_SOURCE_1800
1644 hwPowerDown(TPD_POWER_SOURCE_1800, "TP");
1645 #endif
1646 #else
1647 ft5x0x_write_reg(i2c_client, 0xA5, data); //TP enter sleep mode
1648 /*
1649 mt_set_gpio_mode(GPIO_CTP_EN_PIN, GPIO_CTP_EN_PIN_M_GPIO);
1650 mt_set_gpio_dir(GPIO_CTP_EN_PIN, GPIO_DIR_OUT);
1651 mt_set_gpio_out(GPIO_CTP_EN_PIN, GPIO_OUT_ZERO);
1652 */
1653 #endif
1654 } else {
1655 data = 1;
1656 ret = ft5x0x_write_reg(i2c_client, 0xab, data);
1657 if(ret < 0)
1658 TPD_INFO("Suspend can not write 0xAB\n");
1659 }
1660 /* return retval; */
1661 }
1662
1663
1664 static struct tpd_driver_t tpd_device_driver = {
1665 .tpd_device_name = "FT5x06",
1666 .tpd_local_init = tpd_local_init,
1667 .suspend = tpd_suspend,
1668 .resume = tpd_resume,
1669 #ifdef TPD_HAVE_BUTTON
1670 .tpd_have_button = 1,
1671 #else
1672 .tpd_have_button = 0,
1673 #endif
1674 };
1675
1676 /* called when loaded into kernel */
1677 static int __init tpd_driver_init(void) {
1678 TPD_DEBUG("MediaTek FT5x06 touch panel driver init\n");
1679 i2c_register_board_info(TPD_I2C_NUMBER, &i2c_tpd, 1);
1680 if(tpd_driver_add(&tpd_device_driver) < 0)
1681 TPD_DMESG("add FT5x06 driver failed\n");
1682
1683 return 0;
1684 }
1685
1686 /* should never be called */
1687 static void __exit tpd_driver_exit(void) {
1688 TPD_DMESG("MediaTek FT5x06 touch panel driver exit\n");
1689 //input_unregister_device(tpd->dev);
1690 tpd_driver_remove(&tpd_device_driver);
1691 }
1692
1693 module_init(tpd_driver_init);
1694 module_exit(tpd_driver_exit);
kernel source for telekom puls (alcatel/mediatek)