Uboot移植TQ2440之NOR驱动之二

*

 * (C) Copyright 2002

 * Sysgo Real-Time Solutions, GmbH <

 * Alex Zuepke 

 *修改了 CONFIG_SYS_MAX_FLASH_SECT 这样的参数. 二个版本定义的不一样

 * See file CREDITS for list of people who contributed to this

  

#include 

ulong myflush (void);

#define FLASH_BANK_SIZE PHYS_FLASH_SIZE

#define MAIN_SECT_SIZE  0x10000 /* 64 KB */    //定义一个mai_sect_size  大小

//flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS];

flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS];

#define CMD_READ_ARRAY 0x000000F0

#define CMD_UNLOCK1 0x000000AA

#define CMD_UNLOCK2 0x00000055

#define CMD_ERASE_SETUP 0x00000080

#define CMD_ERASE_CONFIRM 0x00000030

#define CMD_PROGRAM 0x000000A0

#define CMD_UNLOCK_BYPASS 0x00000020

//一下的参数要根据芯片手册来确定. 查一下.应该可以看到类似的参数.按模式修改

#define MEM_FLASH_ADDR1 (*(volatile u16 *)(CONFIG_SYS_FLASH_BASE + (0x00000555 << 1)))

#define MEM_FLASH_ADDR2 (*(volatile u16 *)(CONFIG_SYS_FLASH_BASE + (0x000002AA << 1)))

/ 

#define BIT_ERASE_DONE 0x00000080

#define BIT_RDY_MASK 0x00000080

#define BIT_PROGRAM_ERROR 0x00000020

#define BIT_TIMEOUT 0x80000000 /* our flag */

#define READY 1

#define ERR   2

#define TMO   4

/*--------------------------------------------------------------------- -- 

 */

  定义Flash的ID号 ,自己jlinK可以检测出ID号.我就是这么做的,

#define EN29LV160AB_ID  0x7F2249 /* flash id     added by */

 ulong flash_init (void)

{

int i, j;

ulong size = 0;

for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) {

ulong flashbase = 0;

flash_info[i].flash_id =

#if defined(CONFIG_AMD_LV400)

(AMD_MANUFACT & FLASH_VENDMASK) |

(AMD_ID_LV400B & FLASH_TYPEMASK);

#elif defined(CONFIG_AMD_LV800)

(AMD_MANUFACT & FLASH_VENDMASK) |

(AMD_ID_LV800B & FLASH_TYPEMASK);

#elif defined (CONFIG_EON_29LV160) /* added by */

EN29LV160AB_ID    //只加这句话其实就可以了,.  

 //按照它的模式.起初我就在这个地方难住了,后来弄明白了. 这二句无非就是得出一个ID号而已,我们直接给他就是了.上面已经定义了.

//(EON_MANUFACT & FLASH_VENDMASK) |

//(EON_ID_29LV160AB & FLASH_TYPEMASK);   

//#else

//pritf("Unknown flash configured");

#endif

flash_info[i].size = FLASH_BANK_SIZE;

flash_info[i].sector_count = CONFIG_SYS_MAX_FLASH_SECT;

memset (flash_info[i].protect, 0, CONFIG_SYS_MAX_FLASH_SECT);

if (i == 0)

flashbase = PHYS_FLASH_1;

else

panic ("configured too many flash banks!\n");

for (j = 0; j < flash_info[i].sector_count; j++) {

if (j <= 3) {

/* 1st one is 16 KB */

if (j == 0) {

flash_info[i].start[j] =

flashbase + 0;

}

/* 2nd and 3rd are both 8 KB */

if ((j == 1) || (j == 2)) {

flash_info[i].start[j] =

flashbase + 0x4000 + ( j - 1 ) * 0x2000;

}

/* 4th 32 KB */

if (j == 3) {

flash_info[i].start[j] =

flashbase + 0x8000;

}

} else {

flash_info[i].start[j] =

flashbase + (j - 3) * MAIN_SECT_SIZE;

}

}

size += flash_info[i].size;

}

flash_protect (FLAG_PROTECT_SET,

       CONFIG_SYS_FLASH_BASE,

       CONFIG_SYS_FLASH_BASE + monitor_flash_len - 1,

       &flash_info[0]);

flash_protect (FLAG_PROTECT_SET,

       CONFIG_ENV_ADDR,

       CONFIG_ENV_ADDR + CONFIG_ENV_SIZE - 1, &flash_info[0]);

return size;

}

/*-----------------------------------------------------------------------

 */

void flash_print_info (flash_info_t * info)

{

int i;

switch (info->flash_id & FLASH_VENDMASK) {

case (AMD_MANUFACT & FLASH_VENDMASK):

printf ("AMD: ");

break;

  // 显示厂商

case (EON_MANUFACT & FLASH_VENDMASK):

printf("EON: ");     

break;

default:

printf ("Unknown Vendor ");

break;

}

switch (info->flash_id & FLASH_TYPEMASK) {

case (AMD_ID_LV400B & FLASH_TYPEMASK):

printf ("1x Amd29LV400BB (4Mbit)\n");

break;

case (AMD_ID_LV800B & FLASH_TYPEMASK):

printf ("1x Amd29LV800BB (8Mbit)\n");

break;

// 这里也要按照格式修改.很简单的

case (EON_ID_LV160AB & FLASH_TYPEMASK):

printf ("1x EN29LV160AB (16Mbit)\n");

break;

default:

printf ("Unknown Chip Type\n");

goto Done;

break;

}

printf ("  Size: %ld MB in %d Sectors\n",

info->size >> 20, info->sector_count);

printf ("  Sector Start Addresses:");

for (i = 0; i < info->sector_count; i++) {

if ((i % 5) == 0) {

printf ("\n   ");

}

printf (" %08lX%s", info->start[i],

info->protect[i] ? " (RO)" : "     ");

}

printf ("\n");

      Done:;

}

/*-----------------------------------------------------------------------

 */

int flash_erase (flash_info_t * info, int s_first, int s_last)

{

ushort result;

int iflag, cflag, prot, sect;

int rc = ERR_OK;

int chip;

/* first look for protection bits */

if (info->flash_id == FLASH_UNKNOWN)

return ERR_UNKNOWN_FLASH_TYPE;

if ((s_first < 0) || (s_first > s_last)) {

return ERR_INVAL;

}

if ((info->flash_id & FLASH_VENDMASK) !=

    (AMD_MANUFACT & FLASH_VENDMASK)) {

return ERR_UNKNOWN_FLASH_VENDOR;

}

prot = 0;

for (sect = s_first; sect <= s_last; ++sect) {

if (info->protect[sect]) {

prot++;

}

}

if (prot)

return ERR_PROTECTED;

/*

 * Disable interrupts which might cause a timeout

 * here. Remember that our exception vectors are

 * at address 0 in the flash, and we don't want a

 * (ticker) exception to happen while the flash

 * chip is in programming mode.

 */

cflag = icache_status ();

icache_disable ();

iflag = disable_interrupts ();

/* Start erase on unprotected sectors */

for (sect = s_first; sect <= s_last && !ctrlc (); sect++) {

printf ("Erasing sector %2d ... ", sect);

/* arm simple, non interrupt dependent timer */

reset_timer_masked ();

if (info->protect[sect] == 0) { /* not protected */

vu_short *addr = (vu_short *) (info->start[sect]);

MEM_FLASH_ADDR1 = CMD_UNLOCK1;

MEM_FLASH_ADDR2 = CMD_UNLOCK2;

MEM_FLASH_ADDR1 = CMD_ERASE_SETUP;

MEM_FLASH_ADDR1 = CMD_UNLOCK1;

MEM_FLASH_ADDR2 = CMD_UNLOCK2;

*addr = CMD_ERASE_CONFIRM;

/* wait until flash is ready */

chip = 0;

do {

result = *addr;

/* check timeout */

if (get_timer_masked () >

    CONFIG_SYS_FLASH_ERASE_TOUT) {

MEM_FLASH_ADDR1 = CMD_READ_ARRAY;

chip = TMO;

break;

}

if (!chip

    && (result & 0xFFFF) & BIT_ERASE_DONE)

chip = READY;

if (!chip

    && (result & 0xFFFF) & BIT_PROGRAM_ERROR)

chip = ERR;

} while (!chip);

MEM_FLASH_ADDR1 = CMD_READ_ARRAY;

if (chip == ERR) {

rc = ERR_PROG_ERROR;

goto outahere;

}

if (chip == TMO) {

rc = ERR_TIMOUT;

goto outahere;

}

printf ("ok.\n");

} else { /* it was protected */

printf ("protected!\n");

}

}

if (ctrlc ())

printf ("User Interrupt!\n");

      outahere:

/* allow flash to settle - wait 10 ms */

udelay_masked (10000);

if (iflag)

enable_interrupts ();

if (cflag)

icache_enable ();

return rc;

}

/*-----------------------------------------------------------------------

 * Copy memory to flash

 */

volatile static int write_hword (flash_info_t * info, ulong dest, ushort data)

{

vu_short *addr = (vu_short *) dest;

ushort result;

int rc = ERR_OK;

int cflag, iflag;

int chip;

/*

 * Check if Flash is (sufficiently) erased

 */

result = *addr;

if ((result & data) != data)

return ERR_NOT_ERASED;

/*

 * Disable interrupts which might cause a timeout

 * here. Remember that our exception vectors are

 * at address 0 in the flash, and we don't want a

 * (ticker) exception to happen while the flash

 * chip is in programming mode.

 */

cflag = icache_status ();

icache_disable ();

iflag = disable_interrupts ();

MEM_FLASH_ADDR1 = CMD_UNLOCK1;

MEM_FLASH_ADDR2 = CMD_UNLOCK2;

MEM_FLASH_ADDR1 = CMD_UNLOCK_BYPASS;

*addr = CMD_PROGRAM;

*addr = data;

/* arm simple, non interrupt dependent timer */

reset_timer_masked ();

/* wait until flash is ready */

chip = 0;

do {

result = *addr;

/* check timeout */

if (get_timer_masked () > CONFIG_SYS_FLASH_ERASE_TOUT) {

chip = ERR | TMO;

break;

}

if (!chip && ((result & 0x80) == (data & 0x80)))

chip = READY;

if (!chip && ((result & 0xFFFF) & BIT_PROGRAM_ERROR)) {

result = *addr;

if ((result & 0x80) == (data & 0x80))

chip = READY;

else

chip = ERR;

}

} while (!chip);

*addr = CMD_READ_ARRAY;

if (chip == ERR || *addr != data)

rc = ERR_PROG_ERROR;

if (iflag)

enable_interrupts ();

if (cflag)

icache_enable ();

return rc;

}

/*-----------------------------------------------------------------------

 * Copy memory to flash.

 */

int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)

{

ulong cp, wp;

int l;

int i, rc;

ushort data;

wp = (addr & ~1); /* get lower word aligned address */

/*

 * handle unaligned start bytes

 */

if ((l = addr - wp) != 0) {

data = 0;

for (i = 0, cp = wp; i < l; ++i, ++cp) {

data = (data >> 8) | (*(uchar *) cp << 8);

}

for (; i < 2 && cnt > 0; ++i) {

data = (data >> 8) | (*src++ << 8);

--cnt;

++cp;

}

for (; cnt == 0 && i < 2; ++i, ++cp) {

data = (data >> 8) | (*(uchar *) cp << 8);

}

if ((rc = write_hword (info, wp, data)) != 0) {

return (rc);

}

wp += 2;

}

/*

 * handle word aligned part

 */

while (cnt >= 2) {

data = *((vu_short *) src);

if ((rc = write_hword (info, wp, data)) != 0) {

return (rc);

}

src += 2;

wp += 2;

cnt -= 2;

}

if (cnt == 0) {

return ERR_OK;

}

/*

 * handle unaligned tail bytes

 */

data = 0;

for (i = 0, cp = wp; i < 2 && cnt > 0; ++i, ++cp) {

data = (data >> 8) | (*src++ << 8);

--cnt;

}

for (; i < 2; ++i, ++cp) {

data = (data >> 8) | (*(uchar *) cp << 8);

}

return write_hword (info, wp, data);

}