1 #include <linux/init.h>
\r
2 #include <linux/module.h>
\r
3 #include <linux/kernel.h>
\r
4 #include <linux/platform_device.h>
\r
5 #include <linux/interrupt.h>
\r
6 #include <linux/irq.h>
\r
7 #include <linux/i2c.h>
\r
8 //#include <asm/semaphore.h>
\r
9 #include <linux/gpio.h>
\r
10 #include <mach/gpio.h>
\r
11 #include <linux/suspend.h>
\r
12 #include <linux/input.h>
\r
13 #include <mach/hardware.h>
\r
15 #include <linux/semaphore.h>
\r
16 #include <linux/sched.h>
\r
17 #include <linux/delay.h>
\r
19 #include <mach/iomux.h>
\r
21 #include <mach/spi_fpga.h>
\r
23 extern void rk2818_mux_api_set(char *name, unsigned int mode);
\r
24 extern int lp8725_ldo_en(uint8_t ldo,uint8_t enble);
\r
25 extern int lp8725_set_ldo_vol(uint8_t ldon,uint16_t vol);
\r
26 extern int lp8725_set_lilo_vol(uint8_t lilon,uint16_t vol);
\r
27 extern int lp8725_lilo_en(uint8_t lilon,uint8_t enble);
\r
30 struct Ctp_it7250_data {
\r
33 struct input_dev *input_dev;
34 struct i2c_client *client;
35 struct delayed_work delaywork;
\r
36 int irq; /* Our chip IRQ */
\r
40 static struct i2c_client *Ctp_it7250_client;
\r
42 #define Ctp_it7250_GPIO_INT RK2818_PIN_PE1
\r
45 #define rk28printk(x...) printk(x)
\r
47 #define rk28printk(x...)
\r
56 static struct KeyInfo panel_key_info[]={
63 #define MAX_FINGER_NUM 3
\r
64 //#define DEVICE_ADDRESS 0x8C
\r
65 #define COMMAND_BUFFER_INDEX 0x20
\r
66 #define QUERY_BUFFER_INDEX 0x80
\r
67 #define COMMAND_RESPONSE_BUFFER_INDEX 0xA0
\r
68 #define POINT_BUFFER_INDEX 0xE0
\r
69 #define QUERY_SUCCESS 0x00
\r
70 #define QUERY_BUSY 0x01
\r
71 #define QUERY_ERROR 0x02
\r
72 #define QUERY_POINT 0x80
\r
75 static u8 gpucPointBuffer[14];
\r
76 static u32 gpdwSampleX[3],gpdwSampleY[3],gpdwPressure[1];
\r
78 static int Ctp_it7250_rx_data(struct i2c_client *client, u8 reg,u8* rxData, int length)
\r
83 struct i2c_adapter *adap;int i;
\r
84 struct i2c_msg msgs[2];
87 adap = client->adapter;
\r
90 msgs[0].addr = client->addr;
\r
92 msgs[0].flags = client->flags;
\r
94 msgs[0].scl_rate = 400*1000;
\r
97 // rk28printk("i2c addr=0x%x \r\n",msgs[0].addr);
\r
98 // rk28printk("msgs[0].buf = 0x%x rxData=0x%x\n",*(msgs[0].buf),*rxData);
\r
100 msgs[1].buf = rxData;
\r
101 msgs[1].addr = client->addr;
\r
102 msgs[1].flags = client->flags | I2C_M_RD;
\r
103 msgs[1].len = length;
\r
104 msgs[1].scl_rate = 400*1000;
\r
106 ret = i2c_transfer(adap, msgs, 2);
107 //DBG("**has run at %s %d ret=%d**\n",__FUNCTION__,__LINE__,ret);
108 // rk28printk("\r\n msgs[1].buf = 0x%x ret=%d\n",*(msgs[1].buf),ret);
\r
111 //for (i=0;i<length;i++)
\r
112 // rk28printk("rxData[%d]=%d \r\n",i,rxData[i]);
\r
116 return i2c_master_reg8_recv(client, reg, rxData, length, 400 * 1000);
\r
117 //for (i=0;i<length;i++)
\r
118 // rk28printk("rxData[%d]=%d \r\n",i,rxData[i]);
\r
123 static int Ctp_it7250_tx_data(struct i2c_client *client, u8 reg,char *txData, int length)
\r
127 struct i2c_adapter *adap = client->adapter;
\r
128 struct i2c_msg msg;
\r
131 // rk28printk("reg=0x%x txData=0x%x \r\n",reg,*txData);
\r
133 for (i=0;i<length;i++)
\r
135 buf[i+1]=*txData++;
\r
136 rk28printk("buf[%d]=0x%x ",i+1,buf[i+1]);
\r
138 rk28printk("\r\n");
\r
139 // rk28printk("buf[0]=0x%x buf[1]=0x%x",buf[0],buf[1]);
\r
140 msg.addr = client->addr;
\r
141 //rk28printk("i2c addr=0x%x",msg.addr);
\r
143 msg.len = length+1;//+1 means add the reg length;by roberts
\r
144 msg.flags = client->flags;
\r
145 msg.scl_rate = 400*1000;
\r
147 ret = i2c_transfer(adap, &msg, 1);
150 return i2c_master_reg8_send(client, reg, txData, length, 400 * 1000);
\r
160 bool ReadQueryBuffer(struct i2c_client *client, u8* pucData)
\r
162 return Ctp_it7250_rx_data(client, QUERY_BUFFER_INDEX, pucData, 1);
\r
165 bool ReadCommandResponseBuffer(struct i2c_client *client, u8* pucData, unsigned int unDataLength)
\r
167 return Ctp_it7250_rx_data(client, COMMAND_RESPONSE_BUFFER_INDEX, pucData, unDataLength);
\r
170 bool ReadPointBuffer(struct i2c_client *client, u8* pucData)
\r
172 return Ctp_it7250_rx_data(client, POINT_BUFFER_INDEX, pucData, 14);
\r
175 bool WriteCommandBuffer(struct i2c_client *client, u8* pucData, unsigned int unDataLength)
\r
177 return Ctp_it7250_tx_data(client, COMMAND_BUFFER_INDEX, pucData, unDataLength);
\r
180 static int Ctp_it7250_touch_open(struct input_dev *idev)
\r
183 //struct Ctp_it7250_data *Ctp_it7250 = (struct Ctp_it7250_data *)i2c_get_clientdata(client);
\r
186 //BTN_TOUCH =0 means no touch ;by robert
\r
187 input_report_key(idev,BTN_TOUCH, 0);
\r
193 static void Ctp_it7250_touch_close(struct input_dev *idev)
\r
198 static irqreturn_t Ctp_it7250_touch_irq(int irq, void *dev_id)
\r
200 struct Ctp_it7250_data *Ctp_it7250 = dev_id;
\r
201 //printk("%s++++ %d \r\n",__FUNCTION__,__LINE__);
\r
202 //rk28printk("%s++++ %d \r\n",__FUNCTION__,__LINE__);
\r
203 disable_irq_nosync(irq);
\r
204 //rk28printk("%s++++ %d irq=%d\r\n",__FUNCTION__,__LINE__,irq);
\r
205 schedule_delayed_work(&Ctp_it7250->delaywork,msecs_to_jiffies(10));
\r
207 return IRQ_HANDLED;
\r
213 static int ts_input_init(struct i2c_client *client)
\r
216 struct Ctp_it7250_data *Ctp_it7250;
\r
217 Ctp_it7250 = i2c_get_clientdata(client);
\r
218 /* register input device */
\r
219 Ctp_it7250->input_dev = input_allocate_device();
\r
220 if (Ctp_it7250->input_dev == NULL) {
\r
221 pr_emerg( "%s: failed to allocate input dev\n",
\r
225 rk28printk("+++++++ %s+++++++\n", __FUNCTION__);
\r
226 Ctp_it7250->input_dev->name = "CTS_Ctp_it7250";
\r
227 Ctp_it7250->input_dev->phys = "CTS_Ctp_it7250/input1";
\r
228 Ctp_it7250->input_dev->dev.parent = &client->dev;
\r
229 //no need to open & close it,it will do it automaticlly;noted by robert
\r
230 Ctp_it7250->input_dev->open = Ctp_it7250_touch_open;
\r
231 Ctp_it7250->input_dev->close = Ctp_it7250_touch_close;
\r
233 __set_bit(EV_ABS, Ctp_it7250->input_dev->evbit);
\r
234 __set_bit(ABS_X, Ctp_it7250->input_dev->absbit);
\r
235 __set_bit(ABS_Y, Ctp_it7250->input_dev->absbit);
\r
237 __set_bit(EV_SYN, Ctp_it7250->input_dev->evbit);
\r
238 __set_bit(EV_KEY, Ctp_it7250->input_dev->evbit);
\r
239 __set_bit(BTN_TOUCH, Ctp_it7250->input_dev->keybit);
\r
241 for (i = 0; i < ARRAY_SIZE(panel_key_info); i++)
\r
242 {rk28printk("ts_input_init i=%d\r\n",i);
\r
243 __set_bit(panel_key_info[i].key,Ctp_it7250->input_dev->keybit);
\r
245 //__clear_bit(0, input_dev->keybit);
\r
247 input_set_abs_params(Ctp_it7250->input_dev, ABS_X, 0, 1000, 0, 0);
\r
248 input_set_abs_params(Ctp_it7250->input_dev, ABS_Y, 0, 1000, 0, 0);
\r
249 //pr_emerg("+++++++ %s\n", __FUNCTION__);
\r
250 ret = input_register_device(Ctp_it7250->input_dev);
\r
253 "%s: unabled to register input device, ret = %d\n",
\r
254 __FUNCTION__, ret);
\r
257 rk28printk("+++++++ %s+++++++END\n", __FUNCTION__);
\r
263 static void CTS_configure_pin(struct i2c_client *client)
\r
265 //add reset pin;but we not used it ;robert
\r
266 //had already do it it spi_gpio.c
\r
268 //RESET THE CTP;note by robert
\r
269 spi_gpio_set_pinlevel(SPI_GPIO_P2_15, SPI_GPIO_HIGH);
\r
271 spi_gpio_set_pinlevel(SPI_GPIO_P2_15, SPI_GPIO_LOW);
\r
273 spi_gpio_set_pinlevel(SPI_GPIO_P2_15, SPI_GPIO_HIGH);
\r
279 static int Ctp_it7250_init_irq(struct i2c_client *client)
\r
281 struct Ctp_it7250_data *Ctp_it7250;
\r
284 Ctp_it7250 = i2c_get_clientdata(client);
\r
286 if ( !gpio_is_valid(client->irq)) {
\r
287 rk28printk("+++++++++++gpio_is_invalid\n");
290 ret = gpio_request(client->irq, "Ctp_it7250_int");
\r
292 rk28printk( "failed to request Ctp_it7250_init_irq GPIO%d\n",gpio_to_irq(client->irq));
\r
296 ret = gpio_direction_input(client->irq);
\r
298 rk28printk("failed to set CTS_configure_pin gpio input\n");
\r
299 //goto err_free_gpio;
\r
301 gpio_pull_updown(client->irq,GPIOPullUp);
\r
303 rk28printk("%s gpio_to_irq(%d) is %d\n",__FUNCTION__,client->irq,gpio_to_irq(client->irq));
\r
305 Ctp_it7250->irq = gpio_to_irq(client->irq);
\r
307 ret = request_irq(Ctp_it7250->irq, Ctp_it7250_touch_irq, IRQF_TRIGGER_LOW, client->dev.driver->name, Ctp_it7250);
\r
308 rk28printk("%s request irq is %d,irq1 is %d,ret is 0x%x\n",__FUNCTION__,client->irq,Ctp_it7250->irq,ret);
\r
310 rk28printk(KERN_ERR "Ctp_it7250_init_irq: request irq failed,ret is %d\n",ret);
\r
316 // ================================================================================
\r
317 // Function Name --- GetFirmwareInformation
\r
318 // Description --- Get firmware information
\r
320 //Output --- return true if the command execute successfully, otherwuse return false.
\r
321 // ================================================================================
\r
322 bool GetFirmwareInformation(struct i2c_client *client)
\r
324 u8 ucWriteLength, ucReadLength;
\r
329 ucReadLength = 0x09;
\r
336 if(!ReadQueryBuffer(client, &ucQuery))
\r
338 ucQuery = QUERY_BUSY;
\r
340 }while(ucQuery & QUERY_BUSY);
\r
343 if(!WriteCommandBuffer(client, pucData, ucWriteLength))
\r
351 if(!ReadQueryBuffer(client, &ucQuery))
\r
353 ucQuery = QUERY_BUSY;
\r
355 }while(ucQuery & QUERY_BUSY);
\r
360 // Read Command Response
\r
361 if(!ReadCommandResponseBuffer(client, pucData, ucReadLength))
\r
368 for (i =0;i<ucReadLength;i++)
\r
369 rk28printk("GetFirmwareInformation pucData[%d]=%d \r\n",i,pucData[i]);
\r
371 && pucData[6] == 0
\r
372 && pucData[7] == 0
\r
373 && pucData[8] == 0)
\r
375 // There is no flash code
\r
376 rk28printk("There is no flash code \r\n");
\r
383 // ================================================================================
\r
384 // Function Name --- SetInterruptNotification
\r
385 // Description --- Set It7260 interrupt mode
\r
387 // ucStatus- the interrupt status
\r
388 // ucType- the interrupt type
\r
389 //Output --- return true if the command execute successfully, otherwuse return false.
\r
390 // ================================================================================
\r
391 bool SetInterruptNotification(struct i2c_client *client, u8 ucStatus, u8 ucType)
\r
393 u8 ucWriteLength, ucReadLength;
\r
397 ucWriteLength = 4;// 2
\r
401 pucData[2] = ucStatus;
\r
402 pucData[3] = ucType;
\r
407 if(!ReadQueryBuffer(client, &ucQuery))
\r
409 ucQuery = QUERY_BUSY;
\r
411 }while(ucQuery & QUERY_BUSY);
\r
414 if(!WriteCommandBuffer(client, pucData, ucWriteLength))
\r
422 if(!ReadQueryBuffer(client, &ucQuery))
\r
424 ucQuery = QUERY_BUSY;
\r
426 }while(ucQuery & QUERY_BUSY);
\r
428 // Read Command Response
\r
429 if(!ReadCommandResponseBuffer(client, pucData, ucReadLength))
\r
434 for (i =0;i<ucReadLength;i++)
\r
435 rk28printk("SetInterruptNotification pucData[%d]=0x%x \r\n",i,pucData[i]);
\r
436 if(*(u16*) pucData != 0)
\r
444 // ================================================================================
\r
445 // Function Name --- IdentifyCapSensor
\r
446 // Description --- Identify Capacitive Sensor information
\r
448 //Output --- return true if the command execute successfully, otherwuse return false.
\r
449 // ================================================================================
\r
450 bool IdentifyCapSensor(struct i2c_client *client)
\r
452 u8 ucWriteLength, ucReadLength;
\r
454 u8 ucQuery=0;int i;
\r
457 ucReadLength = 0x0A;
\r
459 rk28printk("%s\r\n",__FUNCTION__);
\r
462 {//printk("first wait 111\r\n");
\r
463 if(!ReadQueryBuffer(client, &ucQuery))
\r
466 rk28printk("first wait \r\n");
\r
467 //means we use resister touchscreen
\r
469 ucQuery = QUERY_BUSY;
\r
471 rk28printk("%s ucQuery!!!!=0x%x \r\n",__FUNCTION__,ucQuery);
\r
472 if (0xff == ucQuery)
\r
475 }while(ucQuery & QUERY_BUSY);
\r
479 //rk28printk("%s11\r\n",__FUNCTION__);
\r
480 pucData[0] = 0x00;ucWriteLength = 1;
\r
481 if(!WriteCommandBuffer(client, pucData, ucWriteLength))
\r
483 rk28printk("WriteCommandBuffer false \r\n");
\r
486 //rk28printk("show1 %s\r\n",__FUNCTION__);
\r
490 if(!ReadQueryBuffer(client, &ucQuery))
\r
492 rk28printk("second wait \r\n");
\r
493 ucQuery = QUERY_BUSY;
\r
494 }rk28printk("%s ucQuery1=0x%x \r\n",__FUNCTION__,ucQuery);
\r
495 }while(ucQuery & QUERY_BUSY);
\r
496 //rk28printk("show2 %s\r\n",__FUNCTION__);
\r
497 // Read Command Response
\r
498 for (i=0;i<ucReadLength;i++)
\r
500 rk28printk("pucData[%d]=%d \r\n",i,pucData[i]);
\r
502 if(!ReadCommandResponseBuffer(client, pucData, ucReadLength))
\r
504 rk28printk("ReadCommandResponseBuffer false \r\n");
\r
507 //rk28printk("show %s\r\n",__FUNCTION__);
\r
508 for (i=0;i<ucReadLength;i++)
\r
509 rk28printk("pucData[%d]=%d \r\n",i,pucData[i]);
\r
510 rk28printk("pucData=%c %c %c %c %c %c %c \r\n",pucData[1],pucData[2],pucData[3],pucData[4],pucData[5],pucData[6],pucData[7]);
\r
519 // ================================================================================
\r
520 // Function Name --- Get2DResolutions
\r
521 // Description --- Get the resolution of X and Y axes
\r
523 // pwXResolution - the X resolution
\r
524 // pwYResolution - the Y resolution
\r
525 // pucStep - the step
\r
526 //Output --- return true if the command execute successfully, otherwuse return false.
\r
527 // ================================================================================
\r
528 bool Get2DResolutions(struct i2c_client *client, u32 *pwXResolution, u32*pwYResolution, u8 *pucStep)
\r
530 u8 ucWriteLength, ucReadLength;
\r
536 ucReadLength = 0x07;
\r
544 if(!ReadQueryBuffer(client, &ucQuery))
\r
546 ucQuery = QUERY_BUSY;
\r
548 }while(ucQuery & QUERY_BUSY);
\r
551 rk28printk("%s WriteCommandBuffer\r\n",__FUNCTION__);
\r
552 if(!WriteCommandBuffer(client, pucData, ucWriteLength))
\r
560 if(!ReadQueryBuffer(client, &ucQuery))
\r
562 ucQuery = QUERY_BUSY;
\r
564 }while(ucQuery & QUERY_BUSY);
\r
565 rk28printk("%s ReadCommandResponseBuffer\r\n",__FUNCTION__);
\r
566 // Read Command Response
\r
567 if(!ReadCommandResponseBuffer(client, pucData, ucReadLength))
\r
571 rk28printk("%s ReadCommandResponseBuffer EDN\r\n",__FUNCTION__);
\r
573 for (i=0;i<ucReadLength;i++)
\r
574 rk28printk("pucData[%d] = 0x%x \r\n",i,pucData[i]);
\r
576 if(pwXResolution != NULL)
\r
578 *pwXResolution = (pucData[2] | (pucData[3] << 8));
\r
580 if(pwYResolution!= NULL)
\r
582 * pwYResolution = (pucData[4] | (pucData[5] << 8));
\r
584 if(pucStep!= NULL)
\r
586 * pucStep = pucData[6];
\r
588 rk28printk("%s x res=%d y res=%d !\r\n",__FUNCTION__,*pwXResolution,* pwYResolution);
\r
592 // *******************************************************************************************
\r
593 // Function Name: CaptouchMode
\r
595 // This function is mainly used to initialize cap-touch controller to active state.
\r
597 // dwMode -- the power state to be entered
\r
599 // return zero if success, otherwise return non zero value
\r
600 // *******************************************************************************************
\r
601 int CaptouchMode(struct i2c_client *client, u8 dwMode)
\r
603 u8 ucQueryResponse;
\r
604 u8 pucCommandBuffer[128];
\r
608 ReadQueryBuffer(client, &ucQueryResponse);
\r
610 while(ucQueryResponse & QUERY_BUSY);
\r
612 pucCommandBuffer[0] = 0x04;
\r
613 pucCommandBuffer[1] = 0x00;
\r
617 pucCommandBuffer[2] = 0x00;
\r
620 pucCommandBuffer[2] = 0x01;
\r
623 pucCommandBuffer[2] = 0x02;
\r
629 if(!WriteCommandBuffer(client, pucCommandBuffer,3))
\r
637 // *******************************************************************************************
\r
638 // Function Name: CaptouchReset
\r
640 // This function is mainly used to reset cap-touch controller by sending reset command.
\r
641 // Parameters: NULL
\r
643 // return TRUE if success, otherwise return FALSE
\r
644 // *******************************************************************************************
\r
645 int CaptouchReset(struct i2c_client *client)
\r
647 u8 ucQueryResponse;
\r
648 u8 pucCommandBuffer[128];
\r
652 ReadQueryBuffer(client, &ucQueryResponse);
\r
654 while(ucQueryResponse & QUERY_BUSY);
\r
656 pucCommandBuffer[0] = 0x6F;
\r
657 if(!WriteCommandBuffer(client, pucCommandBuffer,1))
\r
666 ReadQueryBuffer(client, &ucQueryResponse);
\r
668 while(ucQueryResponse & QUERY_BUSY);
\r
671 if(!ReadCommandResponseBuffer(client, pucCommandBuffer,2))
\r
676 if(pucCommandBuffer[0] == 0 && pucCommandBuffer[1] == 0)
\r
686 // *******************************************************************************************
\r
687 // Function Name: CaptouchHWInitial
\r
689 // This function is mainly used to initialize cap-touch controller to active state.
\r
690 // Parameters: NULL
\r
692 // return zero if success, otherwise return non zero value
\r
693 // *******************************************************************************************
\r
694 int CaptouchHWInitial(struct i2c_client *client)
\r
696 u32 wXResolution=0,wYResolution=0;
\r
698 if (!IdentifyCapSensor(client))
\r
700 rk28printk("%s IdentifyCapSensor error \r\n",__FUNCTION__);
\r
701 printk("%s IdentifyCapSensor error \r\n",__FUNCTION__);
\r
706 if (!GetFirmwareInformation (client))
\r
708 rk28printk("%s GetFirmwareInformation error \r\n",__FUNCTION__);
\r
709 printk("%s GetFirmwareInformation error \r\n",__FUNCTION__);
\r
713 if (!Get2DResolutions(client, &wXResolution, &wYResolution, &ucStep))
\r
715 rk28printk("%s Get2DResolutions error \r\n",__FUNCTION__);
\r
716 printk("%s Get2DResolutions error \r\n",__FUNCTION__);
\r
720 //no need to set interrupt mode because firmware has done that;note by robert
\r
722 if (!SetInterruptNotification(client, 0x01, 0x00))
\r
724 rk28printk("%s SetInterruptNotification error \r\n",__FUNCTION__);
\r
734 if (!CaptouchReset(client))
\r
735 rk28printk("CaptouchReset success \r\n");
\r
738 // if (!CaptouchMode(client, 0x00))
\r
739 // rk28printk("CaptouchMode success \r\n");
\r
743 // *******************************************************************************************
\r
744 // Function Name: CaptouchGetSampleValue
\r
746 // This function is mainly used to get sample values which shall contain x, y position and pressure.
\r
748 // pdwSampleX -- the pointer of returned X coordinates
\r
749 // pdwSampleY -- the pointer of returned Y coordinates
\r
750 // pdwPressure -- the pointer of returned pressures
\r
752 // The return value is the number of sample points. Return 0 if failing to get sample. The maximum // return value is 10 in normal case. If the CTP controller does not support pressure measurement, // the return value is the sample values OR with PRESSURE_INVALID.
\r
753 // *******************************************************************************************
\r
754 int CaptouchGetSampleValue(u32* pdwSampleX, u32* pdwSampleY, u32* pdwPressure)
\r
759 if(gpucPointBuffer[1] & 0x01)
\r
761 return MAX_FINGER_NUM + 1;
\r
765 for(i = 0; i < MAX_FINGER_NUM; i++)
\r
767 if(gpucPointBuffer[0] & (1 << i))
\r
771 pdwSampleX[i] = ((u32)(gpucPointBuffer[i * 4 + 3] & 0x0F) << 8) +
\r
772 (u32)gpucPointBuffer[i * 4 + 2];;
\r
773 pdwSampleY[i] = ((u32)(gpucPointBuffer[i * 4 + 3] & 0xF0) << 4) +
\r
774 (u32)gpucPointBuffer[i * 4 + 4];
\r
775 pdwPressure[i] = (u32)(gpucPointBuffer[i * 4 + 5] & 0x0F);
\r
777 pdwSampleX[i] = ((u32)(gpucPointBuffer[i * 4 + 3] & 0x0F) << 8) |
\r
778 gpucPointBuffer[i * 4 + 2];
\r
779 pdwSampleY[i] = ((u32)(gpucPointBuffer[i * 4 + 3] & 0xF0) << 4) |
\r
780 gpucPointBuffer[i * 4 + 4];
\r
781 pdwPressure[i] = (u32)(gpucPointBuffer[i * 4 + 5] & 0x0F);
\r
783 // rk28printk("%s x[%d]=%d y[%d]=%d \r\n",__FUNCTION__,i,pdwSampleX[i],i,pdwSampleY[i]);
\r
790 pdwPressure[i] = 0;
\r
793 //add by robert for test
\r
795 for(i = 0; i < MAX_FINGER_NUM; i++)
\r
797 rk28printk("%s x[%d]=%d y[%d]=%d \r\n",__FUNCTION__,0,pdwSampleX[0],0,pdwSampleY[0]);
\r
803 // *******************************************************************************************
\r
804 // Function Name: CaptouchGetGesture
\r
806 // This function is mainly used to initialize cap-touch controller to active state.
\r
807 // Parameters: NULL
\r
809 // return gesture ID
\r
810 // *******************************************************************************************
\r
811 int CaptouchGetGesture(void)
\r
813 return (int)gpucPointBuffer[1];
\r
816 static void Ctp_it7250_delaywork_func(struct work_struct *work)
\r
819 u8 ucQueryResponse;
\r
821 struct delayed_work *delaywork = container_of(work, struct delayed_work, work);
\r
822 struct Ctp_it7250_data *Ctp_it7250 = container_of(delaywork, struct Ctp_it7250_data, delaywork);
\r
823 struct i2c_client *client = Ctp_it7250->client;
\r
827 // rk28printk("%s++++ %d \r\n",__FUNCTION__,__LINE__);
\r
830 //PE1status = gpio_get_value(Ctp_it7250_GPIO_INT);
\r
831 PE1status = gpio_get_value(client->irq);
\r
832 // PE1status ΪµÍ£¬±íʾµÍµçƽÖжÏÓÐЧ
\r
835 // rk28printk("%s PE1status low!! \r\n",__FUNCTION__);
\r
836 if(!ReadQueryBuffer(client, &ucQueryResponse))
\r
837 {rk28printk("%s++++ %d ucQueryResponse=0x%x \r\n",__FUNCTION__,__LINE__,ucQueryResponse);
\r
840 //rk28printk("%s++++ %d ucQueryResponse=0x%x \r\n",__FUNCTION__,__LINE__,ucQueryResponse);
\r
842 if(ucQueryResponse & QUERY_POINT)
\r
843 {//rk28printk("%s++++ %d \r\n",__FUNCTION__,__LINE__);
\r
844 if(!ReadPointBuffer(client, gpucPointBuffer))
\r
845 {rk28printk("%s++++ %d \r\n",__FUNCTION__,__LINE__);
\r
848 //rk28printk("%s++++ %d ucQueryResponse=0x%x gpucPointBuffer=0x%x\r\n",__FUNCTION__,__LINE__,ucQueryResponse,gpucPointBuffer[0] & 0xF0);
\r
849 switch(gpucPointBuffer[0] & 0xF0)
\r
852 dwTouchEvent = CaptouchGetSampleValue(gpdwSampleX, gpdwSampleY, gpdwPressure);
\r
853 if(dwTouchEvent == 0)
\r
855 //SynchroSystemEvent(SYSTEM_TOUCH_EVENT_FINGER_RELEASE);
\r
856 rk28printk("TOUCH Release !!\r\n");
\r
857 input_report_key(Ctp_it7250->input_dev,BTN_TOUCH, 0);
\r
858 input_sync(Ctp_it7250->input_dev);
\r
860 else if(dwTouchEvent <=MAX_FINGER_NUM) //CTP_MAX_FINGER_NUMBER)
\r
862 //SynchroSystemEvent(SYSTEM_TOUCH_EVENT_FINGER_ASSERT);
\r
863 if ((abs(Ctp_it7250->temp_x -gpdwSampleX[0])>10) ||( abs(Ctp_it7250->temp_y-gpdwSampleY[0])>10))
\r
865 input_report_abs(Ctp_it7250->input_dev, ABS_X, gpdwSampleX[0]);// & 0xfff
\r
866 input_report_abs(Ctp_it7250->input_dev, ABS_Y, gpdwSampleY[0]); //& 0xfff
\r
867 input_report_key(Ctp_it7250->input_dev,BTN_TOUCH, 1);
\r
868 input_sync(Ctp_it7250->input_dev);
\r
869 rk28printk("x=%d y=%d \r\n",gpdwSampleX[0],gpdwSampleY[0]);
\r
870 Ctp_it7250->temp_x=gpdwSampleX[0];
\r
871 Ctp_it7250->temp_y=gpdwSampleY[0];
\r
874 rk28printk("the same \r\n");
\r
878 rk28printk("%s SYSTEM_TOUCH_EVENT_PALM_DETECT \r\n",__FUNCTION__);
\r
879 //SynchroSystemEvent(SYSTEM_TOUCH_EVENT_PALM_DETECT);
\r
883 dwTouchEvent = CaptouchGetGesture();
\r
884 //SynchroSystemEvent(SYSTEM_GESTURE_EVENT);
\r
885 rk28printk("gesture:0x%x \r\n",dwTouchEvent);
\r
889 rk28printk("ID of button is 0x%x status is 0x%x\r\n",gpucPointBuffer[1],gpucPointBuffer[2]);
\r
890 switch (gpucPointBuffer[1])
\r
892 rk28printk("home \r\n");
\r
893 if (gpucPointBuffer[2])
\r
894 input_report_key(Ctp_it7250->input_dev, panel_key_info[(gpucPointBuffer[1]-1)].key,1);
\r
896 input_report_key(Ctp_it7250->input_dev, panel_key_info[(gpucPointBuffer[1]-1)].key,0);
\r
899 rk28printk("menu \r\n");
\r
900 if (gpucPointBuffer[2])
\r
901 input_report_key(Ctp_it7250->input_dev, panel_key_info[(gpucPointBuffer[1]-1)].key,1);
\r
903 input_report_key(Ctp_it7250->input_dev, panel_key_info[(gpucPointBuffer[1]-1)].key,0);
\r
906 rk28printk("back \r\n");
\r
907 if (gpucPointBuffer[2])
\r
909 rk28printk("back down key=%d\r\n",panel_key_info[(gpucPointBuffer[1]-1)].key);
\r
910 input_report_key(Ctp_it7250->input_dev, panel_key_info[(gpucPointBuffer[1]-1)].key,1);
\r
914 rk28printk("back up key=%d\r\n",panel_key_info[(gpucPointBuffer[1]-1)].key);
\r
915 input_report_key(Ctp_it7250->input_dev, panel_key_info[(gpucPointBuffer[1]-1)].key,0);
\r
919 rk28printk("find \r\n");
\r
920 if (gpucPointBuffer[2])
\r
922 rk28printk("find down key=%d\r\n",panel_key_info[(gpucPointBuffer[1]-1)].key);
\r
923 input_report_key(Ctp_it7250->input_dev, panel_key_info[(gpucPointBuffer[1]-1)].key,1);
\r
927 rk28printk("find up key=%d\r\n",panel_key_info[(gpucPointBuffer[1]-1)].key);
\r
928 input_report_key(Ctp_it7250->input_dev, panel_key_info[(gpucPointBuffer[1]-1)].key,0);
\r
932 rk28printk("shit default \r\n");
\r
937 rk28printk("default \r\n");
\r
941 else if (ucQueryResponse & QUERY_ERROR)
\r
943 if (!CaptouchReset(client))
\r
944 rk28printk("!! CaptouchReset success \r\n");
\r
946 //if (!CaptouchMode(client, 0x00))
\r
947 //rk28printk("!! CaptouchMode success \r\n");
\r
950 // rk28printk("enable ctp_irq=%d \r\n",Ctp_it7250->irq);
\r
952 enable_irq(Ctp_it7250->irq);
\r
953 //²»ÊDzéѯģʽ£¬²»ÐèÒªÂÖѯ
\r
954 //schedule_delayed_work(&Ctp_it7250->delaywork,msecs_to_jiffies(1000));
\r
958 static int Ctp_it7250_probe(struct i2c_client *client, const struct i2c_device_id *id)
\r
960 struct Ctp_it7250_data *Ctp_it7250;
\r
962 Ctp_it7250_client = client;
\r
963 rk28printk("+++++++ %s+++++++\n", __FUNCTION__);
\r
964 Ctp_it7250 = kzalloc(sizeof(struct Ctp_it7250_data), GFP_KERNEL);
\r
967 rk28printk("[Ctp_it7250_probe]:alloc data failed.\n");
\r
971 // INIT_WORK(&Ctp_it7250->irq_work, Ctp_it7250_irq_worker);
\r
972 INIT_DELAYED_WORK(&Ctp_it7250->delaywork, Ctp_it7250_delaywork_func);
\r
974 Ctp_it7250->client = client;
\r
975 i2c_set_clientdata(client, Ctp_it7250);
\r
977 if (!CaptouchHWInitial(client))
\r
979 Ctp_it7250_init_irq(client);
\r
980 ts_input_init(client);
\r
981 // CTS_configure_pin(client);
\r
984 lp8725_lilo_en(2,0);
\r
987 lp8725_lilo_en(2,1);
\r
989 lp8725_set_lilo_vol(2,300);
\r
993 //²»ÊDzéѯģʽ£¬²»ÐèÒªÂÖѯ
\r
994 //schedule_delayed_work(&Ctp_it7250->delaywork,msecs_to_jiffies(50));
\r
997 rk28printk("+++++++ %s+++++++\n", __FUNCTION__);
\r
1000 kfree(Ctp_it7250);
\r
1007 static int Ctp_it7250_remove(struct i2c_client *client)
\r
1016 static int Ctp_it7250_suspend(struct i2c_client *client, pm_message_t state)
\r
1017 {//pr_emerg("\n irq1=%d \n",irq1);
\r
1018 struct Ctp_it7250_data *Ctp_it7250 = (struct Ctp_it7250_data *)i2c_get_clientdata(client);
\r
1020 rk28printk("%s\n",__func__);
\r
1022 CaptouchMode(client, 2);
\r
1023 disable_irq(Ctp_it7250->irq);
\r
1028 static int Ctp_it7250_resume(struct i2c_client *client)
\r
1030 struct Ctp_it7250_data *Ctp_it7250 = (struct Ctp_it7250_data *)i2c_get_clientdata(client);
\r
1033 rk28printk("%s\n",__func__);
\r
1035 if(gpio_direction_output(client->irq,GPIO_LOW))
\r
1036 printk("%s:set pin output error\n",__func__);
\r
1038 ReadQueryBuffer(client, &ucQuery);
\r
1039 if (gpio_direction_input(client->irq))
\r
1040 printk("%s:failed to set CTS_configure_pin gpio input\n",__func__);
\r
1041 gpio_pull_updown(client->irq,GPIOPullUp);
\r
1043 enable_irq(Ctp_it7250->irq);
\r
1048 #define Ctp_it7250_suspend NULL
\r
1049 #define Ctp_it7250_resume NULL
\r
1052 static const struct i2c_device_id Ctp_it7250_id[] = {
\r
1053 {"Ctp_it7250", 0},
\r
1057 static struct i2c_driver Ctp_it7250_driver = {
\r
1059 .name = "Ctp_it7250",
\r
1061 .id_table = Ctp_it7250_id,
\r
1062 .probe = Ctp_it7250_probe,
\r
1063 .remove = Ctp_it7250_remove,
\r
1064 .suspend = Ctp_it7250_suspend,
\r
1065 .resume = Ctp_it7250_resume,
\r
1068 static int __init Ctp_it7250_init(void)
\r
1071 rk28printk("+++++++ %s++\n", __FUNCTION__);
\r
1072 ret=i2c_add_driver(&Ctp_it7250_driver);
\r
1073 rk28printk("**Ctp_it7250_init_init return %d**\n",ret);
\r
1077 static void __exit Ctp_it7250_exit(void)
\r
1079 /* We move these codes here because we want to detect the
\r
1080 * pen down event even when touch driver is not opened.
\r
1082 i2c_del_driver(&Ctp_it7250_driver);
\r
1085 late_initcall(Ctp_it7250_init);
\r
1086 module_exit(Ctp_it7250_exit);
\r
1088 MODULE_AUTHOR("Robert_mu<robert.mu@rahotech.com>");
\r