drivers/input/touchscreen/wacom/wacom_i2c_flash.c

   1 #include <linux/wacom_i2c.h>
   2
   3 #include "wacom_i2c_flash.h"
   4
   5 int wacom_i2c_flash_chksum(struct wacom_i2c *wac_i2c, unsigned char *flash_data,
   6                                         unsigned long *max_address)
   7 {
   8         unsigned long i;
   9         unsigned long chksum = 0;
  10
  11         for (i = 0x0000; i <= *max_address; i++)
  12                 chksum += flash_data[i];
  13
  14         chksum &= 0xFFFF;
  15
  16         return (int)chksum;
  17 }
  18
  19 int wacom_i2c_flash_cmd(struct wacom_i2c *wac_i2c)
  20 {
  21
  22         int ret, len, i;
  23         u8 buf[10], flashq;
  24
  25         buf[0] = 0x0d;
  26         buf[1] = FLASH_START0;
  27         buf[2] = FLASH_START1;
  28         buf[3] = FLASH_START2;
  29         buf[4] = FLASH_START3;
  30         buf[5] = FLASH_START4;
  31         buf[6] = FLASH_START5;
  32         buf[7] = 0x0d;
  33         flashq = 0xE0;
  34         len = 1;
  35
  36         ret = wacom_i2c_master_send(wac_i2c->client, &flashq, len,
  37                                         WACOM_I2C_BOOT);
  38         if (ret >= 0) {
  39
  40                 i = 0;
  41                 do {
  42                         msleep(1);
  43                         ret = wacom_i2c_master_recv(wac_i2c->client, &flashq,
  44                                                         len, WACOM_I2C_BOOT);
  45                         i++;
  46
  47                         if (i > RETRY)
  48                                 return -1;
  49                 } while (flashq == 0xff);
  50         } else {
  51                 msleep(1);
  52                 len = 8;
  53                 ret = i2c_master_send(wac_i2c->client, buf, len);
  54                 if (ret < 0) {
  55                         printk(KERN_ERR "Sending flash command failed\n");
  56                         return -1;
  57                 }
  58                 printk(KERN_DEBUG "flash send?:%d\n", ret);
  59                 msleep(270);
  60         }
  61
  62         return 0;
  63 }
  64
  65 int wacom_i2c_flash_query(struct wacom_i2c *wac_i2c, u8 query, u8 recvdQuery)
  66 {
  67         int ret, len, i;
  68         u8 flashq;
  69
  70         flashq = query;
  71         len = 1;
  72
  73         ret = wacom_i2c_master_send(wac_i2c->client, &flashq, len,
  74                                         WACOM_I2C_BOOT);
  75         if (ret < 0) {
  76                 printk(KERN_ERR "query unsent:%d\n", ret);
  77                 return -1;
  78         }
  79
  80         /*sleep*/
  81         msleep(10);
  82         i = 0;
  83         do {
  84                 msleep(1);
  85                 flashq = query;
  86                 ret = wacom_i2c_master_recv(wac_i2c->client, &flashq, len,
  87                                                 WACOM_I2C_BOOT);
  88                 i++;
  89
  90                 if (i > RETRY)
  91                         return -1;
  92                 printk(KERN_DEBUG "ret:%d flashq:%x\n", ret, flashq);
  93         } while (recvdQuery == 0xff && flashq != recvdQuery);
  94         printk(KERN_DEBUG "query:%x\n", flashq);
  95
  96         return flashq;
  97 }
  98
  99 int wacom_i2c_flash_end(struct wacom_i2c *wac_i2c)
 100 {
 101         if (wacom_i2c_flash_query(wac_i2c, FLASH_END, FLASH_END) == -1)
 102                 return ERR_FAILED_EXIT;
 103         printk(KERN_DEBUG "Digitizer activated\n");
 104         return 0;
 105 }
 106
 107 int wacom_i2c_flash_enter(struct wacom_i2c *wac_i2c)
 108 {
 109         if (wacom_i2c_flash_query(wac_i2c, FLASH_QUERY, FLASH_ACK) == -1)
 110                 return ERR_NOT_FLASH;
 111         return 0;
 112 }
 113
 114 int wacom_i2c_flash_BLVer(struct wacom_i2c *wac_i2c)
 115 {
 116         int ret = 0;
 117         ret = wacom_i2c_flash_query(wac_i2c, FLASH_BLVER, 0x40);
 118         if (ret == -1)
 119                 return ERR_UNSENT;
 120
 121         return ret;
 122 }
 123
 124 int wacom_i2c_flash_mucId(struct wacom_i2c *wac_i2c)
 125 {
 126         int ret = 0;
 127
 128         ret = wacom_i2c_flash_query(wac_i2c, FLASH_MPU, 0x26);
 129         if (ret == -1)
 130                 return ERR_UNSENT;
 131
 132         return ret;
 133 }
 134
 135 int wacom_i2c_flash_erase(struct wacom_i2c *wac_i2c, u8 cmd_erase,
 136                                 u8 cmd_block, u8 endBlock)
 137 {
 138         int len, ret, i, j;
 139         u8 buf[3], sum, block, flashq;
 140
 141         ret = 0;
 142
 143         for (i = cmd_block; i >= endBlock; i--) {
 144                 block = i;
 145                 block |= 0x80;
 146
 147                 sum = cmd_erase;
 148                 sum += block;
 149                 sum = ~sum + 1;
 150
 151                 buf[0] = cmd_erase;
 152                 buf[1] = block;
 153                 buf[2] = sum;
 154
 155                 len = 3;
 156                 ret = wacom_i2c_master_send(wac_i2c->client, buf, len,
 157                                                 WACOM_I2C_BOOT);
 158                 if (ret < 0) {
 159                         printk(KERN_ERR "Erase failed\n");
 160                         return -1;
 161                 }
 162
 163                 len = 1;
 164                 flashq = 0;
 165                 j = 0;
 166
 167                 do {
 168                         /*sleep*/
 169                         msleep(100);
 170                         ret = wacom_i2c_master_recv(wac_i2c->client, &flashq,
 171                                                         len, WACOM_I2C_BOOT);
 172                         j++;
 173
 174                         if (j > RETRY || flashq == 0x84 || flashq == 0x88
 175                                 || flashq == 0x8A || flashq == 0x90) {
 176                                 /*
 177                                 0xff:No data
 178                                 0x84:Erase failure
 179                                 0x88:Erase time parameter error
 180                                 0x8A:Write time parameter error
 181                                 0x90:Checksum error
 182                                 */
 183                                 printk(KERN_ERR "Error:%x\n", flashq);
 184                                 return -1;
 185                         }
 186                 } while (flashq == 0xff);
 187                 printk(KERN_DEBUG "Erasing at %d, ", i);
 188                 /*sleep*/
 189                 msleep(1);
 190         }
 191         printk(KERN_DEBUG "Erasing done\n");
 192         return ret;
 193 }
 194
 195 int wacom_i2c_flash_write(struct wacom_i2c *wac_i2c, unsigned long startAddr,
 196                                 u8 size, unsigned long maxAddr)
 197 {
 198         unsigned long ulAddr;
 199         int ret, len, i, j;
 200 //      float max;
 201 //      float start;
 202         char sum;
 203         u8 buf[WRITE_BUFF], bank;
 204
 205         ret = len = i = 0;
 206         bank = BANK;
 207
 208         for (ulAddr = startAddr; ulAddr <= maxAddr; ulAddr += BLOCK_SIZE_W) {
 209
 210                 sum = 0;
 211                 buf[0] = FLASH_WRITE;
 212                 buf[1] = (u8)(ulAddr & 0xff);
 213                 buf[2] = (u8)((ulAddr & 0xff00)>>8);
 214                 buf[3] = size;
 215                 buf[4] = bank;
 216
 217                 for (i = 0; i < 5; i++)
 218                         sum += buf[i];
 219
 220                 sum = ~sum+1;
 221                 buf[5] = sum;
 222
 223                 len = 6;
 224
 225                 ret = wacom_i2c_master_send(wac_i2c->client, buf, len,
 226                                                 WACOM_I2C_BOOT);
 227                 if (ret < 0) {
 228                         printk(KERN_ERR "Write process aborted\n");
 229                         return ERR_FAILED_ENTER;
 230                 }
 231
 232                 msleep(10);
 233                 len = 1;
 234                 j = 0;
 235                 do {
 236                         msleep(5);
 237                         ret = wacom_i2c_master_recv(wac_i2c->client, buf, len,
 238                                                         WACOM_I2C_BOOT);
 239                         j++;
 240
 241                         if (j > RETRY || buf[0] == 0x90) {
 242                                 /*0xff:No data 0x90:Checksum error*/
 243                                 printk(KERN_ERR "Error:%x\n", buf[0]);
 244                                 return -1;
 245                         }
 246                 } while (buf[0] == 0xff);
 247
 248                 msleep(1);
 249                 sum = 0;
 250                 for (i = 0; i < BLOCK_SIZE_W; i++) {
 251                         buf[i] = Binary[ulAddr+i];
 252                         sum += Binary[ulAddr+i];
 253                 }
 254                 sum = ~sum+1;
 255                 buf[BLOCK_SIZE_W] = sum;
 256                 len = BLOCK_SIZE_W+1;
 257
 258                 ret = wacom_i2c_master_send(wac_i2c->client, buf, len,
 259                                                         WACOM_I2C_BOOT);
 260                 if (ret < 0) {
 261                         printk(KERN_ERR "Firmware flash aborted while writing\n");
 262                         return ERR_NOT_FLASH;
 263                 }
 264
 265                 msleep(100);
 266                 len = 1;
 267                 j = 0;
 268
 269                 do {
 270                         msleep(10);
 271                         ret = wacom_i2c_master_recv(wac_i2c->client, buf, len,
 272                                                         WACOM_I2C_BOOT);
 273                         j++;
 274
 275                         if (j > RETRY || buf[0] == 0x82 || buf[0] == 0x90) {
 276                                 /*
 277                                 0xff:No data
 278                                 0x82:Write error
 279                                 0x90:Checksum error
 280                                 */
 281                                 printk(KERN_ERR "Error:%x\n", buf[0]);
 282                                 return -1;
 283                         }
 284                 } while (buf[0] == 0xff);
 285                 printk(KERN_DEBUG "Written on:0x%lx", ulAddr);
 286                 msleep(1);
 287         }
 288         printk(KERN_DEBUG "\nWriting done\n");
 289
 290         return 0;
 291 }
 292
 293 int wacom_i2c_flash_verify(struct wacom_i2c *wac_i2c, unsigned long startAddr,
 294                                                 u8 size, unsigned long maxAddr)
 295 {
 296         unsigned long ulAddr;
 297         int ret, len, i, j;
 298         char sum;
 299         u8 buf[WRITE_BUFF], bank;
 300
 301         ret = len = i = 0;
 302         bank = BANK;
 303
 304         for (ulAddr = startAddr; ulAddr <= maxAddr; ulAddr += BLOCK_SIZE_W) {
 305
 306                 sum = 0;
 307                 buf[0] = FLASH_VERIFY;
 308                 buf[1] = (u8)(ulAddr & 0xff);
 309                 buf[2] = (u8)((ulAddr & 0xff00)>>8);
 310                 buf[3] = size;
 311                 buf[4] = bank;
 312
 313                 for (i = 0; i < 5; i++)
 314                         sum += buf[i];
 315                 sum = ~sum+1;
 316                 buf[5] = sum;
 317
 318                 len = 6;
 319                 j = 0;
 320                 /*sleep*/
 321
 322                 ret = wacom_i2c_master_send(wac_i2c->client, buf, len,
 323                                                 WACOM_I2C_BOOT);
 324                 if (ret < 0) {
 325                         printk(KERN_ERR "Write process aborted\n");
 326                         return ERR_FAILED_ENTER;
 327                 }
 328
 329                 len = 1;
 330
 331                 do {
 332                         msleep(1);
 333                         ret = wacom_i2c_master_recv(wac_i2c->client, buf, len,
 334                                                         WACOM_I2C_BOOT);
 335                         j++;
 336                         if (j > RETRY || buf[0] == 0x90) {
 337                                 /*0xff:No data 0x90:Checksum error*/
 338                                 printk(KERN_ERR "Error:%x\n", buf[0]);
 339                                 return -1;
 340                         }
 341                 } while (buf[0] == 0xff);
 342
 343                 msleep(1);
 344                 sum = 0;
 345                 for (i = 0; i < BLOCK_SIZE_W; i++) {
 346                         buf[i] = Binary[ulAddr+i];
 347                         sum += Binary[ulAddr+i];
 348                 }
 349                 sum = ~sum+1;
 350                 buf[BLOCK_SIZE_W] = sum;
 351                 len = BLOCK_SIZE_W+1;
 352
 353                 ret = wacom_i2c_master_send(wac_i2c->client, buf, len,
 354                                                 WACOM_I2C_BOOT);
 355                 if (ret < 0) {
 356                         printk(KERN_ERR "Firmware flash aborted while writing\n");
 357                         return ERR_NOT_FLASH;
 358                 }
 359
 360                 msleep(10);
 361                 len = 1;
 362                 j = 0;
 363                 do {
 364                         msleep(10);
 365                         ret = wacom_i2c_master_recv(wac_i2c->client, buf, len,
 366                                                         WACOM_I2C_BOOT);
 367                         j++;
 368
 369                         if (j > RETRY || buf[0] == 0x81 || buf[0] == 0x90) {
 370                                 /*
 371                                 0xff:No data
 372                                 0x82:Write error
 373                                 0x90:Checksum error
 374                                 */
 375                                 printk(KERN_ERR "Error:%x", buf[0]);
 376                                 return -1;
 377                         }
 378                 } while (buf[0] == 0xff);
 379                 printk(KERN_DEBUG "Verified:0x%lx", ulAddr);
 380                 msleep(1);
 381         }
 382         printk("\nVerifying done\n");
 383
 384         return 0;
 385 }
 386
 387
 388 int wacom_i2c_flash(struct wacom_i2c *wac_i2c)
 389 {
 390         int ret, blver, mcu;
 391         unsigned long i, maxAddr;
 392         ret = blver = mcu = 0;
 393         i = maxAddr = 0;
 394
 395         ret = wacom_i2c_flash_cmd(wac_i2c);
 396         msleep(10);
 397         ret = wacom_i2c_flash_enter(wac_i2c);
 398         printk(KERN_DEBUG "flashEnter:%d\n", ret);
 399
 400         /*sleep*/
 401         msleep(1);
 402
 403         blver = wacom_i2c_flash_BLVer(wac_i2c);
 404         printk(KERN_DEBUG "blver:%d\n", blver);
 405
 406         /*sleep*/
 407         msleep(1);
 408
 409         mcu = wacom_i2c_flash_mucId(wac_i2c);
 410         printk(KERN_DEBUG "mcu:%d\n", mcu);
 411         if (Mpu_type != mcu) {
 412                 wacom_i2c_flash_end(wac_i2c);
 413                 return -1;
 414         }
 415
 416         /*sleep*/
 417         msleep(1);
 418
 419
 420         switch (mcu) {
 421         case 0x26:
 422                 printk(KERN_DEBUG "flashing for w8501 started\n");
 423                 maxAddr = MAX_ADDR_W8501;
 424                 ret = wacom_i2c_flash_erase(wac_i2c, FLASH_ERASE,
 425                                         MAX_BLOCK_W8501, END_BLOCK);
 426                 if (ret < 0)
 427                         return -1;
 428                 printk(KERN_DEBUG "erased:%d\n", ret);
 429
 430                 msleep(10);
 431
 432                 ret = wacom_i2c_flash_write(wac_i2c, START_ADDR,
 433                                         NUM_BLOCK_2WRITE, maxAddr);
 434                 if (ret < 0)
 435                         return -1;
 436
 437                 msleep(1);
 438
 439                 ret = wacom_i2c_flash_verify(wac_i2c, START_ADDR,
 440                                         NUM_BLOCK_2WRITE, maxAddr);
 441                 if (ret < 0)
 442                         return -1;
 443
 444                 break;
 445
 446         case 0x27:
 447                 printk(KERN_DEBUG "Flashing for 514 started\n");
 448                 maxAddr = MAX_ADDR_514;
 449                 ret = wacom_i2c_flash_erase(wac_i2c, FLASH_ERASE,
 450                                         MAX_BLOCK_514, END_BLOCK);
 451                 if (ret < 0)
 452                         return -1;
 453                 printk(KERN_DEBUG "erased:%d\n", ret);
 454
 455                 msleep(10);
 456
 457                 ret = wacom_i2c_flash_write(wac_i2c, START_ADDR,
 458                                         NUM_BLOCK_2WRITE, maxAddr);
 459                 if (ret < 0)
 460                         return -1;
 461
 462                 msleep(1);
 463
 464                 ret = wacom_i2c_flash_verify(wac_i2c, START_ADDR,
 465                                         NUM_BLOCK_2WRITE, maxAddr);
 466                 if (ret < 0)
 467                         return -1;
 468
 469                 break;
 470
 471         default:
 472                 printk(KERN_DEBUG "default called\n");
 473                 break;
 474         }
 475         msleep(1);
 476
 477         ret = wacom_i2c_flash_end(wac_i2c);
 478         printk(KERN_DEBUG "Firmware successfully updated:%x\n", ret);
 479
 480         return 0;
 481 }