/* * MOUSSE/MPC8240 Board definitions. * Flash Routines for MOUSSE onboard AMD29LV106DB devices * * (C) Copyright 2000 * Marius Groeger <mgroeger@sysgo.de> * Sysgo Real-Time Solutions, GmbH <www.elinos.com> * * (C) Copyright 2000 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. * * (C) Copyright 1999, by Curt McDowell, 08-06-99, Broadcom Corp. * (C) Copyright 2001, James Dougherty, 07/18/01, Broadcom Corp. * * 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 */#include <common.h>#include <mpc8xx.h>#include <malloc.h>#include "mousse.h"#include "flash.h"int flashLibDebug = 0;int flashLibInited = 0;#define OK  0#define ERROR -1#define STATUS int#define PRINTF			if (flashLibDebug) printf#if 0#define PRIVATE			static#else#define PRIVATE#endifflash_info_t flash_info[CFG_MAX_FLASH_BANKS];#define SLEEP_DELAY    166#define FLASH_SECTOR_SIZE   (64*1024)/*********************************************************************** * * Virtual Flash Devices on Mousse board * * These must be kept in sync with the definitions in flashLib.h. * ***********************************************************************/PRIVATE flash_dev_t flashDev[] = {    /* Bank 0 sector SA0 (16 kB) */    {	"SA0",FLASH0_BANK, FLASH0_SEG0_START, 1, 14,	FLASH0_VENDOR_ID, FLASH0_DEVICE_ID    },    /* Bank 0 sector SA1 (8 kB) */    {	"SA1", FLASH0_BANK, FLASH0_SEG0_START + 0x4000, 1, 13,	FLASH0_VENDOR_ID, FLASH0_DEVICE_ID    },    /* Bank 0 sector SA2 (8 kB) */    {	"SA2", FLASH0_BANK, FLASH0_SEG0_START + 0x6000, 1, 13,	FLASH0_VENDOR_ID, FLASH0_DEVICE_ID    },    /* Bank 0 sector SA3 is occluded by Mousse I/O devices */    /* Bank 0 sectors SA4-SA18, after Mousse devices up to PLCC (960 kB)  */    {	"KERNEL", FLASH0_BANK, FLASH0_SEG1_START, 15, 16,	FLASH0_VENDOR_ID, FLASH0_DEVICE_ID    },    /* Bank 0 sectors SA19-SA26, jumper can occlude this by PLCC (512 kB) */    /* This is where the Kahlua boot vector and boot ROM code resides. */    {	"BOOT",FLASH0_BANK, FLASH0_SEG2_START, 8, 16,	FLASH0_VENDOR_ID, FLASH0_DEVICE_ID    },    /* Bank 0 sectors SA27-SA34 (512 kB) */    {	"RAMDISK",FLASH0_BANK, FLASH0_SEG3_START, 8, 16,	FLASH0_VENDOR_ID, FLASH0_DEVICE_ID    },};int flashDevCount = (sizeof (flashDev) / sizeof (flashDev[0]));#define DEV(no)			(&flashDev[no])#define DEV_NO(dev)		((dev) - flashDev)/*********************************************************************** * * Private Flash Routines * ***********************************************************************//* * The convention is: * * "addr" is always the PROM raw address, which is the address of an * 8-bit quantity for flash 0 and 16-bit quantity for flash 1. * * "pos" is always a logical byte position from the PROM beginning. */#define FLASH0_ADDR(dev, addr) \	((unsigned char *) ((dev)->base + (addr)))#define FLASH0_WRITE(dev, addr, value) \	(*FLASH0_ADDR(dev, addr) = (value))#define FLASH0_READ(dev, addr) \	(*FLASH0_ADDR(dev, addr))PRIVATE int flashCheck(flash_dev_t *dev){    if (! flashLibInited) {	printf("flashCheck: flashLib not initialized\n");	return ERROR;    }    if (dev < &flashDev[0] || dev >= &flashDev[flashDevCount]) {	printf("flashCheck: Bad dev parameter\n");	return ERROR;    }    if (! dev->found) {	printf("flashCheck: Device %d not available\n", DEV_NO(dev));	return ERROR;    }    return OK;}PRIVATE void flashReset(flash_dev_t *dev){    PRINTF("flashReset: dev=%d\n", DEV_NO(dev));    if (dev->bank == FLASH0_BANK) {	FLASH0_WRITE(dev, 0x555, 0xaa);	FLASH0_WRITE(dev, 0xaaa, 0x55);	FLASH0_WRITE(dev, 0x555, 0xf0);    }    udelay(SLEEP_DELAY);    PRINTF("flashReset: done\n");}PRIVATE int flashProbe(flash_dev_t *dev){    int			rv, deviceID, vendorID;    PRINTF("flashProbe: dev=%d\n", DEV_NO(dev));    if (dev->bank != FLASH0_BANK) {    	rv = ERROR;	goto DONE;    }    FLASH0_WRITE(dev, 0xaaa, 0xaa);    FLASH0_WRITE(dev, 0x555, 0x55);    FLASH0_WRITE(dev, 0xaaa, 0x90);    udelay(SLEEP_DELAY);    vendorID = FLASH0_READ(dev, 0);    deviceID = FLASH0_READ(dev, 2);    FLASH0_WRITE(dev, 0, 0xf0);    PRINTF("flashProbe: vendor=0x%x device=0x%x\n", vendorID, deviceID);    if (vendorID == dev->vendorID && deviceID == dev->deviceID)	rv = OK;    else	rv = ERROR;DONE:    PRINTF("flashProbe: rv=%d\n", rv);    return rv;}PRIVATE int flashWait(flash_dev_t *dev, int addr, int expect, int erase){    int			rv = ERROR;    int			i, data;    int			polls;#if 0    PRINTF("flashWait: dev=%d addr=0x%x expect=0x%x erase=%d\n",	   DEV_NO(dev), addr, expect, erase);#endif    if (dev->bank != FLASH0_BANK) {	rv = ERROR;	goto done;    }    if (erase)	polls = FLASH_ERASE_SECTOR_TIMEOUT;	/* Ticks */    else	polls = FLASH_PROGRAM_POLLS;		/* Loops */    for (i = 0; i < polls; i++) {	if (erase)	    udelay(SLEEP_DELAY);	data = FLASH0_READ(dev, addr);	if (((data ^ expect) & 0x80) == 0) {	    rv = OK;	    goto done;	}	if (data & 0x20) {	    /*	     * If the 0x20 bit has come on, it could actually be because	     * the operation succeeded, so check the done bit again.	     */	    data = FLASH0_READ(dev, addr);	    if (((data ^ expect) & 0x80) == 0) {		rv = OK;		goto done;	    }	    printf("flashWait: Program error (dev: %d, addr: 0x%x)\n",		   DEV_NO(dev), addr);	    flashReset(dev);	    rv = ERROR;	    goto done;	}    }    printf("flashWait: Timeout %s (dev: %d, addr: 0x%x)\n",	   erase ? "erasing sector" : "programming byte",	   DEV_NO(dev), addr);done:#if 0    PRINTF("flashWait: rv=%d\n", rv);#endif    return rv;}/*********************************************************************** * * Public Flash Routines * ***********************************************************************/STATUS flashLibInit(void){    int			i;    PRINTF("flashLibInit: devices=%d\n", flashDevCount);    for (i = 0; i < flashDevCount; i++) {	flash_dev_t	*dev = &flashDev[i];	/*	 * For bank 1, probe both without and with byte swappage,	 * so that this module works on both old and new Mousse boards.	 */	flashReset(dev);	if (flashProbe(dev) != ERROR)	    dev->found = 1;	    flashReset(dev);	    if (flashProbe(dev) != ERROR)		dev->found = 1;	    dev->swap = 0;	    if(dev->found){	      PRINTF("\n  FLASH %s[%d]: iobase=0x%x - %d sectors %d KB",		     flashDev[i].name,i,flashDev[i].base, flashDev[i].sectors,		     (flashDev[i].sectors * FLASH_SECTOR_SIZE)/1024);	    }    }    flashLibInited = 1;    PRINTF("flashLibInit: done\n");    return OK;}STATUS flashEraseSector(flash_dev_t *dev, int sector){    int			pos, addr;    PRINTF("flashErasesector: dev=%d sector=%d\n", DEV_NO(dev), sector);    if (flashCheck(dev) == ERROR)	return ERROR;    if (sector < 0 || sector >= dev->sectors) {	printf("flashEraseSector: Sector out of range (dev: %d, sector: %d)\n",	       DEV_NO(dev), sector);	return ERROR;    }    pos = FLASH_SECTOR_POS(dev, sector);    if (dev->bank != FLASH0_BANK) {	return ERROR;    }    addr = pos;    FLASH0_WRITE(dev, 0xaaa, 0xaa);    FLASH0_WRITE(dev, 0x555, 0x55);    FLASH0_WRITE(dev, 0xaaa, 0x80);    FLASH0_WRITE(dev, 0xaaa, 0xaa);    FLASH0_WRITE(dev, 0x555, 0x55);    FLASH0_WRITE(dev, addr, 0x30);    return flashWait(dev, addr, 0xff, 1);}/* * Note: it takes about as long to flash all sectors together with Chip * Erase as it does to flash them one at a time (about 30 seconds for 2 * MB).  Also since we want to be able to treat subsets of sectors as if * they were complete devices, we don't use Chip Erase. */STATUS flashErase(flash_dev_t *dev){    int			sector;    PRINTF("flashErase: dev=%d sectors=%d\n", DEV_NO(dev), dev->sectors);    if (flashCheck(dev) == ERROR)	return ERROR;    for (sector = 0; sector < dev->sectors; sector++) {      if (flashEraseSector(dev, sector) == ERROR)	    return ERROR;    }    return OK;}/* * Read and write bytes */STATUS flashRead(flash_dev_t *dev, int pos, char *buf, int len){    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;    if (dev->bank == FLASH0_BANK) {	addr = pos;	words = len;	PRINTF("flashRead: memcpy(0x%x, 0x%x, 0x%x)\n",	       (int) buf, (int) FLASH0_ADDR(dev, pos), len);	memcpy(buf, FLASH0_ADDR(dev, addr), words);    }    PRINTF("flashRead: rv=OK\n");    return OK;}STATUS flashWrite(flash_dev_t *dev, int pos, char *buf, int len){    int 		addr, words;    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;    if (dev->bank == FLASH0_BANK) {	unsigned char tmp;	addr = pos;	words = len;	while (words--) {	    tmp = *buf;	    if (~FLASH0_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;	    }	    FLASH0_WRITE(dev, 0xaaa, 0xaa);	    FLASH0_WRITE(dev, 0x555, 0x55);	    FLASH0_WRITE(dev, 0xaaa, 0xa0);	    FLASH0_WRITE(dev, addr, tmp);	    if (flashWait(dev, addr, tmp, 0) < 0)		return ERROR;	    buf++;	    addr++;	}    }    PRINTF("flashWrite: rv=OK\n");    return OK;}/* * flashWritable returns TRUE if a range contains all F's. */STATUS flashWritable(flash_dev_t *dev, int pos, int len){    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;