property/tizen_misc.c

   1 #include <common.h>
   2 #include <sprd_battery.h>
   3 #include <part.h>
   4 #include <boot_mode.h>
   5 #include <ext2fs.h>
   6 #include <asm/arch/sprd_keypad.h>
   7 #include <asm/arch/sprd_eic.h>
   8 #include "../disk/part_uefi.h"
   9 #include "../drivers/mmc/card_sdio.h"
  10 #include "tizen_misc.h"
  11 #include "tizen_part.h"
  12 #include <normal_mode.h>
  13 #include <asm/arch-sc8830/adi_reg_v3.h>
  14 #include <asm/arch/adi_hal_internal.h>
  15
  16 #ifdef CONFIG_TIZEN_LPM_SUPPORT
  17 extern int charger_connected(void);
  18 #endif
  19 extern unsigned char *get_global_cid(void);
  20 extern int get_volumn_down_status2(void);
  21 extern unsigned char _chkNVEcc(uint8_t * buf, uint32_t size, uint32_t checksum);
  22 extern unsigned short calc_checksum(unsigned char *dat, unsigned long len);
  23
  24 static void convert_to_string(wchar_t *crap, char *buf)
  25 {
  26         while (*crap)
  27                 *buf++ = (char)*crap++;
  28         *buf = '\0';
  29 }
  30
  31 int tizen_get_partition_info_by_name (block_dev_desc_t *dev_desc,
  32                                                         wchar_t* partition_name, disk_partition_t *info)
  33 {
  34         int i, ret;
  35         char part_name[72 / sizeof(unsigned short)];
  36
  37         ret = get_partition_info_by_name(dev_desc, partition_name, info);
  38         if (ret < 0) {
  39                 convert_to_string(partition_name, part_name);
  40
  41                 for (i = 0; i < ARRAY_SIZE(thor_part_map); i++) {
  42                         if (!strcmp(part_name, thor_part_map[i].part_name)) {
  43                                 info->start = thor_part_map[i].start;
  44                                 info->size = thor_part_map[i].size;
  45                                 info->blksz = thor_part_map[i].blksz;
  46                                 return 0;
  47                         }
  48                 }
  49                 return -1;
  50         }
  51
  52         return 0;
  53 }
  54
  55 int thor_save_env(char *str)
  56 {
  57         block_dev_desc_t *p_block_dev;
  58         disk_partition_t part_info;
  59         int ret;
  60
  61         p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
  62         if (!p_block_dev)
  63                 return -1;
  64
  65         ret = tizen_get_partition_info_by_name(p_block_dev, L"param", &part_info);
  66         if (ret < 0)
  67                 return -1;
  68
  69 #ifndef CONFIG_TIZEN_LPM_SUPPORT
  70         return ret;
  71 #else
  72         ret = Emmc_Write(PARTITION_USER, part_info.start, 1, (uint8 *)str);
  73
  74         return ret;
  75 #endif
  76 }
  77
  78 static int thor_get_env(char *str)
  79 {
  80         block_dev_desc_t *p_block_dev;
  81         disk_partition_t part_info;
  82         int ret;
  83
  84         p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
  85         if (!p_block_dev)
  86                 return -1;
  87
  88         ret = tizen_get_partition_info_by_name(p_block_dev, L"param", &part_info);
  89         if (ret < 0)
  90                 return ret;
  91
  92         ret = Emmc_Read(PARTITION_USER, part_info.start, 1, (uint8 *)str);
  93         if (!ret)
  94                 return -1;
  95
  96         return 0;
  97 }
  98
  99 enum tizen_pm_state check_pm_status(void)
 100 {
 101         enum tizen_pm_state state = PM_STATE_NORMAL;
 102         char str[EMMC_SECTOR_SIZE];
 103         int ret;
 104
 105         ret = thor_get_env(str);
 106
 107         if (!ret) {
 108                 if (!strncmp(str, "thor", strlen("thor")))
 109                         return state;
 110         }
 111
 112 #ifndef CONFIG_TIZEN_LPM_SUPPORT
 113         return state;
 114 #else
 115         if (charger_connected()) {
 116                 int adp_type = sprdchg_charger_is_adapter();
 117
 118                 switch (adp_type) {
 119                 case ADP_TYPE_CDP:
 120                 case ADP_TYPE_DCP:
 121                 case ADP_TYPE_SDP:
 122                         state = PM_STATE_LPM;
 123                         break;
 124                 }
 125         }
 126
 127         return state;
 128 #endif
 129 }
 130
 131 unsigned int tizen_get_part_num(const char *part_name)
 132 {
 133         block_dev_desc_t *p_block_dev;
 134         int i, ret;
 135
 136         p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
 137         if (!p_block_dev)
 138                 return -1;
 139
 140         ret = get_partition_num_by_name(p_block_dev, part_name);
 141         if (ret < 0) {
 142                 for (i = 0; i < ARRAY_SIZE(thor_part_map); i++) {
 143                         if (!strcmp(part_name, thor_part_map[i].part_name))
 144                                 return thor_part_map[i].part_num;
 145                 }
 146                 return -1;
 147         }
 148
 149         return ret;
 150 }
 151
 152 unsigned int tizen_get_part_info(const char *name, struct thor_part_info *info)
 153 {
 154         block_dev_desc_t *p_block_dev;
 155         disk_partition_t part_info;
 156         wchar_t partition_name[MAX_UTF_PARTITION_NAME_LEN];
 157         int i, ret;
 158
 159         p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
 160         if (!p_block_dev)
 161                 return -1;
 162
 163         for (i = 0; i < MAX_UTF_PARTITION_NAME_LEN; i++) {
 164                 partition_name[i] = name[i];
 165                 if (!name[i])
 166                         break;
 167         }
 168
 169         ret = tizen_get_partition_info_by_name(p_block_dev, partition_name, &part_info);
 170         if (ret < 0) {
 171                 info->valid = 0;
 172                 return -1;
 173         }
 174
 175         if (!strcmp(name, PARTS_BOOT))
 176                 info->erase = 1;
 177         else
 178                 info->erase = 0;
 179
 180         info->offset = part_info.start;
 181         info->size = part_info.size;
 182         info->blksz = part_info.blksz;
 183         info->valid = 1;
 184
 185         return ret;
 186 }
 187
 188 unsigned int thor_get_part_info(struct thor_part_info *part_info, const char *name)
 189 {
 190         int i;
 191         char *orig_name, *file_name;
 192
 193         orig_name = strdup(name);
 194         if (!orig_name)
 195                 return -1;
 196
 197         file_name = strtok(orig_name, ".");
 198         if (!file_name)
 199                 goto out;
 200
 201         for (i = 0; i < ARRAY_SIZE(thor_part_map); i++) {
 202                 if (!strcmp(file_name, thor_part_map[i].file_name)) {
 203                         free(orig_name);
 204                         return tizen_get_part_info(thor_part_map[i].part_name, part_info);
 205                 }
 206         }
 207
 208 out:
 209         free(orig_name);
 210         return -1;
 211 }
 212
 213 void tizen_get_emmc_serial_number(unsigned int *uid) {
 214         unsigned char *regCID = get_global_cid();
 215         int v_index = 0;
 216
 217         for (v_index = 0; v_index < 4; v_index++)
 218         {
 219                 uid[v_index] = (unsigned int)(regCID[(v_index * 4)]) << 24 |
 220                                         (unsigned int)(regCID[(v_index * 4) + 1]) << 16 |
 221                                         (unsigned int)(regCID[(v_index * 4) + 2]) << 8 |
 222                                         (unsigned int)(regCID[(v_index * 4) + 3]);
 223         }
 224 }
 225
 226 unsigned int tizen_board_key_scan(void)
 227 {
 228         unsigned int s_int_status = REG_KPD_INT_RAW_STATUS;
 229         unsigned int s_key_status = REG_KPD_KEY_STATUS;
 230         unsigned int scan_code = 0;
 231
 232         if(s_key_status &KPD1_KEY_STS)
 233                 scan_code = (uint32_t)(s_key_status & (KPD1_KEY_STS | KPD1_ROW_CNT | KPD1_COL_CNT));
 234
 235         /* get volumn_down_status2 */
 236         if(get_volumn_down_status2())
 237                 scan_code += 0x90;
 238
 239         if(s_int_status)
 240                 REG_KPD_INT_CLR = KPD_INT_ALL;
 241
 242         /*
 243          *      VOL_UP = 0x80
 244          *      VOL_DOWN = 0x122
 245          *      HOME = 0x81
 246          *      PWR = 0x82
 247          *      PWR + VOL_DOWN = 0x112
 248          *      PWR + VOLDOWN + HOME = 0x111
 249          */
 250         printf("[tizen] scan code: 0x%x\n", scan_code);
 251         return scan_code;
 252 }
 253 #define TIZEN_KEY_VOLUP                         0x80
 254 #define TIZEN_KEY_VOLDN                         0x122
 255 #define TIZEN_KEY_HOME                          0x81
 256 #define TIZEN_KEY_PWR                           0x82
 257
 258 #define TIZEN_KEY_VOLDN_HOME_PWR        0x111
 259 #define TIZEN_KEY_VOLDN_PWR                     0x112
 260
 261 boot_mode_enum_type tizen_check_keypad(void)
 262 {
 263         unsigned int scan_code;
 264
 265         scan_code = tizen_board_key_scan();
 266
 267         switch (scan_code) {
 268         case TIZEN_KEY_VOLDN_HOME_PWR:
 269                 return CMD_THOR_MODE;
 270         case TIZEN_KEY_VOLDN_PWR:
 271                 return CMD_FASTBOOT_MODE;
 272         default:
 273                 return CMD_NORMAL_MODE;
 274         }
 275
 276         return CMD_NORMAL_MODE;
 277 }
 278
 279 typedef struct _NV_Update{
 280     uint32 nv_id;
 281     void   (*update)(void);
 282 } NV_Update_T;
 283
 284 typedef enum _NV_UPDATE_ERR_E
 285 {
 286     ERR_FIXNV_NONE,                    /* normal start */
 287     ERR_UPDATE_OK,              /* fixnv update successfully, back up some items */
 288     ERR_FIXNV_INITCPY,          /* fixnv not exist, init copy from dlnv */
 289     ERR_FIXNV_UPDATENOBACKUP,  /* copy from dlnv to fixnv , nothing backup */
 290     ERR_FIXNV_ERR_STRUCT,
 291     ERR_FIXNV_ERR_DATE,
 292     ERR_FIXNV_ERR_BACKUP_CNT,
 293     ERR_DLNV_NOTEXIST,          /* maybe DLNV be crashed in AP */
 294     ERR_FIXNV_NOTEXIST,
 295     ERR_FIXNV_CRC_FAILURE,
 296     ERR_FIXNV_UPDATE_FAILURE,
 297     ERR_FIXNV_UPDATE_CPY,
 298     ERR_FIXNV_POINTER_ERR,
 299     ERR_LAST
 300 } NV_UPDATE_ERR_E;
 301
 302 typedef enum _CRC_CHECK_ERR_E
 303 {
 304         ERROR_NONE,
 305         ERROR_DATE,
 306         ERROR_STRUCT,
 307         ERROR_MAX
 308 }CRC_CHECK_ERR;
 309
 310 typedef struct
 311 {
 312     uint16 nvitem_id;
 313     uint16 nv_length;
 314     uint32 nv_offset;
 315 } _NVITEM_SCAN_T;
 316
 317
 318 int runtimenv_read_with_backup(void)
 319 {
 320         char *bakbuf = NULL;
 321         char *oribuf = NULL;
 322         u8 status = 0;
 323         char header[SECTOR_SIZE];
 324         unsigned int checksum = 0;
 325         nv_header_t * header_p = NULL;
 326         void *runtimenv_adr;
 327         int ret;
 328
 329         block_dev_desc_t *p_block_dev;
 330         disk_partition_t part_info;
 331
 332         runtimenv_adr = (void *)WRUNTIMENV_ADR;
 333
 334         p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
 335         if (!p_block_dev)
 336                 return -1;
 337
 338         ret = tizen_get_partition_info_by_name(p_block_dev, L"runtimenv1", &part_info);
 339         if (ret < 0)
 340                 return -1;
 341
 342         header_p = (nv_header_t *)header;
 343         bakbuf = malloc(RUNTIMENV_SIZE + SECTOR_SIZE);
 344
 345         if(bakbuf)
 346                 memset(bakbuf, 0xff, RUNTIMENV_SIZE + SECTOR_SIZE);
 347         else
 348                 return -1;
 349
 350         oribuf = malloc(RUNTIMENV_SIZE + SECTOR_SIZE);
 351
 352         if(oribuf) {
 353                 memset(oribuf,0xff, RUNTIMENV_SIZE + SECTOR_SIZE);
 354         } else {
 355                 printf("%s: oribuf malloc failed\n", __func__);
 356                 free(bakbuf);
 357                 return -1;
 358         }
 359
 360         //mmc_bread((u8 *)oribuf, base_sector, RUNTIMENV_SIZE);
 361         ret = Emmc_Read(PARTITION_USER, part_info.start, RUNTIMENV_SIZE / SECTOR_SIZE, (uint8 *)oribuf);
 362         if (!ret) {
 363                 free(bakbuf);
 364                 free(oribuf);
 365                 return -1;
 366         }
 367
 368         memset(header, 0, SECTOR_SIZE);
 369         memcpy(header, oribuf, SECTOR_SIZE);
 370         checksum = header_p->checksum;
 371
 372         printf("runtimenv_read_with_backup origin checksum 0x%x\n", checksum);
 373         if (_chkNVEcc((uint8_t *)oribuf + SECTOR_SIZE, RUNTIMENV_SIZE, checksum)) {
 374                 memcpy(runtimenv_adr,oribuf+SECTOR_SIZE,RUNTIMENV_SIZE);
 375                 status += 1;
 376         }
 377
 378         ret = tizen_get_partition_info_by_name(p_block_dev, L"runtimenv2", &part_info);
 379         if (ret < 0) {
 380                 free(bakbuf);
 381                 free(oribuf);
 382                 return -1;
 383         }
 384
 385         //mmc_bread((u8 *)bakbuf, base_sector, RUNTIMENV_SIZE);
 386         ret = Emmc_Read(PARTITION_USER, part_info.start, RUNTIMENV_SIZE / SECTOR_SIZE, (uint8 *)bakbuf);
 387         if (!ret) {
 388                 free(bakbuf);
 389                 free(oribuf);
 390                 return -1;
 391         }
 392
 393         memset(header, 0, SECTOR_SIZE);
 394         memcpy(header, bakbuf, SECTOR_SIZE);
 395
 396         checksum = header_p->checksum;
 397         printf("runtime_read_with_backup backup checksum 0x%x\n", checksum);
 398
 399         if(_chkNVEcc((uint8_t *)bakbuf + SECTOR_SIZE, RUNTIMENV_SIZE, checksum)) {
 400                 memcpy(runtimenv_adr,bakbuf+SECTOR_SIZE,RUNTIMENV_SIZE);
 401                 status += 1 << 1;
 402         }
 403
 404         switch(status) {
 405         case 0:
 406                 printf("both org and bak partition are damaged!\n");
 407                 free(bakbuf);
 408                 free(oribuf);
 409                 return -1;
 410         case 1:
 411                 printf("bak partition is damaged!\n");
 412 //              mmc_bwrite((u8 *)oribuf, base_sector, (RUNTIMENV_SIZE+SECTOR_SIZE));
 413                 Emmc_Write(PARTITION_USER, part_info.start, (RUNTIMENV_SIZE + SECTOR_SIZE) / SECTOR_SIZE, (uint8 *)oribuf);
 414                 break;
 415         case 2:
 416                 printf("org partition is damaged!\n!");
 417                 memcpy(runtimenv_adr, bakbuf + SECTOR_SIZE, RUNTIMENV_SIZE);
 418
 419                 ret = tizen_get_partition_info_by_name(p_block_dev, L"runtimenv1", &part_info);
 420                 if (ret < 0) {
 421                         free(bakbuf);
 422                         free(oribuf);
 423                         return -1;
 424                 }
 425
 426                 Emmc_Write(PARTITION_USER, part_info.start, (RUNTIMENV_SIZE + SECTOR_SIZE) / SECTOR_SIZE, (uint8 *)bakbuf);
 427                 break;
 428         case 3:
 429                 printf("both org and bak partition are ok!\n");
 430                         break;
 431         }
 432
 433         free(bakbuf);
 434         free(oribuf);
 435
 436         return 0;
 437 }
 438
 439 int fixnv_read_with_backup(void)
 440 {
 441         void *fixnv_adr = (void *)WFIXNV_ADR;
 442         nv_header_t * header_p = NULL;
 443         nv_header_t *tmp_header_p = NULL;
 444         unsigned char status = 0;
 445         char tmp_header[SECTOR_SIZE];
 446         char header[SECTOR_SIZE];
 447         char *tmpbuf = NULL;
 448         char *bakbuf = NULL;
 449         char *oribuf = NULL;
 450         int ret;
 451         unsigned int checksum = 0;
 452         unsigned int nv_updated = 0;
 453         unsigned int nv_magic = 0;
 454
 455         block_dev_desc_t *p_block_dev;
 456         disk_partition_t part_info;
 457
 458         p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
 459         if (!p_block_dev)
 460                 return -1;
 461
 462         ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv2", &part_info);
 463         if (ret < 0)
 464                 return -1;
 465
 466         tmp_header_p = (nv_header_t *)tmp_header;
 467         tmpbuf = malloc(FIXNV_SIZE + SECTOR_SIZE);
 468         memset(tmp_header, 0, SECTOR_SIZE);
 469
 470 //      mmc_bread((u8 *)tmpbuf, ppi->blkstart, FIXNV_SIZE+SECTOR_SIZE);
 471         ret = Emmc_Read(PARTITION_USER, part_info.start, (FIXNV_SIZE + SECTOR_SIZE) / SECTOR_SIZE, (uint8 *)tmpbuf);
 472         if (!ret)
 473                 return -1;
 474
 475         memcpy(tmp_header, tmpbuf, SECTOR_SIZE);
 476
 477         if (tmp_header_p->magic != NV_HEAD_MAGIC) {
 478                 tmp_header_p->magic = NV_HEAD_MAGIC;
 479                 tmp_header_p->len = FIXNV_SIZE;
 480                 tmp_header_p->checksum = (unsigned long)calc_checksum((unsigned char *)tmpbuf, FIXNV_SIZE);
 481                 tmp_header_p->version = NV_VERSION;
 482                 tmp_header_p->updated = NV_UPDATED;
 483
 484                 Emmc_Erase(PARTITION_USER, part_info.start, ((FIXNV_SIZE + SECTOR_SIZE) / SECTOR_SIZE));
 485
 486 //              mmc_bwrite(tmp_header,ppi->blkstart,SECTOR_SIZE);
 487 //              mmc_bwrite(tmpbuf,ppi->blkstart+1,FIXNV_SIZE);
 488                 Emmc_Write(PARTITION_USER, part_info.start, 1, (uint8 *)tmp_header);
 489                 Emmc_Write(PARTITION_USER, part_info.start + 1, FIXNV_SIZE / SECTOR_SIZE, (uint8 *)tmpbuf);
 490         }
 491
 492         free(tmpbuf);
 493
 494         ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv1", &part_info);
 495         if (ret < 0)
 496                 return -1;
 497
 498         header_p = (nv_header_t *)header;
 499         bakbuf = malloc(FIXNV_SIZE + SECTOR_SIZE);
 500
 501         if (bakbuf)
 502                 memset(bakbuf, 0xff, FIXNV_SIZE + SECTOR_SIZE);
 503         else
 504                 return -1;
 505
 506         oribuf = malloc(FIXNV_SIZE + SECTOR_SIZE);
 507         if(oribuf) {
 508                 memset(oribuf,0xff, FIXNV_SIZE + SECTOR_SIZE);
 509         } else {
 510                 free(bakbuf);
 511                 return -1;
 512         }
 513
 514         printf("loading fixnv1 from %lx(%x) to %lx\n", part_info.start, FIXNV_SIZE, (unsigned long)fixnv_adr);
 515
 516         //mmc_bread((u8 *)oribuf, base_sector, FIXNV_SIZE);
 517         ret = Emmc_Read(PARTITION_USER, part_info.start, FIXNV_SIZE / SECTOR_SIZE, (uint8 *)oribuf);
 518         if (!ret) {
 519                 free(bakbuf);
 520                 free(oribuf);
 521                 return -1;
 522         }
 523
 524         memset(header, 0, SECTOR_SIZE);
 525         memcpy(header, oribuf, SECTOR_SIZE);
 526         checksum = header_p->checksum;
 527
 528         printf("nv_read_with_backup origin checksum 0x%x\n", checksum);
 529         if (_chkNVEcc((uint8_t *)oribuf + SECTOR_SIZE, FIXNV_SIZE, checksum)) {
 530                 memcpy(fixnv_adr, oribuf + SECTOR_SIZE, FIXNV_SIZE);
 531                 status += 1;
 532         }
 533         nv_magic = header_p->magic;
 534
 535         printf("fixnv1 header magic 0x%x\n",nv_magic);
 536         if(nv_magic != NV_HEAD_MAGIC)
 537                 status = 0;
 538
 539         ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv2", &part_info);
 540         if (ret < 0) {
 541                 free(bakbuf);
 542                 free(oribuf);
 543                 return -1;
 544         }
 545
 546         printf("loading fixnv2 from %lx(%x) to %lx\n", part_info.start, FIXNV_SIZE, (unsigned long)fixnv_adr);
 547         //mmc_bread((u8 *)bakbuf, base_sector, FIXNV_SIZE);
 548         ret = Emmc_Read(PARTITION_USER, part_info.start, FIXNV_SIZE / SECTOR_SIZE, (uint8 *)bakbuf);
 549         if (!ret)
 550                 return -1;
 551
 552         memset(header, 0, SECTOR_SIZE);
 553         memcpy(header, bakbuf, SECTOR_SIZE);
 554
 555         nv_updated = header_p->updated;
 556         printf("nv_updated: %x, NV_UPDATED: %x\n", nv_updated, NV_UPDATED);
 557         printf("nv1_magic: %x, NV_HEAD_MAGIC: %x\n", nv_magic, NV_HEAD_MAGIC);
 558
 559         if ((nv_updated == NV_UPDATED) && (nv_magic == NV_HEAD_MAGIC)) {
 560 #if NV_BACKUP
 561                 unsigned int nv_backup_status = ERR_FIXNV_NONE;
 562 #endif
 563                 char *bakbuf_update = NULL;
 564                 char *oribuf_update = NULL;
 565
 566                 printf("updated nvitem !!\n");
 567                 // 1. load fixnv1 to oribuf
 568                 oribuf_update = malloc(FIXNV_SIZE);
 569                 if (!oribuf_update) {
 570                         printf("%s: oribuf_update malloc failed\n", __func__);
 571                         free(bakbuf);
 572                         free(oribuf);
 573                         return -1;
 574                 }
 575
 576                 memset(oribuf_update, 0xff, FIXNV_SIZE);
 577                 memcpy(oribuf_update, oribuf + SECTOR_SIZE, FIXNV_SIZE);
 578
 579                 // 2. load fixnv2 to backbuf
 580                 bakbuf_update = malloc(FIXNV_SIZE);
 581
 582                 if (!bakbuf_update) {
 583                         printf("%s: bakbuf_update malloc failed\n", __func__);
 584                         free(bakbuf);
 585                         free(oribuf);
 586                         free(oribuf_update);
 587                         return -1;
 588                 }
 589
 590                 memset(bakbuf_update, 0xff, FIXNV_SIZE);
 591                 memcpy(bakbuf_update, bakbuf + SECTOR_SIZE, FIXNV_SIZE);
 592
 593 #if NV_BACKUP
 594                 /* TODO */
 595 //              nv_backup_status = modem_update_fixnv_image(bakbuf_update, oribuf_update);
 596                 printf("nv_backup_status = %d \n", nv_backup_status);
 597
 598                 switch (nv_backup_status) {
 599                 case ERR_FIXNV_NONE:
 600                 case ERR_UPDATE_OK:
 601                 case ERR_FIXNV_INITCPY:
 602                 case ERR_FIXNV_UPDATE_CPY:
 603                         printf("nv update is succeeded.\n");
 604 #endif
 605
 606                         header_p = (nv_header_t *)header;
 607                         header_p->magic = NV_HEAD_MAGIC;
 608                         header_p->len = FIXNV_SIZE;
 609                         header_p->checksum = (unsigned long)calc_checksum((unsigned char *)oribuf_update,FIXNV_SIZE);
 610                         header_p->version = NV_VERSION;
 611                         header_p->updated = 0x0;
 612
 613                         ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv1", &part_info);
 614                         if (ret < 0) {
 615                                 free(bakbuf);
 616                                 free(oribuf);
 617                                 free(bakbuf_update);
 618                                 free(oribuf_update);
 619                                 return -1;
 620                         }
 621
 622                         //mmc_bwrite(header, ppi->blkstart, SECTOR_SIZE);
 623                         //mmc_bwrite(oribuf_update, (ppi->blkstart+1), FIXNV_SIZE);
 624                         Emmc_Write(PARTITION_USER, part_info.start, 1, (uint8 *)header);
 625                         Emmc_Write(PARTITION_USER, part_info.start + 1, FIXNV_SIZE / SECTOR_SIZE, (uint8 *)oribuf_update);
 626
 627                         ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv2", &part_info);
 628                         if (ret < 0) {
 629                                 free(bakbuf);
 630                                 free(oribuf);
 631                                 free(bakbuf_update);
 632                                 free(oribuf_update);
 633                                 return -1;
 634                         }
 635
 636                         //mmc_bwrite(header, ppi->blkstart, SECTOR_SIZE);
 637                         //mmc_bwrite(oribuf_update, (ppi->blkstart+1), FIXNV_SIZE);
 638                         Emmc_Write(PARTITION_USER, part_info.start, 1, (uint8 *)header);
 639                         Emmc_Write(PARTITION_USER, part_info.start + 1, FIXNV_SIZE / SECTOR_SIZE, (uint8 *)oribuf_update);
 640
 641                         memset(fixnv_adr, 0xff, FIXNV_SIZE);
 642                         memcpy(fixnv_adr, oribuf_update, FIXNV_SIZE);
 643 #if NV_BACKUP
 644                         break;
 645                 default:
 646                         printf("nv update is failed. Original NV will be NV partitions.\n");
 647                         header_p->checksum = 0x0;
 648                         header_p->updated = 0x1;
 649
 650                         ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv2", &part_info);
 651                         if (ret < 0) {
 652                                 free(bakbuf);
 653                                 free(oribuf);
 654                                 free(bakbuf_update);
 655                                 free(oribuf_update);
 656                                 return -1;
 657                         }
 658                         //mmc_bwrite(header, ppi->blkstart, SECTOR_SIZE);
 659                         Emmc_Write(PARTITION_USER, part_info.start, 1, (uint8 *)header);
 660                         memcpy(fixnv_adr, oribuf_update, FIXNV_SIZE);
 661                 }
 662 #endif
 663
 664                 free(bakbuf_update);
 665                 free(oribuf_update);
 666         } else {
 667                 checksum = header_p->checksum;
 668                 printf("nv_read_with_backup backup checksum 0x%x\n", checksum);
 669                 if (_chkNVEcc((uint8_t *)bakbuf + SECTOR_SIZE, FIXNV_SIZE, checksum)) {
 670                         memcpy(fixnv_adr, bakbuf + SECTOR_SIZE,FIXNV_SIZE);
 671                         status += 1<<1;
 672                 }
 673
 674                 switch(status) {
 675                 case 0:
 676                         printf("both org and bak partition are damaged!\n");
 677                         free(bakbuf);
 678                         free(oribuf);
 679                         return -1;
 680                 case 1:
 681                         printf("bak partition is damaged!\n");
 682                         //mmc_bwrite((u8 *)oribuf, base_sector, (FIXNV_SIZE+SECTOR_SIZE));
 683                         Emmc_Write(PARTITION_USER, part_info.start, (FIXNV_SIZE + SECTOR_SIZE) / SECTOR_SIZE, (uint8 *)oribuf);
 684
 685                         break;
 686                 case 2:
 687                         printf("org partition is damaged!\n!");
 688                         memcpy(fixnv_adr, bakbuf+SECTOR_SIZE, FIXNV_SIZE);
 689
 690                         ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv1", &part_info);
 691                         if (ret < 0) {
 692                                 free(bakbuf);
 693                                 free(oribuf);
 694                                 return -1;
 695                         }
 696                         //mmc_bwrite((u8 *)bakbuf, base_sector, (FIXNV_SIZE+SECTOR_SIZE));
 697                         Emmc_Write(PARTITION_USER, part_info.start, (FIXNV_SIZE + SECTOR_SIZE) / SECTOR_SIZE, (uint8 *)bakbuf);
 698                         break;
 699                 case 3:
 700                         printf("both org and bak partition are ok!\n");
 701                         break;
 702                 }
 703         }
 704
 705         free(bakbuf);
 706         free(oribuf);
 707
 708         return 0;
 709 }
 710
 711 int load_nvitem(void)
 712 {
 713         int ret;
 714         ret = fixnv_read_with_backup();
 715         if (ret < 0)
 716                 return ret;
 717
 718         ret = runtimenv_read_with_backup();
 719         if (ret < 0)
 720                 return ret;
 721
 722         return 0;
 723 }
 724
 725 int load_modem_data(void)
 726 {
 727         block_dev_desc_t *p_block_dev;
 728         disk_partition_t part_info;
 729         int ret = 0;
 730 #if BIN_SIZE_LEFT
 731         u32 left;
 732 #endif
 733         u32 nsct;
 734         unsigned char *buf = (void *)WMODEM_ADR;
 735
 736         printf("load modem to addr 0x%08lx\n", (unsigned long)buf);
 737
 738         nsct = WMODEM_SIZE / EMMC_SECTOR_SIZE;
 739 #if BIN_SIZE_LEFT
 740         /* size of the image is multiple of emmc sector size, so no need to check it */
 741         left = WMODEM_SIZE % EMMC_SECTOR_SIZE;
 742 #endif
 743
 744         p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
 745         if (!p_block_dev)
 746                 return -1;
 747
 748         ret = tizen_get_partition_info_by_name(p_block_dev, L"modem", &part_info);
 749         if (ret < 0)
 750                 return -1;
 751
 752         ret = Emmc_Read(PARTITION_USER, part_info.start, nsct, (uint8 *)buf);
 753         if (!ret)
 754                 return -1;
 755
 756 #if BIN_SIZE_LEFT
 757         if (left) {
 758                 char *sctbuf = sctbuf = malloc(EMMC_SECTOR_SIZE);
 759                 if (!sctbuf)
 760                         return -1;
 761
 762                 ret = Emmc_Read(PARTITION_USER, part_info.start + nsct, 1, (uint8 *)sctbuf);
 763                 if (ret)
 764                         memcpy(buf + (nsct * EMMC_SECTOR_SIZE), sctbuf, left);
 765                 free(sctbuf);
 766         }
 767 #endif
 768
 769         printf("partition; modem read success!\n");
 770
 771         return 0;
 772 }
 773
 774 int load_dsp_data(void)
 775 {
 776         block_dev_desc_t *p_block_dev;
 777         disk_partition_t part_info;
 778         int ret = 0;
 779 #if BIN_SIZE_LEFT
 780         u32 left;
 781 #endif
 782         u32 nsct;
 783         unsigned char *buf = (void *)WDSP_ADR;
 784
 785         printf("load dsp to addr 0x%08lx\n", (unsigned long)buf);
 786
 787         nsct = WDSP_SIZE / EMMC_SECTOR_SIZE;
 788 #if BIN_SIZE_LEFT
 789         /* size of the image is multiple of emmc sector size, so no need to check it */
 790         left = WDSP_SIZE % EMMC_SECTOR_SIZE;
 791 #endif
 792
 793         p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
 794         if (!p_block_dev)
 795                 return -1;
 796
 797         ret = tizen_get_partition_info_by_name(p_block_dev, L"dsp", &part_info);
 798         if (ret < 0)
 799                 return -1;
 800
 801         ret = Emmc_Read(PARTITION_USER, part_info.start, nsct, (uint8 *)buf);
 802         if (!ret)
 803                 return -1;
 804
 805 #if BIN_SIZE_LEFT
 806         if (left) {
 807                 char *sctbuf = malloc(EMMC_SECTOR_SIZE);
 808                 if (!sctbuf)
 809                         return -1;
 810
 811                 ret = Emmc_Read(PARTITION_USER, part_info.start + nsct, 1, (uint8 *)sctbuf);
 812                 if (ret)
 813                         memcpy(buf + (nsct * EMMC_SECTOR_SIZE), sctbuf, left);
 814                 free(sctbuf);
 815         }
 816 #endif
 817
 818         printf("partition; dsp read success!\n");
 819
 820         return 0;
 821 }
 822
 823 int get_image_signature(struct sig_header *hdr, unsigned int base_addr,
 824                                                 unsigned int size)
 825 {
 826         memcpy((void *)hdr, (const void *)(base_addr + size - HDR_SIZE),
 827                 HDR_SIZE);
 828
 829         if (hdr->magic != HDR_BOOT_MAGIC)
 830                 return -EFAULT;
 831
 832         return 0;
 833 }
 834
 835 static int load_binary_to_addr(char *name, unsigned int addr, unsigned int size)
 836 {
 837         struct thor_part_info info;
 838         int ret;
 839
 840         ret = tizen_get_part_info(name, &info);
 841         if (ret < 0)
 842                 return ret;
 843
 844         ret = Emmc_Read(PARTITION_USER, info.offset, size / info.blksz, (uint8 *)addr);
 845         if (!ret)
 846                 return -1;
 847
 848         return 0;
 849 }
 850
 851 int load_ramdisk(char *name, unsigned int base_addr, unsigned int size)
 852 {
 853         return load_binary_to_addr(name, base_addr, size);
 854 }
 855
 856 int check_board_signature(char *fname, unsigned int dn_addr, unsigned int size)
 857 {
 858         struct sig_header bh_target;
 859         struct sig_header bh_addr;
 860         char bl_buf[CONFIG_SIG_IMAGE_SIZE];
 861         int ret;
 862
 863         /* only check u-boot-mmc.bin */
 864         if (strcmp(fname, "u-boot-mmc"))
 865                 return 0;
 866
 867         /* can't found signature in target - download continue */
 868         ret = load_binary_to_addr(PARTS_BOOT, (unsigned int)(unsigned long)bl_buf, CONFIG_SIG_IMAGE_SIZE);
 869         if (ret < 0)
 870                 return 0;
 871
 872         ret = get_image_signature(&bh_target, (unsigned int)(unsigned long)bl_buf, CONFIG_SIG_IMAGE_SIZE);
 873         if (ret)
 874                 return 0;
 875
 876         if (size != CONFIG_SIG_IMAGE_SIZE) {
 877                 printf("Bad file size for: %s.\n", fname);
 878                 printf("Expected: %#x bytes, has: %#x bytes.\n",
 879                        CONFIG_SIG_IMAGE_SIZE, (unsigned)size);
 880                 return -EINVAL;
 881         }
 882
 883         /* can't found signature in address - download stop */
 884         ret = get_image_signature(&bh_addr, dn_addr, CONFIG_SIG_IMAGE_SIZE);
 885         if (ret) {
 886                 printf("signature not found.\n");
 887                 return -EFAULT;
 888         }
 889
 890         if (strncmp(bh_target.bd_name, bh_addr.bd_name,
 891                     ARRAY_SIZE(bh_target.bd_name))) {
 892                 printf("Invalid!\n");
 893                 return -EPERM;
 894         }
 895
 896         return 0;
 897 }
 898
 899 unsigned int tizen_get_jig_state(void)
 900 {
 901         int pin_data;
 902
 903         /* read attached device. */
 904         pin_data = ANA_REG_GET(ADI_EIC_DATA);
 905         return pin_data & (1 << 1);
 906 }