flash.c

PXA250上的XBOOT

/* 
 * $Id: flash.c,v 1.3 2003/09/26 07:11:55 jfabo Exp $
 *
 * Copyright (C) 2001, 2002 ETC s.r.o.
 *
 * 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.
 *
 * Written by Marcel Telka <[e-mail]>, 2001, 2002.
 *
 */
#include ".config.h"
#include <stdint.h>
#include <flash/cfi.h>
#include <flash/intel.h>

#include "board.h"

#include "except.h"
#include "flash.h"
#include "format.h"
#include "splash.h"

#define	FLASH(addr)	(*(volatile uint32_t *)(MEM_VIRT_FLASH + ((addr) << 2)))

#define MAXBUFSIZE	1024
#define MAXBLOCKS	256

static uint32_t flashoffset;
static uint8_t flashbuf[MAXBUFSIZE];
static size_t flashbufsize;
static uint32_t flashbufptr;
static int erasedblocks[MAXBLOCKS];
static size_t blocksize;

static void
erase( int block )
{
	if (!erasedblocks[block]) {
		EdbgOutputDebugString( "Erasing block #%d%s\n", block,
				block ? "" : "   WARNING: Overwriting xboot!" );
		if (FlashClearBlockLockBit( block ))
			Throw E_FL_BLOCKUNLOCK;
		if (FlashBlockErase( block ))
			Throw E_FL_BLOCKERASE;
		erasedblocks[block] = 1;
	}
}

static void
flash( void *dst, const void *src, size_t count )
{
	size_t offset = (size_t) dst - MEM_VIRT_FLASH;

	if ((offset % sizeof (size_t)) || (count % sizeof (size_t)))
		Throw E_FL_DATAALIGNMENT;
	/* TODO: check offset and offset + count to be in flashsize */

	while (count) {
		size_t len;
		int block = offset / blocksize;
		size_t nbo = (block + 1) * blocksize;

		if ((len = (nbo - offset)) > count)
			len = count;
		erase( block );

		count -= len;
		while (len) {
			size_t flen = (len > flashbufsize) ? flashbufsize : len;
			if (FlashWriteToBuffer( offset, src, flen / 4 ))
				Throw E_FL_WRITETOBUFFER;
			offset += flen;
			len -= flen;
			src = (void *) ((size_t) src + flen);
		}
	}
}

static void
WriteFlashBuf( void )
{
	uint32_t block = flashoffset / blocksize;
	erase( block );
	if (FlashWriteToBuffer( flashoffset, (uint32_t *) &flashbuf, (flashbufptr + 3) / 4 ))
		Throw E_FL_WRITETOBUFFER;
	flashoffset += flashbufptr;
}

static void
WriteByte( uint8_t c )
{
	flashbuf[flashbufptr++] = c;
	if (flashbufptr == flashbufsize) {
		WriteFlashBuf();
		flashbufptr = 0;
	}
}

static void
WriteDWord( uint32_t dw )
{
	WriteByte( (uint8_t) (dw & 0xFF) );
	WriteByte( (uint8_t) ((dw >> 8) & 0xFF) );
	WriteByte( (uint8_t) ((dw >> 16) & 0xFF) );
	WriteByte( (uint8_t) ((dw >> 24) & 0xFF) );
}

static void
StartFlash( uint32_t offset, struct FlashInfo *fi )
{
	int i;

	if ((fi->wbufsize > MAXBUFSIZE) || (fi->eblocks > MAXBLOCKS))
		Throw E_FL_OUTOFMEMORY;

	flashoffset = offset;
	flashbufsize = fi->wbufsize;
	flashbufptr = 0;
	blocksize = fi->eblocksize;

	for (i = 0; i < fi->eblocks; i++)
		erasedblocks[i] = 0;
}

static void
EndFlash( void )
{
	if (flashbufptr > 0)
		WriteFlashBuf();
	FlashReadArray();
}

void
FlashXIP( struct imginfo *img )
{
	unsigned int *rec = (void *) img->target;
#ifdef CONFIG_SPLASH_SCREEN
	unsigned int total_length = 0;
	unsigned char progress_percentage = 0;
#endif
	switch (img->start & 0xFF000000) {
		case MEM_VIRT_FLASH:
			img->target = img->start;
			break;
		case MEM_PHYS_FLASH:
			img->target = img->start + MEM_VIRT_FLASH - MEM_PHYS_FLASH;
			break;
		default:
			Throw E_FL_UNKNOWNMEMORY;
	}

	for (;;) {
		unsigned int addr = *rec++;
		unsigned int len = *rec++;
		unsigned int sum = *rec++;
#ifdef CONFIG_SPLASH_SCREEN
		unsigned int step = 0, current = 0;
#endif
		if (!addr && !sum) {
			FlashReadArray();
#ifdef CONFIG_SPLASH_SCREEN			
			progress_bar(100, 0);
#endif			
			return;
		}
#ifdef CONFIG_SPLASH_SCREEN
#define	LARGE_BLOCK	262144
		step = (LARGE_BLOCK < len) ? LARGE_BLOCK : len;
		current = 0;
		while (current < len) {
			total_length += step;
			if (((total_length * 100 )/ img->len ) > progress_percentage ){
				progress_percentage = (unsigned char)((total_length * 100 )/ img->len );
				progress_bar(progress_percentage, 0);
			}
			flash( (void *) (addr - img->start + img->target + current), rec + current/4, step );
			current +=step;
			step = (LARGE_BLOCK < (len - current)) ? LARGE_BLOCK : (len - current);
		}			
#else
		flash( (void *) (addr - img->start + img->target), rec, len );
#endif
		rec += len / sizeof *rec;
	}
}

void
FlashImage( struct imginfo *img, unsigned int FlashOffset )
{
	struct FlashInfo fi;
	unsigned int *rec;

	if (!FlashReadInfo( &fi ))
		Throw E_FL_READINFO;

	EdbgOutputDebugString( "Flash size: %d (0x%X)\n", fi.size, fi.size );
	EdbgOutputDebugString( "Write buffer size: %d\n", fi.wbufsize );
	EdbgOutputDebugString( "Number of blocks: %d\n", fi.eblocks );
	EdbgOutputDebugString( "Block size: %d (0x%X)\n", fi.eblocksize, fi.eblocksize );
	EdbgOutputDebugString( "\n" );

	StartFlash( FlashOffset, &fi );

	if (img->copy) {
		FlashXIP( img );
		return;
	}

	WriteByte( 'B' );
	WriteByte( '0' );
	WriteByte( '0' );
	WriteByte( '0' );
	WriteByte( 'F' );
	WriteByte( 'F' );
	WriteByte( '\n' );

	WriteDWord( img->start );
	WriteDWord( img->len );

	rec = (void *) (img->target + img->len);

	for (;;) {
		unsigned int addr = *rec++;
		unsigned int len = *rec++;
		unsigned int sum = *rec++;

		unsigned int calcCRC = 0;

		unsigned int i;

		WriteDWord( addr );
		WriteDWord( len );
		WriteDWord( sum );

		if (!addr && !sum) {
			EndFlash();
			return;
		}

		for (i = 0; i < len; i++) {
			unsigned char d = *(unsigned char *) (addr++ - img->start + img->target);
			WriteByte( d );
			calcCRC += d;
		}

		if (calcCRC != sum)
			Throw E_FL_CHECKSUM;
	}
}

static void
FlashCommand( uint8_t cmd, uint32_t addr )
{
	uint32_t command = cmd;
	FLASH( addr ) = (command << 16) | command;
}

/* 4.1 */

void
FlashReadArray( void )
{
	FlashCommand( CFI_CMD_READ_ARRAY1, 0x00 );
}

/* 4.2 */

#define	DOUBLETEST(val)		{ if (((val) & 0xFFFF) != ((val) >> 16)) return 0; }
#define	COMBINEREAD(adr1, adr2)	((FLASH( adr1 ) & 0xFF00FF) | ((FLASH( adr2 ) & 0xFF00FF) << 8))

int
FlashReadInfo( struct FlashInfo *fi )
{
	uint32_t dw;

	FlashCommand( CFI_CMD_QUERY, CFI_CMD_QUERY_OFFSET );

	/* 
	 * 4.2.1 - 4.2.3
	 */

	/* (nothing to do) */

	/* 
	 * 4.2.4 CFI Query Interface String
	 */

	/* check query-unique ascii string */
	if (FLASH( CFI_QUERY_ID_OFFSET ) != 0x00510051)
		return 0;			/* Q */
	if (FLASH( CFI_QUERY_ID_OFFSET + 1 ) != 0x00520052)
		return 0;			/* R */
	if (FLASH( CFI_QUERY_ID_OFFSET + 2) != 0x00590059)
		return 0;			/* Y */

	/* check vendor specific algorithm */
	if (COMBINEREAD( 0x13, 0x14 ) != 0x00010001)
		return 0;

	/* check extended query table primary algorithm address */
	if (COMBINEREAD( 0x15, 0x16 ) != 0x00310031)
		return 0;

	/* check alternate vendor command set */
	if (COMBINEREAD( 0x17, 0x18 ) != 0x00000000)
		return 0;

	/* check secondary algorithm extended query table address */
	if (COMBINEREAD( 0x19, 0x1A ) != 0x00000000)
		return 0;

	/* 
	 * 4.2.5 System Interface Information
	 */

	/* check Vcc logic supply minimum program/erase voltage */
	if (FLASH( 0x1B ) != 0x00270027)
		return 0;

	/* check Vcc logic supply maximum program/erase voltage */
	if (FLASH( 0x1C ) != 0x00360036)
		return 0;

	/* check Vpp [programming] supply minimum program/erase voltage */
	if (FLASH( 0x1D ) != 0x00000000)
		return 0;

	/* check Vpp [programming] supply maximum program/erase voltage */
	if (FLASH( 0x1E ) != 0x00000000)
		return 0;

	/* TODO: addresses 0x1F - 0x26 */

	/* 
	 * 4.2.6 Device Geometry Definition
	 */

	/* read device size */
	DOUBLETEST( dw = FLASH( 0x27 ) );
	/* device size is multiplied by two, because we have two ICs */
	fi->size = (1 << (dw & 0xFFFF)) * 2;

	/* read max. number of bytes in write buffer */
	DOUBLETEST( dw = COMBINEREAD( 0x2A, 0x2B ) );
	/* write buffer size is multiplied by two, because we have two ICs */
	fi->wbufsize = (1 << (dw & 0xFFFF)) * 2;

	/* check number of erase block regions */
	if (FLASH( 0x2C ) != 0x00010001)
		return 0;

	/* read number of erase blocks */
	DOUBLETEST( dw = COMBINEREAD( 0x2D, 0x2E ) );
	fi->eblocks = (uint16_t) ((dw & 0xFFFF) + 1);

	/* read erase block size */
	DOUBLETEST( dw = COMBINEREAD( 0x2F, 0x30 ) );
	/* erase block size is multiplied by two, because we have two ICs */
	fi->eblocksize = ((dw & 0xFFFF) << 8) * 2;

	/* 
	 * 4.2.7 Primary-Vendor Specific Extended Query Table
	 * TODO
	 */

	return 1;
}

#undef COMBINEREAD
#undef DOUBLETEST

/* 4.3 */

int
FlashReadID( void )
{
	FlashCommand( 0x90, 0x00 );

	/* check Manufacturer Code */
	if (FLASH( 0x00 ) != 0x890089)
		return 0;

	/* check Device Code */
	switch (FLASH( 0x01 )) {
		case 0x160016:
			return 0x16;
		case 0x170017:
			return 0x17;
		case 0x180018:
			return 0x18;
	}
	return 0;
}

/* 4.4 TODO */

uint32_t
FlashReadStatusRegister( void )
{
	FlashCommand( 0x70, 0x00 );
	return FLASH( 0x00 );
}

/* 4.5 */

void
FlashClearStatusRegister( void )
{
	FlashCommand( 0x50, 0x00 );
}

/* 4.6 */

uint32_t
FlashBlockErase( int block )
{
	FlashClearStatusRegister();
	FlashCommand( 0x20, block << 16 );	/* Block Erase Command */
	FlashCommand( 0xD0, block << 16 );	/* confirm */
	while ((FlashReadStatusRegister() & 0x00800080) != 0x00800080)	/* wait for SR.7 = 1 */
		;
	return FlashReadStatusRegister() & 0x007E007E;	/* return masked SR */
}

/* 4.8 */

uint32_t
FlashWriteToBuffer( uint32_t dst, const uint32_t *src, uint32_t size )
{
	uint32_t i;

	dst >>= 2;

	FlashClearStatusRegister();		/* clear status register */
	do {
		FlashCommand( 0xE8, dst );	/* Write to Buffer Command */
	} while ((FLASH( dst ) & 0x00800080) != 0x00800080);	/* repeat until XSR.7 = 1 */
	FlashCommand( (uint8_t) (size - 1), dst );	/* set word count */

	for (i = 0; i < size; i++)
		FLASH( dst++ ) = *src++;	/* copy data to write buffer */

	FlashCommand( 0xD0, 0x00 );		/* confirm */
	while ((FlashReadStatusRegister() & 0x00800080) != 0x00800080)	/* wait for SR.7 = 1 */
		;
	return FlashReadStatusRegister() & 0x007E007E;	/* return masked SR */
}

/* 4.14 */

uint32_t
FlashClearBlockLockBit( int block )
{
	FlashClearStatusRegister();
	FlashCommand( CFI_INTEL_CMD_LOCK_SETUP, block << 16 );
	FlashCommand( CFI_INTEL_CMD_UNLOCK_BLOCK, block << 16 );
	while ((FlashReadStatusRegister() & 0x00800080) != 0x00800080)	/* wait for SR.7 = 1 */
		;
	return FlashReadStatusRegister() & 0x007E007E;	/* return masked SR */
}