[people/ms/u-boot.git] / board / bf533-ezkit / flash.c

/*
 * U-boot - flash.c Flash driver for PSD4256GV
 *
 * Copyright (c) 2005-2007 Analog Devices Inc.
 * This file is based on BF533EzFlash.c originally written by Analog Devices, Inc.
 *
 * (C) Copyright 2000-2004
 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <asm/io.h>
#include "flash-defines.h"

int AFP_NumSectors = 40;
long AFP_SectorSize1 = 0x10000;
int AFP_SectorSize2 = 0x4000;

void flash_reset(void)
{
	reset_flash();
}

unsigned long flash_get_size(ulong baseaddr, flash_info_t * info, int bank_flag)
{
	int id = 0, i = 0;
	static int FlagDev = 1;

	id = get_codes();
	if (FlagDev) {
#ifdef DEBUG
		printf("Device ID of the Flash is %x\n", id);
#endif
		FlagDev = 0;
	}
	info->flash_id = id;

	switch (bank_flag) {
	case 0:
		for (i = PriFlashABegin; i < SecFlashABegin; i++)
			info->start[i] = (baseaddr + (i * AFP_SectorSize1));
		info->size = 0x200000;
		info->sector_count = 32;
		break;
	case 1:
		info->start[0] = baseaddr + SecFlashASec1Off;
		info->start[1] = baseaddr + SecFlashASec2Off;
		info->start[2] = baseaddr + SecFlashASec3Off;
		info->start[3] = baseaddr + SecFlashASec4Off;
		info->size = 0x10000;
		info->sector_count = 4;
		break;
	case 2:
		info->start[0] = baseaddr + SecFlashBSec1Off;
		info->start[1] = baseaddr + SecFlashBSec2Off;
		info->start[2] = baseaddr + SecFlashBSec3Off;
		info->start[3] = baseaddr + SecFlashBSec4Off;
		info->size = 0x10000;
		info->sector_count = 4;
		break;
	}
	return (info->size);
}

unsigned long flash_init(void)
{
	unsigned long size_b0, size_b1, size_b2;
	int i;

	size_b0 = size_b1 = size_b2 = 0;
#ifdef DEBUG
	printf("Flash Memory Start 0x%x\n", CONFIG_SYS_FLASH_BASE);
	printf("Memory Map for the Flash\n");
	printf("0x20000000 - 0x200FFFFF Flash A Primary (1MB)\n");
	printf("0x20100000 - 0x201FFFFF Flash B Primary (1MB)\n");
	printf("0x20200000 - 0x2020FFFF Flash A Secondary (64KB)\n");
	printf("0x20280000 - 0x2028FFFF Flash B Secondary (64KB)\n");
	printf("Please type command flinfo for information on Sectors \n");
#endif
	for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; ++i) {
		flash_info[i].flash_id = FLASH_UNKNOWN;
	}

	size_b0 = flash_get_size(CONFIG_SYS_FLASH0_BASE, &flash_info[0], 0);
	size_b1 = flash_get_size(CONFIG_SYS_FLASH0_BASE, &flash_info[1], 1);
	size_b2 = flash_get_size(CONFIG_SYS_FLASH0_BASE, &flash_info[2], 2);

	if (flash_info[0].flash_id == FLASH_UNKNOWN || size_b0 == 0) {
		printf("## Unknown FLASH on Bank 0 - Size = 0x%08lx = %ld MB\n",
		       size_b0, size_b0 >> 20);
	}

	(void)flash_protect(FLAG_PROTECT_SET, CONFIG_SYS_FLASH0_BASE,
			    (flash_info[0].start[2] - 1), &flash_info[0]);

	return (size_b0 + size_b1 + size_b2);
}

void flash_print_info(flash_info_t * info)
{
	int i;

	if (info->flash_id == FLASH_UNKNOWN) {
		printf("missing or unknown FLASH type\n");
		return;
	}

	switch (info->flash_id) {
	case FLASH_PSD4256GV:
		printf("ST Microelectronics ");
		break;
	default:
		printf("Unknown Vendor: (0x%08lX) ", info->flash_id);
		break;
	}
	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");
	return;
}

int flash_erase(flash_info_t * info, int s_first, int s_last)
{
	int cnt = 0, i;
	int prot, sect;

	prot = 0;
	for (sect = s_first; sect <= s_last; ++sect) {
		if (info->protect[sect])
			prot++;
	}

	if (prot)
		printf("- Warning: %d protected sectors will not be erased!\n",
		       prot);
	else
		printf("\n");

	cnt = s_last - s_first + 1;

	if (cnt == FLASH_TOT_SECT) {
		printf("Erasing flash, Please Wait \n");
		if (erase_flash() < 0) {
			printf("Erasing flash failed \n");
			return FLASH_FAIL;
		}
	} else {
		printf("Erasing Flash locations, Please Wait\n");
		for (i = s_first; i <= s_last; i++) {
			if (info->protect[i] == 0) {	/* not protected */
				if (erase_block_flash(i, info->start[i]) < 0) {
					printf("Error Sector erasing \n");
					return FLASH_FAIL;
				}
			}
		}
	}
	return FLASH_SUCCESS;
}

int write_buff(flash_info_t * info, uchar * src, ulong addr, ulong cnt)
{
	int ret;
	int d;
	if (addr % 2) {
		read_flash(addr - 1 - CONFIG_SYS_FLASH_BASE, &d);
		d = (int)((d & 0x00FF) | (*src++ << 8));
		ret = write_data(addr - 1, 2, (uchar *) & d);
		if (ret == FLASH_FAIL)
			return ERR_NOT_ERASED;
		ret = write_data(addr + 1, cnt - 1, src);
	} else
		ret = write_data(addr, cnt, src);
	if (ret == FLASH_FAIL)
		return ERR_NOT_ERASED;
	return FLASH_SUCCESS;
}

int write_data(long lStart, long lCount, uchar * pnData)
{
	long i = 0;
	unsigned long ulOffset = lStart - CONFIG_SYS_FLASH_BASE;
	int d;
	int nSector = 0;
	int flag = 0;

	if (lCount % 2) {
		flag = 1;
		lCount = lCount - 1;
	}

	for (i = 0; i < lCount - 1; i += 2, ulOffset += 2) {
		get_sector_number(ulOffset, &nSector);
		read_flash(ulOffset, &d);
		if (d != 0xffff) {
			printf
			    ("Flash not erased at offset 0x%lx Please erase to reprogram\n",
			     ulOffset);
			return FLASH_FAIL;
		}
		unlock_flash(ulOffset);
		d = (int)(pnData[i] | pnData[i + 1] << 8);
		write_flash(ulOffset, d);
		if (poll_toggle_bit(ulOffset) < 0) {
			printf("Error programming the flash \n");
			return FLASH_FAIL;
		}
		if ((i > 0) && (!(i % AFP_SectorSize2)))
			printf(".");
	}
	if (flag) {
		get_sector_number(ulOffset, &nSector);
		read_flash(ulOffset, &d);
		if (d != 0xffff) {
			printf
			    ("Flash not erased at offset 0x%lx Please erase to reprogram\n",
			     ulOffset);
			return FLASH_FAIL;
		}
		unlock_flash(ulOffset);
		d = (int)(pnData[i] | (d & 0xFF00));
		write_flash(ulOffset, d);
		if (poll_toggle_bit(ulOffset) < 0) {
			printf("Error programming the flash \n");
			return FLASH_FAIL;
		}
	}
	return FLASH_SUCCESS;
}

int read_data(long ulStart, long lCount, long lStride, int *pnData)
{
	long i = 0;
	int j = 0;
	long ulOffset = ulStart;
	int iShift = 0;
	int iNumWords = 2;
	int nLeftover = lCount % 4;
	int nHi, nLow;
	int nSector = 0;

	for (i = 0; (i < lCount / 4) && (i < BUFFER_SIZE); i++) {
		for (iShift = 0, j = 0; j < iNumWords; j += 2) {
			if ((ulOffset >= INVALIDLOCNSTART)
			    && (ulOffset < INVALIDLOCNEND))
				return FLASH_FAIL;

			get_sector_number(ulOffset, &nSector);
			read_flash(ulOffset, &nLow);
			ulOffset += (lStride * 2);
			read_flash(ulOffset, &nHi);
			ulOffset += (lStride * 2);
			pnData[i] = (nHi << 16) | nLow;
		}
	}
	if (nLeftover > 0) {
		if ((ulOffset >= INVALIDLOCNSTART)
		    && (ulOffset < INVALIDLOCNEND))
			return FLASH_FAIL;

		get_sector_number(ulOffset, &nSector);
		read_flash(ulOffset, &pnData[i]);
	}
	return FLASH_SUCCESS;
}

int write_flash(long nOffset, int nValue)
{
	long addr;

	addr = (CONFIG_SYS_FLASH_BASE + nOffset);
	SSYNC();
	*(unsigned volatile short *)addr = nValue;
	SSYNC();
	if (poll_toggle_bit(nOffset) < 0)
		return FLASH_FAIL;
	return FLASH_SUCCESS;
}

int read_flash(long nOffset, int *pnValue)
{
	int nValue = 0x0;
	long addr = (CONFIG_SYS_FLASH_BASE + nOffset);

	if (nOffset != 0x2)
		reset_flash();
	SSYNC();
	nValue = *(volatile unsigned short *)addr;
	SSYNC();
	*pnValue = nValue;
	return true;
}

int poll_toggle_bit(long lOffset)
{
	unsigned int u1, u2;
	unsigned long timeout = 0xFFFFFFFF;
	volatile unsigned long *FB =
	    (volatile unsigned long *)(0x20000000 + lOffset);
	while (1) {
		if (timeout < 0)
			break;
		u1 = *(volatile unsigned short *)FB;
		u2 = *(volatile unsigned short *)FB;
		if ((u1 & 0x0040) == (u2 & 0x0040))
			return FLASH_SUCCESS;
		if ((u2 & 0x0020) == 0x0000)
			continue;
		u1 = *(volatile unsigned short *)FB;
		if ((u2 & 0x0040) == (u1 & 0x0040))
			return FLASH_SUCCESS;
		else {
			reset_flash();
			return FLASH_FAIL;
		}
		timeout--;
	}
	printf("Time out occured \n");
	if (timeout < 0)
		return FLASH_FAIL;
}

void reset_flash(void)
{
	write_flash(WRITESEQ1, RESET_VAL);
	/* Wait for 10 micro seconds */
	udelay(10);
}

int erase_flash(void)
{
	write_flash(WRITESEQ1, WRITEDATA1);
	write_flash(WRITESEQ2, WRITEDATA2);
	write_flash(WRITESEQ3, WRITEDATA3);
	write_flash(WRITESEQ4, WRITEDATA4);
	write_flash(WRITESEQ5, WRITEDATA5);
	write_flash(WRITESEQ6, WRITEDATA6);

	if (poll_toggle_bit(0x0000) < 0)
		return FLASH_FAIL;

	write_flash(SecFlashAOff + WRITESEQ1, WRITEDATA1);
	write_flash(SecFlashAOff + WRITESEQ2, WRITEDATA2);
	write_flash(SecFlashAOff + WRITESEQ3, WRITEDATA3);
	write_flash(SecFlashAOff + WRITESEQ4, WRITEDATA4);
	write_flash(SecFlashAOff + WRITESEQ5, WRITEDATA5);
	write_flash(SecFlashAOff + WRITESEQ6, WRITEDATA6);

	if (poll_toggle_bit(SecFlashASec1Off) < 0)
		return FLASH_FAIL;

	write_flash(PriFlashBOff + WRITESEQ1, WRITEDATA1);
	write_flash(PriFlashBOff + WRITESEQ2, WRITEDATA2);
	write_flash(PriFlashBOff + WRITESEQ3, WRITEDATA3);
	write_flash(PriFlashBOff + WRITESEQ4, WRITEDATA4);
	write_flash(PriFlashBOff + WRITESEQ5, WRITEDATA5);
	write_flash(PriFlashBOff + WRITESEQ6, WRITEDATA6);

	if (poll_toggle_bit(PriFlashBOff) < 0)
		return FLASH_FAIL;

	write_flash(SecFlashBOff + WRITESEQ1, WRITEDATA1);
	write_flash(SecFlashBOff + WRITESEQ2, WRITEDATA2);
	write_flash(SecFlashBOff + WRITESEQ3, WRITEDATA3);
	write_flash(SecFlashBOff + WRITESEQ4, WRITEDATA4);
	write_flash(SecFlashBOff + WRITESEQ5, WRITEDATA5);
	write_flash(SecFlashBOff + WRITESEQ6, WRITEDATA6);

	if (poll_toggle_bit(SecFlashBOff) < 0)
		return FLASH_FAIL;

	return FLASH_SUCCESS;
}

int erase_block_flash(int nBlock, unsigned long address)
{
	long ulSectorOff = 0x0;

	if ((nBlock < 0) || (nBlock > AFP_NumSectors))
		return false;

	ulSectorOff = (address - CONFIG_SYS_FLASH_BASE);

	write_flash((WRITESEQ1 | ulSectorOff), WRITEDATA1);
	write_flash((WRITESEQ2 | ulSectorOff), WRITEDATA2);
	write_flash((WRITESEQ3 | ulSectorOff), WRITEDATA3);
	write_flash((WRITESEQ4 | ulSectorOff), WRITEDATA4);
	write_flash((WRITESEQ5 | ulSectorOff), WRITEDATA5);

	write_flash(ulSectorOff, BlockEraseVal);

	if (poll_toggle_bit(ulSectorOff) < 0)
		return FLASH_FAIL;

	return FLASH_SUCCESS;
}

void unlock_flash(long ulOffset)
{
	unsigned long ulOffsetAddr = ulOffset;
	ulOffsetAddr &= 0xFFFF0000;

	write_flash((WRITESEQ1 | ulOffsetAddr), UNLOCKDATA1);
	write_flash((WRITESEQ2 | ulOffsetAddr), UNLOCKDATA2);
	write_flash((WRITESEQ3 | ulOffsetAddr), UNLOCKDATA3);
}

int get_codes()
{
	int dev_id = 0;

	write_flash(WRITESEQ1, GETCODEDATA1);
	write_flash(WRITESEQ2, GETCODEDATA2);
	write_flash(WRITESEQ3, GETCODEDATA3);

	read_flash(0x0002, &dev_id);
	dev_id &= 0x00FF;

	reset_flash();

	return dev_id;
}

void get_sector_number(long ulOffset, int *pnSector)
{
	int nSector = 0;

	if (ulOffset >= SecFlashAOff) {
		if ((ulOffset < SecFlashASec1Off)
		    && (ulOffset < SecFlashASec2Off)) {
			nSector = SECT32;
		} else if ((ulOffset >= SecFlashASec2Off)
			   && (ulOffset < SecFlashASec3Off)) {
			nSector = SECT33;
		} else if ((ulOffset >= SecFlashASec3Off)
			   && (ulOffset < SecFlashASec4Off)) {
			nSector = SECT34;
		} else if ((ulOffset >= SecFlashASec4Off)
			   && (ulOffset < SecFlashAEndOff)) {
			nSector = SECT35;
		}
	} else if (ulOffset >= SecFlashBOff) {
		if ((ulOffset < SecFlashBSec1Off)
		    && (ulOffset < SecFlashBSec2Off)) {
			nSector = SECT36;
		}
		if ((ulOffset < SecFlashBSec2Off)
		    && (ulOffset < SecFlashBSec3Off)) {
			nSector = SECT37;
		}
		if ((ulOffset < SecFlashBSec3Off)
		    && (ulOffset < SecFlashBSec4Off)) {
			nSector = SECT38;
		}
		if ((ulOffset < SecFlashBSec4Off)
		    && (ulOffset < SecFlashBEndOff)) {
			nSector = SECT39;
		}
	} else if ((ulOffset >= PriFlashAOff) && (ulOffset < SecFlashAOff)) {
		nSector = ulOffset & 0xffff0000;
		nSector = ulOffset >> 16;
		nSector = nSector & 0x000ff;
	}

	if ((nSector >= 0) && (nSector < AFP_NumSectors)) {
		*pnSector = nSector;
	}
}
Commit	Line	Data
6cb142fa WD	1	/*
	2	* U-boot - flash.c Flash driver for PSD4256GV
	3	*
dfeeab2c	4	* Copyright (c) 2005-2007 Analog Devices Inc.
6cb142fa WD	5	* This file is based on BF533EzFlash.c originally written by Analog Devices, Inc.
	6	*
	7	* (C) Copyright 2000-2004
	8	* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
	9	*
1a459660	10	* SPDX-License-Identifier: GPL-2.0+
6cb142fa WD	11	*/
6cb142fa WD	12
8440bb14	13	#include <asm/io.h>
6cb142fa WD	14	#include "flash-defines.h"
6cb142fa WD	15
65ba1abd MF	16	int AFP_NumSectors = 40;
	17	long AFP_SectorSize1 = 0x10000;
	18	int AFP_SectorSize2 = 0x4000;
	19
6cb142fa WD	20	void flash_reset(void)
	21	{
	22	reset_flash();
	23	}
	24
3f0606ad	25	unsigned long flash_get_size(ulong baseaddr, flash_info_t * info, int bank_flag)
6cb142fa WD	26	{
	27	int id = 0, i = 0;
	28	static int FlagDev = 1;
	29
	30	id = get_codes();
3f0606ad	31	if (FlagDev) {
6cb142fa WD	32	#ifdef DEBUG
	33	printf("Device ID of the Flash is %x\n", id);
	34	#endif
	35	FlagDev = 0;
	36	}
	37	info->flash_id = id;
	38
	39	switch (bank_flag) {
	40	case 0:
	41	for (i = PriFlashABegin; i < SecFlashABegin; i++)
	42	info->start[i] = (baseaddr + (i * AFP_SectorSize1));
	43	info->size = 0x200000;
	44	info->sector_count = 32;
	45	break;
	46	case 1:
	47	info->start[0] = baseaddr + SecFlashASec1Off;
	48	info->start[1] = baseaddr + SecFlashASec2Off;
	49	info->start[2] = baseaddr + SecFlashASec3Off;
	50	info->start[3] = baseaddr + SecFlashASec4Off;
	51	info->size = 0x10000;
	52	info->sector_count = 4;
	53	break;
	54	case 2:
	55	info->start[0] = baseaddr + SecFlashBSec1Off;
	56	info->start[1] = baseaddr + SecFlashBSec2Off;
	57	info->start[2] = baseaddr + SecFlashBSec3Off;
	58	info->start[3] = baseaddr + SecFlashBSec4Off;
	59	info->size = 0x10000;
	60	info->sector_count = 4;
	61	break;
	62	}
	63	return (info->size);
	64	}
	65
	66	unsigned long flash_init(void)
	67	{
	68	unsigned long size_b0, size_b1, size_b2;
	69	int i;
	70
	71	size_b0 = size_b1 = size_b2 = 0;
	72	#ifdef DEBUG
6d0f6bcf	73	printf("Flash Memory Start 0x%x\n", CONFIG_SYS_FLASH_BASE);
6cb142fa WD	74	printf("Memory Map for the Flash\n");
	75	printf("0x20000000 - 0x200FFFFF Flash A Primary (1MB)\n");
	76	printf("0x20100000 - 0x201FFFFF Flash B Primary (1MB)\n");
	77	printf("0x20200000 - 0x2020FFFF Flash A Secondary (64KB)\n");
	78	printf("0x20280000 - 0x2028FFFF Flash B Secondary (64KB)\n");
	79	printf("Please type command flinfo for information on Sectors \n");
	80	#endif
6d0f6bcf	81	for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; ++i) {
6cb142fa WD	82	flash_info[i].flash_id = FLASH_UNKNOWN;
	83	}
	84
6d0f6bcf JCPV	85	size_b0 = flash_get_size(CONFIG_SYS_FLASH0_BASE, &flash_info[0], 0);
	86	size_b1 = flash_get_size(CONFIG_SYS_FLASH0_BASE, &flash_info[1], 1);
	87	size_b2 = flash_get_size(CONFIG_SYS_FLASH0_BASE, &flash_info[2], 2);
6cb142fa WD	88
	89	if (flash_info[0].flash_id == FLASH_UNKNOWN \|\| size_b0 == 0) {
	90	printf("## Unknown FLASH on Bank 0 - Size = 0x%08lx = %ld MB\n",
3f0606ad	91	size_b0, size_b0 >> 20);
6cb142fa WD	92	}
6cb142fa WD	93
6d0f6bcf	94	(void)flash_protect(FLAG_PROTECT_SET, CONFIG_SYS_FLASH0_BASE,
3f0606ad	95	(flash_info[0].start[2] - 1), &flash_info[0]);
6cb142fa WD	96
	97	return (size_b0 + size_b1 + size_b2);
	98	}
	99
	100	void flash_print_info(flash_info_t * info)
	101	{
	102	int i;
	103
	104	if (info->flash_id == FLASH_UNKNOWN) {
	105	printf("missing or unknown FLASH type\n");
	106	return;
	107	}
	108
	109	switch (info->flash_id) {
	110	case FLASH_PSD4256GV:
	111	printf("ST Microelectronics ");
	112	break;
	113	default:
fe033ad6	114	printf("Unknown Vendor: (0x%08lX) ", info->flash_id);
6cb142fa WD	115	break;
	116	}
	117	for (i = 0; i < info->sector_count; ++i) {
	118	if ((i % 5) == 0)
	119	printf("\n ");
	120	printf(" %08lX%s",
3f0606ad	121	info->start[i], info->protect[i] ? " (RO)" : " ");
6cb142fa WD	122	}
	123	printf("\n");
	124	return;
	125	}
	126
	127	int flash_erase(flash_info_t * info, int s_first, int s_last)
	128	{
3f0606ad AL	129	int cnt = 0, i;
3f0606ad AL	130	int prot, sect;
6cb142fa WD	131
6cb142fa WD	132	prot = 0;
8e7b703a WD	133	for (sect = s_first; sect <= s_last; ++sect) {
	134	if (info->protect[sect])
	135	prot++;
	136	}
6cb142fa WD	137
6cb142fa WD	138	if (prot)
3f0606ad AL	139	printf("- Warning: %d protected sectors will not be erased!\n",
3f0606ad AL	140	prot);
8e7b703a	141	else
3f0606ad	142	printf("\n");
6cb142fa WD	143
	144	cnt = s_last - s_first + 1;
	145
	146	if (cnt == FLASH_TOT_SECT) {
	147	printf("Erasing flash, Please Wait \n");
3f0606ad	148	if (erase_flash() < 0) {
6cb142fa WD	149	printf("Erasing flash failed \n");
	150	return FLASH_FAIL;
	151	}
	152	} else {
	153	printf("Erasing Flash locations, Please Wait\n");
	154	for (i = s_first; i <= s_last; i++) {
	155	if (info->protect[i] == 0) { /* not protected */
3f0606ad	156	if (erase_block_flash(i, info->start[i]) < 0) {
6cb142fa WD	157	printf("Error Sector erasing \n");
	158	return FLASH_FAIL;
	159	}
	160	}
	161	}
	162	}
	163	return FLASH_SUCCESS;
	164	}
	165
	166	int write_buff(flash_info_t * info, uchar * src, ulong addr, ulong cnt)
	167	{
	168	int ret;
dfeeab2c AL	169	int d;
dfeeab2c AL	170	if (addr % 2) {
6d0f6bcf	171	read_flash(addr - 1 - CONFIG_SYS_FLASH_BASE, &d);
dfeeab2c AL	172	d = (int)((d & 0x00FF) \| (*src++ << 8));
	173	ret = write_data(addr - 1, 2, (uchar *) & d);
	174	if (ret == FLASH_FAIL)
	175	return ERR_NOT_ERASED;
	176	ret = write_data(addr + 1, cnt - 1, src);
	177	} else
	178	ret = write_data(addr, cnt, src);
3f0606ad	179	if (ret == FLASH_FAIL)
6cb142fa WD	180	return ERR_NOT_ERASED;
	181	return FLASH_SUCCESS;
	182	}
	183
dfeeab2c	184	int write_data(long lStart, long lCount, uchar * pnData)
6cb142fa WD	185	{
6cb142fa WD	186	long i = 0;
6d0f6bcf	187	unsigned long ulOffset = lStart - CONFIG_SYS_FLASH_BASE;
6cb142fa	188	int d;
6cb142fa	189	int nSector = 0;
dfeeab2c	190	int flag = 0;
6cb142fa	191
dfeeab2c AL	192	if (lCount % 2) {
	193	flag = 1;
	194	lCount = lCount - 1;
6cb142fa	195	}
dfeeab2c AL	196
	197	for (i = 0; i < lCount - 1; i += 2, ulOffset += 2) {
	198	get_sector_number(ulOffset, &nSector);
	199	read_flash(ulOffset, &d);
	200	if (d != 0xffff) {
	201	printf
fe033ad6	202	("Flash not erased at offset 0x%lx Please erase to reprogram\n",
dfeeab2c	203	ulOffset);
3f0606ad	204	return FLASH_FAIL;
dfeeab2c AL	205	}
	206	unlock_flash(ulOffset);
	207	d = (int)(pnData[i] \| pnData[i + 1] << 8);
	208	write_flash(ulOffset, d);
	209	if (poll_toggle_bit(ulOffset) < 0) {
	210	printf("Error programming the flash \n");
	211	return FLASH_FAIL;
	212	}
	213	if ((i > 0) && (!(i % AFP_SectorSize2)))
	214	printf(".");
	215	}
	216	if (flag) {
6cb142fa	217	get_sector_number(ulOffset, &nSector);
3f0606ad AL	218	read_flash(ulOffset, &d);
	219	if (d != 0xffff) {
	220	printf
fe033ad6	221	("Flash not erased at offset 0x%lx Please erase to reprogram\n",
dfeeab2c	222	ulOffset);
6cb142fa WD	223	return FLASH_FAIL;
	224	}
	225	unlock_flash(ulOffset);
dfeeab2c AL	226	d = (int)(pnData[i] \| (d & 0xFF00));
	227	write_flash(ulOffset, d);
	228	if (poll_toggle_bit(ulOffset) < 0) {
6cb142fa WD	229	printf("Error programming the flash \n");
	230	return FLASH_FAIL;
	231	}
	232	}
	233	return FLASH_SUCCESS;
	234	}
	235
	236	int read_data(long ulStart, long lCount, long lStride, int *pnData)
	237	{
	238	long i = 0;
	239	int j = 0;
	240	long ulOffset = ulStart;
	241	int iShift = 0;
	242	int iNumWords = 2;
	243	int nLeftover = lCount % 4;
	244	int nHi, nLow;
	245	int nSector = 0;
	246
	247	for (i = 0; (i < lCount / 4) && (i < BUFFER_SIZE); i++) {
	248	for (iShift = 0, j = 0; j < iNumWords; j += 2) {
	249	if ((ulOffset >= INVALIDLOCNSTART)
3f0606ad AL	250	&& (ulOffset < INVALIDLOCNEND))
3f0606ad AL	251	return FLASH_FAIL;
6cb142fa WD	252
	253	get_sector_number(ulOffset, &nSector);
	254	read_flash(ulOffset, &nLow);
	255	ulOffset += (lStride * 2);
	256	read_flash(ulOffset, &nHi);
	257	ulOffset += (lStride * 2);
	258	pnData[i] = (nHi << 16) \| nLow;
	259	}
	260	}
	261	if (nLeftover > 0) {
	262	if ((ulOffset >= INVALIDLOCNSTART)
3f0606ad AL	263	&& (ulOffset < INVALIDLOCNEND))
3f0606ad AL	264	return FLASH_FAIL;
6cb142fa WD	265
	266	get_sector_number(ulOffset, &nSector);
	267	read_flash(ulOffset, &pnData[i]);
	268	}
	269	return FLASH_SUCCESS;
	270	}
	271
	272	int write_flash(long nOffset, int nValue)
	273	{
	274	long addr;
	275
6d0f6bcf	276	addr = (CONFIG_SYS_FLASH_BASE + nOffset);
d4d77308	277	SSYNC();
3f0606ad	278	(unsigned volatile short )addr = nValue;
d4d77308	279	SSYNC();
3f0606ad	280	if (poll_toggle_bit(nOffset) < 0)
6cb142fa WD	281	return FLASH_FAIL;
	282	return FLASH_SUCCESS;
	283	}
	284
	285	int read_flash(long nOffset, int *pnValue)
	286	{
	287	int nValue = 0x0;
6d0f6bcf	288	long addr = (CONFIG_SYS_FLASH_BASE + nOffset);
6cb142fa WD	289
	290	if (nOffset != 0x2)
	291	reset_flash();
d4d77308	292	SSYNC();
3f0606ad	293	nValue = (volatile unsigned short )addr;
d4d77308	294	SSYNC();
6cb142fa	295	*pnValue = nValue;
472d5460	296	return true;
6cb142fa WD	297	}
	298
	299	int poll_toggle_bit(long lOffset)
	300	{
3f0606ad	301	unsigned int u1, u2;
6cb142fa	302	unsigned long timeout = 0xFFFFFFFF;
3f0606ad AL	303	volatile unsigned long *FB =
	304	(volatile unsigned long *)(0x20000000 + lOffset);
	305	while (1) {
	306	if (timeout < 0)
6cb142fa WD	307	break;
	308	u1 = (volatile unsigned short )FB;
	309	u2 = (volatile unsigned short )FB;
3f0606ad	310	if ((u1 & 0x0040) == (u2 & 0x0040))
6cb142fa	311	return FLASH_SUCCESS;
3f0606ad	312	if ((u2 & 0x0020) == 0x0000)
6cb142fa WD	313	continue;
6cb142fa WD	314	u1 = (volatile unsigned short )FB;
3f0606ad	315	if ((u2 & 0x0040) == (u1 & 0x0040))
6cb142fa WD	316	return FLASH_SUCCESS;
	317	else {
	318	reset_flash();
	319	return FLASH_FAIL;
	320	}
	321	timeout--;
	322	}
	323	printf("Time out occured \n");
3f0606ad AL	324	if (timeout < 0)
3f0606ad AL	325	return FLASH_FAIL;
6cb142fa WD	326	}
	327
	328	void reset_flash(void)
	329	{
	330	write_flash(WRITESEQ1, RESET_VAL);
	331	/* Wait for 10 micro seconds */
	332	udelay(10);
	333	}
	334
	335	int erase_flash(void)
	336	{
	337	write_flash(WRITESEQ1, WRITEDATA1);
	338	write_flash(WRITESEQ2, WRITEDATA2);
	339	write_flash(WRITESEQ3, WRITEDATA3);
	340	write_flash(WRITESEQ4, WRITEDATA4);
	341	write_flash(WRITESEQ5, WRITEDATA5);
	342	write_flash(WRITESEQ6, WRITEDATA6);
	343
3f0606ad	344	if (poll_toggle_bit(0x0000) < 0)
6cb142fa WD	345	return FLASH_FAIL;
	346
	347	write_flash(SecFlashAOff + WRITESEQ1, WRITEDATA1);
	348	write_flash(SecFlashAOff + WRITESEQ2, WRITEDATA2);
	349	write_flash(SecFlashAOff + WRITESEQ3, WRITEDATA3);
	350	write_flash(SecFlashAOff + WRITESEQ4, WRITEDATA4);
	351	write_flash(SecFlashAOff + WRITESEQ5, WRITEDATA5);
	352	write_flash(SecFlashAOff + WRITESEQ6, WRITEDATA6);
	353
3f0606ad	354	if (poll_toggle_bit(SecFlashASec1Off) < 0)
6cb142fa WD	355	return FLASH_FAIL;
	356
	357	write_flash(PriFlashBOff + WRITESEQ1, WRITEDATA1);
	358	write_flash(PriFlashBOff + WRITESEQ2, WRITEDATA2);
	359	write_flash(PriFlashBOff + WRITESEQ3, WRITEDATA3);
	360	write_flash(PriFlashBOff + WRITESEQ4, WRITEDATA4);
	361	write_flash(PriFlashBOff + WRITESEQ5, WRITEDATA5);
	362	write_flash(PriFlashBOff + WRITESEQ6, WRITEDATA6);
	363
3f0606ad	364	if (poll_toggle_bit(PriFlashBOff) < 0)
6cb142fa WD	365	return FLASH_FAIL;
	366
	367	write_flash(SecFlashBOff + WRITESEQ1, WRITEDATA1);
	368	write_flash(SecFlashBOff + WRITESEQ2, WRITEDATA2);
	369	write_flash(SecFlashBOff + WRITESEQ3, WRITEDATA3);
	370	write_flash(SecFlashBOff + WRITESEQ4, WRITEDATA4);
	371	write_flash(SecFlashBOff + WRITESEQ5, WRITEDATA5);
	372	write_flash(SecFlashBOff + WRITESEQ6, WRITEDATA6);
	373
3f0606ad	374	if (poll_toggle_bit(SecFlashBOff) < 0)
6cb142fa WD	375	return FLASH_FAIL;
	376
	377	return FLASH_SUCCESS;
	378	}
	379
	380	int erase_block_flash(int nBlock, unsigned long address)
	381	{
	382	long ulSectorOff = 0x0;
	383
	384	if ((nBlock < 0) \|\| (nBlock > AFP_NumSectors))
472d5460	385	return false;
6cb142fa	386
6d0f6bcf	387	ulSectorOff = (address - CONFIG_SYS_FLASH_BASE);
6cb142fa WD	388
	389	write_flash((WRITESEQ1 \| ulSectorOff), WRITEDATA1);
	390	write_flash((WRITESEQ2 \| ulSectorOff), WRITEDATA2);
	391	write_flash((WRITESEQ3 \| ulSectorOff), WRITEDATA3);
	392	write_flash((WRITESEQ4 \| ulSectorOff), WRITEDATA4);
	393	write_flash((WRITESEQ5 \| ulSectorOff), WRITEDATA5);
	394
	395	write_flash(ulSectorOff, BlockEraseVal);
	396
3f0606ad	397	if (poll_toggle_bit(ulSectorOff) < 0)
6cb142fa WD	398	return FLASH_FAIL;
	399
	400	return FLASH_SUCCESS;
	401	}
	402
	403	void unlock_flash(long ulOffset)
	404	{
	405	unsigned long ulOffsetAddr = ulOffset;
	406	ulOffsetAddr &= 0xFFFF0000;
	407
	408	write_flash((WRITESEQ1 \| ulOffsetAddr), UNLOCKDATA1);
	409	write_flash((WRITESEQ2 \| ulOffsetAddr), UNLOCKDATA2);
	410	write_flash((WRITESEQ3 \| ulOffsetAddr), UNLOCKDATA3);
	411	}
	412
	413	int get_codes()
	414	{
	415	int dev_id = 0;
	416
	417	write_flash(WRITESEQ1, GETCODEDATA1);
	418	write_flash(WRITESEQ2, GETCODEDATA2);
	419	write_flash(WRITESEQ3, GETCODEDATA3);
	420
	421	read_flash(0x0002, &dev_id);
	422	dev_id &= 0x00FF;
	423
	424	reset_flash();
	425
	426	return dev_id;
	427	}
	428
	429	void get_sector_number(long ulOffset, int *pnSector)
	430	{
	431	int nSector = 0;
	432
	433	if (ulOffset >= SecFlashAOff) {
	434	if ((ulOffset < SecFlashASec1Off)
3f0606ad AL	435	&& (ulOffset < SecFlashASec2Off)) {
3f0606ad AL	436	nSector = SECT32;
6cb142fa	437	} else if ((ulOffset >= SecFlashASec2Off)
3f0606ad AL	438	&& (ulOffset < SecFlashASec3Off)) {
3f0606ad AL	439	nSector = SECT33;
6cb142fa	440	} else if ((ulOffset >= SecFlashASec3Off)
3f0606ad AL	441	&& (ulOffset < SecFlashASec4Off)) {
3f0606ad AL	442	nSector = SECT34;
6cb142fa	443	} else if ((ulOffset >= SecFlashASec4Off)
3f0606ad AL	444	&& (ulOffset < SecFlashAEndOff)) {
3f0606ad AL	445	nSector = SECT35;
6cb142fa WD	446	}
	447	} else if (ulOffset >= SecFlashBOff) {
	448	if ((ulOffset < SecFlashBSec1Off)
3f0606ad AL	449	&& (ulOffset < SecFlashBSec2Off)) {
3f0606ad AL	450	nSector = SECT36;
6cb142fa WD	451	}
6cb142fa WD	452	if ((ulOffset < SecFlashBSec2Off)
3f0606ad AL	453	&& (ulOffset < SecFlashBSec3Off)) {
3f0606ad AL	454	nSector = SECT37;
6cb142fa WD	455	}
6cb142fa WD	456	if ((ulOffset < SecFlashBSec3Off)
3f0606ad AL	457	&& (ulOffset < SecFlashBSec4Off)) {
3f0606ad AL	458	nSector = SECT38;
6cb142fa WD	459	}
6cb142fa WD	460	if ((ulOffset < SecFlashBSec4Off)
3f0606ad AL	461	&& (ulOffset < SecFlashBEndOff)) {
3f0606ad AL	462	nSector = SECT39;
6cb142fa WD	463	}
	464	} else if ((ulOffset >= PriFlashAOff) && (ulOffset < SecFlashAOff)) {
	465	nSector = ulOffset & 0xffff0000;
	466	nSector = ulOffset >> 16;
	467	nSector = nSector & 0x000ff;
	468	}
	469
	470	if ((nSector >= 0) && (nSector < AFP_NumSectors)) {
	471	*pnSector = nSector;
	472	}
	473	}