--- /dev/null
+/************************************************************************/
+/* */
+/* SPI Flash Memory Drivers */
+/* File name: spiflash.c */
+/* Revision: 1.0 1/27/2004 */
+/* */
+/************************************************************************/
+
+/** Includes. **/
+#ifdef _CFE_
+#include "lib_types.h"
+#include "lib_printf.h"
+#include "lib_string.h"
+#include "bcm_map.h"
+#define printk printf
+#else // linux
+#include <linux/param.h>
+#include <linux/sched.h>
+#include <linux/timer.h>
+#include <linux/kernel.h>
+#include <bcm_map_part.h>
+#endif
+
+#include "bcmtypes.h"
+#include "board.h"
+#include "flash_api.h"
+
+
+/** Defines. **/
+#define OSL_DELAY(X) \
+ do { { int i; for( i = 0; i < (X) * 500; i++ ) ; } } while(0)
+
+#define MAX_RETRY 3
+
+#define FAR
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#define MAX_MEMORY_MAPPED_SIZE (1024 * 1024)
+
+#define MAXSECTORS 1024 /* maximum number of sectors supported */
+
+#define FLASH_PAGE_SIZE 256
+#define SECTOR_SIZE_4K (4 * 1024)
+#define SECTOR_SIZE_32K (32 * 1024)
+#define SECTOR_SIZE_64K (64 * 1024)
+#define SST25VF020_SECTOR 64 /* 2 Mbit */
+#define SST25VF040_SECTOR 128 /* 4 Mbit */
+#define SST25VF080_SECTOR 256 /* 8 Mbit */
+#define SST25VF016B_SECTOR 512 /* 16 Mbit */
+#define AT25F512_SECTOR 2
+#define AT25F2048_SECTOR 4
+#define AMD25FL_SECTOR 4
+
+/* use 60 instead 63 for aligned on word (4 bytes) boundaries */
+#define MAX_READ 60
+#define CMD_LEN_1 1
+#define CMD_LEN_4 4
+
+/* Standard Boolean declarations */
+#define TRUE 1
+#define FALSE 0
+
+#define SPI_STATUS_OK 0
+#define SPI_STATUS_INVALID_LEN -1
+
+/* Command codes for the flash_command routine */
+#define FLASH_READ 0x03 /* read data from memory array */
+#define FLASH_PROG 0x02 /* program data into memory array */
+#define FLASH_WREN 0x06 /* set write enable latch */
+#define FLASH_WRDI 0x04 /* reset write enable latch */
+#define FLASH_RDSR 0x05 /* read status register */
+#define FLASH_WRST 0x01 /* write status register */
+#define FLASH_EWSR 0x50 /* enable write status */
+#define FLASH_WORD_AAI 0xAD /* auto address increment word program */
+#define FLASH_AAI 0xAF /* auto address increment program */
+
+#define SST_FLASH_CERASE 0x60 /* erase all sectors in memory array */
+#define SST_FLASH_SERASE 0x20 /* erase one sector in memroy array */
+#define SST_FLASH_RDID 0x90 /* read manufacturer and product id */
+
+#define ATMEL_FLASH_CERASE 0x62 /* erase all sectors in memory array */
+#define ATMEL_FLASH_SERASE 0x52 /* erase one sector in memroy array */
+#define ATMEL_FLASH_RDID 0x15 /* read manufacturer and product id */
+
+#define AMD_FLASH_CERASE 0xC7 /* erase all sectors in memory array */
+#define AMD_FLASH_SERASE 0xD8 /* erase one sector in memroy array */
+#define AMD_FLASH_RDID 0xAB /* read manufacturer and product id */
+
+/* RDSR return status bit definition */
+#define SR_WPEN 0x80
+#define SR_BP2 0x10
+#define SR_BP1 0x08
+#define SR_BP0 0x04
+#define SR_WEN 0x02
+#define SR_RDY 0x01
+
+/* Return codes from flash_status */
+#define STATUS_READY 0 /* ready for action */
+#define STATUS_BUSY 1 /* operation in progress */
+#define STATUS_TIMEOUT 2 /* operation timed out */
+#define STATUS_ERROR 3 /* unclassified but unhappy status */
+
+/* Used to mask of bytes from word data */
+#define HIGH_BYTE(a) (a >> 8)
+#define LOW_BYTE(a) (a & 0xFF)
+
+/* Define different type of flash */
+#define FLASH_UNDEFINED 0
+#define FLASH_SST 1
+#define FLASH_ATMEL 2
+#define FLASH_AMD 3
+
+/* ATMEL's manufacturer ID */
+#define ATMELPART 0x1F
+
+/* A list of ATMEL device ID's - add others as needed */
+#define ID_AT25F512 0x60
+#define ID_AT25F2048 0x63
+
+/* AMD's device ID */
+#define AMD_S25FL002D 0x11
+
+/* SST's manufacturer ID */
+#define SSTPART 0xBF
+
+/* A list of SST device ID's - add others as needed */
+#define ID_SST25VF016B 0x41
+#define ID_SST25VF020 0x43
+#define ID_SST25VF040 0x44
+#define ID_SST25VF080 0x80
+
+#define SPI_MAKE_ID(A,B) \
+ (((unsigned short) (A) << 8) | ((unsigned short) B & 0xff))
+
+#define SPI_FLASH_DEVICES \
+ {{SPI_MAKE_ID(ATMELPART, ID_AT25F512), "AT25F512"}, \
+ {SPI_MAKE_ID(ATMELPART, ID_AT25F2048), "AT25F2048"}, \
+ {SPI_MAKE_ID(AMD_S25FL002D, 0), "AMD_S25FL002D"}, \
+ {SPI_MAKE_ID(SSTPART, ID_SST25VF016B), "SST25VF016B"}, \
+ {SPI_MAKE_ID(SSTPART, ID_SST25VF020), "SST25VF020"}, \
+ {SPI_MAKE_ID(SSTPART, ID_SST25VF040), "SST25VF040"}, \
+ {SPI_MAKE_ID(SSTPART, ID_SST25VF080), "SST25VF080"}, \
+ {0,""} \
+ }
+
+
+/** Structs. **/
+/* A structure for identifying a flash part. There is one for each
+ * of the flash part definitions. We need to keep track of the
+ * sector organization, the address register used, and the size
+ * of the sectors.
+ */
+struct flashinfo {
+ char *name; /* "AT25F512", etc. */
+ unsigned long addr; /* physical address, once translated */
+ int nsect; /* # of sectors */
+ struct {
+ long size; /* # of bytes in this sector */
+ long base; /* offset from beginning of device */
+ } sec[MAXSECTORS]; /* per-sector info */
+};
+
+struct flash_name_from_id {
+ unsigned short fnfi_id;
+ char fnfi_name[30];
+};
+
+
+/** Prototypes. **/
+int spi_flash_init(flash_device_info_t **flash_info);
+static int spi_read( unsigned char *msg_buf, int prependcnt, int nbytes );
+static int spi_write( unsigned char *msg_buf, int nbytes );
+static int spi_flash_sector_erase_int(unsigned short sector);
+static int spi_flash_reset(void);
+static int spi_flash_read_buf(unsigned short sector, int offset,
+ unsigned char *buffer, int numbytes);
+static int spi_flash_ub(unsigned short sector);
+static int spi_flash_write_status(unsigned char status);
+static int spi_flash_write_buf(unsigned short sector, int offset,
+ unsigned char *buffer, int numbytes);
+static int spi_flash_reset_ub(void);
+static int spi_flash_get_numsectors(void);
+static int spi_flash_get_sector_size(unsigned short sector);
+static unsigned char *spi_get_flash_memptr(unsigned short sector);
+static unsigned char *spi_flash_get_memptr(unsigned short sector);
+static int spi_flash_write(unsigned short sector, int offset, unsigned char *buf,
+ int nbytes,int ub);
+static int spi_flash_status(void);
+static unsigned short spi_flash_get_device_id(unsigned short sector);
+static int spi_flash_get_blk(int addr);
+static int spi_flash_get_total_size(void);
+static int spi_flash_get_total_memory_mapped_size(void);
+
+
+/** Variables. **/
+static flash_device_info_t flash_spi_dev =
+ {
+ 0xffff,
+ "",
+ spi_flash_sector_erase_int,
+ spi_flash_read_buf,
+ spi_flash_write_buf,
+ spi_flash_get_numsectors,
+ spi_flash_get_sector_size,
+ spi_flash_get_memptr,
+ spi_flash_get_blk,
+ spi_flash_get_total_size,
+ spi_flash_get_total_memory_mapped_size
+ };
+
+/*********************************************************************/
+/* 'meminfo' should be a pointer, but most C compilers will not */
+/* allocate static storage for a pointer without calling */
+/* non-portable functions such as 'new'. We also want to avoid */
+/* the overhead of passing this pointer for every driver call. */
+/* Systems with limited heap space will need to do this. */
+/*********************************************************************/
+static struct flashinfo meminfo; /* Flash information structure */
+static int totalSize = 0;
+static int flashFamily = FLASH_UNDEFINED;
+static int sstAaiWordProgram = FALSE;
+
+static int spi_read( unsigned char *msg_buf, int prependcnt, int nbytes )
+{
+ int i;
+ SPI->spiMsgCtl = (nbytes << SPI_BYTE_CNT_SHIFT |
+ HALF_DUPLEX_R << SPI_MSG_TYPE_SHIFT);
+
+ for (i = 0; i < prependcnt; i++)
+ SPI->spiMsgData[i] = msg_buf[i];
+
+ SPI->spiIntStatus = SPI_INTR_CLEAR_ALL;
+
+ SPI->spiCmd = (SPI_CMD_START_IMMEDIATE << SPI_CMD_COMMAND_SHIFT |
+ 0 << SPI_CMD_DEVICE_ID_SHIFT |
+ prependcnt << SPI_CMD_PREPEND_BYTE_CNT_SHIFT );
+
+
+ while (!(SPI->spiIntStatus & SPI_INTR_CMD_DONE));
+
+ SPI->spiIntStatus = SPI_INTR_CLEAR_ALL;
+
+ for(i = 0; i < nbytes; i++) {
+ msg_buf[i] = SPI->spiRxDataFifo[i];
+ }
+ return SPI_STATUS_OK;
+}
+
+static int spi_write( unsigned char *msg_buf, int nbytes )
+{
+ int i;
+
+ SPI->spiMsgCtl = (nbytes << SPI_BYTE_CNT_SHIFT |
+ HALF_DUPLEX_W << SPI_MSG_TYPE_SHIFT);
+
+ for (i = 0; i < nbytes; i++)
+ SPI->spiMsgData[i] = msg_buf[i];
+
+ SPI->spiCmd = (SPI_CMD_START_IMMEDIATE << SPI_CMD_COMMAND_SHIFT |
+ 0 << SPI_CMD_DEVICE_ID_SHIFT |
+ 0 << SPI_CMD_PREPEND_BYTE_CNT_SHIFT );
+
+ while (!(SPI->spiIntStatus & SPI_INTR_CMD_DONE));
+
+ SPI->spiIntStatus = SPI_INTR_CLEAR_ALL;
+
+ return SPI_STATUS_OK;
+}
+
+/*********************************************************************/
+/* Init_flash is used to build a sector table. This information is */
+/* translated from erase_block information to base:offset information*/
+/* for each individual sector. This information is then stored */
+/* in the meminfo structure, and used throughout the driver to access*/
+/* sector information. */
+/* */
+/* This is more efficient than deriving the sector base:offset */
+/* information every time the memory map switches (since on the */
+/* development platform can only map 64k at a time). If the entire */
+/* flash memory array can be mapped in, then the addition static */
+/* allocation for the meminfo structure can be eliminated, but the */
+/* drivers will have to be re-written. */
+/* */
+/* The meminfo struct occupies 44 bytes of heap space, depending */
+/* on the value of the define MAXSECTORS. Adjust to suit */
+/* application */
+/*********************************************************************/
+
+int spi_flash_init(flash_device_info_t **flash_info)
+{
+ struct flash_name_from_id fnfi[] = SPI_FLASH_DEVICES;
+ struct flash_name_from_id *fnfi_ptr;
+ int i=0, count=0;
+ int basecount=0L;
+ unsigned short device_id;
+ unsigned short blkEnables;
+ int sectorsize = 0;
+ int numsector = 0;
+
+ *flash_info = &flash_spi_dev;
+
+#if 0
+ /*
+ * in case of flash corrupt, the following steps can erase the flash
+ * 1. jumper USE_SPI_SLAVE to make SPI in slave mode
+ * 2. start up JTAG debuger and remove the USE_SPI_SLAVE jumper
+ * 3. run the following code to erase the flash
+ */
+ flash_sector_erase_int(0);
+ flash_sector_erase_int(1);
+ printk("flash_init: erase all sectors\n");
+ return FLASH_API_OK;
+#endif
+ blkEnables = PERF->blkEnables;
+ if ((blkEnables & SPI_CLK_EN) == 0) {
+ blkEnables |= SPI_CLK_EN;
+ PERF->blkEnables = blkEnables;
+ }
+
+ flash_spi_dev.flash_device_id = device_id = spi_flash_get_device_id(0);
+
+ if ((((char)(device_id >> 8)) == ATMELPART)) {
+ flashFamily = FLASH_ATMEL;
+ switch ((char)(device_id & 0x00ff)) {
+ case ID_AT25F512:
+ numsector = AT25F512_SECTOR;
+ sectorsize = SECTOR_SIZE_32K;
+ break;
+ case ID_AT25F2048:
+ numsector = AT25F2048_SECTOR;
+ sectorsize = SECTOR_SIZE_64K;
+ break;
+ default:
+ break;
+ }
+ }
+ else if (((char)(device_id >> 8)) == (char)SSTPART) {
+ flashFamily = FLASH_SST;
+ sectorsize = SECTOR_SIZE_4K;
+ switch ((unsigned char)(device_id & 0x00ff)) {
+ case ID_SST25VF016B:
+ numsector = SST25VF016B_SECTOR;
+ sstAaiWordProgram = TRUE;
+ break;
+ case ID_SST25VF080:
+ numsector = SST25VF080_SECTOR;
+ break;
+ case ID_SST25VF040:
+ numsector = SST25VF040_SECTOR;
+ break;
+ case ID_SST25VF020:
+ default:
+ numsector = SST25VF020_SECTOR;
+ break;
+ }
+ }
+ else if (((char)(device_id >> 8)) == (char)AMD_S25FL002D) {
+ flashFamily = FLASH_AMD;
+ numsector = AMD25FL_SECTOR;
+ sectorsize = SECTOR_SIZE_64K;
+ device_id &= 0xff00;
+ }
+ else {
+ meminfo.addr = 0L;
+ meminfo.nsect = 1;
+ meminfo.sec[0].size = SECTOR_SIZE_4K;
+ meminfo.sec[0].base = 0x00000;
+ return FLASH_API_ERROR;
+ }
+
+ meminfo.addr = 0L;
+ meminfo.nsect = numsector;
+ for (i = 0; i < numsector; i++) {
+ meminfo.sec[i].size = sectorsize;
+ meminfo.sec[i].base = basecount;
+ basecount += meminfo.sec[i].size;
+ count++;
+ }
+ totalSize = meminfo.sec[count-1].base + meminfo.sec[count-1].size;
+
+ for( fnfi_ptr = fnfi; fnfi_ptr->fnfi_id != 0; fnfi_ptr++ ) {
+ if( fnfi_ptr->fnfi_id == device_id ) {
+ strcpy( flash_spi_dev.flash_device_name, fnfi_ptr->fnfi_name );
+ break;
+ }
+ }
+
+ return (FLASH_API_OK);
+}
+
+/*********************************************************************/
+/* Flash_sector_erase_int() wait until the erase is completed before */
+/* returning control to the calling function. This can be used in */
+/* cases which require the program to hold until a sector is erased, */
+/* without adding the wait check external to this function. */
+/*********************************************************************/
+
+static int spi_flash_sector_erase_int(unsigned short sector)
+{
+ unsigned char buf[4];
+ unsigned int addr;
+ int rc;
+
+ if (flashFamily == FLASH_UNDEFINED)
+ return FLASH_API_ERROR;
+
+ /* set device to write enabled */
+ spi_flash_reset();
+ spi_flash_ub(sector);
+
+ switch (flashFamily) {
+ case FLASH_SST:
+ buf[0] = SST_FLASH_SERASE;
+ break;
+ case FLASH_ATMEL:
+ buf[0] = ATMEL_FLASH_SERASE;
+ break;
+ case FLASH_AMD:
+ buf[0] = AMD_FLASH_SERASE;
+ break;
+ };
+
+
+ /* erase the sector */
+ addr = (unsigned int) spi_get_flash_memptr(sector);
+ buf[1] = (unsigned char)((addr & 0x00ff0000) >> 16);
+ buf[2] = (unsigned char)((addr & 0x0000ff00) >> 8);
+ buf[3] = (unsigned char)(addr & 0x000000ff);
+ rc = spi_write(buf, sizeof(buf));
+
+ /* check device is ready */
+ if (rc == SPI_STATUS_OK) {
+ while (spi_flash_status() != STATUS_READY) {}
+ }
+
+ return(FLASH_API_OK);
+}
+
+/*********************************************************************/
+/* flash_chip_erase_int() wait until the erase is completed before */
+/* returning control to the calling function. This can be used in */
+/* cases which require the program to hold until a sector is erased, */
+/* without adding the wait check external to this function. */
+/*********************************************************************/
+
+#if 0 /* not used */
+unsigned char spi_flash_chip_erase_int(void)
+{
+ unsigned char buf[4];
+ int rc;
+
+ if (flashFamily == FLASH_UNDEFINED)
+ return FLASH_API_ERROR;
+
+ /* set device to write enabled */
+ buf[0] = FLASH_WREN;
+ rc = spi_write(buf, 1);
+
+ /* check device is ready */
+ if (rc == SPI_STATUS_OK) {
+ do {
+ buf[0] = FLASH_RDSR;
+ rc = spi_read(buf, 1, 1);
+ if (rc == SPI_STATUS_OK) {
+ if (buf[0] & SR_WEN) {
+ break;
+ }
+ } else {
+ break;
+ }
+ } while (1);
+ }
+
+ switch (flashFamily) {
+ case FLASH_SST:
+ buf[0] = SST_FLASH_CERASE;
+ break;
+ case FLASH_ATMEL:
+ buf[0] = ATMEL_FLASH_CERASE;
+ break;
+ case FLASH_AMD:
+ buf[0] = AMD_FLASH_CERASE;
+ break;
+ };
+ /* erase the sector */
+ rc = spi_write(buf, 1);
+
+ /* check device is ready */
+ if (rc == SPI_STATUS_OK) {
+ while (spi_flash_status() != STATUS_READY) {}
+ }
+
+ return(FLASH_API_OK);
+}
+#endif
+
+/*********************************************************************/
+/* flash_reset() will reset the flash device to reading array data. */
+/* It is good practice to call this function after autoselect */
+/* sequences had been performed. */
+/*********************************************************************/
+
+static int spi_flash_reset(void)
+{
+ if (flashFamily == FLASH_UNDEFINED)
+ return FLASH_API_ERROR;
+ spi_flash_reset_ub();
+ while (spi_flash_status() != STATUS_READY) { }
+ return(FLASH_API_OK);
+}
+
+/*********************************************************************/
+/* flash_read_buf() reads buffer of data from the specified */
+/* offset from the sector parameter. */
+/*********************************************************************/
+
+static int spi_flash_read_buf(unsigned short sector, int offset,
+ unsigned char *buffer, int numbytes)
+{
+ unsigned char buf[MAX_READ];
+ unsigned int addr;
+ int maxread;
+ int idx;
+
+ if (flashFamily == FLASH_UNDEFINED)
+ return FLASH_API_ERROR;
+
+ spi_flash_reset();
+
+ addr = (unsigned int) spi_get_flash_memptr(sector);
+ addr += offset;
+ idx = 0;
+ while (numbytes) {
+ maxread = (numbytes < sizeof(buf)) ? numbytes : sizeof(buf);
+ buf[0] = FLASH_READ;
+ buf[1] = (unsigned char)((addr & 0x00ff0000) >> 16);
+ buf[2] = (unsigned char)((addr & 0x0000ff00) >> 8);
+ buf[3] = (unsigned char)(addr & 0x000000ff);
+ spi_read(buf, 4, maxread);
+ while (spi_flash_status() != STATUS_READY) {}
+ memcpy(buffer+idx, buf, maxread);
+ idx += maxread;
+ numbytes -= maxread;
+ addr += maxread;
+ }
+
+ return (FLASH_API_OK);
+}
+
+/*********************************************************************/
+/* flash_ub() places the flash into unlock bypass mode. This */
+/* is REQUIRED to be called before any of the other unlock bypass */
+/* commands will become valid (most will be ignored without first */
+/* calling this function. */
+/*********************************************************************/
+
+static int spi_flash_ub(unsigned short sector)
+{
+ unsigned char buf[4];
+ int rc;
+
+ do {
+ buf[0] = FLASH_RDSR;
+ rc = spi_read(buf, 1, 1);
+
+ if (rc == SPI_STATUS_OK) {
+ while (spi_flash_status() != STATUS_READY) {}
+ if (buf[0] & (SR_BP2|SR_BP1|SR_BP0)) {
+ spi_flash_write_status((unsigned char)~(SR_WPEN|SR_BP2|SR_BP1|SR_BP0));
+ } else {
+ break;
+ }
+ } else {
+ break;
+ }
+ } while (1);
+
+ /* set device to write enabled */
+ buf[0] = FLASH_WREN;
+ rc = spi_write(buf, 1);
+
+ /* check device is ready */
+ if (rc == SPI_STATUS_OK) {
+ while (spi_flash_status() != STATUS_READY) {}
+ do {
+ buf[0] = FLASH_RDSR;
+ rc = spi_read(buf, 1, 1);
+ if (rc == SPI_STATUS_OK) {
+ while (spi_flash_status() != STATUS_READY) {}
+ if (buf[0] & SR_WEN) {
+ break;
+ }
+ } else {
+ break;
+ }
+ } while (1);
+ }
+
+ return(FLASH_API_OK);
+}
+
+static int spi_flash_write_status(unsigned char status)
+{
+ unsigned char buf[4];
+ int rc = SPI_STATUS_OK;
+
+ if (flashFamily == FLASH_UNDEFINED)
+ return FLASH_API_ERROR;
+
+ switch (flashFamily) {
+ case FLASH_SST:
+ buf[0] = FLASH_EWSR;
+ rc = spi_write(buf, 1);
+ break;
+ default:
+ break;
+ }
+ if (rc == SPI_STATUS_OK) {
+ buf[0] = FLASH_WRST;
+ buf[1] = (status & (SR_WPEN|SR_BP2|SR_BP1|SR_BP0));
+ rc = spi_write(buf, 2);
+ if (rc == SPI_STATUS_OK)
+ while (spi_flash_status() != STATUS_READY) {}
+ }
+
+ return FLASH_API_OK;
+}
+
+/*********************************************************************/
+/* flash_write_buf() utilizes */
+/* the unlock bypass mode of the flash device. This can remove */
+/* significant overhead from the bulk programming operation, and */
+/* when programming bulk data a sizeable performance increase can be */
+/* observed. */
+/*********************************************************************/
+
+static int spi_flash_write_buf(unsigned short sector, int offset,
+ unsigned char *buffer, int numbytes)
+{
+ int ret = FLASH_API_ERROR;
+
+ if (flashFamily == FLASH_UNDEFINED)
+ return FLASH_API_ERROR;
+
+ ret = spi_flash_write(sector, offset, buffer, numbytes, TRUE);
+
+ if( ret == -1 )
+ printk( "Flash write error. Verify failed\n" );
+
+ return( ret );
+}
+
+/*********************************************************************/
+/* flash_reset_ub() is required to remove the flash from unlock */
+/* bypass mode. This is important, as other flash commands will be */
+/* ignored while the flash is in unlock bypass mode. */
+/*********************************************************************/
+
+static int spi_flash_reset_ub(void)
+{
+ unsigned char buf[4];
+
+ if (flashFamily == FLASH_UNDEFINED)
+ return FLASH_API_ERROR;
+ /* set device to write disabled */
+ buf[0] = FLASH_WRDI;
+ spi_write(buf, 1);
+ while (spi_flash_status() != STATUS_READY) {}
+
+ return(FLASH_API_OK);
+}
+
+/*********************************************************************/
+/* Usefull funtion to return the number of sectors in the device. */
+/* Can be used for functions which need to loop among all the */
+/* sectors, or wish to know the number of the last sector. */
+/*********************************************************************/
+
+static int spi_flash_get_numsectors(void)
+{
+ return meminfo.nsect;
+}
+
+/*********************************************************************/
+/* flash_get_sector_size() is provided for cases in which the size */
+/* of a sector is required by a host application. The sector size */
+/* (in bytes) is returned in the data location pointed to by the */
+/* 'size' parameter. */
+/*********************************************************************/
+
+static int spi_flash_get_sector_size(unsigned short sector)
+{
+ return meminfo.sec[sector].size;
+}
+
+/*********************************************************************/
+/* The purpose of get_flash_memptr() is to return a memory pointer */
+/* which points to the beginning of memory space allocated for the */
+/* flash. All function pointers are then referenced from this */
+/* pointer. */
+/* */
+/* Different systems will implement this in different ways: */
+/* possibilities include: */
+/* - A direct memory pointer */
+/* - A pointer to a memory map */
+/* - A pointer to a hardware port from which the linear */
+/* address is translated */
+/* - Output of an MMU function / service */
+/* */
+/* Also note that this function expects the pointer to a specific */
+/* sector of the device. This can be provided by dereferencing */
+/* the pointer from a translated offset of the sector from a */
+/* global base pointer (e.g. flashptr = base_pointer + sector_offset)*/
+/* */
+/* Important: Many AMD flash devices need both bank and or sector */
+/* address bits to be correctly set (bank address bits are A18-A16, */
+/* and sector address bits are A18-A12, or A12-A15). Flash parts */
+/* which do not need these bits will ignore them, so it is safe to */
+/* assume that every part will require these bits to be set. */
+/*********************************************************************/
+
+static unsigned char *spi_get_flash_memptr(unsigned short sector)
+{
+ unsigned char *memptr = (unsigned char*)
+ (FLASH_BASE + meminfo.sec[sector].base);
+
+ return (memptr);
+}
+
+static unsigned char *spi_flash_get_memptr(unsigned short sector)
+{
+ return( spi_get_flash_memptr(sector) );
+}
+
+/*********************************************************************/
+/* Flash_write extends the functionality of flash_program() by */
+/* providing an faster way to program multiple data words, without */
+/* needing the function overhead of looping algorithms which */
+/* program word by word. This function utilizes fast pointers */
+/* to quickly loop through bulk data. */
+/*********************************************************************/
+static int spi_flash_write(unsigned short sector, int offset, unsigned char *buf,
+ int nbytes, int ub)
+{
+ unsigned char wbuf[64];
+ unsigned int addr;
+ unsigned int dst;
+ unsigned char *pbuf;
+ int cmdlen;
+ int maxwrite;
+ int pagelimit;
+
+ addr = (unsigned int) spi_get_flash_memptr(sector);
+ dst = addr + offset;
+
+ pbuf = buf;
+ switch (flashFamily) {
+ case FLASH_SST:
+ if( sstAaiWordProgram == FALSE )
+ {
+ /* Auto Address Increment one byte at a time. */
+ spi_flash_ub(sector); /* enable write */
+ wbuf[0] = FLASH_AAI;
+ while (nbytes) {
+ if (pbuf != buf) {
+ wbuf[1] = *pbuf;
+ cmdlen = CMD_LEN_1;
+ } else {
+ wbuf[1] = (unsigned char)((dst & 0x00ff0000) >> 16);
+ wbuf[2] = (unsigned char)((dst & 0x0000ff00) >> 8);
+ wbuf[3] = (unsigned char)(dst & 0x000000ff);
+ wbuf[4] = *pbuf;
+ cmdlen = CMD_LEN_4;
+ }
+ spi_write(wbuf, 1+cmdlen);
+ while (spi_flash_status() != STATUS_READY) {}
+ pbuf++; /* update address and count by one byte */
+ nbytes--;
+ }
+ spi_flash_reset_ub();
+ while (spi_flash_status() != STATUS_READY) {}
+ }
+ else
+ {
+ /* Auto Address Increment one word (2 bytes) at a time. */
+ spi_flash_ub(sector); /* enable write */
+ wbuf[0] = FLASH_WORD_AAI;
+ while (nbytes) {
+ if (pbuf != buf) {
+ wbuf[1] = *pbuf;
+ wbuf[2] = *(pbuf + 1);
+ cmdlen = 3;
+ } else {
+ wbuf[1] = (unsigned char)((dst & 0x00ff0000) >> 16);
+ wbuf[2] = (unsigned char)((dst & 0x0000ff00) >> 8);
+ wbuf[3] = (unsigned char)(dst & 0x000000ff);
+ wbuf[4] = *pbuf;
+ wbuf[5] = *(pbuf + 1);
+ cmdlen = 6;
+ }
+ spi_write(wbuf, cmdlen);
+ while (spi_flash_status() != STATUS_READY) {}
+ pbuf += 2; /* update address and count by two bytes */
+ nbytes -= 2;
+ }
+ spi_flash_reset_ub();
+ while (spi_flash_status() != STATUS_READY) {}
+ }
+ break;
+
+ case FLASH_ATMEL:
+ while (nbytes) {
+ spi_flash_ub(sector); /* enable write */
+ maxwrite = (nbytes < (sizeof(SPI->spiMsgData)-CMD_LEN_4))
+ ? nbytes : (sizeof(SPI->spiMsgData)-CMD_LEN_4);
+ /* maxwrite is limit to page boundary */
+ pagelimit = FLASH_PAGE_SIZE - (dst & 0x000000ff);
+ maxwrite = (maxwrite < pagelimit) ? maxwrite : pagelimit;
+
+ wbuf[0] = FLASH_PROG;
+ wbuf[1] = (unsigned char)((dst & 0x00ff0000) >> 16);
+ wbuf[2] = (unsigned char)((dst & 0x0000ff00) >> 8);
+ wbuf[3] = (unsigned char)(dst & 0x000000ff);
+ memcpy(&wbuf[4], pbuf, maxwrite);
+ spi_write(wbuf, maxwrite+CMD_LEN_4);
+ while (spi_flash_status() != STATUS_READY) {}
+ pbuf += maxwrite;
+ nbytes -= maxwrite;
+ dst += maxwrite;
+ }
+ break;
+
+ case FLASH_AMD:
+ while (nbytes) {
+ spi_flash_ub(sector); /* enable write */
+ maxwrite = (nbytes < (sizeof(SPI->spiMsgData)-CMD_LEN_4))
+ ? nbytes : (sizeof(SPI->spiMsgData)-CMD_LEN_4);
+ /* maxwrite is limit to page boundary */
+ pagelimit = FLASH_PAGE_SIZE - (dst & 0x000000ff);
+ maxwrite = (maxwrite < pagelimit) ? maxwrite : pagelimit;
+
+ wbuf[0] = FLASH_PROG;
+ wbuf[1] = (unsigned char)((dst & 0x00ff0000) >> 16);
+ wbuf[2] = (unsigned char)((dst & 0x0000ff00) >> 8);
+ wbuf[3] = (unsigned char)(dst & 0x000000ff);
+ memcpy(&wbuf[4], pbuf, maxwrite);
+ spi_write(wbuf, maxwrite+CMD_LEN_4);
+ while (spi_flash_status() != STATUS_READY) {}
+ pbuf += maxwrite;
+ nbytes -= maxwrite;
+ dst += maxwrite;
+ }
+ break;
+
+ default:
+ return 0;
+ }
+
+ return (pbuf-buf);
+}
+
+/*********************************************************************/
+/* Flash_status return an appropriate status code */
+/*********************************************************************/
+
+static int spi_flash_status(void)
+{
+ unsigned char buf[4];
+ int rc;
+ int retry = 10;
+
+ /* check device is ready */
+ do {
+ buf[0] = FLASH_RDSR;
+ rc = spi_read(buf, 1, 1);
+ if (rc == SPI_STATUS_OK) {
+ if (!(buf[0] & SR_RDY)) {
+ return STATUS_READY;
+ }
+ } else {
+ return STATUS_ERROR;
+ }
+ OSL_DELAY(10);
+ } while (retry--);
+
+ return STATUS_TIMEOUT;
+}
+
+/*********************************************************************/
+/* flash_get_device_id() return the device id of the component. */
+/*********************************************************************/
+
+static unsigned short spi_flash_get_device_id(unsigned short sector)
+{
+ unsigned char buf[4];
+ int prependcnt;
+ int i;
+
+ for (i = 0; i < MAX_RETRY; i++) {
+ /* read product id command */
+ buf[0] = SST_FLASH_RDID;
+ buf[1] = 0;
+ buf[2] = 0;
+ buf[3] = 0;
+ prependcnt = 4;
+ spi_read(buf, prependcnt, sizeof(unsigned short));
+ while (spi_flash_status() != STATUS_READY) {}
+
+ if (buf[0] == SSTPART) {
+ return( *(unsigned short *)&buf[0] );
+ }
+ }
+
+ for (i = 0; i < MAX_RETRY; i++) {
+ buf[0] = ATMEL_FLASH_RDID;
+ prependcnt = 1;
+ spi_read(buf, prependcnt, sizeof(unsigned short));
+ while (spi_flash_status() != STATUS_READY) {}
+
+ if (buf[0] == ATMELPART) {
+ return( *(unsigned short *)&buf[0] );
+ }
+ }
+
+ for (i = 0; i < MAX_RETRY; i++) {
+ buf[0] = AMD_FLASH_RDID;
+ buf[1] = 0;
+ buf[2] = 0;
+ buf[3] = 0;
+ prependcnt = 4;
+ spi_read(buf, prependcnt, sizeof(unsigned short));
+ while (spi_flash_status() != STATUS_READY) {}
+
+ if (buf[0] == AMD_S25FL002D) {
+ return( *(unsigned short *)&buf[0] );
+ }
+ }
+
+ /* return manufacturer code and device code */
+ return( *(unsigned short *)&buf[0] );
+}
+
+/*********************************************************************/
+/* The purpose of flash_get_blk() is to return a the block number */
+/* for a given memory address. */
+/*********************************************************************/
+
+static int spi_flash_get_blk(int addr)
+{
+ int blk_start, i;
+ int last_blk = spi_flash_get_numsectors();
+ int relative_addr = addr - (int) FLASH_BASE;
+
+ for(blk_start=0, i=0; i < relative_addr && blk_start < last_blk; blk_start++)
+ i += spi_flash_get_sector_size(blk_start);
+
+ if( (unsigned int)i > (unsigned int)relative_addr ) {
+ blk_start--; // last blk, dec by 1
+ } else {
+ if( blk_start == last_blk )
+ {
+ printk("Address is too big.\n");
+ blk_start = -1;
+ }
+ }
+
+ return( blk_start );
+}
+
+/************************************************************************/
+/* The purpose of flash_get_total_size() is to return the total size of */
+/* the flash */
+/************************************************************************/
+static int spi_flash_get_total_size(void)
+{
+ return totalSize;
+}
+
+static int spi_flash_get_total_memory_mapped_size(void)
+{
+ return((totalSize < MAX_MEMORY_MAPPED_SIZE)
+ ? totalSize : MAX_MEMORY_MAPPED_SIZE);
+}
+
projects / bcm963xx.git / blobdiff