2 #include <sprd_battery.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>
16 static void convert_to_string(wchar_t *crap, char *buf)
18 while (*buf++ = (char)*crap++);
21 int tizen_get_partition_info_by_name (block_dev_desc_t *dev_desc,
22 wchar_t* partition_name, disk_partition_t *info)
25 char part_name[72 / sizeof(unsigned short)];
27 ret = get_partition_info_by_name(dev_desc, partition_name, info);
29 convert_to_string(partition_name, part_name);
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;
45 int thor_save_env(char *str)
47 block_dev_desc_t *p_block_dev;
48 disk_partition_t part_info;
51 p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
55 ret = tizen_get_partition_info_by_name(p_block_dev, L"param", &part_info);
59 #ifndef CONFIG_TIZEN_LPM_SUPPORT
62 ret = Emmc_Write(PARTITION_USER, part_info.start, 1, str);
67 char *thor_get_env(void)
69 block_dev_desc_t *p_block_dev;
70 disk_partition_t part_info;
71 char str[EMMC_SECTOR_SIZE];
74 p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
78 ret = tizen_get_partition_info_by_name(p_block_dev, L"param", &part_info);
82 ret = Emmc_Read(PARTITION_USER, part_info.start, 1, str);
89 enum tizen_pm_state check_pm_status(void)
91 enum tizen_pm_state state = PM_STATE_NORMAL;
92 char *str = thor_get_env();
94 #ifndef CONFIG_TIZEN_LPM_SUPPORT
95 return PM_STATE_NORMAL;
99 if (!strncmp(str, "thor", strlen("thor")))
100 return PM_STATE_NORMAL;
103 if (charger_connected()) {
104 int adp_type = sprdchg_charger_is_adapter();
110 state = PM_STATE_LPM;
118 unsigned int tizen_get_part_num(const char *part_name)
120 block_dev_desc_t *p_block_dev;
123 p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
127 ret = get_partition_num_by_name(p_block_dev, part_name);
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;
139 unsigned int tizen_get_part_info(const char *name, struct thor_part_info *info)
141 block_dev_desc_t *p_block_dev;
142 disk_partition_t part_info;
143 wchar_t partition_name[MAX_UTF_PARTITION_NAME_LEN];
146 p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
150 for (i = 0; i < MAX_UTF_PARTITION_NAME_LEN; i++) {
151 partition_name[i] = name[i];
156 ret = tizen_get_partition_info_by_name(p_block_dev, partition_name, &part_info);
162 if (!strcmp(name, PARTS_BOOT))
167 info->offset = part_info.start;
168 info->size = part_info.size;
169 info->blksz = part_info.blksz;
175 unsigned int thor_get_part_info(struct thor_part_info *part_info, const char *name)
178 const char *file_name = strtok(name, ".");
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);
188 void tizen_get_emmc_serial_number(unsigned int *uid) {
189 unsigned char *regCID = get_global_cid();
192 for (v_index = 0; v_index < 4; v_index++)
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]);
201 unsigned int tizen_board_key_scan(void)
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;
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));
211 /* get volumn_down_status2 */
212 if(get_volumn_down_status2())
216 REG_KPD_INT_CLR = KPD_INT_ALL;
223 * PWR + VOL_DOWN = 0x112
224 * PWR + VOLDOWN + HOME = 0x111
226 printf("[tizen] scan code: 0x%x\n", scan_code);
229 #define TIZEN_KEY_VOLUP 0x80
230 #define TIZEN_KEY_VOLDN 0x122
231 #define TIZEN_KEY_HOME 0x81
232 #define TIZEN_KEY_PWR 0x82
234 #define TIZEN_KEY_VOLDN_HOME_PWR 0x111
235 #define TIZEN_KEY_VOLDN_PWR 0x112
237 boot_mode_enum_type tizen_check_keypad(void)
239 unsigned int scan_code;
241 scan_code = tizen_board_key_scan();
244 case TIZEN_KEY_VOLDN_HOME_PWR:
245 return CMD_THOR_MODE;
246 case TIZEN_KEY_VOLDN_PWR:
247 return CMD_FASTBOOT_MODE;
249 return CMD_NORMAL_MODE;
252 return CMD_NORMAL_MODE;
255 typedef struct _NV_Update{
260 typedef enum _NV_UPDATE_ERR_E
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,
268 ERR_FIXNV_ERR_BACKUP_CNT,
269 ERR_DLNV_NOTEXIST, /* maybe DLNV be crashed in AP */
271 ERR_FIXNV_CRC_FAILURE,
272 ERR_FIXNV_UPDATE_FAILURE,
273 ERR_FIXNV_UPDATE_CPY,
274 ERR_FIXNV_POINTER_ERR,
278 typedef enum _CRC_CHECK_ERR_E
294 int runtimenv_read_with_backup(void)
299 char header[SECTOR_SIZE];
300 unsigned int checksum = 0;
301 nv_header_t * header_p = NULL;
302 unsigned int runtimenv_adr;
305 block_dev_desc_t *p_block_dev;
306 disk_partition_t part_info;
308 runtimenv_adr = WRUNTIMENV_ADR;
310 p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
314 ret = tizen_get_partition_info_by_name(p_block_dev, L"runtimenv1", &part_info);
318 header_p = (nv_header_t *)header;
319 bakbuf = malloc(RUNTIMENV_SIZE + SECTOR_SIZE);
322 memset(bakbuf, 0xff, RUNTIMENV_SIZE + SECTOR_SIZE);
326 oribuf = malloc(RUNTIMENV_SIZE + SECTOR_SIZE);
329 memset(oribuf,0xff, RUNTIMENV_SIZE + SECTOR_SIZE);
331 printf("%s: oribuf malloc failed\n", __func__);
336 //mmc_bread((u8 *)oribuf, base_sector, RUNTIMENV_SIZE);
337 ret = Emmc_Read(PARTITION_USER, part_info.start, RUNTIMENV_SIZE / SECTOR_SIZE, oribuf);
341 memset(header, 0, SECTOR_SIZE);
342 memcpy(header, oribuf, SECTOR_SIZE);
343 checksum = header_p->checksum;
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);
351 ret = tizen_get_partition_info_by_name(p_block_dev, L"runtimenv2", &part_info);
355 //mmc_bread((u8 *)bakbuf, base_sector, RUNTIMENV_SIZE);
356 ret = Emmc_Read(PARTITION_USER, part_info.start, RUNTIMENV_SIZE / SECTOR_SIZE, bakbuf);
360 memset(header, 0, SECTOR_SIZE);
361 memcpy(header, bakbuf, SECTOR_SIZE);
363 checksum = header_p->checksum;
364 printf("runtime_read_with_backup backup checksum 0x%x\n", checksum);
366 if(_chkNVEcc(bakbuf + SECTOR_SIZE, RUNTIMENV_SIZE, checksum)) {
367 memcpy(runtimenv_adr,bakbuf+SECTOR_SIZE,RUNTIMENV_SIZE);
373 printf("both org and bak partition are damaged!\n");
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);
383 printf("org partition is damaged!\n!");
384 memcpy(runtimenv_adr, bakbuf + SECTOR_SIZE, RUNTIMENV_SIZE);
386 ret = tizen_get_partition_info_by_name(p_block_dev, L"runtimenv1", &part_info);
390 Emmc_Write(PARTITION_USER, part_info.start, (RUNTIMENV_SIZE + SECTOR_SIZE) / SECTOR_SIZE, bakbuf);
393 printf("both org and bak partition are ok!\n");
403 int fixnv_read_with_backup(void)
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];
415 unsigned int checksum = 0;
416 unsigned int nv_updated = 0;
417 unsigned int nv_magic = 0;
419 block_dev_desc_t *p_block_dev;
420 disk_partition_t part_info;
422 p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
426 ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv2", &part_info);
430 tmp_header_p = (nv_header_t *)tmp_header;
431 tmpbuf = malloc(FIXNV_SIZE + SECTOR_SIZE);
432 memset(tmp_header, 0, SECTOR_SIZE);
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);
439 memcpy(tmp_header, tmpbuf, SECTOR_SIZE);
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;
448 Emmc_Erase(PARTITION_USER, part_info.start, ((FIXNV_SIZE + SECTOR_SIZE) / SECTOR_SIZE));
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);
458 ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv1", &part_info);
462 header_p = (nv_header_t *)header;
463 bakbuf = malloc(FIXNV_SIZE + SECTOR_SIZE);
466 memset(bakbuf, 0xff, FIXNV_SIZE + SECTOR_SIZE);
470 oribuf = malloc(FIXNV_SIZE + SECTOR_SIZE);
472 memset(oribuf,0xff, FIXNV_SIZE + SECTOR_SIZE);
478 printf("loading fixnv1 from %x(%x) to %x\n", part_info.start, FIXNV_SIZE, fixnv_adr);
480 //mmc_bread((u8 *)oribuf, base_sector, FIXNV_SIZE);
481 ret = Emmc_Read(PARTITION_USER, part_info.start, FIXNV_SIZE / SECTOR_SIZE, oribuf);
485 memset(header, 0, SECTOR_SIZE);
486 memcpy(header, oribuf, SECTOR_SIZE);
487 checksum = header_p->checksum;
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);
494 nv_magic = header_p->magic;
496 printf("fixnv1 header magic 0x%x\n",nv_magic);
497 if(nv_magic != NV_HEAD_MAGIC)
500 ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv2", &part_info);
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);
510 memset(header, 0, SECTOR_SIZE);
511 memcpy(header, bakbuf, SECTOR_SIZE);
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);
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;
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__);
532 memset(oribuf_update, 0xff, FIXNV_SIZE);
533 memcpy(oribuf_update, oribuf + SECTOR_SIZE, FIXNV_SIZE);
535 // 2. load fixnv2 to backbuf
536 bakbuf_update = malloc(FIXNV_SIZE);
538 if (!bakbuf_update) {
539 printf("%s: bakbuf_update malloc failed\n", __func__);
546 memset(bakbuf_update, 0xff, FIXNV_SIZE);
547 memcpy(bakbuf_update, bakbuf + SECTOR_SIZE, FIXNV_SIZE);
549 // nv_backup_status = modem_update_fixnv_image(bakbuf_update, oribuf_update);
550 printf("nv_backup_status = %d \n", nv_backup_status);
552 switch (nv_backup_status) {
555 case ERR_FIXNV_INITCPY:
556 case ERR_FIXNV_UPDATE_CPY:
557 printf("nv update is succeeded.\n");
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;
566 ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv1", &part_info);
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);
575 ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv2", &part_info);
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);
584 memset(fixnv_adr, 0xff, FIXNV_SIZE);
585 memcpy(fixnv_adr, oribuf_update, FIXNV_SIZE);
588 printf("nv update is failed. Original NV will be NV partitions.\n");
589 header_p->checksum = 0x0;
590 header_p->updated = 0x1;
592 ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv2", &part_info);
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);
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);
612 printf("both org and bak partition are damaged!\n");
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);
623 printf("org partition is damaged!\n!");
624 memcpy(fixnv_adr, bakbuf+SECTOR_SIZE, FIXNV_SIZE);
626 ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv1", &part_info);
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);
633 printf("both org and bak partition are ok!\n");
644 int load_nvitem(void)
647 ret = fixnv_read_with_backup();
651 ret = runtimenv_read_with_backup();
658 int load_modem_data(void)
660 block_dev_desc_t *p_block_dev;
661 disk_partition_t part_info;
666 unsigned char *buf = WMODEM_ADR;
671 printf("load modem to addr 0x%08x\n", buf);
673 nsct = WMODEM_SIZE / EMMC_SECTOR_SIZE;
674 left = WMODEM_SIZE % EMMC_SECTOR_SIZE;
676 p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
680 ret = tizen_get_partition_info_by_name(p_block_dev, L"modem", &part_info);
684 ret = Emmc_Read(PARTITION_USER, part_info.start, nsct, buf);
689 sctbuf = malloc(EMMC_SECTOR_SIZE);
693 ret = Emmc_Read(PARTITION_USER, part_info.start + nsct, 1, sctbuf);
695 memcpy(buf + (nsct * EMMC_SECTOR_SIZE), sctbuf, left);
699 printf("partition; modem read success!\n");
704 int load_dsp_data(void)
706 block_dev_desc_t *p_block_dev;
707 disk_partition_t part_info;
712 unsigned char *buf = WDSP_ADR;
717 printf("load dsp to addr 0x%08x\n", buf);
719 nsct = WDSP_SIZE / EMMC_SECTOR_SIZE;
720 left = WDSP_SIZE % EMMC_SECTOR_SIZE;
722 p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
726 ret = tizen_get_partition_info_by_name(p_block_dev, L"dsp", &part_info);
730 ret = Emmc_Read(PARTITION_USER, part_info.start, nsct, buf);
735 sctbuf = malloc(EMMC_SECTOR_SIZE);
739 ret = Emmc_Read(PARTITION_USER, part_info.start + nsct, 1, sctbuf);
741 memcpy(buf + (nsct * EMMC_SECTOR_SIZE), sctbuf, left);
745 printf("partition; dsp read success!\n");
750 int get_image_signature(struct sig_header *hdr, unsigned int base_addr,
753 memcpy((void *)hdr, (const void *)(base_addr + size - HDR_SIZE),
756 if (hdr->magic != HDR_BOOT_MAGIC)
762 static int load_binary_to_addr(char *name, unsigned int addr, unsigned int size)
764 struct thor_part_info info;
767 ret = tizen_get_part_info(name, &info);
771 ret = Emmc_Read(PARTITION_USER, info.offset, size / info.blksz, addr);
778 int check_board_signature(char *fname, unsigned int dn_addr, unsigned int size)
780 struct sig_header bh_target;
781 struct sig_header bh_addr;
782 char bl_buf[CONFIG_SIG_IMAGE_SIZE];
785 /* only check u-boot-mmc.bin */
786 if (strcmp(fname, "u-boot-mmc"))
789 /* can't found signature in target - download continue */
790 ret = load_binary_to_addr(PARTS_BOOT, bl_buf, CONFIG_SIG_IMAGE_SIZE);
794 ret = get_image_signature(&bh_target, bl_buf, CONFIG_SIG_IMAGE_SIZE);
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);
805 /* can't found signature in address - download stop */
806 ret = get_image_signature(&bh_addr, dn_addr, CONFIG_SIG_IMAGE_SIZE);
808 printf("signature not found.\n");
812 if (strncmp(bh_target.bd_name, bh_addr.bd_name,
813 ARRAY_SIZE(bh_target.bd_name))) {
814 printf("Invalid!\n");
821 unsigned int tizen_get_jig_state(void)
825 /* read attached device. */
826 pin_data = ANA_REG_GET(ADI_EIC_DATA);
827 return pin_data & (1 << 1);