arch/arm/mach-mt8127/kr076/touchpanel/goodix_tool.c

   1 /* drivers/input/touchscreen/goodix_tool.c
   2  *
   3  * 2010 - 2012 Goodix Technology.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be a reference
  11  * to you, when you are integrating the GOODiX's CTP IC into your system,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  *      V2.2
  17  *        V1.0:2012/05/01,create file.
  18  *        V1.2:2012/10/17,reset_guitar etc.
  19  *        V1.4: 2013/06/08, new proc name
  20  *        V2.2:2014/01/14, compatible with Linux 3.10
  21  *      V2.2.6:
  22  *          Special edition for GT910 flashless
  23  *          1. firmware check
  24  *      V2.2.7
  25  *               Special edition for GT910 flashless
  26  *          1. modified to support gesture wakeup module
  27  */
  28
  29 #include "tpd.h"
  30 #include <linux/interrupt.h>
  31 #include <cust_eint.h>
  32 #include <linux/i2c.h>
  33 #include <linux/sched.h>
  34 #include <linux/kthread.h>
  35 #include <linux/rtpm_prio.h>
  36 #include <linux/wait.h>
  37 #include <linux/time.h>
  38 #include <linux/delay.h>
  39 #include "cust_gpio_usage.h"
  40 #include <asm/uaccess.h>
  41
  42 #include "tpd_custom_gt9xx.h"
  43 extern int gtp_autotool_setting;
  44
  45 #pragma pack(1)
  46 typedef struct
  47 {
  48     u8  wr;         //write read flag£¬0:R  1:W  2:PID 3:
  49     u8  flag;       //0:no need flag/int 1: need flag  2:need int
  50     u8 flag_addr[2];  //flag address
  51     u8  flag_val;   //flag val
  52     u8  flag_relation;  //flag_val:flag 0:not equal 1:equal 2:> 3:<
  53     u16 circle;     //polling cycle
  54     u8  times;      //plling times
  55     u8  retry;      //I2C retry times
  56     u16 delay;      //delay befor read or after write
  57     u16 data_len;   //data length
  58     u8  addr_len;   //address length
  59     u8  addr[2];    //address
  60     u8  res[3];     //reserved
  61     u8 *data;       //data pointer
  62 } st_cmd_head;
  63 #pragma pack()
  64 st_cmd_head cmd_head;
  65
  66 #define UPDATE_FUNCTIONS
  67 #define DATA_LENGTH_UINT    512
  68 #define CMD_HEAD_LENGTH     (sizeof(st_cmd_head) - sizeof(u8*))
  69 static char procname[20] = {0};
  70 extern struct i2c_client *i2c_client_point;
  71 static struct i2c_client *gt_client = NULL;
  72
  73 #ifdef UPDATE_FUNCTIONS
  74 extern s32 gup_enter_update_mode(struct i2c_client *client);
  75 extern void gup_leave_update_mode(void);
  76 extern s32 gup_update_proc(void *dir);
  77 #endif
  78
  79 static struct proc_dir_entry *goodix_proc_entry;
  80
  81 static ssize_t goodix_tool_read(struct file *, char __user *, size_t, loff_t *);
  82 static ssize_t goodix_tool_write(struct file *, const char __user *, size_t, loff_t *);
  83 static const struct file_operations tool_ops = {
  84     .owner = THIS_MODULE,
  85     .read = goodix_tool_read,
  86     .write = goodix_tool_write,
  87 };
  88
  89 //static s32 goodix_tool_write(struct file *filp, const char __user *buff, unsigned long len, void *data);
  90 //static s32 goodix_tool_read( char *page, char **start, off_t off, int count, int *eof, void *data );
  91 static s32(*tool_i2c_read)(u8 *, u16);
  92 static s32(*tool_i2c_write)(u8 *, u16);
  93
  94 #if GTP_ESD_PROTECT
  95 extern void gtp_esd_switch(struct i2c_client *client, s32 on);
  96 #endif
  97
  98 s32 DATA_LENGTH = 0;
  99 s8 IC_TYPE[16] = "GT9XX";
 100 static void tool_set_proc_name(char * procname)
 101 {
 102     char *months[12] = {"Jan", "Feb", "Mar", "Apr", "May",
 103         "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
 104     char date[20] = {0};
 105     char month[4] = {0};
 106     int i = 0, n_month = 1, n_day = 0, n_year = 0;
 107
 108     sprintf(date, "%s", __DATE__);
 109
 110     //GTP_DEBUG("compile date: %s", date);
 111
 112     sscanf(date, "%s %d %d", month, &n_day, &n_year);
 113
 114     for (i = 0; i < 12; ++i)
 115     {
 116         if (!memcmp(months[i], month, 3))
 117         {
 118             n_month = i+1;
 119             break;
 120         }
 121     }
 122
 123     sprintf(procname, "gmnode");
 124     //sprintf(procname, "gmnode%04d%02d%02d", n_year, n_month, n_day);
 125     //memset(procname, 0, 20);
 126     //sprintf(procname, "goodix_tool");
 127     //GTP_DEBUG("procname = %s", procname);
 128 }
 129 static s32 tool_i2c_read_no_extra(u8 *buf, u16 len)
 130 {
 131     s32 ret = -1;
 132
 133     ret = gtp_i2c_read(gt_client, buf, len + GTP_ADDR_LENGTH);
 134     return ret;
 135 }
 136
 137 static s32 tool_i2c_write_no_extra(u8 *buf, u16 len)
 138 {
 139     s32 ret = -1;
 140
 141     ret = gtp_i2c_write(gt_client, buf, len);
 142     return ret;
 143 }
 144
 145 static s32 tool_i2c_read_with_extra(u8 *buf, u16 len)
 146 {
 147     s32 ret = -1;
 148     u8 pre[2] = {0x0f, 0xff};
 149     u8 end[2] = {0x80, 0x00};
 150
 151     tool_i2c_write_no_extra(pre, 2);
 152     ret = tool_i2c_read_no_extra(buf, len);
 153     tool_i2c_write_no_extra(end, 2);
 154
 155     return ret;
 156 }
 157
 158 static s32 tool_i2c_write_with_extra(u8 *buf, u16 len)
 159 {
 160     s32 ret = -1;
 161     u8 pre[2] = {0x0f, 0xff};
 162     u8 end[2] = {0x80, 0x00};
 163
 164     tool_i2c_write_no_extra(pre, 2);
 165     ret = tool_i2c_write_no_extra(buf, len);
 166     tool_i2c_write_no_extra(end, 2);
 167
 168     return ret;
 169 }
 170
 171 static void register_i2c_func(void)
 172 {
 173 //    if (!strncmp(IC_TYPE, "GT818", 5) || !strncmp(IC_TYPE, "GT816", 5)
 174 //        || !strncmp(IC_TYPE, "GT811", 5) || !strncmp(IC_TYPE, "GT818F", 6)
 175 //        || !strncmp(IC_TYPE, "GT827", 5) || !strncmp(IC_TYPE,"GT828", 5)
 176 //        || !strncmp(IC_TYPE, "GT813", 5))
 177     if (strncmp(IC_TYPE, "GT8110", 6) && strncmp(IC_TYPE, "GT8105", 6)
 178             && strncmp(IC_TYPE, "GT801", 5) && strncmp(IC_TYPE, "GT800", 5)
 179             && strncmp(IC_TYPE, "GT801PLUS", 9) && strncmp(IC_TYPE, "GT811", 5)
 180             && strncmp(IC_TYPE, "GTxxx", 5) && strncmp(IC_TYPE, "GT9XX", 5))
 181     {
 182         tool_i2c_read = tool_i2c_read_with_extra;
 183         tool_i2c_write = tool_i2c_write_with_extra;
 184         GTP_DEBUG("I2C function: with pre and end cmd!");
 185     }
 186     else
 187     {
 188         tool_i2c_read = tool_i2c_read_no_extra;
 189         tool_i2c_write = tool_i2c_write_no_extra;
 190         GTP_INFO("I2C function: without pre and end cmd!");
 191     }
 192 }
 193
 194 static void unregister_i2c_func(void)
 195 {
 196     tool_i2c_read = NULL;
 197     tool_i2c_write = NULL;
 198     GTP_INFO("I2C function: unregister i2c transfer function!");
 199 }
 200
 201
 202 s32 init_wr_node(struct i2c_client *client)
 203 {
 204     s32 i;
 205
 206     gt_client = i2c_client_point;
 207
 208     memset(&cmd_head, 0, sizeof(cmd_head));
 209     cmd_head.data = NULL;
 210
 211     i = 5;
 212
 213     while ((!cmd_head.data) && i)
 214     {
 215         cmd_head.data = kzalloc(i * DATA_LENGTH_UINT, GFP_KERNEL);
 216
 217         if (NULL != cmd_head.data)
 218         {
 219             break;
 220         }
 221
 222         i--;
 223     }
 224
 225     if (i)
 226     {
 227         DATA_LENGTH = i * DATA_LENGTH_UINT + GTP_ADDR_LENGTH;
 228         GTP_INFO("Applied memory size:%d.", DATA_LENGTH);
 229     }
 230     else
 231     {
 232         GTP_ERROR("Apply for memory failed.");
 233         return FAIL;
 234     }
 235
 236     cmd_head.addr_len = 2;
 237     cmd_head.retry = 5;
 238
 239     register_i2c_func();
 240
 241     tool_set_proc_name(procname);
 242     //goodix_proc_entry = create_proc_entry(procname, 0666, NULL);
 243     goodix_proc_entry = proc_create(procname, 0666, NULL, &tool_ops);
 244     if (goodix_proc_entry == NULL)
 245     {
 246         GTP_ERROR("Couldn't create proc entry!");
 247         return FAIL;
 248     }
 249     else
 250     {
 251         GTP_INFO("Create proc entry success!");
 252         //goodix_proc_entry->write_proc = goodix_tool_write;
 253         //goodix_proc_entry->read_proc = goodix_tool_read;
 254     }
 255
 256     return SUCCESS;
 257 }
 258
 259 void uninit_wr_node(void)
 260 {
 261     kfree(cmd_head.data);
 262     cmd_head.data = NULL;
 263     unregister_i2c_func();
 264     remove_proc_entry(procname, NULL);
 265 }
 266
 267 static u8 relation(u8 src, u8 dst, u8 rlt)
 268 {
 269     u8 ret = 0;
 270
 271     switch (rlt)
 272     {
 273         case 0:
 274             ret = (src != dst) ? true : false;
 275             break;
 276
 277         case 1:
 278             ret = (src == dst) ? true : false;
 279             GTP_DEBUG("equal:src:0x%02x   dst:0x%02x   ret:%d.", src, dst, (s32)ret);
 280             break;
 281
 282         case 2:
 283             ret = (src > dst) ? true : false;
 284             break;
 285
 286         case 3:
 287             ret = (src < dst) ? true : false;
 288             break;
 289
 290         case 4:
 291             ret = (src & dst) ? true : false;
 292             break;
 293
 294         case 5:
 295             ret = (!(src | dst)) ? true : false;
 296             break;
 297
 298         default:
 299             ret = false;
 300             break;
 301     }
 302
 303     return ret;
 304 }
 305
 306 /*******************************************************
 307 Function:
 308     Comfirm function.
 309 Input:
 310   None.
 311 Output:
 312     Return write length.
 313 ********************************************************/
 314 static u8 comfirm(void)
 315 {
 316     s32 i = 0;
 317     u8 buf[32];
 318
 319 //    memcpy(&buf[GTP_ADDR_LENGTH - cmd_head.addr_len], &cmd_head.flag_addr, cmd_head.addr_len);
 320 //    memcpy(buf, &cmd_head.flag_addr, cmd_head.addr_len);//Modified by Scott, 2012-02-17
 321     memcpy(buf, cmd_head.flag_addr, cmd_head.addr_len);
 322
 323     for (i = 0; i < cmd_head.times; i++)
 324     {
 325         if (tool_i2c_read(buf, 1) <= 0)
 326         {
 327             GTP_ERROR("Read flag data failed!");
 328             return FAIL;
 329         }
 330
 331         if (true == relation(buf[GTP_ADDR_LENGTH], cmd_head.flag_val, cmd_head.flag_relation))
 332         {
 333             GTP_DEBUG("value at flag addr:0x%02x.", buf[GTP_ADDR_LENGTH]);
 334             GTP_DEBUG("flag value:0x%02x.", cmd_head.flag_val);
 335             break;
 336         }
 337
 338         msleep(cmd_head.circle);
 339     }
 340
 341     if (i >= cmd_head.times)
 342     {
 343         GTP_ERROR("Didn't get the flag to continue!");
 344         return FAIL;
 345     }
 346
 347     return SUCCESS;
 348 }
 349
 350 /*******************************************************
 351 Function:
 352     Goodix tool write function.
 353 Input:
 354   standard proc write function param.
 355 Output:
 356     Return write length.
 357 ********************************************************/
 358 //static s32 goodix_tool_write(struct file *filp, const char __user *buff, unsigned long len, void *data)
 359 ssize_t goodix_tool_write(struct file *filp, const char __user *buff, size_t len, loff_t *off)
 360 {
 361     u64 ret = 0;
 362     GTP_DEBUG_FUNC();
 363     GTP_DEBUG_ARRAY((u8 *)buff, len);
 364
 365     ret = copy_from_user(&cmd_head, buff, CMD_HEAD_LENGTH);
 366
 367     if (ret)
 368     {
 369         GTP_ERROR("copy_from_user failed.");
 370         return -EPERM;
 371     }
 372
 373     GTP_DEBUG("[Operation]wr: %02X", cmd_head.wr);
 374     GTP_DEBUG("[Flag]flag: %02X, addr: %02X%02X, value: %02X, relation: %02X", cmd_head.flag, cmd_head.flag_addr[0],
 375                         cmd_head.flag_addr[1], cmd_head.flag_val, cmd_head.flag_relation);
 376     GTP_DEBUG("[Retry]circle: %d, times: %d, retry: %d, delay: %d", (s32)cmd_head.circle, (s32)cmd_head.times,
 377                         (s32)cmd_head.retry, (s32)cmd_head.delay);
 378     GTP_DEBUG("[Data]data len: %d, addr len: %d, addr: %02X%02X, buffer len: %d, data[0]: %02X", (s32)cmd_head.data_len,
 379                         (s32)cmd_head.addr_len, cmd_head.addr[0], cmd_head.addr[1], (s32)len, buff[CMD_HEAD_LENGTH]);
 380
 381     if (1 == cmd_head.wr)
 382     {
 383         ret = copy_from_user(&cmd_head.data[GTP_ADDR_LENGTH], &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
 384
 385         if (ret)
 386         {
 387             GTP_ERROR("copy_from_user failed.");
 388                         return -EPERM;
 389         }
 390
 391         memcpy(&cmd_head.data[GTP_ADDR_LENGTH - cmd_head.addr_len], cmd_head.addr, cmd_head.addr_len);
 392
 393         GTP_DEBUG_ARRAY(cmd_head.data, cmd_head.data_len + cmd_head.addr_len);
 394         GTP_DEBUG_ARRAY((u8 *)&buff[CMD_HEAD_LENGTH], cmd_head.data_len);
 395
 396         if (1 == cmd_head.flag)
 397         {
 398             if (FAIL == comfirm())
 399             {
 400                 GTP_ERROR("[WRITE]Comfirm fail!");
 401                 return -EPERM;
 402             }
 403         }
 404         else if (2 == cmd_head.flag)
 405         {
 406             //Need interrupt!
 407         }
 408
 409         if (tool_i2c_write(&cmd_head.data[GTP_ADDR_LENGTH - cmd_head.addr_len],
 410                            cmd_head.data_len + cmd_head.addr_len) <= 0)
 411         {
 412             GTP_ERROR("[WRITE]Write data failed!");
 413             return -EPERM;
 414         }
 415
 416         GTP_DEBUG_ARRAY(&cmd_head.data[GTP_ADDR_LENGTH - cmd_head.addr_len], cmd_head.data_len + cmd_head.addr_len);
 417
 418         if (cmd_head.delay)
 419         {
 420             msleep(cmd_head.delay);
 421         }
 422     }
 423     else if (3 == cmd_head.wr)  //Write ic type
 424     {
 425         gtp_autotool_setting = 1;
 426         ret = copy_from_user(&cmd_head.data[0], &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
 427         if(ret)
 428         {
 429             GTP_ERROR("copy_from_user failed.");
 430                         return -EPERM;
 431         }
 432         memcpy(IC_TYPE, cmd_head.data, cmd_head.data_len);
 433         register_i2c_func();
 434     }
 435     else if (5 == cmd_head.wr)
 436     {
 437         //memcpy(IC_TYPE, cmd_head.data, cmd_head.data_len);
 438     }
 439     else if (7 == cmd_head.wr)//disable irq!
 440     {
 441         mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
 442     #if GTP_ESD_PROTECT
 443         gtp_esd_switch(i2c_client_point, SWITCH_OFF);
 444     #endif
 445     }
 446     else if (9 == cmd_head.wr) //enable irq!
 447     {
 448         mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
 449     #if GTP_ESD_PROTECT
 450         gtp_esd_switch(i2c_client_point, SWITCH_ON);
 451     #endif
 452     }
 453     else if (17 == cmd_head.wr)
 454     {
 455         ret = copy_from_user(&cmd_head.data[GTP_ADDR_LENGTH], &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
 456
 457         if (ret)
 458         {
 459             GTP_DEBUG("copy_from_user failed.");
 460             return -EPERM;
 461         }
 462
 463         if (cmd_head.data[GTP_ADDR_LENGTH])
 464         {
 465             GTP_DEBUG("gtp enter rawdiff.");
 466             gtp_rawdiff_mode = true;
 467         }
 468         else
 469         {
 470             gtp_rawdiff_mode = false;
 471             GTP_DEBUG("gtp leave rawdiff.");
 472         }
 473     }
 474 #ifdef UPDATE_FUNCTIONS
 475     else if (11 == cmd_head.wr) //Enter update mode!
 476     {
 477         if (FAIL == gup_enter_update_mode(gt_client))
 478         {
 479             return -EPERM;
 480         }
 481     }
 482     else if (13 == cmd_head.wr)//Leave update mode!
 483     {
 484         gup_leave_update_mode();
 485     }
 486     else if (15 == cmd_head.wr) //Update firmware!
 487     {
 488         show_len = 0;
 489         total_len = 0;
 490         memset(cmd_head.data, 0, cmd_head.data_len + 1);
 491         memcpy(cmd_head.data, &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
 492         if (FAIL == gup_update_proc((void *)cmd_head.data))
 493         {
 494             return -EPERM;
 495         }
 496     }
 497
 498 #endif
 499
 500     return len;
 501 }
 502
 503 /*******************************************************
 504 Function:
 505     Goodix tool read function.
 506 Input:
 507   standard proc read function param.
 508 Output:
 509     Return read length.
 510 ********************************************************/
 511 //static s32 goodix_tool_read( char *page, char **start, off_t off, int count, int *eof, void *data )
 512 ssize_t goodix_tool_read(struct file *file, char __user *page, size_t size, loff_t *ppos)
 513 {
 514     s32 ret = 0;
 515
 516     GTP_DEBUG_FUNC();
 517
 518     if (*ppos)      // ADB call again
 519     {
 520         //GTP_DEBUG("[HEAD]wr: %d", cmd_head.wr);
 521         //GTP_DEBUG("[PARAM]size: %d, *ppos: %d", size, (int)*ppos);
 522         //GTP_DEBUG("[TOOL_READ]ADB call again, return it.");
 523         return 0;
 524     }
 525
 526     if (cmd_head.wr % 2)
 527     {
 528         return -EPERM;
 529     }
 530     else if (!cmd_head.wr)
 531     {
 532         u16 len = 0;
 533         s16 data_len = 0;
 534         u16 loc = 0;
 535
 536         if (1 == cmd_head.flag)
 537         {
 538             if (FAIL == comfirm())
 539             {
 540                 GTP_ERROR("[READ]Comfirm fail!");
 541                 return -EPERM;
 542             }
 543         }
 544         else if (2 == cmd_head.flag)
 545         {
 546             //Need interrupt!
 547         }
 548
 549         memcpy(cmd_head.data, cmd_head.addr, cmd_head.addr_len);
 550
 551         GTP_DEBUG("[CMD HEAD DATA] ADDR:0x%02x%02x.", cmd_head.data[0], cmd_head.data[1]);
 552         GTP_DEBUG("[CMD HEAD ADDR] ADDR:0x%02x%02x.", cmd_head.addr[0], cmd_head.addr[1]);
 553
 554         if (cmd_head.delay)
 555         {
 556             msleep(cmd_head.delay);
 557         }
 558
 559         data_len = cmd_head.data_len;
 560
 561         while (data_len > 0)
 562         {
 563             if (data_len > DATA_LENGTH)
 564             {
 565                 len = DATA_LENGTH;
 566             }
 567             else
 568             {
 569                 len = data_len;
 570             }
 571
 572             data_len -= len;
 573
 574             if (tool_i2c_read(cmd_head.data, len) <= 0)
 575             {
 576                 GTP_ERROR("[READ]Read data failed!");
 577                 return -EPERM;
 578             }
 579
 580             //memcpy(&page[loc], &cmd_head.data[GTP_ADDR_LENGTH], len);
 581             ret = simple_read_from_buffer(&page[loc], size, ppos, &cmd_head.data[GTP_ADDR_LENGTH], len);
 582             if (ret < 0)
 583             {
 584                 return ret;
 585             }
 586             loc += len;
 587
 588             GTP_DEBUG_ARRAY(&cmd_head.data[GTP_ADDR_LENGTH], len);
 589             GTP_DEBUG_ARRAY(page, len);
 590         }
 591         return cmd_head.data_len;
 592     }
 593     else if (2 == cmd_head.wr)
 594     {
 595         ret = simple_read_from_buffer(page, size, ppos, IC_TYPE, sizeof(IC_TYPE));
 596         return ret;
 597     }
 598     else if (4 == cmd_head.wr)
 599     {
 600         u8 progress_buf[4];
 601         progress_buf[0] = show_len >> 8;
 602         progress_buf[1] = show_len & 0xff;
 603         progress_buf[2] = total_len >> 8;
 604         progress_buf[3] = total_len & 0xff;
 605
 606         ret = simple_read_from_buffer(page, size, ppos, progress_buf, 4);
 607         return ret;
 608     }
 609     else if (6 == cmd_head.wr)
 610     {
 611         //Read error code!
 612     }
 613     else if (8 == cmd_head.wr)  //Read driver version
 614     {
 615         ret = simple_read_from_buffer(page, size, ppos, GTP_DRIVER_VERSION, strlen(GTP_DRIVER_VERSION));
 616         return ret;
 617     }
 618
 619     return -EPERM;
 620 }