drivers/input/touchscreen/imagis_30xxc/ist30xxc_update.c

   1 /*
   2  *  Copyright (C) 2010,Imagis Technology Co. Ltd. All Rights Reserved.
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; either version 2 of the License, or
   7  *  (at your option) any later version.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  *
  14  */
  15
  16 #include <linux/i2c.h>
  17 #include <linux/delay.h>
  18 #include <linux/slab.h>
  19 #include <linux/firmware.h>
  20 #include <linux/stat.h>
  21 #include <asm/unaligned.h>
  22 #include <linux/uaccess.h>
  23 #include <linux/fcntl.h>
  24 #include <linux/file.h>
  25 #include <linux/fs.h>
  26 #include <linux/err.h>
  27
  28 #include <linux/i2c/ist30xxc.h>
  29 #include "ist30xxc_update.h"
  30 #include "ist30xxc_tracking.h"
  31
  32 #if IST30XX_INTERNAL_BIN
  33 #if defined(CONFIG_SEC_NOVEL_PROJECT)
  34 #include "ist3026c_novel_fw_BOE.h"
  35 #include "ist3026c_novel_fw_CNI.h"
  36 #else
  37 static unsigned char ist30xxc_fw[] = {0};
  38 #endif
  39 #endif  // IST30XX_INTERNAL_BIN
  40
  41 #define TAGS_PARSE_OK           (0)
  42
  43 // ISP burst r/w
  44 int ist30xx_isp_read_burst(struct i2c_client *client, u32 addr,
  45                         u32 *buf32, u16 len)
  46 {
  47         int ret = 0;
  48         int i;
  49         u16 max_len = I2C_MAX_READ_SIZE / IST30XX_DATA_LEN;
  50     u16 remain_len = len;
  51
  52         for (i = 0; i < len; i += max_len) {
  53                 if (remain_len < max_len) max_len = remain_len;
  54                 ret = ist30xx_read_buf(client, addr, buf32, max_len);
  55                 if (unlikely(ret)) {
  56                         tsp_err("Burst fail, addr: %x\n", __func__, addr);
  57                         return ret;
  58                 }
  59
  60                 buf32 += max_len;
  61         remain_len -= max_len;
  62         }
  63
  64         return 0;
  65 }
  66
  67 int ist30xx_isp_write_burst(struct i2c_client *client, u32 addr,
  68                         u32 *buf32, u16 len)
  69 {
  70         int ret = 0;
  71         int i;
  72         u16 max_len = I2C_MAX_WRITE_SIZE / IST30XX_DATA_LEN;
  73     u16 remain_len = len;
  74
  75         for (i = 0; i < len; i += max_len) {
  76                 if (remain_len < max_len) max_len = remain_len;
  77                 ret = ist30xx_write_buf(client, addr, buf32, max_len);
  78                 if (unlikely(ret)) {
  79                         tsp_err("Burst fail, addr: %x\n", addr);
  80                         return ret;
  81                 }
  82
  83                 buf32 += max_len;
  84         remain_len -= max_len;
  85         }
  86
  87         return 0;
  88 }
  89
  90 #define IST30XX_ISP_READ_TOTAL_S    (0x01)
  91 #define IST30XX_ISP_READ_TOTAL_B    (0x11)
  92 #define IST30XX_ISP_READ_MAIN_S     (0x02)
  93 #define IST30XX_ISP_READ_MAIN_B     (0x12)
  94 #define IST30XX_ISP_READ_INFO_S     (0x03)
  95 #define IST30XX_ISP_READ_INFO_B     (0x13)
  96 #define IST30XX_ISP_PROG_TOTAL_S    (0x04)
  97 #define IST30XX_ISP_PROG_TOTAL_B    (0x14)
  98 #define IST30XX_ISP_PROG_MAIN_S     (0x05)
  99 #define IST30XX_ISP_PROG_MAIN_B     (0x15)
 100 #define IST30XX_ISP_PROG_INFO_S     (0x06)
 101 #define IST30XX_ISP_PROG_INFO_B     (0x16)
 102 #define IST30XX_ISP_ERASE_BLOCK     (0x07)
 103 #define IST30XX_ISP_ERASE_SECTOR    (0x08)
 104 #define IST30XX_ISP_ERASE_PAGE      (0x09)
 105 #define IST30XX_ISP_ERASE_INFO      (0x0A)
 106 #define IST30XX_ISP_READ_TOTAL_CRC  (0x1B)
 107 #define IST30XX_ISP_READ_MAIN_CRC   (0x1C)
 108 #define IST30XX_ISP_READ_INFO_CRC   (0x1D)
 109 int ist30xxc_isp_enable(struct i2c_client *client, bool enable)
 110 {
 111         int ret = 0;
 112
 113     if (enable) {
 114         ret = ist30xx_write_cmd(client, IST30XX_FLASH_ISPEN, 0xDE01);
 115         if (unlikely(ret))
 116                         return ret;
 117
 118 #if (IMAGIS_TSP_IC < IMAGIS_IST3038C)
 119         ret = ist30xx_write_cmd(client, IST30XX_FLASH_MODE, 0x4100);
 120         if (unlikely(ret))
 121                         return ret;
 122
 123         ret = ist30xx_write_cmd(client, IST30XX_FLASH_TEST_MODE1, 0x38);
 124         if (unlikely(ret))
 125                         return ret;
 126 #endif
 127         } else {
 128                 ret = ist30xx_write_cmd(client, IST30XX_FLASH_ISPEN, 0x2);
 129                 if (unlikely(ret))
 130                         return ret;
 131         }
 132
 133     msleep(1);
 134
 135         return ret;
 136 }
 137
 138 int ist30xxc_isp_mode(struct i2c_client *client, int mode)
 139 {
 140         int ret = 0;
 141         u32 val = 0;
 142
 143         switch (mode) {
 144         case IST30XX_ISP_READ_TOTAL_S:
 145                 val = 0x8090;
 146                 break;
 147     case IST30XX_ISP_READ_TOTAL_B:
 148     case IST30XX_ISP_READ_TOTAL_CRC:
 149                 val = 0x8190;
 150                 break;
 151         case IST30XX_ISP_READ_MAIN_S:
 152                 val = 0x0090;
 153                 break;
 154     case IST30XX_ISP_READ_MAIN_B:
 155     case IST30XX_ISP_READ_MAIN_CRC:
 156                 val = 0x0190;
 157                 break;
 158         case IST30XX_ISP_READ_INFO_S:
 159                 val = 0x0098;
 160                 break;
 161         case IST30XX_ISP_READ_INFO_B:
 162     case IST30XX_ISP_READ_INFO_CRC:
 163                 val = 0x0198;
 164                 break;
 165         case IST30XX_ISP_PROG_TOTAL_S:
 166                 val = 0x8050;
 167                 break;
 168         case IST30XX_ISP_PROG_TOTAL_B:
 169                 val = 0x8150;
 170                 break;
 171         case IST30XX_ISP_PROG_MAIN_S:
 172                 val = 0x0050;
 173                 break;
 174         case IST30XX_ISP_PROG_MAIN_B:
 175                 val = 0x0150;
 176                 break;
 177         case IST30XX_ISP_PROG_INFO_S:
 178                 val = 0x0058;
 179                 break;
 180         case IST30XX_ISP_PROG_INFO_B:
 181                 val = 0x0158;
 182                 break;
 183         case IST30XX_ISP_ERASE_BLOCK:
 184                 val = 0x0031;
 185                 break;
 186         case IST30XX_ISP_ERASE_SECTOR:
 187                 val = 0x0032;
 188                 break;
 189         case IST30XX_ISP_ERASE_PAGE:
 190                 val = 0x0030;
 191                 break;
 192     case IST30XX_ISP_ERASE_INFO:
 193                 val = 0x0038;
 194                 break;
 195         default:
 196                 tsp_err("ISP fail, unknown mode\n");
 197                 return -EINVAL;
 198         }
 199
 200 #if (IMAGIS_TSP_IC > IMAGIS_IST3032C)
 201         val &= ~(0x8000);
 202 #endif
 203
 204         ret = ist30xx_write_cmd(client, IST30XX_FLASH_MODE, val);
 205         if (unlikely(ret)) {
 206                 tsp_err("ISP fail, IST30XX_FLASH_MODE\n");
 207                 return ret;
 208         }
 209
 210         return 0;
 211 }
 212
 213 int ist30xxc_isp_erase(struct i2c_client *client, int mode, u32 index)
 214 {
 215         int ret = 0;
 216
 217         tsp_info("%s\n", __func__);
 218
 219         ret = ist30xxc_isp_mode(client, mode);
 220         if (unlikely(ret))
 221                 return ret;
 222
 223         ret = ist30xx_write_cmd(client, IST30XX_FLASH_DIN, index);
 224         if (unlikely(ret)) {
 225                 tsp_err("ISP fail, IST30XX_FLASH_DIN\n");
 226                 return ret;
 227         }
 228
 229         msleep(50); // Flash erase time : Mininum 40msec
 230
 231         return ret;
 232 }
 233
 234
 235 int ist30xxc_isp_program(struct i2c_client *client, u32 addr, int mode,
 236                         const u32 *buf32, int len)
 237 {
 238         int ret = 0;
 239
 240         tsp_info("%s\n", __func__);
 241
 242         ret = ist30xxc_isp_mode(client, mode);
 243         if (unlikely(ret))
 244                 return ret;
 245
 246         ret = ist30xx_write_cmd(client, IST30XX_FLASH_ADDR, addr);
 247         if (unlikely(ret)) {
 248                 tsp_err("ISP fail, IST30XX_FLASH_ADDR\n");
 249                 return ret;
 250         }
 251
 252         if (mode & 0x10)
 253                 ret = ist30xx_isp_write_burst(client,
 254                         IST30XX_FLASH_DIN, (u32 *)buf32, len);
 255         else
 256                 ret = ist30xx_write_buf(client, IST30XX_FLASH_DIN, (u32 *)buf32, len);
 257
 258         if (unlikely(ret)) {
 259                 tsp_err("ISP fail, IST30XX_FLASH_DIN\n");
 260                 return ret;
 261         }
 262
 263         return ret;
 264 }
 265
 266 int ist30xxc_isp_read(struct i2c_client *client, u32 addr, int mode,
 267                         u32 *buf32, int len)
 268 {
 269         int ret = 0;
 270
 271         /* IST30xxB ISP read mode */
 272         ret = ist30xxc_isp_mode(client, mode);
 273         if (unlikely(ret))
 274                 return ret;
 275
 276         ret = ist30xx_write_cmd(client, IST30XX_FLASH_ADDR, addr);
 277         if (unlikely(ret)) {
 278                 tsp_err("ISP fail, IST30XX_FLASH_ADDR\n");
 279                 return ret;
 280         }
 281
 282         if (mode & 0x10)
 283                 ret = ist30xx_isp_read_burst(client, IST30XX_FLASH_DOUT, buf32, len);
 284         else
 285                 ret = ist30xx_read_buf(client, IST30XX_FLASH_DOUT, buf32, len);
 286
 287         if (unlikely(ret)) {
 288                 tsp_err("ISP fail, IST30XX_FLASH_DOUT\n");
 289                 return ret;
 290         }
 291
 292         return 0;
 293 }
 294
 295 int ist30xxc_cmd_read_chksum(struct i2c_client *client, int mode,
 296                                 u32 start_addr, u32 end_addr, u32 *chksum)
 297 {
 298         int ret = 0;
 299         u32 val = (1 << 28) | (1 << 25) | (1 << 24) | (1 << 20) | (1 << 16);
 300
 301         val |= (end_addr / IST30XX_ADDR_LEN) - 1;
 302
 303         ret = ist30xxc_isp_mode(client, mode);
 304         if (unlikely(ret))
 305                 return ret;
 306
 307         ret = ist30xx_write_cmd(client, IST30XX_FLASH_ADDR, start_addr);
 308         if (unlikely(ret)) {
 309                 tsp_err("ISP fail, IST30XX_FLASH_ADDR (%x)\n", val);
 310                 return ret;
 311         }
 312
 313         ret = ist30xx_write_cmd(client, IST30XX_FLASH_AUTO_READ, val);
 314         if (unlikely(ret)) {
 315                 tsp_err("ISP fail, IST30XX_FLASH_AUTO_READ (%x)\n", val);
 316                 return ret;
 317         }
 318
 319         msleep(100);
 320
 321         ret = ist30xx_read_reg(client, IST30XX_FLASH_CRC, chksum);
 322         if (unlikely(ret)) {
 323                 tsp_err("ISP fail, IST30XX_FLASH_CRC (%x)\n", chksum);
 324                 return ret;
 325         }
 326
 327         return 0;
 328 }
 329
 330 int ist30xxc_read_chksum(struct ist30xx_data *data, u32 *chksum)
 331 {
 332         int ret = 0;
 333         u32 start_addr, end_addr;
 334
 335         start_addr = data->tags.fw_addr;
 336         end_addr = data->tags.sensor_addr + data->tags.sensor_size;
 337         ret = ist30xxc_cmd_read_chksum(data->client,
 338                 IST30XX_ISP_READ_TOTAL_CRC, start_addr, end_addr, chksum);
 339         if (unlikely(ret))
 340                 return ret;
 341
 342         tsp_info("chksum: %x(%x~%x)\n", *chksum, start_addr, end_addr);
 343
 344         return 0;
 345 }
 346
 347 int ist30xxc_read_chksum_all(struct i2c_client *client, u32 *chksum)
 348 {
 349         int ret = 0;
 350         u32 start_addr, end_addr;
 351
 352         start_addr = IST30XX_FLASH_BASE_ADDR;
 353         end_addr = IST30XX_FLASH_BASE_ADDR + IST30XX_FLASH_TOTAL_SIZE;
 354         ret = ist30xxc_cmd_read_chksum(client,
 355                 IST30XX_ISP_READ_TOTAL_CRC, start_addr, end_addr, chksum);
 356         if (unlikely(ret))
 357                 return ret;
 358
 359         tsp_info("chksum: %x(%x~%x)\n", *chksum, start_addr, end_addr);
 360
 361         return 0;
 362 }
 363
 364 int ist30xxc_isp_info_read(struct ist30xx_data *data, u32 addr, u32 *buf32, u32 len)
 365 {
 366         int ret = 0;
 367         int retry = IST30XX_MAX_RETRY_CNT;
 368
 369 isp_info_read_retry:
 370         if (retry-- == 0)
 371                  goto isp_info_read_end;
 372
 373         ist30xx_reset(data, true);
 374
 375         /* IST30xxB ISP enable */
 376         ret = ist30xxc_isp_enable(data->client, true);
 377         if (unlikely(ret))
 378                  goto isp_info_read_retry;
 379
 380         ret = ist30xxc_isp_read(data->client, addr, IST30XX_ISP_READ_INFO_B,
 381                 buf32, len);
 382         if (unlikely(ret))
 383                  goto isp_info_read_retry;
 384
 385 isp_info_read_end:
 386         /* IST30xxC ISP disable */
 387         ist30xxc_isp_enable(data->client, false);
 388         ist30xx_reset(data, false);
 389         return ret;
 390 }
 391
 392 int ist30xxc_isp_fw_read(struct ist30xx_data *data, u32 *buf32)
 393 {
 394         int ret = 0;
 395         int i;
 396         int len;
 397         u32 addr = IST30XX_FLASH_BASE_ADDR;
 398
 399         ist30xx_reset(data, true);
 400
 401         /* IST30xxB ISP enable */
 402         ret = ist30xxc_isp_enable(data->client, true);
 403         if (unlikely(ret))
 404                 return ret;
 405
 406 #if I2C_BURST_MODE
 407         for (i = 0; i < IST30XX_FLASH_TOTAL_SIZE; i += I2C_MAX_READ_SIZE) {
 408                 len = I2C_MAX_READ_SIZE / IST30XX_DATA_LEN;
 409                 if ((IST30XX_FLASH_TOTAL_SIZE - i) < I2C_MAX_READ_SIZE)
 410                         len = (IST30XX_FLASH_TOTAL_SIZE - i) / IST30XX_DATA_LEN;
 411
 412                 ret = ist30xxc_isp_read(data->client, addr, IST30XX_ISP_READ_TOTAL_B,
 413                         buf32, len);
 414                 if (unlikely(ret))
 415                         goto isp_fw_read_end;
 416
 417                 addr += len;
 418                 buf32 += len;
 419         }
 420 #else
 421         for (i = 0; i < IST30XX_FLASH_MAIN_SIZE; i += IST30XX_DATA_LEN) {
 422                 ret = ist30xxc_isp_read(data->client, addr, IST30XX_ISP_READ_TOTAL_S,
 423                         buf32, 1);
 424                 if (unlikely(ret))
 425                         goto isp_fw_read_end;
 426
 427                 addr++;
 428                 buf32++;
 429         }
 430 #endif
 431 isp_fw_read_end:
 432         /* IST30xxC ISP disable */
 433         ist30xxc_isp_enable(data->client, false);
 434         ist30xx_reset(data, false);
 435         return ret;
 436 }
 437
 438 int ist30xxc_isp_fw_update(struct ist30xx_data *data, const u8 *buf)
 439 {
 440 #if !(I2C_BURST_MODE)
 441         int i;
 442 #endif
 443         int ret = 0;
 444         u32 addr = IST30XX_FLASH_BASE_ADDR;
 445
 446         tsp_info("%s\n", __func__);
 447
 448         ist30xx_reset(data, true);
 449
 450         /* IST30xxC ISP enable */
 451         ret = ist30xxc_isp_enable(data->client, true);
 452         if (unlikely(ret))
 453                 goto isp_fw_update_end;
 454
 455         /* IST30xxC ISP erase */
 456         ret = ist30xxc_isp_erase(data->client, IST30XX_ISP_ERASE_BLOCK, 0);
 457         if (unlikely(ret))
 458                 goto isp_fw_update_end;
 459
 460 #if (IST30XX_FLASH_INFO_SIZE > 0)
 461         ret = ist30xxc_isp_erase(data->client, IST30XX_ISP_ERASE_INFO, 0);
 462         if (unlikely(ret))
 463                 goto isp_fw_update_end;
 464 #endif
 465
 466         ist30xx_reset(data, true);
 467
 468         /* IST30xxC ISP enable */
 469         ret = ist30xxc_isp_enable(data->client, true);
 470         if (unlikely(ret))
 471                 goto isp_fw_update_end;
 472
 473 #if I2C_BURST_MODE
 474         /* IST30xxC ISP write burst */
 475 #if 0
 476         for (i = 0; i < IST30XX_FLASH_TOTAL_SIZE / IST30XX_FLASH_PAGE_SIZE; i++) {
 477                 ret = ist30xxc_isp_program(data->client, addr,
 478                         IST30XX_ISP_PROG_TOTAL_B, (u32 *)buf,
 479                         IST30XX_FLASH_PAGE_SIZE / IST30XX_DATA_LEN);
 480                 if (unlikely(ret))
 481                         goto isp_fw_update_end;
 482
 483                 addr += IST30XX_FLASH_PAGE_SIZE / IST30XX_DATA_LEN;
 484                 buf += IST30XX_FLASH_PAGE_SIZE;
 485         }
 486 #else
 487         ret = ist30xxc_isp_program(data->client, addr, IST30XX_ISP_PROG_TOTAL_B,
 488                 (u32 *)buf, IST30XX_FLASH_TOTAL_SIZE / IST30XX_DATA_LEN);
 489         if (unlikely(ret))
 490                 goto isp_fw_update_end;
 491 #endif
 492 #else
 493         /* IST30xxC ISP write single */
 494         for (i = 0; i < IST30XX_FLASH_TOTAL_SIZE; i += IST30XX_DATA_LEN) {
 495                 ret = ist30xxc_isp_program(data->client, addr,
 496                         IST30XX_ISP_PROG_TOTAL_S, (u32 *)buf, 1);
 497                 if (unlikely(ret))
 498                         goto isp_fw_update_end;
 499
 500                 addr++;
 501                 buf += IST30XX_DATA_LEN;
 502         }
 503 #endif
 504
 505 isp_fw_update_end:
 506         /* IST30xxC ISP disable */
 507         ist30xxc_isp_enable(data->client, false);
 508         ist30xx_reset(data, false);
 509         return ret;
 510 }
 511
 512 u32 ist30xx_parse_ver(struct ist30xx_data *data, int flag, const u8 *buf)
 513 {
 514         u32 ver = 0;
 515         u32 *buf32 = (u32 *)buf;
 516
 517         if (flag == FLAG_MAIN)
 518                 ver = (u32)buf32[(data->tags.flag_addr + 0x1FC) >> 2];
 519         else if (flag == FLAG_TEST)
 520                 ver = (u32)buf32[(data->tags.flag_addr + 0x1F4) >> 2];
 521         else if (flag == FLAG_FW)
 522                 ver = (u32)(buf32[(data->tags.cfg_addr + 0x4) >> 2] & 0xFFFF);
 523         else if (flag == FLAG_CORE)
 524                 ver = (u32)buf32[(data->tags.flag_addr + 0x1F0) >> 2];
 525         else
 526                 tsp_warn("Parsing ver's flag is not corrent!\n");
 527
 528         return ver;
 529 }
 530
 531 int calib_ms_delay = CALIB_WAIT_TIME;
 532 int ist30xx_calib_wait(struct ist30xx_data *data)
 533 {
 534         int cnt = calib_ms_delay;
 535
 536         data->status.calib_msg = 0;
 537         while (cnt-- > 0) {
 538                 msleep(100);
 539
 540                 if (data->status.calib_msg) {
 541                         tsp_info("Calibration status : %d, Max raw gap : %d - (%08x)\n",
 542                                 CALIB_TO_STATUS(data->status.calib_msg),
 543                                 CALIB_TO_GAP(data->status.calib_msg),
 544                                 data->status.calib_msg);
 545                         if (CALIB_TO_STATUS(data->status.calib_msg) == 0)
 546                                 return 0;  // Calibrate success
 547                         else
 548                                 return -EAGAIN;
 549                 }
 550         }
 551         tsp_warn("Calibration time out\n");
 552
 553         return -EPERM;
 554 }
 555
 556 int ist30xx_calibrate(struct ist30xx_data *data, int wait_cnt)
 557 {
 558         int ret = -ENOEXEC;
 559
 560         tsp_info("*** Calibrate %ds ***\n", calib_ms_delay / 10);
 561
 562         data->status.update = 1;
 563         ist30xx_disable_irq(data);
 564         while (1) {
 565                 ret = ist30xx_cmd_calibrate(data->client);
 566                 if (unlikely(ret))
 567                         continue;
 568
 569                 ist30xx_enable_irq(data);
 570                 ret = ist30xx_calib_wait(data);
 571                 if (likely(!ret))
 572                         break;
 573
 574                 ist30xx_disable_irq(data);
 575
 576                 if (--wait_cnt == 0)
 577                         break;
 578
 579                 ist30xx_reset(data, false);
 580         }
 581
 582         ist30xx_disable_irq(data);
 583         ist30xx_reset(data, false);
 584         data->status.update = 2;
 585         ist30xx_enable_irq(data);
 586
 587         return ret;
 588 }
 589
 590
 591 int ist30xx_parse_tags(struct ist30xx_data *data, const u8 *buf, const u32 size)
 592 {
 593         int ret = -EPERM;
 594         struct ist30xx_tags *tags;
 595
 596         tags = (struct ist30xx_tags *)(&buf[size - sizeof(struct ist30xx_tags)]);
 597
 598         if (!strncmp(tags->magic1, IST30XX_TAG_MAGIC, sizeof(tags->magic1))
 599                 && !strncmp(tags->magic2, IST30XX_TAG_MAGIC, sizeof(tags->magic2))
 600                 ) {
 601                 data->tags = *tags;
 602
 603                 data->tags.fw_addr -= data->tags.rom_base;
 604                 data->tags.cfg_addr -= data->tags.rom_base;
 605                 data->tags.sensor_addr -= data->tags.rom_base;
 606                 data->tags.cp_addr -= data->tags.rom_base;
 607                 data->tags.flag_addr -= data->tags.rom_base;
 608
 609                 data->fw.index = data->tags.fw_addr;
 610                 data->fw.size = tags->flag_addr - tags->fw_addr +
 611                                 tags->flag_size;
 612                 data->fw.chksum = tags->chksum;
 613
 614                 tsp_verb("Tagts magic1: %s, magic2: %s\n",
 615                         data->tags.magic1, data->tags.magic2);
 616                 tsp_verb(" rom: %x\n", data->tags.rom_base);
 617                 tsp_verb(" ram: %x\n", data->tags.ram_base);
 618                 tsp_verb(" fw: %x(%x)\n", data->tags.fw_addr, data->tags.fw_size);
 619                 tsp_verb(" cfg: %x(%x)\n", data->tags.cfg_addr, data->tags.cfg_size);
 620                 tsp_verb(" sensor: %x(%x)\n",
 621                         data->tags.sensor_addr, data->tags.sensor_size);
 622                 tsp_verb(" cp: %x(%x)\n", data->tags.cp_addr, data->tags.cp_size);
 623                 tsp_verb(" flag: %x(%x)\n", data->tags.flag_addr, data->tags.flag_size);
 624                 tsp_verb(" zvalue: %x\n", data->tags.zvalue_base);
 625                 tsp_verb(" algo: %x\n", data->tags.algo_base);
 626                 tsp_verb(" raw: %x\n", data->tags.raw_base);
 627                 tsp_verb(" filter: %x\n", data->tags.filter_base);
 628                 tsp_verb(" chksum: %x\n", data->tags.chksum);
 629                 tsp_verb(" chksum_all: %x\n", data->tags.chksum_all);
 630                 tsp_verb(" build time: %04d/%02d/%02d (%02d:%02d:%02d)\n",
 631                         data->tags.year, data->tags.month, data->tags.day,
 632                         data->tags.hour, data->tags.min, data->tags.sec);
 633
 634                 ret = 0;
 635         }
 636
 637         return ret;
 638 }
 639
 640 int ist30xx_get_update_info(struct ist30xx_data *data, const u8 *buf,
 641                              const u32 size)
 642 {
 643         int ret;
 644
 645         ret = ist30xx_parse_tags(data, buf, size);
 646         if (unlikely(ret != TAGS_PARSE_OK))
 647                 tsp_warn("Cannot find tags of F/W, make a tags by 'tagts.exe'\n");
 648
 649     return ret;
 650 }
 651
 652 #define TSP_INFO_SWAP_XY    (1 << 0)
 653 #define TSP_INFO_FLIP_X     (1 << 1)
 654 #define TSP_INFO_FLIP_Y     (1 << 2)
 655 u32 ist30xx_info_cal_crc(u32 *buf)
 656 {
 657     int i;
 658     u32 chksum32 = 0;
 659
 660     for (i = 0; i < IST30XX_MAX_CMD_SIZE - 1; i++) {
 661         chksum32 += *buf++;
 662     }
 663
 664     return chksum32;
 665 }
 666
 667 int ist30xx_tsp_update_info(struct ist30xx_data *data)
 668 {
 669         int ret = 0;
 670         u32 chksum;
 671         u32 info[IST30XX_MAX_CMD_SIZE];
 672         u32 tsp_lcd, tsp_swap, tsp_scr, tsp_gtx, tsp_ch;
 673         u32 tkey_info0, tkey_info1, tkey_info2;
 674         u32 finger_info, baseline, threshold;
 675         TSP_INFO *tsp = &data->tsp_info;
 676 #if IST30XX_USE_KEY
 677         TKEY_INFO *tkey = &data->tkey_info;
 678 #endif
 679
 680         ret = ist30xx_cmd_hold(data, 1);
 681         if (unlikely(ret))
 682                 return ret;
 683
 684         ret = ist30xx_burst_read(data->client,
 685                 IST30XX_DA_ADDR(eHCOM_GET_CHIP_ID), &info[0],
 686                 IST30XX_MAX_CMD_SIZE, true);
 687         if (unlikely(ret))
 688                 return ret;
 689
 690         ret = ist30xx_cmd_hold(data, 0);
 691         if (unlikely(ret)) {
 692                 ist30xx_reset(data, false);
 693                 return ret;
 694         }
 695
 696         ret = ist30xx_read_cmd(data, IST30XX_REG_CHIPID, &data->chip_id);
 697         if (unlikely(ret))
 698                 return ret;
 699
 700         if ((info[IST30XX_CMD_VALUE(eHCOM_GET_CHIP_ID)] != data->chip_id) ||
 701                 (info[IST30XX_CMD_VALUE(eHCOM_GET_CHIP_ID)] == 0) ||
 702                 (info[IST30XX_CMD_VALUE(eHCOM_GET_CHIP_ID)] == 0xFFFF))
 703                 return -EINVAL;
 704
 705         chksum = ist30xx_info_cal_crc((u32*)info);
 706         if (chksum != info[IST30XX_MAX_CMD_SIZE - 1]) {
 707                 tsp_err("info checksum : %08X, %08X\n",
 708                         chksum, info[IST30XX_MAX_CMD_SIZE - 1]);
 709                 return -EINVAL;
 710         }
 711         tsp_info("info read success\n");
 712
 713         tsp_lcd = info[IST30XX_CMD_VALUE(eHCOM_GET_LCD_INFO)];
 714         tsp_ch = info[IST30XX_CMD_VALUE(eHCOM_GET_TSP_INFO)];
 715         tkey_info0 = info[IST30XX_CMD_VALUE(eHCOM_GET_KEY_INFO_0)];
 716         tkey_info1 = info[IST30XX_CMD_VALUE(eHCOM_GET_KEY_INFO_1)];
 717         tkey_info2 = info[IST30XX_CMD_VALUE(eHCOM_GET_KEY_INFO_2)];
 718         tsp_scr = info[IST30XX_CMD_VALUE(eHCOM_GET_SCR_INFO)];
 719         tsp_gtx = info[IST30XX_CMD_VALUE(eHCOM_GET_GTX_INFO)];
 720         tsp_swap = info[IST30XX_CMD_VALUE(eHCOM_GET_SWAP_INFO)];
 721         finger_info = info[IST30XX_CMD_VALUE(eHCOM_GET_FINGER_INFO)];
 722         baseline = info[IST30XX_CMD_VALUE(eHCOM_GET_BASELINE)];
 723         threshold = info[IST30XX_CMD_VALUE(eHCOM_GET_TOUCH_TH)];
 724
 725         tsp->ch_num.rx = (tsp_ch >> 16) & 0xFFFF;
 726         tsp->ch_num.tx = tsp_ch & 0xFFFF;
 727
 728         tsp->node.len = tsp->ch_num.tx * tsp->ch_num.rx;
 729
 730         tsp->gtx.num = (tsp_gtx >> 24) & 0xFF;
 731         tsp->gtx.ch_num[0] = (tsp_gtx >> 16) & 0xFF;
 732         tsp->gtx.ch_num[1] = (tsp_gtx >> 8) & 0xFF;
 733         tsp->gtx.ch_num[2] = 0xFF;
 734         tsp->gtx.ch_num[3] = 0xFF;
 735
 736         tsp->finger_num = finger_info;
 737         tsp->dir.swap_xy = (tsp_swap & TSP_INFO_SWAP_XY ? true : false);
 738         tsp->dir.flip_x = (tsp_swap & TSP_INFO_FLIP_X ? true : false);
 739         tsp->dir.flip_y = (tsp_swap & TSP_INFO_FLIP_Y ? true : false);
 740
 741         tsp->baseline = baseline & 0xFFFF;
 742
 743         tsp->screen.rx = (tsp_scr >> 16) & 0xFFFF;
 744         tsp->screen.tx = tsp_scr & 0xFFFF;
 745
 746         if (tsp->dir.swap_xy) {
 747                 tsp->width = tsp_lcd & 0xFFFF;
 748                 tsp->height = (tsp_lcd >> 16) & 0xFFFF;
 749         } else {
 750                 tsp->width = (tsp_lcd >> 16) & 0xFFFF;
 751                 tsp->height = tsp_lcd & 0xFFFF;
 752         }
 753
 754 #if IST30XX_USE_KEY
 755     tkey->enable = (((tkey_info0 >> 24) & 0xFF) ? true : false);
 756         tkey->key_num = (tkey_info0 >> 16) & 0xFF;
 757         tkey->ch_num[0].tx = tkey_info0 & 0xFF;
 758         tkey->ch_num[0].rx = (tkey_info0 >> 8) & 0xFF;
 759         tkey->ch_num[1].tx = (tkey_info1 >> 16) & 0xFF;
 760         tkey->ch_num[1].rx = (tkey_info1 >> 24) & 0xFF;
 761         tkey->ch_num[2].tx = tkey_info1 & 0xFF;
 762         tkey->ch_num[2].rx = (tkey_info1 >> 8) & 0xFF;
 763         tkey->ch_num[3].tx = (tkey_info2 >> 16) & 0xFF;
 764         tkey->ch_num[3].rx = (tkey_info2 >> 24) & 0xFF;
 765         tkey->ch_num[4].tx = tkey_info2 & 0xFF;
 766         tkey->ch_num[4].rx = (tkey_info2 >> 8) & 0xFF;
 767
 768     tkey->baseline = (baseline >> 16) & 0xFFFF;
 769 #endif
 770
 771     return ret;
 772 }
 773
 774 int ist30xx_get_tsp_info(struct ist30xx_data *data)
 775 {
 776         int ret = 0;
 777     int retry = 3;
 778 #if IST30XX_INTERNAL_BIN
 779     TSP_INFO *tsp = &data->tsp_info;
 780         const struct firmware *firmware = NULL;
 781         struct ist30xx_fw *fw = &data->fw;
 782 #if IST30XX_USE_KEY
 783         TKEY_INFO *tkey = &data->tkey_info;
 784 #endif
 785     u8 *cfg_buf;
 786 #endif
 787
 788         while (retry--) {
 789                 ret = ist30xx_tsp_update_info(data);
 790                 if (ret == 0) {
 791                         tsp_info("tsp update info success!\n");
 792                         return ret;
 793                 }
 794         }
 795
 796 #if IST30XX_INTERNAL_BIN
 797         if (data->dt_data->fw_bin) {
 798                 ret = request_firmware(&firmware, data->dt_data->fw_path, &data->client->dev);
 799                 if (ret) {
 800                         tsp_err("%s: do not request firmware: %d\n", __func__, ret);
 801                         return 0;
 802                 }
 803
 804                 fw->buf = (u8 *)firmware->data;
 805                 fw->buf_size = firmware->size;
 806         }
 807
 808         cfg_buf = (u8 *)&data->fw.buf[data->tags.cfg_addr];
 809
 810         tsp->ch_num.rx = (u8)cfg_buf[0x0C];
 811         tsp->ch_num.tx = (u8)cfg_buf[0x0D];
 812         tsp->screen.rx = (u8)cfg_buf[0x0E];
 813         tsp->screen.tx = (u8)cfg_buf[0x0F];
 814         tsp->node.len = tsp->ch_num.tx * tsp->ch_num.rx;
 815
 816         tsp->gtx.num = (u8)cfg_buf[0x10];
 817         tsp->gtx.ch_num[0] = (u8)cfg_buf[0x11];
 818         tsp->gtx.ch_num[1] = (u8)cfg_buf[0x12];
 819         tsp->gtx.ch_num[2] = (u8)cfg_buf[0x13];
 820         tsp->gtx.ch_num[3] = (u8)cfg_buf[0x14];
 821
 822         tsp->finger_num = (u8)cfg_buf[0x2C];
 823         tsp->dir.swap_xy = (bool)(cfg_buf[0x2D] & TSP_INFO_SWAP_XY ? true : false);
 824         tsp->dir.flip_x = (bool)(cfg_buf[0x2D] & TSP_INFO_FLIP_X ? true : false);
 825         tsp->dir.flip_y = (bool)(cfg_buf[0x2D] & TSP_INFO_FLIP_Y ? true : false);
 826
 827         tsp->baseline = (u16)((cfg_buf[0x45] << 8) | cfg_buf[0x44]);
 828
 829         if (tsp->dir.swap_xy) {
 830                 tsp->width = (u16)((cfg_buf[0x27] << 8) | cfg_buf[0x26]);
 831                 tsp->height = (u16)((cfg_buf[0x25] << 8) | cfg_buf[0x24]);
 832         } else {
 833                 tsp->width = (u16)((cfg_buf[0x25] << 8) | cfg_buf[0x24]);
 834                 tsp->height = (u16)((cfg_buf[0x27] << 8) | cfg_buf[0x26]);
 835         }
 836
 837 #if IST30XX_USE_KEY
 838         tkey->enable = (bool)(cfg_buf[0x15] & 1);
 839         tkey->key_num = (u8)cfg_buf[0x16];
 840
 841         tkey->ch_num[0].tx = (u8)cfg_buf[0x1A];
 842         tkey->ch_num[1].tx = (u8)cfg_buf[0x1B];
 843         tkey->ch_num[2].tx = (u8)cfg_buf[0x1C];
 844         tkey->ch_num[3].tx = (u8)cfg_buf[0x1D];
 845         tkey->ch_num[4].tx = (u8)cfg_buf[0x1E];
 846
 847         tkey->ch_num[0].rx = (u8)cfg_buf[0x1F];
 848         tkey->ch_num[1].rx = (u8)cfg_buf[0x20];
 849         tkey->ch_num[2].rx = (u8)cfg_buf[0x21];
 850         tkey->ch_num[3].rx = (u8)cfg_buf[0x22];
 851         tkey->ch_num[4].rx = (u8)cfg_buf[0x23];
 852
 853         tkey->baseline = (u16)((cfg_buf[0x19] << 8) | cfg_buf[0x18]);
 854 #endif
 855         if (data->dt_data->fw_bin && firmware) {
 856                 release_firmware(firmware);
 857                 fw->buf = NULL;
 858         }
 859 #endif
 860
 861         return ret;
 862 }
 863
 864 void ist30xx_print_info(struct ist30xx_data *data)
 865 {
 866         TSP_INFO *tsp = &data->tsp_info;
 867         TKEY_INFO *tkey = &data->tkey_info;
 868
 869         tsp_info("*** TSP/TKEY info ***\n");
 870         tsp_info("TSP info: \n");
 871         tsp_info(" finger num: %d\n", tsp->finger_num);
 872         tsp_info(" dir swap: %d, flip x: %d, y: %d\n",
 873                  tsp->dir.swap_xy, tsp->dir.flip_x, tsp->dir.flip_y);
 874         tsp_info(" baseline: %d\n", tsp->baseline);
 875         tsp_info(" ch_num tx: %d, rx: %d\n", tsp->ch_num.tx, tsp->ch_num.rx);
 876         tsp_info(" screen tx: %d, rx: %d\n", tsp->screen.tx, tsp->screen.rx);
 877         tsp_info(" width: %d, height: %d\n", tsp->width, tsp->height);
 878         tsp_info(" gtx num: %d, ch [1]: %d, [2]: %d, [3]: %d, [4]: %d\n",
 879                  tsp->gtx.num, tsp->gtx.ch_num[0], tsp->gtx.ch_num[1],
 880                  tsp->gtx.ch_num[2], tsp->gtx.ch_num[3]);
 881         tsp_info(" node len: %d\n", tsp->node.len);
 882         tsp_info("TKEY info: \n");
 883         tsp_info(" enable: %d, key num: %d\n", tkey->enable, tkey->key_num);
 884         tsp_info(" ch [0]: %d,%d [1]: %d,%d [2]: %d,%d [3]: %d,%d [4]: %d,%d\n",
 885                  tkey->ch_num[0].tx, tkey->ch_num[0].rx, tkey->ch_num[1].tx,
 886                  tkey->ch_num[1].rx, tkey->ch_num[2].tx, tkey->ch_num[2].rx,
 887                  tkey->ch_num[3].tx, tkey->ch_num[3].rx, tkey->ch_num[4].tx,
 888                  tkey->ch_num[4].rx);
 889         tsp_info(" baseline : %d\n", tkey->baseline);
 890 }
 891
 892 #define update_next_step(ret)   { if (unlikely(ret)) goto end; }
 893 int ist30xx_fw_update(struct ist30xx_data *data, const u8 *buf, int size)
 894 {
 895         int ret = 0;
 896         u32 chksum = 0;
 897         struct ist30xx_fw *fw = &data->fw;
 898
 899         tsp_info("*** Firmware update ***\n");
 900         tsp_info(" main: %x, fw: %x, test: %x, core: %x(addr: 0x%x ~ 0x%x)\n",
 901                  fw->bin.main_ver, fw->bin.fw_ver, fw->bin.test_ver, fw->bin.core_ver,
 902                  fw->index, (fw->index + fw->size));
 903
 904         data->status.update = 1;
 905     data->status.update_result = 0;
 906
 907         ist30xx_disable_irq(data);
 908
 909         ret = ist30xxc_isp_fw_update(data, buf);
 910         update_next_step(ret);
 911
 912     ret = ist30xx_read_cmd(data, eHCOM_GET_CRC32, &chksum);
 913         if (unlikely((ret) || (chksum != fw->chksum))) {
 914         if (unlikely(ret))
 915             ist30xx_reset(data, false);
 916
 917         goto end;
 918     }
 919
 920         ret = ist30xx_get_ver_info(data);
 921         update_next_step(ret);
 922
 923 end:
 924         if (unlikely(ret)) {
 925         data->status.update_result = 1;
 926                 tsp_warn("Firmware update Fail!, ret=%d\n", ret);
 927         } else if (unlikely(chksum != fw->chksum)) {
 928         data->status.update_result = 1;
 929                 tsp_warn("Error CheckSum: %x(%x)\n", chksum, fw->chksum);
 930                 ret = -ENOEXEC;
 931         }
 932
 933         ist30xx_enable_irq(data);
 934
 935         data->status.update = 2;
 936
 937         return ret;
 938 }
 939
 940 int ist30xx_fw_recovery(struct ist30xx_data *data)
 941 {
 942         int ret = -EPERM;
 943         u8 *fw = data->fw.buf;
 944         int fw_size = data->fw.buf_size;
 945
 946         ret = ist30xx_get_update_info(data, fw, fw_size);
 947         if (ret) {
 948         data->status.update_result = 1;
 949                 return ret;
 950     }
 951
 952         data->fw.bin.main_ver = ist30xx_parse_ver(data, FLAG_MAIN, fw);
 953         data->fw.bin.fw_ver = ist30xx_parse_ver(data, FLAG_FW, fw);
 954         data->fw.bin.test_ver = ist30xx_parse_ver(data, FLAG_TEST, fw);
 955         data->fw.bin.core_ver = ist30xx_parse_ver(data, FLAG_CORE, fw);
 956
 957         mutex_lock(&ist30xx_mutex);
 958         ret = ist30xx_fw_update(data, fw, fw_size);
 959         if (ret == 0)
 960                 ist30xx_calibrate(data, 1);
 961         mutex_unlock(&ist30xx_mutex);
 962
 963         ist30xx_start(data);
 964
 965         return ret;
 966 }
 967
 968 #if IST30XX_INTERNAL_BIN
 969 int ist30xx_check_fw(struct ist30xx_data *data, const u8 *buf)
 970 {
 971         int ret;
 972         u32 chksum;
 973
 974         ret = ist30xx_read_cmd(data, eHCOM_GET_CRC32, &chksum);
 975         if (unlikely(ret)) {
 976         ist30xx_reset(data, false);
 977                 return ret;
 978     }
 979
 980         if (unlikely(chksum != data->fw.chksum)) {
 981                 tsp_warn("Checksum compare error, (IC: %08x, Bin: %08x)\n",
 982                          chksum, data->fw.chksum);
 983                 return -EPERM;
 984         }
 985
 986         return 0;
 987 }
 988
 989 bool ist30xx_check_valid_vendor(u32 tsp_vendor)
 990 {
 991 #if (IMAGIS_TSP_IC < IMAGIS_IST3038C)
 992         switch (tsp_vendor) {
 993         case TSP_TYPE_ALPS:
 994         case TSP_TYPE_EELY:
 995         case TSP_TYPE_TOP:
 996         case TSP_TYPE_MELFAS:
 997         case TSP_TYPE_ILJIN:
 998         case TSP_TYPE_SYNOPEX:
 999         case TSP_TYPE_SMAC:
1000         case TSP_TYPE_TOVIS:
1001         case TSP_TYPE_ELK:
1002         case TSP_TYPE_BOE_SLOC:
1003         case TSP_TYPE_CNI_GF1:
1004         case TSP_TYPE_OTHERS:
1005                 return true;
1006         default:
1007                 return false;
1008         }
1009 #else
1010         if (tsp_vendor < TSP_TYPE_NO)
1011                 return true;
1012 #endif
1013
1014         return false;
1015 }
1016
1017 #if (IMAGIS_TSP_IC < IMAGIS_IST3038C)
1018 #if IST30XX_MULTIPLE_TSP
1019 void ist30xx_set_tsp_fw(struct ist30xx_data *data)
1020 {
1021         char *str;
1022         struct ist30xx_fw *fw = &data->fw;
1023
1024         switch (data->tsp_type) {
1025         case TSP_TYPE_BOE_SLOC:
1026                 str = "BOE";
1027                 fw->buf = (u8 *)ist30xxc_fw;
1028                 fw->buf_size = sizeof(ist30xxc_fw);
1029                 break;
1030         case TSP_TYPE_CNI_GF1:
1031                 str = "CNI";
1032                 fw->buf = (u8 *)ist30xxc_fw2;
1033                 fw->buf_size = sizeof(ist30xxc_fw2);
1034                 break;
1035
1036         case TSP_TYPE_UNKNOWN:
1037         default:
1038                 str = "Unknown";
1039                 tsp_warn("Unknown TSP vendor(0x%x)\n", data->tsp_type);
1040                 break;
1041         }
1042         tsp_info("TSP vendor : %s(%x)\n", str, data->tsp_type);
1043 }
1044 #endif  // IST30XX_MULTIPLE_TSP
1045 #endif  // (IMAGIS_TSP_IC < IMAGIS_IST3038C)
1046 #define MAIN_VER_MASK           0xFF000000
1047 int ist30xx_check_auto_update(struct ist30xx_data *data)
1048 {
1049         int ret = 0;
1050     int retry = IST30XX_MAX_RETRY_CNT;
1051         u32 tsp_type = TSP_TYPE_UNKNOWN;
1052         bool tsp_check = false;
1053         u32 chksum;
1054         struct ist30xx_fw *fw = &data->fw;
1055
1056     while (retry--) {
1057                 ret = ist30xx_read_cmd(data, eHCOM_GET_TSP_VENDOR, &tsp_type);
1058                 if (likely(ret == 0)) {
1059                         if (likely(ist30xx_check_valid_vendor(tsp_type) == true))
1060                                 tsp_check = true;
1061                         break;
1062                 }
1063
1064                 ist30xx_reset(data, false);
1065         }
1066 #if (IMAGIS_TSP_IC < IMAGIS_IST3038C)
1067     tsp_info("TSP vendor: %x\n", tsp_type);
1068 #endif
1069
1070     if (unlikely(!tsp_check))
1071                 goto fw_check_end;
1072
1073         ist30xx_get_ver_info(data);
1074
1075 /* Temp Code : Force firmware update for wrong firmware written case */
1076 #if defined(CONFIG_SEC_NOVEL_PROJECT)
1077         if (data->chip_id != IST30XX_CHIP_ID) {
1078                 tsp_info("The wrong firmware(IC : %x). Force firmware update.\n", data->chip_id);
1079                 goto fw_check_end;
1080         }
1081 #endif
1082
1083         if (data->dt_data->extra_string)
1084                 tsp_info("%s: %s, cur:%d, bin:%d\n",
1085                                                 __func__, data->dt_data->extra_string,
1086                                                 fw->cur.fw_ver, fw->bin.fw_ver);
1087
1088         if (likely((fw->cur.fw_ver > 0) && (fw->cur.fw_ver < 0xFFFFFFFF))) {
1089                 if (unlikely(((fw->cur.main_ver & MAIN_VER_MASK) == MAIN_VER_MASK) ||
1090                              ((fw->cur.main_ver & MAIN_VER_MASK) == 0)))
1091                         goto fw_check_end;
1092
1093                 tsp_info("Version compare IC: %x(%x), BIN: %x(%x)\n", fw->cur.fw_ver,
1094                         fw->cur.main_ver, fw->bin.fw_ver, fw->bin.main_ver);
1095
1096                 /* If FW version is same, check FW checksum */
1097                 if (likely((fw->cur.main_ver == fw->bin.main_ver) &&
1098                            (fw->cur.fw_ver == fw->bin.fw_ver) &&
1099                            (fw->cur.test_ver == 0))) {
1100                         ret = ist30xx_read_cmd(data, eHCOM_GET_CRC32, &chksum);
1101                         if (unlikely((ret) || (chksum != fw->chksum))) {
1102                                 tsp_warn("Checksum error, IC: %x, Bin: %x (ret: %d)\n",
1103                                          chksum, fw->chksum, ret);
1104                                 goto fw_check_end;
1105                         }
1106                 }
1107
1108                 /*
1109                  *  fw->cur.main_ver : Main version in TSP IC
1110                  *  fw->cur.fw_ver : FW version if TSP IC
1111                  *  fw->bin.main_ver : Main version in FW Binary
1112                  *  fw->bin.fw_ver : FW version in FW Binary
1113                  */
1114                 /* If the ver of binary is higher than ver of IC, FW update operate. */
1115
1116                 if (likely((fw->cur.main_ver >= fw->bin.main_ver) && (fw->cur.fw_ver >= fw->bin.fw_ver)))
1117                         return 0;
1118         }
1119
1120 fw_check_end:
1121         return -EAGAIN;
1122 }
1123
1124 int ist30xx_auto_bin_update(struct ist30xx_data *data)
1125 {
1126         int ret = 0;
1127         int retry = IST30XX_MAX_RETRY_CNT;
1128         const struct firmware *firmware = NULL;
1129         struct ist30xx_fw *fw = &data->fw;
1130
1131         if (data->dt_data->fw_bin) {
1132                 ret = request_firmware(&firmware, data->dt_data->fw_path, &data->client->dev);
1133                 if (ret) {
1134                         tsp_err("%s: do not request firmware: %d\n", __func__, ret);
1135                         return 0;
1136                 }
1137
1138                 fw->buf = (u8 *)firmware->data;
1139                 fw->buf_size = firmware->size;
1140         } else {
1141                 fw->buf = (u8 *)ist30xxc_fw;
1142                 fw->buf_size = sizeof(ist30xxc_fw);
1143         }
1144
1145 #if (IMAGIS_TSP_IC < IMAGIS_IST3038C)
1146 #if IST30XX_MULTIPLE_TSP
1147         ist30xx_set_tsp_fw(data);
1148 #endif
1149 #endif
1150
1151     ret = ist30xx_get_update_info(data, fw->buf, fw->buf_size);
1152     if (unlikely(ret)) {
1153                 tsp_err("%s: failed get update info, %d\n", __func__, ret);
1154                 goto release_fw;
1155     }
1156     fw->bin.main_ver = ist30xx_parse_ver(data, FLAG_MAIN, fw->buf);
1157         fw->bin.fw_ver = ist30xx_parse_ver(data, FLAG_FW, fw->buf);
1158         fw->bin.test_ver = ist30xx_parse_ver(data, FLAG_TEST, fw->buf);
1159     fw->bin.core_ver = ist30xx_parse_ver(data, FLAG_CORE, fw->buf);
1160
1161         tsp_info("IC: %x, Binary ver main: %x, fw: %x, test: %x, core: %x\n",
1162                 data->chip_id, fw->bin.main_ver, fw->bin.fw_ver, fw->bin.test_ver,
1163                 fw->bin.core_ver);
1164
1165         mutex_lock(&ist30xx_mutex);
1166         ret = ist30xx_check_auto_update(data);
1167         mutex_unlock(&ist30xx_mutex);
1168
1169         if (data->dt_data->bringup) {
1170                 tsp_info("%s: bring up! do not update firmware.\n", __func__);
1171                 ret = 0;
1172                 goto release_fw;
1173         }
1174
1175         if (likely(ret >= 0))
1176                 goto release_fw;
1177
1178 update_bin:   // TSP is not ready / FW update
1179         tsp_info("Update version. fw(main, test, core): %x(%x, %x, %x) -> %x(%x, %x, %x)\n",
1180                  fw->cur.fw_ver, fw->cur.main_ver, fw->cur.test_ver, fw->cur.core_ver,
1181                  fw->bin.fw_ver, fw->bin.main_ver, fw->bin.test_ver, fw->bin.core_ver);
1182
1183         mutex_lock(&ist30xx_mutex);
1184         while (retry--) {
1185                 ret = ist30xx_fw_update(data, fw->buf, fw->buf_size);
1186                 if (unlikely(!ret))
1187                         break;
1188         }
1189         mutex_unlock(&ist30xx_mutex);
1190
1191         if (unlikely(ret))
1192                 goto end_update;
1193
1194         if (unlikely(retry > 0 && ist30xx_check_fw(data, fw->buf)))
1195                 goto update_bin;
1196
1197     mutex_lock(&ist30xx_mutex);
1198         ist30xx_calibrate(data, IST30XX_MAX_RETRY_CNT);
1199     mutex_unlock(&ist30xx_mutex);
1200
1201 end_update:
1202         ist30xx_write_cmd(data->client,
1203                           IST30XX_HIB_CMD, (eHCOM_FW_HOLD << 16) | (1 & 0xFFFF));
1204         tsp_info("%s: set FW_HOLD\n", __func__);
1205 release_fw:
1206         if (data->dt_data->fw_bin && firmware) {
1207                 release_firmware(firmware);
1208                 fw->buf = NULL;
1209         }
1210
1211         return ret;
1212 }
1213 #endif // IST30XX_INTERNAL_BIN
1214
1215 #define MAX_FILE_PATH   255
1216 /* sysfs: /sys/class/touch/firmware/firmware */
1217 ssize_t ist30xx_fw_store(struct device *dev, struct device_attribute *attr,
1218                          const char *buf, size_t size)
1219 {
1220         int ret;
1221         int fw_size = 0;
1222         u8 *fw = NULL;
1223         const u8 *buff = 0;
1224         mm_segment_t old_fs = { 0 };
1225         struct file *fp = NULL;
1226         long fsize = 0, nread = 0;
1227         char fw_path[MAX_FILE_PATH];
1228         const struct firmware *request_fw = NULL;
1229         int mode = 0;
1230         int calib = 1;
1231     struct ist30xx_data *data = dev_get_drvdata(dev);
1232
1233         sscanf(buf, "%d %d", &mode, &calib);
1234
1235         switch (mode) {
1236         case MASK_UPDATE_INTERNAL:
1237 #if IST30XX_INTERNAL_BIN
1238                 fw = data->fw.buf;
1239                 fw_size = data->fw.buf_size;
1240 #else
1241                 data->status.update_result = 1;
1242                 tsp_warn("Not support internal bin!!\n");
1243                 return size;
1244 #endif
1245                 break;
1246
1247         case MASK_UPDATE_FW:
1248                 ret = request_firmware(&request_fw, IST30XX_FW_NAME,
1249                                        &data->client->dev);
1250                 if (ret) {
1251                         data->status.update_result = 1;
1252                         tsp_warn("File not found, %s\n", IST30XX_FW_NAME);
1253                         return size;
1254                 }
1255
1256                 fw = (u8 *)request_fw->data;
1257                 fw_size = (u32)request_fw->size;
1258         tsp_info("firmware is loaded!!\n");
1259                 break;
1260
1261         case MASK_UPDATE_SDCARD:
1262                 old_fs = get_fs();
1263                 set_fs(get_ds());
1264
1265                 snprintf(fw_path, MAX_FILE_PATH, "/sdcard/%s",
1266                          IST30XX_FW_NAME);
1267                 fp = filp_open(fw_path, O_RDONLY, 0);
1268                 if (IS_ERR(fp)) {
1269                         data->status.update_result = 1;
1270                         tsp_info("file %s open error:%d\n", fw_path, (s32)fp);
1271                         goto err_file_open;
1272                 }
1273
1274                 fsize = fp->f_path.dentry->d_inode->i_size;
1275
1276                 buff = kzalloc((size_t)fsize, GFP_KERNEL);
1277                 if (!buff) {
1278                         data->status.update_result = 1;
1279                         tsp_info("fail to alloc buffer\n");
1280                         goto err_alloc;
1281                 }
1282
1283                 nread = vfs_read(fp, (char __user *)buff, fsize, &fp->f_pos);
1284                 if (nread != fsize) {
1285                         data->status.update_result = 1;
1286                         tsp_info("mismatch fw size\n");
1287                         goto err_fw_size;
1288                 }
1289
1290                 fw = (u8 *)buff;
1291                 fw_size = (u32)fsize;
1292
1293                 filp_close(fp, current->files);
1294                 tsp_info("firmware is loaded!!\n");
1295                 break;
1296
1297         case MASK_UPDATE_ERASE:
1298                 tsp_info("EEPROM all erase!!\n");
1299
1300                 mutex_lock(&ist30xx_mutex);
1301                 ist30xx_disable_irq(data);
1302         ist30xx_reset(data, true);
1303                 ist30xxc_isp_enable(data->client, true);
1304                 ist30xxc_isp_erase(data->client, IST30XX_ISP_ERASE_BLOCK, 0);
1305 #if (IST30XX_FLASH_INFO_SIZE > 0)
1306                 ist30xxc_isp_erase(data->client, IST30XX_ISP_ERASE_INFO, 0);
1307 #endif
1308         ist30xxc_isp_enable(data->client, false);
1309                 ist30xx_reset(data, false);
1310         ist30xx_start(data);
1311                 ist30xx_enable_irq(data);
1312                 mutex_unlock(&ist30xx_mutex);
1313
1314         default:
1315                 return size;
1316         }
1317
1318         ret = ist30xx_get_update_info(data, fw, fw_size);
1319         if (ret) {
1320                 data->status.update_result = 1;
1321                 goto err_get_info;
1322         }
1323
1324         data->fw.bin.main_ver = ist30xx_parse_ver(data, FLAG_MAIN, fw);
1325         data->fw.bin.fw_ver = ist30xx_parse_ver(data, FLAG_FW, fw);
1326         data->fw.bin.test_ver = ist30xx_parse_ver(data, FLAG_TEST, fw);
1327         data->fw.bin.core_ver = ist30xx_parse_ver(data, FLAG_CORE, fw);
1328
1329         mutex_lock(&ist30xx_mutex);
1330         ret = ist30xx_fw_update(data, fw, fw_size);
1331         if (ret == 0) {
1332                 if (calib)
1333                         ist30xx_calibrate(data, 1);
1334         }
1335         mutex_unlock(&ist30xx_mutex);
1336
1337         ist30xx_start(data);
1338
1339 err_get_info:
1340         if (request_fw != NULL)
1341                 release_firmware(request_fw);
1342
1343         if (fp != NULL) {
1344 err_fw_size:
1345                 kfree(buff);
1346 err_alloc:
1347                 filp_close(fp, NULL);
1348 err_file_open:
1349                 set_fs(old_fs);
1350         }
1351
1352         return size;
1353 }
1354
1355 /* sysfs: /sys/class/touch/firmware/fw_sdcard */
1356 ssize_t ist30xx_fw_sdcard_show(struct device *dev,
1357                                struct device_attribute *attr, char *buf)
1358 {
1359     int ret = 0;
1360         int fw_size = 0;
1361         u8 *fw = NULL;
1362         const u8 *buff = 0;
1363         mm_segment_t old_fs = { 0 };
1364         struct file *fp = NULL;
1365         long fsize = 0, nread = 0;
1366         char fw_path[MAX_FILE_PATH];
1367     struct ist30xx_data *data = dev_get_drvdata(dev);
1368
1369         old_fs = get_fs();
1370         set_fs(get_ds());
1371
1372         snprintf(fw_path, MAX_FILE_PATH, "/sdcard/%s",
1373                  IST30XX_FW_NAME);
1374         fp = filp_open(fw_path, O_RDONLY, 0);
1375         if (IS_ERR(fp)) {
1376                 data->status.update_result = 1;
1377                 tsp_info("file %s open error:%d\n", fw_path, (s32)fp);
1378                 goto err_file_open;
1379         }
1380
1381         fsize = fp->f_path.dentry->d_inode->i_size;
1382
1383         buff = kzalloc((size_t)fsize, GFP_KERNEL);
1384         if (!buff) {
1385                 data->status.update_result = 1;
1386                 tsp_info("fail to alloc buffer\n");
1387                 goto err_alloc;
1388         }
1389
1390         nread = vfs_read(fp, (char __user *)buff, fsize, &fp->f_pos);
1391         if (nread != fsize) {
1392                 data->status.update_result = 1;
1393                 tsp_info("mismatch fw size\n");
1394                 goto err_fw_size;
1395         }
1396
1397         fw = (u8 *)buff;
1398         fw_size = (u32)fsize;
1399
1400         filp_close(fp, current->files);
1401         tsp_info("firmware is loaded!!\n");
1402
1403         ret = ist30xx_get_update_info(data, fw, fw_size);
1404         if (ret) {
1405                 data->status.update_result = 1;
1406                 goto err_get_info;
1407         }
1408
1409         data->fw.bin.main_ver = ist30xx_parse_ver(data, FLAG_MAIN, fw);
1410         data->fw.bin.fw_ver = ist30xx_parse_ver(data, FLAG_FW, fw);
1411         data->fw.bin.test_ver = ist30xx_parse_ver(data, FLAG_TEST, fw);
1412         data->fw.bin.core_ver = ist30xx_parse_ver(data, FLAG_CORE, fw);
1413
1414         mutex_lock(&ist30xx_mutex);
1415         ist30xx_fw_update(data, fw, fw_size);
1416         mutex_unlock(&ist30xx_mutex);
1417
1418         ist30xx_start(data);
1419
1420 err_get_info:
1421 err_fw_size:
1422         if (buff)
1423                 kfree(buff);
1424 err_alloc:
1425                 filp_close(fp, NULL);
1426 err_file_open:
1427         set_fs(old_fs);
1428
1429         return 0;
1430 }
1431
1432 /* sysfs: /sys/class/touch/firmware/firmware */
1433 ssize_t ist30xx_fw_status_show(struct device *dev,
1434                                struct device_attribute *attr, char *buf)
1435 {
1436         int count;
1437     struct ist30xx_data *data = dev_get_drvdata(dev);
1438
1439         switch (data->status.update) {
1440         case 1:
1441                 count = sprintf(buf, "Downloading\n");
1442                 break;
1443         case 2:
1444                 if (data->status.update_result) {
1445                         count = sprintf(buf, "Update fail\n");
1446                 } else {
1447                         count = sprintf(buf, "Update success, ver %x(%x, %x, %x)-> %x(%x, %x, %x), "
1448                                 "status : %d, gap : %d\n",
1449                                 data->fw.prev.fw_ver, data->fw.prev.main_ver,
1450                                 data->fw.prev.test_ver, data->fw.prev.core_ver,
1451                                 data->fw.cur.fw_ver, data->fw.cur.main_ver,
1452                                 data->fw.cur.test_ver, data->fw.cur.core_ver,
1453                                 CALIB_TO_STATUS(data->status.calib_msg),
1454                                 CALIB_TO_GAP(data->status.calib_msg));
1455                 }
1456                 break;
1457         default:
1458                 if (data->status.update_result)
1459                         count = sprintf(buf, "Update fail\n");
1460                 else
1461                         count = sprintf(buf, "Pass\n");
1462                 break;
1463         }
1464
1465         return count;
1466 }
1467
1468 /* sysfs: /sys/class/touch/firmware/fw_read */
1469 u32 buf32_flash[IST30XX_FLASH_TOTAL_SIZE / IST30XX_DATA_LEN];
1470 ssize_t ist30xx_fw_read_show(struct device *dev, struct device_attribute *attr,
1471                              char *buf)
1472 {
1473         int i;
1474     mm_segment_t old_fs = { 0 };
1475     struct file *fp = NULL;
1476     char fw_path[MAX_FILE_PATH];
1477     u8 *buf8 = (u8 *)buf32_flash;
1478     struct ist30xx_data *data = dev_get_drvdata(dev);
1479
1480         mutex_lock(&ist30xx_mutex);
1481         ist30xx_disable_irq(data);
1482
1483         ist30xxc_isp_fw_read(data, buf32_flash);
1484         for (i = 0; i < IST30XX_FLASH_TOTAL_SIZE; i += 16) {
1485                 tsp_debug("%07x: %02x%02x %02x%02x %02x%02x %02x%02x "
1486                           "%02x%02x %02x%02x %02x%02x %02x%02x\n", i,
1487                           buf8[i], buf8[i + 1], buf8[i + 2], buf8[i + 3],
1488                           buf8[i + 4], buf8[i + 5], buf8[i + 6], buf8[i + 7],
1489                           buf8[i + 8], buf8[i + 9], buf8[i + 10], buf8[i + 11],
1490                           buf8[i + 12], buf8[i + 13], buf8[i + 14], buf8[i + 15]);
1491         }
1492
1493     old_fs = get_fs();
1494         set_fs(get_ds());
1495
1496     snprintf(fw_path, MAX_FILE_PATH, "/sdcard/%s", IST30XX_BIN_NAME);
1497     fp = filp_open(fw_path, O_CREAT|O_WRONLY|O_TRUNC, 0);
1498     if (IS_ERR(fp)) {
1499                 tsp_info("file %s open error:%d\n", fw_path, (s32)fp);
1500                 goto err_file_open;
1501         }
1502
1503         fp->f_op->write(fp, buf8, IST30XX_FLASH_TOTAL_SIZE, &fp->f_pos);
1504         fput(fp);
1505
1506         filp_close(fp, NULL);
1507         set_fs(old_fs);
1508
1509 err_file_open:
1510         ist30xx_enable_irq(data);
1511         mutex_unlock(&ist30xx_mutex);
1512
1513         ist30xx_start(data);
1514
1515         return 0;
1516 }
1517
1518 /* sysfs: /sys/class/touch/firmware/version */
1519 ssize_t ist30xx_fw_version_show(struct device *dev,
1520                                 struct device_attribute *attr, char *buf)
1521 {
1522         int count;
1523     struct ist30xx_data *data = dev_get_drvdata(dev);
1524
1525         count = sprintf(buf, "ID: %x, main: %x, fw: %x, test: %x, core: %x\n",
1526                         data->chip_id, data->fw.cur.main_ver, data->fw.cur.fw_ver,
1527                         data->fw.cur.test_ver, data->fw.cur.core_ver);
1528
1529 #if IST30XX_INTERNAL_BIN
1530         {
1531                 const struct firmware *firmware = NULL;
1532                 struct ist30xx_fw *fw = &data->fw;
1533                 int ret;
1534
1535                 if (data->dt_data->fw_bin) {
1536                         ret = request_firmware(&firmware, data->dt_data->fw_path, &data->client->dev);
1537                         if (ret) {
1538                                 tsp_err("%s: do not request firmware: %d\n", __func__, ret);
1539                                 return count;
1540                         }
1541
1542                         fw->buf = (u8 *)firmware->data;
1543                         fw->buf_size = firmware->size;
1544                 }
1545
1546                 ret = ist30xx_get_update_info(data, data->fw.buf, data->fw.buf_size);
1547                 if (ret == 0)
1548                         count += sprintf(buf + count,
1549                                         "Header - main: %x, fw: %x, test: %x, core: %x\n",
1550                                         ist30xx_parse_ver(data, FLAG_MAIN, data->fw.buf),
1551                                         ist30xx_parse_ver(data, FLAG_FW, data->fw.buf),
1552                                         ist30xx_parse_ver(data, FLAG_TEST, data->fw.buf),
1553                                         ist30xx_parse_ver(data, FLAG_CORE, data->fw.buf));
1554
1555                 if (data->dt_data->fw_bin && firmware) {
1556                         release_firmware(firmware);
1557                         fw->buf = NULL;
1558                 }
1559
1560         }
1561 #endif
1562
1563         return count;
1564 }
1565
1566 /* sysfs  */
1567 static DEVICE_ATTR(fw_read, S_IRUGO, ist30xx_fw_read_show, NULL);
1568 static DEVICE_ATTR(firmware, S_IRUGO, ist30xx_fw_status_show,
1569                    ist30xx_fw_store);
1570 static DEVICE_ATTR(fw_sdcard, S_IRUGO, ist30xx_fw_sdcard_show, NULL);
1571 static DEVICE_ATTR(version, S_IRUGO, ist30xx_fw_version_show, NULL);
1572
1573 struct class *ist30xx_class;
1574 struct device *ist30xx_fw_dev;
1575
1576 static struct attribute *fw_attributes[] = {
1577         &dev_attr_fw_read.attr,
1578         &dev_attr_firmware.attr,
1579         &dev_attr_fw_sdcard.attr,
1580         &dev_attr_version.attr,
1581         NULL,
1582 };
1583
1584 static struct attribute_group fw_attr_group = {
1585         .attrs  = fw_attributes,
1586 };
1587
1588 int ist30xx_init_update_sysfs(struct ist30xx_data *data)
1589 {
1590         /* /sys/class/touch */
1591         ist30xx_class = class_create(THIS_MODULE, "touch");
1592
1593         /* /sys/class/touch/firmware */
1594         ist30xx_fw_dev = device_create(ist30xx_class, NULL, 0, data, "firmware");
1595
1596         /* /sys/class/touch/firmware/... */
1597         if (unlikely(sysfs_create_group(&ist30xx_fw_dev->kobj, &fw_attr_group)))
1598                 tsp_err("Failed to create sysfs group(%s)!\n", "firmware");
1599
1600         data->status.update = 0;
1601         data->status.calib = 0;
1602     data->status.update_result = 0;
1603
1604         return 0;
1605 }