cmd_flash.c

source code of armboot for s3c4510

/*
 * (C) Copyright 2000
 * Wolfgang Denk, DENX Software Engineering, [e-mail].
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */

/*
 * FLASH support
 */
#include <armboot.h>
#include <command.h>
#include <cmd_boot.h>

#if (CONFIG_COMMANDS & CFG_CMD_FLASH)

extern flash_info_t flash_info[];	/* info for FLASH chips */
extern image_header_t header;           /* from cmd_bootm.c */

ulong giFlashAppBaseAddr=0;

/*
 * The user interface starts numbering for Flash banks with 1
 * for historical reasons.
 */

/*
 * this routine looks for an abbreviated flash range specification.
 * the syntax is B:SF[-SL], where B is the bank number, SF is the first
 * sector to erase, and SL is the last sector to erase (defaults to SF).
 * bank numbers start at 1 to be consistent with other specs, sector numbers
 * start at zero.
 *
 * returns:	1	- correct spec; *pinfo, *psf and *psl are
 *			  set appropriately
 *		0	- doesn't look like an abbreviated spec
 *		-1	- looks like an abbreviated spec, but got
 *			  a parsing error, a number out of range,
 *			  or an invalid flash bank.
 */
static int
abbrev_spec(char *str, flash_info_t **pinfo, int *psf, int *psl)
{
    flash_info_t *fp;
    int bank, first, last;
    char *p, *ep;
    
    if ((p = strchr(str, ':')) == NULL)
      return 0;
    *p++ = '\0';
    
    bank = simple_strtoul(str, &ep, 10);
    if (ep == str || *ep != '\0' ||
	bank < 1 || bank > CFG_MAX_FLASH_BANKS ||
	(fp = &flash_info[bank - 1])->flash_id == FLASH_UNKNOWN)
      return -1;
    
    str = p;
    if ((p = strchr(str, '-')) != NULL)
      *p++ = '\0';
    
    first = simple_strtoul(str, &ep, 10);
    if (ep == str || *ep != '\0' || first >= fp->sector_count)
      return -1;
    
    if (p != NULL) {
	last = simple_strtoul(p, &ep, 10);
	if (ep == p || *ep != '\0' ||
	    last < first || last >= fp->sector_count)
	  return -1;
    }
    else
      last = first;
    
    *pinfo = fp;
    *psf = first;
    *psl = last;
    
    return 1;
}

int do_flinfo (cmd_tbl_t *cmdtp, bd_t *bd, int flag, int argc, char *argv[])
{
    ulong bank;
    
    if (argc == 1)	/* print info for all FLASH banks */
    {	
		for (bank=0; bank <CFG_MAX_FLASH_BANKS; ++bank)
		{
	    	printf ("\nBank # %ld: ", bank+1);
	    	flash_print_info (&flash_info[bank]);
	    		    		    	
		}
		return 0;
    }
    
    bank = simple_strtoul(argv[1], NULL, 16);
    if ((bank < 1) || (bank > CFG_MAX_FLASH_BANKS))
    {
		printf ("Only FLASH Banks # 1 ... # %d supported\n",
			CFG_MAX_FLASH_BANKS);
		return 1;
    }
    printf ("\nBank # %ld: ", bank);
    flash_print_info (&flash_info[bank-1]);
    return 0;
}

int do_flerase(cmd_tbl_t *cmdtp, bd_t *bd, int flag, int argc, char *argv[])
{
    flash_info_t *info;
    ulong bank, addr_first, addr_last;
    int n, sect_first, sect_last;
    
    if (argc < 2)
    {
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;
    }
    
    if (strcmp(argv[1], "all") == 0)
    {
		for (bank=1; bank<=CFG_MAX_FLASH_BANKS; ++bank)
		{
	    	printf ("Erase Flash Bank # %ld:\n", bank);
	    	info = &flash_info[bank-1];
	    	n = flash_erase (info, 0, info->sector_count-1);
	    	if (n < 0)
	    	{
				flash_perror(n);
				return 1;
	    	}
	    	else
	      		printf("Done.\n");
		}
		return 0;
    }
    
    if ((n = abbrev_spec(argv[1], &info, &sect_first, &sect_last)) != 0)
    {
		if (n < 0)
		{
	    	printf("Bad sector specification\n");
	    	return 1;
		}
		printf ("Erase Flash Sectors %d-%d in Bank # %ld:\n",
                sect_first, sect_last, (info-flash_info)+1);
		
		n = flash_erase(info, sect_first, sect_last);
		if (n < 0)
		{
	  		flash_perror(n);
	  		return 1;
		}
		else
	  		printf("Done.\n");
		
		return 0;
    }
    
    
    if (argc != 3)
    {
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;
    }
    
    if (strcmp(argv[1], "bank") == 0)
    {
		bank = simple_strtoul(argv[2], NULL, 16);
		if ((bank < 1) || (bank > CFG_MAX_FLASH_BANKS))
		{
	    	printf ("Only FLASH Banks # 1 ... # %d supported\n",
		    	CFG_MAX_FLASH_BANKS);
	    	return 1;
		}
		printf ("Erase Flash Bank # %ld:\n", bank);
		info = &flash_info[bank-1];
		n = flash_erase (info, 0, info->sector_count-1);
		if (n < 0)
		{
	  		flash_perror(n);
	  		return 1;
		}
		else
	  		printf("done.\n");
		return 0;
    }
    
    addr_first = simple_strtoul(argv[1], NULL, 16);
    addr_last  = simple_strtoul(argv[2], NULL, 16);
#if defined(AM29LV320D) || defined(AT49BV321)
    if(addr_first<0x1000000 || addr_last >= 0x1400000)
#else
    if(addr_first<0x1000000 || addr_last >= 0x1200000)
#endif
    {
    	printf("Address range error !!\n");
    	printf ("Usage:\n%s\n", cmdtp->usage);
    	return 1;
    }
    
    if (addr_first >= addr_last)
    {
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;
    }
    
    printf ("Erase Flash from 0x%08lx to 0x%08lx... \n", addr_first, addr_last);
    n = flash_sect_erase(addr_first, addr_last);

    if (n < 0)
    {
    	flash_perror(n);
    	return 1;
    }
    else
      printf("done.\nErased %d sectors.\n", n);
    return 0;
}

int do_protect(cmd_tbl_t *cmdtp, bd_t *bd, int flag, int argc, char *argv[])
{
    flash_info_t *info;
    ulong bank, addr_first, addr_last;
    int i, p, n, sect_first, sect_last;
    
    if (argc < 3)
    {
    	printf ("Usage:\n%s\n", cmdtp->usage);
    	return 1;
    }
    
    if (strcmp(argv[1], "off") == 0)
    	p = 0;
    else if (strcmp(argv[1], "on") == 0)
    	p = 1;
    else
    {
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;
    }
    
    if (strcmp(argv[2], "all") == 0)
    {
		for (bank=1; bank<=CFG_MAX_FLASH_BANKS; ++bank)
		{
	    	info = &flash_info[bank-1];
	    	if (info->flash_id == FLASH_UNKNOWN)
	    	{
				continue;
	    	}
	    	printf ("%sProtect Flash Bank # %ld\n",
		    	p ? "" : "Un-", bank);
	    
	    	for (i=0; i<info->sector_count; ++i)
	    	{
				info->protect[i] = p;
	    	}
		}

		return 0;
    }
    
    if ((n = abbrev_spec(argv[2], &info, &sect_first, &sect_last)) != 0)
    {
		if (n < 0)
		{
	    	printf("Bad sector specification\n");
	    	return 1;
		}
		printf("%sProtect Flash Sectors %d-%d in Bank # %ld\n",
             	 p ? "" : "Un-", sect_first, sect_last, 
		   		(info-flash_info)+1);

		for (i = sect_first; i <= sect_last; i++)
		{
			info->protect[i] = p;
		}
		return 0;
    }
    
    if (argc != 4)
    {
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;
    }
    
    if (strcmp(argv[2], "bank") == 0)
    {
		bank = simple_strtoul(argv[3], NULL, 16);
		if ((bank < 1) || (bank > CFG_MAX_FLASH_BANKS))
		{
	    	printf ("Only FLASH Banks # 1 ... # %d supported\n",
		    	CFG_MAX_FLASH_BANKS);
	    	return 1;
		}

		printf ("%sProtect Flash Bank # %ld\n",
			p ? "" : "Un-", bank);

		info = &flash_info[bank-1];
	
		if (info->flash_id == FLASH_UNKNOWN)
		{
	    	printf ("missing or unknown FLASH type\n");
	    	return 1;
		}

		for (i=0; i<info->sector_count; ++i)
		{
	    	info->protect[i] = p;
		}
		return 0;
    }
    
    addr_first = simple_strtoul(argv[2], NULL, 16);
    addr_last  = simple_strtoul(argv[3], NULL, 16);
    
    if (addr_first >= addr_last)
    {
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;
    }
    
    return flash_sect_protect (p, addr_first, addr_last) ? 1 : 0;
}

int flash_sect_protect (int p, ulong addr_first, ulong addr_last)
{
    flash_info_t *info;
    ulong bank;
    int s_first, s_last;
    int protection, i;
    int rc = ERR_OK;
    
    protection = 0;
    
    for (bank=0,info=&flash_info[0]; bank < CFG_MAX_FLASH_BANKS; ++bank, ++info)
    {
		ulong b_end;
		int sect;
	
		if (info->flash_id == FLASH_UNKNOWN)
		{
	    	continue;
		}
	
		b_end = info->start[0] + info->size - 1; /* bank end addr */
	
		s_first = -1;		/* first sector to erase	*/
		s_last  = -1;		/* last  sector to erase	*/
	
		for (sect=0; sect < info->sector_count; ++sect)
		{
	    	ulong end;		/* last address in current sect	*/
	    	short s_end;
	    
	    	s_end = info->sector_count - 1;
	    
	    	end = (sect == s_end) ? b_end : info->start[sect + 1] - 1;
	    
	    	if (addr_first > end)
	      		continue;
	    	if (addr_last < info->start[sect])
	      		continue;
	    
	    	if (addr_first == info->start[sect])
	    	{
				s_first = sect;
	    	}
	    	if (addr_last  == end)
	    	{
				s_last  = sect;
	    	}
		}
	
		if (s_first>=0 && s_first<=s_last)
		{
	    	protection += s_last - s_first + 1;
	    	for (i=s_first; i<=s_last; ++i)
	    	{
				info->protect[i] = p;
	    	}
		}
    }
    
    if (protection)
    {
		printf ("%sProtected %d sectors\n",
			p ? "" : "Un-", protection);
    }
    else
    {
		rc = ERR_ALIGN;
		flash_perror(rc);
    }
    return rc;
}
// by laputa start
int  flash_protect_range(unsigned short * flashptr,int start, int end, int flag)
{

    //unsigned long from, to;
    ulong from, to;

    from  = PHYS_FLASH_1 +  (ulong)start;       // 0x8000 0000 + start
    to  = PHYS_FLASH_1 + (ulong)end;        // 0x8000 0000 + end

    printf("\nFlash  PROTECT ");
    (flag) ? printf("SET  ") : printf("CLEAR  ");

    printf(" [%x] ~ [%x]\n\n ",from, to);


    //flash_protect (flag, from, to, &flash_info[0]);
    if(flash_sect_protect(flag,from,to) == ERR_OK)
        return 1;                           //PROTECT SET/CLEAR OK
    else
        return 0;                           // SET/CLEAR ERROR
}


int do_flwrite(cmd_tbl_t * cmdtp, bd_t * bd, int flag, int argc, char *argv[])
{
	flash_info_t *info;
	ulong b_end;
	image_header_t 	*hdr = &header;
	int rc = ERR_OK;
	int n,sect;
	ulong len,len_mod,addr_last,src;
	ulong addr_last_erase;
	ulong data, checksum;
	int IncImgHeader;

	memcpy (&header, (char *)load_addr, sizeof(image_header_t));

	// Basically including the image header.
	IncImgHeader = 1;

	if (argc > 3)
    	{
	    	printf ("Usage:\n%s\n", cmdtp->usage);
	    	return 1;
    	}
	
	if (argc == 3)
	{
		
		if(!strcmp(argv[2], "0"))
		{
			IncImgHeader = 0;
		}
		else if(!strcmp(argv[2], "1"))
		{
			IncImgHeader = 1;
		}
		else
		{
#if defined(CONFIG_S3C2500) || defined(CONFIG_S3C2510)
    		printf ("Usage:flwrite 80020000 1(include)/0(not include)\n");
#else
    		printf ("Usage:flwrite 1020000 1(include)/0(not include)\n");
#endif
			return 1;
		}
	}
	
	if (argc < 2) 
	{
		giFlashAppBaseAddr = SWAP32(hdr->ih_load);		/* Flash writing address */
		//printf("the giFlashAppBaseAddr is : 0x%8x\n",giFlashAppBaseAddr);
	} 
	else // argc >=2
	{
		giFlashAppBaseAddr = simple_strtoul(argv[1], NULL, 16);
		//printf("the giFlashAppBaseAddr is : 0x%8x\n",giFlashAppBaseAddr);
	}

	// avoid writing armboot region
#if defined(CONFIG_S3C2500) || defined(CONFIG_S3C2510)
	if((giFlashAppBaseAddr > 0x80000000)&&(giFlashAppBaseAddr < 0x80020000))
#else
	if((giFlashAppBaseAddr > 0x1000000)&&(giFlashAppBaseAddr < 0x1020000))
#endif
	{
		rc = ERR_PROTECTED;
		flash_perror(rc);
    		return 1;
	}

	printf ("\n## Checking Image at %08lx ...\n", load_addr);

	if (SWAP32(hdr->ih_magic)  != IH_MAGIC)
	{
		printf ("   Bad Magic Number\n");
		return 1;
	}

	data = (ulong)&header;
	len  = sizeof(image_header_t);

	checksum = SWAP32(hdr->ih_hcrc);
	hdr->ih_hcrc = 0;

	if (crc32 (0, (char *)data, len) != checksum)
	{
		printf ("   Bad Header Checksum\n");
		return 1;
	}

	/* for multi-file images we need the data part, too */
	print_image_hdr ((image_header_t *)load_addr);

	data = load_addr + sizeof(image_header_t);
	len  = SWAP32(hdr->ih_size);

	printf ("   Verifying Checksum ... ");
	if (crc32 (0, (char *)data, len) != SWAP32(hdr->ih_dcrc))
	{
		printf ("   Bad Data CRC\n");
		return 1;
	}
	printf ("OK\n");

	if(IncImgHeader)
	{
		src = load_addr;
		len = len + sizeof(image_header_t);
		addr_last = giFlashAppBaseAddr + len;
	}
	else
	{
	//	src = load_addr + 64;
		src = load_addr + sizeof(image_header_t);
		addr_last = giFlashAppBaseAddr + len;
	}

#if defined(AM29LV320D) || defined(AT49BV321)
	if((len > 0x3e0000)||(addr_last > (CFG_FLASH_BASE+0x3fffff)))
#else
	if((len > 0x1e0000)||(addr_last > (CFG_FLASH_BASE+0x1fffff)))
#endif
	{
	
//hill 20070921
#if 1
		printf("the the image data size is : 0x%8x\n",len);
		printf("the end address to write is : 0x%8x\n",addr_last);
		
		printf("the load_addr is : 0x%8x\n",load_addr);
#endif

		rc = ERR_SIZE;
		flash_perror(rc);
    	return 1;
	}

	
	info=&flash_info[0];
	b_end = info->start[0] + info->size - 1; /* bank end addr */
	
	addr_last_erase = addr_last;
	
	for (sect=0; sect < info->sector_count; ++sect)
	{
	   	ulong end;		/* last address in current sect */
	   	short s_end;
  
	   	s_end = info->sector_count - 1;
	   
	   	end = (sect == s_end) ? b_end : info->start[sect + 1] - 1;
		   	
	   	if((signed long)(addr_last_erase - end) < 0 )
	    {
	    	addr_last_erase = end;
	    	break;
	    }
	}

	n = flash_sect_erase(giFlashAppBaseAddr, addr_last_erase);
    if (n < 0)
    {
    	flash_perror(n);
    	return 1;
    }
    else
      printf("done.\nErased %d sectors.\n", n);
	
	printf("Saving Image to Flash...wait...");

	len_mod = len % 2;
	if(len_mod)
		len += 1;
		

    rc = flash_write((char *)src, giFlashAppBaseAddr,len) ;
    if (rc < 0)
    {
    	flash_perror(rc);
    	return 1;
    }
    
    else 
      printf("\b\b\b\b\b\b\bdone.\n");

	return 0;
}

#endif	/* CFG_CMD_FLASH */