drivers/input/touchscreen/zet62xx/zet62xx.c

   1 /**\r
   2  * @file drivers/input/touchscreen/zet62xx.c\r
   3  *\r
   4  * This software is licensed under the terms of the GNU General Public\r
   5  * License version 2, as published by the Free Software Foundation, and\r
   6  * may be copied, distributed, and modified under those terms.\r
   7  * This program is distributed in the hope that it will be useful,\r
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  10  * GNU General Public License for more details.\r
  11  * ZEITEC Semiconductor Co., Ltd\r
  12   * @author JLJuang <JL.Juang@zeitecsemi.com>\r
  13  * @note Copyright (c) 2010, Zeitec Semiconductor Ltd., all rights reserved.\r
  14  * @version $Revision: 25 $\r
  15  * @note\r
  16 */\r
  17 \r
  18 \r
  19 #include <asm/types.h>\r
  20 #include <linux/timer.h>\r
  21 #include <linux/workqueue.h>\r
  22 #include <linux/io.h>\r
  23 #include <linux/input-polldev.h>\r
  24 #include <linux/types.h>\r
  25 #include <linux/cdev.h>\r
  26 #include <linux/device.h>\r
  27 #include <linux/poll.h>\r
  28 //#include <mach/iomux.h>\r
  29 //#include <mach/gpio.h>\r
  30 //#include <mach/board.h>\r
  31 //#include <linux/wakelock.h>\r
  32 #include <linux/input.h>\r
  33 #include <linux/slab.h>\r
  34 #include <linux/init.h>\r
  35 #include <linux/i2c.h>\r
  36 #include <linux/pm.h>\r
  37 //#include <linux/earlysuspend.h>\r
  38 #include <linux/interrupt.h>\r
  39 #include <linux/delay.h>\r
  40 #include <linux/errno.h>\r
  41 #include <linux/kernel.h>\r
  42 #include <linux/module.h>\r
  43 #include <linux/platform_device.h>\r
  44 #include <linux/async.h>\r
  45 #include <linux/hrtimer.h>\r
  46 #include <linux/ioport.h>\r
  47 #include <linux/kthread.h>\r
  48 #include <linux/input/mt.h>\r
  49 #include <linux/fs.h> \r
  50 #include <linux/file.h> \r
  51 //#include <asm/irq.h>\r
  52 #include <asm/io.h>\r
  53 #include <asm/uaccess.h>\r
  54 \r
  55 //#include <mach/irqs.h>\r
  56 //#include <mach/system.h>\r
  57 //#include <mach/hardware.h>\r
  58 \r
  59 #include <linux/pinctrl/consumer.h>
  60 #include <linux/pinctrl/pinctrl.h>
  61 #include <linux/pinctrl/machine.h>\r
  62 #include <linux/of.h>
  63 #include <linux/of_gpio.h>\r
  64 #include <linux/timer.h>\r
  65 #include <linux/types.h>\r
  66 #include <linux/version.h>\r
  67 #include <linux/proc_fs.h>\r
  68 #include <linux/delay.h>\r
  69 #include <linux/input.h>\r
  70 #include <linux/gpio.h>\r
  71 #include <linux/sched.h>\r
  72 #include <linux/kthread.h>\r
  73 #include <linux/of_gpio.h>\r
  74 #include "../tp_suspend.h"\r
  75 \r
  76 \r
  77 #define X CONFIG_TOUCHSCREEN_ZET62xx_X\r
  78 #define Y CONFIG_TOUCHSCREEN_ZET62xx_Y\r
  79 \r
  80 #define CONFIG_RK3026_BOARD_AK47_V5_2\r
  81 \r
  82 #if defined( CONFIG_RK3026_BOARD_86V_BT )\r
  83     #include "zet6251_fw_rk3026_86v_bt.h"\r
  84     #include "zet6221_fw.h"\r
  85     #include "zet6223_fw.h"\r
  86     #include "zet6231_fw.h"\r
  87 #elif defined(CONFIG_RK3026_BOARD_TH785)\r
  88     #include "zet6251_fw_rk3026_th785.h"\r
  89     #include "zet6223_fw.h"\r
  90     #include "zet6221_fw.h"\r
  91     #include "zet6231_fw.h"
  92 #elif defined(CONFIG_RK3026_BOARD_W7)
  93     #include "zet6251_fw_rk3026_w7.h"\r
  94     #include "zet6221_fw.h"\r
  95     #include "zet6223_fw.h"\r
  96     #include "zet6231_fw.h"\r
  97 \r
  98 #elif defined(CONFIG_RK3026_BOARD_W8)\r
  99     #include "zet6223_fw_rk3026_w8.h"\r
 100     #include "zet6221_fw.h"\r
 101     #include "zet6251_fw.h"\r
 102     #include "zet6231_fw.h"\r
 103     \r
 104 #elif defined(CONFIG_RK3026_BOARD_W9)
 105     #include "zet6223_fw_rk3026_w9.h"    \r
 106     #include "zet6221_fw.h"\r
 107     #include "zet6251_fw.h"\r
 108     #include "zet6231_fw.h"\r
 109 \r
 110 #elif defined(CONFIG_RK3026_BOARD_W10)\r
 111     #include "zet6223_fw_rk3026_w10.h"  \r
 112     #include "zet6221_fw.h"\r
 113     #include "zet6251_fw.h"\r
 114     #include "zet6231_fw.h"\r
 115 \r
 116 #elif defined(CONFIG_RK3026_BOARD_AK47_V4_1)\r
 117     #include "zet6251_fw_ak47_v41.h"\r
 118     #include "zet6221_fw.h"\r
 119     #include "zet6223_fw.h"\r
 120     #include "zet6231_fw.h"\r
 121 \r
 122 #elif defined(CONFIG_RK3026_BOARD_AK47_V4_2)\r
 123     #include "zet6251_fw_ak47_v42.h"\r
 124     #include "zet6221_fw.h"\r
 125     #include "zet6223_fw.h"\r
 126     #include "zet6231_fw.h"\r
 127 \r
 128 #elif defined (CONFIG_RK3028A_BOARD_AK47H_V2_0)\r
 129     #include "zet6251_fw_ak47h_v20.h"\r
 130     #include "zet6221_fw.h"\r
 131     #include "zet6223_fw.h"\r
 132     #include "zet6231_fw.h"\r
 133         \r
 134 #elif defined(CONFIG_RK3026_BOARD_AK47_V5)\r
 135     #include "zet6251_fw_ak47_v5.h"\r
 136     #include "zet6221_fw.h"\r
 137     #include "zet6223_fw.h"\r
 138     #include "zet6231_fw.h"\r
 139 \r
 140 #elif defined(CONFIG_RK3026_BOARD_B52_V5)\r
 141     #include "zet6251_fw_b52_v5.h"\r
 142     #include "zet6221_fw.h"\r
 143     #include "zet6223_fw.h"\r
 144     #include "zet6231_fw.h"\r
 145         \r
 146 #elif defined(CONFIG_RK3026_BOARD_AK47_V5_2)\r
 147     #include "zet6251_fw_ak47_v52.h"\r
 148     #include "zet6221_fw.h"\r
 149     #include "zet6223_fw.h"\r
 150     #include "zet6231_fw.h"\r
 151         \r
 152 #elif defined(CONFIG_RK3026_BOARD_AK47_BT)\r
 153     #include "zet6251_fw_ak47_bt.h"\r
 154     #include "zet6221_fw.h"\r
 155     #include "zet6223_fw.h"\r
 156     #include "zet6231_fw.h"\r
 157         \r
 158 #elif defined(CONFIG_RK3026_BOARD_B52_V4_1)\r
 159     #include "zet6251_fw_b52_v41.h"\r
 160     #include "zet6221_fw.h"\r
 161     #include "zet6223_fw.h"\r
 162     #include "zet6231_fw.h"\r
 163 \r
 164 \r
 165 #elif defined(CONFIG_RK3026_BOARD_B52_V5_2)\r
 166     #include "zet6251_fw_b52_v52.h"\r
 167     #include "zet6221_fw.h"\r
 168     #include "zet6223_fw.h"\r
 169     #include "zet6231_fw.h"\r
 170         \r
 171 #elif defined(CONFIG_RK3026_BOARD_TH71)\r
 172     #include "zet6251_fw_th71.h"\r
 173     #include "zet6221_fw.h"\r
 174     #include "zet6223_fw.h"\r
 175     #include "zet6231_fw.h"\r
 176 #endif\r
 177 \r
 178 ///=============================================================================================///\r
 179 /// ò\8c\84Ó\99z²é±í(Checklist): Õ\88ÒÀ¿Í\91ôÐèÇó£¬\81í\9bQ¶¨ÏÂÁÐµÄºêÊÇ·ñ\91ªÔ\93é_\86¢»òêPé]\r
 180 ///=============================================================================================///\r
 181 ///---------------------------------------------------------------------------------///\r
 182 ///  1. FW Upgrade\r
 183 ///---------------------------------------------------------------------------------///\r
 184 #define FEATURE_FW_UPGRADE                      ///< \86¢\84ÓÏÂÝdÆ÷(downloader) ßMÐÐ¹Ì¼þ\9fýä\9b\r
 185 #ifdef FEATURE_FW_UPGRADE\r
 186         #define FEATURE_FW_SIGNATURE            ///< ¹Ì¼þ\9fý¾Gáá, \9fýÈëº\9eÕÂ\r
 187         #define FEATURE_FW_COMPARE              ///< ¹Ì¼þ\9fý¾Gáá£¬ßMÐÐ±È\8c¦\r
 188         //#define FEATURE_FW_UPGRADE_RESUME     ///< ÐÝÃß\86¾ÐÑáá£¬ÊÇ·ñßMÐÐ¹Ì¼þ\9fýä\9b\r
 189                 //#define FEATURE_FW_CHECK_SUM       ///< ZET6251 ÐÝÃß\86¾ÐÑáá£¬¹Ì¼þ\9fýä\9b±È\8c¦\r
 190         #define FEATURE_FW_SKIP_FF              ///< ¹Ì¼þ\9fý¾G\95r£¬·Å\97\89È«\9eé0xFFµÄí\93Ãæ\r
 191 #endif ///< for FEATURE_FW_UPGRADE\r
 192 \r
 193 ///---------------------------------------------------------------------------------///\r
 194 ///  2. Hardware check only and do no FW upgrade\r
 195 ///---------------------------------------------------------------------------------///\r
 196 //#define FEATURE_HW_CHECK_ONLY                 ///< [³ýåeÓÃ(debug)]\83H±È¹Ì¼þ\8c¦°æ£¬²»ßMÐÐ¹Ì¼þ\9fýä\9b\r
 197 \r
 198 ///---------------------------------------------------------------------------------///\r
 199 ///  3. Read TP information (B2 Command)\r
 200 ///---------------------------------------------------------------------------------///\r
 201 //#define FEATURE_TPINFO                                ///< \8fÄIC×xÂ ÊÖÖ¸\94µ£¬·Ö±æÂÊ¼°°´ä\9b\86¢\84Ó(B2Ö¸Áî£©\r
 202 \r
 203 ///---------------------------------------------------------------------------------///\r
 204 ///  4. Virtual key\r
 205 ///---------------------------------------------------------------------------------///\r
 206 //#define FEATURE_VIRTUAL_KEY                   ///< ò\8c\84ÓÌ\93\94M°´æIé_\86¢ £¨×¢Òâ£º·Ç¹Ì¼þ»òÊÇÓ²¼þ°´æI£© \r
 207 \r
 208 ///---------------------------------------------------------------------------------///\r
 209 ///  5. Multi-touch type B\r
 210 ///---------------------------------------------------------------------------------///\r
 211 #define FEATURE_MT_TYPE_B                       ///< °²×¿multitouch type B protocol£¬¿ÉÔößM\88óücÐ§ÂÊ (×¢Òâ£º ÅfÏµ½y²»Ö§³Ö£©\r
 212 //#define FEATURE_BTN_TOUCH                     ///< ÅfÏµ½y°´\89º¿ØÖÆ(ÌÓëxÉñ\8fR£©\r
 213 #ifdef FEATURE_MT_TYPE_B\r
 214         #define FEAURE_LIGHT_LOAD_REPORT_MODE   ///<   \9cpÉÙÖØÑ}µÄücÍùÉÏ\88ó£¬¿ÉÔößMÏµ½yÐ§ÄÜ\r
 215         #define PRESSURE_CONST  (1)             \r
 216 #endif ///< for FEATURE_MT_TYPE_B\r
 217 ///---------------------------------------------------------------------------------///\r
 218 ///  6. Hihg impedance mode (ZET6221)\r
 219 ///---------------------------------------------------------------------------------///\r
 220 //#define FEATURE_HIGH_IMPEDENCE_MODE           ///< ZET6221 high impedance Ä£Ê½é_\86¢\r
 221 \r
 222 ///---------------------------------------------------------------------------------///\r
 223 ///  7. Coordinate translation\r
 224 ///---------------------------------------------------------------------------------///\r
 225
 226 #if defined(CONFIG_RK3026_BOARD_JINGHUA)
 227     #if defined(CONFIG_RK3026_BOARD_W7)\r
 228         #elif defined( CONFIG_RK3026_BOARD_86V_BT )\r
 229     #else\r
 230          #define FEATURE_TRANSLATE_ENABLE       ///< ò\8c\84ÓÔücÞD\93Q¹¦ÄÜ(×¢Òâ£ºÕ\88Ê¹ÓÃ¹Ì¼þµÄÔücÞD\93Q)\r
 231     #endif\r
 232 #endif\r
 233 \r
 234 ///---------------------------------------------------------------------------------///\r
 235 ///  8. Auto Zoom translation\r
 236 ///---------------------------------------------------------------------------------///\r
 237 //#define FEATURE_AUTO_ZOOM_ENABLE                      ///< FW to driver XY auto zoom in\r
 238 \r
 239 ///---------------------------------------------------------------------------------///\r
 240 ///  9. Firmware download check the last page\r
 241 ///---------------------------------------------------------------------------------///\r
 242 //#define FEATURE_CHECK_LAST_PAGE               ///< Ôö¼Ó¹Ì¼þ×îááÒ»í\93±È\8c¦£¬\81í\9bQ¶¨ÊÇ·ñ\9fýä\9b \r
 243 \r
 244 ///---------------------------------------------------------------------------------///\r
 245 ///  10. Dummy report (without pull high resistor)\r
 246 ///---------------------------------------------------------------------------------///\r
 247 //#define FEATURE_DUMMY_REPORT                  ///< ÖØ\86¢áá£¬INTµÍÎ»\95r²»×xüc(\9foÉÏÀë\8a×è£¬Õ\88é_\86¢£©\r
 248 #ifdef FEATURE_DUMMY_REPORT\r
 249         #define SKIP_DUMMY_REPORT_COUNT         (1) ///< skip # times int low, if there is no pull high resistor, used 1\r
 250 #else ///< for FEATURE_FUMMY_REPORT\r
 251         #define SKIP_DUMMY_REPORT_COUNT         (0) ///< skip # times int low, if there is no pull high resistor, used 1\r
 252 #endif ///< for FEATURE_FUMMY_REPORT\r
 253 \r
 254 ///---------------------------------------------------------------------------------///\r
 255 ///  11. Finger number \r
 256 ///---------------------------------------------------------------------------------///\r
 257 #if defined(CONFIG_RK3026_BOARD_W8)\\r
 258 ||defined(CONFIG_RK3026_BOARD_W9)\\r
 259 ||defined(CONFIG_RK3026_BOARD_W10)\\r
 260 ||defined(CONFIG_RK3026_BOARD_TH785)\r
 261     #define FINGER_NUMBER                       (10)\r
 262 #else\r
 263     #define FINGER_NUMBER                       (5)\r
 264 #endif\r
 265 \r
 266 ///---------------------------------------------------------------------------------///\r
 267 ///  12. key number \r
 268 ///---------------------------------------------------------------------------------///\r
 269 #define KEY_NUMBER                              (0)             ///< ÔO¶¨°´ä\9b\94µ£¬ÈôÓÐé_TPINFO£¬\84tÒÔTPINFO\9eéÖ÷\r
 270 \r
 271 ///---------------------------------------------------------------------------------///\r
 272 ///  13. Finger up debounce count  \r
 273 ///---------------------------------------------------------------------------------///\r
 274 #define DEBOUNCE_NUMBER                         (1)             ///< ÊÕµ½\8e×´Î\9foÊÖÖ¸£¬\84t\94àµô¾\80£¬îAÔO1´Î \r
 275 \r
 276 ///=========================================================================================///\r
 277 ///  14. Device Name \r
 278 ///=========================================================================================///\r
 279 \r
 280 #define ZET_TS_ID_NAME                  "zet6221-ts"\r
 281 #define MJ5_TS_NAME                     "zet6221_touchscreen" ///< ZET_TS_ID_NAME\r
 282 \r
 283 /*\r
 284 #if defined(CONFIG_RK3026_BOARD_JINGHUA)\\r
 285 ||defined(CONFIG_RK3026_BOARD_TH71)            \r
 286     #define TS_RST_GPIO         RK30_PIN2_PB1\r
 287     #define TS_INT_GPIO         RK30_PIN1_PB0 \r
 288 #elif defined(CONFIG_RK3026_BOARD_AK47_V5)\\r
 289 ||defined(CONFIG_RK3026_BOARD_B52_V5)\r
 290     #define TS_RST_GPIO         RK30_PIN2_PB1\r
 291     #define TS_INT_GPIO         RK30_PIN1_PA1 \r
 292 #elif defined (CONFIG_RK3026_BOARD_AK47_V5_2)\\r
 293 ||defined(CONFIG_RK3026_BOARD_B52_V5_2)\\r
 294 ||defined(CONFIG_RK3026_BOARD_AK47_BT)\r
 295     #define TS_RST_GPIO         RK30_PIN0_PA0\r
 296     #define TS_INT_GPIO         RK30_PIN0_PA1 \r
 297 #elif defined(CONFIG_RK3026_BOARD_TH785)\r
 298     #define TS_RST_GPIO         RK30_PIN2_PB2//RK30_PIN2_PB1 //RK2928_PIN3_PC3\r
 299     #define TS_INT_GPIO         RK30_PIN1_PA1 \r
 300 #elif defined (CONFIG_RK3028A_BOARD_AK47H_V2_0)\r
 301     #define TS_RST_GPIO         RK30_PIN3_PC3//RK30_PIN2_PB1 //RK2928_PIN3_PC3\r
 302     #define TS_INT_GPIO         RK30_PIN3_PC7 // RK2928_PIN_PC7\r
 303 #else\r
 304     #define TS_RST_GPIO         RK30_PIN0_PA0//RK30_PIN2_PB1 //RK2928_PIN3_PC3\r
 305     #define TS_INT_GPIO         RK30_PIN1_PB0 // RK2928_PIN_PC7\r
 306 #endif\r
 307 */\r
 308 \r
 309 /*\r
 310         GPIO0_A0/I2C0_SCL   TP_RST\r
 311         GPIO0_A1/I2C0_SDA       TP_INT\r
 312  */\r
 313 #define TS_RST_GPIO             0\r
 314 #define TS_INT_GPIO             1 \r
 315 ///=========================================================================================///\r
 316 ///  15.Charge mode  \r
 317 ///=========================================================================================///\r
 318 //#define FEATURE_CHARGER_MODE          ///< Õ\88ÐÞ¸ÄAXP20-sply.c£¬\8c¢³äë\8aÄ£Ê½\86¢\84Ó\r
 319 \r
 320 #ifdef FEATURE_CHARGER_MODE\r
 321 extern int charger_on;                  ///< Õ\88ÔÚAXP20-sply.cÖÐÐû¸æ´Ë×\83Á¿£¬\81KÔÚ³äë\8a\95r£¬\8c¢Ö®ÔO\9eé1£¬·´Ö®0\r
 322 #else ///< FEATURE_CHARGER_MODE\r
 323 int charger_on  = 0;                    ///< È«ÔO0£¬\9fo³äë\8aÄ£Ê½¹¦ÄÜ\r
 324 #endif ///< for FEATURE_CHARGER_MODE\r
 325 \r
 326 ///---------------------------------------------------------------------------------///\r
 327 ///  16. IOCTRL Debug\r
 328 ///---------------------------------------------------------------------------------///\r
 329 #define FEATURE_IDEV_OUT_ENABLE\r
 330 #define FEATURE_MBASE_OUT_ENABLE\r
 331 #define FEATURE_MDEV_OUT_ENABLE\r
 332 #define FEATURE_INFO_OUT_EANBLE\r
 333 #define FEATURE_IBASE_OUT_ENABLE\r
 334 #define FEATURE_FPC_OPEN_ENABLE\r
 335 #define FEATURE_FPC_SHORT_ENABLE\r
 336 \r
 337 ///---------------------------------------------------------------------------------///\r
 338 ///  17. TRACE SETTING GPIO  \r
 339 ///---------------------------------------------------------------------------------///\r
 340 #define FEATURE_TRACE_SETTING_GPIO\r
 341 #ifdef FEATURE_TRACE_SETTING_GPIO\r
 342         #define FEATRUE_TRACE_GPIO_OUTPUT\r
 343         #define FEATRUE_TRACE_GPIO_INPUT\r
 344         #ifdef FEATRUE_TRACE_GPIO_INPUT\r
 345                 //#define FEATRUE_TRACE_SENSOR_ID\r
 346         #endif ///< for FEATRUE_TRACE_GPIO_INPUT\r
 347 #endif ///< for FEATURE_TRACE_SETTING_GPIO\r
 348 \r
 349 #ifdef FEATRUE_TRACE_SENSOR_ID\r
 350         #include "zet6223_fw_01.h"\r
 351         #include "zet6223_fw_02.h"\r
 352         #include "zet6223_fw_03.h"\r
 353         #include "zet6231_fw_01.h"\r
 354         #include "zet6231_fw_02.h"\r
 355         #include "zet6231_fw_03.h"\r
 356         #include "zet6251_fw_01.h"\r
 357         #include "zet6251_fw_02.h"\r
 358         #include "zet6251_fw_03.h"\r
 359 #endif ///< for FEATURE_TRACE_SETTING_GPIO\r
 360 ///---------------------------------------------------------------------------------///\r
 361 ///  20. suspend/resume clean finger\r
 362 ///---------------------------------------------------------------------------------///\r
 363 #define FEATURE_SUSPEND_CLEAN_FINGER\r
 364 \r
 365 ///  21. int pin free \r
 366 ///---------------------------------------------------------------------------------///\r
 367 //#define FEATURE_INT_FREE\r
 368 \r
 369 ///---------------------------------------------------------------------------------///\r
 370 ///  22. Fram rate\r
 371 ///---------------------------------------------------------------------------------///\r
 372 #define FEATURE_FRAM_RATE\r
 373 \r
 374 \r
 375 \r
 376 ///=============================================================================================///\r
 377 /// ò\8c\84Ó\99z²é±í½YÊø\r
 378 ///=============================================================================================///\r
 379 ///=============================================================================================///\r
 380 /// Reset Timing \r
 381 ///=============================================================================================///\r
 382 #define TS_RESET_LOW_PERIOD                     (1)             ///< é_\99CÖØ\86¢£º RST \8fÄ¸ßÎ»ÞDµÍÎ»³ÖÀm1msÔÙ\8fÍ¸ßÎ»\r
 383 #define TS_INITIAL_HIGH_PERIOD                  (30)            ///< é_\86¢ÖØ\86¢£º ³ÐÉÏ£¬RST ÞD¸ßÎ»áá£¬ÌØÀm30ms\r
 384 #define TS_WAKEUP_LOW_PERIOD                    (10)            ///< \86¾ÐÑÖØ\86¢£º RST \8fÄ¸ßÎ»ÞDµÍÎ»³ÖÀm20msÔÙ\8fÍ¸ßÎ» \r
 385 #define TS_WAKEUP_HIGH_PERIOD                   (20)            ///< \86¾ÐÑÖØ\86¢£º ³ÐÉÏ£¬RST ÞD¸ßÎ»áá£¬ÌØÀm20m\r
 386 \r
 387 ///=============================================================================================///\r
 388 /// Device numbers\r
 389 ///=============================================================================================///\r
 390 #define I2C_MINORS                              (256)           ///< ¸±ÑbÖÃ´aÉÏÏÞ\r
 391 #define I2C_MAJOR                               (126)           ///< Ö÷ÑbÖÃ´a\r
 392 \r
 393 ///=============================================================================================///\r
 394 /// Flash control Definition\r
 395 ///=============================================================================================///\r
 396 #define CMD_WRITE_PASSWORD                      (0x20)\r
 397         #define CMD_PASSWORD_HIBYTE                     (0xC5)\r
 398         #define CMD_PASSWORD_LOBYTE                     (0x9D)\r
 399 \r
 400         #define CMD_PASSWORD_1K_HIBYTE                  (0xB9)\r
 401         #define CMD_PASSWORD_1K_LOBYTE                  (0xA3)\r
 402         \r
 403         #define CMD_WRITE_PASSWORD_LEN                  (3)\r
 404 #define CMD_WRITE_CODE_OPTION                   (0x21)\r
 405 #define CMD_WRITE_PROGRAM                       (0x22)\r
 406 #define CMD_PAGE_ERASE                          (0x23)\r
 407         #define CMD_PAGE_ERASE_LEN                      (2)\r
 408 #define CMD_MASS_ERASE                          (0x24)\r
 409 #define CMD_PAGE_READ_PROGRAM                   (0x25)\r
 410         #define CMD_PAGE_READ_PROGRAM_LEN               (2)\r
 411 #define CMD_MASS_READ_PROGRAM                   (0x26)\r
 412 #define CMD_READ_CODE_OPTION                    (0x27)\r
 413 #define CMD_ERASE_CODE_OPTION                   (0x28)\r
 414 #define CMD_RESET_MCU                           (0x29)\r
 415 #define CMD_OUTPUT_CLOCK                        (0x2A)\r
 416 #define CMD_WRITE_SFR                           (0x2B)\r
 417 #define CMD_READ_SFR                            (0x2C)\r
 418         #define SFR_UNLOCK_FLASH                        (0x3D)\r
 419         #define SFR_LOCK_FLASH                          (0x7D)  \r
 420 #define CMD_ERASE_SPP                           (0x2D)\r
 421 #define CMD_WRITE_SPP                           (0x2E)\r
 422 #define CMD_READ_SPP                            (0x2F)\r
 423 #define CMD_PROG_INF                            (0x30)\r
 424 #define CMD_PROG_MAIN                           (0x31)\r
 425 #define CMD_PROG_CHECK_SUM                      (0x36)\r
 426 #define CMD_PROG_GET_CHECK_SUM                  (0x37)\r
 427 #define CMD_OUTPUT_CLOCK1                       (0x3B)\r
 428 #define CMD_FILL_FIFO                           (0x60)\r
 429 #define CMD_READ_FIFO                           (0x61)\r
 430 \r
 431 #define FLASH_PAGE_LEN                          (128)\r
 432 \r
 433 \r
 434 #define  FLASH_SIZE_ZET6221                     (0x4000)\r
 435 #define  FLASH_SIZE_ZET6223                     (0x10000)\r
 436 #define  FLASH_SIZE_ZET6231                     (0x8000)\r
 437 \r
 438 ///=============================================================================================///\r
 439 /// GPIO Input/Output command\r
 440 ///=============================================================================================///\r
 441 #define GPIO_TRACE_OUTPUT_SET                   (0xD0)\r
 442 #define GPIO_TRACE_OUTPUT_GET                   (0xD1)\r
 443 #define GPIO_TRACE_OUTPUT_CNT                   (0xD2)\r
 444         #define TRACE_GPIO1_INDEX                       (0x01)\r
 445         #define TRACE_GPIO2_INDEX                       (0x02)\r
 446         #define TRACE_GPIO3_INDEX                       (0x04)\r
 447         #define TRACE_GPIO4_INDEX                       (0x08)\r
 448         #define TRACE_GPIO5_INDEX                       (0x10)\r
 449         #define TRACE_GPIO6_INDEX                       (0x20)  \r
 450         #define TRACE_GPIO7_INDEX                       (0x40)\r
 451         #define TRACE_GPIO8_INDEX                       (0x80)\r
 452 #define GPIO_TRACE_INPUT_GET                    (0xD3)\r
 453 #define GPIO_TRACE_INPUT_CNT                    (0xD4)\r
 454         #define SENID_00                                (0x00)\r
 455         #define SENID_01                                (0x01)\r
 456         #define SENID_02                                (0x02)\r
 457         #define SENID_03                                (0x03)  \r
 458 ///=============================================================================================///\r
 459 /// Macro Definition\r
 460 ///=============================================================================================///\r
 461 #define MAX_FLASH_BUF_SIZE                      (0x10000)\r
 462 #define MAX_DATA_FLASH_BUF_SIZE                 (0x400)\r
 463 #define DATA_FLASH_START_ADDR                   (0x7C00)\r
 464 #define SENSOR_ID_INDEX_ADDR                    (0x7C8E)\r
 465 #define DATA_FLASH_START_ID                     (248)\r
 466 #define SENID_MAX_CNT                           (4)\r
 467 #define SENID_MAX_INDEX                         (15)\r
 468 #define PROJECT_CODE_MAX_CNT                    (8)\r
 469 #define FINGER_REPROT_DATA_HEADER               (0x3C)\r
 470 #define INT_FREE_DATA_HEADER                    (0x3B)\r
 471 #define FINGER_PACK_SIZE                        (4)\r
 472 #define FINGER_HEADER_SHIFT                     (3)\r
 473 /// for debug INT\r
 474 #define GPIO_BASE                               (0x01c20800)\r
 475 #define GPIO_RANGE                              (0x400)\r
 476 #define PH2_CTRL_OFFSET                         (0x104)\r
 477 #define PH_DATA_OFFSET                          (0x10c)\r
 478 \r
 479 ///=========================================================================================///\r
 480 ///  TP related define : configured for all tp\r
 481 ///=========================================================================================///\r
 482 \r
 483 /// Boolean definition\r
 484 #define TRUE                                    (1)\r
 485 #define FALSE                                   (0)\r
 486 \r
 487 /// Origin definition\r
 488 #define ORIGIN_TOP_RIGHT                        (0)\r
 489 #define ORIGIN_TOP_LEFT                         (1)\r
 490 #define ORIGIN_BOTTOM_RIGHT                     (2)\r
 491 #define ORIGIN_BOTTOM_LEFT                      (3)\r
 492 \r
 493 #define ORIGIN                                  (ORIGIN_BOTTOM_RIGHT)\r
 494 \r
 495 /// Max key number\r
 496 #define MAX_KEY_NUMBER                          (8)\r
 497 \r
 498 /// Max finger number\r
 499 #define MAX_FINGER_NUMBER                       (16)\r
 500 /*\r
 501 /// X, Y Resolution\r
 502 #define FW_X_RESOLUTION         (X)             ///< the FW setting X resolution\r
 503 #define FW_Y_RESOLUTION         (Y)     ///< the FW setting Y resolution\r
 504 #define X_MAX                           (X)             ///< the X resolution of TP AA(Action Area)\r
 505 #define Y_MAX                           (Y)     ///< the Y resolution of TP AA(Action Area)\r
 506 */\r
 507 \r
 508 /// X, Y Resolution\r
 509 #define FW_X_RESOLUTION                         (1024)          ///< the FW setting X resolution\r
 510 #define FW_Y_RESOLUTION                         (600)           ///< the FW setting Y resolution\r
 511 #define X_MAX                                   (800)           ///< the X resolution of TP AA(Action Area)\r
 512 #define Y_MAX                                   (480)           ///< the Y resolution of TP AA(Action Area)\r
 513 \r
 514 \r
 515 ///=========================================================================================///\r
 516 ///  Model Type\r
 517 ///=========================================================================================///\r
 518 #define MODEL_ZET6221                           (0)\r
 519 #define MODEL_ZET6223                           (1)\r
 520 #define MODEL_ZET6231                           (2)\r
 521 #define MODEL_ZET6241                           (3)\r
 522 #define MODEL_ZET6251                           (4)\r
 523 \r
 524 ///=========================================================================================///\r
 525 ///  Rom Type\r
 526 ///=========================================================================================///\r
 527 #define ROM_TYPE_UNKNOWN                        (0x00)\r
 528 #define ROM_TYPE_SRAM                           (0x02)\r
 529 #define ROM_TYPE_OTP                            (0x06)\r
 530 #define ROM_TYPE_FLASH                          (0x0F)\r
 531 \r
 532 ///=========================================================================================///\r
 533 ///  Working queue error number\r
 534 ///=========================================================================================///\r
 535 #define ERR_WORK_QUEUE_INIT_FAIL                (100)\r
 536 #define ERR_WORK_QUEUE1_INIT_FAIL               (101)\r
 537 \r
 538 ///=========================================================================================///\r
 539 ///  Virtual Key\r
 540 ///=========================================================================================///\r
 541 #ifdef FEATURE_VIRTUAL_KEY\r
 542   #define TP_AA_X_MAX                           (480)   ///< X resolution of TP VA(View Area)\r
 543   #define TP_AA_Y_MAX                           (600)   ///< Y resolution of TP VA(View Area)\r
 544 #endif ///< for FEATURE_VIRTUAL_KEY\r
 545 \r
 546 ///=========================================================================================///\r
 547 ///  Impedance byte\r
 548 ///=========================================================================================///\r
 549 #define IMPEDENCE_BYTE                          (0xf1)  ///< High Impendence Mode : (8M) 0xf1 (16M) 0xf2 \r
 550 \r
 551 #define P_MAX                                   (255)\r
 552 #define S_POLLING_TIME                          (100)\r
 553 \r
 554 ///=========================================================================================///\r
 555 ///  Signature\r
 556 ///=========================================================================================///\r
 557 #ifdef FEATURE_FW_SIGNATURE\r
 558 #define SIG_PAGE_ID                             (255)   ///< º\9eÕÂËùÔÚµÄí\93\r
 559 #define SIG_DATA_ADDR                           (128  - SIG_DATA_LEN)   ///< º\9eÕÂËùÔÚµÄÎ»Ö·\r
 560 #define SIG_DATA_LEN                            (4)     ///< º\9eÕÂËùÔÚµÄí\93\r
 561 static const u8 sig_data[SIG_DATA_LEN]          = {'Z', 'e', 'i', 'T'};\r
 562 #endif ///< for FEATURE_FW_SIGNATURE\r
 563 \r
 564 ///=============================================================================================///\r
 565 /// IOCTL control Definition\r
 566 ///=============================================================================================///\r
 567 #define ZET_IOCTL_CMD_FLASH_READ                (20)\r
 568 #define ZET_IOCTL_CMD_FLASH_WRITE               (21)\r
 569 #define ZET_IOCTL_CMD_RST                       (22)\r
 570 #define ZET_IOCTL_CMD_RST_HIGH                  (23)\r
 571 #define ZET_IOCTL_CMD_RST_LOW                   (24)\r
 572 \r
 573 #define ZET_IOCTL_CMD_DYNAMIC                   (25)\r
 574 \r
 575 #define ZET_IOCTL_CMD_FW_FILE_PATH_GET          (26)\r
 576 #define ZET_IOCTL_CMD_FW_FILE_PATH_SET          (27)\r
 577 \r
 578 #define ZET_IOCTL_CMD_MDEV                      (28)\r
 579 #define ZET_IOCTL_CMD_MDEV_GET                  (29)\r
 580 \r
 581 #define ZET_IOCTL_CMD_TRAN_TYPE_PATH_GET        (30)\r
 582 #define ZET_IOCTL_CMD_TRAN_TYPE_PATH_SET        (31)\r
 583 \r
 584 #define ZET_IOCTL_CMD_IDEV                      (32)\r
 585 #define ZET_IOCTL_CMD_IDEV_GET                  (33)\r
 586 \r
 587 #define ZET_IOCTL_CMD_MBASE                     (34)\r
 588 #define ZET_IOCTL_CMD_MBASE_GET                 (35)\r
 589 \r
 590 #define ZET_IOCTL_CMD_INFO_SET                  (36)\r
 591 #define ZET_IOCTL_CMD_INFO_GET                  (37)\r
 592 \r
 593 #define ZET_IOCTL_CMD_TRACE_X_SET               (38)\r
 594 #define ZET_IOCTL_CMD_TRACE_X_GET               (39)\r
 595 \r
 596 #define ZET_IOCTL_CMD_TRACE_Y_SET               (40)\r
 597 #define ZET_IOCTL_CMD_TRACE_Y_GET               (41)\r
 598 \r
 599 #define ZET_IOCTL_CMD_IBASE                     (42)\r
 600 #define ZET_IOCTL_CMD_IBASE_GET                 (43)\r
 601 \r
 602 #define ZET_IOCTL_CMD_DRIVER_VER_GET            (44)\r
 603 #define ZET_IOCTL_CMD_MBASE_EXTERN_GET          (45)\r
 604 \r
 605 #define ZET_IOCTL_CMD_GPIO_HIGH                 (46)\r
 606 #define ZET_IOCTL_CMD_GPIO_LOW                  (47)\r
 607 \r
 608 #define ZET_IOCTL_CMD_SENID_GET                 (48)\r
 609 #define ZET_IOCTL_CMD_PCODE_GET                 (49)\r
 610 \r
 611 #define ZET_IOCTL_CMD_TRACE_X_NAME_SET          (50)\r
 612 #define ZET_IOCTL_CMD_TRACE_X_NAME_GET          (51)\r
 613 \r
 614 #define ZET_IOCTL_CMD_TRACE_Y_NAME_SET          (52)\r
 615 #define ZET_IOCTL_CMD_TRACE_Y_NAME_GET          (53)\r
 616 \r
 617 #define ZET_IOCTL_CMD_WRITE_CMD         (54)\r
 618 #define ZET_IOCTL_CMD_UI_FINGER         (55)\r
 619 \r
 620 #define ZET_IOCTL_CMD_FRAM_RATE         (56)\r
 621 \r
 622 #define ZET_IOCTL_CMD_FPC_OPEN_SET              (57)\r
 623 #define ZET_IOCTL_CMD_FPC_OPEN_GET              (58)\r
 624 \r
 625 #define ZET_IOCTL_CMD_FPC_SHORT_SET             (59)\r
 626 #define ZET_IOCTL_CMD_FPC_SHORT_GET             (60)\r
 627 \r
 628 #define IOCTL_MAX_BUF_SIZE                      (1024)\r
 629 \r
 630 ///----------------------------------------------------///\r
 631 /// IOCTL ACTION\r
 632 ///----------------------------------------------------///\r
 633 #define IOCTL_ACTION_NONE                       (0)\r
 634 #define IOCTL_ACTION_FLASH_DUMP                 (1<<0)\r
 635 \r
 636 static int ioctl_action = IOCTL_ACTION_NONE;\r
 637 \r
 638 ///=============================================================================================///\r
 639 ///  Transfer type\r
 640 ///=============================================================================================///\r
 641 #define TRAN_TYPE_DYNAMIC                       (0x00)\r
 642 #define TRAN_TYPE_MUTUAL_SCAN_BASE              (0x01)\r
 643 #define TRAN_TYPE_MUTUAL_SCAN_DEV               (0x02)\r
 644 #define TRAN_TYPE_INIT_SCAN_BASE                (0x03)\r
 645 #define TRAN_TYPE_INIT_SCAN_DEV                 (0x04)\r
 646 #define TRAN_TYPE_KEY_MUTUAL_SCAN_BASE          (0x05)\r
 647 #define TRAN_TYPE_KEY_MUTUAL_SCAN_DEV           (0x06)\r
 648 #define TRAN_TYPE_KEY_DATA                      (0x07)\r
 649 #define TRAN_TYPE_MTK_TYPE                      (0x0A)\r
 650 #define TRAN_TYPE_FOCAL_TYPE                    (0x0B)\r
 651 #define TRAN_TYPE_INFORMATION_TYPE              (0x0C)\r
 652 #define TRAN_TYPE_TRACE_X_TYPE                  (0x0D)\r
 653 #define TRAN_TYPE_TRACE_Y_TYPE                  (0x0E)\r
 654 #define TRAN_TYPE_FPC_OPEN                      (0x0F)\r
 655 #define TRAN_TYPE_FPC_SHORT                     (0x10)\r
 656 \r
 657 ///=============================================================================================///\r
 658 ///  TP Trace,APKµ÷ÊÔËùÓÃÇý¶¯\r
 659 ///=============================================================================================///\r
 660 #if defined(CONFIG_RK3026_BOARD_TH785)\r
 661 #define TP_DEFAULT_ROW (20)\r
 662 #define TP_DEFAULT_COL (12)\r
 663 #else\r
 664 #define TP_DEFAULT_ROW                          (15)\r
 665 #define TP_DEFAULT_COL                          (10)\r
 666 #endif\r
 667 ///=============================================================================================///\r
 668 ///  Fram rate definition\r
 669 ///=============================================================================================///\r
 670 #define FRAM_RATE_TIMER                         (1000)\r
 671 #define INT_FREE_TIMER                          (5)\r
 672 ///=========================================================================================///\r
 673 /// TP related parameters \r
 674 ///=========================================================================================///\r
 675 \r
 676 /// resolutions setting\r
 677 static u16 resolution_x         = X_MAX;\r
 678 static u16 resolution_y         = Y_MAX;\r
 679 \r
 680 /// Finger and key\r
 681 static u16 finger_num           = 0;\r
 682 static u16 key_num              = 0;\r
 683 static int finger_packet_size   = 0;    ///< Finger packet buffer size  \r
 684 \r
 685 static u8 xy_exchange           = 0;\r
 686 static u16 finger_up_cnt        = 0;    ///< recieved # finger up count\r
 687 \r
 688 static u8 pcode[8];                     ///< project code[] from b2\r
 689 static u8 sfr_data[16]          = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \r
 690                                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};\r
 691 \r
 692 static u8 ic_model              = MODEL_ZET6251;        ///< MODEL_ZET6221, MODE_ZET6223, MODEL_ZET6231\r
 693 #define DRIVER_VERSION "$Revision: 25 $"\r
 694 \r
 695 ///=========================================================================================///\r
 696 ///  the light load report mode\r
 697 ///=========================================================================================///\r
 698 #ifdef FEAURE_LIGHT_LOAD_REPORT_MODE\r
 699 #define PRE_PRESSED_DEFAULT_VALUE            (-1)\r
 700 struct light_load_report_mode\r
 701 {\r
 702         u32 pre_x;\r
 703         u32 pre_y;\r
 704         u32 pre_z;\r
 705         int pressed;\r
 706 };\r
 707 static struct light_load_report_mode pre_event[MAX_FINGER_NUMBER];\r
 708 #endif ///< for  FEAURE_LIGHT_LOAD_REPORT_MODE\r
 709 \r
 710 ///=============================================================================================///\r
 711 /// Macro Definition\r
 712 ///=============================================================================================///\r
 713 struct finger_coordinate_struct\r
 714 {\r
 715         u32 report_x;\r
 716         u32 report_y;\r
 717         u32 report_z;\r
 718         u32 last_report_x;\r
 719         u32 last_report_y;\r
 720         u32 last_report_z;\r
 721         u32 coordinate_x;\r
 722         u32 coordinate_y;\r
 723         u32 last_coordinate_x;\r
 724         u32 last_coordinate_y;\r
 725         u32 predicted_coordinate_x;\r
 726         u32 predicted_coordinate_y;\r
 727         u32 last_distance;\r
 728         u8 valid;\r
 729 };\r
 730 static struct finger_coordinate_struct finger_report[MAX_FINGER_NUMBER];\r
 731 static u8 finger_report_key;\r
 732 \r
 733 #ifdef FEATURE_FRAM_RATE\r
 734 static u32 fram_rate =0;\r
 735 static u32 last_fram_rate = 0;\r
 736 #endif ///< for FEATURE_FRAM_RATE\r
 737 \r
 738 struct timer_list write_timer; ///<  write_cmd\r
 739 \r
 740 struct i2c_dev\r
 741 {\r
 742         struct list_head list;  \r
 743         struct i2c_adapter *adap;\r
 744         struct device *dev;\r
 745 };\r
 746 \r
 747 static struct class *i2c_dev_class;\r
 748 static LIST_HEAD (i2c_dev_list);\r
 749 static DEFINE_SPINLOCK(i2c_dev_list_lock);\r
 750 \r
 751 static union\r
 752 {\r
 753         unsigned short          dirty_addr_buf[2];\r
 754         const unsigned short    normal_i2c[2];\r
 755 }u_i2c_addr = {{0x00},};\r
 756 \r
 757 ///----------------------------------------------------///\r
 758 /// FW variables\r
 759 ///----------------------------------------------------///\r
 760 static u16 pcode_addr[8]        = {0x3DF1,0x3DF4,0x3DF7,0x3DFA,0x3EF6,0x3EF9,0x3EFC,0x3EFF}; ///< default pcode addr: zet6221\r
 761 static u16 pcode_addr_6221[8]   = {0x3DF1,0x3DF4,0x3DF7,0x3DFA,0x3EF6,0x3EF9,0x3EFC,0x3EFF}; ///< zet6221 pcode_addr[8]\r
 762 static u16 pcode_addr_6223[8]   = {0x7BFC,0x7BFD,0x7BFE,0x7BFF,0x7C04,0x7C05,0x7C06,0x7C07}; ///< zet6223 pcode_addr[8]\r
 763 \r
 764 static int dummy_report_cnt     = 0;\r
 765 static int charger_status       = 0;    ///< 0 : discharge,  1 : charge\r
 766 static u16 polling_time         = S_POLLING_TIME;\r
 767 static u8 hover_status          = 0;\r
 768 \r
 769 static u8 download_ok           = FALSE;\r
 770 \r
 771 ///-------------------------------------///\r
 772 /// key variables\r
 773 ///-------------------------------------///\r
 774 static u8 key_menu_pressed      = 0x00; ///< key#0\r
 775 static u8 key_back_pressed      = 0x00; ///< key#1\r
 776 static u8 key_home_pressed      = 0x00; ///< key#2\r
 777 static u8 key_search_pressed    = 0x00; ///< key#3\r
 778 \r
 779 static u8 zet_tx_data[131];\r
 780 static u8 zet_rx_data[131];\r
 781 struct zet622x_tsdrv *zet62xx_ts;\r
 782 \r
 783 static u8 firmware_upgrade      = TRUE; \r
 784 static u8 rom_type              = ROM_TYPE_FLASH; ///< Flash:0xf SRAM:0x2 OTP:0x6\r
 785 \r
 786 ///---------------------------------------------------------------------------------///\r
 787 /// trace setting GPIO\r
 788 ///---------------------------------------------------------------------------------///\r
 789 #ifdef FEATRUE_TRACE_GPIO_OUTPUT\r
 790 static u8 trace_output_status = 0;\r
 791 #endif ///< for FEATRUE_TRACE_GPIO_OUTPUT\r
 792 #ifdef FEATRUE_TRACE_GPIO_INPUT\r
 793 static u8 trace_input_status = 0;\r
 794 #endif ///< for FEATRUE_TRACE_GPIO_INPUT\r
 795 #ifdef FEATRUE_TRACE_SENSOR_ID\r
 796 static u8 sensor_id_status = 0xFF;\r
 797 static u8 sensor_id = 0x0;\r
 798 #endif ///< for FEATRUE_TRACE_SENSOR_ID\r
 799 \r
 800 \r
 801 ///=========================================================================================///\r
 802 /// suspend no read any finger packet\r
 803 ///=========================================================================================///\r
 804 static u8 suspend_mode          = FALSE;\r
 805 \r
 806 ///=========================================================================================///\r
 807 /// resume wait download finish then send charger mode\r
 808 ///=========================================================================================///\r
 809 static u8 resume_download       = FALSE;\r
 810 #ifdef FEATURE_VIRTUAL_KEY\r
 811 static int tpd_keys_dim[4][4] = \r
 812 {\r
 813 ///     {X_LEFT_BOUNDARY,X_RIGHT_BOUNDARY,Y_TOP_BOUNDARY,Y_BOTTOM_BOUNDARY}\r
 814         {33, 122, 897, 1019},\r
 815         {184, 273, 879, 1019},\r
 816         {363, 451, 879, 1019},  \r
 817         {527, 615, 879, 1019},  \r
 818 };\r
 819 #endif ///< for FEATURE_VIRTUAL_KEY\r
 820 \r
 821 #ifdef FEATURE_HW_CHECK_ONLY\r
 822         #ifndef FEATURE_FW_UPGRADE\r
 823                 #define FEATURE_FW_UPGRADE\r
 824         #endif ///< for FEATURE_FW_UPGRADE\r
 825         firmware_upgrade = FALSE;\r
 826 #endif ///< for FEATURE_HW_CHECK_ONLY\r
 827 \r
 828 ///-------------------------------------///\r
 829 ///  firmware save / load\r
 830 ///-------------------------------------///\r
 831 u32 data_offset                         = 0;\r
 832 u8 *flash_buffer                        = NULL;\r
 833 u8 *flash_buffer_01                     = NULL;\r
 834 u8 *flash_buffer_02                     = NULL;\r
 835 u8 *flash_buffer_03                     = NULL;\r
 836 struct inode *inode                     = NULL;\r
 837 mm_segment_t old_fs;\r
 838 \r
 839 char driver_version[128];\r
 840 char pcode_version[128];\r
 841 \r
 842 #define FW_FILE_NAME                    "/system/vendor/zet62xx.bin"\r
 843 u8 chk_have_bin_file  = FALSE;\r
 844 char fw_file_name[128];\r
 845 ///-------------------------------------///\r
 846 ///  Transmit Type Mode Path parameters \r
 847 ///-------------------------------------///\r
 848 ///  External SD-Card could be\r
 849 ///      "/mnt/sdcard/"\r
 850 ///      "/mnt/extsd/"\r
 851 ///-------------------------------------///\r
 852 #define TRAN_MODE_FILE_PATH             "/mnt/sdcard/"\r
 853 char tran_type_mode_file_name[128];\r
 854 u8 *tran_data = NULL;\r
 855 \r
 856 ///-------------------------------------///\r
 857 ///  Mutual Dev Mode  parameters \r
 858 ///-------------------------------------///\r
 859 ///  External SD-Card could be\r
 860 ///      "/mnt/sdcard/zetmdev"\r
 861 ///      "/mnt/extsd/zetmdev"\r
 862 ///-------------------------------------///\r
 863 #ifdef FEATURE_MDEV_OUT_ENABLE\r
 864         #define MDEV_FILE_NAME          "zetmdev"\r
 865         #define MDEV_MAX_FILE_ID        (10)\r
 866         #define MDEV_MAX_DATA_SIZE      (2048)\r
 867 ///-------------------------------------///\r
 868 ///  mutual dev variables\r
 869 ///-------------------------------------///\r
 870         u8 *mdev_data = NULL;\r
 871         int mdev_file_id = 0;\r
 872 #endif ///< FEATURE_MDEV_OUT_ENABLE\r
 873 \r
 874 ///-------------------------------------///\r
 875 ///  Initial Base Mode  parameters \r
 876 ///-------------------------------------///\r
 877 ///  External SD-Card could be\r
 878 ///      "/mnt/sdcard/zetibase"\r
 879 ///      "/mnt/extsd/zetibase"\r
 880 ///-------------------------------------///\r
 881 #ifdef FEATURE_IBASE_OUT_ENABLE\r
 882         #define IBASE_FILE_NAME         "zetibase"\r
 883         #define IBASE_MAX_FILE_ID       (10)\r
 884         #define IBASE_MAX_DATA_SIZE     (512)\r
 885 \r
 886 ///-------------------------------------///\r
 887 ///  initial base variables\r
 888 ///-------------------------------------///\r
 889         u8 *ibase_data = NULL;\r
 890         int ibase_file_id = 0;\r
 891 #endif ///< FEATURE_IBASE_OUT_ENABLE\r
 892 \r
 893 #ifdef FEATURE_FPC_OPEN_ENABLE\r
 894         #define FPC_OPEN_FILE_NAME              "zetfpcopen"\r
 895         #define FPC_OPEN_MAX_FILE_ID            (10)\r
 896         #define FPC_OPEN_MAX_DATA_SIZE  (512)\r
 897         #define FPC_OPEN_CMD_LEN                (1)\r
 898         #define FPC_OPEN_CMD                    (0xA1)\r
 899 ///-------------------------------------///\r
 900 ///  fpc open variables\r
 901 ///-------------------------------------///\r
 902         u8 *fpcopen_data = NULL;\r
 903         int fpcopen_file_id = 0;\r
 904 #endif ///< FEATURE_FPC_OPEN_ENABLE\r
 905 \r
 906 #ifdef FEATURE_FPC_SHORT_ENABLE\r
 907         #define FPC_SHORT_FILE_NAME             "zetfpcshort"\r
 908         #define FPC_SHORT_MAX_FILE_ID           (10)\r
 909         #define FPC_SHORT_MAX_DATA_SIZE (512)\r
 910         #define FPC_SHORT_CMD_LEN               (1)\r
 911         #define FPC_SHORT_CMD                   (0xA0)\r
 912         \r
 913 ///-------------------------------------///\r
 914 ///  fpc short variables\r
 915 ///-------------------------------------///\r
 916         u8 *fpcshort_data = NULL;\r
 917         int fpcshort_file_id = 0;\r
 918 #endif ///< FEATURE_FPC_SHORT_ENABLE\r
 919 \r
 920 ///-------------------------------------///\r
 921 ///  Initial Dev Mode  parameters \r
 922 ///-------------------------------------///\r
 923 ///  External SD-Card could be\r
 924 ///      "/mnt/sdcard/zetidev"\r
 925 ///      "/mnt/extsd/zetidev"\r
 926 ///-------------------------------------///\r
 927 #ifdef FEATURE_IDEV_OUT_ENABLE\r
 928         #define IDEV_FILE_NAME          "zetidev"\r
 929         #define IDEV_MAX_FILE_ID        (10)    \r
 930         #define IDEV_MAX_DATA_SIZE      (512)\r
 931 \r
 932 ///-------------------------------------///\r
 933 ///  initial dev variables\r
 934 ///-------------------------------------///\r
 935         u8 *idev_data = NULL;\r
 936         int idev_file_id = 0;\r
 937 #endif ///< FEATURE_IDEV_OUT_ENABLE\r
 938 \r
 939 ///-------------------------------------///\r
 940 ///  Mutual Base Mode  parameters \r
 941 ///-------------------------------------///\r
 942 ///  External SD-Card could be\r
 943 ///      "/mnt/sdcard/zetmbase"\r
 944 ///      "/mnt/extsd/zetmbase"\r
 945 ///-------------------------------------///\r
 946 #ifdef FEATURE_MBASE_OUT_ENABLE\r
 947         #define MBASE_FILE_NAME         "zetmbase"\r
 948         #define MBASE_MAX_FILE_ID       (10)\r
 949         #define MBASE_MAX_DATA_SIZE     (2048)\r
 950 \r
 951 ///-------------------------------------///\r
 952 ///  mutual base variables\r
 953 ///-------------------------------------///\r
 954         u8 *mbase_data = NULL;\r
 955         int mbase_file_id = 0;\r
 956 #endif ///< FEATURE_MBASE_OUT_ENABLE\r
 957 \r
 958 ///-------------------------------------///\r
 959 ///  infomation variables\r
 960 ///-------------------------------------///\r
 961 #ifdef FEATURE_INFO_OUT_EANBLE\r
 962         #define INFO_MAX_DATA_SIZE      (64)\r
 963         #define INFO_DATA_SIZE          (17)\r
 964         #define ZET6221_INFO            (0x00)\r
 965         #define ZET6231_INFO            (0x0B)\r
 966         #define ZET6223_INFO            (0x0D)\r
 967         #define ZET6251_INFO            (0x0C)  \r
 968         #define UNKNOW_INFO             (0xFF)\r
 969         #define INFO_FILE_NAME          "zetinfo"\r
 970         u8 *info_data = NULL;\r
 971         u8 *trace_x_data = NULL;\r
 972         u8 *trace_y_data = NULL;\r
 973 #endif ///< FEATURE_INFO_OUT_EANBLE\r
 974 ///-------------------------------------///\r
 975 ///  Default transfer type\r
 976 ///-------------------------------------///\r
 977 u8 transfer_type = TRAN_TYPE_DYNAMIC;\r
 978 \r
 979 ///-------------------------------------///\r
 980 ///  Default TP TRACE\r
 981 ///-------------------------------------///\r
 982 int row = TP_DEFAULT_ROW;\r
 983 int col = TP_DEFAULT_COL;\r
 984 \r
 985 ///=========================================================================================///\r
 986 ///  TP related parameters/structures : configured for all tp\r
 987 ///=========================================================================================///\r
 988 static struct task_struct *resume_download_task = NULL;\r
 989 static struct i2c_client *this_client;\r
 990 \r
 991 struct zet622x_tsdrv\r
 992 {\r
 993         struct i2c_client *i2c_dev;\r
 994         struct work_struct work1;               ///< get point from ZET62xx task queue \r
 995         struct work_struct work2;               ///<  write_cmd\r
 996         struct workqueue_struct *ts_workqueue;  ///< get point from ZET62xx task queue \r
 997         struct workqueue_struct *ts_workqueue1; ///< write_cmd\r
 998         struct input_dev *input;\r
 999         struct timer_list zet622x_ts_timer_task;\r
1000 #ifdef FEATURE_INT_FREE\r
1001         struct timer_list zet622x_ts_timer_task1;\r
1002 #endif ///< for FEATURE_INT_FREE\r
1003 #ifdef FEATURE_FRAM_RATE\r
1004         struct timer_list zet622x_ts_timer_task2;\r
1005 #endif ///< for FEATURE_FRAM_RATE\r
1006         //struct early_suspend early_suspend;\r
1007         unsigned int gpio;                      ///< GPIO used for interrupt of TS1\r
1008         unsigned int irq;\r
1009         struct  tp_device  tp;\r
1010 \r
1011         struct pinctrl *pinctrl; /*Pinctrl state*/
1012         struct pinctrl_state    *pins_default;
1013         struct pinctrl_state    *pins_idle;
1014         struct pinctrl_state    *pins_sleep;\r\r
1015 };\r
1016 \r
1017 /// Touch Screen id tables\r
1018 static const struct i2c_device_id zet622x_ts_idtable[] =\r
1019 {\r
1020       { ZET_TS_ID_NAME, 0 },\r
1021       { }\r
1022 };\r
1023 \r
1024 static int  zet622x_ts_probe(struct i2c_client *client, const struct i2c_device_id *id);\r
1025 static int  zet622x_ts_remove(struct i2c_client *dev);\r
1026 \r
1027 s32 zet622x_i2c_write_tsdata(struct i2c_client *client, u8 *data, u8 length);\r
1028 s32 zet622x_i2c_read_tsdata(struct i2c_client *client, u8 *data, u8 length);\r
1029 \r
1030 static int  zet_fw_size(void);\r
1031 static void zet_fw_save(char *file_name);\r
1032 static void zet_fw_load(char *file_name);\r
1033 static void zet_fw_init(void);\r
1034 #ifdef FEATURE_MDEV_OUT_ENABLE\r
1035 static void zet_mdev_save(char *file_name);\r
1036 #endif ///< for FEATURE_MDEV_OUT_ENABLE\r
1037 #ifdef FEATURE_IDEV_OUT_ENABLE\r
1038 static void zet_idev_save(char *file_name);\r
1039 #endif ///< for FEATURE_IDEV_OUT_ENABLE\r
1040 #ifdef FEATURE_IBASE_OUT_ENABLE\r
1041 static void zet_ibase_save(char *file_name);\r
1042 #endif ///< for FEATURE_IBASE_OUT_ENABLE\r
1043 \r
1044 #ifdef FEATURE_FPC_OPEN_ENABLE\r
1045 static void zet_fpcopen_save(char *file_name);\r
1046 #endif ///< FEATURE_FPC_OPEN_ENABLE\r
1047 #ifdef FEATURE_FPC_SHORT_ENABLE\r
1048 static void zet_fpcshort_save(char *file_name);\r
1049 #endif ///< FEATURE_FPC_SHORT_ENABLE\r
1050 \r
1051 #ifdef FEATURE_MBASE_OUT_ENABLE\r
1052 static void zet_mbase_save(char *file_name);\r
1053 #endif ///< for FEATURE_MBASE_OUT_ENABLE\r
1054 #ifdef FEATURE_INFO_OUT_EANBLE\r
1055 static void zet_information_save(char *file_name);\r
1056 static void zet_trace_x_save(char *file_name);\r
1057 static void zet_trace_y_save(char *file_name);\r
1058 #endif ///< for FEATURE_INFO_OUT_EANBLE\r
1059 \r
1060 u8 zet622x_ts_check_version(void);\r
1061 int  zet622x_downloader( struct i2c_client *client, u8 upgrade, u8 *pRomType, u8 icmodel);\r
1062 int zet622x_ts_data_flash_download(struct i2c_client *client);\r
1063 \r
1064 #ifdef FEATRUE_TRACE_SENSOR_ID\r
1065 u8 zet622x_ts_check_sensor_id_index(void);\r
1066 #endif ///< FEATRUE_TRACE_SENSOR_ID\r
1067 \r
1068 ///**********************************************************************\r
1069 ///   [function]:  ctp_set_reset_low\r
1070 ///   [parameters]: void\r
1071 ///   [return]: void\r
1072 ///**********************************************************************\r
1073 void ctp_set_reset_low(void)\r
1074 {\r
1075         gpio_direction_output(TS_RST_GPIO, 0);\r
1076 }\r
1077 \r
1078 ///**********************************************************************\r
1079 ///   [function]:  ctp_set_reset_high\r
1080 ///   [parameters]: void\r
1081 ///   [return]: void\r
1082 ///**********************************************************************\r
1083 void ctp_set_reset_high(void)\r
1084 {\r
1085         gpio_direction_output(TS_RST_GPIO, 1);\r
1086 }\r
1087 \r
1088 ///**********************************************************************\r
1089 ///   [function]:  ctp_wakeup\r
1090 ///   [parameters]: void\r
1091 ///   [return]: void\r
1092 ///**********************************************************************\r
1093 static void ctp_wakeup(void)\r
1094 {\r
1095         printk("[ZET] : %s. \n", __func__);\r
1096         ctp_set_reset_low();\r
1097         mdelay(TS_WAKEUP_LOW_PERIOD);\r
1098         ctp_set_reset_high();\r
1099         mdelay(TS_WAKEUP_HIGH_PERIOD);\r
1100 }\r
1101 \r
1102 ///**********************************************************************\r
1103 ///   [function]:  ctp_wakeup2\r
1104 ///   [parameters]: delay_ms\r
1105 ///   [return]: void\r
1106 ///**********************************************************************\r
1107 static void ctp_wakeup2(int delay_ms)\r
1108 {\r
1109 \r
1110         printk("[ZET] : %s. \n", __func__);\r
1111         ctp_set_reset_low();\r
1112         mdelay(TS_WAKEUP_LOW_PERIOD);\r
1113         ctp_set_reset_high();\r
1114         mdelay(delay_ms);\r
1115 }\r
1116 \r
1117 \r
1118 ///**********************************************************************\r
1119 ///   [function]:  zet622x_i2c_get_free_dev\r
1120 ///   [parameters]: adap\r
1121 ///   [return]: void\r
1122 ///**********************************************************************\r
1123 static struct i2c_dev *zet622x_i2c_get_free_dev(struct i2c_adapter *adap) \r
1124 {\r
1125         struct i2c_dev *i2c_dev;\r
1126 \r
1127         if (adap->nr >= I2C_MINORS)\r
1128         {\r
1129                 printk("[ZET] : i2c-dev:out of device minors (%d) \n", adap->nr);\r
1130                 return ERR_PTR (-ENODEV);\r
1131         }\r
1132 \r
1133         i2c_dev = kzalloc(sizeof(*i2c_dev), GFP_KERNEL);\r
1134         if (!i2c_dev)\r
1135         {\r
1136                 return ERR_PTR(-ENOMEM);\r
1137         }\r
1138         i2c_dev->adap = adap;\r
1139 \r
1140         spin_lock(&i2c_dev_list_lock);\r
1141         list_add_tail(&i2c_dev->list, &i2c_dev_list);\r
1142         spin_unlock(&i2c_dev_list_lock);\r
1143         \r
1144         return i2c_dev;\r
1145 }\r
1146 \r
1147 ///**********************************************************************\r
1148 ///   [function]:  zet622x_i2c_dev_get_by_minor\r
1149 ///   [parameters]: index\r
1150 ///   [return]: i2c_dev\r
1151 ///**********************************************************************\r
1152 static struct i2c_dev *zet622x_i2c_dev_get_by_minor(unsigned index)\r
1153 {\r
1154         struct i2c_dev *i2c_dev;\r
1155         spin_lock(&i2c_dev_list_lock);\r
1156         \r
1157         list_for_each_entry(i2c_dev, &i2c_dev_list, list)\r
1158         {\r
1159                 printk(" [ZET] : line = %d ,i2c_dev->adapt->nr = %d,index = %d.\n", __LINE__, i2c_dev->adap->nr, index);\r
1160                 if(i2c_dev->adap->nr == index)\r
1161                 {\r
1162                      goto LABEL_FOUND;\r
1163                 }\r
1164         }\r
1165         i2c_dev = NULL;\r
1166         \r
1167 LABEL_FOUND: \r
1168         spin_unlock(&i2c_dev_list_lock);\r
1169         \r
1170         return i2c_dev ;\r
1171 }\r
1172 \r
1173 ///**********************************************************************\r
1174 ///   [function]:  zet622x_i2c_read_tsdata\r
1175 ///   [parameters]: client, data, length\r
1176 ///   [return]: s32\r
1177 ///***********************************************************************\r
1178 s32 zet622x_i2c_read_tsdata(struct i2c_client *client, u8 *data, u8 length)\r
1179 {\r
1180         struct i2c_msg msg;\r
1181         msg.addr     = client->addr;\r
1182         msg.flags    = I2C_M_RD;\r
1183         msg.len      = length;\r
1184         msg.buf      = data;\r
1185         msg.scl_rate = 300*1000;\r
1186         return i2c_transfer(client->adapter,&msg, 1);\r
1187 }\r
1188 \r
1189 ///**********************************************************************\r
1190 ///   [function]:  zet622x_i2c_write_tsdata\r
1191 ///   [parameters]: client, data, length\r
1192 ///   [return]: s32\r
1193 ///***********************************************************************\r
1194 s32 zet622x_i2c_write_tsdata(struct i2c_client *client, u8 *data, u8 length)\r
1195 {\r
1196         struct i2c_msg msg;\r
1197         msg.addr     = client->addr;\r
1198         msg.flags    = 0;\r
1199         msg.len      = length;\r
1200         msg.buf      = data;\r
1201         msg.scl_rate = 300*1000;\r
1202         return i2c_transfer(client->adapter,&msg, 1);\r
1203 }\r
1204 \r
1205 ///**********************************************************************\r
1206 ///   [function]:  zet622x_cmd_sndpwd\r
1207 ///   [parameters]: client\r
1208 ///   [return]: u8\r
1209 ///**********************************************************************\r
1210 u8 zet622x_cmd_sndpwd(struct i2c_client *client)\r
1211 {\r
1212         u8 ts_cmd[3] = {CMD_WRITE_PASSWORD, CMD_PASSWORD_HIBYTE, CMD_PASSWORD_LOBYTE};  \r
1213         int ret;\r
1214         \r
1215         ret = zet622x_i2c_write_tsdata(client, ts_cmd, 3);\r
1216         return ret;\r
1217 }\r
1218 \r
1219 ///**********************************************************************\r
1220 ///   [function]:  zet622x_cmd_sndpwd_1k (ZET6223 only)\r
1221 ///   [parameters]: client\r
1222 ///   [return]: u8\r
1223 ///**********************************************************************\r
1224 u8 zet622x_cmd_sndpwd_1k(struct i2c_client *client)\r
1225 {\r
1226         u8 ts_cmd[3] = {CMD_WRITE_PASSWORD, CMD_PASSWORD_1K_HIBYTE, CMD_PASSWORD_1K_LOBYTE};    \r
1227         int ret;\r
1228         \r
1229         ret = zet622x_i2c_write_tsdata(client, ts_cmd, 3);\r
1230         return ret;\r
1231 }\r
1232 \r
1233 ///**********************************************************************\r
1234 ///   [function]:  zet622x_cmd_codeoption\r
1235 ///   [parameters]: client, romtype\r
1236 ///   [return]: u8\r
1237 ///**********************************************************************\r
1238 u8 zet622x_cmd_codeoption(struct i2c_client *client, u8 *romtype)\r
1239 {\r
1240         u8 ts_cmd[1] = {CMD_READ_CODE_OPTION};\r
1241         u8 code_option[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};\r
1242 \r
1243 #ifdef FEATURE_HIGH_IMPEDENCE_MODE\r
1244         u8 ts_code_option_erase[1] = {CMD_ERASE_CODE_OPTION};\r
1245         u8 tx_buf[18] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};\r
1246 #endif ///< for FEATURE_HIGH_IMPEDENCE_MODE\r
1247 \r
1248         int ret;\r
1249         u16 model;\r
1250         int i;\r
1251         \r
1252         //printk("\n[ZET] : option write : "); \r
1253 \r
1254         ret = zet622x_i2c_write_tsdata(client, ts_cmd, 1);\r
1255 \r
1256         msleep(1);\r
1257         \r
1258         //printk("%02x ",ts_cmd[0]); \r
1259         \r
1260         //printk("\n[ZET] : read : "); \r
1261 \r
1262         ret = zet622x_i2c_read_tsdata(client, code_option, 16);\r
1263 \r
1264         msleep(1);\r
1265 /*\r
1266         for(i = 0 ; i < 16 ; i++)\r
1267         {\r
1268                 printk("%02x ",code_option[i]); \r
1269         }\r
1270         printk("\n"); \r
1271 */\r
1272         model = 0x0;\r
1273         model = code_option[7];\r
1274         model = (model << 8) | code_option[6];\r
1275 \r
1276         /// Set the rom type    \r
1277         *romtype = (code_option[2] & 0xf0)>>4;\r
1278         \r
1279         switch(model)\r
1280         { \r
1281                 case 0xFFFF: \r
1282                         ret = 1;\r
1283                         ic_model = MODEL_ZET6221;\r
1284                         for(i = 0 ; i < 8 ; i++)\r
1285                         {\r
1286                                 pcode_addr[i] = pcode_addr_6221[i];\r
1287                         }\r
1288                         \r
1289 #ifdef FEATURE_HIGH_IMPEDENCE_MODE\r
1290                         if(code_option[2] != IMPEDENCE_BYTE)\r
1291                         {\r
1292                                 ///------------------------------------------///\r
1293                                 /// unlock the flash \r
1294                                 ///------------------------------------------///                                \r
1295                                 if(zet622x_cmd_sfr_read(client) == 0)\r
1296                                 {\r
1297                                         return 0;\r
1298                                 }\r
1299                                 if(zet622x_cmd_sfr_unlock(client) == 0)\r
1300                                 {\r
1301                                         return 0;\r
1302                                 }\r
1303                                 ///------------------------------------------///\r
1304                                 /// Erase Code Option\r
1305                                 ///------------------------------------------///                                                        \r
1306                                 ret = zet622x_i2c_write_tsdata(client, ts_code_option_erase, 1);\r
1307                                 msleep(50);\r
1308 \r
1309                                 ///------------------------------------------///\r
1310                                 /// Write Code Option\r
1311                                 ///------------------------------------------///        \r
1312                                 tx_buf[0] = CMD_WRITE_CODE_OPTION;\r
1313                                 tx_buf[1] = 0xc5;\r
1314                                 for(i = 2 ; i < 18 ; i++)\r
1315                                 {\r
1316                                         tx_buf[i]=code_option[i-2];\r
1317                                 }                               \r
1318                                 tx_buf[4] = IMPEDENCE_BYTE;\r
1319                         \r
1320                                 ret = zet622x_i2c_write_tsdata(client, tx_buf, 18);\r
1321                                 msleep(50);\r
1322 \r
1323                                 ///------------------------------------------///\r
1324                                 /// Read Code Option back check\r
1325                                 ///------------------------------------------///                                        \r
1326                                 ret = zet622x_i2c_write_tsdata(client, ts_cmd, 1);\r
1327                                 msleep(5);      \r
1328                                 printk("%02x ",ts_cmd[0]);      \r
1329                                 printk("\n[ZET] : (2)read : "); \r
1330                                 ret = zet622x_i2c_read_tsdata(client, code_option, 16);\r
1331                                 msleep(1);\r
1332                                 for(i = 0 ; i < 16 ; i++)\r
1333                                 {\r
1334                                         printk("%02x ",code_option[i]); \r
1335                                 }\r
1336                                 printk("\n"); \r
1337                                 \r
1338                         }\r
1339 #endif ///< for  FEATURE_HIGH_IMPEDENCE_MODE\r
1340                 break; \r
1341                 case 0x6231: \r
1342                         ret = 1;\r
1343                         ic_model = MODEL_ZET6231;\r
1344                         for(i = 0 ; i < 8 ; i++)\r
1345                         {\r
1346                                 pcode_addr[i] = pcode_addr_6223[i];\r
1347                         } \r
1348                 break;           \r
1349                 case 0x6223:\r
1350                         ret = 1;\r
1351                         ic_model = MODEL_ZET6223;\r
1352                         for(i = 0 ; i < 8 ; i++)\r
1353                         {\r
1354                                 pcode_addr[i] = pcode_addr_6223[i];\r
1355                         }\r
1356                 break; \r
1357                 case 0x6251:\r
1358                         ic_model = MODEL_ZET6251;\r
1359                         for(i = 0 ; i < 8 ; i++)\r
1360                         {\r
1361                                 pcode_addr[i] = pcode_addr_6223[i];\r
1362                         }\r
1363                         break;\r
1364                 default:\r
1365                         ret = 1;\r
1366                         ic_model = MODEL_ZET6223;\r
1367                         for(i = 0 ; i < 8 ; i++)\r
1368                         {\r
1369                                 pcode_addr[i] = pcode_addr_6223[i];\r
1370                         }\r
1371                 break;         \r
1372         } \r
1373 \r
1374         return ret;\r
1375 }\r
1376 \r
1377 ///**********************************************************************\r
1378 ///   [function]:  zet622x_cmd_sfr_read\r
1379 ///   [parameters]: client\r
1380 ///   [return]: u8\r
1381 ///**********************************************************************\r
1382 u8 zet622x_cmd_sfr_read(struct i2c_client *client)\r
1383 {\r
1384 \r
1385         u8 ts_cmd[1] = {CMD_READ_SFR};\r
1386         int ret;\r
1387         \r
1388         //printk("\n[ZET] : write : "); \r
1389 \r
1390         ret = zet622x_i2c_write_tsdata(client, ts_cmd, 1);\r
1391 \r
1392         msleep(5);\r
1393         \r
1394         //printk("%02x ",ts_cmd[0]); \r
1395         \r
1396         //printk("\n[ZET] : sfr_read : "); \r
1397 \r
1398         ret = zet622x_i2c_read_tsdata(client, sfr_data, 16);\r
1399 \r
1400         msleep(1);\r
1401 /*\r
1402         for(i = 0 ; i < 16 ; i++)\r
1403         {\r
1404                 printk("%02x ",sfr_data[i]); \r
1405         }\r
1406         printk("\n"); \r
1407 */\r
1408         if((sfr_data[14] != SFR_UNLOCK_FLASH) && \r
1409            (sfr_data[14] != SFR_LOCK_FLASH))\r
1410         {\r
1411                 //printk("[ZET] : The SFR[14] shall be 0x3D or 0x7D\n"); \r
1412                 return FALSE;\r
1413         }\r
1414         \r
1415         return TRUE;\r
1416 }\r
1417 \r
1418 ///**********************************************************************\r
1419 ///   [function]:  zet622x_cmd_sfr_unlock\r
1420 ///   [parameters]: client\r
1421 ///   [return]: u8\r
1422 ///**********************************************************************\r
1423 u8 zet622x_cmd_sfr_unlock(struct i2c_client *client)\r
1424 {\r
1425         u8 tx_buf[17] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};\r
1426         int ret;\r
1427         int i;\r
1428         \r
1429         //printk("\nsfr_update : ");    \r
1430         for(i = 0 ; i < 16 ; i++)\r
1431         {\r
1432                 tx_buf[i+1] = sfr_data[i];\r
1433         //      printk("%02x ",sfr_data[i]); \r
1434         }\r
1435         //printk("\n"); \r
1436 \r
1437         if(sfr_data[14] != SFR_UNLOCK_FLASH)\r
1438         {\r
1439                 tx_buf[0]  = CMD_WRITE_SFR;     \r
1440                 tx_buf[15] = SFR_UNLOCK_FLASH;\r
1441                 ret = zet622x_i2c_write_tsdata(client, tx_buf, 17);\r
1442         }\r
1443         \r
1444         return TRUE;\r
1445 }\r
1446 \r
1447 ///***********************************************************************\r
1448 ///   [function]:  zet622x_cmd_masserase\r
1449 ///   [parameters]: client\r
1450 ///   [return]: u8\r
1451 ///************************************************************************\r
1452 u8 zet622x_cmd_masserase(struct i2c_client *client)\r
1453 {\r
1454         u8 ts_cmd[1] = {CMD_MASS_ERASE};\r
1455         \r
1456         int ret;\r
1457 \r
1458         ret = zet622x_i2c_write_tsdata(client, ts_cmd, 1);\r
1459 \r
1460         return ret;\r
1461 }\r
1462 \r
1463 ///***********************************************************************\r
1464 ///   [function]:  zet622x_cmd_pageerase\r
1465 ///   [parameters]: client, npage\r
1466 ///   [return]: u8\r
1467 ///************************************************************************\r
1468 u8 zet622x_cmd_pageerase(struct i2c_client *client, int npage)\r
1469 {\r
1470         u8 ts_cmd[3] = {CMD_PAGE_ERASE, 0x00, 0x00};\r
1471         u8 len = 0;\r
1472         int ret;\r
1473 \r
1474         switch(ic_model)\r
1475         {\r
1476                 case MODEL_ZET6221: ///< 6221\r
1477                         ts_cmd[1] = npage;\r
1478                         len = 2;\r
1479                         break;\r
1480                 case MODEL_ZET6223: ///< 6223\r
1481                 case MODEL_ZET6231: ///< 6231\r
1482                 case MODEL_ZET6251: ///< 6251\r
1483                 default: \r
1484                         ts_cmd[1] = npage & 0xff;\r
1485                         ts_cmd[2] = npage >> 8;\r
1486                         len=3;\r
1487                         break;\r
1488         }\r
1489 \r
1490         ret = zet622x_i2c_write_tsdata(client, ts_cmd, len);\r
1491         printk( " [ZET] : page erase\n");\r
1492         return TRUE;\r
1493 }\r
1494 \r
1495 ///***********************************************************************\r
1496 ///   [function]:  zet622x_cmd_resetmcu\r
1497 ///   [parameters]: client\r
1498 ///   [return]: u8\r
1499 ///************************************************************************\r
1500 u8 zet622x_cmd_resetmcu(struct i2c_client *client)\r
1501 {\r
1502         u8 ts_cmd[1] = {CMD_RESET_MCU};\r
1503         \r
1504         int ret;\r
1505 \r
1506         ret = zet622x_i2c_write_tsdata(client, ts_cmd, 1);\r
1507 \r
1508         return ret;\r
1509 }\r
1510 \r
1511 ///***********************************************************************\r
1512 ///   [function]:  zet622x_cmd_read_check_sum\r
1513 ///   [parameters]: client, page_id, buf\r
1514 ///   [return]: int\r
1515 ///************************************************************************\r
1516 int zet622x_cmd_read_check_sum(struct i2c_client *client, int page_id, u8 * buf)\r
1517 {\r
1518         int ret;\r
1519         int cmd_len = 3;\r
1520         \r
1521         buf[0] = CMD_PROG_CHECK_SUM;\r
1522         buf[1] = (u8)(page_id) & 0xff; \r
1523         buf[2] = (u8)(page_id >> 8);            \r
1524         ret = zet622x_i2c_write_tsdata(client, buf, cmd_len);\r
1525         if(ret <= 0)\r
1526         {\r
1527                 printk("[ZET]: Read check sum fail");\r
1528                 return ret;\r
1529         }\r
1530         \r
1531         buf[0] = CMD_PROG_GET_CHECK_SUM;\r
1532         cmd_len = 1;\r
1533         ret = zet622x_i2c_write_tsdata(client, buf, cmd_len);\r
1534         if(ret <= 0)\r
1535         {\r
1536                 printk("[ZET]: Read check sum fail");\r
1537                 return ret;\r
1538         }\r
1539         \r
1540         cmd_len = 1;\r
1541         ret = zet622x_i2c_read_tsdata(client, buf, cmd_len);\r
1542         if(ret <= 0)            \r
1543         {\r
1544                 printk("[ZET]: Read check sum fail");\r
1545                 return ret;\r
1546         }\r
1547         return 1;\r
1548 }\r
1549 \r
1550 ///**********************************************************************\r
1551 ///   [function]:  zet622x_ts_gpio_output_on\r
1552 ///   [parameters]: client\r
1553 ///   [return]: void\r
1554 ///**********************************************************************\r
1555 #ifdef FEATRUE_TRACE_GPIO_INPUT\r
1556 void zet622x_ts_gpio_input_get(void)\r
1557 {\r
1558         u8 ts_buf[1] = {GPIO_TRACE_INPUT_GET};\r
1559         u8 cmd_len = 1;\r
1560         int ret;\r
1561 \r
1562 \r
1563         /// write the gpio status\r
1564         ret = zet622x_i2c_write_tsdata(this_client, ts_buf, 1);\r
1565         if(ret <= 0)\r
1566         {\r
1567                 printk("[ZET] : Set the GPIO_TRACE_OUTPUT_SET command fail\n");\r
1568         }\r
1569 \r
1570         /// get the gpio status\r
1571         ret = zet622x_i2c_read_tsdata(this_client, ts_buf, cmd_len);\r
1572         if(ret <= 0)            \r
1573         {\r
1574                 printk("[ZET]: Read check sum fail\n");\r
1575                 return ;\r
1576         }\r
1577         trace_input_status = ts_buf[0];         \r
1578         printk("[ZET] : trace input status :%d\n", trace_input_status);\r
1579         \r
1580 }\r
1581 #endif ///< for FEATRUE_TRACE_GPIO_INPUT\r
1582         \r
1583 ///**********************************************************************\r
1584 ///   [function]:  zet622x_ts_gpio_output_on\r
1585 ///   [parameters]: client\r
1586 ///   [return]: void\r
1587 ///**********************************************************************\r
1588 #ifdef FEATRUE_TRACE_SENSOR_ID\r
1589 u8 zet622x_ts_sensor_id_bin_set(u8 status)\r
1590 {\r
1591         int i;\r
1592         u8 write_data_flash = FALSE;\r
1593         int flash_total_len     = 0;\r
1594         \r
1595         sensor_id_status = status;\r
1596 \r
1597         /// if used the bin file not to check bin\r
1598         if(chk_have_bin_file == TRUE)\r
1599         {\r
1600                 sensor_id_status = 0xF0 | sensor_id_status;\r
1601                 printk("[ZET] : have bin then bypass Sensor ID status:%d\n", sensor_id_status);\r
1602                 return FALSE;\r
1603         }\r
1604 \r
1605         /// first check the version is match\r
1606         if(zet622x_ts_check_sensor_id_index() == FALSE)\r
1607         {\r
1608                 printk("[ZET] : sensor id is same %d status : %d\n", sensor_id, sensor_id_status);\r
1609                 return FALSE;\r
1610         }\r
1611         else\r
1612         {\r
1613                 printk("[ZET]: Version different sensor id : %d status : %d\n", sensor_id, sensor_id_status);\r
1614                 write_data_flash = TRUE;\r
1615         }\r
1616         \r
1617         flash_total_len = zet_fw_size();\r
1618         switch(sensor_id)\r
1619         {\r
1620         case SENID_01:\r
1621                 printk("[ZET] : reload senid 01 FW\n");\r
1622                 for(i = 0 ; i < flash_total_len ; i++)\r
1623                 {       \r
1624                         flash_buffer[i] = flash_buffer_01[i];\r
1625                 }\r
1626         break;\r
1627         case SENID_02:\r
1628                 printk("[ZET] : reload senid 02 FW\n");\r
1629                 for(i = 0 ; i < flash_total_len ; i++)\r
1630                 {       \r
1631                         flash_buffer[i] = flash_buffer_02[i];\r
1632                 }\r
1633         break;\r
1634         case SENID_03:\r
1635                 printk("[ZET] : reload senid 03 FW\n");\r
1636                 for(i = 0 ; i < flash_total_len ; i++)\r
1637                 {       \r
1638                         flash_buffer[i] = flash_buffer_03[i];\r
1639                 }\r
1640         break;\r
1641         default:\r
1642         case SENID_00:\r
1643                 printk("[ZET] : default fail \n");\r
1644                 return FALSE;\r
1645         break;\r
1646         }\r
1647 \r
1648         \r
1649         printk("[ZET] : SendID pcode_new : ");\r
1650         for(i = 0 ; i < PROJECT_CODE_MAX_CNT ; i++)\r
1651         {\r
1652                 printk("%02x ",flash_buffer[pcode_addr[i]]);\r
1653         }\r
1654         printk("\n");\r
1655 \r
1656         return TRUE;\r
1657         \r
1658 }\r
1659 #endif ///< for FEATRUE_TRACE_SENSOR_ID\r
1660 \r
1661 ///**********************************************************************\r
1662 ///   [function]:  zet622x_ts_gpio_output_on\r
1663 ///   [parameters]: client\r
1664 ///   [return]: void\r
1665 ///**********************************************************************\r
1666 #ifdef FEATRUE_TRACE_GPIO_OUTPUT\r
1667 void zet622x_ts_gpio_output_on(u8 index)\r
1668 {\r
1669         u8 ts_write_cmd[2] = {GPIO_TRACE_OUTPUT_SET, 0x00};\r
1670         u8 status = trace_output_status;\r
1671         int ret = 0;\r
1672 \r
1673         /// setting the bit on status\r
1674         status |= index;\r
1675 \r
1676         /// write the gpio status\r
1677         ts_write_cmd[1] = status;\r
1678         ret = zet622x_i2c_write_tsdata(this_client, ts_write_cmd, 2);\r
1679         if(ret <= 0)\r
1680         {\r
1681                 printk("[ZET] : Set the GPIO_TRACE_OUTPUT_SET command fail\n");\r
1682         }\r
1683 \r
1684         trace_output_status = status;\r
1685 }\r
1686 #endif ///< for FEATRUE_TRACE_GPIO_OUTPUT\r
1687 \r
1688 ///**********************************************************************\r
1689 ///   [function]:  zet622x_ts_gpio_output_off\r
1690 ///   [parameters]: client\r
1691 ///   [return]: void\r
1692 ///**********************************************************************\r
1693 #ifdef FEATRUE_TRACE_GPIO_OUTPUT\r
1694 void zet622x_ts_gpio_output_off(u8 index)\r
1695 {\r
1696         u8 ts_write_cmd[2] = {GPIO_TRACE_OUTPUT_SET, 0x00};\r
1697         u8 status = trace_output_status;\r
1698         int ret = 0;\r
1699 \r
1700         /// setting the bit off status\r
1701         status &= ~(index);\r
1702 \r
1703         /// write the gpio status\r
1704         ts_write_cmd[1] = status;\r
1705         ret = zet622x_i2c_write_tsdata(this_client, ts_write_cmd, 2);\r
1706         if(ret <= 0)\r
1707         {\r
1708                 printk("[ZET] : Set the GPIO_TRACE_OUTPUT_SET command fail\n");\r
1709         }\r
1710         trace_output_status = status;\r
1711 }\r
1712 #endif ///< for FEATRUE_TRACE_GPIO_OUTPUT\r
1713 \r
1714 ///**********************************************************************\r
1715 ///   [function]:  zet622x_ts_gpio1_output\r
1716 ///   [parameters]: client\r
1717 ///   [return]: void\r
1718 ///**********************************************************************\r
1719 #ifdef FEATRUE_TRACE_GPIO_OUTPUT\r
1720 void zet622x_ts_gpio1_output(int status)\r
1721 {\r
1722         if(status > 0)\r
1723         {\r
1724                 zet622x_ts_gpio_output_on(TRACE_GPIO1_INDEX);\r
1725         }\r
1726         else\r
1727         {\r
1728                 zet622x_ts_gpio_output_off(TRACE_GPIO1_INDEX);\r
1729         }\r
1730 }\r
1731 EXPORT_SYMBOL_GPL(zet622x_ts_gpio1_output);\r
1732 #endif ///< for FEATRUE_TRACE_GPIO_OUTPUT\r
1733 \r
1734 ///**********************************************************************\r
1735 ///   [function]:  zet622x_ts_gpio_output\r
1736 ///   [parameters]: client\r
1737 ///   [return]: void\r
1738 ///**********************************************************************\r
1739 #ifdef FEATRUE_TRACE_GPIO_OUTPUT\r
1740 void zet622x_ts_gpio_output(int index, int status)\r
1741 {\r
1742   u8 gpio_index = TRACE_GPIO1_INDEX;\r
1743 \r
1744         switch(index)\r
1745         {\r
1746         case 1:\r
1747                 gpio_index = TRACE_GPIO1_INDEX;\r
1748         break;\r
1749         case 2:\r
1750                 gpio_index = TRACE_GPIO2_INDEX;\r
1751         break;\r
1752         case 3:\r
1753                 gpio_index = TRACE_GPIO3_INDEX;\r
1754         break;\r
1755        case 4:\r
1756                 gpio_index = TRACE_GPIO4_INDEX;\r
1757         break;\r
1758         case 5:\r
1759                 gpio_index = TRACE_GPIO5_INDEX;\r
1760         break;\r
1761         case 6:\r
1762                 gpio_index = TRACE_GPIO6_INDEX;\r
1763         break;\r
1764         case 7:\r
1765                 gpio_index = TRACE_GPIO7_INDEX;\r
1766         break;\r
1767         case 8:\r
1768                 gpio_index = TRACE_GPIO8_INDEX;\r
1769         break;\r
1770         }\r
1771 \r
1772         if(status > 0)\r
1773         {\r
1774                 zet622x_ts_gpio_output_on(gpio_index);\r
1775         }\r
1776         else\r
1777         {\r
1778                 zet622x_ts_gpio_output_off(gpio_index);\r
1779         }\r
1780 }\r
1781 EXPORT_SYMBOL_GPL(zet622x_ts_gpio_output);\r
1782 #endif ///< for FEATRUE_TRACE_GPIO_OUTPUT\r
1783 \r
1784 ///***********************************************************************\r
1785 ///   [function]:  zet622x_cmd_readpage\r
1786 ///   [parameters]: client, page_id, buf\r
1787 ///   [return]: int\r
1788 ///************************************************************************\r
1789 int zet622x_cmd_readpage(struct i2c_client *client, int page_id, u8 * buf)\r
1790 {\r
1791         int ret;\r
1792         int cmd_len = 3;\r
1793 \r
1794         switch(ic_model)\r
1795         {\r
1796                 case MODEL_ZET6221:\r
1797                         buf[0] = CMD_PAGE_READ_PROGRAM;\r
1798                         buf[1] = (u8)(page_id); ///< (pcode_addr[0]/128);                       \r
1799                         cmd_len = 2;\r
1800                         break;\r
1801                 case MODEL_ZET6223: \r
1802                 case MODEL_ZET6231: \r
1803                 case MODEL_ZET6251: \r
1804                         buf[0] = CMD_PAGE_READ_PROGRAM;\r
1805                         buf[1] = (u8)(page_id) & 0xff; ///< (pcode_addr[0]/128);\r
1806                         buf[2] = (u8)(page_id >> 8);   ///< (pcode_addr[0]/128);                        \r
1807                         cmd_len = 3;\r
1808                         break;\r
1809                 default: \r
1810                         buf[0] = CMD_PAGE_READ_PROGRAM;\r
1811                         buf[1] = (u8)(page_id) & 0xff; ///< (pcode_addr[0]/128);\r
1812                         buf[2] = (u8)(page_id >> 8);   ///< (pcode_addr[0]/128);                        \r
1813                         cmd_len = 3;\r
1814                         break;\r
1815         }\r
1816         \r
1817         ret = zet622x_i2c_write_tsdata(client, buf, cmd_len);\r
1818         if(ret <= 0)\r
1819         {\r
1820                 printk("[ZET]: Read page command fail");\r
1821                 return ret;\r
1822         }\r
1823 \r
1824         ret = zet622x_i2c_read_tsdata(client, buf, FLASH_PAGE_LEN);\r
1825         if(ret <= 0)            \r
1826         {\r
1827                 printk("[ZET]: Read page data fail");\r
1828                 return ret;\r
1829         }\r
1830         return 1;\r
1831 }\r
1832 \r
1833 ///***********************************************************************\r
1834 ///   [function]:  zet622x_cmd_ioctl_write_data\r
1835 ///   [parameters]: client, len, buf\r
1836 ///   [return]: int\r
1837 ///************************************************************************\r
1838 int zet622x_cmd_ioctl_write_data(struct i2c_client *client, u8 len, u8 * buf)\r
1839 {\r
1840         u8 tx_buf[256];\r
1841         int i;\r
1842         int ret;\r
1843         \r
1844         for(i = 0 ; i < len ; i++)\r
1845         {\r
1846                 tx_buf[i] = buf[i];\r
1847         }\r
1848         \r
1849         ret = zet622x_i2c_write_tsdata(client, tx_buf, len);\r
1850         if(ret <= 0)\r
1851         {\r
1852                 printk("[ZET] : write cmd failed!!:");\r
1853         }\r
1854         else\r
1855         {\r
1856                 printk("[ZET] : write cmd :");\r
1857         }\r
1858         \r
1859         for(i = 0 ; i < len ; i++)\r
1860         {\r
1861                 printk("%02x ", tx_buf[i]);\r
1862                 if((i%0x10) == 0x0F)\r
1863                 {\r
1864                         printk("\n");\r
1865                 }\r
1866                 else if((i%0x08) == 0x07)\r
1867                 {\r
1868                         printk(" - ");\r
1869                 }\r
1870         }\r
1871         printk("\n");\r
1872         return ret;\r
1873 }\r
1874 \r
1875 ///***********************************************************************\r
1876 ///   [function]:  zet622x_cmd_writepage\r
1877 ///   [parameters]: client, page_id, buf\r
1878 ///   [return]: int\r
1879 ///************************************************************************\r
1880 int zet622x_cmd_writepage(struct i2c_client *client, int page_id, u8 * buf)\r
1881 {\r
1882         int ret;\r
1883         int cmd_len = 131;\r
1884         int cmd_idx = 3;\r
1885         u8 tx_buf[256];\r
1886         int i;\r
1887 \r
1888         switch(ic_model)\r
1889         {\r
1890                 case MODEL_ZET6221: ///< for 6221\r
1891                         cmd_len = 130;\r
1892                         \r
1893                         tx_buf[0] = CMD_WRITE_PROGRAM;\r
1894                         tx_buf[1] = page_id;\r
1895                         cmd_idx = 2;\r
1896                         break;\r
1897                 case MODEL_ZET6223: ///< for 6223\r
1898                 case MODEL_ZET6231: ///< for 6231\r
1899                 case MODEL_ZET6251: ///< for 6251\r
1900                 default: \r
1901                         cmd_len = 131;\r
1902                         \r
1903                         tx_buf[0] = CMD_WRITE_PROGRAM;\r
1904                         tx_buf[1] = (page_id & 0xff);\r
1905                         tx_buf[2] = (u8)(page_id >> 8);\r
1906                         cmd_idx = 3;\r
1907                         break;\r
1908         }\r
1909 \r
1910         for(i = 0 ; i < FLASH_PAGE_LEN ; i++)\r
1911         {\r
1912                 tx_buf[i + cmd_idx] = buf[i];\r
1913         }\r
1914         ret = zet622x_i2c_write_tsdata(client, tx_buf, cmd_len);\r
1915         if(ret <= 0)\r
1916         {\r
1917                 printk("[ZET] : write page %d failed!!", page_id);\r
1918         }\r
1919         return ret;\r
1920 }\r
1921 \r
1922 ///***********************************************************************\r
1923 ///   [function]:  zet622x_ts_check_version\r
1924 ///   [parameters]: void\r
1925 ///   [return]: void\r
1926 ///************************************************************************\r
1927 u8 zet622x_ts_check_version(void)\r
1928 {       \r
1929         int i;\r
1930         \r
1931         for(i = 0 ; i < PROJECT_CODE_MAX_CNT ; i++)\r
1932         {\r
1933                 if(pcode[i] != flash_buffer[pcode_addr[i]])\r
1934                 {\r
1935                         printk("[ZET]: Version different\n");\r
1936                         /// if reload the bin file mode \r
1937                         return FALSE;\r
1938                 }\r
1939         }\r
1940 \r
1941         printk("[ZET]: Version the same\n");                    \r
1942         return TRUE;\r
1943 }\r
1944 \r
1945 ///***********************************************************************\r
1946 ///   [function]:  zet622x_ts_check_sensor_id_index\r
1947 ///   [parameters]: void\r
1948 ///   [return]: void\r
1949 ///************************************************************************\r
1950 #ifdef FEATRUE_TRACE_SENSOR_ID\r
1951 u8 zet622x_ts_check_sensor_id_index(void)\r
1952 {\r
1953         u8 ret = FALSE;\r
1954         \r
1955          sensor_id = flash_buffer[SENSOR_ID_INDEX_ADDR];\r
1956 \r
1957         switch(sensor_id_status)\r
1958         {\r
1959         case SENID_01:\r
1960          if(sensor_id != flash_buffer_01[SENSOR_ID_INDEX_ADDR])\r
1961         {\r
1962                 sensor_id = SENID_01;\r
1963                 ret = TRUE;\r
1964         }\r
1965         break;\r
1966         case SENID_02:\r
1967          if(sensor_id != flash_buffer_02[SENSOR_ID_INDEX_ADDR])\r
1968         {\r
1969                 sensor_id = SENID_02;\r
1970                 ret = TRUE;\r
1971         }\r
1972         break;\r
1973         case SENID_03:\r
1974          if(sensor_id != flash_buffer_03[SENSOR_ID_INDEX_ADDR])\r
1975         {\r
1976                 sensor_id = SENID_03;\r
1977                 ret = TRUE;\r
1978         }\r
1979         break;\r
1980         default:\r
1981         case SENID_00:\r
1982                 sensor_id = SENID_00;\r
1983               ret = FALSE;\r
1984          break;\r
1985         }\r
1986         return ret;\r
1987 }\r
1988 #endif ///< FEATRUE_TRACE_SENSOR_ID\r
1989 \r
1990 ///***********************************************************************\r
1991 ///   [function]:  zet622x_ts_check_skip_page\r
1992 ///   [parameters]: u8 point\r
1993 ///   [return]: skip download is TRUE/FALSE\r
1994 ///************************************************************************\r
1995 #ifdef FEATURE_FW_SKIP_FF\r
1996 u8 zet622x_ts_check_skip_page(u8 *data)\r
1997 {       \r
1998         int j;\r
1999         \r
2000         for(j = 0 ; j < FLASH_PAGE_LEN ; j++)\r
2001         {\r
2002                 if(data[j] != 0xFF)     \r
2003                 {\r
2004                         return FALSE;\r
2005                 }\r
2006         }\r
2007                 \r
2008         return TRUE;\r
2009 }\r
2010 #endif ///< for FEATURE_FW_SKIP_FF\r
2011 \r
2012 #ifdef FEATURE_FW_CHECK_SUM\r
2013 ///***********************************************************************\r
2014 ///   [function]:  zet622x_ts_check_skip_page\r
2015 ///   [parameters]: u8 point\r
2016 ///   [return]: check sum is TRUE/FALSE\r
2017 ///************************************************************************\r
2018 u8 zet622x_ts_sram_check_sum(struct i2c_client *client, int page_id, u8 *data)\r
2019 {               \r
2020         u8 get_check_sum        = 0;\r
2021         u8 check_sum            = 0;\r
2022         int i;\r
2023         int ret;\r
2024         u8 tmp_data[16];\r
2025 \r
2026         ///---------------------------------///\r
2027         ///  Get check sum\r
2028         ///---------------------------------///\r
2029         for(i = 0 ; i < FLASH_PAGE_LEN ; i++)\r
2030         {\r
2031                 if(i == 0)\r
2032                 {\r
2033                         check_sum = data[i];\r
2034                 }\r
2035                 else\r
2036                 {\r
2037                         check_sum = check_sum ^ data[i];\r
2038                 }\r
2039         }\r
2040         \r
2041         ///---------------------------------///\r
2042         /// Read check sum\r
2043         ///---------------------------------///\r
2044         memset(tmp_data, 0, 16);\r
2045         ret = zet622x_cmd_read_check_sum(client, page_id, &tmp_data[0]);        \r
2046         if(ret <= 0)\r
2047         {\r
2048                 return FALSE;\r
2049         }\r
2050         get_check_sum = tmp_data[0];\r
2051         if(check_sum == get_check_sum)\r
2052         {\r
2053                 return TRUE;\r
2054         }\r
2055         else\r
2056         {\r
2057                 printk("[ZET]: page=%3d  ,Check sum : %x ,get check sum : %x\n", page_id, check_sum, get_check_sum);\r
2058                 return FALSE;\r
2059         }\r
2060 }\r
2061 #endif ///< for FEATURE_FW_CHECK_SUM\r
2062 \r
2063 ///**********************************************************************\r
2064 ///   [function]:  zet622x_ts_hover_status_get\r
2065 ///   [parameters]: void\r
2066 ///   [return]: u8\r
2067 ///**********************************************************************\r
2068 u8 zet622x_ts_hover_status_get(void)\r
2069 {\r
2070         return hover_status;\r
2071 }\r
2072 \r
2073 EXPORT_SYMBOL_GPL(zet622x_ts_hover_status_get);\r
2074 \r
2075 ///**********************************************************************\r
2076 ///   [function]:  zet622x_ts_set_transfer_type\r
2077 ///   [parameters]: void\r
2078 ///   [return]: void\r
2079 ///**********************************************************************\r
2080 int zet622x_ts_set_transfer_type(u8 bTransType)\r
2081 {\r
2082         u8 ts_cmd[10] = {0xC1, 0x02, TRAN_TYPE_DYNAMIC, 0x55, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00}; \r
2083         int ret = 0;\r
2084         ts_cmd[2] = bTransType;\r
2085         ret = zet622x_i2c_write_tsdata(this_client, ts_cmd, 10);\r
2086         return ret;\r
2087 }\r
2088 \r
2089 \r
2090 ///**********************************************************************\r
2091 ///   [function]:  zet622x_ts_parse_mutual_dev\r
2092 ///   [parameters]: client\r
2093 ///   [return]: u8\r
2094 ///**********************************************************************\r
2095 #ifdef FEATURE_MDEV_OUT_ENABLE\r
2096 u8 zet622x_ts_parse_mutual_dev(struct i2c_client *client)\r
2097 {\r
2098         int mdev_packet_size = (row+2) * (col + 2);\r
2099         int ret = 0;\r
2100         int idx = 0;\r
2101         int len =  mdev_packet_size;\r
2102         char mdev_file_name_out[128];\r
2103         \r
2104         int step_size = col + 2;\r
2105         \r
2106 #ifdef FEATURE_INT_FREE\r
2107         ret = zet622x_i2c_read_tsdata(client, &tran_data[idx],  1);\r
2108         if(tran_data[idx] != INT_FREE_DATA_HEADER)\r
2109         {\r
2110                 return FALSE;\r
2111         }       \r
2112 #endif ///< for FEATURE_INT_FREE\r
2113         while(len > 0)\r
2114         {\r
2115                 if(len < step_size)\r
2116                 {\r
2117                         step_size = len;\r
2118                 }\r
2119 \r
2120                 ret = zet622x_i2c_read_tsdata(client, &tran_data[idx], step_size);\r
2121                 len -= step_size;\r
2122                 idx += step_size;\r
2123         }\r
2124         \r
2125         sprintf(mdev_file_name_out, "%s%s%02d.bin", tran_type_mode_file_name, MDEV_FILE_NAME, mdev_file_id);    \r
2126         zet_mdev_save(mdev_file_name_out);\r
2127         mdev_file_id  =  (mdev_file_id +1)% (MDEV_MAX_FILE_ID);\r
2128         return ret;\r
2129 }\r
2130 #endif ///< FEATURE_MDEV_OUT_ENABLE\r
2131 \r
2132 ///**********************************************************************\r
2133 ///   [function]:  zet622x_ts_parse_initial_base\r
2134 ///   [parameters]: client\r
2135 ///   [return]: u8\r
2136 ///**********************************************************************\r
2137 #ifdef FEATURE_IBASE_OUT_ENABLE\r
2138 u8 zet622x_ts_parse_initial_base(struct i2c_client *client)\r
2139 {\r
2140         int ibase_packet_size = (row + col) * 2;\r
2141         int ret = 0;\r
2142         int idx = 0;\r
2143         int len =  ibase_packet_size;\r
2144         char ibase_file_name_out[128];\r
2145         \r
2146         int step_size = ibase_packet_size;\r
2147         \r
2148 #ifdef FEATURE_INT_FREE\r
2149         ret = zet622x_i2c_read_tsdata(client, &tran_data[idx], 1);\r
2150         if(tran_data[idx] != INT_FREE_DATA_HEADER)\r
2151         {\r
2152                 return FALSE;\r
2153         }       \r
2154 #endif ///< for FEATURE_INT_FREE\r
2155 \r
2156         while(len > 0)\r
2157         {\r
2158                 if(len < step_size)\r
2159                 {\r
2160                         step_size = len;\r
2161                 }\r
2162                 ret = zet622x_i2c_read_tsdata(client, &tran_data[idx], step_size);\r
2163                 len -= step_size;\r
2164                 idx += step_size;\r
2165         }\r
2166         sprintf(ibase_file_name_out, "%s%s%02d.bin", tran_type_mode_file_name, IBASE_FILE_NAME, ibase_file_id); \r
2167         zet_ibase_save(ibase_file_name_out);\r
2168         ibase_file_id  =  (ibase_file_id +1)% (IBASE_MAX_FILE_ID);\r
2169         return ret;\r
2170 }\r
2171 #endif ///< FEATURE_IBASE_OUT_ENABLE\r
2172 \r
2173 ///**********************************************************************\r
2174 ///   [function]:  zet622x_ts_parse_fpc_open\r
2175 ///   [parameters]: client\r
2176 ///   [return]: u8\r
2177 ///**********************************************************************\r
2178 #ifdef FEATURE_FPC_OPEN_ENABLE\r
2179 u8 zet622x_ts_parse_fpc_open(struct i2c_client *client)\r
2180 {\r
2181         int fpcopen_packet_size = (row + col) ;\r
2182         int ret = 0;\r
2183         int idx = 0;\r
2184         int len =  fpcopen_packet_size;\r
2185         char fpcopen_file_name_out[128];\r
2186         \r
2187         int step_size = fpcopen_packet_size;\r
2188         \r
2189 #ifdef FEATURE_INT_FREE\r
2190         ret = zet622x_i2c_read_tsdata(client, &tran_data[idx],  1);\r
2191         if(tran_data[idx] != INT_FREE_DATA_HEADER)\r
2192         {\r
2193                 return FALSE;\r
2194         }       \r
2195 #endif ///< for FEATURE_INT_FREE\r
2196 \r
2197         while(len > 0)\r
2198         {\r
2199                 if(len < step_size)\r
2200                 {\r
2201                         step_size = len;\r
2202                 }\r
2203                 ret = zet622x_i2c_read_tsdata(client, &tran_data[idx], step_size);\r
2204                 len -= step_size;\r
2205                 idx += step_size;\r
2206         }\r
2207         sprintf(fpcopen_file_name_out, "%s%s%02d.bin", tran_type_mode_file_name, FPC_OPEN_FILE_NAME, fpcopen_file_id);  \r
2208         zet_fpcopen_save(fpcopen_file_name_out);\r
2209         fpcopen_file_id  =  (fpcopen_file_id +1)% (FPC_OPEN_MAX_FILE_ID);\r
2210         return ret;\r
2211 }\r
2212 #endif ///< FEATURE_FPC_OPEN_ENABLE\r
2213 \r
2214 ///**********************************************************************\r
2215 ///   [function]:  zet622x_ts_parse_fpc_short\r
2216 ///   [parameters]: client\r
2217 ///   [return]: u8\r
2218 ///**********************************************************************\r
2219 #ifdef FEATURE_FPC_SHORT_ENABLE\r
2220 u8 zet622x_ts_parse_fpc_short(struct i2c_client *client)\r
2221 {\r
2222         int fpcshort_packet_size = (row + col) * 2;\r
2223         int ret = 0;\r
2224         int idx = 0;\r
2225         int len =  fpcshort_packet_size;\r
2226         char fpcshort_file_name_out[128];\r
2227         \r
2228         int step_size = col*2;\r
2229         \r
2230 #ifdef FEATURE_INT_FREE\r
2231         ret = zet622x_i2c_read_tsdata(client, &tran_data[idx],  1);\r
2232         if(tran_data[idx] != INT_FREE_DATA_HEADER)\r
2233         {\r
2234                 return FALSE;\r
2235         }       \r
2236 #endif ///< for FEATURE_INT_FREE\r
2237 \r
2238         while(len > 0)\r
2239         {\r
2240                 if(len < step_size)\r
2241                 {\r
2242                         step_size = len;\r
2243                 }\r
2244                 ret = zet622x_i2c_read_tsdata(client, &tran_data[idx], step_size);\r
2245                 len -= step_size;\r
2246                 idx += step_size;\r
2247         }\r
2248         sprintf(fpcshort_file_name_out, "%s%s%02d.bin", tran_type_mode_file_name, FPC_SHORT_FILE_NAME, fpcshort_file_id);       \r
2249         zet_fpcshort_save(fpcshort_file_name_out);\r
2250         fpcshort_file_id  =  (fpcshort_file_id +1)% (FPC_OPEN_MAX_FILE_ID);\r
2251         return ret;\r
2252 }\r
2253 #endif ///< FEATURE_FPC_SHORT_ENABLE\r
2254 \r
2255 ///**********************************************************************\r
2256 ///   [function]:  zet622x_ts_parse_initial_dev\r
2257 ///   [parameters]: client\r
2258 ///   [return]: u8\r
2259 ///**********************************************************************\r
2260 #ifdef FEATURE_IDEV_OUT_ENABLE\r
2261 u8 zet622x_ts_parse_initial_dev(struct i2c_client *client)\r
2262 {\r
2263         int idev_packet_size = (row + col);\r
2264         int ret = 0;\r
2265         int idx = 0;\r
2266         int len =  idev_packet_size;\r
2267         char idev_file_name_out[128];\r
2268         \r
2269         int step_size = idev_packet_size;\r
2270         \r
2271 #ifdef FEATURE_INT_FREE\r
2272         ret = zet622x_i2c_read_tsdata(client, &tran_data[idx], 1);\r
2273         if(tran_data[idx] != INT_FREE_DATA_HEADER)\r
2274         {\r
2275                 return FALSE;\r
2276         }       \r
2277 #endif ///< for FEATURE_INT_FREE\r
2278 \r
2279         while(len > 0)\r
2280         {\r
2281                 if(len < step_size)\r
2282                 {\r
2283                         step_size = len;\r
2284                 }\r
2285                 ret = zet622x_i2c_read_tsdata(client, &tran_data[idx], step_size);\r
2286                 len -= step_size;\r
2287                 idx += step_size;\r
2288         }\r
2289         sprintf(idev_file_name_out, "%s%s%02d.bin", tran_type_mode_file_name, IDEV_FILE_NAME, idev_file_id);    \r
2290         zet_idev_save(idev_file_name_out);\r
2291         idev_file_id  =  (idev_file_id +1)% (IDEV_MAX_FILE_ID);\r
2292         return ret;\r
2293 }\r
2294 #endif ///< FEATURE_IDEV_OUT_ENABLE\r
2295 \r
2296 ///**********************************************************************\r
2297 ///   [function]:  zet622x_ts_parse_mutual_base\r
2298 ///   [parameters]: client\r
2299 ///   [return]: u8\r
2300 ///**********************************************************************\r
2301 #ifdef FEATURE_MBASE_OUT_ENABLE\r
2302 u8 zet622x_ts_parse_mutual_base(struct i2c_client *client)\r
2303 {\r
2304         int mbase_packet_size = (row * col * 2);\r
2305         int ret = 0;\r
2306         int idx = 0;\r
2307         int len =  mbase_packet_size;\r
2308         char mbase_file_name_out[128];\r
2309         \r
2310         int step_size = col*2;\r
2311         \r
2312 #ifdef FEATURE_INT_FREE\r
2313         ret = zet622x_i2c_read_tsdata(client, &tran_data[idx], 1);\r
2314         if(tran_data[idx] != INT_FREE_DATA_HEADER)\r
2315         {\r
2316                 return FALSE;\r
2317         }       \r
2318 #endif ///< for FEATURE_INT_FREE\r
2319 \r
2320         while(len > 0)\r
2321         {\r
2322                 if(len < step_size)\r
2323                 {\r
2324                         step_size = len;\r
2325                 }\r
2326 \r
2327                 ret = zet622x_i2c_read_tsdata(client, &tran_data[idx], step_size);\r
2328                 len -= step_size;\r
2329                 idx += step_size;\r
2330         }\r
2331         sprintf(mbase_file_name_out, "%s%s%02d.bin",tran_type_mode_file_name, MBASE_FILE_NAME, mbase_file_id);  \r
2332         zet_mbase_save(mbase_file_name_out);\r
2333         mbase_file_id  =  (mbase_file_id +1)% (MBASE_MAX_FILE_ID);\r
2334         return ret;\r
2335 }\r
2336 #endif ///< FEATURE_MBASE_OUT_ENABLE\r
2337 \r
2338 ///**********************************************************************\r
2339 ///   [function]:  zet622x_ts_set_transfer_type\r
2340 ///   [parameters]: void\r
2341 ///   [return]: int\r
2342 ///**********************************************************************\r
2343 #ifdef FEATURE_INFO_OUT_EANBLE\r
2344 int zet622x_ts_set_info_type(void)\r
2345 {\r
2346         int ret = 1;\r
2347         u8 ts_cmd[1] = {0xB2};\r
2348         transfer_type = TRAN_TYPE_INFORMATION_TYPE;\r
2349         ret = zet622x_i2c_write_tsdata(this_client, ts_cmd, 1);\r
2350         if(ret <= 0)\r
2351         {\r
2352                 transfer_type = TRAN_TYPE_DYNAMIC;\r
2353         }\r
2354         return ret;\r
2355 }\r
2356 #endif ///< FEATURE_INFO_OUT_EANBLE\r
2357 \r
2358 ///**********************************************************************\r
2359 ///   [function]:  zet622x_ts_parse_info\r
2360 ///   [parameters]: client\r
2361 ///   [return]: u8\r
2362 ///**********************************************************************\r
2363 #ifdef FEATURE_INFO_OUT_EANBLE\r
2364 u8 zet622x_ts_parse_info(struct i2c_client *client)\r
2365 {\r
2366         int packet_size = INFO_DATA_SIZE;\r
2367         int ret = 0;\r
2368         int i;\r
2369         int len = packet_size;\r
2370         char info_file_name_out[128];\r
2371         u8 key_enable = FALSE;\r
2372         \r
2373 \r
2374         \r
2375         ret = zet622x_i2c_read_tsdata(client, &tran_data[0], 1);\r
2376         if(tran_data[0] == FINGER_REPROT_DATA_HEADER)\r
2377         {\r
2378                 return FALSE;\r
2379         }\r
2380         \r
2381         ret = zet622x_i2c_read_tsdata(client, &tran_data[1], len-1);\r
2382 \r
2383         transfer_type = TRAN_TYPE_DYNAMIC;\r
2384 \r
2385         /// check the ic type is right\r
2386         if(tran_data[0] != ZET6231_INFO && \r
2387            tran_data[0] != ZET6251_INFO &&\r
2388            tran_data[0] != ZET6223_INFO )  \r
2389         {\r
2390                 printk("[ZET] :  zet622x_ts_parse_info IC model fail 0x%X,  0x%X", tran_data[0] ,  tran_data[1] );\r
2391                 return -1;\r
2392         }\r
2393 #ifndef FEATURE_FW_UPGRADE\r
2394         if(tran_data[0] == ZET6231_INFO)\r
2395         {\r
2396                 ic_model = MODEL_ZET6231;\r
2397         }\r
2398         else if(tran_data[0] == ZET6251_INFO)\r
2399         {\r
2400                 ic_model = MODEL_ZET6251;\r
2401         }\r
2402         else if( tran_data[0] == ZET6223_INFO)\r
2403         {\r
2404                 ic_model = MODEL_ZET6223;\r
2405         }\r
2406 #endif ///< for FEATURE_FW_UPGRADE      \r
2407         for(i = 0 ; i < 8 ; i++)\r
2408         {\r
2409                 pcode[i] = tran_data[i] & 0xff;\r
2410         }\r
2411 \r
2412         xy_exchange = (tran_data[16] & 0x8) >> 3;\r
2413         if(xy_exchange == 1)\r
2414         {\r
2415                 resolution_y = tran_data[9] & 0xff;\r
2416                 resolution_y = (resolution_y << 8)|(tran_data[8] & 0xff);\r
2417                 resolution_x = tran_data[11] & 0xff;\r
2418                 resolution_x = (resolution_x << 8) | (tran_data[10] & 0xff);\r
2419         }\r
2420         else\r
2421         {\r
2422                 resolution_x = tran_data[9] & 0xff;\r
2423                 resolution_x = (resolution_x << 8)|(tran_data[8] & 0xff);\r
2424                 resolution_y = tran_data[11] & 0xff;\r
2425                 resolution_y = (resolution_y << 8) | (tran_data[10] & 0xff);\r
2426         }\r
2427                 \r
2428         finger_num = (tran_data[15] & 0x7f);\r
2429         key_enable = (tran_data[15] & 0x80);\r
2430         if(key_enable == 0)\r
2431         {\r
2432                 finger_packet_size  = 3 + 4*finger_num;\r
2433         }\r
2434         else\r
2435         {\r
2436                 finger_packet_size  = 3 + 4*finger_num + 1;\r
2437         }\r
2438         \r
2439         col = tran_data[13];  ///< trace x\r
2440         row = tran_data[14];  ///< trace y\r
2441 \r
2442         sprintf(info_file_name_out, "%s%s.bin",tran_type_mode_file_name, INFO_FILE_NAME);       \r
2443         zet_information_save(info_file_name_out);\r
2444                 \r
2445         return ret;\r
2446 }\r
2447 #endif ///< FEATURE_INFO_OUT_EANBLE\r
2448 \r
2449 ///**********************************************************************\r
2450 ///   [function]:  zet622x_ts_set_trace_x_type\r
2451 ///   [parameters]: void\r
2452 ///   [return]: int\r
2453 ///**********************************************************************\r
2454 #ifdef FEATURE_INFO_OUT_EANBLE\r
2455 int zet622x_ts_set_trace_x_type(void)\r
2456 {\r
2457         int ret = 0;\r
2458         u8 ts_cmd[10] = {0xC1, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; \r
2459         transfer_type = TRAN_TYPE_TRACE_X_TYPE;\r
2460         ret = zet622x_i2c_write_tsdata(this_client, ts_cmd, 10);\r
2461         if(ret <= 0)\r
2462         {\r
2463                 transfer_type = TRAN_TYPE_DYNAMIC;\r
2464         }\r
2465         return ret;        \r
2466 }\r
2467 #endif ///< FEATURE_INFO_OUT_EANBLE\r
2468 \r
2469 ///**********************************************************************\r
2470 ///   [function]:  zet622x_ts_parse_trace_x\r
2471 ///   [parameters]: client\r
2472 ///   [return]: u8\r
2473 ///**********************************************************************\r
2474 #ifdef FEATURE_INFO_OUT_EANBLE\r
2475 u8 zet622x_ts_parse_trace_x(struct i2c_client *client)\r
2476 {\r
2477         int packet_size = col;\r
2478         int ret = 0;\r
2479         int len = packet_size;\r
2480         char info_file_name_out[128];\r
2481         \r
2482         \r
2483 \r
2484         ret = zet622x_i2c_read_tsdata(client, &tran_data[0], 1);\r
2485         if(tran_data[0] == FINGER_REPROT_DATA_HEADER)\r
2486         {\r
2487                 return FALSE;\r
2488         }\r
2489         \r
2490         ret = zet622x_i2c_read_tsdata(client, &tran_data[1], len-1);\r
2491 \r
2492         transfer_type = TRAN_TYPE_DYNAMIC;\r
2493         \r
2494         sprintf(info_file_name_out, "%stracex.bin",tran_type_mode_file_name);   \r
2495         zet_trace_x_save(info_file_name_out);\r
2496         return ret;\r
2497 }\r
2498 #endif ///< FEATURE_INFO_OUT_EANBLE\r
2499 \r
2500 ///**********************************************************************\r
2501 ///   [function]:  zet622x_ts_set_trace_y_type\r
2502 ///   [parameters]: void\r
2503 ///   [return]: int\r
2504 ///**********************************************************************\r
2505 #ifdef FEATURE_INFO_OUT_EANBLE\r
2506 int zet622x_ts_set_trace_y_type(void)\r
2507 {\r
2508         int ret = 0;\r
2509         u8 ts_cmd[10] = {0xC1, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; \r
2510         transfer_type = TRAN_TYPE_TRACE_Y_TYPE;\r
2511         ret = zet622x_i2c_write_tsdata(this_client, ts_cmd, 10);\r
2512         if(ret <= 0)\r
2513         {\r
2514                 transfer_type = TRAN_TYPE_DYNAMIC;\r
2515         }\r
2516         return ret;        \r
2517 }\r
2518 #endif ///< FEATURE_INFO_OUT_EANBLE\r
2519 \r
2520 ///**********************************************************************\r
2521 ///   [function]:  zet622x_ts_parse_trace_x\r
2522 ///   [parameters]: client\r
2523 ///   [return]: u8\r
2524 ///**********************************************************************\r
2525 #ifdef FEATURE_INFO_OUT_EANBLE\r
2526 u8 zet622x_ts_parse_trace_y(struct i2c_client *client)\r
2527 {\r
2528         int packet_size = row;\r
2529         int ret = 0;\r
2530         int len = packet_size;\r
2531         char info_file_name_out[128];\r
2532 \r
2533         ret = zet622x_i2c_read_tsdata(client, &tran_data[0], 1);\r
2534         if(tran_data[0] == FINGER_REPROT_DATA_HEADER)\r
2535         {\r
2536                 return FALSE;\r
2537         }\r
2538         \r
2539         ret = zet622x_i2c_read_tsdata(client, &tran_data[1], len-1);\r
2540 \r
2541         transfer_type = TRAN_TYPE_DYNAMIC;\r
2542         \r
2543         sprintf(info_file_name_out, "%stracey.bin",tran_type_mode_file_name);   \r
2544         zet_trace_y_save(info_file_name_out);\r
2545         return ret;\r
2546 }\r
2547 #endif ///< FEATURE_INFO_OUT_EANBLE\r
2548 \r
2549 \r
2550 ///**********************************************************************\r
2551 ///   [function]:  zet622x_ts_get_information\r
2552 ///   [parameters]: client\r
2553 ///   [return]: u8\r
2554 ///**********************************************************************\r
2555 u8 zet622x_ts_get_information(struct i2c_client *client)\r
2556 {\r
2557         u8 ts_report_cmd[1] = {0xB2};\r
2558         u8 ts_in_data[17] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};\r
2559         int ret;\r
2560         int i;\r
2561         u8 key_enable = FALSE;\r
2562         \r
2563         ret = zet622x_i2c_write_tsdata(client, ts_report_cmd, 1);\r
2564 \r
2565         if (ret > 0)\r
2566         {\r
2567                 msleep(10);\r
2568                 printk ("[ZET] : B2 read\n");\r
2569                 ret = zet622x_i2c_read_tsdata(client, ts_in_data, 17);\r
2570                         \r
2571                 if(ret > 0)\r
2572                 {\r
2573                         for(i = 0 ; i < 8 ; i++)\r
2574                         {\r
2575                                 pcode[i] = ts_in_data[i] & 0xff;\r
2576                         }\r
2577 \r
2578                         xy_exchange = (ts_in_data[16] & 0x8) >> 3;\r
2579                         if(xy_exchange == 1)\r
2580                         {\r
2581                                 resolution_y = ts_in_data[9] & 0xff;\r
2582                                 resolution_y = (resolution_y << 8)|(ts_in_data[8] & 0xff);\r
2583                                 resolution_x = ts_in_data[11] & 0xff;\r
2584                                 resolution_x = (resolution_x << 8) | (ts_in_data[10] & 0xff);\r
2585                         }\r
2586                         else\r
2587                         {\r
2588                                 resolution_x = ts_in_data[9] & 0xff;\r
2589                                 resolution_x = (resolution_x << 8)|(ts_in_data[8] & 0xff);\r
2590                                 resolution_y = ts_in_data[11] & 0xff;\r
2591                                 resolution_y = (resolution_y << 8) | (ts_in_data[10] & 0xff);\r
2592                         }\r
2593                                         \r
2594                         finger_num = (ts_in_data[15] & 0x7f);\r
2595                         \r
2596                         key_enable = (ts_in_data[15] & 0x80);\r
2597                         if(key_enable == 0)\r
2598                         {\r
2599                                 finger_packet_size  = 3 + 4*finger_num;\r
2600                         }\r
2601                         else\r
2602                         {\r
2603                                 finger_packet_size  = 3 + 4*finger_num + 1;\r
2604                         }\r
2605                 }\r
2606                 else\r
2607                 {\r
2608                         printk ("[ZET] : B2 fail\n");\r
2609                         return ret;\r
2610                 }\r
2611         }\r
2612         else\r
2613         {\r
2614                 return ret;\r
2615         }\r
2616         return 1;\r
2617 }\r
2618 \r
2619 ///**********************************************************************\r
2620 ///   [function]:  zet622x_ts_interrupt\r
2621 ///   [parameters]: irq, dev_id\r
2622 ///   [return]: irqreturn_t\r
2623 ///**********************************************************************\r
2624 #ifndef FEATURE_INT_FREE\r
2625 static irqreturn_t zet622x_ts_interrupt(int irq, void *dev_id)\r
2626 {\r
2627         if(gpio_get_value(TS_INT_GPIO) == 0)\r
2628         {\r
2629                 struct zet622x_tsdrv *ts_drv = dev_id;\r
2630                 queue_work(ts_drv->ts_workqueue, &ts_drv->work1);\r
2631         }\r
2632         return IRQ_HANDLED;\r
2633 }\r
2634 #endif ///< for FEATURE_INT_FREE\r
2635 \r
2636 ///************************************************************************\r
2637 ///   [function]:  zet62xx_ts_init\r
2638 ///   [parameters]: \r
2639 ///   [return]: void\r
2640 ///************************************************************************\r
2641 #ifdef FEAURE_LIGHT_LOAD_REPORT_MODE\r
2642 static void zet62xx_ts_init(void)\r
2643 {\r
2644         u8 i;\r
2645         /// initital the pre-finger status \r
2646         for(i = 0 ; i < MAX_FINGER_NUMBER ; i++)\r
2647         {\r
2648                 pre_event[i].pressed = PRE_PRESSED_DEFAULT_VALUE;\r
2649         }\r
2650 }\r
2651 #endif ///< for FEAURE_LIGHT_LOAD_REPORT_MODE\r
2652 \r
2653 ///**********************************************************************\r
2654 ///   [function]:  zet622x_ts_clean_finger\r
2655 ///   [parameters]: work\r
2656 ///   [return]: void\r
2657 ///**********************************************************************\r
2658 #ifdef FEATURE_SUSPEND_CLEAN_FINGER\r
2659 static void zet622x_ts_clean_finger(struct zet622x_tsdrv *ts )\r
2660 {\r
2661         int i;\r
2662         //printk("[ZET] : clean point:\n");\r
2663 \r
2664                 \r
2665 #ifdef FEATURE_BTN_TOUCH\r
2666         input_report_key(ts->input, BTN_TOUCH, 0);\r
2667 #endif ///< for FEATURE_BTN_TOUCH\r
2668 \r
2669 #ifdef FEATURE_MT_TYPE_B\r
2670         for(i = 0; i < finger_num; i++)\r
2671         {\r
2672                 input_mt_slot(ts->input, i);\r
2673                 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, false);\r
2674                 input_report_abs(ts->input, ABS_MT_TRACKING_ID, -1);\r
2675         }\r
2676         input_mt_report_pointer_emulation(ts->input, true);\r
2677         #else ///< for FEATURE_MT_TYPE_B                                \r
2678         input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, 0);\r
2679         input_mt_sync(ts->input);\r
2680 #endif ///< for FEATURE_MT_TYPE_B\r
2681         input_sync(ts->input);          \r
2682 }\r
2683 #endif ///< for FEATURE_SUSPEND_CLEAN_FINGER\r
2684 \r
2685 ///**********************************************************************\r
2686 ///   [function]:  zet62xx_ts_auto_zoom\r
2687 ///   [parameters]: finger_report_data\r
2688 ///   [return]: void\r
2689 ///**********************************************************************\r
2690 void zet62xx_ts_auto_zoom(struct finger_coordinate_struct* finger_report_data)\r
2691 {\r
2692         int i;\r
2693         u32 value_x;\r
2694         u32 value_y;\r
2695 \r
2696         for(i = 0 ; i < MAX_FINGER_NUMBER ; i++)\r
2697         {\r
2698                 if(finger_report_data[i].valid != TRUE)\r
2699                 {\r
2700                         continue;\r
2701                 }\r
2702                 value_x = (u32)(((finger_report_data[i].report_x*X_MAX*10)/FW_X_RESOLUTION + 5)/10);\r
2703                 value_y = (u32)(((finger_report_data[i].report_y*Y_MAX*10)/FW_Y_RESOLUTION + 5)/10);\r
2704                 finger_report_data[i].report_x = value_x;\r
2705                 finger_report_data[i].report_y = value_y;       \r
2706         }\r
2707 }\r
2708 \r
2709 ///**********************************************************************\r
2710 ///   [function]:  zet622x_ts_coordinate_translating\r
2711 ///   [parameters]: px, py, p\r
2712 ///   [return]: void\r
2713 ///**********************************************************************\r
2714 void zet622x_ts_coordinate_translating(struct finger_coordinate_struct* finger_report_data)\r
2715 {\r
2716 \r
2717         int i;\r
2718 #if ORIGIN == ORIGIN_TOP_RIGHT\r
2719         for(i = 0 ; i < MAX_FINGER_NUMBER ; i++)\r
2720         {\r
2721                 if(finger_report_data[i].valid == TRUE)\r
2722                 {\r
2723                         finger_report_data[i].report_x  = X_MAX - finger_report_data[i].report_x ;\r
2724                 }\r
2725         }\r
2726 #elif ORIGIN == ORIGIN_BOTTOM_RIGHT\r
2727         for(i = 0 ; i < MAX_FINGER_NUMBER ; i++)\r
2728         {\r
2729                 if(finger_report_data[i].valid  == TRUE)\r
2730                 {\r
2731                         finger_report_data[i].report_x  = X_MAX - finger_report_data[i].report_x ;\r
2732                         finger_report_data[i].report_y = Y_MAX - finger_report_data[i].report_y;\r
2733                 }\r
2734         }\r
2735 #elif ORIGIN == ORIGIN_BOTTOM_LEFT\r
2736         for(i = 0 ; i < MAX_FINGER_NUMBER ; i++)\r
2737         {\r
2738                 if(finger_report_data[i].valid == TRUE)\r
2739                 {\r
2740                         finger_report_data[i].report_y = Y_MAX - finger_report_data[i].report_y;\r
2741                 }\r
2742         }\r
2743 #endif ///< for ORIGIN\r
2744 }\r
2745 \r
2746 ///**********************************************************************\r
2747 ///   [function]:  zet622x_ts_parse_dynamic_finger\r
2748 ///   [parameters]: i2c_client\r
2749 ///   [return]: void\r
2750 ///**********************************************************************\r
2751 static u8 zet622x_ts_parse_dynamic_finger(struct i2c_client *client)\r
2752 {\r
2753         u8  ts_data[70];\r
2754         int i;\r
2755         u16 valid;\r
2756         int ret;\r
2757         u8 pressed;\r
2758         \r
2759         memset(ts_data,0,70);\r
2760 \r
2761         ret = zet622x_i2c_read_tsdata(client, &ts_data[0], 1);\r
2762         if(ts_data[0] != FINGER_REPROT_DATA_HEADER)\r
2763         {\r
2764                 return FALSE;\r
2765         }\r
2766         \r
2767         ret = zet622x_i2c_read_tsdata(client, &ts_data[1], finger_packet_size-1);\r
2768         \r
2769         valid = ts_data[1];\r
2770         valid = (valid << 8) | ts_data[2];\r
2771         /// parse the finger data       \r
2772         /// parse the valid data to finger report data\r
2773         for(i = 0; i < finger_num; i++)\r
2774         {\r
2775                 pressed = (valid >> (MAX_FINGER_NUMBER-i-1)) & 0x1;\r
2776                 /// keep the last point data\r
2777                 finger_report[i].last_report_x = finger_report[i].report_x;\r
2778                 finger_report[i].last_report_y = finger_report[i].report_y;\r
2779                 finger_report[i].last_report_z = finger_report[i].report_z;\r
2780                 /// get the finger data\r
2781                 finger_report[i].report_x = (u8)((ts_data[FINGER_HEADER_SHIFT+FINGER_PACK_SIZE*i])>>4)*256 + (u8)ts_data[(FINGER_HEADER_SHIFT+FINGER_PACK_SIZE*i)+1];\r
2782                 finger_report[i].report_y = (u8)((ts_data[FINGER_HEADER_SHIFT+FINGER_PACK_SIZE*i]) & 0x0f)*256 + (u8)ts_data[(FINGER_HEADER_SHIFT+FINGER_PACK_SIZE*i)+2];\r
2783                 finger_report[i].report_z = (u8)((ts_data[(FINGER_HEADER_SHIFT+FINGER_PACK_SIZE*i)+3]) & 0xff);\r
2784                 finger_report[i].valid = pressed;\r
2785         }\r
2786 \r
2787         //if key enable\r
2788         if(key_num > 0)\r
2789         {\r
2790                 finger_report_key = ts_data[FINGER_HEADER_SHIFT+FINGER_PACK_SIZE*finger_num];\r
2791         }\r
2792 \r
2793                 \r
2794 #ifdef FEATURE_AUTO_ZOOM_ENABLE\r
2795         zet62xx_ts_auto_zoom(finger_report);\r
2796 #endif ///< for FEATURE_AUTO_ZOOM_ENABLE\r
2797 \r
2798 #ifdef FEATURE_TRANSLATE_ENABLE\r
2799         zet622x_ts_coordinate_translating(finger_report);\r
2800 #endif ///< for FEATURE_TRANSLATE_ENABLE\r
2801 #ifdef FEATURE_FRAM_RATE\r
2802         fram_rate = fram_rate + 1;\r
2803 #endif ///< FEATURE_FRAM_RATE\r
2804         return TRUE;\r
2805 \r
2806 }\r
2807 \r
2808 ///**********************************************************************\r
2809 ///   [function]:  zet622x_ts_finger_up_report\r
2810 ///   [parameters]: ts,  index\r
2811 ///   [return]: void\r
2812 ///**********************************************************************\r
2813 static void zet622x_ts_finger_up_report(struct zet622x_tsdrv *ts, int index)\r
2814 {\r
2815 #ifdef FEAURE_LIGHT_LOAD_REPORT_MODE\r
2816         if(pre_event[index].pressed == FALSE)  ///< check the pre-finger status is up\r
2817         {\r
2818                 return;\r
2819         }\r
2820         pre_event[index].pressed = FALSE;\r
2821 #endif  ///< for FEAURE_LIGHT_LOAD_REPORT_MODE\r
2822         input_mt_slot(ts->input, index);\r
2823         input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, false);\r
2824         input_report_abs(ts->input, ABS_MT_TRACKING_ID, -1);\r
2825 }\r
2826 \r
2827 ///**********************************************************************\r
2828 ///   [function]:  zet62xx_ts_finger_down_report\r
2829 ///   [parameters]: ts, index\r
2830 ///   [return]: void\r
2831 ///**********************************************************************\r
2832 static void zet62xx_ts_finger_down_report( struct zet622x_tsdrv *ts, int index, struct finger_coordinate_struct* report_data)\r
2833 {\r
2834 \r
2835 #ifdef FEATURE_BTN_TOUCH\r
2836         input_report_key(ts->input, BTN_TOUCH, 1);\r
2837 #endif ///< for FEATURE_BTN_TOUCH \r
2838 #ifdef FEAURE_LIGHT_LOAD_REPORT_MODE\r
2839         /// check the pre-finger status is pressed and X,Y is same, than skip report to the host\r
2840         if((pre_event[index].pressed == TRUE) &&\r
2841         (pre_event[index].pre_x == report_data[index].report_x) &&\r
2842         (pre_event[index].pre_y == report_data[index].report_y))\r
2843         {\r
2844                 return;\r
2845         }\r
2846         /// Send finger down status to host\r
2847         pre_event[index].pressed = TRUE;\r
2848         pre_event[index].pre_x = report_data[index].report_x;\r
2849         pre_event[index].pre_y =  report_data[index].report_y;\r
2850         pre_event[index].pre_z =  report_data[index].report_z;\r
2851 #endif ///< for FEAURE_LIGHT_LOAD_REPORT_MODE \r
2852 \r
2853 #ifdef FEATURE_VIRTUAL_KEY\r
2854         if( report_data[index].report_y > TP_AA_Y_MAX)\r
2855         { \r
2856                 report_data[index].report_y = TP_AA_Y_MAX;\r
2857         }\r
2858 #endif ///< for FEATURE_VIRTUAL_KEY\r
2859 \r
2860 #ifdef FEATURE_MT_TYPE_B\r
2861         input_mt_slot(ts->input, index);\r
2862         input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);\r
2863         input_report_abs(ts->input,ABS_MT_PRESSURE,  PRESSURE_CONST);\r
2864 #endif ///< for FEATURE_MT_TYPE_B\r
2865 \r
2866         input_report_abs(ts->input, ABS_MT_TRACKING_ID, index);\r
2867         input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, PRESSURE_CONST);\r
2868         input_report_abs(ts->input, ABS_MT_POSITION_X,  report_data[index].report_x);\r
2869         input_report_abs(ts->input, ABS_MT_POSITION_Y,  report_data[index].report_y);\r
2870         //printk("xhh ============== x = %d  , y = %d  \n",report_data[index].report_x,report_data[index].report_y);\r
2871 #ifndef FEATURE_MT_TYPE_B                       \r
2872         input_mt_sync(ts->input);\r
2873 #endif ///< for FEATURE_MT_TYPE_B\r
2874 }\r
2875 \r
2876 ///**********************************************************************\r
2877 ///   [function]:  zet622x_ts_key_report\r
2878 ///   [parameters]: ts, key index\r
2879 ///   [return]: void\r
2880 ///**********************************************************************\r
2881 static void zet622x_ts_key_report(struct zet622x_tsdrv *ts, u8 ky)\r
2882 {\r
2883         int i;\r
2884         u8 pressed;\r
2885         \r
2886 #ifdef FEATURE_VIRTUAL_KEY\r
2887 LABEL_KEY_FINGER:\r
2888 #endif ///< for FEATURE_VIRTUAL_KEY\r
2889         if(key_num <= 0)\r
2890         {\r
2891                 return;\r
2892         }\r
2893         for(i = 0 ; i < KEY_NUMBER ; i++)\r
2894         {                       \r
2895                 pressed = ky & ( 0x01 << i );\r
2896                 switch(i)\r
2897                 {\r
2898                         case 0:\r
2899                                 if(pressed == TRUE)\r
2900                                 {\r
2901                                         if(!key_search_pressed)\r
2902                                         {\r
2903                                                 input_report_key(ts->input, KEY_SEARCH, 1);\r
2904                                                 key_search_pressed = 0x1;\r
2905                                         }\r
2906                                 }\r
2907                                 else\r
2908                                 {\r
2909                                         if(key_search_pressed)\r
2910                                         {\r
2911                                                 input_report_key(ts->input, KEY_SEARCH, 0);\r
2912                                                 key_search_pressed = 0x0;\r
2913                                         }\r
2914                                 }\r
2915                                 \r
2916                                 break;\r
2917                         case 1:\r
2918                                 if(pressed == TRUE)\r
2919                                 {\r
2920                                         if(!key_back_pressed)\r
2921                                         {\r
2922                                                 input_report_key(ts->input, KEY_BACK, 1);\r
2923                                                 key_back_pressed = 0x1;\r
2924                                         }\r
2925                                 }\r
2926                                 else\r
2927                                 {\r
2928                                         if(key_back_pressed)\r
2929                                         {\r
2930                                                 input_report_key(ts->input, KEY_BACK, 0);\r
2931                                                 key_back_pressed = 0x0;\r
2932                                         }\r
2933                                 }\r
2934                                 \r
2935                                 break;\r
2936                         case 2:\r
2937                                 if(pressed == TRUE)\r
2938                                 {\r
2939                                         if(!key_home_pressed)\r
2940                                         {\r
2941                                                 input_report_key(ts->input, KEY_HOME, 1);\r
2942                                                 key_home_pressed = 0x1;\r
2943                                         }\r
2944                                 }\r
2945                                 else\r
2946                                 {\r
2947                                         if(key_home_pressed)\r
2948                                         {\r
2949                                                 input_report_key(ts->input, KEY_HOME, 0);\r
2950                                                 key_home_pressed = 0x0;\r
2951                                         }\r
2952                                 }\r
2953                                 \r
2954                                 break;\r
2955                         case 3:\r
2956                                 if(pressed == TRUE)\r
2957                                 {\r
2958                                         if(!key_menu_pressed)\r
2959                                         {\r
2960                                                 input_report_key(ts->input, KEY_MENU, 1);\r
2961                                                 key_menu_pressed = 0x1;\r
2962                                         }\r
2963                                 }\r
2964                                 else\r
2965                                 {\r
2966                                         if(key_menu_pressed)\r
2967                                         {\r
2968                                                 input_report_key(ts->input, KEY_MENU, 0);\r
2969                                                 key_menu_pressed = 0x0;\r
2970                                         }\r
2971                                 }\r
2972                                 break;\r
2973                         case 4:\r
2974                                 break;\r
2975                         case 5:\r
2976                                 break;\r
2977                         case 6:\r
2978                                 break;\r
2979                         case 7:\r
2980                                 break;\r
2981                 }\r
2982 \r
2983         }\r
2984 }\r
2985 \r
2986 ///**********************************************************************\r
2987 ///   [function]:  zet622x_ts_finger_report\r
2988 ///   [parameters]: work\r
2989 ///   [return]: void\r
2990 ///**********************************************************************\r
2991 static void zet622x_ts_finger_report(struct zet622x_tsdrv *ts)\r
2992 {\r
2993         int i;\r
2994         u8 finger_cnt = 0;\r
2995         u8 chk_finger = FALSE;\r
2996         u8 ky = finger_report_key;\r
2997         \r
2998         ///-------------------------------------------///\r
2999         /// check have finger data\r
3000         ///-------------------------------------------///\r
3001         for(i = 0; i < finger_num; i++)\r
3002         {\r
3003                 if(finger_report[i].valid == TRUE)\r
3004                 {\r
3005                         chk_finger = TRUE;\r
3006                         finger_cnt = finger_cnt + 1; \r
3007                 }\r
3008         }\r
3009 \r
3010 #ifdef FEATURE_VIRTUAL_KEY\r
3011         key_num = TPD_KEY_COUNT;\r
3012          /// only finger 1 enable and the report location on the virtual key area\r
3013         if((finger_cnt == 1) && (finger_report[0].pressed == TRUE) && (finger_report[0].y > TP_AA_Y_MAX))\r
3014         {\r
3015                 if((finger_report[0].x >= tpd_keys_dim[0][0]) && \r
3016                    (finger_report[0].x <= tpd_keys_dim[0][1]) && \r
3017                    (finger_report[0].y >= tpd_keys_dim[0][2]) && \r
3018                    (finger_report[0].y <= tpd_keys_dim[0][3]))\r
3019                 {\r
3020                         ky=0x1;\r
3021                 }\r
3022                 else if((finger_report[0].x >= tpd_keys_dim[1][0]) && \r
3023                         (finger_report[0].x <= tpd_keys_dim[1][1]) && \r
3024                         (finger_report[0].y >= tpd_keys_dim[1][2]) && \r
3025                         (finger_report[0].y <= tpd_keys_dim[1][3]) ) \r
3026                 {\r
3027                         ky=0x2;\r
3028                 }\r
3029                 else if((finger_report[0].x >= tpd_keys_dim[2][0]) && \r
3030                         (finger_report[0].x <= tpd_keys_dim[2][1]) && \r
3031                         (finger_report[0].y >= tpd_keys_dim[2][2]) && \r
3032                         (finger_report[0].y <= tpd_keys_dim[2][3])) \r
3033                 {\r
3034                         ky=0x4;\r
3035                 }\r
3036                 else if((finger_report[0].x >= tpd_keys_dim[3][0]) && \r
3037                         (finger_report[0].x <= tpd_keys_dim[3][1]) && \r
3038                         (finger_report[0].y >= tpd_keys_dim[3][2]) && \r
3039                         (finger_report[0].y <= tpd_keys_dim[3][3])) \r
3040                 {\r
3041                         ky=0x8;\r
3042                 }\r
3043                 goto LABEL_KEY_REPORT;\r
3044         }\r
3045 #endif ///< for FEATURE_VIRTUAL_KEY\r
3046 \r
3047         ///-------------------------------------------///\r
3048         /// all finger up report \r
3049         ///-------------------------------------------///\r
3050         if(chk_finger == FALSE)\r
3051         {\r
3052                 /// finger up debounce check\r
3053                 finger_up_cnt++;\r
3054                 if(finger_up_cnt >= DEBOUNCE_NUMBER)\r
3055                 {\r
3056                         finger_up_cnt = 0;\r
3057 #ifdef FEATURE_BTN_TOUCH\r
3058                         input_report_key(ts->input, BTN_TOUCH, 0);\r
3059 #endif ///< for FEATURE_BTN_TOUCH\r
3060                         for(i = 0; i < finger_num; i++)\r
3061                         {\r
3062                                 /// finger up setting\r
3063                                 zet622x_ts_finger_up_report(ts, i);\r
3064                         }\r
3065                 }\r
3066         }\r
3067         else\r
3068         {\r
3069                 ///-------------------------------------------///\r
3070                 /// parse finger report \r
3071                 ///-------------------------------------------///\r
3072                 finger_up_cnt = 0;\r
3073                 for(i = 0 ; i < finger_num ; i++)\r
3074                 {\r
3075                         if(finger_report[i].valid == TRUE)\r
3076                         {\r
3077                                 /// finger down setting\r
3078                                 zet62xx_ts_finger_down_report(ts, i, finger_report);\r
3079                         }\r
3080                         else\r
3081                         {\r
3082                                 /// finger up setting\r
3083                                 zet622x_ts_finger_up_report(ts, i);                             \r
3084                         }\r
3085                 }\r
3086 #ifdef FEATURE_MT_TYPE_B\r
3087                 input_mt_report_pointer_emulation(ts->input, true);\r
3088 #endif ///< for FEATURE_MT_TYPE_B\r
3089                 \r
3090         }\r
3091 #ifdef FEATURE_VIRTUAL_KEY\r
3092 LABEL_KEY_REPORT:\r
3093 #endif ///< FEATURE_VIRTUAL_KEY\r
3094 \r
3095         zet622x_ts_key_report(ts, ky);\r
3096         input_sync(ts->input);  \r
3097 }\r
3098 \r
3099 ///**********************************************************************\r
3100 ///   [function]:  zet622x_ts_work\r
3101 ///   [parameters]: work\r
3102 ///   [return]: void\r
3103 ///**********************************************************************\r
3104 static void zet622x_ts_work(struct work_struct *_work)\r
3105 {\r
3106         struct zet622x_tsdrv *ts = \r
3107                 container_of(_work, struct zet622x_tsdrv, work1);\r
3108 \r
3109         struct i2c_client *tsclient1 = ts->i2c_dev;\r
3110 \r
3111         ///-------------------------------------------///\r
3112         /// Read no fingers in suspend mode\r
3113         ///-------------------------------------------///\r
3114         if(suspend_mode == TRUE)\r
3115         {\r
3116                 return;\r
3117         }\r
3118 \r
3119         if(finger_packet_size == 0)\r
3120         {\r
3121                 return;\r
3122         }\r
3123 \r
3124         if(resume_download == TRUE)\r
3125         {\r
3126                 return;\r
3127         }\r
3128 \r
3129         ///-------------------------------------------///\r
3130         /// Dummy report \r
3131         ///-------------------------------------------///\r
3132         if(dummy_report_cnt == 1)\r
3133         {\r
3134                 dummy_report_cnt = 0;\r
3135                 return;\r
3136         }\r
3137 #ifdef FEATURE_INFO_OUT_EANBLE\r
3138         ///-------------------------------------------///\r
3139         /// Transfer Type :get IC information\r
3140         ///-------------------------------------------///\r
3141         if(transfer_type == TRAN_TYPE_INFORMATION_TYPE)\r
3142         {\r
3143                 zet622x_ts_parse_info(tsclient1);\r
3144                 return; \r
3145         }\r
3146         \r
3147         ///-------------------------------------------///\r
3148         /// Transfer Type :get trace Y name \r
3149         ///-------------------------------------------///\r
3150         if(transfer_type == TRAN_TYPE_TRACE_Y_TYPE)\r
3151         {\r
3152                 zet622x_ts_parse_trace_y(tsclient1);\r
3153                 return; \r
3154         }\r
3155 \r
3156         ///-------------------------------------------///\r
3157         /// Transfer Type :get trace X name \r
3158         ///-------------------------------------------///\r
3159         if(transfer_type == TRAN_TYPE_TRACE_X_TYPE)\r
3160         {\r
3161                 zet622x_ts_parse_trace_x(tsclient1);\r
3162                 return; \r
3163         }\r
3164         \r
3165 #endif ///< for FEATURE_INFO_OUT_EANBLE\r
3166         ///-------------------------------------------///\r
3167         /// Transfer Type : Mutual Dev Mode \r
3168         ///-------------------------------------------///\r
3169 #ifdef FEATURE_MDEV_OUT_ENABLE\r
3170         if(transfer_type == TRAN_TYPE_MUTUAL_SCAN_DEV)\r
3171         {\r
3172                 zet622x_ts_parse_mutual_dev(tsclient1);\r
3173                 return; \r
3174         }\r
3175 #endif ///< FEATURE_MDEV_OUT_ENABLE\r
3176 \r
3177         ///-------------------------------------------///\r
3178         /// Transfer Type : Initial Base Mode \r
3179         ///-------------------------------------------///\r
3180 #ifdef FEATURE_IBASE_OUT_ENABLE\r
3181         if(transfer_type == TRAN_TYPE_INIT_SCAN_BASE)\r
3182         {\r
3183                 zet622x_ts_parse_initial_base(tsclient1);\r
3184                 return; \r
3185         }       \r
3186 #endif ///< FEATURE_IBASE_OUT_ENABLE\r
3187 \r
3188         ///-------------------------------------------///\r
3189         /// Transfer Type :  fpc open Mode \r
3190         ///-------------------------------------------///\r
3191 #ifdef FEATURE_FPC_OPEN_ENABLE\r
3192         if(transfer_type == TRAN_TYPE_FPC_OPEN)\r
3193         {\r
3194                 zet622x_ts_parse_fpc_open(tsclient1);\r
3195                 return; \r
3196         }       \r
3197 #endif ///< FEATURE_FPC_OPEN_ENABLE\r
3198 \r
3199         ///-------------------------------------------///\r
3200         /// Transfer Type : fpc short  Mode \r
3201         ///-------------------------------------------///\r
3202 #ifdef FEATURE_FPC_SHORT_ENABLE\r
3203         if(transfer_type == TRAN_TYPE_FPC_SHORT)\r
3204         {\r
3205                 zet622x_ts_parse_fpc_short(tsclient1);\r
3206                 return; \r
3207         }       \r
3208 #endif ///< FEATURE_FPC_SHORT_ENABLE\r
3209 \r
3210         ///-------------------------------------------///\r
3211         /// Transfer Type : Initial Dev Mode \r
3212         ///-------------------------------------------///\r
3213 #ifdef FEATURE_IDEV_OUT_ENABLE\r
3214         if(transfer_type == TRAN_TYPE_INIT_SCAN_DEV)\r
3215         {\r
3216                 zet622x_ts_parse_initial_dev(tsclient1);\r
3217                 return; \r
3218         }\r
3219 #endif ///< TRAN_TYPE_INIT_SCAN_DEV\r
3220 \r
3221         ///-------------------------------------------///\r
3222         /// Transfer Type : Mutual Base Mode \r
3223         ///-------------------------------------------///\r
3224 #ifdef FEATURE_MBASE_OUT_ENABLE\r
3225         if(transfer_type == TRAN_TYPE_MUTUAL_SCAN_BASE)\r
3226         {\r
3227                 zet622x_ts_parse_mutual_base(tsclient1);\r
3228                 return; \r
3229         }\r
3230 #endif ///< FEATURE_MBASE_OUT_ENABLE\r
3231         ///-------------------------------------------///\r
3232         /// Transfer Type : Dynamic Mode \r
3233         ///-------------------------------------------///\r
3234         if(zet622x_ts_parse_dynamic_finger(tsclient1) != TRUE)\r
3235         {\r
3236                 return;\r
3237         }\r
3238 \r
3239         ///-------------------------------------------///\r
3240         /// report the finger data\r
3241         ///-------------------------------------------///\r
3242         zet622x_ts_finger_report(ts);\r
3243         \r
3244 }\r
3245 \r
3246 ///**********************************************************************\r
3247 ///   [function]:  zet622x_ts_fram_rate\r
3248 ///   [parameters]: NULL\r
3249 ///   [return]: void\r
3250 ///***********************************************************************\r
3251 #ifdef FEATURE_FRAM_RATE\r
3252 static void zet622x_ts_fram_rate(void)\r
3253 {\r
3254 \r
3255         last_fram_rate = fram_rate;     \r
3256         fram_rate = 0;\r
3257         //printk("[ZET] : fram rate : %d\n", last_fram_rate);\r
3258 }\r
3259 #endif ///< FEATURE_FRAM_RATE\r
3260 \r
3261 ///**********************************************************************\r
3262 ///   [function]:  zet622x_ts_timer_task\r
3263 ///   [parameters]: arg\r
3264 ///   [return]: void\r
3265 ///***********************************************************************\r
3266 static void zet622x_ts_timer_task(unsigned long arg)\r
3267 {\r
3268         struct zet622x_tsdrv *ts_drv = (struct zet622x_tsdrv *)arg;\r
3269         queue_work(ts_drv->ts_workqueue1, &ts_drv->work2);\r
3270         mod_timer(&ts_drv->zet622x_ts_timer_task,jiffies + msecs_to_jiffies(polling_time));     \r
3271 }\r
3272 \r
3273 ///**********************************************************************\r
3274 ///   [function]:  zet622x_ts_polling_task\r
3275 ///   [parameters]: arg\r
3276 ///   [return]: void\r
3277 ///***********************************************************************\r
3278 #ifdef FEATURE_INT_FREE\r
3279 static void zet622x_ts_polling_task(unsigned long arg)\r
3280 {\r
3281         struct zet622x_tsdrv *ts_drv = (struct zet622x_tsdrv *)arg;\r
3282         queue_work(ts_drv->ts_workqueue, &ts_drv->work1);\r
3283         mod_timer(&ts_drv->zet622x_ts_timer_task1, jiffies + msecs_to_jiffies(INT_FREE_TIMER)); \r
3284 }\r
3285 #endif ///< for FEATURE_INT_FREE\r
3286 \r
3287 ///**********************************************************************\r
3288 ///   [function]:  zet622x_ts_fram_rate_task\r
3289 ///   [parameters]: arg\r
3290 ///   [return]: void\r
3291 ///***********************************************************************\r
3292 #ifdef FEATURE_FRAM_RATE\r
3293 static void zet622x_ts_fram_rate_task(unsigned long arg)\r
3294 {\r
3295         struct zet622x_tsdrv *ts_drv = (struct zet622x_tsdrv *)arg;\r
3296         zet622x_ts_fram_rate();\r
3297         mod_timer(&ts_drv->zet622x_ts_timer_task2, jiffies + msecs_to_jiffies(FRAM_RATE_TIMER));        \r
3298 }\r
3299 #endif ///< FEATURE_FRAM_RATE\r
3300 \r
3301 ///**********************************************************************\r
3302 ///   [function]:  zet622x_ts_charge_mode_enable\r
3303 ///   [parameters]: void\r
3304 ///   [return]: void\r
3305 ///**********************************************************************\r
3306 void zet622x_ts_charge_mode_enable(void)\r
3307 {\r
3308         u8 ts_write_charge_cmd[1] = {0xb5}; \r
3309         int ret = 0;\r
3310         \r
3311 #ifdef FEATURE_FW_UPGRADE_RESUME\r
3312         if(resume_download == TRUE)\r
3313         {\r
3314                 return;\r
3315         }\r
3316 #endif ///< for FEATURE_FW_UPGRADE_RESUME\r
3317         if(suspend_mode == TRUE)\r
3318         {\r
3319                 return;\r
3320         }\r
3321         printk("[ZET] : enable charger mode\n");\r
3322         ret = zet622x_i2c_write_tsdata(this_client, ts_write_charge_cmd, 1);\r
3323 \r
3324 }\r
3325 EXPORT_SYMBOL_GPL(zet622x_ts_charge_mode_enable);\r
3326 \r
3327 ///**********************************************************************\r
3328 ///   [function]:  zet622x_ts_charge_mode_disable\r
3329 ///   [parameters]: client\r
3330 ///   [return]: u8\r
3331 ///**********************************************************************\r
3332 void zet622x_ts_charge_mode_disable(void)\r
3333 {\r
3334         u8 ts_write_cmd[1] = {0xb6}; \r
3335         int ret = 0;\r
3336 \r
3337 #ifdef FEATURE_FW_UPGRADE_RESUME\r
3338         if(resume_download == TRUE)\r
3339         {\r
3340                 return;\r
3341         }\r
3342 #endif ///< for FEATURE_FW_UPGRADE_RESUME\r
3343         if(suspend_mode == TRUE)\r
3344         {\r
3345                 return;\r
3346         }\r
3347         printk("[ZET] : disable charger mode\n");\r
3348         ret = zet622x_i2c_write_tsdata(this_client, ts_write_cmd, 1);\r
3349 \r
3350 }\r
3351 EXPORT_SYMBOL_GPL(zet622x_ts_charge_mode_disable);\r
3352 \r
3353 ///**********************************************************************\r
3354 ///   [function]:  zet622x_charger_cmd_work\r
3355 ///   [parameters]: work\r
3356 ///   [return]: void\r
3357 ///***********************************************************************\r
3358 static void zet622x_charger_cmd_work(struct work_struct *_work)\r
3359 {\r
3360         if(suspend_mode == TRUE)\r
3361         {\r
3362                 return;\r
3363         }\r
3364 \r
3365         if(resume_download == TRUE)\r
3366         {\r
3367                 return;\r
3368         }\r
3369 \r
3370         if(charger_on != charger_status)\r
3371         {       \r
3372                 if(charger_on == TRUE)\r
3373                 {\r
3374                         zet622x_ts_charge_mode_enable();\r
3375                         printk("[ZET]:Charger Mode On\n");              \r
3376                 }\r
3377                 else\r
3378                 {\r
3379                         zet622x_ts_charge_mode_disable();\r
3380                         printk("[ZET]:Charger Mode Off\n");             \r
3381                 }\r
3382                 charger_status = charger_on;\r
3383         }\r
3384         \r
3385         ///-------------------------------------------------------------------///\r
3386         /// IOCTL Action\r
3387         ///-------------------------------------------------------------------///\r
3388         if(ioctl_action  & IOCTL_ACTION_FLASH_DUMP)\r
3389         {\r
3390                 printk("[ZET]: IOCTL_ACTION: Dump flash\n");\r
3391                 zet_fw_save(fw_file_name);\r
3392                 ioctl_action &= ~IOCTL_ACTION_FLASH_DUMP;\r
3393         }\r
3394 }\r
3395 \r
3396 ///************************************************************************\r
3397 ///   [function]:  zet622x_ts_sig_check\r
3398 ///   [parameters]: client\r
3399 ///   [return]: void\r
3400 ///************************************************************************\r
3401 #ifdef FEATURE_FW_SIGNATURE\r
3402 int zet622x_ts_sig_check(struct i2c_client *client)\r
3403 {\r
3404         int i;\r
3405         int ret = TRUE;\r
3406 \r
3407         ///---------------------------------///\r
3408         /// if zet6221, then leaves\r
3409         ///---------------------------------///\r
3410         if(ic_model == MODEL_ZET6221)\r
3411         {\r
3412                 printk("[ZET]: signature check ignored\n");\r
3413                 return  TRUE;\r
3414         }\r
3415 \r
3416         ///---------------------------------///\r
3417         /// Read sig page\r
3418         ///---------------------------------///\r
3419         ret = zet622x_cmd_readpage(client, SIG_PAGE_ID, &zet_rx_data[0]);\r
3420         if(ret <= 0)\r
3421         {\r
3422                 printk("[ZET]: signature check fail\n");\r
3423                 return FALSE;\r
3424         }       \r
3425 \r
3426         ///---------------------------------///\r
3427         /// Clear the signature position\r
3428         ///---------------------------------///\r
3429         for(i = 0 ; i < SIG_DATA_LEN ; i++)\r
3430         {\r
3431                 /// erase the sig page last 4 bytes data\r
3432                 flash_buffer[SIG_PAGE_ID * FLASH_PAGE_LEN + SIG_DATA_ADDR + i] = 0xFF;\r
3433         }\r
3434 \r
3435         ///---------------------------------///\r
3436         /// check signature\r
3437         ///---------------------------------///\r
3438         printk("[ZET]: sig_curr[] =  ");\r
3439         for(i = 0 ; i < SIG_DATA_LEN ; i++)\r
3440         {\r
3441                 printk("%02X ", zet_rx_data[i + SIG_DATA_ADDR]);\r
3442         }\r
3443         printk("\n");\r
3444 \r
3445         printk("[ZET]: sig_data[] =  ");\r
3446         for(i = 0 ; i < SIG_DATA_LEN ; i++)\r
3447         {\r
3448                 printk("%02X ", sig_data[i]);\r
3449         }\r
3450         printk("\n");      \r
3451 \r
3452         printk("[ZET]: sig_data[] =  ");\r
3453         for(i = 0 ; i < SIG_DATA_LEN ; i++)\r
3454         {\r
3455                 if(zet_rx_data[i + SIG_DATA_ADDR] != sig_data[i])\r
3456                 {\r
3457                         printk("[ZET]: signature check : not signatured!!\n");\r
3458                         return FALSE;\r
3459                 }\r
3460         }\r
3461         printk("[ZET]: signature check : signatured\n");\r
3462         return  TRUE;\r
3463 \r
3464 }\r
3465 \r
3466 ///************************************************************************\r
3467 ///   [function]:  zet622x_ts_sig_write\r
3468 ///   [parameters]: client\r
3469 ///   [return]: void\r
3470 ///************************************************************************\r
3471 int zet622x_ts_sig_write(struct i2c_client *client)\r
3472 {\r
3473         int i;\r
3474         int ret;\r
3475 \r
3476         ///---------------------------------///\r
3477         /// if zet6221, then leaves\r
3478         ///---------------------------------///\r
3479         if(ic_model == MODEL_ZET6221)\r
3480         {\r
3481                 printk("[ZET]: signature write ignore\n");\r
3482                 return  TRUE;\r
3483         }\r
3484 \r
3485         ///---------------------------------///\r
3486         /// set signature\r
3487         ///---------------------------------///\r
3488         for(i = 0; i < FLASH_PAGE_LEN; i++)\r
3489         {\r
3490                 zet_tx_data[i] = flash_buffer[SIG_PAGE_ID * FLASH_PAGE_LEN + i];\r
3491         }\r
3492 \r
3493         printk("[ZET] : old data\n");\r
3494         for(i = 0 ; i < FLASH_PAGE_LEN ; i++)\r
3495         {\r
3496                 printk("%02x ", zet_tx_data[i]);\r
3497                 if((i%0x10) == 0x0F)\r
3498                 {\r
3499                         printk("\n");\r
3500                 }\r
3501                 else if((i%0x08) == 0x07)\r
3502                 {\r
3503                         printk(" - ");\r
3504                 }\r
3505         }\r
3506 \r
3507 \r
3508         ///---------------------------------///\r
3509         /// set signature\r
3510         ///---------------------------------///\r
3511         for(i = 0 ; i < SIG_DATA_LEN ; i++)\r
3512         {\r
3513                 zet_tx_data[ i + SIG_DATA_ADDR] = sig_data[i];\r
3514         }\r
3515 \r
3516         printk("[ZET] : new data\n");\r
3517         for(i = 0 ; i < FLASH_PAGE_LEN ; i++)\r
3518         {\r
3519                 printk("%02x ", zet_tx_data[i]);\r
3520                 if((i%0x10) == 0x0F)\r
3521                 {\r
3522                         printk("\n");\r
3523                 }\r
3524                 else if((i%0x08) == 0x07)\r
3525                 {\r
3526                         printk(" - ");\r
3527                 }               \r
3528         }\r
3529 \r
3530         ///---------------------------------///\r
3531         /// write sig page\r
3532         ///---------------------------------///\r
3533         ret = zet622x_cmd_writepage(client, SIG_PAGE_ID, &zet_tx_data[0]);\r
3534         if(ret <= 0)\r
3535         {\r
3536                 printk("[ZET]: signature write fail\n");\r
3537                 return FALSE;\r
3538         }\r
3539         msleep(2);\r
3540         ret = zet622x_ts_sig_check(client);\r
3541         if(ret <= 0)\r
3542         {\r
3543                 printk("[ZET]: signature write fail\n");\r
3544                 return FALSE;\r
3545         }\r
3546         printk("[ZET]: signature write ok\n");  \r
3547         return TRUE;\r
3548 }\r
3549 #endif ///< for FEATURE_FW_SIGNATURE\r
3550 \r
3551 ///************************************************************************\r
3552 ///   [function]:  zet622x_ts_project_code_get\r
3553 ///   [parameters]: client\r
3554 ///   [return]: int\r
3555 ///************************************************************************\r
3556 int zet622x_ts_project_code_get(struct i2c_client *client)\r
3557 {\r
3558         int i;\r
3559         int ret;\r
3560 \r
3561         ///----------------------------------------///\r
3562         /// Read Data page for flash version check#1\r
3563         ///----------------------------------------///\r
3564         ret = zet622x_cmd_readpage(client, (pcode_addr[0]>>7), &zet_rx_data[0]);                \r
3565         if(ret <= 0)\r
3566         {\r
3567                 return ret;\r
3568         }\r
3569         printk("[ZET]: page=%3d ",(pcode_addr[0] >> 7)); ///< (pcode_addr[0]/128));\r
3570         for(i = 0 ; i < 4 ; i++)\r
3571         {\r
3572                 pcode[i] = zet_rx_data[(pcode_addr[i] & 0x7f)]; ///< [(pcode_addr[i]%128)];\r
3573                 printk("offset[%04x] = %02x ",i,(pcode_addr[i] & 0x7f));    ///< (pcode_addr[i]%128));\r
3574         }\r
3575         printk("\n");\r
3576 \r
3577         ///----------------------------------------///\r
3578         /// Read Data page for flash version check#2\r
3579         ///----------------------------------------///\r
3580         ret = zet622x_cmd_readpage(client, (pcode_addr[4]>>7), &zet_rx_data[0]);                \r
3581         if(ret <= 0)\r
3582         {\r
3583                 return ret;\r
3584         }       \r
3585 \r
3586         printk("[ZET]: page=%3d ",(pcode_addr[4] >> 7)); //(pcode_addr[4]/128));\r
3587         for(i = 4 ; i < PROJECT_CODE_MAX_CNT ; i++)\r
3588         {\r
3589                 pcode[i] = zet_rx_data[(pcode_addr[i] & 0x7f)]; //[(pcode_addr[i]%128)];\r
3590                 printk("offset[%04x] = %02x ",i,(pcode_addr[i] & 0x7f));  //(pcode_addr[i]%128));\r
3591         }\r
3592         printk("\n");\r
3593         \r
3594         printk("[ZET]: pcode_now : ");\r
3595         for(i = 0 ; i < PROJECT_CODE_MAX_CNT ; i++)\r
3596         {\r
3597                 printk("%02x ",pcode[i]);\r
3598         }\r
3599         printk("\n");\r
3600         \r
3601         printk("[ZET]: pcode_new : ");\r
3602         for(i = 0 ; i < PROJECT_CODE_MAX_CNT ; i++)\r
3603         {\r
3604                 printk("%02x ", flash_buffer[pcode_addr[i]]);\r
3605         }\r
3606         printk("\n");\r
3607         \r
3608         return ret;\r
3609 }\r
3610 \r
3611 ///**********************************************************************\r
3612 ///   [function]:  zet622x_ts_data_flash_download\r
3613 ///   [parameters]: client\r
3614 ///   [return]: void\r
3615 ///**********************************************************************\r
3616 #ifdef FEATRUE_TRACE_SENSOR_ID\r
3617 int zet622x_ts_data_flash_download(struct i2c_client *client)\r
3618 {\r
3619         int ret = 0;\r
3620         int i;\r
3621         \r
3622         int flash_total_len     = 0;\r
3623         int flash_rest_len      = 0;    \r
3624         int flash_page_id       = 0;\r
3625                 \r
3626         int now_flash_rest_len  = 0;\r
3627         int now_flash_page_id   = 0;\r
3628 \r
3629         int retry_count         = 0;\r
3630         \r
3631         download_ok = TRUE;\r
3632         \r
3633         printk("[ZET] : zet622x_ts_data_flash_download\n"); \r
3634 \r
3635         ///----------------------------------------///\r
3636         /// 1. set_reset pin low\r
3637         ///----------------------------------------///\r
3638         ctp_set_reset_low();\r
3639 \r
3640         msleep(1);\r
3641         ///----------------------------------------///\r
3642         /// 2. send password\r
3643         ///----------------------------------------///\r
3644         ret = zet622x_cmd_sndpwd(client);       \r
3645         if(ret <= 0)\r
3646         {\r
3647                 return ret;\r
3648         }\r
3649         msleep(10);\r
3650         \r
3651         /// unlock the write protect of 0xFC00~0xFFFF\r
3652         if(ic_model != MODEL_ZET6251)\r
3653         {\r
3654                 if(ic_model == MODEL_ZET6223)\r
3655                 {\r
3656                         ret = zet622x_cmd_sndpwd_1k(client);    \r
3657                         if(ret <= 0)\r
3658                         {\r
3659                                 return ret;\r
3660                         }       \r
3661                 }\r
3662                 \r
3663                 ///----------------------------------------///\r
3664                 /// Read SFR\r
3665                 ///----------------------------------------///\r
3666                 ret = zet622x_cmd_sfr_read(client);     \r
3667                 if(ret <= 0)\r
3668                 {\r
3669                         return ret;\r
3670                 }\r
3671                 ///----------------------------------------///\r
3672                 /// Update the SFR[14] = 0x3D\r
3673                 ///----------------------------------------///  \r
3674                 if(zet622x_cmd_sfr_unlock(client) == 0)\r
3675                 {\r
3676                         return 0;\r
3677                 }\r
3678                 msleep(20);\r
3679 \r
3680         }\r
3681 \r
3682         /// first erase the Sig. page\r
3683 #ifdef FEATURE_FW_SIGNATURE\r
3684         if(ic_model != MODEL_ZET6251)\r
3685         {\r
3686                 ///------------------------------///\r
3687                 /// Do page erase\r
3688                 ///------------------------------///    \r
3689                 zet622x_cmd_pageerase(client, SIG_PAGE_ID);\r
3690                 msleep(30);\r
3691 \r
3692         }\r
3693 #endif ///< for FEATURE_FW_SIGNATURE\r
3694 \r
3695         flash_total_len = MAX_DATA_FLASH_BUF_SIZE;\r
3696         flash_page_id = DATA_FLASH_START_ID;\r
3697         flash_rest_len = flash_total_len;\r
3698         while(flash_rest_len >0)\r
3699         {\r
3700                 memset(zet_tx_data, 0x00, 131);\r
3701 \r
3702 #ifdef FEATURE_FW_COMPARE\r
3703 LABEL_DATA_FLASH_PAGE:          \r
3704 #endif ///< for FEATURE_FW_COMPARE\r
3705 \r
3706                 /// Do page erase \r
3707                 if(ic_model != MODEL_ZET6251)\r
3708                 {\r
3709                         ///------------------------------///\r
3710                         /// Do page erase\r
3711                         ///------------------------------///    \r
3712                         zet622x_cmd_pageerase(client, flash_page_id);\r
3713                         msleep(30);\r
3714         \r
3715                 }\r
3716 \r
3717                 //printk( " [ZET] : write page%d\n", flash_page_id);\r
3718                 now_flash_rest_len      = flash_rest_len;\r
3719                 now_flash_page_id       = flash_page_id;\r
3720                 \r
3721                 ///---------------------------------///\r
3722                 /// Write page\r
3723                 ///---------------------------------///         \r
3724                 ret = zet622x_cmd_writepage(client, flash_page_id, &flash_buffer[flash_page_id * FLASH_PAGE_LEN]);\r
3725                 flash_rest_len -= FLASH_PAGE_LEN;\r
3726 \r
3727                 if(ic_model != MODEL_ZET6251)\r
3728                 {\r
3729                         msleep(5);\r
3730                 }\r
3731                 \r
3732 #ifdef FEATURE_FW_COMPARE\r
3733 \r
3734                 ///---------------------------------///\r
3735                 /// Read page\r
3736                 ///---------------------------------///\r
3737                 ret = zet622x_cmd_readpage(client, flash_page_id, &zet_rx_data[0]);             \r
3738                 if(ret <= 0)\r
3739                 {\r
3740                         return ret;\r
3741                 }\r
3742                 \r
3743                 for(i = 0 ; i < FLASH_PAGE_LEN ; i++)\r
3744                 {\r
3745                         if(i < now_flash_rest_len)\r
3746                         {\r
3747                                 if(flash_buffer[flash_page_id * FLASH_PAGE_LEN + i] != zet_rx_data[i])\r
3748                                 {\r
3749                                         flash_rest_len = now_flash_rest_len;\r
3750                                         flash_page_id = now_flash_page_id;\r
3751                                 \r
3752                                         if(retry_count < 5)\r
3753                                         {\r
3754                                                 retry_count++;\r
3755                                                 goto LABEL_DATA_FLASH_PAGE;\r
3756                                         }\r
3757                                         else\r
3758                                         {\r
3759                                                 download_ok = FALSE;\r
3760                                                 retry_count = 0;                                                \r
3761                                                 ctp_set_reset_high();\r
3762                                                 msleep(20);             \r
3763                                                 ctp_set_reset_low();\r
3764                                                 msleep(20);\r
3765                                                 ctp_set_reset_high();\r
3766                                                 msleep(20);\r
3767                                                 goto LABEL_EXIT_DATA_FLASH;\r
3768                                         }\r
3769 \r
3770                                 }\r
3771                         }\r
3772                 }\r
3773                 \r
3774 #endif ///< for FEATURE_FW_COMPARE\r
3775                 retry_count=0;\r
3776                 flash_page_id+=1;\r
3777         }\r
3778 \r
3779 LABEL_EXIT_DATA_FLASH:\r
3780 \r
3781         if(download_ok == TRUE && ic_model != MODEL_ZET6251)\r
3782         {\r
3783 #ifdef FEATURE_FW_SIGNATURE\r
3784                 if(zet622x_ts_sig_write(client) == FALSE)\r
3785                 {\r
3786                         download_ok = FALSE;\r
3787                 }\r
3788 #endif ///< for FEATURE_FW_SIGNATURE\r
3789 \r
3790         }\r
3791 \r
3792         zet622x_cmd_resetmcu(client);\r
3793         msleep(10);\r
3794 \r
3795         ctp_set_reset_high();\r
3796         msleep(20);\r
3797 \r
3798         if(download_ok == FALSE)\r
3799         {\r
3800                 printk("[ZET] : download data flash failed!\n");\r
3801         }\r
3802         else\r
3803         {\r
3804         \r
3805                 ///---------------------------------///\r
3806                 /// update the project code\r
3807                 ///---------------------------------///\r
3808                 printk("[ZET] : download data flash pass!\n");\r
3809                         \r
3810                 for(i = 0 ; i < PROJECT_CODE_MAX_CNT ; i++)\r
3811                 {      \r
3812                         pcode[i] = flash_buffer[pcode_addr[i]];\r
3813                 }\r
3814         }\r
3815                 \r
3816         return ret;\r
3817 }\r
3818 #endif ///< for  FEATRUE_TRACE_SENSOR_ID\r
3819 \r
3820 ///************************************************************************\r
3821 ///   [function]:  zet622x_downloader\r
3822 ///   [parameters]: client, upgrade, romtype, icmodel\r
3823 ///   [return]: int\r
3824 ///************************************************************************\r
3825 int  zet622x_downloader( struct i2c_client *client, u8 upgrade, u8 *pRomType, u8 icmodel)\r
3826 {\r
3827         int ret;\r
3828         int i;\r
3829         \r
3830         int flash_total_len     = 0;\r
3831         int flash_rest_len      = 0;    \r
3832         int flash_page_id       = 0;\r
3833                 \r
3834         int now_flash_rest_len  = 0;\r
3835         int now_flash_page_id   = 0;\r
3836 \r
3837         int retry_count         = 0;\r
3838         \r
3839         \r
3840         u8 uRomType=*pRomType;\r
3841 #ifdef FEATURE_FW_SKIP_FF\r
3842         u8 bSkipWrite = TRUE;\r
3843 #endif ///< for FEATURE_FW_SKIP_FF\r
3844 \r
3845         download_ok = TRUE;\r
3846 \r
3847         ///----------------------------------------///\r
3848         /// 1. set_reset pin low\r
3849         ///----------------------------------------///\r
3850         ctp_set_reset_low();\r
3851 \r
3852         msleep(1);\r
3853         ///----------------------------------------///\r
3854         /// 2. send password\r
3855         ///----------------------------------------///\r
3856         ret = zet622x_cmd_sndpwd(client);       \r
3857         if(ret <= 0)\r
3858         {\r
3859                 return ret;\r
3860         }\r
3861         msleep(10);\r
3862         \r
3863         ///----------------------------------------///\r
3864         /// Read Code Option\r
3865         ///----------------------------------------///\r
3866         ret = zet622x_cmd_codeoption(client, &uRomType);\r
3867         if(ret <= 0)\r
3868         {\r
3869                 return ret;\r
3870         }\r
3871         *pRomType = uRomType;   \r
3872         msleep(10);\r
3873                 \r
3874         if(upgrade == 0)\r
3875         {\r
3876                 printk("[ZET]: HW_CHECK_ONLY enable! It is zeitec product and not going to upgrade FW. \n");\r
3877                 return 1;\r
3878         }\r
3879         \r
3880         ///--------------------------------------------------------------------------///\r
3881         /// 4.1 the ZET6223 need unlock the write protect of 0xFC00~0xFFFF\r
3882         ///--------------------------------------------------------------------------///\r
3883         if(ic_model == MODEL_ZET6223)\r
3884         {\r
3885                 ret = zet622x_cmd_sndpwd_1k(client);    \r
3886                 if(ret <= 0)\r
3887                 {\r
3888                         return ret;\r
3889                 }       \r
3890         }\r
3891         \r
3892         ///------------------------------------------------///\r
3893         /// init the file\r
3894         ///------------------------------------------------///\r
3895         zet_fw_init();\r
3896 \r
3897         ///------------------------------------------------///\r
3898         /// the SRAM need download code\r
3899         ///------------------------------------------------///\r
3900         if(ic_model == MODEL_ZET6251)\r
3901         {\r
3902                 goto LABEL_START_DOWNLOAD;\r
3903         }\r
3904         \r
3905         ///----------------------------------------///\r
3906         /// Clear Read-in buffer\r
3907         ///----------------------------------------///\r
3908         memset(zet_rx_data, 0x00, 131);\r
3909         \r
3910         zet622x_ts_project_code_get(client);\r
3911         \r
3912         ///================================///\r
3913         ///        Check version         \r
3914         ///================================///\r
3915 \r
3916         #ifdef FEATURE_FW_SIGNATURE\r
3917         ///----------------------------------------///\r
3918         /// Check the data flash version\r
3919         ///----------------------------------------///\r
3920         if(zet622x_ts_sig_check(client) == TRUE)\r
3921         {\r
3922                 ///----------------------------------------///\r
3923                 /// Check the data flash version\r
3924                 ///----------------------------------------///\r
3925                 if(zet622x_ts_check_version() == TRUE)\r
3926                 {\r
3927                         goto LABEL_EXIT_DOWNLOAD;\r
3928                 }\r
3929         }\r
3930         #else ///< for FEATURE_FW_SIGNATURE\r
3931         ///----------------------------------------///\r
3932         /// Check the data flash version\r
3933         ///----------------------------------------///\r
3934         if(zet622x_ts_check_version() == TRUE)\r
3935         {\r
3936                 goto LABEL_EXIT_DOWNLOAD;\r
3937         }\r
3938         #endif  ///< for FEATURE_FW_SIGNATURE\r
3939 \r
3940         ///================================///\r
3941         ///        Start to download\r
3942         ///================================///\r
3943 LABEL_START_DOWNLOAD:\r
3944         ///----------------------------------------///\r
3945         /// Read SFR\r
3946         ///----------------------------------------///\r
3947         ret = zet622x_cmd_sfr_read(client);     \r
3948         if(ret <= 0)\r
3949         {\r
3950                 return ret;\r
3951         }\r
3952         ///----------------------------------------///\r
3953         /// Update the SFR[14] = 0x3D\r
3954         ///----------------------------------------///  \r
3955         if(zet622x_cmd_sfr_unlock(client) == 0)\r
3956         {\r
3957                 return 0;\r
3958         }\r
3959         msleep(20);\r
3960         \r
3961 \r
3962         ///------------------------------///\r
3963         /// mass erase\r
3964         ///------------------------------///            \r
3965         if(uRomType == ROM_TYPE_FLASH)\r
3966         {\r
3967                 zet622x_cmd_masserase(client);\r
3968                 msleep(40);\r
3969         }\r
3970 \r
3971         flash_total_len = zet_fw_size();\r
3972 \r
3973         flash_rest_len = flash_total_len;\r
3974         \r
3975         while(flash_rest_len > 0)\r
3976         {\r
3977                 memset(zet_tx_data, 0x00, 131);\r
3978 \r
3979 #ifdef FEATURE_FW_COMPARE\r
3980 LABEL_DOWNLOAD_PAGE:            \r
3981 #endif ///< for FEATURE_FW_COMPARE\r
3982 \r
3983                 /// Do page erase\r
3984                 if(retry_count > 0)\r
3985                 {\r
3986                         ///------------------------------///\r
3987                         /// Do page erase\r
3988                         ///------------------------------///    \r
3989                         if(uRomType == ROM_TYPE_FLASH)\r
3990                         {\r
3991                                 zet622x_cmd_pageerase(client, flash_page_id);\r
3992                                 msleep(30);\r
3993                         }\r
3994 \r
3995                 }\r
3996 \r
3997                 //printk( " [ZET] : write page%d\n", flash_page_id);\r
3998                 now_flash_rest_len = flash_rest_len;\r
3999                 now_flash_page_id  = flash_page_id;\r
4000 #ifdef FEATURE_FW_SKIP_FF\r
4001 \r
4002                 bSkipWrite = zet622x_ts_check_skip_page(&flash_buffer[flash_page_id * FLASH_PAGE_LEN]);\r
4003 \r
4004                 if(bSkipWrite == TRUE)\r
4005                 {\r
4006                         //printk( " [ZET] : skip write page%d\n", flash_page_id);\r
4007                         retry_count = 0;\r
4008                         flash_page_id += 1;     \r
4009                         flash_rest_len -= FLASH_PAGE_LEN;\r
4010                         continue;\r
4011                 }       \r
4012 #endif ///< for FEATURE_SKIP_FF \r
4013                 \r
4014                 ///---------------------------------///\r
4015                 /// Write page\r
4016                 ///---------------------------------///         \r
4017                 ret = zet622x_cmd_writepage(client, flash_page_id, &flash_buffer[flash_page_id * FLASH_PAGE_LEN]);\r
4018                 flash_rest_len -= FLASH_PAGE_LEN;\r
4019 \r
4020                 if(ic_model != MODEL_ZET6251)\r
4021                 {\r
4022                         msleep(5);\r
4023                 }\r
4024                 \r
4025 #ifdef FEATURE_FW_COMPARE\r
4026 \r
4027                 ///---------------------------------///\r
4028                 /// Read page\r
4029                 ///---------------------------------///\r
4030                 ret = zet622x_cmd_readpage(client, flash_page_id, &zet_rx_data[0]);             \r
4031                 if(ret <= 0)\r
4032                 {\r
4033                         return ret;\r
4034                 }\r
4035                 \r
4036                 ///--------------------------------------------------------------------------///\r
4037                 /// 10. compare data\r
4038                 ///--------------------------------------------------------------------------///\r
4039                 for(i = 0 ; i < FLASH_PAGE_LEN ; i++)\r
4040                 {\r
4041                         if(i < now_flash_rest_len)\r
4042                         {\r
4043                                 if(flash_buffer[flash_page_id * FLASH_PAGE_LEN + i] != zet_rx_data[i])\r
4044                                 {\r
4045                                         flash_rest_len = now_flash_rest_len;\r
4046                                         flash_page_id = now_flash_page_id;\r
4047                                 \r
4048                                         if(retry_count < 5)\r
4049                                         {\r
4050                                                 retry_count++;\r
4051                                                 goto LABEL_DOWNLOAD_PAGE;\r
4052                                         }\r
4053                                         else\r
4054                                         {\r
4055                                                 download_ok = FALSE;\r
4056                                                 retry_count = 0;                                                \r
4057                                                 ctp_set_reset_high();\r
4058                                                 msleep(20);             \r
4059                                                 ctp_set_reset_low();\r
4060                                                 msleep(20);\r
4061                                                 ctp_set_reset_high();\r
4062                                                 msleep(20);\r
4063                                                 goto LABEL_EXIT_DOWNLOAD;\r
4064                                         }\r
4065 \r
4066                                 }\r
4067                         }\r
4068                 }\r
4069                 \r
4070 #endif ///< for FEATURE_FW_COMPARE\r
4071                 retry_count = 0;\r
4072                 flash_page_id += 1;\r
4073         }\r
4074 \r
4075         ///---------------------------------///\r
4076         /// write signature\r
4077         ///---------------------------------///\r
4078 \r
4079 #ifdef FEATURE_FW_SIGNATURE\r
4080         if(download_ok == TRUE && uRomType == ROM_TYPE_FLASH)\r
4081         {       \r
4082                 if(zet622x_ts_sig_write(client) == FALSE)\r
4083                 {\r
4084                         download_ok = FALSE;\r
4085                 }\r
4086                 \r
4087         }\r
4088 #endif ///< for FEATURE_FW_SIGNATURE\r
4089 LABEL_EXIT_DOWNLOAD:\r
4090         if(download_ok == FALSE)\r
4091         {\r
4092                 printk("[ZET] : download failed!\n");\r
4093         }\r
4094 \r
4095         zet622x_cmd_resetmcu(client);\r
4096         msleep(10);\r
4097 \r
4098         ctp_set_reset_high();\r
4099         msleep(20);\r
4100         if(ic_model == MODEL_ZET6221 || download_ok == FALSE)\r
4101         {\r
4102                 return 1;\r
4103         }\r
4104         /// download pass then copy the pcode\r
4105         for(i = 0 ; i < PROJECT_CODE_MAX_CNT ; i++)\r
4106         {      \r
4107                 pcode[i] = flash_buffer[pcode_addr[i]];\r
4108         }\r
4109 #ifdef FEATRUE_TRACE_GPIO_INPUT\r
4110         /// get the gpio input setting\r
4111         zet622x_ts_gpio_input_get();\r
4112         #ifdef FEATRUE_TRACE_SENSOR_ID\r
4113         /// get sensor id setting on the data flash \r
4114         if(zet622x_ts_sensor_id_bin_set(trace_input_status) == TRUE)\r
4115         {\r
4116                 zet622x_ts_data_flash_download(client);\r
4117         }\r
4118         #endif ///< for FEATRUE_TRACE_SENSOR_ID\r
4119 \r
4120 #endif ///< for FEATRUE_TRACE_GPIO_INPUT\r
4121         return 1;\r
4122 }\r
4123 \r
4124 ///************************************************************************\r
4125 ///   [function]:  zet622x_resume_downloader\r
4126 ///   [parameters]: client, upgrade, romtype, icmodel\r
4127 ///   [return]: int\r
4128 ///************************************************************************\r
4129 static int zet622x_resume_downloader(struct i2c_client *client, u8 upgrade, u8 *romtype, u8 icmodel)\r
4130 {\r
4131         int ret = 0;\r
4132 #ifdef FEATURE_FW_SKIP_FF\r
4133         u8 bSkipWrite;\r
4134 #endif ///< for FEATURE_FW_SKIP_FF\r
4135 \r
4136 #ifdef FEATURE_FW_CHECK_SUM\r
4137         int retry_count         = 0;\r
4138         u8 check_sum            = 0;\r
4139 #endif ///< for FEATURE_FW_CHECK_SUM\r
4140 \r
4141         int flash_total_len     = FLASH_SIZE_ZET6231;\r
4142         int flash_rest_len      = 0;\r
4143         int flash_page_id       = 0;\r
4144                 \r
4145         \r
4146         ///-------------------------------------------------------------///\r
4147         ///   1. Set RST=LOW\r
4148         ///-------------------------------------------------------------///\r
4149         ctp_set_reset_low();\r
4150         printk("[ZET] : RST = LOW\n");\r
4151 \r
4152         ///-------------------------------------------------------------///\r
4153         /// 2.Send password\r
4154         ///-------------------------------------------------------------///\r
4155         ret = zet622x_cmd_sndpwd(client);\r
4156         if(ret <= 0)\r
4157         {\r
4158                 return ret;\r
4159         }\r
4160 \r
4161         switch(ic_model)\r
4162         {\r
4163                 case MODEL_ZET6221:\r
4164                         flash_total_len = FLASH_SIZE_ZET6221;\r
4165                         break;\r
4166                 case MODEL_ZET6223: \r
4167                         flash_total_len =  FLASH_SIZE_ZET6223;\r
4168                         break;\r
4169                 case MODEL_ZET6231:                     \r
4170                 case MODEL_ZET6251: \r
4171                 default: \r
4172                         flash_total_len =  FLASH_SIZE_ZET6231;\r
4173                         break;\r
4174         }\r
4175         \r
4176         /// unlock the write protect of 0xFC00~0xFFFF\r
4177         if(ic_model == MODEL_ZET6223)\r
4178         {\r
4179                 ret = zet622x_cmd_sndpwd_1k(client);    \r
4180                 if(ret <= 0)\r
4181                 {\r
4182                         return ret;\r
4183                 }\r
4184         }\r
4185         \r
4186         if(rom_type == ROM_TYPE_FLASH)\r
4187         {\r
4188                 ///----------------------------------------///\r
4189                 /// Read SFR\r
4190                 ///----------------------------------------///\r
4191                 ret = zet622x_cmd_sfr_read(client);     \r
4192                 if(ret <= 0)\r
4193                 {\r
4194                         return ret;\r
4195                 }\r
4196                 ///----------------------------------------///\r
4197                 /// Update the SFR[14] = 0x3D\r
4198                 ///----------------------------------------///  \r
4199                 if(zet622x_cmd_sfr_unlock(client) == 0)\r
4200                 {\r
4201                         return 0;\r
4202                 }\r
4203                 msleep(20);\r
4204                         \r
4205                 ///------------------------------///\r
4206                 /// mass erase\r
4207                 ///------------------------------///            \r
4208                 zet622x_cmd_masserase(client);\r
4209                 msleep(30);\r
4210         }\r
4211 \r
4212         flash_rest_len = flash_total_len;\r
4213 \r
4214         ///-------------------------------------------------------------///\r
4215         /// Read Firmware from BIN if any\r
4216         ///-------------------------------------------------------------///\r
4217         zet_fw_load(fw_file_name);\r
4218 #ifdef FEATURE_FW_CHECK_SUM\r
4219         if(ic_model == MODEL_ZET6251)\r
4220         {\r
4221                 ///-------------------------------------------------------------///\r
4222                 /// add the sram check sum to compare the data\r
4223                 ///-------------------------------------------------------------///\r
4224                 while(flash_rest_len>0)\r
4225                 {\r
4226 #ifdef FEATURE_FW_SKIP_FF\r
4227                         bSkipWrite = zet622x_ts_check_skip_page(&flash_buffer[flash_page_id * FLASH_PAGE_LEN]);\r
4228                         if(bSkipWrite == TRUE)\r
4229                         {\r
4230                                 //printk( " [ZET] : skip write page%d\n", flash_page_id);\r
4231                                 flash_rest_len-=FLASH_PAGE_LEN;\r
4232                                 flash_page_id += 1;\r
4233                                 continue;\r
4234                         }\r
4235 #endif ///< for FEATURE_SKIP_FF \r
4236                         check_sum = zet622x_ts_sram_check_sum(client, flash_page_id, &flash_buffer[flash_page_id * FLASH_PAGE_LEN]);\r
4237                         if(check_sum == FALSE)\r
4238                         {\r
4239                                 printk("[ZET] :  check the check sum have differ\n");\r
4240                                 goto LABEL_START_RESUME_DOWNLOAD;\r
4241                         }\r
4242                         flash_rest_len -= FLASH_PAGE_LEN;\r
4243                         flash_page_id++;\r
4244                 }\r
4245                 goto LABEL_RESUME_DOWNLOAD_FINISH;\r
4246         }\r
4247 LABEL_START_RESUME_DOWNLOAD:\r
4248         //printk("[ZET] :  LABEL_START_RESUME_DOWNLOAD\n");\r
4249         flash_rest_len = flash_total_len;\r
4250         flash_page_id = 0;\r
4251 #endif  ///< for FEATURE_FW_CHECK_SUM\r
4252 \r
4253         while(flash_rest_len>0)\r
4254         {\r
4255 \r
4256 #ifdef FEATURE_FW_SKIP_FF\r
4257                 bSkipWrite = zet622x_ts_check_skip_page(&flash_buffer[flash_page_id * FLASH_PAGE_LEN]);\r
4258                 if(bSkipWrite == TRUE)\r
4259                 {\r
4260                         //printk( " [ZET] : skip write page%d\n", flash_page_id);\r
4261                         flash_rest_len-=FLASH_PAGE_LEN;\r
4262                         flash_page_id += 1;\r
4263                         continue;\r
4264                 }\r
4265 #endif ///< for FEATURE_SKIP_FF \r
4266                 //---------------------------------///\r
4267                 /// 5. Write page\r
4268                 ///--------------------------------///          \r
4269                 \r
4270 #ifdef FEATURE_FW_CHECK_SUM\r
4271 LABEL_RETRY_DOWNLOAD_PAGE:\r
4272 #endif  ///< for FEATURE_FW_CHECK_SUM\r
4273                 ret = zet622x_cmd_writepage(client, flash_page_id, &flash_buffer[flash_page_id * FLASH_PAGE_LEN]);\r
4274                 flash_rest_len -= FLASH_PAGE_LEN;\r
4275 #ifdef FEATURE_FW_CHECK_SUM\r
4276 \r
4277                 if(ic_model == MODEL_ZET6251)\r
4278                 {\r
4279                         check_sum = zet622x_ts_sram_check_sum(client, flash_page_id, &flash_buffer[flash_page_id * FLASH_PAGE_LEN]);\r
4280                         \r
4281                         if(check_sum == FALSE)\r
4282                         {               \r
4283                                 if(retry_count < 5)\r
4284                                 {\r
4285                                         retry_count++;\r
4286                                         flash_rest_len += FLASH_PAGE_LEN;\r
4287                                         /// zet6251 add reset function\r
4288                                         ctp_set_reset_high();\r
4289                                         msleep(1);              \r
4290                                         ctp_set_reset_low();\r
4291                                         msleep(1);\r
4292                                         zet622x_cmd_sndpwd(client);             \r
4293                                         goto LABEL_RETRY_DOWNLOAD_PAGE;\r
4294                                 }\r
4295                                 else\r
4296                                 {\r
4297                                         retry_count = 0;                                                \r
4298                                         ctp_set_reset_high();\r
4299                                         msleep(20);             \r
4300                                         ctp_set_reset_low();\r
4301                                         msleep(20);\r
4302                                         ctp_set_reset_high();\r
4303                                         msleep(20);\r
4304                                         printk("[ZET] zet622x_resume_downloader fail\n");\r
4305                                         return ret;\r
4306                                 }\r
4307                                 \r
4308                         }\r
4309                         retry_count  = 0;       \r
4310                 }\r
4311 #endif  ///< for FEATURE_FW_CHECK_SUM\r
4312                 flash_page_id++;\r
4313                                         \r
4314         }\r
4315 \r
4316 #ifdef FEATURE_FW_CHECK_SUM\r
4317 LABEL_RESUME_DOWNLOAD_FINISH:\r
4318 #endif ///< for FEATURE_FW_CHECK_SUM\r
4319 \r
4320         printk("[ZET] RST = HIGH\n");\r
4321 \r
4322         ///-------------------------------------------------------------///\r
4323         /// reset_mcu command\r
4324         ///-------------------------------------------------------------///\r
4325         printk("[ZET] zet622x_cmd_resetmcu\n");\r
4326         zet622x_cmd_resetmcu(client);\r
4327         msleep(10);     \r
4328 \r
4329         ///-------------------------------------------------------------///\r
4330         ///   SET RST=HIGH\r
4331         ///-------------------------------------------------------------///\r
4332         ctp_set_reset_high();\r
4333         msleep(20);\r
4334 \r
4335         ///-------------------------------------------------------------///\r
4336         /// RST toggle  \r
4337         ///-------------------------------------------------------------///\r
4338         ctp_set_reset_low();\r
4339         msleep(2);\r
4340         ctp_set_reset_high();\r
4341         msleep(2);\r
4342 \r
4343         printk("[ZET]: zet622x_resume_downloader finish\n");\r
4344         return ret;\r
4345 }\r
4346 \r
4347 #ifdef FEATURE_FW_UPGRADE_RESUME\r
4348 ///************************************************************************\r
4349 ///   [function]:  zet622x_resume_download_thread\r
4350 ///   [parameters]: arg\r
4351 ///   [return]: int\r
4352 ///************************************************************************\r
4353 static int zet622x_resume_download_thread(void *arg)\r
4354 {\r
4355         int ret = 0;\r
4356 \r
4357         printk("[ZET] : Thread Enter\n");\r
4358         resume_download = TRUE;\r
4359         if((rom_type == ROM_TYPE_SRAM) || \r
4360            (rom_type == ROM_TYPE_OTP)) //SRAM,OTP\r
4361         {\r
4362                 if(ic_model == MODEL_ZET6251)\r
4363                 {\r
4364                         zet622x_resume_downloader(this_client, firmware_upgrade, &rom_type, ic_model);\r
4365                         printk("zet622x download OK\n");\r
4366                 }\r
4367         }\r
4368         printk("[ZET] : Thread Leave\n");\r
4369         resume_download = FALSE;\r
4370         return ret;\r
4371 }\r
4372 #endif ///< for FEATURE_FW_UPGRADE\r
4373 \r
4374 ///************************************************************************\r
4375 ///   [function]:  zet622x_ts_late_resume\r
4376 ///   [parameters]:\r
4377 ///   [return]:\r
4378 ///************************************************************************\r
4379 static void zet622x_ts_late_resume(void)\r
4380 {       \r
4381         printk("[ZET] : Resume START\n");\r
4382 \r
4383         dummy_report_cnt = SKIP_DUMMY_REPORT_COUNT;\r
4384         charger_status = 0;\r
4385         //ctp_ops.ts_wakeup();\r
4386         ctp_wakeup();\r
4387 \r
4388 #ifdef FEATURE_FW_UPGRADE_RESUME\r
4389         if(rom_type != ROM_TYPE_SRAM)\r
4390         {\r
4391                 goto LABEL_RESUME_END;\r
4392         }\r
4393         \r
4394         resume_download_task = kthread_create(zet622x_resume_download_thread, NULL, "resume_download");\r
4395         if(IS_ERR(resume_download_task))\r
4396         {\r
4397                 printk(KERN_ERR "%s: cread thread failed\n",__FILE__);  \r
4398         }\r
4399         wake_up_process(resume_download_task); \r
4400 \r
4401 LABEL_RESUME_END:       \r
4402 #endif ///< for TURE_FW_UPGRADE\r
4403 \r
4404         ///------------------------------------------------///\r
4405         /// init the finger pressed data\r
4406         ///------------------------------------------------///\r
4407 #ifdef FEAURE_LIGHT_LOAD_REPORT_MODE\r
4408         zet62xx_ts_init();\r
4409 #endif ///< for FEAURE_LIGHT_LOAD_REPORT_MODE\r
4410  \r
4411         //printk("[ZET] : Resume END\n");\r
4412         \r
4413         /// leave suspend mode\r
4414         suspend_mode = FALSE;\r
4415 \r
4416         ///--------------------------------------///\r
4417         /// Set transfer type to dynamic mode\r
4418         ///--------------------------------------///\r
4419         transfer_type = TRAN_TYPE_DYNAMIC;\r
4420 \r
4421         return;\r
4422 }\r
4423 \r
4424 ///************************************************************************\r
4425 ///   [function]:  zet622x_ts_early_suspend\r
4426 ///   [parameters]: early_suspend\r
4427 ///   [return]: void\r
4428 ///************************************************************************\r
4429 static void zet622x_ts_early_suspend(void)\r
4430 {\r
4431         u8 ts_sleep_cmd[1] = {0xb1}; \r
4432         int ret = 0;\r
4433         printk("[ZET] : ================= enter %s \n",__FUNCTION__);\r
4434         //return 0;\r
4435         suspend_mode = TRUE;\r
4436 \r
4437         ret = zet622x_i2c_write_tsdata(this_client, ts_sleep_cmd, 1);\r
4438 #ifdef FEATURE_SUSPEND_CLEAN_FINGER\r
4439         zet622x_ts_clean_finger(zet62xx_ts);\r
4440 #endif ///< for FEATURE_SUSPEND_CLEAN_FINGER\r
4441         return;         \r
4442 }\r
4443 \r
4444 \r
4445 static int zet622x_ts_fb_event_notify(struct notifier_block *self,\r
4446                                       unsigned long action, void *data)\r
4447 {\r
4448         struct fb_event *event = data;\r
4449         int blank_mode = *((int *)event->data);\r
4450         \r
4451 \r
4452         if (action == FB_EARLY_EVENT_BLANK) {\r
4453                 switch (blank_mode) {\r
4454                 case FB_BLANK_UNBLANK:\r
4455                         break;\r
4456                 default:\r
4457                         zet622x_ts_early_suspend();\r
4458                         break;\r
4459                 }\r
4460         } else if (action == FB_EVENT_BLANK) {\r
4461                 switch (blank_mode) {\r
4462                 case FB_BLANK_UNBLANK:\r
4463                         zet622x_ts_late_resume();\r
4464                         break;\r
4465                 default:\r
4466                         break;\r
4467                 }\r
4468         }\r
4469 \r
4470         return NOTIFY_OK;\r
4471 }\r
4472 \r
4473 static struct notifier_block zet622x_ts_fb_notifier = {\r
4474         .notifier_call = zet622x_ts_fb_event_notify,\r
4475 };\r
4476 \r
4477 \r
4478 \r
4479 static struct of_device_id zet622x_dt_ids[] = {\r
4480         /*gsensor*/\r
4481         { .compatible = "zet6221-ts" },\r
4482         \r
4483 };\r
4484 ///************************************************************************\r
4485 ///     zet622x_i2c_driver\r
4486 ///************************************************************************\r
4487 static struct i2c_driver zet622x_i2c_driver = \r
4488 {\r
4489         .class = I2C_CLASS_HWMON, \r
4490         .driver = \r
4491         {\r
4492                 .owner  = THIS_MODULE,\r
4493                 .name   = ZET_TS_ID_NAME,\r
4494                 .of_match_table = of_match_ptr(zet622x_dt_ids),\r
4495         },\r
4496         .probe          = zet622x_ts_probe,\r
4497         .remove         = zet622x_ts_remove,\r
4498         .id_table       = zet622x_ts_idtable,\r
4499         .address_list   = u_i2c_addr.normal_i2c,\r
4500 };\r
4501 \r
4502 ///***********************************************************************\r
4503 ///   [function]:  zet_mdev_save\r
4504 ///   [parameters]: char *\r
4505 ///   [return]: void\r
4506 ///************************************************************************\r
4507 static void zet_mdev_save(char *file_name)\r
4508 {\r
4509         struct file *fp;\r
4510         int data_total_len  = (row+2) * (col + 2);\r
4511 \r
4512         memcpy(mdev_data, tran_data, data_total_len);\r
4513 \r
4514         ///-------------------------------------------------------///        \r
4515         /// create the file that stores the mutual dev data\r
4516         ///-------------------------------------------------------///        \r
4517         fp = filp_open(file_name, O_RDWR | O_CREAT, 0644);\r
4518         if(IS_ERR(fp))\r
4519         {\r
4520                 printk("[ZET] : Failed to open %s\n", file_name);\r
4521                 return;\r
4522         }\r
4523         old_fs = get_fs();\r
4524         set_fs(KERNEL_DS);\r
4525 \r
4526         vfs_write(fp, tran_data, data_total_len, &(fp->f_pos));\r
4527         set_fs(old_fs);\r
4528         filp_close(fp, 0);\r
4529 \r
4530         return;\r
4531 }\r
4532 \r
4533 ///***********************************************************************\r
4534 ///   [function]:  zet_idev_save\r
4535 ///   [parameters]: char *\r
4536 ///   [return]: void\r
4537 ///************************************************************************\r
4538 #ifdef FEATURE_IDEV_OUT_ENABLE\r
4539 static void zet_idev_save(char *file_name)\r
4540 {\r
4541         struct file *fp;\r
4542         int data_total_len  = (row + col);\r
4543 \r
4544         memcpy(idev_data, tran_data, data_total_len);\r
4545 \r
4546         ///-------------------------------------------------------///        \r
4547         /// create the file that stores the initial dev data\r
4548         ///-------------------------------------------------------///        \r
4549         fp = filp_open(file_name, O_RDWR | O_CREAT, 0644);\r
4550         if(IS_ERR(fp))\r
4551         {\r
4552                 printk("[ZET] : Failed to open %s\n", file_name);\r
4553                 return;\r
4554         }\r
4555         old_fs = get_fs();\r
4556         set_fs(KERNEL_DS);\r
4557 \r
4558         vfs_write(fp, tran_data, data_total_len, &(fp->f_pos));\r
4559         set_fs(old_fs);\r
4560         filp_close(fp, 0);\r
4561 \r
4562         return;\r
4563 }\r
4564 #endif ///< FEATURE_IDEV_OUT_ENABLE\r
4565 \r
4566 ///***********************************************************************\r
4567 ///   [function]:  zet_ibase_save\r
4568 ///   [parameters]: char *\r
4569 ///   [return]: void\r
4570 ///************************************************************************\r
4571 #ifdef FEATURE_IBASE_OUT_ENABLE\r
4572 static void zet_ibase_save(char *file_name)\r
4573 {\r
4574         struct file *fp;\r
4575         int data_total_len  = (row + col) * 2;\r
4576         \r
4577         memcpy(ibase_data, tran_data, data_total_len);\r
4578         ///-------------------------------------------------------///        \r
4579         /// create the file that stores the initial base data\r
4580         ///-------------------------------------------------------///        \r
4581         fp = filp_open(file_name, O_RDWR | O_CREAT, 0644);\r
4582         if(IS_ERR(fp))\r
4583         {\r
4584                 printk("[ZET] : Failed to open %s\n", file_name);\r
4585                 return;\r
4586         }\r
4587         old_fs = get_fs();\r
4588         set_fs(KERNEL_DS);\r
4589 \r
4590         vfs_write(fp, tran_data, data_total_len, &(fp->f_pos));\r
4591         set_fs(old_fs);\r
4592         filp_close(fp, 0);\r
4593 \r
4594         return;\r
4595 }\r
4596 #endif ///< FEATURE_IBASE_OUT_ENABLE\r
4597 \r
4598 ///***********************************************************************\r
4599 ///   [function]:  zet_fpcopen_save\r
4600 ///   [parameters]: char *\r
4601 ///   [return]: void\r
4602 ///************************************************************************\r
4603 #ifdef FEATURE_FPC_OPEN_ENABLE\r
4604 static void zet_fpcopen_save(char *file_name)\r
4605 {\r
4606         struct file *fp;\r
4607         int data_total_len  = (row + col) ;\r
4608         \r
4609         memcpy(fpcopen_data, tran_data, data_total_len);\r
4610         ///-------------------------------------------------------///        \r
4611         /// create the file that stores the initial base data\r
4612         ///-------------------------------------------------------///        \r
4613         fp = filp_open(file_name, O_RDWR | O_CREAT, 0644);\r
4614         if(IS_ERR(fp))\r
4615         {\r
4616                 printk("[ZET] : Failed to open %s\n", file_name);\r
4617                 return;\r
4618         }\r
4619         old_fs = get_fs();\r
4620         set_fs(KERNEL_DS);\r
4621 \r
4622         vfs_write(fp, tran_data, data_total_len, &(fp->f_pos));\r
4623         set_fs(old_fs);\r
4624         filp_close(fp, 0);\r
4625 \r
4626         return;\r
4627 }\r
4628 #endif ///< FEATURE_FPC_OPEN_ENABLE\r
4629 \r
4630 ///***********************************************************************\r
4631 ///   [function]:  zet_fpcshort_save\r
4632 ///   [parameters]: char *\r
4633 ///   [return]: void\r
4634 ///************************************************************************\r
4635 #ifdef FEATURE_FPC_SHORT_ENABLE\r
4636 static void zet_fpcshort_save(char *file_name)\r
4637 {\r
4638         struct file *fp;\r
4639         int data_total_len  = (row + col)*2 ;\r
4640         \r
4641         memcpy(fpcshort_data, tran_data, data_total_len);\r
4642         ///-------------------------------------------------------///        \r
4643         /// create the file that stores the initial base data\r
4644         ///-------------------------------------------------------///        \r
4645         fp = filp_open(file_name, O_RDWR | O_CREAT, 0644);\r
4646         if(IS_ERR(fp))\r
4647         {\r
4648                 printk("[ZET] : Failed to open %s\n", file_name);\r
4649                 return;\r
4650         }\r
4651         old_fs = get_fs();\r
4652         set_fs(KERNEL_DS);\r
4653 \r
4654         vfs_write(fp, tran_data, data_total_len, &(fp->f_pos));\r
4655         set_fs(old_fs);\r
4656         filp_close(fp, 0);\r
4657 \r
4658         return;\r
4659 }\r
4660 #endif ///< FEATURE_FPC_SHORT_ENABLE\r
4661 \r
4662 ///***********************************************************************\r
4663 ///   [function]:  zet_mbase_save\r
4664 ///   [parameters]: char *\r
4665 ///   [return]: void\r
4666 ///************************************************************************\r
4667 #ifdef FEATURE_MBASE_OUT_ENABLE\r
4668 static void zet_mbase_save(char *file_name)\r
4669 {\r
4670         struct file *fp;\r
4671         int data_total_len  = (row * col * 2);\r
4672                                 \r
4673 \r
4674         ///-------------------------------------------------------///        \r
4675         /// create the file that stores the mutual base data\r
4676         ///-------------------------------------------------------/// \r
4677         memcpy(mbase_data, tran_data, data_total_len);       \r
4678         fp = filp_open(file_name, O_RDWR | O_CREAT, 0644);\r
4679         if(IS_ERR(fp))\r
4680         {\r
4681                 printk("[ZET] : Failed to open %s\n", file_name);\r
4682                 return;\r
4683         }\r
4684         old_fs = get_fs();\r
4685         set_fs(KERNEL_DS);\r
4686 \r
4687         vfs_write(fp, tran_data, data_total_len, &(fp->f_pos));\r
4688         set_fs(old_fs);\r
4689         filp_close(fp, 0);\r
4690 \r
4691         return;\r
4692 }\r
4693 #endif ///< FEATURE_MBASE_OUT_ENABLE\r
4694 \r
4695 ///***********************************************************************\r
4696 ///   [function]:  zet_information_save\r
4697 ///   [parameters]: char *\r
4698 ///   [return]: void\r
4699 ///************************************************************************\r
4700 #ifdef FEATURE_INFO_OUT_EANBLE\r
4701 static void zet_information_save(char *file_name)\r
4702 {\r
4703         struct file *fp;\r
4704         int data_total_len  = INFO_DATA_SIZE;\r
4705                                 \r
4706 \r
4707         ///-------------------------------------------------------///        \r
4708         /// create the file that stores the mutual base data\r
4709         ///-------------------------------------------------------/// \r
4710         memcpy(info_data, tran_data, data_total_len);       \r
4711         fp = filp_open(file_name, O_RDWR | O_CREAT, 0644);\r
4712         if(IS_ERR(fp))\r
4713         {\r
4714                 printk("[ZET] : Failed to open %s\n", file_name);\r
4715                 filp_close(fp, 0);\r
4716                 return;\r
4717         }\r
4718         old_fs = get_fs();\r
4719         set_fs(KERNEL_DS);\r
4720 \r
4721         vfs_write(fp, info_data, data_total_len, &(fp->f_pos));\r
4722         set_fs(old_fs);\r
4723         filp_close(fp, 0);\r
4724 \r
4725         return;\r
4726 }\r
4727 #endif ///< FEATURE_INFO_OUT_EANBLE\r
4728 \r
4729 ///***********************************************************************\r
4730 ///   [function]:  zet_trace_x_save\r
4731 ///   [parameters]: char *\r
4732 ///   [return]: void\r
4733 ///************************************************************************\r
4734 #ifdef FEATURE_INFO_OUT_EANBLE\r
4735 static void zet_trace_x_save(char *file_name)\r
4736 {\r
4737         struct file *fp;\r
4738         int data_total_len  = col;\r
4739 \r
4740         ///-------------------------------------------------------///        \r
4741         /// create the file that stores the trace X data\r
4742         ///-------------------------------------------------------///  \r
4743         memcpy(trace_x_data, tran_data, data_total_len);      \r
4744         fp = filp_open(file_name, O_RDWR | O_CREAT, 0644);\r
4745         if(IS_ERR(fp))\r
4746         {\r
4747                 printk("[ZET] : Failed to open %s\n", file_name);\r
4748                 return;\r
4749         }\r
4750         old_fs = get_fs();\r
4751         set_fs(KERNEL_DS);\r
4752 \r
4753         vfs_write(fp, tran_data, data_total_len, &(fp->f_pos));\r
4754         set_fs(old_fs);\r
4755         filp_close(fp, 0);\r
4756 \r
4757         return;\r
4758 }\r
4759 #endif ///< FEATURE_INFO_OUT_EANBLE\r
4760 \r
4761 ///***********************************************************************\r
4762 ///   [function]:  zet_trace_y_save\r
4763 ///   [parameters]: char *\r
4764 ///   [return]: void\r
4765 ///************************************************************************\r
4766 #ifdef FEATURE_INFO_OUT_EANBLE\r
4767 static void zet_trace_y_save(char *file_name)\r
4768 {\r
4769         struct file *fp;\r
4770         int data_total_len  = row;\r
4771 \r
4772         ///-------------------------------------------------------///        \r
4773         /// create the file that stores the trace Y data\r
4774         ///-------------------------------------------------------///     \r
4775         memcpy(trace_y_data, tran_data, data_total_len);   \r
4776         fp = filp_open(file_name, O_RDWR | O_CREAT, 0644);\r
4777         if(IS_ERR(fp))\r
4778         {\r
4779                 printk("[ZET] : Failed to open %s\n", file_name);\r
4780                 return;\r
4781         }\r
4782         old_fs = get_fs();\r
4783         set_fs(KERNEL_DS);\r
4784 \r
4785         vfs_write(fp, tran_data, data_total_len, &(fp->f_pos));\r
4786         set_fs(old_fs);\r
4787         filp_close(fp, 0);\r
4788 \r
4789         return;\r
4790 }\r
4791 #endif ///< FEATURE_INFO_OUT_EANBLE\r
4792 \r
4793 ///************************************************************************\r
4794 ///   [function]:  zet_dv_set_file_name\r
4795 ///   [parameters]: void\r
4796 ///   [return]: void\r
4797 ///************************************************************************\r
4798 static void zet_dv_set_file_name(char *file_name)\r
4799 {\r
4800         strcpy(driver_version, file_name);\r
4801 }\r
4802 \r
4803 ///************************************************************************\r
4804 ///   [function]:  zet_dv_set_file_name\r
4805 ///   [parameters]: void\r
4806 ///   [return]: void\r
4807 ///************************************************************************\r
4808 static void zet_fw_set_pcode_name(char *file_name)\r
4809 {\r
4810         strcpy(pcode_version, file_name);\r
4811 }\r
4812 \r
4813 ///************************************************************************\r
4814 ///   [function]:  zet_fw_set_file_name\r
4815 ///   [parameters]: void\r
4816 ///   [return]: void\r
4817 ///************************************************************************\r
4818 static void zet_fw_set_file_name(char *file_name)\r
4819 {\r
4820         strcpy(fw_file_name, file_name);\r
4821 }\r
4822 \r
4823 ///************************************************************************\r
4824 ///   [function]:  zet_mdev_set_file_name\r
4825 ///   [parameters]: void\r
4826 ///   [return]: void\r
4827 ///************************************************************************\r
4828 static void zet_tran_type_set_file_name(char *file_name)\r
4829 {\r
4830         strcpy(tran_type_mode_file_name, file_name);\r
4831 }\r
4832 \r
4833 ///***********************************************************************\r
4834 ///   [function]:  zet_fw_size\r
4835 ///   [parameters]: void\r
4836 ///   [return]: void\r
4837 ///************************************************************************\r
4838 static int zet_fw_size(void)\r
4839 {\r
4840         int flash_total_len     = 0x8000;\r
4841         \r
4842         switch(ic_model)\r
4843         {\r
4844                 case MODEL_ZET6221:\r
4845                         flash_total_len = 0x4000;\r
4846                         break;\r
4847                 case MODEL_ZET6223: \r
4848                         flash_total_len = 0x10000;\r
4849                         break;\r
4850                 case MODEL_ZET6231:                     \r
4851                 case MODEL_ZET6251: \r
4852                 default: \r
4853                         flash_total_len = 0x8000;\r
4854                         break;\r
4855         }\r
4856         \r
4857         return flash_total_len;\r
4858 }\r
4859 \r
4860 ///***********************************************************************\r
4861 ///   [function]:  zet_fw_save\r
4862 ///   [parameters]: file name\r
4863 ///   [return]: void\r
4864 ///************************************************************************\r
4865 static void zet_fw_save(char *file_name)\r
4866 {\r
4867         struct file *fp;\r
4868         int flash_total_len     = 0;\r
4869         \r
4870         fp = filp_open(file_name, O_RDWR | O_CREAT, 0644);\r
4871         if(IS_ERR(fp))\r
4872         {\r
4873                 printk("[ZET] : Failed to open %s\n", file_name);\r
4874                 return;\r
4875         }\r
4876         old_fs = get_fs();\r
4877         set_fs(KERNEL_DS);\r
4878 \r
4879         flash_total_len = zet_fw_size();\r
4880         printk("[ZET] : flash_total_len = 0x%04x\n",flash_total_len );\r
4881 \r
4882         vfs_write(fp, flash_buffer, flash_total_len, &(fp->f_pos));\r
4883         \r
4884         set_fs(old_fs);\r
4885 \r
4886         filp_close(fp, 0);      \r
4887 \r
4888         \r
4889         return;\r
4890 }\r
4891 \r
4892 ///***********************************************************************\r
4893 ///   [function]:  zet_fw_load\r
4894 ///   [parameters]: file name\r
4895 ///   [return]: void\r
4896 ///************************************************************************\r
4897 static void zet_fw_load(char *file_name)\r
4898 {       \r
4899         int file_length = 0;\r
4900         struct file *fp;\r
4901         loff_t *pos;\r
4902         \r
4903         //printk("[ZET]: find %s\n", file_name);\r
4904         fp = filp_open(file_name, O_RDONLY, 0644);\r
4905         if(IS_ERR(fp))\r
4906         {                       \r
4907                 //printk("[ZET]: No firmware file detected\n");\r
4908                 return;\r
4909         }\r
4910 \r
4911         ///----------------------------///\r
4912         /// Load from file\r
4913         ///----------------------------///              \r
4914         printk("[ZET]: Load from %s\n", file_name);     \r
4915 \r
4916         old_fs = get_fs();\r
4917         set_fs(KERNEL_DS);\r
4918 \r
4919         /// Get file size\r
4920         inode = fp->f_dentry->d_inode;\r
4921         file_length = (int)inode->i_size;\r
4922 \r
4923         pos = &(fp->f_pos); \r
4924 \r
4925         vfs_read(fp, &flash_buffer[0], file_length, pos);\r
4926 \r
4927         //file_length\r
4928         set_fs(old_fs);\r
4929         filp_close(fp, 0);\r
4930         chk_have_bin_file = TRUE;\r
4931 \r
4932 }\r
4933 \r
4934 ///************************************************************************\r
4935 ///   [function]:  zet_mem_init\r
4936 ///   [parameters]: void\r
4937 ///   [return]: void\r
4938 ///************************************************************************\r
4939 static void zet_mem_init(void)\r
4940 {\r
4941         if(flash_buffer == NULL)\r
4942         {\r
4943                 flash_buffer = kmalloc(MAX_FLASH_BUF_SIZE, GFP_KERNEL); \r
4944         }\r
4945 \r
4946         ///---------------------------------------------///\r
4947         /// Init the mutual dev buffer\r
4948         ///---------------------------------------------///\r
4949         if(mdev_data== NULL)\r
4950         {\r
4951                 mdev_data   = kmalloc(MDEV_MAX_DATA_SIZE, GFP_KERNEL);\r
4952         }\r
4953         if(idev_data== NULL)\r
4954         {\r
4955                 idev_data   = kmalloc(IDEV_MAX_DATA_SIZE, GFP_KERNEL);\r
4956         }\r
4957 \r
4958         if(mbase_data== NULL)\r
4959         {\r
4960                 mbase_data  = kmalloc(MBASE_MAX_DATA_SIZE, GFP_KERNEL);\r
4961         }\r
4962         if(ibase_data== NULL)\r
4963         {\r
4964                 ibase_data  = kmalloc(IBASE_MAX_DATA_SIZE, GFP_KERNEL);\r
4965         }       \r
4966         \r
4967 #ifdef FEATURE_FPC_OPEN_ENABLE\r
4968         if(fpcopen_data == NULL)\r
4969         {\r
4970                 fpcopen_data  = kmalloc(FPC_OPEN_MAX_DATA_SIZE, GFP_KERNEL);\r
4971         }\r
4972 #endif ///< for FEATURE_FPC_OPEN_ENABLE\r
4973 \r
4974 #ifdef FEATURE_FPC_SHORT_ENABLE\r
4975         if(fpcshort_data == NULL)\r
4976         {\r
4977                 fpcshort_data  = kmalloc(FPC_SHORT_MAX_DATA_SIZE, GFP_KERNEL);\r
4978         }\r
4979 #endif ///< for FEATURE_FPC_SHORT_ENABLE\r
4980         \r
4981         if(tran_data == NULL)\r
4982         {\r
4983                 tran_data  = kmalloc(MBASE_MAX_DATA_SIZE, GFP_KERNEL);\r
4984         }\r
4985 \r
4986         if(info_data == NULL)\r
4987         {\r
4988                 info_data  = kmalloc(INFO_MAX_DATA_SIZE, GFP_KERNEL);\r
4989         }\r
4990 \r
4991         if(trace_x_data == NULL)\r
4992         {\r
4993                 trace_x_data  = kmalloc(INFO_MAX_DATA_SIZE, GFP_KERNEL);\r
4994         }\r
4995         if(trace_y_data == NULL)\r
4996         {\r
4997                 trace_y_data  = kmalloc(INFO_MAX_DATA_SIZE, GFP_KERNEL);\r
4998         }\r
4999 }\r
5000 \r
5001 ///************************************************************************\r
5002 ///   [function]:  zet_fw_init\r
5003 ///   [parameters]: void\r
5004 ///   [return]: void\r
5005 ///************************************************************************\r
5006 static void zet_fw_init(void)\r
5007 {\r
5008         int i;\r
5009         \r
5010         //printk("[ZET]: Load from header\n");\r
5011 \r
5012         if(ic_model == MODEL_ZET6221)\r
5013         {\r
5014                 for(i = 0 ; i < sizeof(zeitec_zet6221_firmware) ; i++)\r
5015                 {\r
5016                         flash_buffer[i] = zeitec_zet6221_firmware[i];\r
5017                 }\r
5018                 \r
5019         }\r
5020         else if(ic_model == MODEL_ZET6223)\r
5021         {\r
5022                 for(i = 0 ; i < sizeof(zeitec_zet6223_firmware) ; i++)\r
5023                 {\r
5024                         flash_buffer[i] = zeitec_zet6223_firmware[i];\r
5025                 }\r
5026 #ifdef FEATRUE_TRACE_SENSOR_ID\r
5027                flash_buffer_01 = &zeitec_zet6223_01_firmware[0];\r
5028                flash_buffer_02 = &zeitec_zet6223_02_firmware[0];\r
5029                flash_buffer_03 = &zeitec_zet6223_03_firmware[0];\r
5030 #endif ///< FEATRUE_TRACE_SENSOR_ID\r
5031         }\r
5032         else if(ic_model == MODEL_ZET6231)\r
5033         {\r
5034                 for(i = 0 ; i < sizeof(zeitec_zet6231_firmware) ; i++)\r
5035                 {\r
5036                         flash_buffer[i] = zeitec_zet6231_firmware[i];\r
5037                 }\r
5038 #ifdef FEATRUE_TRACE_SENSOR_ID\r
5039                flash_buffer_01 = &zeitec_zet6231_01_firmware[0];\r
5040                flash_buffer_02 = &zeitec_zet6231_02_firmware[0];\r
5041                flash_buffer_03 = &zeitec_zet6231_03_firmware[0];\r
5042 #endif ///< FEATRUE_TRACE_SENSOR_ID\r
5043         }\r
5044         else if(ic_model == MODEL_ZET6251)\r
5045         {\r
5046                 for(i = 0 ; i < sizeof(zeitec_zet6251_firmware) ; i++)\r
5047                 {\r
5048                         flash_buffer[i] = zeitec_zet6251_firmware[i];\r
5049                 }\r
5050 #ifdef FEATRUE_TRACE_SENSOR_ID\r
5051                 flash_buffer_01 = &zeitec_zet6251_01_firmware[0];\r
5052               flash_buffer_02 = &zeitec_zet6251_02_firmware[0];\r
5053               flash_buffer_03 = &zeitec_zet6251_03_firmware[0];\r
5054 #endif ///< FEATRUE_TRACE_SENSOR_ID\r
5055         }\r
5056         \r
5057         /// Load firmware from bin file\r
5058         zet_fw_load(fw_file_name);\r
5059 }\r
5060 \r
5061 ///************************************************************************\r
5062 ///   [function]:  zet_fw_exit\r
5063 ///   [parameters]: void\r
5064 ///   [return]: void\r
5065 ///************************************************************************\r
5066 static void zet_fw_exit(void)\r
5067 {\r
5068         ///---------------------------------------------///\r
5069         /// free mdev_data\r
5070         ///---------------------------------------------///\r
5071         if(mdev_data!=NULL)\r
5072         {\r
5073                 kfree(mdev_data);\r
5074                 mdev_data = NULL;\r
5075         }\r
5076 \r
5077         if(idev_data!=NULL)\r
5078         {                       \r
5079                 kfree(idev_data);\r
5080                 idev_data = NULL;\r
5081         }\r
5082 \r
5083         if(mbase_data!=NULL)\r
5084         {       \r
5085                 kfree(mbase_data);\r
5086                 mbase_data = NULL;\r
5087         }\r
5088 \r
5089         if(ibase_data!=NULL)\r
5090         {       \r
5091                 kfree(ibase_data);\r
5092                 ibase_data = NULL;\r
5093         }\r
5094         \r
5095 #ifdef FEATURE_FPC_OPEN_ENABLE\r
5096         if(fpcopen_data!=NULL)\r
5097         {       \r
5098                 kfree(fpcopen_data);\r
5099                 fpcopen_data = NULL;\r
5100         }\r
5101 #endif ///< for FEATURE_FPC_OPEN_ENABLE\r
5102         \r
5103 #ifdef FEATURE_FPC_OPEN_ENABLE\r
5104         if(fpcshort_data!=NULL)\r
5105         {       \r
5106                 kfree(fpcshort_data);\r
5107                 fpcshort_data = NULL;\r
5108         }\r
5109 #endif ///< for FEATURE_FPC_OPEN_ENABLE\r
5110         \r
5111         if(tran_data != NULL)   \r
5112         {\r
5113                 kfree(tran_data);\r
5114                 tran_data = NULL;\r
5115         }\r
5116 \r
5117         if(info_data != NULL)   \r
5118         {\r
5119                 kfree(info_data);\r
5120                 info_data = NULL;\r
5121         }\r
5122 \r
5123         if(trace_x_data != NULL)        \r
5124         {\r
5125                 kfree(trace_x_data);\r
5126                 trace_x_data = NULL;\r
5127         }\r
5128 \r
5129         if(trace_y_data != NULL)        \r
5130         {\r
5131                 kfree(trace_y_data);\r
5132                 trace_y_data = NULL;\r
5133         }\r
5134 \r
5135         ///---------------------------------------------///\r
5136         /// free flash buffer\r
5137         ///---------------------------------------------///\r
5138         if(flash_buffer!=NULL)\r
5139         {\r
5140                 kfree(flash_buffer);\r
5141                 flash_buffer = NULL;\r
5142         }\r
5143 \r
5144 }\r
5145 \r
5146 ///************************************************************************\r
5147 ///   [function]:  zet_fops_open\r
5148 ///   [parameters]: file\r
5149 ///   [return]: int\r
5150 ///************************************************************************\r
5151 static int zet_fops_open(struct inode *inode, struct file *file)\r
5152 {\r
5153         int subminor;\r
5154         int ret = 0;    \r
5155         struct i2c_client *client;\r
5156         struct i2c_adapter *adapter;    \r
5157         struct i2c_dev *i2c_dev;        \r
5158         \r
5159         subminor = iminor(inode);\r
5160         printk("[ZET] : ZET_FOPS_OPEN ,  subminor=%d\n",subminor);\r
5161         \r
5162         i2c_dev = zet622x_i2c_dev_get_by_minor(subminor);       \r
5163         if (!i2c_dev)\r
5164         {       \r
5165                 printk("error i2c_dev\n");              \r
5166                 return -ENODEV; \r
5167         }\r
5168         \r
5169         adapter = i2c_get_adapter(i2c_dev->adap->nr);   \r
5170         if(!adapter)\r
5171         {               \r
5172                 return -ENODEV; \r
5173         }       \r
5174         \r
5175         client = kzalloc(sizeof(*client), GFP_KERNEL);  \r
5176         \r
5177         if(!client)\r
5178         {               \r
5179                 i2c_put_adapter(adapter);               \r
5180                 ret = -ENOMEM;  \r
5181         }       \r
5182         snprintf(client->name, I2C_NAME_SIZE, "pctp_i2c_ts%d", adapter->nr);\r
5183         client->driver = &zet622x_i2c_driver;\r
5184         client->adapter = adapter;              \r
5185         file->private_data = client;\r
5186                 \r
5187         return 0;\r
5188 }\r
5189 \r
5190 \r
5191 ///************************************************************************\r
5192 ///   [function]:  zet_fops_release\r
5193 ///   [parameters]: inode, file\r
5194 ///   [return]: int\r
5195 ///************************************************************************\r
5196 static int zet_fops_release (struct inode *inode, struct file *file) \r
5197 {\r
5198         struct i2c_client *client = file->private_data;\r
5199 \r
5200         printk("[ZET] : zet_fops_release -> line : %d\n",__LINE__ );\r
5201         \r
5202         i2c_put_adapter(client->adapter);\r
5203         kfree(client);\r
5204         file->private_data = NULL;\r
5205         return 0;         \r
5206 }\r
5207 \r
5208 ///************************************************************************\r
5209 ///   [function]:  zet_fops_read\r
5210 ///   [parameters]: file, buf, count, ppos\r
5211 ///   [return]: size_t\r
5212 ///************************************************************************\r
5213 static ssize_t zet_fops_read(struct file *file, char __user *buf, size_t count,\r
5214                         loff_t *ppos)\r
5215 {\r
5216         int i;\r
5217         int iCnt = 0;\r
5218         char str[256];\r
5219         int len = 0;\r
5220 \r
5221         printk("[ZET] : zet_fops_read -> line : %d\n",__LINE__ );\r
5222         \r
5223         ///-------------------------------///\r
5224         /// Print message\r
5225         ///-------------------------------///   \r
5226         sprintf(str, "Please check \"%s\"\n", fw_file_name);\r
5227         len = strlen(str);\r
5228 \r
5229         ///-------------------------------///\r
5230         /// if read out\r
5231         ///-------------------------------///           \r
5232         if(data_offset >= len)\r
5233         {\r
5234                 return 0;\r
5235         }               \r
5236         \r
5237         for(i = 0 ; i < count-1 ; i++)\r
5238         {\r
5239                 buf[i] = str[data_offset];\r
5240                 buf[i+1] = 0;\r
5241                 iCnt++;\r
5242                 data_offset++;\r
5243                 if(data_offset >= len)\r
5244                 {\r
5245                         break;\r
5246                 }\r
5247         }       \r
5248         \r
5249         ///-------------------------------///\r
5250         /// Save file\r
5251         ///-------------------------------///   \r
5252         if(data_offset == len)\r
5253         {\r
5254                 zet_fw_save(fw_file_name);\r
5255         }       \r
5256         return iCnt;\r
5257 }\r
5258 \r
5259 ///************************************************************************\r
5260 ///   [function]:  zet_fops_write\r
5261 ///   [parameters]: file, buf, count, ppos\r
5262 ///   [return]: size_t\r
5263 ///************************************************************************\r
5264 static ssize_t zet_fops_write(struct file *file, const char __user *buf,\r
5265                                                 size_t count, loff_t *ppos)\r
5266 {       \r
5267         printk("[ZET]: zet_fops_write ->  %s\n", buf);\r
5268         data_offset = 0;\r
5269         return count;\r
5270 }\r
5271 \r
5272 ///************************************************************************\r
5273 ///   [function]:  ioctl\r
5274 ///   [parameters]: file , cmd , arg\r
5275 ///   [return]: long\r
5276 ///************************************************************************\r
5277 static long zet_fops_ioctl(struct file *file, unsigned int cmd, unsigned long arg )\r
5278 {\r
5279   u8 __user * user_buf = (u8 __user *) arg;\r
5280 \r
5281         u8 buf[IOCTL_MAX_BUF_SIZE];\r
5282         int input_data;\r
5283         int data_size;\r
5284         \r
5285         if(copy_from_user(buf, user_buf, IOCTL_MAX_BUF_SIZE))\r
5286         {\r
5287                 printk("[ZET]: zet_ioctl: copy_from_user fail\n");\r
5288                 return 0;\r
5289         }\r
5290 \r
5291         printk("[ZET]: zet_ioctl ->  cmd = %d, %02x, %02x\n",  cmd, buf[0], buf[1]);\r
5292 \r
5293         if(cmd == ZET_IOCTL_CMD_FLASH_READ)\r
5294         {\r
5295                 printk("[ZET]: zet_ioctl -> ZET_IOCTL_CMD_FLASH_DUMP  cmd = %d, file=%s\n",  cmd, (char *)buf);\r
5296                 ioctl_action |= IOCTL_ACTION_FLASH_DUMP;\r
5297         }\r
5298         else if(cmd == ZET_IOCTL_CMD_FLASH_WRITE)\r
5299         {\r
5300                 printk("[ZET]: zet_ioctl -> ZET_IOCTL_CMD_FLASH_WRITE  cmd = %d\n",  cmd);      \r
5301                 \r
5302                 resume_download = TRUE;\r
5303                 zet622x_resume_downloader(this_client, firmware_upgrade, &rom_type, ic_model);          \r
5304                 resume_download = FALSE;\r
5305         }\r
5306         else if(cmd == ZET_IOCTL_CMD_RST)\r
5307         {\r
5308                 printk("[ZET]: zet_ioctl -> ZET_IOCTL_CMD_RST  cmd = %d\n",  cmd);\r
5309                 //ctp_reset();\r
5310                 ctp_set_reset_high();\r
5311 \r
5312                 ctp_set_reset_low();    \r
5313                 msleep(20);\r
5314                 ctp_set_reset_high();\r
5315 \r
5316                 transfer_type = TRAN_TYPE_DYNAMIC;                      \r
5317         }\r
5318         else if(cmd == ZET_IOCTL_CMD_RST_HIGH)\r
5319         {\r
5320                 ctp_set_reset_high();\r
5321         }\r
5322         else if(cmd == ZET_IOCTL_CMD_RST_LOW)\r
5323         {\r
5324                 ctp_set_reset_low();    \r
5325         }\r
5326         else if(cmd == ZET_IOCTL_CMD_GPIO_HIGH)\r
5327         {\r
5328                 input_data = (int)buf[0];\r
5329 #ifdef FEATRUE_TRACE_GPIO_OUTPUT\r
5330                 zet622x_ts_gpio_output(input_data, TRUE);\r
5331 #endif ///< for FEATRUE_TRACE_GPIO_OUTPUT\r
5332         }\r
5333         else if(cmd == ZET_IOCTL_CMD_GPIO_LOW)\r
5334         {\r
5335                 input_data = (int)buf[0];\r
5336 #ifdef FEATRUE_TRACE_GPIO_OUTPUT\r
5337                 zet622x_ts_gpio_output(input_data, FALSE);\r
5338 #endif ///< for FEATRUE_TRACE_GPIO_OUTPUT\r
5339         }\r
5340         else if(cmd == ZET_IOCTL_CMD_MDEV)\r
5341         {\r
5342                 ///---------------------------------------------------///\r
5343                 /// set mutual dev mode\r
5344                 ///---------------------------------------------------///\r
5345                 zet622x_ts_set_transfer_type(TRAN_TYPE_MUTUAL_SCAN_DEV);\r
5346                 transfer_type = TRAN_TYPE_MUTUAL_SCAN_DEV;                      \r
5347                 \r
5348         }\r
5349         else if(cmd == ZET_IOCTL_CMD_IBASE)\r
5350         {\r
5351                 ///---------------------------------------------------///\r
5352                 /// set initial base mode\r
5353                 ///---------------------------------------------------///\r
5354                 zet622x_ts_set_transfer_type(TRAN_TYPE_INIT_SCAN_BASE);\r
5355                 transfer_type = TRAN_TYPE_INIT_SCAN_BASE;\r
5356                 \r
5357         }       \r
5358 #ifdef FEATURE_IDEV_OUT_ENABLE \r
5359         else if(cmd == ZET_IOCTL_CMD_IDEV)\r
5360         {\r
5361                 ///---------------------------------------------------///\r
5362                 /// set initial dev mode\r
5363                 ///---------------------------------------------------///\r
5364                 zet622x_ts_set_transfer_type(TRAN_TYPE_INIT_SCAN_DEV);\r
5365                 transfer_type = TRAN_TYPE_INIT_SCAN_DEV;\r
5366                 \r
5367         }\r
5368 #endif ///<     FEATURE_IDEV_OUT_ENABLE\r
5369 #ifdef FEATURE_MBASE_OUT_ENABLE\r
5370         else if(cmd == ZET_IOCTL_CMD_MBASE)\r
5371         {\r
5372                 ///---------------------------------------------------///\r
5373                 /// set Mutual Base mode\r
5374                 ///---------------------------------------------------///\r
5375                 zet622x_ts_set_transfer_type(TRAN_TYPE_MUTUAL_SCAN_BASE);\r
5376                 transfer_type = TRAN_TYPE_MUTUAL_SCAN_BASE;\r
5377                 \r
5378         }\r
5379 #endif ///< FEATURE_MBASE_OUT_ENABLE\r
5380         else if(cmd == ZET_IOCTL_CMD_DYNAMIC)\r
5381         {\r
5382                 zet622x_ts_set_transfer_type(TRAN_TYPE_DYNAMIC);\r
5383                 transfer_type = TRAN_TYPE_DYNAMIC;\r
5384         }\r
5385         else if(cmd == ZET_IOCTL_CMD_FW_FILE_PATH_GET)\r
5386         {\r
5387                 memset(buf, 0x00, 64);\r
5388                 strcpy(buf, fw_file_name);              \r
5389                 printk("[ZET]: zet_ioctl: Get FW_FILE_NAME = %s\n", buf);\r
5390         }\r
5391         else if(cmd == ZET_IOCTL_CMD_FW_FILE_PATH_SET)\r
5392         {\r
5393                 strcpy(fw_file_name, buf);              \r
5394                 printk("[ZET]: zet_ioctl: set FW_FILE_NAME = %s\n", buf);\r
5395         }\r
5396         else if(cmd == ZET_IOCTL_CMD_MDEV_GET)\r
5397         {\r
5398                 data_size = (row+2)*(col+2);\r
5399                 memcpy(buf, mdev_data, data_size);\r
5400                 printk("[ZET]: zet_ioctl: Get MDEV data size=%d\n", data_size);\r
5401          }\r
5402         else if(cmd == ZET_IOCTL_CMD_TRAN_TYPE_PATH_SET)\r
5403         {\r
5404                 strcpy(tran_type_mode_file_name, buf);          \r
5405                 printk("[ZET]: zet_ioctl: Set ZET_IOCTL_CMD_TRAN_TYPE_PATH_ = %s\n", buf);\r
5406         }\r
5407         else if(cmd == ZET_IOCTL_CMD_TRAN_TYPE_PATH_GET)\r
5408         {\r
5409                 memset(buf, 0x00, 64);\r
5410                 strcpy(buf, tran_type_mode_file_name);  \r
5411                 printk("[ZET]: zet_ioctl: Get ZET_IOCTL_CMD_TRAN_TYPE_PATH = %s\n", buf);\r
5412         }\r
5413         else if(cmd == ZET_IOCTL_CMD_IDEV_GET)\r
5414         {\r
5415                 data_size = (row + col);\r
5416                 memcpy(buf, idev_data, data_size);\r
5417                 printk("[ZET]: zet_ioctl: Get IDEV data size=%d\n", data_size);\r
5418         }\r
5419         else if(cmd == ZET_IOCTL_CMD_IBASE_GET)\r
5420         {\r
5421                 data_size = (row + col)*2;\r
5422                 memcpy(buf, ibase_data, data_size);\r
5423                 printk("[ZET]: zet_ioctl: Get IBASE data size=%d\n", data_size);\r
5424         }       \r
5425         else if(cmd == ZET_IOCTL_CMD_MBASE_GET)\r
5426         {\r
5427                 data_size = (row*col*2);\r
5428                 if(data_size > IOCTL_MAX_BUF_SIZE)\r
5429                 {\r
5430                         data_size = IOCTL_MAX_BUF_SIZE;\r
5431                 }\r
5432                 memcpy(buf, mbase_data, data_size);\r
5433                 printk("[ZET]: zet_ioctl: Get MBASE data size=%d\n", data_size);\r
5434         }\r
5435         else if(cmd == ZET_IOCTL_CMD_INFO_SET)\r
5436         {\r
5437                 printk("[ZET]: zet_ioctl: ZET_IOCTL_CMD_INFO_SET\n");\r
5438                 zet622x_ts_set_info_type();\r
5439         }\r
5440         else if(cmd == ZET_IOCTL_CMD_INFO_GET)\r
5441         {\r
5442                 data_size = INFO_DATA_SIZE;\r
5443  #ifdef FEATURE_INFO_OUT_EANBLE\r
5444                 memcpy(buf, info_data, data_size);\r
5445                 printk("[ZET]: zet_ioctl: Get INFO data size=%d,IC: %x,X:%d,Y:%d\n", data_size, info_data[0], info_data[13], info_data[14]);\r
5446   #endif ///< for FEATURE_INFO_OUT_EANBLE               \r
5447         }\r
5448         else if(cmd == ZET_IOCTL_CMD_TRACE_X_NAME_SET)\r
5449         {\r
5450  #ifdef FEATURE_INFO_OUT_EANBLE\r
5451                 zet622x_ts_set_trace_x_type();\r
5452   #endif ///< for FEATURE_INFO_OUT_EANBLE               \r
5453         }\r
5454         else if(cmd == ZET_IOCTL_CMD_TRACE_X_NAME_GET)\r
5455         {\r
5456                 data_size = col;\r
5457  #ifdef FEATURE_INFO_OUT_EANBLE\r
5458                 memcpy(buf, trace_x_data, data_size);\r
5459   #endif ///< for FEATURE_INFO_OUT_EANBLE       \r
5460         }\r
5461         else if(cmd == ZET_IOCTL_CMD_TRACE_Y_NAME_SET)\r
5462         {\r
5463  #ifdef FEATURE_INFO_OUT_EANBLE\r
5464                 zet622x_ts_set_trace_y_type();\r
5465   #endif ///< for FEATURE_INFO_OUT_EANBLE               \r
5466         }\r
5467         else if(cmd == ZET_IOCTL_CMD_TRACE_Y_NAME_GET)\r
5468         {\r
5469                 data_size = row;\r
5470  #ifdef FEATURE_INFO_OUT_EANBLE\r
5471                 memcpy(buf, trace_y_data, data_size);\r
5472   #endif ///< for FEATURE_INFO_OUT_EANBLE       \r
5473         }\r
5474         else if(cmd == ZET_IOCTL_CMD_TRACE_X_SET)\r
5475         {\r
5476                 printk("[ZET]: zet_ioctl: ZET_IOCTL_CMD_TRACE_X_SET\n");\r
5477                 row = (int)(*buf);\r
5478         }\r
5479         else if(cmd == ZET_IOCTL_CMD_WRITE_CMD)\r
5480         {\r
5481                 zet622x_cmd_ioctl_write_data(this_client, buf[0], &buf[1]);\r
5482         }\r
5483         else if(cmd == ZET_IOCTL_CMD_TRACE_X_GET)\r
5484         {\r
5485                 printk("[ZET]: zet_ioctl: Get TRACEX data\n");\r
5486                 memset(buf, 0x00, 64);\r
5487                 data_size = sizeof(int);\r
5488                 memcpy(buf, &row, data_size);\r
5489         \r
5490         }\r
5491         else if(cmd == ZET_IOCTL_CMD_TRACE_Y_SET)\r
5492         {\r
5493                 printk("[ZET]: zet_ioctl: ZET_IOCTL_CMD_TRACE_Y_SET\n");\r
5494                 col = (int)(*buf);\r
5495         }\r
5496         else if(cmd == ZET_IOCTL_CMD_TRACE_Y_GET)\r
5497         {\r
5498                 printk("[ZET]: zet_ioctl: Get TRACEY data \n");\r
5499                 memset(buf, 0x00, 64);\r
5500                 data_size = sizeof(int);\r
5501                 memcpy(buf, &col, data_size);\r
5502         }\r
5503         else if(cmd == ZET_IOCTL_CMD_DRIVER_VER_GET)\r
5504         {\r
5505                 memset(buf, 0x00, 64);\r
5506                 strcpy(buf, driver_version);            \r
5507                 printk("[ZET]: zet_ioctl: Get DRIVER_VERSION = %s\n", buf);\r
5508                 printk("[ZET]: zet_ioctl: Get SVN = %s\n", DRIVER_VERSION);\r
5509         }\r
5510         else if(cmd == ZET_IOCTL_CMD_SENID_GET)\r
5511         {\r
5512                 memset(buf, 0x00, 64);\r
5513                 \r
5514         #ifdef FEATRUE_TRACE_SENSOR_ID\r
5515                 buf[0] = sensor_id_status;\r
5516                 buf[1] = sensor_id;\r
5517                 printk("[ZET]: zet_ioctl: Get ZET_IOCTL_CMD_SENID_GET = %d/ %d\n", sensor_id_status, sensor_id);\r
5518         #else ///< for FEATRUE_TRACE_SENSOR_ID\r
5519                 memset(buf, 0xFF, 64);\r
5520         #endif ///< for FEATRUE_TRACE_SENSOR_ID\r
5521         }\r
5522         else if(cmd == ZET_IOCTL_CMD_PCODE_GET)\r
5523         {\r
5524                 memset(buf, 0x00, 64);\r
5525                 strcpy(buf, pcode_version);     \r
5526                 printk("[ZET]: zet_ioctl: Get ZET_IOCTL_CMD_PCODE_GET = %s\n", buf);\r
5527         \r
5528         }\r
5529         else if(cmd == ZET_IOCTL_CMD_MBASE_EXTERN_GET)\r
5530         {\r
5531                 data_size = (row*col*2) - IOCTL_MAX_BUF_SIZE;\r
5532                 if(data_size < 1)\r
5533                 {\r
5534                         data_size = 1;\r
5535                 }\r
5536                 memcpy(buf, (mbase_data+IOCTL_MAX_BUF_SIZE), data_size);\r
5537                 printk("[ZET]: zet_ioctl: Get MBASE extern data size=%d\n", data_size);\r
5538         }\r
5539         else if(cmd == ZET_IOCTL_CMD_FRAM_RATE)\r
5540         {\r
5541 #ifdef FEATURE_FRAM_RATE\r
5542                 memset(buf, 0x00, 64);\r
5543                 data_size = sizeof(int);\r
5544                 memcpy(buf, &last_fram_rate, data_size);\r
5545 #endif ///< for FEATURE_FRAM_RATE\r
5546         }\r
5547         else if(cmd == ZET_IOCTL_CMD_FPC_OPEN_GET)\r
5548         {\r
5549 #ifdef FEATURE_FPC_OPEN_ENABLE  \r
5550                 data_size = (row + col);\r
5551                 memcpy(buf, fpcopen_data, data_size);\r
5552                 printk("[ZET]: zet_ioctl: Get IDEV data size=%d\n", data_size);\r
5553 #endif ///< for FEATURE_FPC_OPEN_ENABLE\r
5554         }\r
5555         else if(cmd == ZET_IOCTL_CMD_FPC_SHORT_GET)\r
5556         {\r
5557 #ifdef FEATURE_FPC_SHORT_ENABLE\r
5558                 data_size = (row + col)*2;\r
5559                 memcpy(buf, fpcshort_data, data_size);\r
5560                 printk("[ZET]: zet_ioctl: Get IBASE data size=%d\n", data_size);\r
5561 #endif ///< for FEATURE_FPC_SHORT_ENABLE\r
5562         }\r
5563         else if(cmd == ZET_IOCTL_CMD_FPC_SHORT_SET)\r
5564         {\r
5565 #ifdef FEATURE_FPC_SHORT_ENABLE\r
5566                 buf[0] = FPC_SHORT_CMD_LEN;\r
5567                 buf[1] = FPC_SHORT_CMD;\r
5568                 zet622x_cmd_ioctl_write_data(this_client, buf[0], &buf[1]);\r
5569                 transfer_type = TRAN_TYPE_FPC_SHORT;\r
5570 #endif ///< for FEATURE_FPC_SHORT_ENABLE\r
5571         }\r
5572         else if(cmd == ZET_IOCTL_CMD_FPC_OPEN_SET)\r
5573         {\r
5574 #ifdef FEATURE_FPC_OPEN_ENABLE  \r
5575                 buf[0] = FPC_OPEN_CMD_LEN;\r
5576                 buf[1] = FPC_OPEN_CMD;\r
5577                 zet622x_cmd_ioctl_write_data(this_client, buf[0], &buf[1]);\r
5578                 transfer_type = TRAN_TYPE_FPC_OPEN;\r
5579 #endif ///< for FEATURE_FPC_OPEN_ENABLE\r
5580         }\r
5581         \r
5582         if(copy_to_user(user_buf, buf, IOCTL_MAX_BUF_SIZE))\r
5583         {\r
5584                 printk("[ZET]: zet_ioctl: copy_to_user fail\n");\r
5585                 return 0;\r
5586         }\r
5587 \r
5588         return 0;\r
5589 }\r
5590 \r
5591 ///************************************************************************\r
5592 ///     file_operations\r
5593 ///************************************************************************\r
5594 static const struct file_operations zet622x_ts_fops =\r
5595 {       \r
5596         .owner          = THIS_MODULE,  \r
5597         .open           = zet_fops_open,        \r
5598         .read           = zet_fops_read,        \r
5599         .write          = zet_fops_write, \r
5600         .unlocked_ioctl = zet_fops_ioctl,\r
5601         .compat_ioctl   = zet_fops_ioctl,\r
5602         .release        = zet_fops_release, \r
5603 };\r
5604 \r
5605 ///************************************************************************\r
5606 ///   [function]:  zet622x_ts_remove\r
5607 ///   [parameters]:\r
5608 ///   [return]:\r
5609 ///************************************************************************\r
5610 static int  zet622x_ts_remove(struct i2c_client *dev)\r
5611 {\r
5612         struct zet622x_tsdrv *zet6221_ts = i2c_get_clientdata(dev);\r
5613 \r
5614         printk("[ZET] : ==zet622x_ts_remove=\n");\r
5615         del_timer_sync(&zet6221_ts->zet622x_ts_timer_task);\r
5616         free_irq(zet6221_ts->irq, zet6221_ts);\r
5617         \r
5618         ///------------------------------------------///\r
5619         /// unregister early_suspend\r
5620         ///------------------------------------------///\r
5621         //unregister_early_suspend(&zet6221_ts->early_suspend);\r
5622         //tp_unregister_fb(&zet6221_ts->tp);\r
5623 \r
5624         input_unregister_device(zet6221_ts->input);\r
5625         input_free_device(zet6221_ts->input);\r
5626         destroy_workqueue(zet6221_ts->ts_workqueue); //  workqueue\r
5627         kfree(zet6221_ts);\r
5628    \r
5629         i2c_set_clientdata(dev, NULL);\r
5630 \r
5631         /// release the buffer\r
5632         zet_fw_exit();\r
5633 \r
5634         return 0;\r
5635 }\r
5636 \r
5637 ///************************************************************************\r
5638 ///   [function]:  zet622x_ts_probe\r
5639 ///   [parameters]:  i2c_client, i2c_id\r
5640 ///   [return]: int\r
5641 ///************************************************************************\r
5642 static int  zet622x_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)\r
5643 {\r
5644         int result;  //,ret;\r
5645         int err = 0;\r
5646         \r
5647         struct input_dev *input_dev;\r
5648         struct zet622x_tsdrv *zet6221_ts;\r
5649         struct i2c_dev *i2c_dev;\r
5650         struct device *dev;\r
5651         char name[64];  \r
5652         struct device_node *np;\r
5653         enum of_gpio_flags rst_flags;\r
5654         unsigned long irq_flags;\r
5655         int x_TS_INT_GPIO,x_TS_RST_GPIO;\r
5656 \r
5657 \r
5658         //printk("[ZET]: Probe Zet62xx\n");\r
5659         ///------------------------------------------------///\r
5660         /// Check the rst pin have other driver used\r
5661         ///------------------------------------------------///\r
5662         /*\r
5663         result = gpio_request(TS_RST_GPIO, "ts_rst_gpio"); //ÉêÇë¸´Î»IO¿Ú\r
5664         if(result)\r
5665         {\r
5666                 goto LABEL_GPIO_REQUEST_FAIL;\r
5667         }\r
5668         */\r
5669         \r
5670         ///------------------------------------------------///\r
5671         /// init the finger pressed data\r
5672         ///------------------------------------------------///\r
5673 #ifdef FEAURE_LIGHT_LOAD_REPORT_MODE\r
5674         zet62xx_ts_init();\r
5675 #endif  ///< for FEAURE_LIGHT_LOAD_REPORT_MODE\r
5676 \r
5677         ///------------------------------------------------///\r
5678         /// allocate zet32xx touch screen device driver\r
5679         ///------------------------------------------------///\r
5680         zet6221_ts = kzalloc(sizeof(struct zet622x_tsdrv), GFP_KERNEL);//ÎªÉè±¸¿ª±Ù´æ´¢¿Õ¼ä\r
5681 \r
5682         ///------------------------------------------------///\r
5683         /// hook i2c to this_client£¬½¨Á¢IICºÍÎÒÃÇµÄÉè±¸Ö®¼äµÄÁªÏµ\r
5684         ///------------------------------------------------///\r
5685         zet6221_ts->i2c_dev = client;\r
5686         zet6221_ts->gpio = TS_INT_GPIO;\r
5687         this_client = client;   \r
5688         i2c_set_clientdata(client, zet6221_ts);\r
5689 \r
5690         dev = &zet6221_ts->i2c_dev->dev;        \r
5691         np = dev->of_node;\r
5692 \r
5693         /*\r
5694     zet6221_ts->pinctrl = devm_pinctrl_get(&zet6221_ts->i2c_dev->dev);\r
5695     if(IS_ERR(zet6221_ts->pinctrl))\r
5696         {\r
5697                 printk("Warning : No pinctrl used!\n");\r
5698                 return 0;\r
5699         }\r
5700     else\r
5701     {\r
5702         zet6221_ts->pins_idle= pinctrl_lookup_state(zet6221_ts->pinctrl,"gpio");\r
5703         if(IS_ERR(zet6221_ts->pins_idle))\r
5704             printk("Warning : No IDLE pinctrl matched!\n");\r
5705     \r
5706         zet6221_ts->pins_default = pinctrl_lookup_state(zet6221_ts->pinctrl,"default");\r
5707         if(IS_ERR(zet6221_ts->pins_default))\r
5708             printk("Warning : No default pinctrl matched!\n");\r
5709     \r
5710     }\r
5711  \r
5712     if(pinctrl_select_state(zet6221_ts->pinctrl, zet6221_ts->pins_idle) < 0)\r
5713         printk("Warning :  Idle pinctrl setting failed!\n");  \r
5714 \r
5715         printk("Idle pinctrl setting ok!\n");  \r
5716          */\r
5717 \r
5718         /*\r
5719                 GPIO0_A0/I2C0_SCL   TP_RST\r
5720                 GPIO0_A1/I2C0_SDA       TP_INT\r
5721                 #define TS_RST_GPIO             0\r
5722                 #define TS_INT_GPIO             1 \r
5723          */\r
5724         x_TS_INT_GPIO = of_get_named_gpio_flags(np, "irq_gpio_number", 0, (enum of_gpio_flags *)&irq_flags);\r
5725         x_TS_RST_GPIO = of_get_named_gpio_flags(np, "rst_gpio_number", 0, &rst_flags);\r
5726 \r
5727         //printk("TS_INT_GPIO:%d,TS_RST_GPIO:%d.\n",x_TS_INT_GPIO,x_TS_RST_GPIO);\r
5728 \r
5729         //gpio_free(x_TS_INT_GPIO);\r
5730         //gpio_free(x_TS_RST_GPIO);     \r
5731 \r
5732     if( gpio_request(x_TS_INT_GPIO,NULL) < 0)\r
5733                 printk("TS_INT_GPIO failed..\n");       \r
5734     if( gpio_request(x_TS_RST_GPIO,NULL) < 0)\r
5735                 printk("TS_RST_GPIO failed..\n");\r
5736 \r
5737 /*\r
5738         if (gpio_is_valid(TS_RST_GPIO)) {\r
5739                 ret = devm_gpio_request_one(&zet6221_ts->i2c_dev->dev,TS_RST_GPIO, GPIOF_OUT_INIT_HIGH, "zetxx rst pin");\r
5740                 if (ret != 0) {\r
5741                         dev_err(&zet6221_ts->i2c_dev->dev, "zetxx rst error\n");\r
5742                         return -EIO;\r
5743                 }\r
5744                 //msleep(100);\r
5745         } else {\r
5746                 dev_info(&zet6221_ts->i2c_dev->dev, "zetxx rst pin invalid\n");\r
5747         }\r
5748 */      \r
5749 \r
5750         ///------------------------------------------------///\r
5751         /// driver\r
5752         ///------------------------------------------------///\r
5753         client->driver = &zet622x_i2c_driver;//Éè±¸¸æËßÖ÷»úÒª×öµÄÊÂÇé\r
5754 \r
5755         ///------------------------------------------------///\r
5756         ///  init finger report work£¬Îª±¨µãÖÐ¶Ï´´½¨Ïß³Ì\r
5757         ///------------------------------------------------///\r
5758         INIT_WORK(&zet6221_ts->work1, zet622x_ts_work);\r
5759         zet6221_ts->ts_workqueue = create_singlethread_workqueue(dev_name(&client->dev));\r
5760         if (!zet6221_ts->ts_workqueue)\r
5761         {\r
5762                 printk("[ZET] : ts_workqueue ts_probe error ==========\n");\r
5763                 return ERR_WORK_QUEUE_INIT_FAIL;\r
5764         }\r
5765         \r
5766         ///-----------------------------------------------///\r
5767         ///   charger detect : write_cmd£¬Îª¶¨Ê±ÖÐ¶Ï´´½¨Ïß³Ì\r
5768         ///-----------------------------------------------///\r
5769         INIT_WORK(&zet6221_ts->work2, zet622x_charger_cmd_work);\r
5770         zet6221_ts->ts_workqueue1 = create_singlethread_workqueue(dev_name(&client->dev)); //  workqueue\r
5771         if (!zet6221_ts->ts_workqueue1)\r
5772         {\r
5773                 printk("ts_workqueue1 ts_probe error ==========\n");\r
5774                 return ERR_WORK_QUEUE1_INIT_FAIL;\r
5775         }\r
5776 \r
5777 \r
5778         ///-----------------------------------------------///\r
5779         /// touch input device regist£¬½«ÎÒÃÇµÄÉè±¸×¢²áÎªÊäÈëÉè±¸\r
5780         ///-----------------------------------------------///\r
5781         input_dev = input_allocate_device();\r
5782         if (!input_dev || !zet6221_ts)\r
5783         {\r
5784                 result = -ENOMEM;\r
5785                 goto LABEL_DEVICE_ALLOC_FAIL;\r
5786         }\r
5787         \r
5788         i2c_set_clientdata(client, zet6221_ts);\r
5789 \r
5790         input_dev->name       = MJ5_TS_NAME;\r
5791         /// input_dev->phys       = "input/ts";\r
5792         input_dev->phys = "zet6221_touch/input0";\r
5793         input_dev->id.bustype = BUS_HOST;\r
5794         input_dev->id.vendor  = 0x0001;\r
5795         input_dev->id.product = 0x0002;\r
5796         input_dev->id.version = 0x0100;\r
5797 \r
5798         ic_model = MODEL_ZET6251; ///< Set the default model name\r
5799 \r
5800         ///-----------------------------------------------///\r
5801         /// Set the default firmware bin file name & mutual dev file name\r
5802         ///-----------------------------------------------///\r
5803         zet_dv_set_file_name(DRIVER_VERSION);\r
5804         zet_fw_set_file_name(FW_FILE_NAME);//.binÎÄ¼þÃû\r
5805         zet_tran_type_set_file_name(TRAN_MODE_FILE_PATH);//Ä£¿éÂ·¾¶\r
5806 \r
5807 \r
5808         ///------------------------------------------------///\r
5809         /// init the memory\r
5810         ///------------------------------------------------///\r
5811         zet_mem_init();\r
5812         \r
5813 #ifdef FEATURE_FW_UPGRADE\r
5814         ///-----------------------------------------------///\r
5815         ///   Do firmware downloader£¬ÏÂÔØ²Ù×÷\r
5816         ///-----------------------------------------------///\r
5817         if(zet622x_downloader(client,firmware_upgrade,&rom_type,ic_model) <= 0)\r
5818         {\r
5819                 goto LABEL_DOWNLOAD_FAIL;       \r
5820         }\r
5821 #endif  ///< for FEATURE_FW_UPGRADE\r
5822         ///-----------------------------------------------///\r
5823         /// wakeup pin for reset        \r
5824         ///-----------------------------------------------///\r
5825         ctp_wakeup2(5);\r
5826 \r
5827 #ifdef FEATURE_TPINFO \r
5828         ///-----------------------------------------------///\r
5829         /// B2 Command : read tp information\r
5830         ///-----------------------------------------------///\r
5831         if(zet622x_ts_get_information(client) <= 0)\r
5832         {\r
5833                 return err;\r
5834         }\r
5835         \r
5836 #else ///< for FEATURE_TPINFO\r
5837         ///-----------------------------------------------///   \r
5838         /// set the TP information not by B2\r
5839         ///-----------------------------------------------///\r
5840         resolution_x = X_MAX;\r
5841         resolution_y = Y_MAX;\r
5842         \r
5843         finger_num   = FINGER_NUMBER;\r
5844         key_num      = KEY_NUMBER;   \r
5845         if(key_num == 0)\r
5846         {\r
5847                 finger_packet_size  = 3 + 4*finger_num;\r
5848         }\r
5849         else\r
5850         {\r
5851                 finger_packet_size  = 3 + 4*finger_num + 1;\r
5852         }\r
5853 #endif ///< for FEATURE_TPINFO\r
5854         sprintf(name, "%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X", \r
5855                        pcode[0], pcode[1], pcode[2], pcode[3], \r
5856                        pcode[4], pcode[5], pcode[6], pcode[7] );\r
5857         zet_fw_set_pcode_name(name);\r
5858         \r
5859         //printk( "[ZET] : resolution= (%d x %d ), finger_num=%d, key_num=%d\n",resolution_x,resolution_y,finger_num,key_num);\r
5860 \r
5861         __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);//¿ÉÒÔÈ¡´úIDCÎÄ¼þ      \r
5862 \r
5863 #ifdef FEATURE_MT_TYPE_B\r
5864         ///-----------------------------------------------///   \r
5865         /// set type B finger number\r
5866         ///-----------------------------------------------///\r
5867         input_mt_init_slots(input_dev, finger_num,0);   \r
5868 #endif ///< for FEATURE_MT_TYPE_B\r
5869         \r
5870         set_bit(ABS_MT_TOUCH_MAJOR, input_dev->absbit); //×¢²á±¨µãÐÅÏ¢\r
5871         set_bit(ABS_MT_POSITION_X,  input_dev->absbit); \r
5872         set_bit(ABS_MT_POSITION_Y,  input_dev->absbit); \r
5873         set_bit(ABS_MT_WIDTH_MAJOR, input_dev->absbit); \r
5874         input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, P_MAX, 0, 0);\r
5875 \r
5876 \r
5877         ///------------------------------------------///\r
5878         /// Set virtual key\r
5879         ///------------------------------------------///\r
5880 #ifdef FEATURE_VIRTUAL_KEY\r
5881         input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, TP_AA_X_MAX, 0, 0);\r
5882         input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, TP_AA_Y_MAX, 0, 0);\r
5883 #else ///< for FEATURE_VIRTUAL_KEY\r
5884         input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, resolution_x, 0, 0);\r
5885         input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, resolution_y, 0, 0);\r
5886 #endif ///< for FEATURE_VIRTUAL_KEY\r
5887 \r
5888         set_bit(KEY_BACK, input_dev->keybit);\r
5889         set_bit(KEY_MENU, input_dev->keybit);\r
5890         set_bit(KEY_HOME, input_dev->keybit);\r
5891         set_bit(KEY_SEARCH, input_dev->keybit);\r
5892 \r
5893         input_dev->evbit[0] = BIT(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);\r
5894 \r
5895         result = input_register_device(input_dev);//ÔÚ´Ë½«Éè±¸ÐÅÏ¢×¢²áÎªÊäÈë\r
5896         if(result)\r
5897         {\r
5898                 goto LABEL_DEV_REGISTER_FAIL;\r
5899         }\r
5900 \r
5901         ///------------------------------------------///\r
5902         /// Config early_suspend\r
5903         ///------------------------------------------///\r
5904         printk("==register_early_suspend =\n");\r
5905 /*\r
5906         zet6221_ts->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 5;//ÐÝÃßµÈ¼¶\r
5907         zet6221_ts->early_suspend.suspend = zet622x_ts_early_suspend;//ÐÝÃß\r
5908         zet6221_ts->early_suspend.resume = zet622x_ts_late_resume;//»½ÐÑ\r
5909         register_early_suspend(&zet6221_ts->early_suspend);//×¢²áÐÝÃß£¬»½ÐÑ\r
5910 */\r
5911 \r
5912         //zet6221_ts->tp.tp_resume = zet622x_ts_late_resume;\r
5913         //zet6221_ts->tp.tp_suspend = zet622x_ts_early_suspend;\r
5914     //tp_register_fb(&zet6221_ts->tp);\r
5915         fb_register_client(&zet622x_ts_fb_notifier);\r
5916 \r
5917 \r
5918         zet6221_ts->input = input_dev;//ÊäÈëÉè±¸\r
5919 \r
5920         input_set_drvdata(zet6221_ts->input, zet6221_ts);\r
5921 \r
5922         ///------------------------------------------///\r
5923         /// Set charger mode timer//½¨Á¢¶¨Ê±Æ÷ÖÐ¶Ï\r
5924         ///------------------------------------------///\r
5925         setup_timer(&zet6221_ts->zet622x_ts_timer_task, zet622x_ts_timer_task, (unsigned long)zet6221_ts);\r
5926         mod_timer(&zet6221_ts->zet622x_ts_timer_task, jiffies + msecs_to_jiffies(800));\r
5927 \r
5928         ///-----------------------------------------------///\r
5929         /// Try to Get GPIO to see whether it is allocated to other drivers\r
5930         ///-----------------------------------------------///\r
5931         //printk( "[ZET]: ------request GPIO start------\n");\r
5932 /*      \r
5933         result = gpio_request(zet6221_ts->gpio, "GPN"); //ÉêÇëÒ»¸öIO¿ÚÎªÏÂÃæµÄINTÓÃ\r
5934         if (result)\r
5935         {\r
5936                 printk( "[ZET]: ------request GPIO failed------\n");\r
5937                 goto LABEL_DEVICE_ALLOC_FAIL;\r
5938         }\r
5939 \r
5940         if (gpio_is_valid(zet6221_ts->gpio)) {\r
5941                 ret = devm_gpio_request_one(&zet6221_ts->i2c_dev->dev, zet6221_ts->gpio, GPIOF_OUT_INIT_LOW, "zetxx power pin");\r
5942                 if (ret != 0) {\r
5943                         dev_err(&zet6221_ts->i2c_dev->dev, "zetxx power error\n");\r
5944                         return -EIO;\r
5945                 }\r
5946                 //msleep(100);\r
5947         } else {\r
5948                 dev_info(&zet6221_ts->i2c_dev->dev, "zetxx pin invalid\n");\r
5949         }\r
5950 */\r
5951 \r
5952 \r
5953         \r
5954 \r
5955         ///-----------------------------------------------///\r
5956         /// Set IRQ corresponding to GPIO\r
5957         ///-----------------------------------------------///\r
5958         zet6221_ts->irq = gpio_to_irq(zet6221_ts->gpio);//ÉêÇëINTÖÐ¶Ï\r
5959         //printk( "[ZET]: zet6221_ts_probe.gpid_to_irq [zet6221_ts->irq=%d]\n", zet6221_ts->irq);\r
5960         \r
5961 \r
5962 #ifdef FEATURE_INT_FREE\r
5963         ///------------------------------------------///\r
5964         /// Set polling timer\r
5965         ///------------------------------------------///\r
5966         setup_timer(&zet6221_ts->zet622x_ts_timer_task1, zet622x_ts_polling_task, (unsigned long)zet6221_ts);\r
5967         mod_timer(&zet6221_ts->zet622x_ts_timer_task1, jiffies + msecs_to_jiffies(INT_FREE_TIMER));\r
5968 \r
5969 #else ///< for FEATURE_INT_FREE\r
5970         ///--------------------------------------------///\r
5971         /// set the finger report interrupt (INT = low)£¬ÅäÖÃÖÐ¶Ï´¥·¢ÀàÐÍ\r
5972         ///--------------------------------------------///\r
5973         err = request_irq(zet6221_ts->irq, zet622x_ts_interrupt, \r
5974                                 (IRQF_TRIGGER_FALLING | IRQF_SHARED), ZET_TS_ID_NAME, zet6221_ts);\r
5975 \r
5976         if(err < 0)\r
5977         {\r
5978                 printk( "[ZET]:zet622x_ts_probe.request_irq failed. err=%d\n",err);\r
5979                 goto LABEL_IRQ_REQUEST_FAIL;\r
5980         }\r
5981         disable_irq(zet6221_ts->irq);\r
5982         mdelay(100);\r
5983         enable_irq(zet6221_ts->irq);\r
5984         \r
5985 #endif ///< for FEATURE_INT_FREE\r
5986 \r
5987 #ifdef FEATURE_FRAM_RATE\r
5988         ///------------------------------------------///\r
5989         /// Set fram rate timer\r
5990         ///------------------------------------------///\r
5991         setup_timer(&zet6221_ts->zet622x_ts_timer_task2, zet622x_ts_fram_rate_task, (unsigned long)zet6221_ts);\r
5992         mod_timer(&zet6221_ts->zet622x_ts_timer_task2, jiffies + msecs_to_jiffies(FRAM_RATE_TIMER));\r
5993 #endif ///< for FEATURE_FRAM_RATE\r
5994 \r
5995         ///--------------------------------------------///\r
5996         /// Get a free i2c dev\r
5997         ///--------------------------------------------///\r
5998         i2c_dev = zet622x_i2c_get_free_dev(client->adapter);//»ñÈ¡¿ÕÏÐIIC       \r
5999         if(IS_ERR(i2c_dev))\r
6000         {       \r
6001                 err = PTR_ERR(i2c_dev);         \r
6002                 return err;     \r
6003         }\r
6004         dev = device_create(i2c_dev_class, &client->adapter->dev, \r
6005                                 MKDEV(I2C_MAJOR,client->adapter->nr), NULL, "zet62xx_ts%d", client->adapter->nr);       \r
6006         if(IS_ERR(dev))\r
6007         {               \r
6008                 err = PTR_ERR(dev);             \r
6009                 return err;     \r
6010         }\r
6011         printk("[ZET] : zet62xx probe ok........");\r
6012         zet62xx_ts = zet6221_ts;\r
6013 \r
6014         return 0;\r
6015 \r
6016         free_irq(zet6221_ts->irq, zet6221_ts);\r
6017         input_unregister_device(input_dev);\r
6018 LABEL_DEV_REGISTER_FAIL:\r
6019 LABEL_DEVICE_ALLOC_FAIL:\r
6020         input_free_device(input_dev);\r
6021         input_dev = NULL;\r
6022         kfree(zet6221_ts);\r
6023         return result;\r
6024 \r
6025 #ifdef FEATURE_FW_UPGRADE\r
6026 LABEL_DOWNLOAD_FAIL:\r
6027 #endif ///< for FEATURE_FW_UPGRADE\r
6028 #ifndef FEATURE_INT_FREE\r
6029 LABEL_IRQ_REQUEST_FAIL:\r
6030 #endif ///< for FEATURE_INT_FREE\r
6031         input_free_device(input_dev);\r
6032         printk("==singlethread error =\n");\r
6033         fb_unregister_client(&zet622x_ts_fb_notifier);\r
6034         i2c_set_clientdata(client, NULL);\r
6035         kfree(zet6221_ts);\r
6036 //LABEL_GPIO_REQUEST_FAIL:\r
6037         return err;\r
6038 }\r
6039 \r
6040 \r
6041 \r
6042 ///************************************************************************\r
6043 ///   [function]:  zet622x_module_init\r
6044 ///   [parameters]:  void\r
6045 ///   [return]: int\r
6046 ///************************************************************************\r
6047 static int  zet622x_module_init(void)\r
6048 {\r
6049         int ret = -1;\r
6050 \r
6051         ///---------------------------------///\r
6052         /// Set file operations\r
6053         ///---------------------------------/// \r
6054         ret= register_chrdev(I2C_MAJOR, "zet_i2c_ts", &zet622x_ts_fops );\r
6055         if(ret)\r
6056         {       \r
6057                 printk(KERN_ERR "%s:register chrdev failed\n",__FILE__);        \r
6058                 return ret;\r
6059         }\r
6060 \r
6061         ///---------------------------------///\r
6062         /// Create device class\r
6063         ///---------------------------------///\r
6064         i2c_dev_class = class_create(THIS_MODULE,"zet_i2c_dev");//´´½¨Éè±¸Ä£¿é\r
6065         if(IS_ERR(i2c_dev_class))\r
6066         {               \r
6067                 ret = PTR_ERR(i2c_dev_class);           \r
6068                 class_destroy(i2c_dev_class);   \r
6069         }\r
6070 \r
6071         ///---------------------------------///\r
6072         /// Add the zet622x_ts to i2c drivers\r
6073         ///---------------------------------///\r
6074         i2c_add_driver(&zet622x_i2c_driver);//Çý¶¯×¢²á\r
6075         \r
6076         return ret;\r
6077 }\r
6078 \r
6079 \r
6080 ///***********************************************************************\r
6081 ///   [function]:  ts exit\r
6082 ///   [parameters]:\r
6083 ///   [return]:\r
6084 ///***********************************************************************\r
6085 static void __exit zet622x_module_exit(void)\r
6086 {\r
6087         i2c_del_driver(&zet622x_i2c_driver);//ÍË³öÐ¶ÔØÇý¶¯\r
6088         if (resume_download_task != NULL)\r
6089         {\r
6090                 kthread_stop(resume_download_task);\r
6091         }\r
6092 }\r
6093 \r
6094 module_init(zet622x_module_init);\r
6095 module_exit(zet622x_module_exit);\r
6096 MODULE_DESCRIPTION("ZET6221 I2C Touch Screen driver");\r
6097 MODULE_LICENSE("GPL v2");\r