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