cf.c

增强型51单片机fs7821cf卡读写程序

        CmdTimer = CF_CMD_TIMEOUT;
        while(CmdTimer > 0)
        {
            RegValue = CSRRead(CF_BASE + CF_IE);
            if(RegValue & CF_DMA_COMPLETE)
            {
                CSRWrite(CF_BASE + CF_IE, ~CF_DMA_COMPLETE);
                return STATUS_SUCCESS;
            }
        }
    }
    return STATUS_FLASH_ERROR;
}

//--------------------------------------------------------------------
// Write one sector of data
//--------------------------------------------------------------------
STATUS CfWriteOneSector()
{
    STATUS Status;
    BYTE LBA0 = (BYTE)SectorStart;
    BYTE LBA1 = (BYTE)(SectorStart >> 8);
    BYTE LBA2 = (BYTE)(SectorStart >> 16);
    BYTE LBA3 = (BYTE)(SectorStart >> 24);
    BYTE RetryCount = 0;
    BYTE RegValue;

    for( ; RetryCount < MAX_FLASH_RETRY_TIMES; RetryCount++)
    {
        Status = CfWaitDevRdy(CF_CMD_TIMEOUT);
        if(Status != STATUS_SUCCESS)
            continue;

        CfWriteReg(CF_BASE + CF_SECTOR_CNT , 1);
        CfWriteReg(CF_BASE + CF_SECTOR     , LBA0);
        CfWriteReg(CF_BASE + CF_CYLINDER_LO, LBA1);
        CfWriteReg(CF_BASE + CF_CYLINDER_HI, LBA2);
        CfWriteReg(CF_BASE + CF_HEADER     , (LBA3 & 0x0F) | 0xE0);
        if(CfCmdStatus != STATUS_SUCCESS)
            continue;

        CfWriteReg(CF_BASE + CF_STS_CMD, CMD_WRITE_SECTOR);  
        if(CfCmdStatus != STATUS_SUCCESS)
            continue;

        Status = CfWaitDataRdy(CF_CMD_TIMEOUT);
        if(Status != STATUS_SUCCESS)
            continue;

        CfWriteSectorDataCmd(CurrentBuffer, BYTES_PER_SECTOR);

        CmdTimer = CF_CMD_TIMEOUT;
        while(CmdTimer)
        {
            RegValue = CSRRead(CF_BASE + CF_IE);
            if(RegValue & CF_DMA_COMPLETE)
            {
                CSRWrite(CF_BASE + CF_IE, ~CF_DMA_COMPLETE);
                return STATUS_SUCCESS;
            }
        }        
    }
    return STATUS_FLASH_ERROR;
}

//--------------------------------------------------------------------
// Identify Drive
//--------------------------------------------------------------------
STATUS CfIdentifyDrive(UINT16 Buffer)
{
    UINT16 *Info = (PUINT16)Buffer;
    BYTE RegValue;
    STATUS Status;
    BYTE RetryCount = 0;

    for( ; RetryCount < MAX_FLASH_RETRY_TIMES; RetryCount++)
    {
        Status = CfWaitDevRdy(CF_CMD_TIMEOUT);
        if(Status != STATUS_SUCCESS)
            continue;

        CfWriteReg(CF_BASE + CF_HEADER , 0xE0);
        CfWriteReg(CF_BASE + CF_STS_CMD, CMD_IDENTIFY_DRIVE);

        if(CfCmdStatus != STATUS_SUCCESS)
            continue;

        Status = CfWaitDataRdy(CF_CMD_TIMEOUT);
        if(Status != STATUS_SUCCESS)
            continue;

        CfReadSectorDataCmd(Buffer, ID_INFO_SIZE);

        CmdTimer = CF_CMD_TIMEOUT;
        while(CmdTimer)
        {
            RegValue = CSRRead(CF_BASE + CF_IE);
            if(RegValue & CF_DMA_COMPLETE)
            {
                CSRWrite(CF_BASE + CF_IE, ~CF_DMA_COMPLETE);
                break;
            }
        }
        if(CmdTimer > 0)
        {
            Fifo2ClkCpu();
            ConvertBufEndian16(Buffer, ID_INFO_SIZE);
            Fifo2ClkUsb();
            return STATUS_SUCCESS;
        }
    }
    return STATUS_FLASH_ERROR;
}

#ifdef DEBUG_FLASH_ERASE
//----------------------------------------------------------------------------
// Description:
//   Erase sectors of CF device
//----------------------------------------------------------------------------
STATUS CfEraseSector(UINT32 StartSector, BYTE SectorCnt)
{
  STATUS Status;

  if ((Status = CfWaitReady(CF_DEVICE_READY)) != STATUS_SUCCESS)
    return Status;
  CfWriteReg(CF_BASE + CF_SECTOR_CNT, SectorCnt);  

  CfWriteReg(CF_BASE + CF_SECTOR,      ((TDataCast *)&StartSector)->ucByte[3]);
  CfWriteReg(CF_BASE + CF_CYLINDER_LO, ((TDataCast *)&StartSector)->ucByte[2]);
  CfWriteReg(CF_BASE + CF_CYLINDER_HI, ((TDataCast *)&StartSector)->ucByte[1]);
  // | 1 L 1 DRV HS3 HS2 HS1 HS0 |, L = 1 (LBA MODE) DRV = 0 (MASTER) 
  CfWriteReg(CF_BASE + CF_HEADER, 0xe0 | (((TDataCast *)&StartSector)->ucByte[0] & 0x0f));

  CfWriteReg(CF_BASE + CF_STS_CMD, CMD_ERASE_SECTOR);  

  return STATUS_SUCCESS;
}
#endif

//----------------------------------------------------------------------------
// Description:
//   Read first sector of data from the CF device
//----------------------------------------------------------------------------
STATUS CfReadSector()
{
    STATUS Status = CfReadOneSector();
    SectorStart ++;
    return Status;
}

//----------------------------------------------------------------------------
// Read one sector of data
//----------------------------------------------------------------------------
STATUS CfReadNextSector()
{   
    STATUS Status = CfReadOneSector();
    SectorStart ++;
    return Status;
}

//----------------------------------------------------------------------------
// Description:
//   Write first sector of data to the CF device
//----------------------------------------------------------------------------
STATUS CfWriteSector()
{
    STATUS Status = CfWriteOneSector();
    SectorStart ++;
    return Status;
}

//----------------------------------------------------------------------------
// Write one sector of data
//----------------------------------------------------------------------------
STATUS CfWriteNextSector()
{
    STATUS Status = CfWriteOneSector();
    SectorStart ++;
    return Status;
}
//----------------------------------------------------------------------------
// Description:
//   use to change STATUS when device "start"
//----------------------------------------------------------------------------
void CfStart()
{
    if(CfCardExist())
        CfMediaStatus = STATUS_SUCCESS;
}

//----------------------------------------------------------------------------
// Description:
//   use to change STATUS when device "eject"
//----------------------------------------------------------------------------
void CfEject()
{
    CfMediaStatus = STATUS_NO_MEDIA;
}

//----------------------------------------------------------------------------
// Description:
//   Query the current device information
//   *NumScsiBlocks = 0 means that the device does not exist now
//----------------------------------------------------------------------------
STATUS CfQueryDevice()
{
  STATUS OrgStatus = CfMediaStatus;

  if (CfMediaStatus == STATUS_NO_MEDIA)
    return CfMediaStatus;

  if (CfMediaStatus == STATUS_MEDIA_CHANGE)
    CfMediaStatus = STATUS_SUCCESS;

  DeviceInfo.TotalBlocks = CfAvailableSectors;
  DeviceInfo.BlockSize = BYTES_PER_SECTOR;
  DeviceInfo.WriteProtect = false;
 
  return OrgStatus;
}

//----------------------------------------------------------------------------
// Description:
//   Read information of CF devices and set the variables
//----------------------------------------------------------------------------
STATUS CfReadFlashInfo()
{
  PUINT16 InfoBuffer = (UINT16 xdata *)CopyBuffer;
  STATUS Status;
  
  if ((Status = CfReset()) != STATUS_SUCCESS)
    return Status;
  if ((Status = CfIdentifyDrive(CopyBuffer)) != STATUS_SUCCESS)
    return Status;
    
  Fifo2ClkCpu();
  CfAvailableSectors = (((UINT32)InfoBuffer[61] << 16) | InfoBuffer[60]) - 1;
  Fifo2ClkUsb();
  
  return STATUS_SUCCESS;
}

//----------------------------------------------------------------------------
// Description:
//   Handle the media change event
//----------------------------------------------------------------------------
void CfMediaChange()
{
    BYTE i , Sum = 0;
    bool CardInserted;

    for(i = 0; i < 10; i++)
    {
        if(CfCardExist())
            Sum ++;
    }
    if(Sum > 5)
        CardInserted = true;
    else
        CardInserted = false;

    if(CardInserted)
    {
        if(CfMediaStatus == STATUS_NO_MEDIA)
        {
            CfPowerOn();
            CfMediaStatus = CfReadFlashInfo();
            if(CfMediaStatus == STATUS_SUCCESS)
                CfMediaStatus = STATUS_MEDIA_CHANGE;
        }
    }
    else
    {
        CfPowerOff();
        CfAvailableSectors = 0;
        CfMediaStatus = STATUS_NO_MEDIA;
    }
}

//----------------------------------------------------------------------------
// Description:
//   The CF interrupt handler
//----------------------------------------------------------------------------
void CfIntHandler(BYTE Event)
{ 
  Event=Event;

  CfGetFlashInfoTimer = GET_FLASH_INFO_DELAY;
}

//----------------------------------------------------------------------------
// Description:
//   Make the CF device into suspend mode
//----------------------------------------------------------------------------
void CfSuspend()
{
  CfPowerOff();
}

//----------------------------------------------------------------------------
// Description:
//   Make the CF device resume
//----------------------------------------------------------------------------
void CfResume()
{
  if (CfCardExist())
  {
    CfPowerOn();
    CfReadFlashInfo();
  }
}

//----------------------------------------------------------------------------
// Description:
//   Initiate the CF device
//----------------------------------------------------------------------------
void CfInit()
{
  CfPowerOff();
  Delay(200);
  if (CfCardExist())
  {
    CfMediaChange();
#ifdef DEBUG_FLASH_ERASE
#if (defined(DEBUG_UART) || !defined(DEBUG))
    if (DEBUG_BIT_RESET == 0)
#endif
    {
      CfEraseSector(0, 1);
      CfMediaStatus = CfReadFlashInfo();
    }
#endif
  }
}
#endif