flashlib.c

大名鼎鼎的mpc8260的bsp源代码

    if (flashCheck(dev) == ERROR)
	return ERROR;

    for (sector = 0; sector < dev->sectors; sector++)
	if (flashBootEraseSector(dev, sector) == ERROR)
	    return ERROR;

    return OK;
}

/*
 * Read and write bytes
 */

STATUS flashRead(flash_dev_t *dev, int pos, char *buf, int len)
{
    unsigned int			addr, words;

    PRINTF("flashRead: dev=%d pos=0x%x buf=0x%x len=0x%x\n",
	   DEV_NO(dev), pos, (int) buf, len);

    if (flashCheck(dev) == ERROR)
	return ERROR;

    if (pos < 0 || len < 0 || pos + len > FLASH_MAX_POS(dev)) {
	printf("flashRead: Position out of range "
	       "(dev: %d, pos: 0x%x, len: 0x%x)\n",
	       DEV_NO(dev), pos, len);
	return ERROR;
    }

    if (len == 0)
	return OK;


	addr = pos;
	words = len;

	PRINTF("flashRead: memcpy(0x%x, 0x%x, 0x%x)\n",
	       (int) buf, (int) FLASH_ADDR(dev, pos), len);

	memcpy(buf, FLASH_ADDR(dev, addr), words);


    PRINTF("flashRead: rv=OK\n");

    return OK;
}

STATUS flashWrite(flash_dev_t *dev, int pos, char *buf, int len)
{
	unsigned int 		addr, words;
    	UINT32 tmp;

    PRINTF("flashWrite: dev=%d pos=0x%x buf=0x%x len=0x%x\n",
	   DEV_NO(dev), pos, (int) buf, len);

    if (flashCheck(dev) == ERROR)
	return ERROR;

    if (pos < 0 || len < 0 || pos + len > FLASH_MAX_POS(dev)) {
	printf("flashWrite: Position out of range "
	       "(dev: %d, pos: 0x%x, len: 0x%x)\n",
	       DEV_NO(dev), pos, len);
	return ERROR;
    }

    if (len == 0)
	return OK;



	addr = pos ;
	words = len;

	while (words--) {
	    tmp = * buf;

#if FALSE/*def YOUNG*/
        if (~FLASH_READ(dev, addr) & tmp) {
		    printf("flashWrite: Attempt to program 0 to 1 "
		       "(dev: %d, addr: 0x%x, data: 0x%x)\n",
		       DEV_NO(dev), addr, tmp);
		    return ERROR;
	    }
 #endif

	    FLASH_WRITE(dev, 0xaaa, 0xaa);
	    FLASH_WRITE(dev, 0x555, 0x55);
	    FLASH_WRITE(dev, 0xaaa, 0xa0);
	    FLASH_WRITE(dev, addr, tmp);
	    if (flashWait(dev, addr, tmp, 0) < 0)
		return ERROR;
	    buf ++;
	    addr++;
	
    }

    PRINTF("flashWrite: rv=OK\n");

    return OK;
}

STATUS flashBootWrite(flash_dev_t *dev, int pos, char *buf, int len)
{
	unsigned int 		addr, words;
    UINT32 tmp;

    if (len == 0)
	return OK;

	addr = pos ;
	words = len;

	while (words--) {
	    tmp = * buf;

	    FLASH_WRITE(dev, 0x555, 0xAA);
	    FLASH_WRITE(dev, 0x2AA, 0x55);
	    FLASH_WRITE(dev, 0x555, 0xA0);
	    FLASH_WRITE(dev, addr, tmp);
	    if (flashWait(dev, addr, tmp, 0) < 0)
		return ERROR;
	    buf ++;
	    addr++;
	
    }

    return OK;
}

/*
 * flashWritable returns TRUE if a range contains all F's.
 */

STATUS flashWritable(flash_dev_t *dev, int pos, int len)
{
	unsigned  int 		addr, words;
    int			rv = ERROR;

    PRINTF("flashWritable: dev=%d pos=0x%x len=0x%x\n",
	   DEV_NO(dev), pos, len);

    if (flashCheck(dev) == ERROR)
	goto done;

    if (pos < 0 || len < 0 || pos + len > FLASH_MAX_POS(dev)) {
	printf("flashWritable: Position out of range "
	       "(dev: %d, pos: 0x%x, len: 0x%x)\n",
	       DEV_NO(dev), pos, len);
	goto done;
    }

    if (len == 0) {
	rv = 1;
	goto done;
    }



	addr = pos;
	words = len;

	while (words--) {
	    if (FLASH_READ(dev, addr) != 0xff) {
		rv = 0;
		goto done;
	    }
	    addr++;
	}
    

    rv = 1;

 done:
    PRINTF("flashWrite: rv=%d\n", rv);
    return rv;
}

/***********************************************************************
 *
 * Flash Diagnostics
 *
 ***********************************************************************/

STATUS flashDiag(flash_dev_t *dev)
{
    UINT32		*buf = 0;
    int			i, len, sector;
    int			rv = ERROR;

    if (flashCheck(dev) == ERROR)
	return ERROR;

    printf("flashDiag: Testing device %d, "
	   "base: 0x%x, %d sectors @ %d kB = %d kB\n",
	   DEV_NO(dev), dev->base,
	   dev->sectors,
	   1 << (dev->lgSectorSize - 10),
	   dev->sectors << (dev->lgSectorSize - 10));

    len = 1 << dev->lgSectorSize;

    printf("flashDiag: Erasing\n");

    if (flashErase(dev) == ERROR) {
	printf("flashDiag: Erase failed\n");
	goto done;
    }

    buf = malloc(len);

    if (buf == 0) {
	printf("flashDiag: Out of memory, malloc %d\n", len);
	goto done;
    }

    /*
     * Write unique counting pattern to each sector
     */

    for (sector = 0; sector < dev->sectors; sector++) {
	printf("flashDiag: Write sector %d\n", sector);

	for (i = 0; i < len / 4; i++)
	    buf[i] = sector << 24 | i;

	if (flashWrite(dev,
		       sector << dev->lgSectorSize,
		       (char *) buf,
		       len) == ERROR) {
	    printf("flashDiag: Write failed (dev: %d, sector: %d)\n",
		   DEV_NO(dev), sector);
	    goto done;
	}
    }

    /*
     * Verify
     */

    for (sector = 0; sector < dev->sectors; sector++) {
	printf("flashDiag: Verify sector %d\n", sector);

	if (flashRead(dev,
		      sector << dev->lgSectorSize,
		      (char *) buf,
		      len) == ERROR) {
	    printf("flashDiag: Read failed (dev: %d, sector: %d)\n",
		   DEV_NO(dev), sector);
	    goto done;
	}

	for (i = 0; i < len / 4; i++) {
	    if (buf[i] != (sector << 24 | i)) {
		printf("flashDiag: Verify error "
		       "(dev: %d, sector: %d, offset: 0x%x)\n",
		       DEV_NO(dev), sector, i);
		printf("flashDiag: Expected 0x%08x, got 0x%08x\n",
		       sector << 24 | i, buf[i]);

		goto done;
	    }
	}
    }

    printf("flashDiag: Erasing\n");

    if (flashErase(dev) == ERROR) {
	printf("flashDiag: Final erase failed\n");
	goto done;
    }

    rv = OK;

 done:
    if (buf)
	free(buf);

    if (rv == OK)
	printf("flashDiag: Device %d passed\n", DEV_NO(dev));
    else
	printf("flashDiag: Device %d failed\n", DEV_NO(dev));

    return rv;
}

STATUS flashDiagAll(void)
{
    int			i;
    int			rv = OK;

    PRINTF("flashDiagAll: devices=%d\n", flashDevCount);

    for (i = 0; i < flashDevCount; i++) {
	flash_dev_t	*dev = &flashDev[i];
      if (dev->bank==FLASH_BANK) /* added for not erasing bootrom 04apr03,lyx */
          if (dev->found && flashDiag(dev) == ERROR)
	    rv = ERROR;
    }

    if (rv == OK)
	printf("flashDiagAll: Passed\n");
    else
	printf("flashDiagAll: Failed because of earlier errors\n");

    return rv;
}

void flashDrvLibInit()
{
}

void memcat(char *buff, int count, int column)
{  	
	int i,j; 
	i=0; 
	if ((count>0)&&(column>0))
	{     
	while(i<count)   
	{    
		for (j =1; j<=column; j++)      
		{          printf(" %02x", *(buff++));        
		if (!(j % column)) printf("\n");         
		i++;          
		if(i>=count)
		{ printf("\n");             
			break;                   
		}/*if*/  
	}/*for*/
	}/*while*/
	}/*if*/
}

#if 1
void flashDiagNo(int devno)
{
  flashDiag(&flashDev[devno]);
}
void flashTest(int devno, int offset, char c)
{
      char i;
      char buffer[64];

      memset(buffer, c, 64);      
      flashErase(&flashDev[devno]);
      


      memcat(buffer, 64, 16);

      flashWrite(&flashDev[devno],  offset, buffer, 64);
      
      bzero(buffer, 64);
      flashRead(&flashDev[devno], offset, buffer, 64);
            memcat(buffer, 64, 16);
            
            bzero(buffer, 64);
      flashRead(&flashDev[devno], offset, buffer, 64);
      memcat(buffer, 64, 16);
      
            bzero(buffer, 64);
      flashRead(&flashDev[devno], offset, buffer, 64);
      memcat(buffer, 64, 16);
}

void flashTest1(int devno, int offset, char c)
{
      char i;
      char buffer[64];

      memset(buffer, 0, 64);
      flashRead(&flashDev[devno], offset, buffer, 64);
      memcat(buffer, 64, 16);
}

/* 查询SecSi 扇区信息 */
void flashGetSecSiProtect (int devno)
{
	unsigned int	FactoryProtect, ProtectVerify;
	flash_dev_t		*dev;

	dev = &flashDev[devno];
	
	/* 查询Factory protect */
	FLASH_WRITE (dev, 0, 0xF0);

	FLASH_WRITE (dev, 0xAAA, 0xAA);
	FLASH_WRITE (dev, 0x555, 0x55);
	FLASH_WRITE (dev, 0xAAA, 0x90);

	taskDelay (1);
	
	/* 读protect值 */
	FactoryProtect = FLASH_READ (dev, 0x06);

	/* 查询protect verify */
	FLASH_WRITE (dev, 0, 0xF0);

	FLASH_WRITE (dev, 0xAAA, 0xAA);
	FLASH_WRITE (dev, 0x555, 0x55);
	FLASH_WRITE (dev, 0xAAA, 0x90);

	/* 读protect值 */
	ProtectVerify = FLASH_READ (dev, 0x04);

	/* 复位 */
	FLASH_WRITE (dev, 0, 0xF0);
	
	printf ("FactoryProtect: %x ProtectVerify: %x\n", FactoryProtect, ProtectVerify);
}

/* 进入SecSi扇区 */
void flashSecSiEnter (int devno)
{
	flash_dev_t		*dev;

	dev = &flashDev[devno];
	
	/* 进入SecSi扇区 */
	FLASH_WRITE (dev, 0, 0xF0);

	FLASH_WRITE (dev, 0xAAA, 0xAA);
	FLASH_WRITE (dev, 0x555, 0x55);
	FLASH_WRITE (dev, 0xAAA, 0x88);
}

/* 离开SecSi扇区 */
void flashSecSiLeave (int devno)
{
	flash_dev_t		*dev;

	dev = &flashDev[devno];
	
	/* 离开SecSi扇区 */
	FLASH_WRITE (dev, 0xAAA, 0xAA);
	FLASH_WRITE (dev, 0x555, 0x55);
	FLASH_WRITE (dev, 0xAAA, 0x90);
	FLASH_WRITE (dev, 0xAAA, 0x00);

	FLASH_WRITE (dev, 0, 0xF0);
}

/* SecSi扇区编程 */
void flashSecSiProgram (int devno, int offset, char *buf, int len)
{
	flash_dev_t		*dev;

	dev = &flashDev[devno];

	flashWrite (dev, offset, buf, len);
}

/* BOOTROM FLASH初始化 */
void flashBootDevInit ()
{
	int			i;
	flash_dev_t	*dev;

    for (i = 0; i < FLASH_BOOTDEV_COUNT; i ++) {
		dev = &flashBootDev[i];

		flashBootReset(dev);

		if (flashBootProbe(dev) != ERROR)
	    	dev->found = 1;
    }

    return OK;
}

/* BOOTROM FLASH写 */
void flashBootDevProgram (int devno, int offset, char *buf, int len)
{
	flash_dev_t		*dev;

	dev = &flashBootDev[devno];

	flashBootWrite (dev, offset, buf, len);
}

#endif