首页 > 代码库 > (转)关于三星cortex A9 Sate4412 开发板 uboot 启动的一些问题释疑

(转)关于三星cortex A9 Sate4412 开发板 uboot 启动的一些问题释疑

2024-07-10 06:06:51   221人阅读

说明：本文转载自：http://blog.csdn.net/gooogleman/article/details/17238079 
作者：gooogleman                   日期：2013.11.27            

最近，发现4412 和S5PV210的一些iNand/TF启动方式有些不同，4412 的一些磁盘索引不是固定在某一个通道的上的，而S5PV210 是固定的，这就导致一些人在烧写4412 ，分区格式化的时候会莫名其妙，不知所以然，现在看看代码，看是4412 代码到底是为何会这样了。
首先看从iNand 启动时候uboot打印信息。
U-Boot 2010.12 (Jul 29 2013 - 10:01:49) for SMDK4412


CPU: S5PC220 [Samsung SOC on SMP Platform Base on ARM CortexA9]
APLL = 1200MHz, MPLL = 800MHz
DRAM:  1023 MiB
TrustZone Enabled BSP
BL1 version: 20120711
OM_STAT=0x00000029
Checking Boot Mode ... EMMC4.41
REVISION: 1.1
NAME: S5P_MSHC4
MMC Device 0: 7576 MB
MMC Device 1: 0 MB
MMC Device 2 not found
Using default environment


MMC read: dev # 0, block # 26624, count 1 ... 1 blocks read: OK
Hit ‘a‘ key to stop autoboot:  0 
SMDK4412 #
查找OM_STAT 所在位置
unsigned int OmPin;
OmPin = INF_REG3_REG;
        printf("OM_STAT=0x%08x\n", *((unsigned int *)(0x10020000)));
        printf("Checking Boot Mode ...");
        if(OmPin == BOOT_ONENAND) {
                printf(" OneNand\n");
        } else if (OmPin == BOOT_NAND) {
                printf(" NAND\n");
        } else if (OmPin == BOOT_MMCSD) {
                printf(" SDMMC\n");
        } else if (OmPin == BOOT_EMMC) {
                printf(" EMMC4.3\n");
        } else if (OmPin == BOOT_EMMC_4_4) {
                printf(" EMMC4.41\n");
        }

查询一下 OmPin 所用到的位置，这个变量的确非常重要，决定了到底烧写哪个存储器（nandflash ，还是mmc，还是iNand.........等等）


common/cmd_fastboot.c:extern unsigned int OmPin;
common/cmd_fastboot.c:                        if (OmPin == BOOT_MMCSD) {
common/cmd_fastboot.c:                        } else if (OmPin == BOOT_EMMC_4_4 || OmPin == BOOT_EMMC) {
common/cmd_fastboot.c:                        } else if (OmPin == BOOT_ONENAND) {
common/cmd_fastboot.c:                        if (OmPin == BOOT_MMCSD) {
common/cmd_fastboot.c:                        } else if(OmPin == BOOT_EMMC_4_4 || OmPin == BOOT_EMMC) {
common/cmd_fastboot.c:                        else if(OmPin == BOOT_ONENAND) {
common/cmd_fastboot.c:....                                if (OmPin == BOOT_ONENAND) {
common/cmd_fastboot.c:                                } else if (OmPin == BOOT_MMCSD) {
common/cmd_fastboot.c:                                } else if (OmPin == BOOT_EMMC_4_4 || OmPin == BOOT_EMMC) {
common/cmd_fastboot.c:                                if (OmPin == BOOT_ONENAND) {
common/cmd_fastboot.c:                                } else if (OmPin == BOOT_MMCSD) {
common/cmd_fastboot.c:                                } else if (OmPin == BOOT_EMMC_4_4 || OmPin == BOOT_EMMC) {
common/cmd_fastboot.c:                                        if (OmPin == BOOT_ONENAND) {
common/cmd_fastboot.c:                                        } else if (OmPin == BOOT_MMCSD) {
common/cmd_fastboot.c:                                        } else if (OmPin == BOOT_EMMC_4_4 || OmPin == BOOT_EMMC) {
common/cmd_fastboot.c:        switch(OmPin) {
common/cmd_fastboot.c:        switch(OmPin) {
drivers/mmc/s5p_mshc.c:extern unsigned int OmPin;
drivers/mmc/s5p_mshc.c:        if (OmPin == BOOT_EMMC_4_4 || OmPin == BOOT_EMMC) {

从上面的代码看，我以前写的Sate4412 开发板镜像烧写方法似乎是错误的，但是...........那个步骤是我一边烧写一边写的，的的确确是能够烧写成功启动的，why？
我觉得其中程序必有一些暗藏的东西，继续找找......




#if defined(CFG_FASTBOOT_SDMMCBSP)
#if defined(CONFIG_S5P6450) && !defined(CONFIG_EMMC_4_4)
#define        DEV_NUM 1
#else
#define        DEV_NUM 0
#endif
static int write_to_ptn_sdmmc(struct fastboot_ptentry *ptn, unsigned int addr, unsigned int size)
{

   .......

/* use the partition name that can be understood by a command, movi */
                if (!strcmp(ptn->name, "bl_uboot"))
                {
                        strncpy(part, "bl_uboot", 10);
                        sprintf(run_cmd,"emmc open 0");
                        run_command(run_cmd, 0);
                }

..............................

if (INF_REG3_REG == 7 && (!strcmp(ptn->name, "bl_uboot"))){
                        sprintf(run_cmd,"emmc close 0");
                        run_command(run_cmd, 0);
}

前面看到了吧INF_REG3_REG 这个不是OM 的寄存器啊，只是在启动阶段读OM寄存器，然后存到INF_REG3_REG，也够恶心的。这里居然不用OM，直接用这个，用意何在？！INF_REG3_REG == 7 这个值正是OM为 EMMC4.4 时候的值（INF_REG3_REG不是OM寄存器的值，只是一个强制的赋值，所以不要混淆，不是Sate4412 开发板TF 小卡启动的配置），这里判断到是iNand启动，烧写完毕镜像那么就关闭了emmc？
所以一般人找不到，总以为OM是在开机时候读一次就没再改过了.........囧！

这个INF_REG3_REG 只是被系统用来存放ＯＭ设置值而已.请看lowlevel_init.S中的read_om函数,　
        ldr        r0, =S5PV310_POWER_BASE
        ldr        r1, [r0,#OMR_OFFSET]
        bic        r2, r1, #0xffffffc1
这个就是读取ＯＭ设置pin状态,并写入r2.
        /* SD/MMC BOOT */
        cmp     r2, #0x4
        moveq   r3, #BOOT_MMCSD

        /* eMMC BOOT */
        cmp        r2, #0x6
        moveq        r3, #BOOT_EMMC

        /* eMMC 4.4 BOOT */
        cmp        r2, #0x8
        moveq        r3, #BOOT_EMMC_4_4
        cmp        r2, #0x28
        moveq        r3, #BOOT_EMMC_4_4
上面就是根据r2值,记入相应的启动方式到r3
        ldr        r0, =INF_REG_BASE
        str        r3, [r0, #INF_REG3_OFFSET]
        mov        pc, lr
上面就是将存放在r3中的ＯＭ设置值存入INF_REG3_REG.

INF_REG3_REG 这个也太扯了吧，本身就有OM_STAT 寄存器的，为啥这么搞，其实可以随时对OM_STAT  来判断的。
上面的INF_REG3_REG 这个不是OM 的寄存器啊，只是在启动阶段读OM寄存器，然后存到INF_REG3_REG，也够恶心的。这里居然不用OM，直接用这个，用意何在？！INF_REG3_REG == 7 这个值正是OM为 EMMC4.4 时候的值（INF_REG3_REG不是OM寄存器的值，只是一个强制的赋值，所以不要混淆，不是Sate4412 开发板TF 小卡启动的配置），这里判断到是iNand启动，烧写完毕镜像那么就关闭了emmc？
去看看emmc close 命令的代码，发现有一些注释，就是要求镜像烧写完毕以后，需要关闭这个成功烧写的emmc，难道不关闭会被刷掉吗？

int do_emmc(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
        int rc = 0;
        u32 dev;

        switch (argc) {
        case 5:
                if (strcmp(argv[1], "partition") == 0) {
                        dev = simple_strtoul(argv[2], NULL, 10);
                        struct mmc *mmc = find_mmc_device(dev);
                        u32 bootsize = simple_strtoul(argv[3], NULL, 10);
                        u32 rpmbsize = simple_strtoul(argv[4], NULL, 10);

                        if (!mmc)
                                rc = 1;

                        rc = emmc_boot_partition_size_change(mmc, bootsize, rpmbsize);
                        if (rc == 0) {
                                printf("eMMC boot partition Size is %d MB.!!\n", bootsize);
                                printf("eMMC RPMB partition Size is %d MB.!!\n", rpmbsize);
                        } else {
                                printf("eMMC boot partition Size change Failed.!!\n");
                        }
                } else {
                        printf("Usage:\n%s\n", cmdtp->usage);
                        rc =1;
                }
                break;

        case 3:
                if (strcmp(argv[1], "open") == 0) {
                        int dev = simple_strtoul(argv[2], NULL, 10);
                        struct mmc *mmc = find_mmc_device(dev);

                        if (!mmc)
                                rc = 1;

                        rc = emmc_boot_open(mmc);

                        if (rc == 0) {
                        printf("eMMC OPEN Success.!!\n");
                        printf("\t\t\t!!!Notice!!!\n");
                        printf("!You must close eMMC boot Partition after all image writing!\n");
                        printf("!eMMC boot partition has continuity at image writing time.!\n");
                        printf("!So, Do not close boot partition, Before, all images is written.!\n");
                        } else {
                                printf("eMMC OPEN Failed.!!\n");
                        }
                } else if (strcmp(argv[1], "close") == 0) {
                        int dev = simple_strtoul(argv[2], NULL, 10);
                        struct mmc *mmc = find_mmc_device(dev);

                        if (!mmc)
                                rc = 1;

                        rc = emmc_boot_close(mmc);

                        if (rc == 0) {
                                printf("eMMC CLOSE Success.!!\n");
                        } else {
                                printf("eMMC CLOSE Failed.!!\n");
                        }
                } else {
                        printf("Usage:\n%s\n", cmdtp->usage);
                        rc =1;
                }
                break;
        case 0:
        case 1:                
        case 2:
        case 4:
        default:
                printf("Usage:\n%s\n", cmdtp->usage);
                rc = 1;
                break;
        }
        
        return rc;
}


注意这里emmc 的关闭不是指电源关闭，而是关闭了一些功能

int emmc_boot_open(struct mmc *mmc)


{
        int err;
        struct mmc_cmd cmd;

        /* Boot ack enable, boot partition enable , boot partition access */
        cmd.cmdidx = MMC_CMD_SWITCH;
        cmd.resp_type = MMC_RSP_R1b;
        cmd.cmdarg = ((3<<24)|(179<<16)|(((1<<6)|(1<<3)|(1<<0))<<8));
        cmd.flags = 0;

        err = mmc_send_cmd(mmc, &cmd, NULL);
        if (err)
                return err;

        /* 4bit transfer mode at booting time. */
        cmd.cmdidx = MMC_CMD_SWITCH;
        cmd.resp_type = MMC_RSP_R1b;
        cmd.cmdarg = ((3<<24)|(177<<16)|((1<<0)<<8));
        cmd.flags = 0;

        err = mmc_send_cmd(mmc, &cmd, NULL);
        if (err)
                return err;

        return 0;
}

int emmc_boot_close(struct mmc *mmc)
{
        int err;
        struct mmc_cmd cmd;

        /* Boot ack enable, boot partition enable , boot partition access */
        cmd.cmdidx = MMC_CMD_SWITCH;
        cmd.resp_type = MMC_RSP_R1b;
        cmd.cmdarg = ((3<<24)|(179<<16)|(((1<<6)|(1<<3)|(0<<0))<<8));
        cmd.flags = 0;

        err = mmc_send_cmd(mmc, &cmd, NULL);
        if (err)
                return err;

        return 0;
}
上面可以知道，有一个判断，判断是iNand启动烧写后 才关闭了mmc ，但是TF 卡却没有，这个就是OM 在TF 烧写模式下，TF 烧写完毕会连bootloader 都会被冲掉的原因。囧。S5pv210 没有这个现象，难道这个是4412 有什么特殊的原因要这么样的？三星不可能会这么混的啊。

INF_REG3_REG  应该是这个 ，就是Base Address: 0x1002_0000 +0x080C
INFORM3  0x080C  Information register 3  0x0000_0000

比较奇怪， 0x1002_0000 本身就是OM 寄存器地址但是却转存到INFORM3  ，再看看，三星不可能绕一大圈来做这个无谓的事情。

——这个里面有笔误，上面应该改成如下就可以了。
先把薄码开关拨到MMC2启动，即OM[5:1] 为b‘00010，把启动TF卡插入MMC2，上电启动，进入uboot命令行模式后执行命令：
mmc erase boot 1 0 1024 （当从mmc2 TF卡启动时i，TF卡设备索引号是0，而nand 设备索引号应该是1）
即可擦除iNand uboot分区最前面的引导部分。注意，不要此时烧写uboot，此时烧写会把uboot烧写到TF卡上而不是INAND上。接着断电，薄码开关调回INAND启动，即OM[5：1] B‘10100，上电就会检查iNand，但是iNand 没有uboot启动代码，所以就会自动切换到TF卡启动，但是此时的OM值是iNand 模式的，所以iNand 设备索引值是0，而mmc2 TF卡是1，所以能够正常用fdisk -c 0 ，ext3format mmc 0:1 等分区命令进行烧写。这时就可以烧写uboot到inand上了。整个过程终于明白了，今天主要看了Sate4412 的uboot代码，并且举一反三，终于明白4412 烧写是怎么回事。终于清静了......

intdo_mmcops(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
         int rc = 0;
         int part = 0;

         switch (argc) {
         case 3:
                   if (strcmp(argv[1],"rescan") == 0) {
                            int dev =simple_strtoul(argv[2], NULL, 10);
                            struct mmc *mmc =find_mmc_device(dev);

                            if (!mmc)
                                     return 1;

                            mmc_init(mmc);

                            return 0;
                   }

         case 0:
         case 1:
         case 4:
                   printf("Usage:\n%s\n",cmdtp->usage);
                   return 1;

         case 2:
                   if (!strcmp(argv[1],"list")) {
                            print_mmc_devices(‘\n‘);
                            return 0;
                   }
                   return 1;
         case 6:
                   if (strcmp(argv[1],"erase") == 0) {
                            /* Read inputvariable */
                            int dev =simple_strtoul(argv[3], NULL, 10);
                            u32 start =simple_strtoul(argv[4], NULL, 10);
                            u32 block =simple_strtoul(argv[5], NULL, 10);

                            struct mmc *mmc =find_mmc_device(dev);

                            if (!mmc)
                                     return 1;

                            u32 count = 0;

                            /* Select erasepartition */
                            if (strcmp(argv[2],"boot") == 0) {
                                     part = 0;
                                     /* ReadBoot partition size. */
                                     count =((mmc->ext_csd.boot_size_multi)*256);
                            } else if(strcmp(argv[2], "user") == 0) {
                                     part = 1;
                                     /* ReadUser partition size. */
                                     count =mmc->capacity;
                            } else {
                                     part = 1;
                                     count =mmc->capacity;
                                     printf("Defaulterase user partition\n");
                            }

                            /* If input counteris larger than max counter */
                            if ((start + block)> count) {
                                     block =(count - start) - 1;
                                     printf("Blockcount is Too BIG!!\n");
                            }

                            /* If input counteris 0 */
                            if (!block ) {
                                     block =(count - start) - 1;
                                     printf("Eraseall from %d block\n", start);
                            }

                            rc = mmc_erase(mmc,part, start, block);

                            if (rc == 0) {
                                     printf("MMCerase Success.!!\n");
                            } else {
                                     printf("MMCerase Failed.!!\n");
                                     return -1;
                            }
                            return 0;
                   } else if (strcmp(argv[1],"read") == 0) {
                            int dev =simple_strtoul(argv[2], NULL, 10);
                            void *addr = (void*)simple_strtoul(argv[3], NULL, 16);
                            u32 cnt =simple_strtoul(argv[5], NULL, 10);
                            u32 n;
                            u32 blk =simple_strtoul(argv[4], NULL, 10);
                            u32 read_cnt;
                            u32 cnt_to_read;
                            void *addr_to_read =addr;
                            struct mmc *mmc =find_mmc_device(dev);

                            if (!mmc)
                                     return 1;

                            printf("\nMMCread: dev # %d, block # %d, count %d ... ",
                                     dev, blk,cnt);

                            n = 0;
                            addr_to_read = addr;
                            do {
                                     if (cnt - n> MAXIMUM_BLOCK_COUNT)
                                               cnt_to_read= MAXIMUM_BLOCK_COUNT;
                                     else
                                               cnt_to_read= cnt - n;

                                     read_cnt =mmc->block_dev.block_read(dev, blk, cnt_to_read, addr_to_read);
                                     n +=read_cnt;
                                     blk +=read_cnt;
                                     addr_to_read+= read_cnt * 512;
                                     if(cnt_to_read!= read_cnt) {
                                               printf("%dblocks read: %s\n",
                                                        n,"ERROR");
                                               return-1;
                                     }
                            } while(cnt > n);

                            /* flush cache afterread */
                            flush_cache((ulong)addr,cnt * 512); /* FIXME */

                            printf("%dblocks read: %s\n",
                                     n, (n==cnt)? "OK" : "ERROR");
                            return (n == cnt) ?0 : 1;
                   } else if (strcmp(argv[1],"write") == 0) {
                            int dev =simple_strtoul(argv[2], NULL, 10);
                            void *addr = (void*)simple_strtoul(argv[3], NULL, 16);
                            u32 cnt =simple_strtoul(argv[5], NULL, 10);
                            int blk =simple_strtoul(argv[4], NULL, 10);
                            u32 n;
                            u32 written_cnt;
                            u32 cnt_to_write;
                            void *addr_to_write= addr;
                            struct mmc *mmc =find_mmc_device(dev);


                            if (!mmc)
                                     return 1;

                            printf("\nMMCwrite: dev # %d, block # %d, count %d ... ",
                                     dev, blk,cnt);

                            n = 0;
                            addr_to_write =addr;
                            do {
                                     if (cnt - n> MAXIMUM_BLOCK_COUNT)
                                               cnt_to_write= MAXIMUM_BLOCK_COUNT;
                                     else
                                               cnt_to_write= cnt - n;

                                     written_cnt= mmc->block_dev.block_write(dev, blk, cnt_to_write, addr_to_write);
                                     n +=written_cnt;
                                     blk +=written_cnt;
                                     addr_to_write+= written_cnt * 512;
                                     if(cnt_to_write!= written_cnt) {
                                               printf("%dblocks written: %s\n",
                                                        n,"ERROR");
                                               return-1;
                                     }
                            } while(cnt > n);

                            printf("%dblocks written: %s\n",
                                     n, (n ==cnt) ? "OK" : "ERROR");
                            return (n == cnt) ?0 : 1;
                   } else {
                            printf("Usage:\n%s\n",cmdtp->usage);
                            rc = 1;
                   }

                   return rc;
         default: /* at least 5 args */
                   printf("Usage:\n%s\n",cmdtp->usage);
                   return 1;
         }
}
 
晚上搞定这个事情先。
iNand启动时候
SKD4X12 # mmc list
S5P_MSHC4: 0
S3C_HSMMC2: 1
SKD4X12 # 

不关机切换成
SD/TF MM2 启动的时候一样
SKD4X12 # mmc list
S5P_MSHC4: 0
S3C_HSMMC2: 1
SKD4X12 # 
SKD4X12 # mmc list
S5P_MSHC4: 0
S3C_HSMMC2: 1
fdisk -c 0 分区仍然是给iNand 分的区
SKD4X12 # fdisk -c 0
NAME: S5P_MSHC4
fdisk is completed

partion #    size(MB)     block start #    block count    partition_Id 
   1           500           102400         1024000          0x83 
   2           150          1126400          307200          0x83 
   3          6876          1433600        14082048          0x83 
SKD4X12 # 

设置SD/TF MM2 启动，关机，重启
发现变了。索引号 mmc2 和inand 颠倒了位置所以对应分区命令也跟着变了。
SMDK4412 # mmc list
S3C_HSMMC2: 0
S5P_MSHC4: 1
SMDK4412 # 
SMDK4412 # fdisk -c 0
fdisk is completed

partion #    size(MB)     block start #    block count    partition_Id 
   1           500            67584         1024000          0x83 
   2           150          1091584          307200          0x83 
   3          6777          1398784        13879296          0x83 
SMDK4412 # fdisk -c 1
NAME: S5P_MSHC4
fdisk is completed

partion #    size(MB)     block start #    block count    partition_Id 
   1           500            67584         1024000          0x83 
   2           150          1091584          307200          0x83 
   3          6893          1398784        14116864          0x83 
SMDK4412 #

 

，昨晚我看了一下，这个主要还是uboot代码里面他自己这么做了，这样做也没什么不好，或者这样做有他的好处，就是他可以自由选择从mmc2 还是iNand 通道启动系统应该都没问题，不过内核那些要匹配一下。

 

现在Sate4412 开发板用户手册已经升级更改，需要参考的广大网友和Sate4412 用户请到如下地址下载

http://download.csdn.net/detail/gooogleman/6688457

 


联系
我们