1234 lines
40 KiB
C
1234 lines
40 KiB
C
/*
|
|
* $Log: P:/user/amir/lite/vcs/cfiscs.c_v $
|
|
*
|
|
* Rev 1.19 06 Oct 1997 9:53:30 danig
|
|
* VPP functions under #ifdef
|
|
*
|
|
* Rev 1.18 18 Sep 1997 10:05:40 danig
|
|
* Warnings
|
|
*
|
|
* Rev 1.17 10 Sep 1997 16:31:16 danig
|
|
* Got rid of generic names
|
|
*
|
|
* Rev 1.16 04 Sep 1997 18:19:34 danig
|
|
* Debug messages
|
|
*
|
|
* Rev 1.15 31 Aug 1997 14:50:52 danig
|
|
* Registration routine return status
|
|
*
|
|
* Rev 1.14 27 Jul 1997 15:00:38 danig
|
|
* FAR -> FAR0
|
|
*
|
|
* Rev 1.13 21 Jul 1997 19:58:24 danig
|
|
* No watchDogTimer
|
|
*
|
|
* Rev 1.12 15 Jul 1997 19:18:32 danig
|
|
* Ver 2.0
|
|
*
|
|
* Rev 1.11 09 Jul 1997 10:58:52 danig
|
|
* Fixed byte erase bug & changed identification routines
|
|
*
|
|
* Rev 1.10 20 May 1997 14:48:02 danig
|
|
* Changed overwrite to mode in write routines
|
|
*
|
|
* Rev 1.9 18 May 1997 13:54:58 danig
|
|
* JEDEC ID independent
|
|
*
|
|
* Rev 1.8 13 May 1997 16:43:10 danig
|
|
* Added getMultiplier.
|
|
*
|
|
* Rev 1.7 08 May 1997 19:56:12 danig
|
|
* Added cfiscsByteSize
|
|
*
|
|
* Rev 1.6 04 May 1997 14:01:16 danig
|
|
* Changed cfiscsByteErase and added multiplier
|
|
*
|
|
* Rev 1.4 15 Apr 1997 11:38:52 danig
|
|
* Changed word identification and IDs.
|
|
*
|
|
* Rev 1.3 15 Jan 1997 18:21:40 danig
|
|
* Bigger ID string buffers and removed unused definitions.
|
|
*
|
|
* Rev 1.2 08 Jan 1997 14:54:06 danig
|
|
* Changes in specification
|
|
*
|
|
* Rev 1.1 25 Dec 1996 18:21:44 danig
|
|
* Initial revision
|
|
*/
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* FAT-FTL Lite Software Development Kit */
|
|
/* Copyright (C) M-Systems Ltd. 1995-1997 */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* This MTD supports the SCS/CFI technology. */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
#include "flflash.h"
|
|
#ifdef FL_BACKGROUND
|
|
#include "backgrnd.h"
|
|
#endif
|
|
|
|
/* JEDEC-IDs */
|
|
|
|
#define VOYAGER_ID 0x8915
|
|
#define KING_COBRA_ID 0xb0d0
|
|
|
|
/* command set IDs */
|
|
|
|
#define INTEL_COMMAND_SET 0x0001
|
|
#define AMDFUJ_COMMAND_SET 0x0002
|
|
#define INTEL_ALT_COMMAND_SET 0x0001
|
|
#define AMDFUJ_ALT_COMMAND_SET 0x0004
|
|
#define ALT_NOT_SUPPORTED 0x0000
|
|
|
|
|
|
/* CFI identification strings */
|
|
|
|
#define ID_STR_LENGTH 3
|
|
#define QUERY_ID_STR "QRY"
|
|
#define PRIMARY_ID_STR "PRI"
|
|
#define ALTERNATE_ID_STR "ALT"
|
|
|
|
|
|
/* commands */
|
|
|
|
#define CONFIRM_SET_LOCK_BIT 0x01
|
|
#define SETUP_BLOCK_ERASE 0x20
|
|
#define SETUP_QUEUE_ERASE 0x28
|
|
#define SETUP_CHIP_ERASE 0x30
|
|
#define CLEAR_STATUS 0x50
|
|
#define SET_LOCK_BIT 0x60
|
|
#define CLEAR_LOCK_BIT 0x60
|
|
#define READ_STATUS 0x70
|
|
#define READ_ID 0x90
|
|
#define QUERY 0x98
|
|
#define SUSPEND_WRITE 0xb0
|
|
#define SUSPEND_ERASE 0xb0
|
|
#define CONFIG 0xb8
|
|
#define CONFIRM_WRITE 0xd0
|
|
#define RESUME_WRITE 0xd0
|
|
#define CONFIRM_ERASE 0xd0
|
|
#define RESUME_ERASE 0xd0
|
|
#define CONFIRM_CLEAR_LOCK_BIT 0xd0
|
|
#define WRITE_TO_BUFFER 0xe8
|
|
#define READ_ARRAY 0xff
|
|
|
|
|
|
/* status register bits */
|
|
|
|
#define WSM_ERROR 0x3a
|
|
#define SR_BLOCK_LOCK 0x02
|
|
#define SR_WRITE_SUSPEND 0x04
|
|
#define SR_VPP_ERROR 0x08
|
|
#define SR_WRITE_ERROR 0x10
|
|
#define SR_LOCK_SET_ERROR 0x10
|
|
#define SR_ERASE_ERROR 0x20
|
|
#define SR_LOCK_RESET_ERROR 0x20
|
|
#define SR_ERASE_SUSPEND 0x40
|
|
#define SR_READY 0x80
|
|
|
|
|
|
/* optional commands support */
|
|
|
|
#define CHIP_ERASE_SUPPORT 0x0001
|
|
#define SUSPEND_ERASE_SUPPORT 0x0002
|
|
#define SUSPEND_WRITE_SUPPORT 0x0004
|
|
#define LOCK_SUPPORT 0x0008
|
|
#define QUEUED_ERASE_SUPPORT 0x0010
|
|
|
|
|
|
/* supported functions after suspend */
|
|
|
|
#define WRITE_AFTER_SUSPEND_SUPPORT 0x0001
|
|
|
|
|
|
/* a structure that hold important CFI data. */
|
|
typedef struct {
|
|
|
|
ULONG commandSetId; /* id of a specific command set. */
|
|
ULONG altCommandSetId; /* id of alternate command set. */
|
|
FLBoolean wordMode; /* TRUE - word mode. */
|
|
/* FALSE - byte mode. */
|
|
LONG multiplier; /* the number of times each byte */
|
|
/* of data appears in READ_ID */
|
|
/* and QUERY commands. */
|
|
ULONG maxBytesWrite; /* maximum number of bytes */
|
|
/* in multi-byte write. */
|
|
FLBoolean vpp; /* if = TRUE, need vpp. */
|
|
LONG optionalCommands; /* optional commands supported */
|
|
/* (1 = yes, 0 = no): */
|
|
/* bit 0 - chip erase. */
|
|
/* bit 1 - suspend erase. */
|
|
/* bit 2 - suspend write */
|
|
/* bit 3 - lock/unlock. */
|
|
/* bit 4 - queued erase. */
|
|
ULONG afterSuspend; /* functions supported after */
|
|
/* suspend (1 = yes, 0 = no): */
|
|
/* bit 0 - write after erase */
|
|
/* suspend. */
|
|
} CFI;
|
|
|
|
CFI mtdVars_cfiscs[SOCKETS];
|
|
|
|
#define thisCFI ((CFI *)vol.mtdVars)
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* c f i s c s B y t e S i z e */
|
|
/* */
|
|
/* Identify the card size for byte mode. */
|
|
/* Sets the value of flash.noOfChips. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* amdCmdRoutine : Routine to read-id AMD/Fujitsu style at */
|
|
/* a specific location. If null, Intel procedure */
|
|
/* is used. */
|
|
/* idOffset : Chip offset to use for identification */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 = OK, otherwise failed (invalid Flash array)*/
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
FLStatus cfiscsByteSize(FLFlash vol)
|
|
{
|
|
CHAR queryIdStr[ID_STR_LENGTH + 1] = QUERY_ID_STR;
|
|
|
|
FlashPTR flashPtr = (FlashPTR) flMap(vol.socket, 0);
|
|
tffsWriteByteFlash(flashPtr + (0x55 * vol.interleaving), QUERY);
|
|
/* We leave the first chip in QUERY mode, so that we can */
|
|
/* discover an address wraparound. */
|
|
|
|
for (vol.noOfChips = 0; /* Scan the chips */
|
|
vol.noOfChips < 2000; /* Big enough ? */
|
|
vol.noOfChips += vol.interleaving) {
|
|
LONG i;
|
|
|
|
flashPtr = (FlashPTR) flMap(vol.socket, vol.noOfChips * vol.chipSize);
|
|
|
|
/* Check for address wraparound to the first chip */
|
|
if (vol.noOfChips > 0 &&
|
|
(queryIdStr[0] == tffsReadByteFlash(flashPtr +
|
|
0x10 * vol.interleaving * thisCFI->multiplier) &&
|
|
queryIdStr[1] == tffsReadByteFlash(flashPtr +
|
|
0x11 * vol.interleaving * thisCFI->multiplier) &&
|
|
queryIdStr[2] == tffsReadByteFlash(flashPtr +
|
|
0x12 * vol.interleaving * thisCFI->multiplier)))
|
|
goto noMoreChips; /* wraparound */
|
|
|
|
/* Check if chip displays the "QRY" ID string */
|
|
for (i = (vol.noOfChips ? 0 : 1); i < vol.interleaving; i++) {
|
|
tffsWriteByteFlash(flashPtr + vol.interleaving * 0x55 + i, QUERY);
|
|
if (queryIdStr[0] != tffsReadByteFlash(flashPtr +
|
|
0x10 * vol.interleaving * thisCFI->multiplier + i) ||
|
|
queryIdStr[1] != tffsReadByteFlash(flashPtr +
|
|
0x11 * vol.interleaving * thisCFI->multiplier + i) ||
|
|
queryIdStr[2] != tffsReadByteFlash(flashPtr +
|
|
0x12 * vol.interleaving * thisCFI->multiplier + i))
|
|
goto noMoreChips; /* This "chip" doesn't respond correctly, so we're done */
|
|
|
|
tffsWriteByteFlash(flashPtr+i, READ_ARRAY);
|
|
}
|
|
}
|
|
|
|
noMoreChips:
|
|
flashPtr = (FlashPTR) flMap(vol.socket, 0);
|
|
tffsWriteByteFlash(flashPtr, READ_ARRAY); /* reset the original chip */
|
|
|
|
return (vol.noOfChips == 0) ? flUnknownMedia : flOK;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* c f i s c s B y t e I d e n t i f y */
|
|
/* */
|
|
/* Identify the Flash type for cards in byte mode. */
|
|
/* Sets the value of flash.type (JEDEC id) & flash.interleaving. */
|
|
/* Calculate the number of times each byte of data appears in READ_ID */
|
|
/* and QUERY commands. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 = OK, otherwise failed (invalid Flash array)*/
|
|
/*----------------------------------------------------------------------*/
|
|
FLStatus cfiscsByteIdentify(FLFlash vol)
|
|
{
|
|
LONG inlv, mul;
|
|
FlashPTR flashPtr = (FlashPTR) flMap(vol.socket, 0);
|
|
|
|
for (inlv = 1; inlv <= 8; inlv++) /* let us assume that interleaving is 8 */
|
|
tffsWriteByteFlash(flashPtr+inlv, READ_ARRAY); /* and reset all the interleaved chips */
|
|
|
|
for (inlv = 1; inlv <= 8; inlv++) {
|
|
for (mul = 1; mul <= 8; mul++) { /* try all possibilities */
|
|
LONG letter;
|
|
|
|
tffsWriteByteFlash(flashPtr + 0x55 * inlv, QUERY);
|
|
|
|
for (letter = 0; letter < ID_STR_LENGTH; letter++) { /* look for "QRY" id string */
|
|
CHAR idChar = '?';
|
|
LONG offset, counter;
|
|
|
|
switch (letter) {
|
|
case 0:
|
|
idChar = 'Q';
|
|
break;
|
|
case 1:
|
|
idChar = 'R';
|
|
break;
|
|
case 2:
|
|
idChar = 'Y';
|
|
break;
|
|
}
|
|
|
|
for (counter = 0, offset = (0x10 + letter) * inlv * mul;
|
|
counter < mul;
|
|
counter++, offset += inlv) /* each character should appear mul times */
|
|
if (tffsReadByteFlash(flashPtr+offset) != idChar)
|
|
break;
|
|
|
|
if (counter < mul) /* no match */
|
|
break;
|
|
}
|
|
|
|
tffsWriteByteFlash(flashPtr + 0x55 * inlv, READ_ARRAY); /* reset the chip */
|
|
if (letter >= ID_STR_LENGTH)
|
|
goto checkInlv;
|
|
}
|
|
}
|
|
|
|
checkInlv:
|
|
|
|
if (inlv > 8) /* too much */
|
|
return flUnknownMedia;
|
|
|
|
if (inlv & (inlv - 1))
|
|
return flUnknownMedia; /* not a power of 2, no way ! */
|
|
|
|
vol.interleaving = (unsigned short)inlv;
|
|
thisCFI->multiplier = mul;
|
|
tffsWriteByteFlash(flashPtr + 0x55 * inlv, QUERY);
|
|
vol.type = (FlashType) ((tffsReadByteFlash(flashPtr) << 8) |
|
|
tffsReadByteFlash(flashPtr + inlv * thisCFI->multiplier));
|
|
tffsWriteByteFlash(flashPtr+inlv, READ_ARRAY);
|
|
|
|
return flOK;
|
|
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* c f i s c s W o r d S i z e */
|
|
/* */
|
|
/* Identify the card size for a word-mode Flash array. */
|
|
/* Sets the value of flash.noOfChips. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 = OK, otherwise failed (invalid Flash array)*/
|
|
/*----------------------------------------------------------------------*/
|
|
FLStatus cfiscsWordSize(FLFlash vol)
|
|
{
|
|
CHAR queryIdStr[ID_STR_LENGTH + 1] = QUERY_ID_STR;
|
|
|
|
FlashWPTR flashPtr = (FlashWPTR) flMap(vol.socket, 0);
|
|
tffsWriteWordFlash(flashPtr, CLEAR_STATUS);
|
|
tffsWriteWordFlash(flashPtr+0x55, QUERY);
|
|
/* We leave the first chip in QUERY mode, so that we can */
|
|
/* discover an address wraparound. */
|
|
|
|
for (vol.noOfChips = 1; /* Scan the chips */
|
|
vol.noOfChips < 2000; /* Big enough ? */
|
|
vol.noOfChips++) {
|
|
flashPtr = (FlashWPTR) flMap(vol.socket, vol.noOfChips * vol.chipSize);
|
|
|
|
if ((tffsReadWordFlash(flashPtr+0x10) == (USHORT)queryIdStr[0]) &&
|
|
(tffsReadWordFlash(flashPtr+0x11) == (USHORT)queryIdStr[1]) &&
|
|
(tffsReadWordFlash(flashPtr+0x12) == (USHORT)queryIdStr[2]))
|
|
break; /* We've wrapped around to the first chip ! */
|
|
|
|
tffsWriteWordFlash(flashPtr+0x55, QUERY);
|
|
if ((tffsReadWordFlash(flashPtr+0x10) != (USHORT)queryIdStr[0]) ||
|
|
(tffsReadWordFlash(flashPtr+0x11) != (USHORT)queryIdStr[1]) ||
|
|
(tffsReadWordFlash(flashPtr+0x12) != (USHORT)queryIdStr[2]))
|
|
break;
|
|
|
|
tffsWriteWordFlash(flashPtr, CLEAR_STATUS);
|
|
tffsWriteWordFlash(flashPtr, READ_ARRAY);
|
|
}
|
|
|
|
flashPtr = (FlashWPTR) flMap(vol.socket, 0);
|
|
tffsWriteWordFlash(flashPtr, READ_ARRAY);
|
|
|
|
return flOK;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* g e t B y t e C F I */
|
|
/* */
|
|
/* Load important CFI data to the CFI structure in a byte-mode. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 = OK, otherwise failed. */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
FLStatus getByteCFI(FLFlash vol)
|
|
{
|
|
ULONG primaryTable, secondaryTable;
|
|
CHAR queryIdStr[ID_STR_LENGTH + 1] = QUERY_ID_STR;
|
|
CHAR priIdStr[ID_STR_LENGTH + 1] = PRIMARY_ID_STR;
|
|
FlashPTR flashPtr;
|
|
|
|
DEBUG_PRINT(("Debug: reading CFI for byte mode.\n"));
|
|
|
|
flashPtr = (FlashPTR)flMap(vol.socket, 0);
|
|
tffsWriteByteFlash(flashPtr + 0x55 * vol.interleaving, QUERY);
|
|
|
|
vol.interleaving *= (unsigned short)thisCFI->multiplier; /* jump over the copies of the
|
|
same byte */
|
|
|
|
/* look for the query identification string "QRY" */
|
|
if (queryIdStr[0] != tffsReadByteFlash(flashPtr + 0x10 * vol.interleaving) ||
|
|
queryIdStr[1] != tffsReadByteFlash(flashPtr + 0x11 * vol.interleaving) ||
|
|
queryIdStr[2] != tffsReadByteFlash(flashPtr + 0x12 * vol.interleaving)) {
|
|
DEBUG_PRINT(("Debug: did not recognize CFI.\n"));
|
|
return flUnknownMedia;
|
|
}
|
|
|
|
/* check the command set ID */
|
|
thisCFI->commandSetId = tffsReadByteFlash(flashPtr +0x13 * vol.interleaving) |
|
|
((ULONG)tffsReadByteFlash(flashPtr + 0x14 * vol.interleaving) << 8);
|
|
if (thisCFI->commandSetId != INTEL_COMMAND_SET &&
|
|
thisCFI->commandSetId != AMDFUJ_COMMAND_SET) {
|
|
DEBUG_PRINT(("Debug: did not recognize command set.\n"));
|
|
return flUnknownMedia;
|
|
}
|
|
/* get address for primary algorithm extended table. */
|
|
primaryTable = tffsReadByteFlash(flashPtr + 0x15 * vol.interleaving) |
|
|
((ULONG)tffsReadByteFlash(flashPtr + 0x16 * vol.interleaving) << 8);
|
|
|
|
/* check alternate command set ID. */
|
|
thisCFI->altCommandSetId = tffsReadByteFlash(flashPtr + 0x17 * vol.interleaving) |
|
|
((ULONG)tffsReadByteFlash(flashPtr + 0x18 * vol.interleaving) << 8);
|
|
if (thisCFI->altCommandSetId != INTEL_ALT_COMMAND_SET &&
|
|
thisCFI->altCommandSetId != AMDFUJ_ALT_COMMAND_SET &&
|
|
thisCFI->altCommandSetId != ALT_NOT_SUPPORTED)
|
|
return flUnknownMedia;
|
|
|
|
/* get address for secondary algorithm extended table. */
|
|
secondaryTable = tffsReadByteFlash(flashPtr + 0x19 * vol.interleaving) |
|
|
((ULONG)tffsReadByteFlash(flashPtr + 0x1a * vol.interleaving) << 8);
|
|
|
|
thisCFI->vpp = tffsReadByteFlash(flashPtr + 0x1d * vol.interleaving);
|
|
|
|
vol.chipSize = 1L << tffsReadByteFlash(flashPtr + 0x27 * vol.interleaving);
|
|
|
|
thisCFI->maxBytesWrite = 1L << (tffsReadByteFlash(flashPtr + 0x2a * vol.interleaving) |
|
|
((ULONG)tffsReadByteFlash(flashPtr + 0x2b * vol.interleaving) << 8));
|
|
|
|
|
|
/* divide by multiplier because interleaving is multiplied by multiplier */
|
|
vol.erasableBlockSize = (tffsReadByteFlash(flashPtr + 0x2f * vol.interleaving) |
|
|
((ULONG)tffsReadByteFlash(flashPtr + 0x30 * vol.interleaving)) << 8) *
|
|
0x100L * vol.interleaving / thisCFI->multiplier;
|
|
|
|
/* In this part we access the primary extended table implemented by Intel.
|
|
If the device uses a different extended table, it should be accessed
|
|
according to the vendor specifications. */
|
|
if ((primaryTable) && (thisCFI->commandSetId == INTEL_COMMAND_SET)) {
|
|
/* look for the primary table identification string "PRI" */
|
|
if (priIdStr[0] != tffsReadByteFlash(flashPtr + primaryTable * vol.interleaving) ||
|
|
priIdStr[1] != tffsReadByteFlash(flashPtr + (primaryTable + 1) * vol.interleaving) ||
|
|
priIdStr[2] != tffsReadByteFlash(flashPtr + (primaryTable + 2) * vol.interleaving))
|
|
return flUnknownMedia;
|
|
|
|
thisCFI->optionalCommands = tffsReadByteFlash(flashPtr + (primaryTable + 5) * vol.interleaving) |
|
|
((LONG)tffsReadByteFlash(flashPtr + (primaryTable + 6) *
|
|
vol.interleaving) << 8) |
|
|
((LONG)tffsReadByteFlash(flashPtr + (primaryTable + 7) *
|
|
vol.interleaving) << 16) |
|
|
((LONG)tffsReadByteFlash(flashPtr + (primaryTable + 8) *
|
|
vol.interleaving) << 24);
|
|
|
|
thisCFI->afterSuspend = tffsReadByteFlash(flashPtr + (primaryTable + 9) * vol.interleaving);
|
|
}
|
|
else {
|
|
thisCFI->optionalCommands = 0;
|
|
thisCFI->afterSuspend = 0;
|
|
}
|
|
|
|
tffsWriteByteFlash(flashPtr, READ_ARRAY);
|
|
|
|
vol.interleaving /= (unsigned short)thisCFI->multiplier; /* return to the real interleaving*/
|
|
|
|
return flOK;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* g e t W o r d C F I */
|
|
/* */
|
|
/* Load important CFI data to the CFI structure in a word-mode. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 = OK, otherwise failed. */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
FLStatus getWordCFI(FLFlash vol)
|
|
{
|
|
ULONG primaryTable, secondaryTable;
|
|
CHAR queryIdStr[ID_STR_LENGTH + 1] = QUERY_ID_STR;
|
|
CHAR priIdStr[ID_STR_LENGTH + 1] = PRIMARY_ID_STR;
|
|
FlashWPTR flashPtr;
|
|
|
|
DEBUG_PRINT(("Debug: reading CFI for word mode.\n"));
|
|
|
|
flashPtr = (FlashWPTR)flMap(vol.socket, 0);
|
|
tffsWriteWordFlash(flashPtr+0x55, QUERY);
|
|
|
|
/* look for the query identification string "QRY" */
|
|
if (queryIdStr[0] != (CHAR)tffsReadWordFlash(flashPtr+0x10) ||
|
|
queryIdStr[1] != (CHAR)tffsReadWordFlash(flashPtr+0x11) ||
|
|
queryIdStr[2] != (CHAR)tffsReadWordFlash(flashPtr+0x12)) {
|
|
DEBUG_PRINT(("Debug: did not recognize CFI.\n"));
|
|
return flUnknownMedia;
|
|
}
|
|
|
|
/* check the command set ID */
|
|
thisCFI->commandSetId = tffsReadWordFlash(flashPtr+0x13) |
|
|
(tffsReadWordFlash(flashPtr+0x14) << 8);
|
|
if (thisCFI->commandSetId != INTEL_COMMAND_SET &&
|
|
thisCFI->commandSetId != AMDFUJ_COMMAND_SET) {
|
|
DEBUG_PRINT(("Debug: did not recognize command set.\n"));
|
|
return flUnknownMedia;
|
|
}
|
|
|
|
/* get address for primary algorithm extended table. */
|
|
primaryTable = tffsReadWordFlash(flashPtr+0x15) |
|
|
(tffsReadWordFlash(flashPtr+0x16) << 8);
|
|
|
|
/* check alternate command set ID. */
|
|
thisCFI->altCommandSetId = tffsReadWordFlash(flashPtr+0x17) |
|
|
(tffsReadWordFlash(flashPtr+0x18) << 8);
|
|
if (thisCFI->altCommandSetId != INTEL_ALT_COMMAND_SET &&
|
|
thisCFI->altCommandSetId != AMDFUJ_ALT_COMMAND_SET &&
|
|
thisCFI->altCommandSetId != ALT_NOT_SUPPORTED)
|
|
return flUnknownMedia;
|
|
|
|
/* get address for secondary algorithm extended table. */
|
|
secondaryTable = tffsReadWordFlash(flashPtr+0x19) |
|
|
(tffsReadWordFlash(flashPtr+0x1a) << 8);
|
|
|
|
thisCFI->vpp = tffsReadWordFlash(flashPtr+0x1d);
|
|
|
|
vol.chipSize = 1L << tffsReadWordFlash(flashPtr+0x27);
|
|
|
|
thisCFI->maxBytesWrite = 1L << (tffsReadWordFlash(flashPtr+0x2a) |
|
|
(tffsReadWordFlash(flashPtr+0x2b) << 8));
|
|
|
|
vol.erasableBlockSize = (tffsReadWordFlash(flashPtr+0x2f) |
|
|
(tffsReadWordFlash(flashPtr+0x30) << 8)) * 0x100L;
|
|
|
|
/* In this part we access the primary extended table implemented by Intel.
|
|
If the device uses a different extended table, it should be accessed
|
|
according to the vendor specifications. */
|
|
if ((primaryTable) && (thisCFI->commandSetId == INTEL_COMMAND_SET)) {
|
|
/* look for the primary table identification string "PRI" */
|
|
if (priIdStr[0] != (CHAR)tffsReadWordFlash(flashPtr+primaryTable) ||
|
|
priIdStr[1] != (CHAR)tffsReadWordFlash(flashPtr+primaryTable + 1) ||
|
|
priIdStr[2] != (CHAR)tffsReadWordFlash(flashPtr+primaryTable + 2))
|
|
return flUnknownMedia;
|
|
|
|
thisCFI->optionalCommands = tffsReadWordFlash(flashPtr+primaryTable + 5) |
|
|
(tffsReadWordFlash(flashPtr+primaryTable + 6) << 8) |
|
|
((LONG)tffsReadWordFlash(flashPtr+primaryTable + 7) << 16) |
|
|
((LONG)tffsReadWordFlash(flashPtr+primaryTable + 8) << 24);
|
|
|
|
thisCFI->afterSuspend = tffsReadWordFlash(flashPtr+primaryTable + 9);
|
|
}
|
|
else {
|
|
thisCFI->optionalCommands = 0;
|
|
thisCFI->afterSuspend = 0;
|
|
}
|
|
|
|
tffsWriteWordFlash(flashPtr, READ_ARRAY);
|
|
|
|
return flOK;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* c f i s c s B y t e W r i t e */
|
|
/* */
|
|
/* Write a block of bytes to Flash in a byte-mode. */
|
|
/* */
|
|
/* This routine will be registered as the MTD flash.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 */
|
|
/* mode : write mode (overwrite yes/no) */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 on success, failed otherwise */
|
|
/*----------------------------------------------------------------------*/
|
|
FLStatus cfiscsByteWrite(FLFlash vol,
|
|
CardAddress address,
|
|
const VOID FAR1 *buffer,
|
|
dword length,
|
|
word mode)
|
|
{
|
|
FLStatus status = flOK;
|
|
FlashPTR flashPtr;
|
|
ULONG i, from, eachWrite;
|
|
const CHAR FAR1 *temp = (const CHAR FAR1 *)buffer;
|
|
/* Set timeout to 5 seconds from now */
|
|
ULONG writeTimeout = flMsecCounter + 5000;
|
|
|
|
if (flWriteProtected(vol.socket))
|
|
return flWriteProtect;
|
|
|
|
#ifdef SOCKET_12_VOLTS
|
|
if (thisCFI->vpp)
|
|
checkStatus(flNeedVpp(vol.socket));
|
|
#endif
|
|
|
|
if (thisCFI->maxBytesWrite > 1) /* multi-byte write supported */
|
|
eachWrite = thisCFI->maxBytesWrite * vol.interleaving;
|
|
else
|
|
eachWrite = vol.interleaving;
|
|
|
|
for (from = 0; from < (ULONG) length && status == flOK; from += eachWrite) {
|
|
LONG thisLength = length - from;
|
|
FlashPTR currPtr;
|
|
ULONG tailBytes, lengthByte;
|
|
CHAR FAR1 *fromPtr;
|
|
UCHAR byteToWrite;
|
|
|
|
if ((ULONG)thisLength > eachWrite)
|
|
thisLength = eachWrite;
|
|
|
|
lengthByte = thisLength / vol.interleaving;
|
|
tailBytes = thisLength % vol.interleaving;
|
|
|
|
flashPtr = (FlashPTR) flMap(vol.socket, address + from);
|
|
|
|
for (i = 0, currPtr = flashPtr;
|
|
i < (ULONG) vol.interleaving && i < (ULONG) thisLength;
|
|
i++, currPtr++) {
|
|
do {
|
|
tffsWriteByteFlash(currPtr, WRITE_TO_BUFFER);
|
|
} while (!(tffsReadByteFlash(currPtr) & SR_READY) && (flMsecCounter < writeTimeout));
|
|
if (!(tffsReadByteFlash(currPtr) & SR_READY)) {
|
|
DEBUG_PRINT(("Debug: timeout error in CFISCS write.\n"));
|
|
status = flWriteFault;
|
|
}
|
|
byteToWrite = i < tailBytes ? (UCHAR) lengthByte : (UCHAR) (lengthByte - 1);
|
|
tffsWriteByteFlash(currPtr, byteToWrite);
|
|
}
|
|
|
|
for(i = 0, currPtr = flashPtr,fromPtr = (CHAR *)temp + from;
|
|
i < (ULONG) thisLength;
|
|
i++, flashPtr++, fromPtr++)
|
|
tffsWriteByteFlash(currPtr, *fromPtr);
|
|
|
|
|
|
for (i = 0, currPtr = flashPtr;
|
|
i < (ULONG) vol.interleaving && i < (ULONG) thisLength;
|
|
i++, currPtr++)
|
|
tffsWriteByteFlash(currPtr, CONFIRM_WRITE);
|
|
|
|
for (i = 0, currPtr = flashPtr;
|
|
i < (ULONG) vol.interleaving && i < (ULONG) thisLength;
|
|
i++, currPtr++) {
|
|
while (!(tffsReadByteFlash(currPtr) & SR_READY) && (flMsecCounter < writeTimeout))
|
|
;
|
|
if (!(tffsReadByteFlash(currPtr) & SR_READY)) {
|
|
DEBUG_PRINT(("Debug: timeout error in CFISCS write.\n"));
|
|
status = flWriteFault;
|
|
}
|
|
if (tffsReadByteFlash(currPtr) & WSM_ERROR) {
|
|
DEBUG_PRINT(("Debug: error in CFISCS write.\n"));
|
|
status = (tffsReadByteFlash(currPtr) & SR_VPP_ERROR) ? flVppFailure : flWriteFault;
|
|
tffsWriteByteFlash(currPtr, CLEAR_STATUS);
|
|
}
|
|
tffsWriteByteFlash(currPtr, READ_ARRAY);
|
|
}
|
|
}
|
|
|
|
#ifdef SOCKET_12_VOLTS
|
|
if (thisCFI->vpp)
|
|
flDontNeedVpp(vol.socket);
|
|
#endif
|
|
|
|
flashPtr = (FlashPTR) flMap(vol.socket, address);
|
|
/* verify the data */
|
|
if (status == flOK) {
|
|
for(i = 0; i < (ULONG) length - 4; i += 4) {
|
|
if (tffsReadDwordFlash((PUCHAR)(flashPtr+i)) != *(ULONG *)(temp+i)) {
|
|
DEBUG_PRINT(("Debug: CFISCS write failed in verification.\n"));
|
|
status = flWriteFault;
|
|
}
|
|
}
|
|
for(; i < (ULONG) length; i++) {
|
|
if (tffsReadByteFlash(flashPtr+i) != *(UCHAR *)(temp+i)) {
|
|
DEBUG_PRINT(("Debug: CFISCS write failed in verification.\n"));
|
|
status = flWriteFault;
|
|
}
|
|
}
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* c f i s c s W o r d W r i t e */
|
|
/* */
|
|
/* Write a block of bytes to Flash in a word-mode. */
|
|
/* */
|
|
/* This routine will be registered as the MTD flash.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 */
|
|
/* mode : write mode (overwrite yes/no) */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 on success, failed otherwise */
|
|
/*----------------------------------------------------------------------*/
|
|
FLStatus cfiscsWordWrite(FLFlash vol,
|
|
CardAddress address,
|
|
const VOID FAR1 *buffer,
|
|
dword length,
|
|
word mode)
|
|
{
|
|
FLStatus status = flOK;
|
|
FlashPTR byteFlashPtr;
|
|
FlashWPTR flashPtr;
|
|
ULONG from;
|
|
ULONG i, eachWrite;
|
|
const CHAR FAR1 *temp = (const CHAR FAR1 *)buffer;
|
|
/* Set timeout to 5 seconds from now */
|
|
ULONG writeTimeout = flMsecCounter + 5000;
|
|
|
|
if (flWriteProtected(vol.socket))
|
|
return flWriteProtect;
|
|
|
|
if ((length & 1) || (address & 1)) /* Only write words on word-boundary */
|
|
return flBadParameter;
|
|
|
|
#ifdef SOCKET_12_VOLTS
|
|
if (thisCFI->vpp)
|
|
checkStatus(flNeedVpp(vol.socket));
|
|
#endif
|
|
|
|
if (thisCFI->maxBytesWrite > 1) /* multi-byte write supported */
|
|
eachWrite = thisCFI->maxBytesWrite / 2; /* we are counting words */
|
|
else
|
|
eachWrite = 1;
|
|
|
|
/* we assume that the interleaving is 1. */
|
|
for (from = 0; (from < length / 2) && (status == flOK); from += eachWrite) {
|
|
USHORT *fromPtr;
|
|
ULONG thisLength = (length / 2) - from;
|
|
|
|
if (thisLength > eachWrite)
|
|
thisLength = eachWrite;
|
|
|
|
flashPtr = (FlashWPTR)flMap(vol.socket, address + from * 2);
|
|
|
|
do {
|
|
tffsWriteWordFlash(flashPtr, WRITE_TO_BUFFER);
|
|
} while (!(tffsReadByteFlash(flashPtr) & SR_READY) && (flMsecCounter < writeTimeout));
|
|
if (!(tffsReadByteFlash(flashPtr) & SR_READY)) {
|
|
DEBUG_PRINT(("Debug: timeout error in CFISCS write.\n"));
|
|
status = flWriteFault;
|
|
}
|
|
tffsWriteWordFlash(flashPtr, (USHORT) (thisLength - 1));
|
|
|
|
for(i = 0, fromPtr = (USHORT *)(temp + from * 2);
|
|
i < thisLength;
|
|
i++, fromPtr++)
|
|
tffsWriteWordFlash(flashPtr + i, *fromPtr);
|
|
|
|
|
|
tffsWriteWordFlash(flashPtr, CONFIRM_WRITE);
|
|
|
|
while (!(tffsReadByteFlash(flashPtr) & SR_READY) && (flMsecCounter < writeTimeout))
|
|
;
|
|
if (!(tffsReadByteFlash(flashPtr) & SR_READY)) {
|
|
DEBUG_PRINT(("Debug: timeout error in CFISCS write.\n"));
|
|
status = flWriteFault;
|
|
}
|
|
if (tffsReadByteFlash(flashPtr) & WSM_ERROR) {
|
|
DEBUG_PRINT(("Debug: CFISCS write error.\n"));
|
|
status = (tffsReadByteFlash(flashPtr) & SR_VPP_ERROR) ? flVppFailure : flWriteFault;
|
|
tffsWriteWordFlash(flashPtr, CLEAR_STATUS);
|
|
}
|
|
tffsWriteWordFlash(flashPtr, READ_ARRAY);
|
|
}
|
|
|
|
#ifdef SOCKET_12_VOLTS
|
|
if (thisCFI->vpp)
|
|
flDontNeedVpp(vol.socket);
|
|
#endif
|
|
|
|
byteFlashPtr = (FlashPTR) flMap(vol.socket, address);
|
|
/* verify the data */
|
|
if (status == flOK) {
|
|
for(i = 0; i < length - 4; i += 4) {
|
|
if (tffsReadDwordFlash((PUCHAR)(byteFlashPtr+i)) != *(ULONG *)(temp+i)) {
|
|
DEBUG_PRINT(("Debug: CFISCS write failed in verification.\n"));
|
|
status = flWriteFault;
|
|
}
|
|
}
|
|
for(; i < length; i++) {
|
|
if (tffsReadByteFlash(byteFlashPtr+i) != *(UCHAR *)(temp+i)) {
|
|
DEBUG_PRINT(("Debug: CFISCS write failed in verification.\n"));
|
|
status = flWriteFault;
|
|
}
|
|
}
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
/************************************************************************/
|
|
/* Auxiliary routines for cfiscsByteErase */
|
|
/************************************************************************/
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* m a k e C o m m a n d */
|
|
/* */
|
|
/* Create a command to write to the flash. This routine is used for */
|
|
/* byte mode, write command to the relevant chip and 0xff to the other */
|
|
/* chip if interleaving is greater than 1, or write the command if */
|
|
/* interleaving is 1. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* command : Command to be written to the media */
|
|
/* chip : first chip (0) or second chip (1) */
|
|
/* */
|
|
/* Returns: */
|
|
/* The command that should be written to the media */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
USHORT makeCommand(FLFlash vol, USHORT command, LONG chip)
|
|
{
|
|
if ((vol.interleaving == 1) || (chip == 0))
|
|
return command | 0xff00;
|
|
else
|
|
return (command << 8) | 0xff;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* g e t D a t a */
|
|
/* */
|
|
/* Read the lower byte or the upper byte from a given word. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* vol : Pointer identifying drive */
|
|
/* wordData : the given word */
|
|
/* chip : if chip = 0 read lower byte */
|
|
/* if chip = 1 read upper byte */
|
|
/* */
|
|
/* Returns: */
|
|
/* The byte that was read. */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
UCHAR getData(FLFlash vol, USHORT wordData, LONG chip)
|
|
{
|
|
if ((vol.interleaving == 1) || (chip == 0))
|
|
return (UCHAR)wordData; /* lower byte */
|
|
else
|
|
return (UCHAR)(wordData >> 8); /* upper byte */
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* c f i s c s B y t e E r a s e */
|
|
/* */
|
|
/* Erase one or more contiguous Flash erasable blocks in a byte-mode. */
|
|
/* */
|
|
/* This routine will be registered as the MTD flash.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 cfiscsByteErase(FLFlash vol,
|
|
word firstErasableBlock,
|
|
word numOfErasableBlocks)
|
|
{
|
|
LONG iBlock;
|
|
/* Set timeout to 5 seconds from now */
|
|
ULONG writeTimeout = flMsecCounter + 5000;
|
|
|
|
FLStatus status = flOK; /* unless proven otherwise */
|
|
|
|
if (flWriteProtected(vol.socket))
|
|
return flWriteProtect;
|
|
|
|
#ifdef SOCKET_12_VOLTS
|
|
if (thisCFI->vpp)
|
|
checkStatus(flNeedVpp(vol.socket));
|
|
#endif
|
|
|
|
for (iBlock = 0; iBlock < numOfErasableBlocks && status == flOK; iBlock++) {
|
|
LONG j;
|
|
FLBoolean finished;
|
|
|
|
FlashWPTR flashPtr = (FlashWPTR)
|
|
flMap(vol.socket, (firstErasableBlock + iBlock) * vol.erasableBlockSize);
|
|
|
|
for (j = 0; j * 2 < vol.interleaving; j++) { /* access chips in pairs */
|
|
LONG i;
|
|
|
|
for (i = 0; i < (vol.interleaving == 1 ? 1 : 2); i++) { /* write to each chip seperately */
|
|
if (thisCFI->optionalCommands & QUEUED_ERASE_SUPPORT) {
|
|
do {
|
|
tffsWriteWordFlash(flashPtr+j, makeCommand(&vol, SETUP_QUEUE_ERASE, i));
|
|
} while (!(getData(&vol, tffsReadWordFlash(flashPtr+j), i) & SR_READY) &&
|
|
(flMsecCounter < writeTimeout));
|
|
if (!(getData(&vol, tffsReadWordFlash(flashPtr+j), i) & SR_READY)) {
|
|
DEBUG_PRINT(("Debug: timeout error in CFISCS erase.\n"));
|
|
status = flWriteFault;
|
|
}
|
|
else
|
|
tffsWriteWordFlash(flashPtr+j, makeCommand(&vol, CONFIRM_ERASE, i));
|
|
}
|
|
else {
|
|
tffsWriteWordFlash(flashPtr+j, makeCommand(&vol, SETUP_BLOCK_ERASE, i));
|
|
tffsWriteWordFlash(flashPtr+j, makeCommand(&vol, CONFIRM_ERASE, i));
|
|
}
|
|
}
|
|
}
|
|
|
|
do {
|
|
#ifdef FL_BACKGROUND
|
|
if (thisCFI->optionalCommands & SUSPEND_ERASE_SUPPORT) {
|
|
while (flForeground(1) == BG_SUSPEND) { /* suspend */
|
|
for (j = 0; j < vol.interleaving; j += 2, flashPtr++) {
|
|
LONG i;
|
|
|
|
for (i = 0; i < (vol.interleaving == 1 ? 1 : 2); i++) {
|
|
tffsWriteWordFlash(flashPtr+j, makeCommand(&vol, READ_STATUS, i));
|
|
if (!(getData(&vol, tffsReadWordFlash(flashPtr+j), i) & SR_READY)) {
|
|
tffsWriteWordFlash(flashPtr+j, makeCommand(&vol, SUSPEND_ERASE, i));
|
|
tffsWriteWordFlash(flashPtr+j, makeCommand(&vol, READ_STATUS, i));
|
|
while (!(getData(&vol, tffsReadWordFlash(flashPtr+j), i) & SR_READY))
|
|
;
|
|
}
|
|
tffsWriteWordFlash(flashPtr+j, makeCommand(&vol, READ_ARRAY, i));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
finished = TRUE;
|
|
for (j = 0; j * 2 < vol.interleaving; j++) {
|
|
LONG i;
|
|
|
|
for (i = 0; i < (vol.interleaving == 1 ? 1 : 2); i++) {
|
|
tffsWriteWordFlash(flashPtr+j, makeCommand(&vol, READ_STATUS, i));
|
|
if (!(getData(&vol, tffsReadWordFlash(flashPtr+j), i) & SR_READY))
|
|
finished = FALSE;
|
|
else if (getData(&vol, tffsReadWordFlash(flashPtr+j), i) & SR_ERASE_SUSPEND) {
|
|
tffsWriteWordFlash(flashPtr+j, makeCommand(&vol, RESUME_ERASE, i));
|
|
finished = FALSE;
|
|
}
|
|
else {
|
|
if (getData(&vol, tffsReadWordFlash(flashPtr+j), i) & WSM_ERROR) {
|
|
DEBUG_PRINT(("Debug: CFISCS erase error.\n"));
|
|
status = (getData(&vol, tffsReadWordFlash(flashPtr+j), i) & SR_VPP_ERROR) ?
|
|
flVppFailure : flWriteFault;
|
|
tffsWriteWordFlash(flashPtr+j, makeCommand(&vol, CLEAR_STATUS, i));
|
|
}
|
|
tffsWriteWordFlash(flashPtr+j, makeCommand(&vol, READ_ARRAY, i));
|
|
}
|
|
}
|
|
}
|
|
flDelayMsecs(1);
|
|
} while (!finished);
|
|
}
|
|
|
|
#ifdef SOCKET_12_VOLTS
|
|
if (thisCFI->vpp)
|
|
flDontNeedVpp(vol.socket);
|
|
#endif
|
|
|
|
return status;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* c f i s c s W o r d E r a s e */
|
|
/* */
|
|
/* Erase one or more contiguous Flash erasable blocks in a word-mode */
|
|
/* */
|
|
/* This routine will be registered as the MTD flash.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 cfiscsWordErase(FLFlash vol,
|
|
word firstErasableBlock,
|
|
word numOfErasableBlocks)
|
|
{
|
|
FLStatus status = flOK; /* unless proven otherwise */
|
|
LONG iBlock;
|
|
/* Set timeout to 5 seconds from now */
|
|
ULONG writeTimeout = flMsecCounter + 5000;
|
|
|
|
if (flWriteProtected(vol.socket))
|
|
return flWriteProtect;
|
|
|
|
#ifdef SOCKET_12_VOLTS
|
|
if (thisCFI->vpp)
|
|
checkStatus(flNeedVpp(vol.socket));
|
|
#endif
|
|
|
|
for (iBlock = 0; iBlock < numOfErasableBlocks && status == flOK; iBlock++) {
|
|
FLBoolean finished;
|
|
|
|
FlashWPTR flashPtr = (FlashWPTR)
|
|
flMap(vol.socket,(firstErasableBlock + iBlock) * vol.erasableBlockSize);
|
|
|
|
if (thisCFI->optionalCommands & QUEUED_ERASE_SUPPORT) {
|
|
do {
|
|
tffsWriteWordFlash(flashPtr, SETUP_QUEUE_ERASE);
|
|
} while (!(tffsReadByteFlash(flashPtr) & SR_READY) && (flMsecCounter < writeTimeout));
|
|
if (!(tffsReadByteFlash(flashPtr) & SR_READY)) {
|
|
DEBUG_PRINT(("Debug: timeout error in CFISCS erase.\n"));
|
|
status = flWriteFault;
|
|
}
|
|
else
|
|
tffsWriteWordFlash(flashPtr, CONFIRM_ERASE);
|
|
}
|
|
else {
|
|
tffsWriteWordFlash(flashPtr, SETUP_BLOCK_ERASE);
|
|
tffsWriteWordFlash(flashPtr, CONFIRM_ERASE);
|
|
}
|
|
|
|
do {
|
|
#ifdef FL_BACKGROUND
|
|
if (thisCFI->optionalCommands & SUSPEND_ERASE_SUPPORT) {
|
|
while (flForeground(1) == BG_SUSPEND) { /* suspend */
|
|
if (!(tffsReadByteFlash(flashPtr) & SR_READY)) {
|
|
tffsWriteWordFlash(flashPtr, SUSPEND_ERASE);
|
|
tffsWriteWordFlash(flashPtr, READ_STATUS);
|
|
while (!(tffsReadByteFlash(flashPtr) & SR_READY))
|
|
;
|
|
}
|
|
tffsWriteWordFlash(flashPtr, READ_ARRAY);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
finished = TRUE;
|
|
|
|
if (!(tffsReadByteFlash(flashPtr) & SR_READY))
|
|
finished = FALSE;
|
|
else if (tffsReadByteFlash(flashPtr) & SR_ERASE_SUSPEND) {
|
|
tffsWriteWordFlash(flashPtr, RESUME_ERASE);
|
|
finished = FALSE;
|
|
}
|
|
else {
|
|
if (tffsReadByteFlash(flashPtr) & WSM_ERROR) {
|
|
DEBUG_PRINT(("Debug: CFISCS erase error.\n"));
|
|
status = (tffsReadByteFlash(flashPtr) & SR_VPP_ERROR) ? flVppFailure : flWriteFault;
|
|
tffsWriteWordFlash(flashPtr, CLEAR_STATUS);
|
|
}
|
|
tffsWriteWordFlash(flashPtr, READ_ARRAY);
|
|
}
|
|
flDelayMsecs(1);
|
|
} while (!finished);
|
|
}
|
|
|
|
#ifdef SOCKET_12_VOLTS
|
|
if (thisCFI->vpp)
|
|
flDontNeedVpp(vol.socket);
|
|
#endif
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* c f i s c s 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 *cfiscsMap (FLFlash vol, CardAddress address, int length)
|
|
{
|
|
vol.socket->remapped = TRUE;
|
|
return mapThroughBuffer(&vol,address,length);
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* c f i s c s 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 cfiscsRead(FLFlash vol,
|
|
CardAddress address,
|
|
VOID FAR1 *buffer,
|
|
dword length,
|
|
word modes)
|
|
{
|
|
ULONG i;
|
|
UCHAR * byteBuffer;
|
|
FlashPTR byteFlashPtr;
|
|
ULONG * doubleWordBuffer = (ULONG *)buffer;
|
|
FlashDPTR doubleWordFlashPtr = (FlashDPTR)flMap(vol.socket, address);
|
|
|
|
for (i = 0; i < length - 4; i += 4, doubleWordBuffer++, doubleWordFlashPtr++) {
|
|
*doubleWordBuffer = tffsReadDwordFlash(doubleWordFlashPtr);
|
|
}
|
|
byteBuffer = (UCHAR *)doubleWordBuffer;
|
|
byteFlashPtr = (FlashPTR)doubleWordFlashPtr;
|
|
for(; i < length; i++, byteBuffer++, byteFlashPtr++) {
|
|
*byteBuffer = tffsReadByteFlash(byteFlashPtr);
|
|
}
|
|
return flOK ;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* c f i s c s I d e n t i f y */
|
|
/* */
|
|
/* Identifies media based on SCS/CFI 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 cfiscsIdentify(FLFlash vol)
|
|
{
|
|
FlashWPTR flashPtr;
|
|
CHAR queryIdStr[ID_STR_LENGTH + 1] = QUERY_ID_STR;
|
|
|
|
DEBUG_PRINT(("Debug: entering CFISCS identification routine.\n"));
|
|
|
|
flSetWindowBusWidth(vol.socket, 16);/* use 16-bits */
|
|
flSetWindowSpeed(vol.socket, 150); /* 120 nsec. */
|
|
flSetWindowSize(vol.socket, 2); /* 8 KBytes */
|
|
|
|
vol.mtdVars = &mtdVars_cfiscs[flSocketNoOf(vol.socket)];
|
|
|
|
/* try word mode first */
|
|
flashPtr = (FlashWPTR)flMap(vol.socket, 0);
|
|
tffsWriteWordFlash(flashPtr+0x55, QUERY);
|
|
if ((tffsReadWordFlash(flashPtr+0x10) == (USHORT)queryIdStr[0]) &&
|
|
(tffsReadWordFlash(flashPtr+0x11) == (USHORT)queryIdStr[1]) &&
|
|
(tffsReadWordFlash(flashPtr+0x12) == (USHORT)queryIdStr[2])) {
|
|
vol.type = (tffsReadWordFlash(flashPtr) << 8) |
|
|
tffsReadWordFlash(flashPtr+1);
|
|
vol.interleaving = 1;
|
|
thisCFI->wordMode = TRUE;
|
|
vol.write = cfiscsWordWrite;
|
|
vol.erase = cfiscsWordErase;
|
|
checkStatus(getWordCFI(&vol));
|
|
DEBUG_PRINT(("Debug: identified 16-bit CFISCS.\n"));
|
|
}
|
|
else { /* Use standard identification routine to detect byte-mode */
|
|
checkStatus(cfiscsByteIdentify(&vol));
|
|
thisCFI->wordMode = FALSE;
|
|
vol.write = cfiscsByteWrite;
|
|
vol.erase = cfiscsByteErase;
|
|
checkStatus(getByteCFI(&vol));
|
|
DEBUG_PRINT(("Debug: identified 8-bit CFISCS.\n"));
|
|
}
|
|
|
|
checkStatus(thisCFI->wordMode ? cfiscsWordSize(&vol) : cfiscsByteSize(&vol));
|
|
|
|
vol.map = cfiscsMap;
|
|
vol.read = cfiscsRead;
|
|
|
|
return flOK;
|
|
}
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* f l R e g i s t e r C F I S C S */
|
|
/* */
|
|
/* Registers this MTD for use */
|
|
/* */
|
|
/* Parameters: */
|
|
/* None */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 on success, otherwise failure */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
FLStatus flRegisterCFISCS(VOID)
|
|
{
|
|
if (noOfMTDs >= MTDS)
|
|
return flTooManyComponents;
|
|
|
|
mtdTable[noOfMTDs++] = cfiscsIdentify;
|
|
|
|
return flOK;
|
|
}
|