538 lines
15 KiB
C
538 lines
15 KiB
C
|
/*
|
||
|
|
* $Log: V:/i28f008.c_v $
|
||
|
|
*
|
||
|
|
* Rev 1.16 06 Oct 1997 18:37:30 ANDRY
|
||
|
|
* no COBUX
|
||
|
|
*
|
||
|
|
* Rev 1.15 05 Oct 1997 19:11:08 ANDRY
|
||
|
|
* COBUX (Motorola M68360 16-bit only board)
|
||
|
|
*
|
||
|
|
* Rev 1.14 05 Oct 1997 14:35:36 ANDRY
|
||
|
|
* flNeedVpp() and flDontNeedVpp() are under #ifdef SOCKET_12_VOLTS
|
||
|
|
*
|
||
|
|
* Rev 1.13 10 Sep 1997 16:18:10 danig
|
||
|
|
* Got rid of generic names
|
||
|
|
*
|
||
|
|
* Rev 1.12 04 Sep 1997 18:47:20 danig
|
||
|
|
* Debug messages
|
||
|
|
*
|
||
|
|
* Rev 1.11 31 Aug 1997 15:06:40 danig
|
||
|
|
* Registration routine return status
|
||
|
|
*
|
||
|
|
* Rev 1.10 24 Jul 1997 17:52:30 amirban
|
||
|
|
* FAR to FAR0
|
||
|
|
*
|
||
|
|
* Rev 1.9 21 Jul 1997 14:44:06 danig
|
||
|
|
* No parallelLimit
|
||
|
|
*
|
||
|
|
* Rev 1.8 20 Jul 1997 17:17:00 amirban
|
||
|
|
* No watchDogTimer
|
||
|
|
*
|
||
|
|
* Rev 1.7 07 Jul 1997 15:22:06 amirban
|
||
|
|
* Ver 2.0
|
||
|
|
*
|
||
|
|
* Rev 1.6 15 Apr 1997 19:16:40 danig
|
||
|
|
* Pointer conversions.
|
||
|
|
*
|
||
|
|
* Rev 1.5 29 Aug 1996 14:17:48 amirban
|
||
|
|
* Warnings
|
||
|
|
*
|
||
|
|
* Rev 1.4 18 Aug 1996 13:48:44 amirban
|
||
|
|
* Comments
|
||
|
|
*
|
||
|
|
* Rev 1.3 31 Jul 1996 14:31:10 amirban
|
||
|
|
* Background stuff
|
||
|
|
*
|
||
|
|
* Rev 1.2 04 Jul 1996 18:20:06 amirban
|
||
|
|
* New flag field
|
||
|
|
*
|
||
|
|
* Rev 1.1 03 Jun 1996 16:28:58 amirban
|
||
|
|
* Cobra additions
|
||
|
|
*
|
||
|
|
* Rev 1.0 20 Mar 1996 13:33:06 amirban
|
||
|
|
* Initial revision.
|
||
|
|
*/
|
||
|
|
|
||
|
|
/************************************************************************/
|
||
|
|
/* */
|
||
|
|
/* FAT-FTL Lite Software Development Kit */
|
||
|
|
/* Copyright (C) M-Systems Ltd. 1995-1996 */
|
||
|
|
/* */
|
||
|
|
/************************************************************************/
|
||
|
|
|
||
|
|
/*----------------------------------------------------------------------*/
|
||
|
|
/* */
|
||
|
|
/* This MTD supports the following Flash technologies: */
|
||
|
|
/* */
|
||
|
|
/* - Intel 28F008/Cobra 8-mbit devices */
|
||
|
|
/* - Intel 28F016SA/28016SV/Cobra 16-mbit devices (byte-mode operation) */
|
||
|
|
/* */
|
||
|
|
/* And (among else), the following Flash media and cards: */
|
||
|
|
/* */
|
||
|
|
/* - Intel Series-2 PCMCIA cards */
|
||
|
|
/* - Intel Series-2+ PCMCIA cards */
|
||
|
|
/* - M-Systems ISA/Tiny/PC-104 Flash Disks */
|
||
|
|
/* - M-Systems NOR PCMCIA cards */
|
||
|
|
/* - Intel Value-100 cards */
|
||
|
|
/* */
|
||
|
|
/*----------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
#include "flflash.h"
|
||
|
|
#ifdef FL_BACKGROUND
|
||
|
|
#include "backgrnd.h"
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#define flash (*pFlash)
|
||
|
|
|
||
|
|
#define SETUP_ERASE 0x20
|
||
|
|
#define SETUP_WRITE 0x40
|
||
|
|
#define CLEAR_STATUS 0x50
|
||
|
|
#define READ_STATUS 0x70
|
||
|
|
#define READ_ID 0x90
|
||
|
|
#define SUSPEND_ERASE 0xb0
|
||
|
|
#define CONFIRM_ERASE 0xd0
|
||
|
|
#define RESUME_ERASE 0xd0
|
||
|
|
#define READ_ARRAY 0xff
|
||
|
|
|
||
|
|
#define WSM_ERROR 0x38
|
||
|
|
#define WSM_VPP_ERROR 0x08
|
||
|
|
#define WSM_SUSPENDED 0x40
|
||
|
|
#define WSM_READY 0x80
|
||
|
|
|
||
|
|
/* JEDEC ids for this MTD */
|
||
|
|
#define I28F008_FLASH 0x89a2
|
||
|
|
#define I28F016_FLASH 0x89a0
|
||
|
|
#define COBRA004_FLASH 0x89a7
|
||
|
|
#define COBRA008_FLASH 0x89a6
|
||
|
|
#define COBRA016_FLASH 0x89aa
|
||
|
|
|
||
|
|
#define MOBILE_MAX_INLV_4 0x8989
|
||
|
|
#define LDP_1MB_IN_16BIT_MODE 0x89ff
|
||
|
|
|
||
|
|
/* Definition of MTD specific vol.flags bits: */
|
||
|
|
|
||
|
|
#define NO_12VOLTS 0x100 /* Card does not need 12 Volts Vpp */
|
||
|
|
|
||
|
|
/*----------------------------------------------------------------------*/
|
||
|
|
/* i 2 8 f 0 0 8 W r i t e */
|
||
|
|
/* */
|
||
|
|
/* Write a block of bytes to Flash */
|
||
|
|
/* */
|
||
|
|
/* This routine will be registered as the MTD vol.write routine */
|
||
|
|
/* */
|
||
|
|
/* Parameters: */
|
||
|
|
/* vol : Pointer identifying drive */
|
||
|
|
/* address : Card address to write to */
|
||
|
|
/* buffer : Address of data to write */
|
||
|
|
/* length : Number of bytes to write */
|
||
|
|
/* overwrite : TRUE if overwriting old Flash contents */
|
||
|
|
/* FALSE if old contents are known to be erased */
|
||
|
|
/* */
|
||
|
|
/* Returns: */
|
||
|
|
/* FLStatus : 0 on success, failed otherwise */
|
||
|
|
/*----------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
FLStatus i28f008Write(FLFlash vol,
|
||
|
|
CardAddress address,
|
||
|
|
const VOID FAR1 *buffer,
|
||
|
|
dword length,
|
||
|
|
word overwrite)
|
||
|
|
{
|
||
|
|
/* Set timeout ot 5 seconds from now */
|
||
|
|
ULONG writeTimeout = flMsecCounter + 5000;
|
||
|
|
|
||
|
|
FLStatus status;
|
||
|
|
ULONG i, cLength;
|
||
|
|
FlashPTR flashPtr;
|
||
|
|
|
||
|
|
|
||
|
|
if (flWriteProtected(vol.socket))
|
||
|
|
return flWriteProtect;
|
||
|
|
|
||
|
|
#ifdef SOCKET_12_VOLTS
|
||
|
|
if (!(vol.flags & NO_12VOLTS))
|
||
|
|
checkStatus(flNeedVpp(vol.socket));
|
||
|
|
#endif
|
||
|
|
|
||
|
|
flashPtr = (FlashPTR) flMap(vol.socket,address);
|
||
|
|
cLength = length;
|
||
|
|
|
||
|
|
if (vol.interleaving == 1) {
|
||
|
|
lastByte:
|
||
|
|
#ifdef __cplusplus
|
||
|
|
#define bFlashPtr flashPtr
|
||
|
|
#define bBuffer ((const UCHAR FAR1 * &) buffer)
|
||
|
|
#else
|
||
|
|
#define bFlashPtr flashPtr
|
||
|
|
#define bBuffer ((const UCHAR FAR1 *) buffer)
|
||
|
|
#endif
|
||
|
|
while (cLength >= 1) {
|
||
|
|
tffsWriteByteFlash(bFlashPtr, SETUP_WRITE);
|
||
|
|
tffsWriteByteFlash(bFlashPtr, *bBuffer);
|
||
|
|
cLength--;
|
||
|
|
bBuffer++;
|
||
|
|
bFlashPtr++;
|
||
|
|
while (!(tffsReadByteFlash(bFlashPtr-1) & WSM_READY) && flMsecCounter < writeTimeout)
|
||
|
|
;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (vol.interleaving == 2) {
|
||
|
|
lastWord:
|
||
|
|
#ifdef __cplusplus
|
||
|
|
#define wFlashPtr ((FlashWPTR &) flashPtr)
|
||
|
|
#define wBuffer ((const USHORT FAR1 * &) buffer)
|
||
|
|
#else
|
||
|
|
#define wFlashPtr ((FlashWPTR) flashPtr)
|
||
|
|
#define wBuffer ((const USHORT FAR1 *) buffer)
|
||
|
|
#endif
|
||
|
|
while (cLength >= 2) {
|
||
|
|
tffsWriteWordFlash(wFlashPtr, SETUP_WRITE * 0x101);
|
||
|
|
tffsWriteWordFlash(wFlashPtr, *wBuffer);
|
||
|
|
cLength -= 2;
|
||
|
|
wBuffer++;
|
||
|
|
wFlashPtr++;
|
||
|
|
while ((~(tffsReadWordFlash(wFlashPtr-1)) & (WSM_READY * 0x101)) && flMsecCounter < writeTimeout)
|
||
|
|
;
|
||
|
|
}
|
||
|
|
if (cLength > 0)
|
||
|
|
goto lastByte;
|
||
|
|
}
|
||
|
|
else /* if (vol.interleaving >= 4) */ {
|
||
|
|
#ifdef __cplusplus
|
||
|
|
#define dFlashPtr ((FlashDPTR &) flashPtr)
|
||
|
|
#define dBuffer ((const ULONG FAR1 * &) buffer)
|
||
|
|
#else
|
||
|
|
#define dFlashPtr ((FlashDPTR) flashPtr)
|
||
|
|
#define dBuffer ((const ULONG FAR1 *) buffer)
|
||
|
|
#endif
|
||
|
|
while (cLength >= 4) {
|
||
|
|
tffsWriteDwordFlash(dFlashPtr, SETUP_WRITE * 0x1010101l);
|
||
|
|
tffsWriteDwordFlash(dFlashPtr, *dBuffer);
|
||
|
|
cLength -= 4;
|
||
|
|
dBuffer++;
|
||
|
|
dFlashPtr++;
|
||
|
|
while ((~(tffsReadDwordFlash(dFlashPtr-1)) & (WSM_READY * 0x1010101lu)) && flMsecCounter < writeTimeout)
|
||
|
|
;
|
||
|
|
}
|
||
|
|
if (cLength > 0)
|
||
|
|
goto lastWord;
|
||
|
|
}
|
||
|
|
|
||
|
|
flashPtr -= length;
|
||
|
|
bBuffer -= length;
|
||
|
|
|
||
|
|
status = flOK;
|
||
|
|
for (i = 0; i < (ULONG)vol.interleaving && i < length; i++) {
|
||
|
|
if (tffsReadByteFlash(flashPtr + i) & WSM_ERROR) {
|
||
|
|
DEBUG_PRINT(("Debug: write failed for 8-bit Intel media.\n"));
|
||
|
|
status = (tffsReadByteFlash(flashPtr + i) & WSM_VPP_ERROR) ? flVppFailure : flWriteFault;
|
||
|
|
tffsWriteByteFlash(flashPtr + i, CLEAR_STATUS);
|
||
|
|
}
|
||
|
|
tffsWriteByteFlash(flashPtr + i, READ_ARRAY);
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifdef SOCKET_12_VOLTS
|
||
|
|
if (!(vol.flags & NO_12VOLTS))
|
||
|
|
flDontNeedVpp(vol.socket);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/* verify the data */
|
||
|
|
if (status == flOK) {
|
||
|
|
/* compare double words */
|
||
|
|
for (;length >= 4; length -= 4, dFlashPtr++, dBuffer++) {
|
||
|
|
if (tffsReadDwordFlash(dFlashPtr) != *dBuffer) {
|
||
|
|
DEBUG_PRINT(("Debug: write failed for 8-bit Intel media in verification.\n"));
|
||
|
|
return flWriteFault;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* compare the last bytes */
|
||
|
|
for (; length; length--, bFlashPtr++, bBuffer++) {
|
||
|
|
if (tffsReadByteFlash(bFlashPtr) != *bBuffer) {
|
||
|
|
DEBUG_PRINT(("Debug: write failed for 8-bit Intel media in verification.\n"));
|
||
|
|
return flWriteFault;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return status;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*----------------------------------------------------------------------*/
|
||
|
|
/* i 2 8 f 0 0 8 E r a s e */
|
||
|
|
/* */
|
||
|
|
/* Erase one or more contiguous Flash erasable blocks */
|
||
|
|
/* */
|
||
|
|
/* This routine will be registered as the MTD vol.erase routine */
|
||
|
|
/* */
|
||
|
|
/* Parameters: */
|
||
|
|
/* vol : Pointer identifying drive */
|
||
|
|
/* firstErasableBlock : Number of first block to erase */
|
||
|
|
/* numOfErasableBlocks: Number of blocks to erase */
|
||
|
|
/* */
|
||
|
|
/* Returns: */
|
||
|
|
/* FLStatus : 0 on success, failed otherwise */
|
||
|
|
/*----------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
FLStatus i28f008Erase(FLFlash vol,
|
||
|
|
word firstErasableBlock,
|
||
|
|
word numOfErasableBlocks)
|
||
|
|
{
|
||
|
|
LONG iBlock;
|
||
|
|
|
||
|
|
FLStatus status = flOK; /* unless proven otherwise */
|
||
|
|
|
||
|
|
if (flWriteProtected(vol.socket))
|
||
|
|
return flWriteProtect;
|
||
|
|
|
||
|
|
#ifdef SOCKET_12_VOLTS
|
||
|
|
if (!(vol.flags & NO_12VOLTS))
|
||
|
|
checkStatus(flNeedVpp(vol.socket));
|
||
|
|
#endif
|
||
|
|
|
||
|
|
for (iBlock = 0; iBlock < numOfErasableBlocks && status == flOK; iBlock++) {
|
||
|
|
LONG j;
|
||
|
|
FLBoolean finished;
|
||
|
|
|
||
|
|
FlashPTR flashPtr = (FlashPTR)
|
||
|
|
flMap(vol.socket,
|
||
|
|
(firstErasableBlock + iBlock) * vol.erasableBlockSize);
|
||
|
|
|
||
|
|
for (j = 0; j < vol.interleaving; j++) {
|
||
|
|
tffsWriteByteFlash(flashPtr + j, SETUP_ERASE);
|
||
|
|
tffsWriteByteFlash(flashPtr + j, CONFIRM_ERASE);
|
||
|
|
}
|
||
|
|
|
||
|
|
do {
|
||
|
|
#ifdef FL_BACKGROUND
|
||
|
|
while (flForeground(1) == BG_SUSPEND) { /* suspend */
|
||
|
|
for (j = 0; j < vol.interleaving; j++) {
|
||
|
|
tffsWriteByteFlash(flashPtr + j, READ_STATUS);
|
||
|
|
if (!(tffsReadByteFlash(flashPtr + j) & WSM_READY)) {
|
||
|
|
tffsWriteByteFlash(flashPtr + j, SUSPEND_ERASE);
|
||
|
|
tffsWriteByteFlash(flashPtr + j, READ_STATUS);
|
||
|
|
while (!(tffsReadByteFlash(flashPtr + j) & WSM_READY))
|
||
|
|
;
|
||
|
|
}
|
||
|
|
tffsWriteByteFlash(flashPtr + j, READ_ARRAY);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
finished = TRUE;
|
||
|
|
for (j = 0; j < vol.interleaving; j++) {
|
||
|
|
tffsWriteByteFlash(flashPtr + j, READ_STATUS);
|
||
|
|
if (tffsReadByteFlash(flashPtr + j) & WSM_SUSPENDED) {
|
||
|
|
tffsWriteByteFlash(flashPtr + j, RESUME_ERASE);
|
||
|
|
finished = FALSE;
|
||
|
|
}
|
||
|
|
else if (!(tffsReadByteFlash(flashPtr + j) & WSM_READY))
|
||
|
|
finished = FALSE;
|
||
|
|
else {
|
||
|
|
if (tffsReadByteFlash(flashPtr + j) & WSM_ERROR) {
|
||
|
|
DEBUG_PRINT(("Debug: erase failed for 8-bit Intel media.\n"));
|
||
|
|
status = (tffsReadByteFlash(flashPtr + j) & WSM_VPP_ERROR) ? flVppFailure : flWriteFault;
|
||
|
|
tffsWriteByteFlash(flashPtr + j, CLEAR_STATUS);
|
||
|
|
}
|
||
|
|
tffsWriteByteFlash(flashPtr + j, READ_ARRAY);
|
||
|
|
}
|
||
|
|
flDelayMsecs(10);
|
||
|
|
}
|
||
|
|
} while (!finished);
|
||
|
|
} /* block loop */
|
||
|
|
|
||
|
|
#ifdef SOCKET_12_VOLTS
|
||
|
|
if (!(vol.flags & NO_12VOLTS))
|
||
|
|
flDontNeedVpp(vol.socket);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
return status;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*----------------------------------------------------------------------*/
|
||
|
|
/* i 2 8 f 0 0 8 M a p */
|
||
|
|
/* */
|
||
|
|
/* Map through buffer. This routine will be registered as the map */
|
||
|
|
/* routine for this MTD. */
|
||
|
|
/* */
|
||
|
|
/* Parameters: */
|
||
|
|
/* vol : Pointer identifying drive */
|
||
|
|
/* address : Flash address to be mapped. */
|
||
|
|
/* length : number of bytes to map. */
|
||
|
|
/* */
|
||
|
|
/* Returns: */
|
||
|
|
/* Pointer to the buffer data was mapped to. */
|
||
|
|
/* */
|
||
|
|
/*----------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
VOID FAR0 *i28f008Map (FLFlash vol, CardAddress address, int length)
|
||
|
|
{
|
||
|
|
vol.socket->remapped = TRUE;
|
||
|
|
return mapThroughBuffer(&vol,address,length);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*----------------------------------------------------------------------*/
|
||
|
|
/* i 2 8 f 0 0 8 R e a d */
|
||
|
|
/* */
|
||
|
|
/* Read some data from the flash. This routine will be registered as */
|
||
|
|
/* the read routine for this MTD. */
|
||
|
|
/* */
|
||
|
|
/* Parameters: */
|
||
|
|
/* vol : Pointer identifying drive */
|
||
|
|
/* address : Address to read from. */
|
||
|
|
/* buffer : buffer to read to. */
|
||
|
|
/* length : number of bytes to read (up to sector size). */
|
||
|
|
/* modes : EDC flag etc. */
|
||
|
|
/* */
|
||
|
|
/* Returns: */
|
||
|
|
/* FLStatus : 0 on success, otherwise failed. */
|
||
|
|
/* */
|
||
|
|
/*----------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
FLStatus i28f008Read(FLFlash vol,
|
||
|
|
CardAddress address,
|
||
|
|
VOID FAR1 *buffer,
|
||
|
|
dword length,
|
||
|
|
word modes)
|
||
|
|
{
|
||
|
|
ULONG i;
|
||
|
|
UCHAR * byteBuffer;
|
||
|
|
FlashPTR byteFlashPtr;
|
||
|
|
ULONG * dwordBuffer = (ULONG *)buffer;
|
||
|
|
FlashDPTR dwordFlashPtr = (FlashDPTR)flMap(vol.socket, address);
|
||
|
|
|
||
|
|
for (i = 0; i < length - 4; i += 4, dwordBuffer++, dwordFlashPtr++) {
|
||
|
|
*dwordBuffer = tffsReadDwordFlash(dwordFlashPtr);
|
||
|
|
}
|
||
|
|
byteBuffer = (UCHAR *)dwordBuffer;
|
||
|
|
byteFlashPtr = (FlashPTR)dwordFlashPtr;
|
||
|
|
for(; i < length; i++, byteBuffer++, byteFlashPtr++) {
|
||
|
|
*byteBuffer = tffsReadByteFlash(byteFlashPtr);
|
||
|
|
}
|
||
|
|
return flOK ;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*----------------------------------------------------------------------*/
|
||
|
|
/* i 2 8 f 0 0 8 I d e n t i f y */
|
||
|
|
/* */
|
||
|
|
/* Identifies media based on Intel 28F008 and Intel 28F016 and */
|
||
|
|
/* registers as an MTD for such */
|
||
|
|
/* */
|
||
|
|
/* This routine will be placed on the MTD list in custom.h. It must be */
|
||
|
|
/* an extern routine. */
|
||
|
|
/* */
|
||
|
|
/* On successful identification, the Flash structure is filled out and */
|
||
|
|
/* the write and erase routines registered. */
|
||
|
|
/* */
|
||
|
|
/* Parameters: */
|
||
|
|
/* vol : Pointer identifying drive */
|
||
|
|
/* */
|
||
|
|
/* Returns: */
|
||
|
|
/* FLStatus : 0 on positive identificaion, failed otherwise */
|
||
|
|
/*----------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
FLStatus i28f008Identify(FLFlash vol)
|
||
|
|
{
|
||
|
|
LONG iChip;
|
||
|
|
|
||
|
|
CardAddress idOffset = 0;
|
||
|
|
|
||
|
|
DEBUG_PRINT(("Debug: i28f008Identify :entering 8-bit Intel media identification routine.\n"));
|
||
|
|
|
||
|
|
flSetWindowBusWidth(vol.socket, 16);/* use 16-bits */
|
||
|
|
flSetWindowSpeed(vol.socket, 150); /* 120 nsec. */
|
||
|
|
flSetWindowSize(vol.socket, 2); /* 8 KBytes */
|
||
|
|
|
||
|
|
flIntelIdentify(&vol, NULL,0);
|
||
|
|
|
||
|
|
if (vol.type == NOT_FLASH) {
|
||
|
|
/* The flash may be write-protected at offset 0. Try another offset */
|
||
|
|
idOffset = 0x80000l;
|
||
|
|
flIntelIdentify(&vol, NULL,idOffset);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (vol.type == LDP_1MB_IN_16BIT_MODE) {
|
||
|
|
flSetWindowBusWidth(vol.socket, 8); /* use 8-bits */
|
||
|
|
flIntelIdentify(&vol, NULL,idOffset); /* and try to get a valid id */
|
||
|
|
}
|
||
|
|
|
||
|
|
switch (vol.type) {
|
||
|
|
case COBRA004_FLASH:
|
||
|
|
vol.chipSize = 0x80000l;
|
||
|
|
vol.flags |= SUSPEND_FOR_WRITE | NO_12VOLTS;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case COBRA008_FLASH:
|
||
|
|
vol.flags |= SUSPEND_FOR_WRITE | NO_12VOLTS;
|
||
|
|
/* no break */
|
||
|
|
|
||
|
|
case MOBILE_MAX_INLV_4:
|
||
|
|
case I28F008_FLASH:
|
||
|
|
vol.chipSize = 0x100000l;
|
||
|
|
break;
|
||
|
|
|
||
|
|
case COBRA016_FLASH:
|
||
|
|
vol.flags |= SUSPEND_FOR_WRITE | NO_12VOLTS;
|
||
|
|
/* no break */
|
||
|
|
|
||
|
|
case I28F016_FLASH:
|
||
|
|
vol.chipSize = 0x200000l;
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
DEBUG_PRINT(("Debug: failed to identify 8-bit Intel media.\n"));
|
||
|
|
return flUnknownMedia; /* not ours */
|
||
|
|
}
|
||
|
|
|
||
|
|
vol.erasableBlockSize = 0x10000l * vol.interleaving;
|
||
|
|
|
||
|
|
checkStatus(flIntelSize(&vol, NULL,idOffset));
|
||
|
|
|
||
|
|
if (vol.type == MOBILE_MAX_INLV_4)
|
||
|
|
vol.type = I28F008_FLASH;
|
||
|
|
|
||
|
|
for (iChip = 0; iChip < vol.noOfChips; iChip += vol.interleaving) {
|
||
|
|
LONG i;
|
||
|
|
|
||
|
|
FlashPTR flashPtr = (FlashPTR)
|
||
|
|
flMap(vol.socket,iChip * vol.chipSize);
|
||
|
|
|
||
|
|
for (i = 0; i < vol.interleaving; i++)
|
||
|
|
tffsWriteByteFlash(flashPtr + i, CLEAR_STATUS);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Register our flash handlers */
|
||
|
|
vol.write = i28f008Write;
|
||
|
|
vol.erase = i28f008Erase;
|
||
|
|
vol.read = i28f008Read;
|
||
|
|
vol.map = i28f008Map;
|
||
|
|
|
||
|
|
DEBUG_PRINT(("Debug: i28f008Identify :identified 8-bit Intel media.\n"));
|
||
|
|
|
||
|
|
return flOK;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*----------------------------------------------------------------------*/
|
||
|
|
/* f l R e g i s t e r I 2 8 F 0 0 8 */
|
||
|
|
/* */
|
||
|
|
/* Registers this MTD for use */
|
||
|
|
/* */
|
||
|
|
/* Parameters: */
|
||
|
|
/* None */
|
||
|
|
/* */
|
||
|
|
/* Returns: */
|
||
|
|
/* FLStatus : 0 on success, otherwise failure */
|
||
|
|
/*----------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
FLStatus flRegisterI28F008(VOID)
|
||
|
|
{
|
||
|
|
if (noOfMTDs >= MTDS)
|
||
|
|
return flTooManyComponents;
|
||
|
|
|
||
|
|
mtdTable[noOfMTDs++] = i28f008Identify;
|
||
|
|
|
||
|
|
return flOK;
|
||
|
|
}
|
||
|
|
|