2 * drivers/input/touchscreen/ft5x0x_ts.c
4 * FocalTech ft5x0x TouchScreen driver.
6 * Copyright (c) 2010 Focal tech Ltd.
8 * This software is licensed under the terms of the GNU General Public
9 * License version 2, as published by the Free Software Foundation, and
10 * may be copied, distributed, and modified under those terms.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
18 * note: only support mulititouch Wenfs 2010-10-01
21 #include <linux/input.h>
22 #include <linux/input/mt.h>
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/interrupt.h>
26 #include <linux/kernel.h>
27 #include <linux/platform_device.h>
28 #include <linux/spi/spi.h>
29 #include <linux/slab.h>
30 #include <linux/fcntl.h>
31 #include <linux/delay.h>
32 #include <linux/device.h>
33 #include <linux/timer.h>
34 #include <linux/jiffies.h>
35 #include <linux/miscdevice.h>
36 #include <linux/types.h>
38 #include <linux/delay.h>
39 #include <linux/ioport.h>
40 #include <linux/input-polldev.h>
41 #include <linux/i2c.h>
42 #include <linux/workqueue.h>
43 #ifdef CONFIG_ANDROID_POWER
44 #include <linux/android_power.h>
46 #include <mach/hardware.h>
47 #include <asm/setup.h>
48 #include <asm/mach-types.h>
49 #include <asm/mach/arch.h>
50 #include <asm/mach/map.h>
51 #include <asm/mach/flash.h>
52 #include <asm/hardware/gic.h>
53 #include <mach/iomux.h>
54 #include <mach/gpio.h>
55 #include <mach/irqs.h>
56 //#include <mach/rk29_iomap.h>
57 #include <mach/board.h>
58 //#include <mach/rk29_nand.h>
59 //#include <mach/rk29_camera.h> /* ddl@rock-chips.com : camera support */
60 #include <media/soc_camera.h> /* ddl@rock-chips.com : camera support */
61 //#include <mach/vpu_mem.h>
62 #include <mach/sram.h>
63 #include <linux/earlysuspend.h>
64 #ifdef CONFIG_RK_CONFIG
65 #include <mach/config.h>
66 #include <linux/regulator/rk29-pwm-regulator.h>
68 static struct early_suspend ft5306_power;
73 #define CONFIG_FT5X0X_MULTITOUCH 1
75 #define FT5306_IIC_SPEED 50*1000 //300*1000
76 #define FT5X0X_REG_THRES 0x80 /* Thresshold, the threshold be low, the sensitivy will be high */
77 #define FT5X0X_REG_REPORT_RATE 0x88 /* **************report rate, in unit of 10Hz **************/
78 #define FT5X0X_REG_PMODE 0xA5 /* Power Consume Mode 0 -- active, 1 -- monitor, 3 -- sleep */
79 #define FT5X0X_REG_FIRMID 0xA6 /* ***************firmware version **********************/
80 #define FT5X0X_REG_NOISE_MODE 0xb2 /* to enable or disable power noise, 1 -- enable, 0 -- disable */
81 #define SCREEN_MAX_X 800
82 #define SCREEN_MAX_Y 480
84 #define FT5X0X_NAME "ft5x0x_ts"//"synaptics_i2c_rmi"//"synaptics-rmi-ts"//
85 #define TOUCH_MAJOR_MAX 200
86 #define WIDTH_MAJOR_MAX 200
88 #define PMODE_ACTIVE 0x00
89 #define PMODE_MONITOR 0x01
90 #define PMODE_STANDBY 0x02
91 #define PMODE_HIBERNATE 0x03
93 #define TP_MODULE_NAME FT5X0X_NAME
94 #ifdef CONFIG_RK_CONFIG
97 #if defined(RK2928_PHONEPAD_DEFAULT_CONFIG)
102 DEF_IRQ = 0x002003c7,
103 DEF_RST = 0X000003d5,
110 static int en = DEF_EN;
111 module_param(en, int, 0644);
113 static int irq = DEF_IRQ;
114 module_param(irq, int, 0644);
115 static int rst =DEF_RST;
116 module_param(rst, int, 0644);
118 static int i2c = DEF_I2C; // i2c channel
119 module_param(i2c, int, 0644);
120 static int addr = DEF_ADDR; // i2c addr
121 module_param(addr, int, 0644);
122 static int x_max = DEF_X_MAX;
123 module_param(x_max, int, 0644);
124 static int y_max = DEF_Y_MAX;
125 module_param(y_max, int, 0644);
126 static int tp_ldo = DEF_TP_LDO;
127 module_param(tp_ldo, int, 0644);
129 static int tp_hw_init(void)
133 pmic_ldo_set(tp_ldo, 0);
135 ret = gpio_request(get_port_config(irq).gpio, "tp_irq");
137 printk("%s: gpio_request(irq gpio) failed\n", __func__);
141 ret = port_output_init(rst, 1, "tp_rst");
143 printk("%s: port(rst) output init faild\n", __func__);
147 pmic_ldo_set(tp_ldo, 1);
152 static int tp_hw_exit(void)
156 static int tp_hw_suspend(void)
158 port_output_off(rst);
161 static int tp_hw_resume(void)
172 s16 cur_touch_id[MAX_POINT];
173 s16 last_touch_id[MAX_POINT];
185 struct ft5x0x_ts_data {
186 struct i2c_client *client;
187 struct input_dev *input_dev;
189 struct ts_event event;
190 struct work_struct pen_event_work;
191 struct workqueue_struct *ts_workqueue;
193 static struct i2c_client *this_client;
195 /***********************************************************************/
197 #define FTS_PACKET_LENGTH 128
202 //#include "ft5406_app.i"
218 /***********************************************************************/
220 /***********************************************************************
222 callback: send data to ctpm by i2c interface;
224 txdata[in]: data buffer which is used to send data;
225 length[in]: the length of the data buffer;
229 ************************************************************************/
230 static int fts_i2c_txdata(u8 *txdata, int length)
236 msg.addr = this_client->addr;
240 msg.scl_rate = FT5306_IIC_SPEED;
242 ret = i2c_transfer(this_client->adapter, &msg, 1);
244 pr_err("%s i2c write error: %d\n", __func__, ret);
249 /***********************************************************************
251 callback: write data to ctpm by i2c interface;
253 buffer[in]: data buffer;
254 length[in]: the length of the data buffer;
258 ************************************************************************/
259 static bool i2c_write_interface(u8* pbt_buf, int dw_lenth)
262 ret=i2c_master_send(this_client, pbt_buf, dw_lenth);
265 printk("[TSP]i2c_write_interface error line = %d, ret = %d\n", __LINE__, ret);
272 /***********************************************************************
274 callback: read register value ftom ctpm by i2c interface;
276 reg_name[in]: the register which you want to write;
277 tx_buf[in]: buffer which is contained of the writing value;
281 ************************************************************************/
282 static bool fts_register_write(u8 reg_name, u8* tx_buf)
284 u8 write_cmd[2] = {0};
286 write_cmd[0] = reg_name;
287 write_cmd[1] = *tx_buf;
289 /*call the write callback function*/
290 return i2c_write_interface(write_cmd, 2);
293 /***********************************************************************
295 callback: send a command to ctpm.
297 btcmd[in]: command code;
298 btPara1[in]: parameter 1;
299 btPara2[in]: parameter 2;
300 btPara3[in]: parameter 3;
301 num[in]: the valid input parameter numbers,
302 if only command code needed and no
303 parameters followed,then the num is 1;
307 ************************************************************************/
308 static bool cmd_write(u8 btcmd,u8 btPara1,u8 btPara2,u8 btPara3,u8 num)
310 u8 write_cmd[4] = {0};
312 write_cmd[0] = btcmd;
313 write_cmd[1] = btPara1;
314 write_cmd[2] = btPara2;
315 write_cmd[3] = btPara3;
316 return i2c_write_interface(write_cmd, num);
319 /***********************************************************************
321 callback: read data from ctpm by i2c interface;
323 buffer[in]: data buffer;
324 length[in]: the length of the data buffer;
328 ************************************************************************/
329 static bool i2c_read_interface(u8* pbt_buf, int dw_lenth)
333 ret=i2c_master_recv(this_client, pbt_buf, dw_lenth);
337 printk("[TSP]i2c_read_interface error\n");
345 /***********************************************************************
347 callback: read a byte data from ctpm;
349 buffer[in]: read buffer;
350 length[in]: the size of read data;
354 ************************************************************************/
355 static bool byte_read(u8* buffer, int length)
357 return i2c_read_interface(buffer, length);
360 /***********************************************************************
362 callback: write a byte data to ctpm;
364 buffer[in]: write buffer;
365 length[in]: the size of write data;
369 ************************************************************************/
370 static bool byte_write(u8* buffer, int length)
373 return i2c_write_interface(buffer, length);
376 /***********************************************************************
378 callback: read register value ftom ctpm by i2c interface;
380 reg_name[in]: the register which you want to read;
381 rx_buf[in]: data buffer which is used to store register value;
382 rx_length[in]: the length of the data buffer;
386 ************************************************************************/
387 static bool fts_register_read(u8 reg_name, u8* rx_buf, int rx_length)
392 read_cmd[0] = reg_name;
395 /*send register addr*/
396 if(!i2c_write_interface(&read_cmd[0], cmd_len))
401 /*call the read callback function to get the register value*/
402 if(!i2c_read_interface(rx_buf, rx_length))
411 /***********************************************************************
413 callback: burn the FW to ctpm.
415 pbt_buf[in]: point to Head+FW ;
416 dw_lenth[in]: the length of the FW + 6(the Head length);
419 ERR_MODE: fail to switch to UPDATE mode;
420 ERR_READID: read id fail;
421 ERR_ERASE: erase chip fail;
422 ERR_STATUS: status error;
424 ************************************************************************/
425 E_UPGRADE_ERR_TYPE fts_ctpm_fw_upgrade(u8* pbt_buf, int dw_lenth)
427 u8 cmd,reg_val[2] = {0};
429 u8 packet_buf[FTS_PACKET_LENGTH + 6];
430 u8 auc_i2c_write_buf[10];
433 int j,temp,lenght,i_ret,packet_number, i = 0;
434 int i_is_new_protocol = 0;
437 /******write 0xaa to register 0xfc******/
439 fts_register_write(0xfc,&cmd);
442 /******write 0x55 to register 0xfc******/
444 fts_register_write(0xfc,&cmd);
445 printk("[TSP] Step 1: Reset CTPM test\n");
450 /*******Step 2:Enter upgrade mode ****/
451 printk("\n[TSP] Step 2:enter new update mode\n");
452 auc_i2c_write_buf[0] = 0x55;
453 auc_i2c_write_buf[1] = 0xaa;
457 i_ret = fts_i2c_txdata(auc_i2c_write_buf, 2);
459 }while(i_ret <= 0 && i < 10 );
463 i_is_new_protocol = 1;
466 /********Step 3:check READ-ID********/
467 cmd_write(0x90,0x00,0x00,0x00,4);
468 byte_read(reg_val,2);
469 if (reg_val[0] == 0x79 && reg_val[1] == 0x3)
471 printk("[TSP] Step 3: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
475 printk("[TSP] Step 3: error CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
477 //i_is_new_protocol = 1;
481 /*********Step 4:erase app**********/
482 if (i_is_new_protocol)
484 cmd_write(0x61,0x00,0x00,0x00,1);
488 cmd_write(0x60,0x00,0x00,0x00,1);
491 printk("[TSP] Step 4: erase. \n");
495 /*Step 5:write firmware(FW) to ctpm flash*/
497 printk("[TSP] Step 5: start upgrade. \n");
498 dw_lenth = dw_lenth - 8;
499 packet_number = (dw_lenth) / FTS_PACKET_LENGTH;
500 packet_buf[0] = 0xbf;
501 packet_buf[1] = 0x00;
502 for (j=0;j<packet_number;j++)
504 temp = j * FTS_PACKET_LENGTH;
505 packet_buf[2] = (u8)(temp>>8);
506 packet_buf[3] = (u8)temp;
507 lenght = FTS_PACKET_LENGTH;
508 packet_buf[4] = (u8)(lenght>>8);
509 packet_buf[5] = (u8)lenght;
511 for (i=0;i<FTS_PACKET_LENGTH;i++)
513 packet_buf[6+i] = pbt_buf[j*FTS_PACKET_LENGTH + i];
514 bt_ecc ^= packet_buf[6+i];
517 byte_write(&packet_buf[0],FTS_PACKET_LENGTH + 6);
518 mdelay(FTS_PACKET_LENGTH/6 + 1);
519 if ((j * FTS_PACKET_LENGTH % 1024) == 0)
521 printk("[TSP] upgrade the 0x%x th byte.\n", ((unsigned int)j) * FTS_PACKET_LENGTH);
525 if ((dw_lenth) % FTS_PACKET_LENGTH > 0)
527 temp = packet_number * FTS_PACKET_LENGTH;
528 packet_buf[2] = (u8)(temp>>8);
529 packet_buf[3] = (u8)temp;
531 temp = (dw_lenth) % FTS_PACKET_LENGTH;
532 packet_buf[4] = (u8)(temp>>8);
533 packet_buf[5] = (u8)temp;
537 packet_buf[6+i] = pbt_buf[ packet_number*FTS_PACKET_LENGTH + i];
538 bt_ecc ^= packet_buf[6+i];
541 byte_write(&packet_buf[0],temp+6);
545 /***********send the last six byte**********/
546 for (i = 0; i<6; i++)
549 packet_buf[2] = (u8)(temp>>8);
550 packet_buf[3] = (u8)temp;
552 packet_buf[4] = (u8)(temp>>8);
553 packet_buf[5] = (u8)temp;
554 packet_buf[6] = pbt_buf[ dw_lenth + i];
555 bt_ecc ^= packet_buf[6];
557 byte_write(&packet_buf[0],7);
561 /********send the opration head************/
562 cmd_write(0xcc,0x00,0x00,0x00,1);
563 byte_read(reg_val,1);
564 printk("[TSP] Step 6: ecc read 0x%x, new firmware 0x%x. \n", reg_val[0], bt_ecc);
565 if(reg_val[0] != bt_ecc)
570 /*******Step 7: reset the new FW**********/
571 cmd_write(0x07,0x00,0x00,0x00,1);
573 fts_register_read(0xfc, buffer, 1);
577 fts_register_write(0xfc, &cmd);
578 mdelay(2500);//2500ms
581 fts_register_read(0xfc, buffer, 1);
583 }while (buffer[0] != 1);
589 /***********************************************************************/
591 int fts_ctpm_fw_upgrade_with_i_file(void)
597 i_ret = fts_ctpm_fw_upgrade(pbt_buf,sizeof(CTPM_FW));
602 /***********************************************************************/
604 unsigned char fts_ctpm_get_upg_ver(void)
608 ui_sz = sizeof(CTPM_FW);
611 return CTPM_FW[ui_sz - 2];
618 static int ft5306_init_touchid(s16 touch_buf[], unsigned len,s16 init_val)
622 touch_buf[i] = init_val;
627 /*read the it7260 register ,used i2c bus*/
628 static int ft5306_read_regs(struct i2c_client *client, u8 reg, u8 buf[], unsigned len)
631 ret = i2c_master_reg8_recv(client, reg, buf, len, FT5306_IIC_SPEED);
636 /* set the it7260 registe,used i2c bus*/
637 static int ft5306_set_regs(struct i2c_client *client, u8 reg, u8 const buf[], unsigned short len)
640 ret = i2c_master_reg8_send(client, reg, buf, (int)len, FT5306_IIC_SPEED);
644 static void ft5306_queue_work(struct work_struct *work)
646 struct ft5x0x_ts_data *data = container_of(work, struct ft5x0x_ts_data, pen_event_work);
647 struct tp_event event;
650 int ret,i,offset,points;
652 #if CONFIG_FT5X0X_MULTITOUCH
653 ret = ft5306_read_regs(data->client,start_reg, buf, 6*MAX_POINT+1);
655 ret = ft5306_read_regs(data->client,start_reg, buf, 7);
658 dev_err(&data->client->dev, "ft5306_read_regs fail:%d!\n",ret);
659 enable_irq(data->irq);
663 points = buf[2] & 0x07;
664 memset(&event, 0, sizeof(struct tp_event));
665 #if CONFIG_FT5X0X_MULTITOUCH
666 ft5306_init_touchid(data->event.cur_touch_id,MAX_POINT,-1);
667 // dev_info(&data->client->dev,
668 // "ft5306 multiple report points = %d :\n",points);
669 for(i=0;i<points;i++){
671 event.x = (((s16)(buf[offset+0] & 0x0F))<<8) | ((s16)buf[offset+1]);
672 event.y = (((s16)(buf[offset+2] & 0x0F))<<8) | ((s16)buf[offset+3]);
673 event.id = (s16)(buf[offset+2] & 0xF0)>>4;
674 event.flag = ((buf[offset+0] & 0xc0) >> 6);
675 event.pressure = 200;
676 if(event.x<=SCREEN_MAX_X && event.y<=SCREEN_MAX_Y && event.id < MAX_POINT){
677 // dev_info(&data->client->dev,
678 // "ft5306 multiple report event[%d]:x = %d,y = %d,last_id = %d,cur_id = %d,flag = %d,pressure = %d\n",
679 // i,event.x,event.y,data->event.last_touch_id[event.id],event.id,event.flag,event.pressure);
680 input_mt_slot(data->input_dev, event.id);
681 data->event.cur_touch_id[event.id] = event.id;
682 if(data->event.last_touch_id[event.id] != event.id){
683 input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event.id);
684 data->event.last_touch_id[event.id] = event.id;
686 input_report_abs(data->input_dev, ABS_MT_POSITION_X, event.x);
687 input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event.y);
688 // dev_info(&data->client->dev,"new last_id=%d,cur_id = %d\n",data->event.last_touch_id[event.id],
689 // data->event.cur_touch_id[event.id]);
692 for(i=0;i<MAX_POINT;i++){
693 if(data->event.last_touch_id[i] != data->event.cur_touch_id[i]){
694 // dev_info(&data->client->dev,"release id=%d: last_id=%d,cur_id = %d\n",i,data->event.last_touch_id[i],
695 // data->event.cur_touch_id[i]);
696 data->event.last_touch_id[i] = data->event.cur_touch_id[i];
697 input_mt_slot(data->input_dev, i);
698 input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, data->event.cur_touch_id[i]);
703 input_report_abs(data->input_dev, ABS_PRESSURE, 0);
704 input_report_key(data->input_dev, BTN_TOUCH, 0);
705 input_sync(data->input_dev);
706 enable_irq(data->irq);
707 // dev_info(&data->client->dev, "ft5306 touch release\n");
710 event.x = (s16)(buf[3] & 0x0F)<<8 | (s16)buf[4];
711 event.y = (s16)(buf[5] & 0x0F)<<8 | (s16)buf[6];
713 input_report_abs(data->input_dev, ABS_X, event.x);
714 input_report_abs(data->input_dev, ABS_Y, event.y);
715 input_report_abs(data->input_dev, ABS_PRESSURE, event.pressure);
716 input_report_key(data->input_dev, BTN_TOUCH, 1);
717 //dev_info(&data->client->dev, "ft5306 single report event:x = %d,y = %d\n",event.x,event.y);
719 input_sync(data->input_dev);
720 enable_irq(data->irq);
724 static irqreturn_t ft5306_interrupt(int irq, void *dev_id)
726 struct ft5x0x_ts_data *ft5x0x_ts = dev_id;
728 //printk("ft5306_interrupt\n");
729 disable_irq_nosync(ft5x0x_ts->irq);
730 if (!work_pending(&ft5x0x_ts->pen_event_work))
731 queue_work(ft5x0x_ts->ts_workqueue, &ft5x0x_ts->pen_event_work);
735 static int ft5306_suspend(struct i2c_client *client, pm_message_t mesg)
737 struct ft5x0x_ts_data *ft5x0x_ts = i2c_get_clientdata(client);
738 struct ft5306_platform_data *pdata = client->dev.platform_data;
740 #ifdef CONFIG_RK_CONFIG
743 if (pdata->platform_sleep)
744 pdata->platform_sleep();
746 disable_irq(ft5x0x_ts->irq);
751 static int ft5306_resume(struct i2c_client *client)
753 struct ft5x0x_ts_data *ft5x0x_ts = i2c_get_clientdata(client);
754 struct ft5306_platform_data *pdata = client->dev.platform_data;
756 enable_irq(ft5x0x_ts->irq);
757 #ifdef CONFIG_RK_CONFIG
760 if (pdata->platform_wakeup)
761 pdata->platform_wakeup();
766 static void ft5306_suspend_early(struct early_suspend *h)
768 ft5306_suspend(this_client,PMSG_SUSPEND);
771 static void ft5306_resume_early(struct early_suspend *h)
773 ft5306_resume(this_client);
775 static int __devexit ft5306_remove(struct i2c_client *client)
777 struct ft5x0x_ts_data *ft5x0x_ts = i2c_get_clientdata(client);
779 free_irq(ft5x0x_ts->irq, ft5x0x_ts);
780 input_unregister_device(ft5x0x_ts->input_dev);
782 cancel_work_sync(&ft5x0x_ts->pen_event_work);
783 destroy_workqueue(ft5x0x_ts->ts_workqueue);
784 i2c_set_clientdata(client, NULL);
785 unregister_early_suspend(&ft5306_power);
790 static int ft5306_probe(struct i2c_client *client ,const struct i2c_device_id *id)
792 struct ft5x0x_ts_data *ft5x0x_ts;
793 struct input_dev *input_dev;
794 struct ft5306_platform_data *pdata = client->dev.platform_data;
800 const u8 buf_test[1] = {0};
801 unsigned char reg_value;
802 unsigned char reg_version;
804 #ifdef CONFIG_RK_CONFIG
805 struct port_config irq_cfg = get_port_config(irq);
808 dev_info(&client->dev, "ft5x0x_ts_probe!\n");
810 dev_err(&client->dev, "platform data is required!\n");
813 if (pdata->init_platform_hw)
814 pdata->init_platform_hw();
816 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)){
817 dev_err(&client->dev, "Must have I2C_FUNC_I2C.\n");
821 ft5x0x_ts = kzalloc(sizeof(*ft5x0x_ts), GFP_KERNEL);
828 ret=ft5306_set_regs(client,FT5X0X_REG_PMODE, buf_test,1);
834 printk("FT5306 I2C TEST ERROR!\n");
836 goto exit_i2c_test_fail;
839 err = ft5306_read_regs(client,FT5X0X_REG_PMODE,buf_r,1);
840 printk("read buf[FT5X0X_REG_PMODE] = %d\n", buf_r[0]);
843 input_dev = input_allocate_device();
846 printk("failed to allocate input device\n");
847 goto exit_input_dev_alloc_failed;
849 ft5x0x_ts->client = this_client = client;
850 #ifdef CONFIG_RK_CONFIG
851 ft5x0x_ts->irq = get_port_config(irq).gpio;
853 ft5x0x_ts->irq = pdata->irq_pin;
855 ft5x0x_ts->input_dev = input_dev;
857 set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
858 set_bit(EV_ABS, input_dev->evbit);
860 #if CONFIG_FT5X0X_MULTITOUCH
861 ft5306_init_touchid(ft5x0x_ts->event.cur_touch_id,MAX_POINT,-1);
862 ft5306_init_touchid(ft5x0x_ts->event.last_touch_id,MAX_POINT,-1);
863 input_mt_init_slots(input_dev, MAX_POINT);
864 #ifdef CONFIG_RK_CONFIG
865 input_set_abs_params(input_dev,ABS_MT_POSITION_X, 0, x_max, 0, 0);
866 input_set_abs_params(input_dev,ABS_MT_POSITION_Y, 0, y_max, 0, 0);
868 input_set_abs_params(input_dev,ABS_MT_POSITION_X, 0, SCREEN_MAX_X, 0, 0);
869 input_set_abs_params(input_dev,ABS_MT_POSITION_Y, 0, SCREEN_MAX_Y, 0, 0);
872 set_bit(ABS_X, input_dev->absbit);
873 set_bit(ABS_Y, input_dev->absbit);
874 set_bit(ABS_PRESSURE, input_dev->absbit);
875 set_bit(BTN_TOUCH, input_dev->keybit);
876 #ifdef CONFIG_RK_CONFIG
877 input_set_abs_params(input_dev, ABS_X, 0, x_max, 0, 0);
878 input_set_abs_params(input_dev, ABS_Y, 0, y_max, 0, 0);
880 input_set_abs_params(input_dev, ABS_X, 0, SCREEN_MAX_X, 0, 0);
881 input_set_abs_params(input_dev, ABS_Y, 0, SCREEN_MAX_Y, 0, 0);
883 input_set_abs_params(input_dev, ABS_PRESSURE, 0, PRESS_MAX, 0 , 0);
886 input_dev->name = FT5X0X_NAME;
887 input_dev->id.bustype = BUS_I2C;
889 err = input_register_device(input_dev);
891 printk("ft5x0x_ts_probe: failed to register input device: \n");
892 goto exit_input_register_device_failed;
895 if (!ft5x0x_ts->irq) {
897 dev_err(&ft5x0x_ts->client->dev, "no IRQ?\n");
898 goto exit_no_irq_fail;
900 ft5x0x_ts->irq = gpio_to_irq(ft5x0x_ts->irq);
903 //INIT_WORK(&ft5x0x_ts->pen_event_work, ft5306_ts_pen_irq_work);
904 INIT_WORK(&ft5x0x_ts->pen_event_work, ft5306_queue_work);
905 ft5x0x_ts->ts_workqueue = create_singlethread_workqueue("ft5x0x_ts");
906 if (!ft5x0x_ts->ts_workqueue) {
908 goto exit_create_singlethread;
911 /***wait CTP to bootup normally***/
914 fts_register_read(FT5X0X_REG_FIRMID, ®_version,1);
915 printk("[TSP] firmware version = 0x%2x\n", reg_version);
916 fts_register_read(FT5X0X_REG_REPORT_RATE, ®_value,1);
917 printk("[TSP]firmware report rate = %dHz\n", reg_value*10);
918 fts_register_read(FT5X0X_REG_THRES, ®_value,1);
919 printk("[TSP]firmware threshold = %d\n", reg_value * 4);
920 fts_register_read(FT5X0X_REG_NOISE_MODE, ®_value,1);
921 printk("[TSP]nosie mode = 0x%2x\n", reg_value);
924 if (fts_ctpm_get_upg_ver() != reg_version)
926 printk("[TSP] start upgrade new verison 0x%2x\n", fts_ctpm_get_upg_ver());
928 err = fts_ctpm_fw_upgrade_with_i_file();
931 printk("[TSP] ugrade successfuly.\n");
933 fts_register_read(FT5X0X_REG_FIRMID, ®_value,1);
934 printk("FTS_DBG from old version 0x%2x to new version = 0x%2x\n", reg_version, reg_value);
938 printk("[TSP] ugrade fail err=%d, line = %d.\n",err, __LINE__);
944 //printk("client->dev.driver->name %s ,%d \n",client->dev.driver->name,ft5x0x_ts->irq);
945 #ifdef CONFIG_RK_CONFIG
946 ret = request_irq(ft5x0x_ts->irq, ft5306_interrupt, irq_cfg.irq.irq_flags, client->dev.driver->name, ft5x0x_ts);
948 ret = request_irq(ft5x0x_ts->irq, ft5306_interrupt, IRQF_TRIGGER_FALLING, client->dev.driver->name, ft5x0x_ts);
951 dev_err(&client->dev, "irq %d busy?\n", ft5x0x_ts->irq);
952 goto exit_irq_request_fail;
955 i2c_set_clientdata(client, ft5x0x_ts);
956 ft5306_power.suspend =ft5306_suspend_early;
957 ft5306_power.resume =ft5306_resume_early;
958 ft5306_power.level = 0x2;
959 register_early_suspend(&ft5306_power);
962 err = ft5306_set_regs(client,0x88,buf_w,1);
964 err = ft5306_read_regs(client,0x88,buf_r,1);
965 printk("read buf[0x88] = %d\n", buf_r[0]);
968 i2c_set_clientdata(client, NULL);
969 free_irq(ft5x0x_ts->irq,ft5x0x_ts);
970 exit_irq_request_fail:
971 cancel_work_sync(&ft5x0x_ts->pen_event_work);
972 destroy_workqueue(ft5x0x_ts->ts_workqueue);
973 exit_create_singlethread:
975 input_unregister_device(input_dev);
976 exit_input_register_device_failed:
977 input_free_device(input_dev);
978 exit_input_dev_alloc_failed:
980 #ifdef CONFIG_RK_CONFIG
983 if (pdata->exit_platform_hw)
984 pdata->exit_platform_hw();
992 static struct i2c_device_id ft5306_idtable[] = {
997 MODULE_DEVICE_TABLE(i2c, ft5306_idtable);
999 static struct i2c_driver ft5306_driver = {
1001 .owner = THIS_MODULE,
1004 .id_table = ft5306_idtable,
1005 .probe = ft5306_probe,
1006 .remove = __devexit_p(ft5306_remove),
1009 static int __init ft5306_ts_init(void)
1012 #ifdef CONFIG_RK_CONFIG
1013 int ret = tp_board_init();
1018 return i2c_add_driver(&ft5306_driver);
1021 static void __exit ft5306_ts_exit(void)
1023 printk("Touchscreen driver of ft5306 exited.\n");
1024 i2c_del_driver(&ft5306_driver);
1028 /***********************************************************************/
1030 module_init(ft5306_ts_init);
1031 module_exit(ft5306_ts_exit);
1033 MODULE_AUTHOR("<wenfs@Focaltech-systems.com>");
1034 MODULE_DESCRIPTION("FocalTech ft5x0x TouchScreen driver");