uboot例子

#define structprint(a,b) printf(#b); printf("=%x\n",a->b);
#define structprint2(a,b) printf(#b); printf("=%x\n",a.b);
extern int nand_curr_device ;
extern nand_info_t nand_info[CONFIG_SYS_MAX_NAND_DEVICE];

打印nand信息

static void printnand()
{
        // int crc1_ok = 0, crc2_ok = 0;
    // env_t *ep, *tmp_env1, *tmp_env2;
// tmp_env1 = (env_t *)malloc(CONFIG_ENV_SIZE);
    // tmp_env2 = (env_t *)malloc(CONFIG_ENV_SIZE);

    // if ((tmp_env1 == NULL) || (tmp_env2 == NULL)) {
        // puts("Can't allocate buffers for environment\n");
        // free(tmp_env1);
        // free(tmp_env2);
        // set_default_env("!malloc() failed");
        // return;
    // }

    //if (readenv(CONFIG_ENV_OFFSET, (u_char *) tmp_env1))
 

    printf("nand_curr_device=%d",nand_curr_device);    
    structprint2(nand_info[nand_curr_device],type);
    structprint2(nand_info[nand_curr_device],flags);
    structprint2(nand_info[nand_curr_device],size);
    structprint2(nand_info[nand_curr_device],erasesize);
    structprint2(nand_info[nand_curr_device],writesize);
    structprint2(nand_info[nand_curr_device],oobsize);
    structprint2(nand_info[nand_curr_device],oobavail);
    structprint2(nand_info[nand_curr_device],name);
    structprint2(nand_info[nand_curr_device],index);
    structprint2(nand_info[nand_curr_device],numeraseregions);
}

typedef struct _ENTRY {
    int used;
    ENTRY entry;

} _ENTRY;

打印环境变量

static void pintenv()
{    
    char *res, *p;
    size_t totlen;
    int i, n;
    ENTRY *ep ;
    struct hsearch_data * htab =&env_htab;
    for (i = 1, n = 0, totlen = 0; i <= htab->size; ++i) {
            if (htab->table[i].used > 0) {
                ep = &htab->table[i].entry;
                 printf("%s=%s\n",ep->key,ep->data);                
            }
    }
}

打印板子信息

static void printbd()
{
    int i;
    bd_t        *bd = gd->bd;
    structprint(bd,bi_baudrate)
    structprint(bd,bi_ip_addr)
    structprint(bd,bi_arch_number)
    structprint(bd,bi_boot_params)
    for(i=0;i<CONFIG_NR_DRAM_BANKS;i++){
        structprint(bd,bi_dram[i].start)
        structprint(bd,bi_dram[i].size)
    }
    
}

打印gd

static void printgd()
{
    //    bd_t        *bd;
    
    //unsigned long    flags;
    printnand();
    pintenv();
    printbd();
    structprint(gd,flags);
    //printf("gd->flags=%x\n",gd->flags);
    #if 1
    ///* /*  structprint(gd,flags);
    //unsigned long    baudrate;
     structprint(gd,baudrate);
    //unsigned long    have_console;    serial_init() was called
     structprint(gd,have_console);
    //unsigned long    env_addr;    Address  of Environment struct
     structprint(gd,env_addr);
    //unsigned long    env_valid;    Checksum of Environment valid?
    structprint(gd,env_valid);
    //unsigned long    fb_base;    base address of frame buffer
     structprint(gd,fb_base);
 #ifdef CONFIG_FSL_ESDHC
    //unsigned long    sdhc_clk;
     structprint(gd,sdhc_clk);
 #endif
 #ifdef CONFIG_AT91FAMILY
    // "static data" needed by at91's clock.c
    //unsigned long    cpu_clk_rate_hz;
     structprint(gd,cpu_clk_rate_hz);
    //unsigned long    main_clk_rate_hz;
     structprint(gd,main_clk_rate_hz);
    //unsigned long    mck_rate_hz;
     structprint(gd,mck_rate_hz);
    //unsigned long    plla_rate_hz;
     structprint(gd,plla_rate_hz);
    //unsigned long    pllb_rate_hz;
     structprint(gd,pllb_rate_hz);
    //unsigned long    at91_pllb_usb_init;
     structprint(gd,at91_pllb_usb_init);
 #endif
 #ifdef CONFIG_ARM
    // "static data" needed by most of timer.c on ARM platforms
    //unsigned long    timer_rate_hz;
     structprint(gd,timer_rate_hz);
    //unsigned long    tbl;
     structprint(gd,tbl);
    //unsigned long    tbu;
     structprint(gd,tbu);
    //unsigned long long    timer_reset_value;
     structprint(gd,timer_reset_value);
    //unsigned long    lastinc;
     structprint(gd,lastinc);
 #endif
 #ifdef CONFIG_IXP425
    //unsigned long    timestamp;
     structprint(gd,timestamp);
 #endif
    //unsigned long    relocaddr;    Start address of U-Boot in RAM
     structprint(gd,relocaddr);
    //phys_size_t    ram_size;    RAM size
     structprint(gd,ram_size);
    //unsigned long    mon_len;    monitor len
     structprint(gd,mon_len);
    //unsigned long    irq_sp;        irq stack pointer
     structprint(gd,irq_sp);
    //unsigned long    start_addr_sp;    start_addr_stackpointer
     structprint(gd,start_addr_sp);
    //unsigned long    reloc_off;
     structprint(gd,reloc_off);
 #if !(defined(CONFIG_SYS_ICACHE_OFF) && defined(CONFIG_SYS_DCACHE_OFF))
    //unsigned long    tlb_addr;
     structprint(gd,tlb_addr);
 #endif
    //void        **jt;        jump table
     structprint(gd,jt);
    //char        env_buf[32];    buffer for getenv() before reloc.
     structprint(gd,env_buf);
    #endif
}

int do_info (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
    int i;
    printgd();
    return 0;
}
U_BOOT_CMD (info, 2, 1, do_info,
    "loadable FPGA image support",
    "[operation type] [device number] [image address] [image size]\n"    
);

导出nand块的内容

static int nand_dump(nand_info_t *nand, ulong off)
{
    int i;
    u_char *datbuf, *oobbuf, *p;
    static loff_t last;
    printf("writesize:%x oobsize:%x",nand->writesize,nand->oobsize);

    last = off;

    datbuf = malloc(nand->writesize + nand->oobsize);
    oobbuf = malloc(nand->oobsize);
    if (!datbuf || !oobbuf) {
        puts("No memory for page buffer\n");
        return 1;
    }
    off = off * nand->writesize ;
    loff_t addr = (loff_t) off;
    struct mtd_oob_ops ops;
    memset(&ops, 0, sizeof(ops));
    ops.datbuf = datbuf;
    ops.oobbuf = oobbuf; /* must exist, but oob data will be appended to ops.datbuf */
    ops.len = nand->writesize;
    ops.ooblen = nand->oobsize;
    ops.mode = MTD_OOB_RAW;
    i = nand->read_oob(nand, addr, &ops);
    if (i < 0) {
        printf("Error (%d) reading page %08lx\n", i, off);
        free(datbuf);
        free(oobbuf);
        return 1;
    }
    printf("Page %08lx dump:\n", off);
    i = nand->writesize >> 4;
    p = datbuf;

    while (i--) {
        
            printf("\t%02x %02x %02x %02x %02x %02x %02x %02x"
                   "  %02x %02x %02x %02x %02x %02x %02x %02x\n",
                   p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
                   p[8], p[9], p[10], p[11], p[12], p[13], p[14],
                   p[15]);
        p += 16;
    }
    puts("OOB:\n");
    i = nand->oobsize >> 3;
    while (i--) {
        printf("\t%02x %02x %02x %02x %02x %02x %02x %02x\n",
               p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
        p += 8;
    }
    free(datbuf);
    free(oobbuf);

    return 0;
}

 char _ctoi(char c)
{
    if(c>='0'&&c<='9')return c-'0';
    if(c>='a'&&c<='f')return c-'a';
    return 0;
}
int _atox(char* s)
{
    unsigned int  a=0;
    unsigned int  b=0;
    int i=0;
    while(s[i]){
        a<<=4;
        a|=_ctoi(s[i]);
        i++;    
        if(i>=8)break;
    }
    return a;

}

nand dump

int do_ndump (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
    int i;
    if(argc<2){
        printf("ERR: parameter < 2\n");
        return 0;
    }
    i = _atox(argv[1]);
    printf("i=%x",i);
    nand_dump(&nand_info[nand_curr_device], i);
    return 0;
}

U_BOOT_CMD (ndump, 2, 1, do_ndump,
    "loadable FPGA image support",
    "[operation type] [device number] [image address] [image size]\n"    

);

内存导出

static void our_mdump(int memaddress)
{
    size_t amount_loaded = 0;
    size_t  len;
 
    int i;
    int rval;
 
    printf("our_ndump:%x",memaddress);

    len = 512;
    u_char* char_ptr=(u_char* )memaddress;
 
        for(i=0;i<len;i++){
            printf("%2.2x " ,char_ptr[i]);
            if((i&0xf)==15)printf("\n");
        }        
}

int do_mdump (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
    int i;
    if(argc<2){
        printf("ERR: parameter < 2\n");
        return 0;
    }
    i = _atox(argv[1]);
    our_mdump(i);
    return 0;
}

U_BOOT_CMD (mdump, 2, 1, do_mdump,
    "loadable FPGA image support",
    "[operation type] [device number] [image address] [image size]\n"    
);
 static unsigned int read_cpsr (void)
{
                unsigned long old,temp;
                __asm__ __volatile__("mrs %0, cpsr\n"
                                : "=r" (old)
                                :
                                 );
                return old ;
}
static void write_p15_c1 (unsigned long value)
{
        #ifdef MMU_DEBUG
                printf ("write %08lx to p15/c1\n", value);
        #endif
                __asm__ __volatile__(
                                "mcr p15, 0, %0, c1, c0, 0 @ write it back\n"
                                :
                                : "r" (value)
                                : "memory");
                
}
static unsigned long read_p15_c1 (void)
{
                unsigned long value;
                __asm__ __volatile__(
                                "mrc p15, 0, %0, c1, c0, 0 @ read control reg\n"
                                : "=r" (value)
                                :
                                : "memory");
        #ifdef MMU_DEBUG
                printf ("p15/c1 is = %08lx\n", value);
        #endif
                return value;
}
static unsigned long read_p15_c2 (void)
{
                unsigned long value;
                __asm__ __volatile__(
                                "mrc p15, 0, %0, c2, c0, 0 @ read control reg\n"
                                : "=r" (value)
                                :
                                : "memory");
        #ifdef MMU_DEBUG
                printf ("p15/c1 is = %08lx\n", value);
        #endif
                return value;

}        

打印分页内存

int do_pagetable (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
    int i;
    int tmp;   
    unsigned int  data;
    data = read_cpsr();
    printf("cpsr=%x\n",data);    
    data  = read_p15_c1();
    printf("cp15 c1=%x\n",data);
    data = read_p15_c2();
    printf("cp15 c2=%x\n",data);
    printf("uboot address:%x offset:%x\n",CONFIG_SYS_NAND_U_BOOT_START,CONFIG_SYS_NAND_U_BOOT_OFFS);
    printf("nand page size:%x block size:%x oobsize:%x pagecount:%x \n",CONFIG_SYS_NAND_PAGE_SIZE,CONFIG_SYS_NAND_BLOCK_SIZE,CONFIG_SYS_NAND_OOBSIZE,CONFIG_SYS_NAND_PAGE_COUNT);
    printf("sdram address:%x size:%x\n",PHYS_DRAM_1,PHYS_DRAM_1_SIZE);
    printf("nand adress:%x\n",CONFIG_SYS_NAND_ADDR);
    printf("sys memtest :%x-%x\n",CONFIG_SYS_MEMTEST_START,CONFIG_SYS_MEMTEST_END);
    printf("sys load address:%x\n",CONFIG_SYS_LOAD_ADDR);
    printf("sysram address:%x size:%x\n",SRAM0_START,SRAM0_SIZE);
        
    return 0;
}

U_BOOT_CMD (page, 2, 1, do_pagetable,
    "loadable FPGA image support",
    "[operation type] [device number] [image address] [image size]\n"    
);

nand擦除

int do_nanderaseall()
{
		 int i, ret = 0;
	ulong addr;
	loff_t off, size;
	char *cmd, *s;
	nand_info_t *nand;
#ifdef CONFIG_SYS_NAND_QUIET
	int quiet = CONFIG_SYS_NAND_QUIET;
#else
	int quiet = 0;
#endif
	 
	int dev = nand_curr_device;
	 

	/* at least two arguments please */
	 
		quiet = 0;

	 
	
		nand_erase_options_t opts;
		/* "clean" at index 2 means request to write cleanmarker */
		int clean = 0;
		int o = clean ? 3 : 2;
		int scrub = 0;
		int part = 0;
		int chip = 1;
		int spread = 0;
		int args = 0;
 
			 

		/*
		 * Don't allow missing arguments to cause full chip/partition
		 * erases -- easy to do accidentally, e.g. with a misspelled
		 * variable name.
		 */
		 

		 
 		// *off = 0;
		//*size = nand_info[*idx].size;

		nand = &nand_info[dev];

		memset(&opts, 0, sizeof(opts)); 
		opts.offset = 0;
		opts.length = nand->size;
		opts.jffs2  = clean;
		opts.quiet  = quiet;
		opts.spread = spread;

		
		ret = nand_erase_opts(nand, &opts);
		printf("%s\n", ret ? "ERROR" : "OK");

		return ret == 0 ? 0 : 1;
	 
}

int do_ndel (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
     
    do_nanderaseall();
    return 0;
    
}

U_BOOT_CMD (ndel, 2, 1, do_ndel,
    "loadable FPGA image support",
    "[operation type] [device number] [image address] [image size]\n"    
);
#endif