linux driver ------ 三星公司uboot模式下更改分区（EMMC）大小fdisk命令 ------ iTOP4412 开发板烧写

核心板

SCP 1G

eMMC：KLM8G------>8G

终端（串口）输入（如果执行过，只需要执行最后一句即可）：

开发板一启动，立马在终端按回车，进入 uboot 模式

fdisk -c 0 （0代表eMMC，1代表TF卡）
fatformat mmc 0:1
ext3format mmc 0:2
ext3format mmc 0:3
ext3format mmc 0:4
fastboot

开发板OTG连接到电脑（电脑需要安装ADB 驱动），打开cmd.exe，输入：

fastboot.exe flash bootloader u-boot-iTOP-4412.bin（u-boot，烧过可以不烧）

fastboot.exe flash kernel zImage（内核）

fastboot.exe flash ramdisk ramdisk-uboot.img（文件系统） 

fastboot.exe flash system system.img （根文件系统，rootfs）

fastboot -w ( 擦除userdata分区和cache分区 )

fastboot reboot

如果是最小文件系统，system.img不一样外，“u-boot-iTOP-4412.bin”文件不用烧写 ，“zImage”、"ramdisk-uboot.img "和 Linux-QT 系统相同

fastboot.exe 程序

用户在烧写的时候，会发现所有的烧写命令前面都会添加“fastboot”，这些 fastboot命令以及“fastboot.exe”小程序，都是三星在 Google 提供的 ADB 驱动以及“adb.exe”程序的基础上做的。当然，fastboot 命令只能用来和 exynos4412 的 uboot 模式进行交互

一、分区

三星平台一般把emmc（或者NAND）分为四个区：

（1）、fat分区,作为sd卡用；

（2）、系统分区，相当为电脑c 盘，用来安装android系统；

（3）、userdata分区；

（4）、cache分区。

二、分区更改操作过程

1，  更改uboot中代码/common/cmd_mmc_fdisk.c

在这个文件中我们可以看到对四个分区大小的定义：

#define        BLOCK_SIZE            512
#define        BLOCK_END            0xFFFFFFFF
#define        _10MB                (10*1024*1024)
#define        _100MB                (100*1024*1024)
#define        _300MB                (300*1024*1024)
#define        _8_4GB                (1023*254*63)
#define        _1GB                (1024*1024*1024)
#define        DISK_START            RAW_AREA_SIZE//mj (16*1024*1024) //same as raw area size
 
#define        SYSTEM_PART_SIZE        _1GB //_300MB
#define        USER_DATA_PART_SIZE        _1GB //_300MB //_1GB
#define        CACHE_PART_SIZE            _300MB
 
#define        CHS_MODE            0
#define        LBA_MODE            !(CHS_MODE)

 2、重新分区 fdisk -c 0 命令，即按 /common/cmd_mmc_fdisk.c 把 emmc 分成4个规定大小的分区

 

3、对分出来的4个区进行格式化（清空数据），并格式化为特定的文件系统格式

3.1、输入如下命令 fatformat mmc 0:1

3.2、输入如下命令fatformat mmc 0:2

3.3、输入如下命令fatformat mmc 0:3

3.4、输入如下命令fatformat mmc 0:4

 

3.5在超级终端中输入“fastboot”

 4、把整个系统重新烧录

在PC机上运行“USB_fastboot_tool”-->“platform-tools”文件夹中的文件“cmd.exe”（cmd.exe可执行文件是Windows自带的命令行工具，光盘里面的是Win7下的，如果提示版本不兼容，请使用你自己系统里面的cmd.exe工具）

（三星平台的命令，不同平台也许不同）

fastboot.exe flash bootloader u-boot-iTOP-4412.bin
fastboot.exe flash kernel zImage
fastboot.exe flash ramdisk ramdisk-uboot.img 
fastboot.exe flash system system.img  

 三、fdisk 命令分析

1、命令定义

U_BOOT_CMD(
    fdisk, 6, 0, do_fdisk,
    "fdisk	- fdisk for sd/mmc.
",
    "-c <device_num>	- create partition.
"
    "fdisk -p <device_num> [<sys. part size(MB)> <user data part size> <cache part size>]	- print partition information
"
);

2、do_fdisk的实现函数

   我们平时用的fdisk -c 0 格式化emmc ，fdisk -p 0 查看分区信息，在这里可以看到对这两条命令的解析：

int do_fdisk(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
    if ( argc == 3 || argc ==6 )
    {
        if ( strcmp(argv[1], "-c") == 0 )
            return create_mmc_fdisk(argc, argv);  //格式化分区
        else if ( strcmp(argv[1], "-p") == 0 )
            return print_mmc_part_info(argc, argv); //打印出分区的信息
    }
    else //如果不满足argc条件，打印出帮助信息
    {
        printf("Usage:
fdisk <-p> <device_num>
");
        printf("fdisk <-c> <device_num> [<sys. part size(MB)> <user data part size> <cache part size>]
");
    }
    return 0;
}

3、如果为fdisk -c 0进，进入 create_mmc_fdisk，我们再分析这个函数

int create_mmc_fdisk(int argc, char *argv[])
{
    int        rv;
    int        total_block_count;
    unsigned char    mbr[512];
    memset(mbr, 0x00, 512);    
total_block_count = get_mmc_block_count(argv[2]); //获得块信息，以512 为单位
    if (total_block_count < 0)
        return -1;
    //格式化INAND
    make_mmc_partition(total_block_count, mbr, (argc==6?1:0), argv);
 
    rv = put_mmc_mbr(mbr, argv[2]);
    if (rv != 0)
        return -1;
        
    printf("fdisk is completed
");  //分区成功，打印信息
 
    argv[1][1] = 'p';
    print_mmc_part_info(argc, argv);  //和fdisk –p 0 作用一样，打印出分区信息
    return 0;
}

4、我们看下格式化函数make_mmc_partition是怎么实现的吧。

这里面有两上参考比较重要：block_start 、block_offset;每个区块的开始和大小（偏移量），我们画个图来更好的表示这个吧。

在这里我们可以看到

#define        SYSTEM_PART_SIZE        (300*1024*1024)
#define        USER_DATA_PART_SIZE        (600*1024*1024)
#define        CACHE_PART_SIZE            (300*1024*1024)

这几宏的应用，block_start= calc_unit(CFG_PARTITION_START, sdInfo)，计算分区大小

int make_mmc_partition(int total_block_count, unsigned char *mbr, int flag, char *argv[])
{
    int        block_start = 0, block_offset;
 
    SDInfo        sdInfo;
    PartitionInfo    partInfo[4];
    memset((unsigned char *)&sdInfo, 0x00, sizeof(SDInfo));
    get_SDInfo(total_block_count, &sdInfo);
 
///////////////////////////////////////////////////////////
    block_start = calc_unit(CFG_PARTITION_START, sdInfo); //得到第一分区的开始地址
    if (flag)
        block_offset = calc_unit((unsigned long long)simple_strtoul(argv[3], NULL, 0)*1024*1024, sdInfo);
    else
        block_offset = calc_unit(SYSTEM_PART_SIZE, sdInfo);//计算分区大小，这里面的值是不是很熟悉，就是我们开始改那些地方，这个是系统分区的
 
    partInfo[0].bootable    = 0x00;
    partInfo[0].partitionId    = 0x83;
 
    make_partitionInfo(block_start, block_offset, sdInfo, &partInfo[0]);//开始分区
 
///////////////////////////////////////////////////////////    
    block_start += block_offset;//更改下一个分析的开始地址，这样可以保证分区连续
    if (flag)
        block_offset = calc_unit((unsigned long long)simple_strtoul(argv[4], NULL, 0)*1024*1024, sdInfo);
    else
        block_offset = calc_unit(USER_DATA_PART_SIZE, sdInfo);
    
    partInfo[1].bootable    = 0x00;
    partInfo[1].partitionId    = 0x83;
 
    make_partitionInfo(block_start, block_offset, sdInfo, &partInfo[1]);
 
///////////////////////////////////////////////////////////    
    block_start += block_offset;
    if (flag)
        block_offset = calc_unit((unsigned long long)simple_strtoul(argv[5], NULL, 0)*1024*1024, sdInfo);
    else
        block_offset = calc_unit(CACHE_PART_SIZE, sdInfo);
 
    partInfo[2].bootable    = 0x00;
    partInfo[2].partitionId    = 0x83;
 
    make_partitionInfo(block_start, block_offset, sdInfo, &partInfo[2]);
 
///////////////////////////////////////////////////////////    
    block_start += block_offset;
    block_offset = BLOCK_END;
 
    partInfo[3].bootable    = 0x00;
    partInfo[3].partitionId    = 0x0C;
 
    make_partitionInfo(block_start, block_offset, sdInfo, &partInfo[3]);
 
///////////////////////////////////////////////////////////    
    memset(mbr, 0x00, sizeof(mbr));
    mbr[510] = 0x55; mbr[511] = 0xAA;
    
    encode_partitionInfo(partInfo[0], &mbr[0x1CE]);
    encode_partitionInfo(partInfo[1], &mbr[0x1DE]);
    encode_partitionInfo(partInfo[2], &mbr[0x1EE]);
    encode_partitionInfo(partInfo[3], &mbr[0x1BE]);
    
    return 0;
}

5、fidsk – p 0的实现函数也很简单

int print_mmc_part_info(int argc, char *argv[])
{
    int        rv;
 
    PartitionInfo    partInfo[4];
    
    rv = get_mmc_part_info(argv[2], 1, &(partInfo[0].block_start), &(partInfo[0].block_count),
            &(partInfo[0].partitionId) );
    
    rv = get_mmc_part_info(argv[2], 2, &(partInfo[1].block_start), &(partInfo[1].block_count),
            &(partInfo[1].partitionId) );
 
    rv = get_mmc_part_info(argv[2], 3, &(partInfo[2].block_start), &(partInfo[2].block_count),
            &(partInfo[2].partitionId) );
 
    rv = get_mmc_part_info(argv[2], 4, &(partInfo[3].block_start), &(partInfo[3].block_count),
            &(partInfo[3].partitionId) );
 
    printf("
");    
    printf("partion #    size(MB)     block start #    block count    partition_Id 
");
 
    if ( (partInfo[0].block_start !=0) && (partInfo[0].block_count != 0) ) 
        printf("   1        %6d         %8d        %8d          0x%.2X 
",
            (partInfo[0].block_count / 2048), partInfo[0].block_start,
            partInfo[0].block_count, partInfo[0].partitionId);
    
    if ( (partInfo[1].block_start !=0) && (partInfo[1].block_count != 0) ) 
        printf("   2        %6d         %8d        %8d          0x%.2X 
",
            (partInfo[1].block_count / 2048), partInfo[1].block_start,
            partInfo[1].block_count, partInfo[1].partitionId);
    
    if ( (partInfo[2].block_start !=0) && (partInfo[2].block_count != 0) ) 
        printf("   3        %6d         %8d        %8d          0x%.2X 
",
            (partInfo[2].block_count / 2048), partInfo[2].block_start,
            partInfo[2].block_count, partInfo[2].partitionId);
 
    if ( (partInfo[3].block_start !=0) && (partInfo[3].block_count != 0) ) 
        printf("   4        %6d         %8d        %8d          0x%.2X 
",
            (partInfo[3].block_count / 2048), partInfo[3].block_start,
            partInfo[3].block_count, partInfo[3].partitionId);
 
    return 1;
}