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 #ifdef CONFIG_TIZEN_LPM_SUPPORT
17 extern int charger_connected(void);
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);
24 static void convert_to_string(wchar_t *crap, char *buf)
27 *buf++ = (char)*crap++;
31 int tizen_get_partition_info_by_name (block_dev_desc_t *dev_desc,
32 wchar_t* partition_name, disk_partition_t *info)
35 char part_name[72 / sizeof(unsigned short)];
37 ret = get_partition_info_by_name(dev_desc, partition_name, info);
39 convert_to_string(partition_name, part_name);
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;
55 int thor_save_env(char *str)
57 block_dev_desc_t *p_block_dev;
58 disk_partition_t part_info;
61 p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
65 ret = tizen_get_partition_info_by_name(p_block_dev, L"param", &part_info);
69 #ifndef CONFIG_TIZEN_LPM_SUPPORT
72 ret = Emmc_Write(PARTITION_USER, part_info.start, 1, (uint8 *)str);
78 static int thor_get_env(char *str)
80 block_dev_desc_t *p_block_dev;
81 disk_partition_t part_info;
84 p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
88 ret = tizen_get_partition_info_by_name(p_block_dev, L"param", &part_info);
92 ret = Emmc_Read(PARTITION_USER, part_info.start, 1, (uint8 *)str);
99 enum tizen_pm_state check_pm_status(void)
101 enum tizen_pm_state state = PM_STATE_NORMAL;
102 char str[EMMC_SECTOR_SIZE];
105 ret = thor_get_env(str);
108 if (!strncmp(str, "thor", strlen("thor")))
112 #ifndef CONFIG_TIZEN_LPM_SUPPORT
115 if (charger_connected()) {
116 int adp_type = sprdchg_charger_is_adapter();
122 state = PM_STATE_LPM;
131 unsigned int tizen_get_part_num(const char *part_name)
133 block_dev_desc_t *p_block_dev;
136 p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
140 ret = get_partition_num_by_name(p_block_dev, part_name);
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;
152 unsigned int tizen_get_part_info(const char *name, struct thor_part_info *info)
154 block_dev_desc_t *p_block_dev;
155 disk_partition_t part_info;
156 wchar_t partition_name[MAX_UTF_PARTITION_NAME_LEN];
159 p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
163 for (i = 0; i < MAX_UTF_PARTITION_NAME_LEN; i++) {
164 partition_name[i] = name[i];
169 ret = tizen_get_partition_info_by_name(p_block_dev, partition_name, &part_info);
175 if (!strcmp(name, PARTS_BOOT))
180 info->offset = part_info.start;
181 info->size = part_info.size;
182 info->blksz = part_info.blksz;
188 unsigned int thor_get_part_info(struct thor_part_info *part_info, const char *name)
191 char *orig_name, *file_name;
193 orig_name = strdup(name);
197 file_name = strtok(orig_name, ".");
201 for (i = 0; i < ARRAY_SIZE(thor_part_map); i++) {
202 if (!strcmp(file_name, thor_part_map[i].file_name)) {
204 return tizen_get_part_info(thor_part_map[i].part_name, part_info);
213 void tizen_get_emmc_serial_number(unsigned int *uid) {
214 unsigned char *regCID = get_global_cid();
217 for (v_index = 0; v_index < 4; v_index++)
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]);
226 unsigned int tizen_board_key_scan(void)
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;
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));
235 /* get volumn_down_status2 */
236 if(get_volumn_down_status2())
240 REG_KPD_INT_CLR = KPD_INT_ALL;
247 * PWR + VOL_DOWN = 0x112
248 * PWR + VOLDOWN + HOME = 0x111
250 printf("[tizen] scan code: 0x%x\n", scan_code);
253 #define TIZEN_KEY_VOLUP 0x80
254 #define TIZEN_KEY_VOLDN 0x122
255 #define TIZEN_KEY_HOME 0x81
256 #define TIZEN_KEY_PWR 0x82
258 #define TIZEN_KEY_VOLDN_HOME_PWR 0x111
259 #define TIZEN_KEY_VOLDN_PWR 0x112
261 boot_mode_enum_type tizen_check_keypad(void)
263 unsigned int scan_code;
265 scan_code = tizen_board_key_scan();
268 case TIZEN_KEY_VOLDN_HOME_PWR:
269 return CMD_THOR_MODE;
270 case TIZEN_KEY_VOLDN_PWR:
271 return CMD_FASTBOOT_MODE;
273 return CMD_NORMAL_MODE;
276 return CMD_NORMAL_MODE;
279 typedef struct _NV_Update{
281 void (*update)(void);
284 typedef enum _NV_UPDATE_ERR_E
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,
292 ERR_FIXNV_ERR_BACKUP_CNT,
293 ERR_DLNV_NOTEXIST, /* maybe DLNV be crashed in AP */
295 ERR_FIXNV_CRC_FAILURE,
296 ERR_FIXNV_UPDATE_FAILURE,
297 ERR_FIXNV_UPDATE_CPY,
298 ERR_FIXNV_POINTER_ERR,
302 typedef enum _CRC_CHECK_ERR_E
318 int runtimenv_read_with_backup(void)
323 char header[SECTOR_SIZE];
324 unsigned int checksum = 0;
325 nv_header_t * header_p = NULL;
329 block_dev_desc_t *p_block_dev;
330 disk_partition_t part_info;
332 runtimenv_adr = (void *)WRUNTIMENV_ADR;
334 p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
338 ret = tizen_get_partition_info_by_name(p_block_dev, L"runtimenv1", &part_info);
342 header_p = (nv_header_t *)header;
343 bakbuf = malloc(RUNTIMENV_SIZE + SECTOR_SIZE);
346 memset(bakbuf, 0xff, RUNTIMENV_SIZE + SECTOR_SIZE);
350 oribuf = malloc(RUNTIMENV_SIZE + SECTOR_SIZE);
353 memset(oribuf,0xff, RUNTIMENV_SIZE + SECTOR_SIZE);
355 printf("%s: oribuf malloc failed\n", __func__);
360 //mmc_bread((u8 *)oribuf, base_sector, RUNTIMENV_SIZE);
361 ret = Emmc_Read(PARTITION_USER, part_info.start, RUNTIMENV_SIZE / SECTOR_SIZE, (uint8 *)oribuf);
368 memset(header, 0, SECTOR_SIZE);
369 memcpy(header, oribuf, SECTOR_SIZE);
370 checksum = header_p->checksum;
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);
378 ret = tizen_get_partition_info_by_name(p_block_dev, L"runtimenv2", &part_info);
385 //mmc_bread((u8 *)bakbuf, base_sector, RUNTIMENV_SIZE);
386 ret = Emmc_Read(PARTITION_USER, part_info.start, RUNTIMENV_SIZE / SECTOR_SIZE, (uint8 *)bakbuf);
393 memset(header, 0, SECTOR_SIZE);
394 memcpy(header, bakbuf, SECTOR_SIZE);
396 checksum = header_p->checksum;
397 printf("runtime_read_with_backup backup checksum 0x%x\n", checksum);
399 if(_chkNVEcc((uint8_t *)bakbuf + SECTOR_SIZE, RUNTIMENV_SIZE, checksum)) {
400 memcpy(runtimenv_adr,bakbuf+SECTOR_SIZE,RUNTIMENV_SIZE);
406 printf("both org and bak partition are damaged!\n");
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);
416 printf("org partition is damaged!\n!");
417 memcpy(runtimenv_adr, bakbuf + SECTOR_SIZE, RUNTIMENV_SIZE);
419 ret = tizen_get_partition_info_by_name(p_block_dev, L"runtimenv1", &part_info);
426 Emmc_Write(PARTITION_USER, part_info.start, (RUNTIMENV_SIZE + SECTOR_SIZE) / SECTOR_SIZE, (uint8 *)bakbuf);
429 printf("both org and bak partition are ok!\n");
439 int fixnv_read_with_backup(void)
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];
451 unsigned int checksum = 0;
452 unsigned int nv_updated = 0;
453 unsigned int nv_magic = 0;
455 block_dev_desc_t *p_block_dev;
456 disk_partition_t part_info;
458 p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
462 ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv2", &part_info);
466 tmp_header_p = (nv_header_t *)tmp_header;
467 tmpbuf = malloc(FIXNV_SIZE + SECTOR_SIZE);
468 memset(tmp_header, 0, SECTOR_SIZE);
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);
475 memcpy(tmp_header, tmpbuf, SECTOR_SIZE);
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;
484 Emmc_Erase(PARTITION_USER, part_info.start, ((FIXNV_SIZE + SECTOR_SIZE) / SECTOR_SIZE));
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);
494 ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv1", &part_info);
498 header_p = (nv_header_t *)header;
499 bakbuf = malloc(FIXNV_SIZE + SECTOR_SIZE);
502 memset(bakbuf, 0xff, FIXNV_SIZE + SECTOR_SIZE);
506 oribuf = malloc(FIXNV_SIZE + SECTOR_SIZE);
508 memset(oribuf,0xff, FIXNV_SIZE + SECTOR_SIZE);
514 printf("loading fixnv1 from %lx(%x) to %lx\n", part_info.start, FIXNV_SIZE, (unsigned long)fixnv_adr);
516 //mmc_bread((u8 *)oribuf, base_sector, FIXNV_SIZE);
517 ret = Emmc_Read(PARTITION_USER, part_info.start, FIXNV_SIZE / SECTOR_SIZE, (uint8 *)oribuf);
524 memset(header, 0, SECTOR_SIZE);
525 memcpy(header, oribuf, SECTOR_SIZE);
526 checksum = header_p->checksum;
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);
533 nv_magic = header_p->magic;
535 printf("fixnv1 header magic 0x%x\n",nv_magic);
536 if(nv_magic != NV_HEAD_MAGIC)
539 ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv2", &part_info);
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);
552 memset(header, 0, SECTOR_SIZE);
553 memcpy(header, bakbuf, SECTOR_SIZE);
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);
559 if ((nv_updated == NV_UPDATED) && (nv_magic == NV_HEAD_MAGIC)) {
561 unsigned int nv_backup_status = ERR_FIXNV_NONE;
563 char *bakbuf_update = NULL;
564 char *oribuf_update = NULL;
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__);
576 memset(oribuf_update, 0xff, FIXNV_SIZE);
577 memcpy(oribuf_update, oribuf + SECTOR_SIZE, FIXNV_SIZE);
579 // 2. load fixnv2 to backbuf
580 bakbuf_update = malloc(FIXNV_SIZE);
582 if (!bakbuf_update) {
583 printf("%s: bakbuf_update malloc failed\n", __func__);
590 memset(bakbuf_update, 0xff, FIXNV_SIZE);
591 memcpy(bakbuf_update, bakbuf + SECTOR_SIZE, FIXNV_SIZE);
595 // nv_backup_status = modem_update_fixnv_image(bakbuf_update, oribuf_update);
596 printf("nv_backup_status = %d \n", nv_backup_status);
598 switch (nv_backup_status) {
601 case ERR_FIXNV_INITCPY:
602 case ERR_FIXNV_UPDATE_CPY:
603 printf("nv update is succeeded.\n");
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;
613 ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv1", &part_info);
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);
627 ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv2", &part_info);
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);
641 memset(fixnv_adr, 0xff, FIXNV_SIZE);
642 memcpy(fixnv_adr, oribuf_update, FIXNV_SIZE);
646 printf("nv update is failed. Original NV will be NV partitions.\n");
647 header_p->checksum = 0x0;
648 header_p->updated = 0x1;
650 ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv2", &part_info);
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);
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);
676 printf("both org and bak partition are damaged!\n");
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);
687 printf("org partition is damaged!\n!");
688 memcpy(fixnv_adr, bakbuf+SECTOR_SIZE, FIXNV_SIZE);
690 ret = tizen_get_partition_info_by_name(p_block_dev, L"fixnv1", &part_info);
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);
700 printf("both org and bak partition are ok!\n");
711 int load_nvitem(void)
714 ret = fixnv_read_with_backup();
718 ret = runtimenv_read_with_backup();
725 int load_modem_data(void)
727 block_dev_desc_t *p_block_dev;
728 disk_partition_t part_info;
734 unsigned char *buf = (void *)WMODEM_ADR;
736 printf("load modem to addr 0x%08lx\n", (unsigned long)buf);
738 nsct = WMODEM_SIZE / EMMC_SECTOR_SIZE;
740 /* size of the image is multiple of emmc sector size, so no need to check it */
741 left = WMODEM_SIZE % EMMC_SECTOR_SIZE;
744 p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
748 ret = tizen_get_partition_info_by_name(p_block_dev, L"modem", &part_info);
752 ret = Emmc_Read(PARTITION_USER, part_info.start, nsct, (uint8 *)buf);
758 char *sctbuf = sctbuf = malloc(EMMC_SECTOR_SIZE);
762 ret = Emmc_Read(PARTITION_USER, part_info.start + nsct, 1, (uint8 *)sctbuf);
764 memcpy(buf + (nsct * EMMC_SECTOR_SIZE), sctbuf, left);
769 printf("partition; modem read success!\n");
774 int load_dsp_data(void)
776 block_dev_desc_t *p_block_dev;
777 disk_partition_t part_info;
783 unsigned char *buf = (void *)WDSP_ADR;
785 printf("load dsp to addr 0x%08lx\n", (unsigned long)buf);
787 nsct = WDSP_SIZE / EMMC_SECTOR_SIZE;
789 /* size of the image is multiple of emmc sector size, so no need to check it */
790 left = WDSP_SIZE % EMMC_SECTOR_SIZE;
793 p_block_dev = get_dev("mmc", CONFIG_MMC_DEFAULT_DEV);
797 ret = tizen_get_partition_info_by_name(p_block_dev, L"dsp", &part_info);
801 ret = Emmc_Read(PARTITION_USER, part_info.start, nsct, (uint8 *)buf);
807 char *sctbuf = malloc(EMMC_SECTOR_SIZE);
811 ret = Emmc_Read(PARTITION_USER, part_info.start + nsct, 1, (uint8 *)sctbuf);
813 memcpy(buf + (nsct * EMMC_SECTOR_SIZE), sctbuf, left);
818 printf("partition; dsp read success!\n");
823 int get_image_signature(struct sig_header *hdr, unsigned int base_addr,
826 memcpy((void *)hdr, (const void *)(base_addr + size - HDR_SIZE),
829 if (hdr->magic != HDR_BOOT_MAGIC)
835 static int load_binary_to_addr(char *name, unsigned int addr, unsigned int size)
837 struct thor_part_info info;
840 ret = tizen_get_part_info(name, &info);
844 ret = Emmc_Read(PARTITION_USER, info.offset, size / info.blksz, (uint8 *)addr);
851 int load_ramdisk(char *name, unsigned int base_addr, unsigned int size)
853 return load_binary_to_addr(name, base_addr, size);
856 int check_board_signature(char *fname, unsigned int dn_addr, unsigned int size)
858 struct sig_header bh_target;
859 struct sig_header bh_addr;
860 char bl_buf[CONFIG_SIG_IMAGE_SIZE];
863 /* only check u-boot-mmc.bin */
864 if (strcmp(fname, "u-boot-mmc"))
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);
872 ret = get_image_signature(&bh_target, (unsigned int)(unsigned long)bl_buf, CONFIG_SIG_IMAGE_SIZE);
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);
883 /* can't found signature in address - download stop */
884 ret = get_image_signature(&bh_addr, dn_addr, CONFIG_SIG_IMAGE_SIZE);
886 printf("signature not found.\n");
890 if (strncmp(bh_target.bd_name, bh_addr.bd_name,
891 ARRAY_SIZE(bh_target.bd_name))) {
892 printf("Invalid!\n");
899 unsigned int tizen_get_jig_state(void)
903 /* read attached device. */
904 pin_data = ANA_REG_GET(ADI_EIC_DATA);
905 return pin_data & (1 << 1);