PIC32MZ - SD Probleme

#include "ff.h"

#include "diskio.h"

/** CONFIGURATION *************************************************************/

// DEVCFG2

//Define SYSCLK = 200 MHz

#pragma config FPLLIDIV = DIV_3         // System PLL Input Divider (3x Divider)

#pragma config FPLLRNG = RANGE_5_10_MHZ // System PLL Input Range (5-10 MHz Input)

#pragma config FPLLICLK = PLL_POSC      // System PLL Input Clock Selection (POSC is input to the System PLL)

#pragma config FPLLMULT = MUL_50        // System PLL Multiplier (PLL Multiply by 50)

#pragma config FPLLODIV = DIV_2         // System PLL Output Clock Divider (2x Divider)

#pragma config UPLLFSEL = FREQ_24MHZ    // USB PLL Input Frequency Selection (USB PLL input is 24 MHz)

// DEVCFG1

#pragma config FNOSC = SPLL             // Oscillator Selection Bits (System PLL)

#pragma config POSCMOD = EC             // Primary Oscillator Configuration (External clock mode)

#pragma config DMTCNT = DMT31           // Deadman Timer Count Selection (2^31 (2147483648))

#pragma config FDMTEN = OFF             // Deadman Timer Enable (Deadman Timer is disabled)

// DEVCFG0

#pragma config ICESEL = ICS_PGx2        // ICE/ICD Comm Channel Select (Communicate on PGEC2/PGED2)

#include <xc.h>

#include <stdio.h>

#include <stdlib.h>

#include <stdbool.h>

#include <proc/p32mz2048efg100.h>

#define SYS_FREQ 200000000 // Running at 200MHz

void set_performance_mode()

{   

  unsigned int cp0;

    // Unlock Sequence

    asm volatile("di"); // Disable all interrupts

    SYSKEY = 0xAA996655;

    SYSKEY = 0x556699AA;  

    // PB1DIV

    // Peripheral Bus 1 cannot be turned off, so there's no need to turn it on

    PB1DIVbits.PBDIV = 1; // Peripheral Bus 1 Clock Divisor Control (PBCLK1 is SYSCLK divided by 2)

    // PB2DIV

    PB2DIVbits.ON = 1; // Peripheral Bus 2 Output Clock Enable (Output clock is enabled)

    PB2DIVbits.PBDIV = 1; // Peripheral Bus 2 Clock Divisor Control (PBCLK2 is SYSCLK divided by 2)

    // PB3DIV

    PB3DIVbits.ON = 1; // Peripheral Bus 2 Output Clock Enable (Output clock is enabled)

    PB3DIVbits.PBDIV = 1; // Peripheral Bus 3 Clock Divisor Control (PBCLK3 is SYSCLK divided by 2)

    // PB4DIV

    PB4DIVbits.ON = 1; // Peripheral Bus 4 Output Clock Enable (Output clock is enabled)

    while (!PB4DIVbits.PBDIVRDY); // Wait until it is ready to write to

    PB4DIVbits.PBDIV = 0; // Peripheral Bus 4 Clock Divisor Control (PBCLK4 is SYSCLK divided by 1)

    // PB5DIV

    PB5DIVbits.ON = 1; // Peripheral Bus 5 Output Clock Enable (Output clock is enabled)

    PB5DIVbits.PBDIV = 1; // Peripheral Bus 5 Clock Divisor Control (PBCLK5 is SYSCLK divided by 2)

    // PB7DIV

    PB7DIVbits.ON = 1; // Peripheral Bus 7 Output Clock Enable (Output clock is enabled)

    PB7DIVbits.PBDIV = 1; // Peripheral Bus 7 Clock Divisor Control (PBCLK7 is SYSCLK divided by 1)

    // PB8DIV

    PB8DIVbits.ON = 1; // Peripheral Bus 8 Output Clock Enable (Output clock is enabled)

    PB8DIVbits.PBDIV = 1; // Peripheral Bus 8 Clock Divisor Control (PBCLK8 is SYSCLK divided by 2)

    // PRECON - Set up prefetch

    PRECONbits.PFMSECEN = 0; // Flash SEC Interrupt Enable (Do not generate an interrupt when the PFMSEC bit is set)

    PRECONbits.PREFEN = 0b11; // Predictive Prefetch Enable (Enable predictive prefetch for any address)

    PRECONbits.PFMWS = 0b010; // PFM Access Time Defined in Terms of SYSCLK Wait States (Two wait states)

    // Set up caching

    cp0 = _mfc0(16, 0);

    cp0 &= ~0x07;

    cp0 |= 0b011; // K0 = Cacheable, non-coherent, write-back, write allocate

    _mtc0(16, 0, cp0);  

    // Lock Sequence

    SYSKEY = 0x33333333;

    asm volatile("ei"); // Enable all interrupts

}

// Global variables

FIL file; // File handle for the file we open

DIR dir; // Directory information for the current directory

FATFS fso; // File System Object for the file system we are reading from

FILINFO fileInfo; // Information for the file we have opened (not really necessary to have this)

void init_disk()

{

    // Wait for the disk to initialise

    while(disk_initialize(0));

    // Mount the disk

    f_mount(&fso, "", 0);

    // Change dir to the root directory

    f_chdir("/");

    // Open the directory

    f_opendir(&dir, ".");

}

void main()

{

  int bytes_read;

    unsigned char buffer[32768];

  // Set up all ports to be digital and not analog

    ANSELA = 0;

    ANSELB = 0;

    ANSELC = 0;

    ANSELD = 0;

    ANSELE = 0;

    ANSELF = 0;

    ANSELG = 0;

  // Set up PPS for SPI3 on RB10 and RC4

  SDI3R = 0b0110; // RB10 = SDI3

  RPC4R = 0b0111; // RC4 = SDO3

  TRISBbits.TRISB10 = 1; // Set RB10 as input because it's SDI3

  // Set max performance mode

//  set_performance_mode();

  // Initialise the SD card

  init_disk();

  // Open the file test.txt

  f_open(&file, "/test.txt", FA_WRITE);

  while (1);

}

/*------------------------------------------------------------------------/

/  MMCv3/SDv1/SDv2 (in SPI mode) control module

/-------------------------------------------------------------------------/

/

/  Copyright (C) 2010, ChaN, all right reserved.

/

/ * This software is a free software and there is NO WARRANTY.

/ * No restriction on use. You can use, modify and redistribute it for

/   personal, non-profit or commercial products UNDER YOUR RESPONSIBILITY.

/ * Redistributions of source code must retain the above copyright notice.

/

/-------------------------------------------------------------------------*/

//Edited by A. Morrison to function on PIC32.

// Ported by Riccardo Leonardi to PIC32MX795F512L  (22/11/2011)

// Many thanks to Aiden Morrison's good work!

// changes: parametrization of SPI port number

// Modified by Bryn Thomas (11/09/2016) to use Enhanced Buffer SPI mode

// and boost read performance with 32-bit transfers

// Modified by Aidan Mocke (04/09/2018) to work with the PIC32MZ series

#define _DISABLE_OPENADC10_CONFIGPORT_WARNING

#define _SUPPRESS_PLIB_WARNING

#include <xc.h>

#include "diskio.h"

/* Definitions for MMC/SDC command */

#define CMD0   (0)      /* GO_IDLE_STATE */

#define CMD1   (1)      /* SEND_OP_COND */

#define ACMD41 (41|0x80)  /* SEND_OP_COND (SDC) */

#define CMD8   (8)      /* SEND_IF_COND */

#define CMD9   (9)      /* SEND_CSD */

#define CMD10  (10)      /* SEND_CID */

#define CMD12  (12)      /* STOP_TRANSMISSION */

#define ACMD13 (13|0x80)  /* SD_STATUS (SDC) */

#define CMD16  (16)      /* SET_BLOCKLEN */

#define CMD17  (17)      /* READ_SINGLE_BLOCK */

#define CMD18  (18)      /* READ_MULTIPLE_BLOCK */

#define CMD23  (23)      /* SET_BLOCK_COUNT */

#define ACMD23 (23|0x80)  /* SET_WR_BLK_ERASE_COUNT (SDC) */

#define CMD24  (24)      /* WRITE_BLOCK */

#define CMD25  (25)      /* WRITE_MULTIPLE_BLOCK */

#define CMD41  (41)      /* SEND_OP_COND (ACMD) */

#define CMD55  (55)      /* APP_CMD */

#define CMD58  (58)      /* READ_OCR */

/* Port Controls  (Platform dependent) */

#define CS_SETOUT() TRISCbits.TRISC3 = 0 

#define CS_LOW()  LATCbits.LATC3 = 0  //MMC CS = L

#define CS_HIGH() LATCbits.LATC3 = 1  //MMC CS = H

//Change the SPI port number as needed on the following 5 lines

#define SPIBRG  SPI3BRG

#define SPIBUF  SPI3BUF

#define SPISTATbits SPI3STATbits

#define SPICONbits SPI3CONbits

#define  FCLK_SLOW()  SPIBRG = 128    /* Set slow clock (100k-400k) */

#define  FCLK_FAST()  SPIBRG = 16    /* Set fast clock (depends on the CSD) */

static volatile

DSTATUS Stat = STA_NOINIT;  /* Disk status */

static volatile

UINT Timer1, Timer2;    /* 1000Hz decrement timer */

static

UINT CardType;

typedef union 

{ 

    UINT int_data[128]; 

    BYTE byte_data[512];

} spi32_data;

unsigned char __attribute__((coherent)) rcvbuff[8192];

#define xmit_spi(dat)   xchg_spi(dat)

#define rcvr_spi()    xchg_spi(0xFF)

#define rcvr_spi_m(p)  SPIBUF = 0xFF; while (SPISTATbits.SPIRBE); *(p) = (BYTE)SPIBUF;

static

BYTE xchg_spi (BYTE dat)

{

  SPIBUF = dat;

  while (!SPISTATbits.SPIRBF);

  return (BYTE)SPIBUF;

}

/*-----------------------------------------------------------------------*/

/* Wait for card ready                                                   */

/*-----------------------------------------------------------------------*/

static

BYTE wait_ready (void)

{

  BYTE res;

  Timer2 = 500;  /* Wait for ready in timeout of 500ms */

  rcvr_spi();

  do

    res = rcvr_spi();

  while ((res != 0xFF) && Timer2);

  return res;

}

/*-----------------------------------------------------------------------*/

/* Deselect the card and release SPI bus                                 */

/*-----------------------------------------------------------------------*/

static

void deselect (void)

{

  CS_HIGH();

  rcvr_spi();

}

/*-----------------------------------------------------------------------*/

/* Select the card and wait ready                                        */

/*-----------------------------------------------------------------------*/

static

int select (void)  /* 1:Successful, 0:Timeout */

{

  CS_LOW();

  if (wait_ready() != 0xFF) {

    deselect();

    return 0;

  }

  return 1;

}

/*-----------------------------------------------------------------------*/

/* Write Sector(s)                                                       */

/*-----------------------------------------------------------------------*/

/*-----------------------------------------------------------------------*/

/* Send a command packet to MMC                                          */

/*-----------------------------------------------------------------------*/

static

BYTE send_cmd (

  BYTE cmd,    /* Command byte */

  DWORD arg    /* Argument */

)

{

  BYTE n, res;

  if (cmd & 0x80) {  /* ACMD<n> is the command sequense of CMD55-CMD<n> */

    cmd &= 0x7F;

    res = send_cmd(CMD55, 0);

    if (res > 1) return res;

  }

  /* Select the card and wait for ready */

  deselect();

  if (!select()) return 0xFF;

  /* Send command packet */

  xmit_spi(0x40 | cmd);      /* Start + Command index */

  xmit_spi((BYTE)(arg >> 24));  /* Argument[31..24] */

  xmit_spi((BYTE)(arg >> 16));  /* Argument[23..16] */

  xmit_spi((BYTE)(arg >> 8));    /* Argument[15..8] */

  xmit_spi((BYTE)arg);      /* Argument[7..0] */

  n = 0x01;            /* Dummy CRC + Stop */

  if (cmd == CMD0) n = 0x95;    /* Valid CRC for CMD0(0) */

  if (cmd == CMD8) n = 0x87;    /* Valid CRC for CMD8(0x1AA) */

  xmit_spi(n);

  /* Receive command response */

  if (cmd == CMD12) rcvr_spi();  /* Skip a stuff byte when stop reading */

  n = 10;              /* Wait for a valid response in timeout of 10 attempts */

  do

    res = rcvr_spi();

  while ((res & 0x80) && --n);

  return res;      /* Return with the response value */

}

/*-----------------------------------------------------------------------*/

/* Send a data packet to MMC                                             */

/*-----------------------------------------------------------------------*/

#if _READONLY == 0

static

int xmit_datablock (  /* 1:OK, 0:Failed */

  const BYTE *buff,  /* 512 byte data block to be transmitted */

  BYTE token      /* Data token */

)

{

  BYTE resp;

  UINT bc = 512;

  if (wait_ready() != 0xFF) return 0;

  xmit_spi(token);    /* Xmit a token */

  if (token != 0xFD) {  /* Not StopTran token */

    do {            /* Xmit the 512 byte data block to the MMC */

      xmit_spi(*buff++);

      xmit_spi(*buff++);

    } while (bc -= 2);

    xmit_spi(0xFF);        /* CRC (Dummy) */

    xmit_spi(0xFF);

    resp = rcvr_spi();      /* Receive a data response */

    if ((resp & 0x1F) != 0x05)  /* If not accepted, return with error */

      return 0;

  }

  return 1;

}

#endif  /* _READONLY */

#if _READONLY == 0

DRESULT disk_write (

  BYTE pdrv,        /* Physical drive nmuber (0) */

  const BYTE *buff,    /* Pointer to the data to be written */

  DWORD sector,      /* Start sector number (LBA) */

  UINT count        /* Sector count (1..255) */

)

{

  if (pdrv || !count) return RES_PARERR;

  if (Stat & STA_NOINIT) return RES_NOTRDY;

  if (Stat & STA_PROTECT) return RES_WRPRT;

  if (!(CardType & CT_BLOCK)) sector *= 512;  /* Convert to byte address if needed */

  if (count == 1) {    /* Single block write */

    if ((send_cmd(CMD24, sector) == 0)  /* WRITE_BLOCK */

      && xmit_datablock(buff, 0xFE))

      count = 0;

  }

  else {        /* Multiple block write */

    if (CardType & CT_SDC) send_cmd(ACMD23, count);

    if (send_cmd(CMD25, sector) == 0) {  /* WRITE_MULTIPLE_BLOCK */

      do {

        if (!xmit_datablock(buff, 0xFC)) break;

        buff += 512;

      } while (--count);

      if (!xmit_datablock(0, 0xFD))  /* STOP_TRAN token */

        count = 1;

    }

  }

  deselect();

  return count ? RES_ERROR : RES_OK;

}

#endif /* _READONLY */

/*-----------------------------------------------------------------------*/

/* Power Control  (Platform dependent)                                   */

/*-----------------------------------------------------------------------*/

/* When the target system does not support socket power control, there   */

/* is nothing to do in these functions and chk_power always returns 1.   */

static

void power_on (void)

{

    int cnt;

    /* Setup SPI */

  // Setup CS as output

  CS_SETOUT();

    SPICONbits.ON = 0;

    SPISTATbits.SPIROV = 0;

    SPICONbits.MSTEN = 1;

    SPICONbits.CKP = 1;

    SPICONbits.CKE = 0;

    SPICONbits.SMP = 1;

    SPICONbits.MODE16 = 0;

    SPICONbits.MODE32 = 0;

    SPICONbits.SRXISEL = 1;

    // Enables SPI port to run in Enhanced Buffer mode

    SPICONbits.ENHBUF = 0;

  SPICONbits.ON = 1;

}

static

void power_off (void)

{

  select();      /* Wait for card ready */

  deselect();

  SPICONbits.ON = 0;      /* Disable SPI */

  Stat |= STA_NOINIT;  /* Set STA_NOINIT */

}

/*-----------------------------------------------------------------------*/

/* Receive a data packet from MMC                                        */

/*-----------------------------------------------------------------------*/

static

int rcvr_datablock (  /* 1:OK, 0:Failed */

  BYTE *buff,      /* Data buffer to store received data */

  UINT btr      /* Byte count (must be multiple of 4) */

)

{

  BYTE token;

  Timer1 = 100;

  do {              /* Wait for data packet in timeout of 100ms */

    token = rcvr_spi();

  } while ((token == 0xFF) && Timer1);

  if(token != 0xFE) return 0;    /* If not valid data token, retutn with error */

  do {              /* Receive the data block into buffer */

    rcvr_spi_m(buff++);

    rcvr_spi_m(buff++);

    rcvr_spi_m(buff++);

    rcvr_spi_m(buff++);

  } while (btr -= 4);

  rcvr_spi();            /* Discard CRC */

  rcvr_spi();

  return 1;            /* Return with success */

}

/*--------------------------------------------------------------------------

   Public Functions

---------------------------------------------------------------------------*/

/*-----------------------------------------------------------------------*/

/* Initialize Disk Drive                                                 */

/*-----------------------------------------------------------------------*/

DSTATUS disk_initialize (

  BYTE drv    /* Physical drive nmuber (0) */

)

{

  BYTE n, cmd, ty, ocr[4];

  power_on();              /* Force socket power on */

        FCLK_SLOW();

  for (n = 80; n; n--) rcvr_spi();  /* 80 dummy clocks */

  ty = 0;

  if (send_cmd(CMD0, 0) == 1) {      /* Enter Idle state */

    Timer1 = 100;            /* Initialization timeout of 1000 msec */

    if (send_cmd(CMD8, 0x1AA) == 1) {  /* SDv2? */

      for (n = 0; n < 4; n++) ocr[n] = rcvr_spi();      /* Get trailing return value of R7 resp */

      if (ocr[2] == 0x01 && ocr[3] == 0xAA) {        /* The card can work at vdd range of 2.7-3.6V */

        while (Timer1 && send_cmd(ACMD41, 0x40000000));  /* Wait for leaving idle state (ACMD41 with HCS bit) */

        if (Timer1 && send_cmd(CMD58, 0) == 0) {      /* Check CCS bit in the OCR */

          for (n = 0; n < 4; n++) ocr[n] = rcvr_spi();

          ty = (ocr[0] & 0x40) ? CT_SD2|CT_BLOCK : CT_SD2;  /* SDv2 */

        }

      }

    } else {              /* SDv1 or MMCv3 */

      if (send_cmd(ACMD41, 0) <= 1)   {

        ty = CT_SD1; cmd = ACMD41;  /* SDv1 */

      } else {

        ty = CT_MMC; cmd = CMD1;  /* MMCv3 */

      }

      while (Timer1 && send_cmd(cmd, 0));    /* Wait for leaving idle state */

      if (!Timer1 || send_cmd(CMD16, 512) != 0)  /* Set read/write block length to 512 */

        ty = 0;

    }

  }

  CardType = ty;

  deselect();

  if (ty) {      /* Initialization succeded */

    Stat &= ~STA_NOINIT;  /* Clear STA_NOINIT */

    FCLK_FAST();

  } else {      /* Initialization failed */

    power_off();

  }

  return Stat;

}

/*-----------------------------------------------------------------------*/

/* Get Disk Status                                                       */

/*-----------------------------------------------------------------------*/

DSTATUS disk_status (

  BYTE drv    /* Physical drive nmuber (0) */

)

{

  if (drv) return STA_NOINIT;    /* Supports only single drive */

  return Stat;

}

/*-----------------------------------------------------------------------*/

/* Read Sector(s)                                                        */

/*-----------------------------------------------------------------------*/

DRESULT disk_read (BYTE pdrv, BYTE* buff, DWORD sector, UINT count)

{

  if (pdrv || !count) return RES_PARERR;

  if (Stat & STA_NOINIT) return RES_NOTRDY;

  if (!(CardType & CT_BLOCK)) sector *= 512;  /* Convert to byte address if needed */

  if (count == 1) {    /* Single block read */

    if ((send_cmd(CMD17, sector) == 0)  /* READ_SINGLE_BLOCK */

      && rcvr_datablock(buff, 512))

      count = 0;

  }

  else {        /* Multiple block read */

    if (send_cmd(CMD18, sector) == 0) {  /* READ_MULTIPLE_BLOCK */

      do {

        if (!rcvr_datablock(buff, 512)) break;

        buff += 512;

      } while (--count);

      send_cmd(CMD12, 0);        /* STOP_TRANSMISSION */

    }

  }

  deselect();

  return count ? RES_ERROR : RES_OK;

}

/*-----------------------------------------------------------------------*/

/* Write Sector(s)                                                       */

/*-----------------------------------------------------------------------*/

#if _READONLY == 0

DRESULT w (

  BYTE drv,        /* Physical drive nmuber (0) */

  const BYTE *buff,    /* Pointer to the data to be written */

  DWORD sector,      /* Start sector number (LBA) */

  BYTE count        /* Sector count (1..255) */

)

{

  if (drv || !count) return RES_PARERR;

  if (Stat & STA_NOINIT) return RES_NOTRDY;

  if (Stat & STA_PROTECT) return RES_WRPRT;

  if (!(CardType & CT_BLOCK)) sector *= 512;  /* Convert to byte address if needed */

  if (count == 1) {    /* Single block write */

    if ((send_cmd(CMD24, sector) == 0)  /* WRITE_BLOCK */

      && xmit_datablock(buff, 0xFE))

      count = 0;

  }

  else {        /* Multiple block write */

    if (CardType & CT_SDC) send_cmd(ACMD23, count);

    if (send_cmd(CMD25, sector) == 0) {  /* WRITE_MULTIPLE_BLOCK */

      do {

        if (!xmit_datablock(buff, 0xFC)) break;

        buff += 512;

      } while (--count);

      if (!xmit_datablock(0, 0xFD))  /* STOP_TRAN token */

        count = 1;

    }

  }

  deselect();

  return count ? RES_ERROR : RES_OK;

}

#endif /* _READONLY */

/*-----------------------------------------------------------------------*/

/* Miscellaneous Functions                                               */

/*-----------------------------------------------------------------------*/

DRESULT disk_ioctl (

  BYTE drv,    /* Physical drive nmuber (0) */

  BYTE ctrl,    /* Control code */

  void *buff    /* Buffer to send/receive data block */

)

{

  DRESULT res;

  BYTE n, csd[16], *ptr = buff;

  DWORD csize;

  if (drv) return RES_PARERR;

  if (Stat & STA_NOINIT) return RES_NOTRDY;

  res = RES_ERROR;

  switch (ctrl) {

    case CTRL_SYNC :  /* Flush dirty buffer if present */

      if (select()) {

        deselect();

        res = RES_OK;

      }

      break;

    case GET_SECTOR_COUNT :  /* Get number of sectors on the disk (WORD) */

      if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16)) {

        if ((csd[0] >> 6) == 1) {  /* SDv2? */

          csize = csd[9] + ((WORD)csd[8] << 8) + 1;

          *(DWORD*)buff = (DWORD)csize << 10;

        } else {          /* SDv1 or MMCv2 */

          n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;

          csize = (csd[8] >> 6) + ((WORD)csd[7] << 2) + ((WORD)(csd[6] & 3) << 10) + 1;

          *(DWORD*)buff = (DWORD)csize << (n - 9);

        }

        res = RES_OK;

      }

      break;

    case GET_SECTOR_SIZE :  /* Get sectors on the disk (WORD) */

      *(WORD*)buff = 512;

      res = RES_OK;

      break;

    case GET_BLOCK_SIZE :  /* Get erase block size in unit of sectors (DWORD) */

      if (CardType & CT_SD2) {  /* SDv2? */

        if (send_cmd(ACMD13, 0) == 0) {    /* Read SD status */

          rcvr_spi();

          if (rcvr_datablock(csd, 16)) {        /* Read partial block */

            for (n = 64 - 16; n; n--) rcvr_spi();  /* Purge trailing data */

            *(DWORD*)buff = 16UL << (csd[10] >> 4);

            res = RES_OK;

          }

        }

      } else {          /* SDv1 or MMCv3 */

        if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16)) {  /* Read CSD */

          if (CardType & CT_SD1) {  /* SDv1 */

            *(DWORD*)buff = (((csd[10] & 63) << 1) + ((WORD)(csd[11] & 128) >> 7) + 1) << ((csd[13] >> 6) - 1);

          } else {          /* MMCv3 */

            *(DWORD*)buff = ((WORD)((csd[10] & 124) >> 2) + 1) * (((csd[11] & 3) << 3) + ((csd[11] & 224) >> 5) + 1);

          }

          res = RES_OK;

        }

      }

      break;

    case MMC_GET_TYPE :    /* Get card type flags (1 byte) */

      *ptr = CardType;

      res = RES_OK;

      break;

    case MMC_GET_CSD :  /* Receive CSD as a data block (16 bytes) */

      if ((send_cmd(CMD9, 0) == 0)  /* READ_CSD */

        && rcvr_datablock(buff, 16))

        res = RES_OK;

      break;

    case MMC_GET_CID :  /* Receive CID as a data block (16 bytes) */

      if ((send_cmd(CMD10, 0) == 0)  /* READ_CID */

        && rcvr_datablock(buff, 16))

        res = RES_OK;

      break;

    case MMC_GET_OCR :  /* Receive OCR as an R3 resp (4 bytes) */

      if (send_cmd(CMD58, 0) == 0) {  /* READ_OCR */

        for (n = 0; n < 4; n++)

          *((BYTE*)buff+n) = rcvr_spi();

        res = RES_OK;

      }

      break;

    case MMC_GET_SDSTAT :  /* Receive SD statsu as a data block (64 bytes) */

      if (send_cmd(ACMD13, 0) == 0) {  /* SD_STATUS */

        rcvr_spi();

        if (rcvr_datablock(buff, 64))

          res = RES_OK;

      }

      break;

    default:

      res = RES_PARERR;

  }

  deselect();

  return res;

}

/*-----------------------------------------------------------------------*/

/* Device Timer Interrupt Procedure  (Platform dependent)                */

/*-----------------------------------------------------------------------*/

/* This function must be called in period of 1ms                         */

void disk_timerproc (void)

{

}

static

BYTE wait_ready (void)

{

  BYTE res;

  Timer2 = 500;  /* Wait for ready in timeout of 500ms */

  rcvr_spi();

  do

    res = rcvr_spi();

  while ((res != 0xFF) && Timer2);

  return res;

}

while ((res != 0xFF) && Timer2);