sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
568d5272e9
nuttx/drivers/mmcsd/mmcsd_spi.c
patacongo f7f7c531e0 Add enum argument to SPI status method 
git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@1667 42af7a65-404d-4744-a932-0658087f49c3
2009-03-29 18:53:20 +00:00

1416 lines
40 KiB
C
Raw Blame History

/****************************************************************************
* drivers/mmcsd/mmcsd_spi.c
*
* Copyright (C) 2008 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <spudmonkey@racsa.co.cr>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <sys/types.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <debug.h>
#include <nuttx/arch.h>
#include <nuttx/spi.h>
#include <nuttx/fs.h>
#include <nuttx/mmcsd.h>
#include "mmcsd_spi.h"
#include "mmcsd_csd.h"
#include "mmcsd_internal.h"
/****************************************************************************
* Pre-Processor Definitions
****************************************************************************/
/* Configuration ************************************************************/
#ifndef CONFIG_MMCSD_NSLOTS
# ifdef CONFIG_CPP_HAVE_WARNING
# warning "CONFIG_MMCSD_NSLOTS not defined"
# endif
# define CONFIG_MMCSD_NSLOTS 1
#endif
#define MMCSD_IDMODE_CLOCK (400000)
#if defined(CONFIG_FS_WRITABLE) && !defined(CONFIG_MMCSD_READONLY)
# define MMCSD_MODE 0666
#else
# define MMCSD_MODE 0444
#endif
/* Slot struct info *********************************************************/
/* Slot status definitions */
#define MMCSD_SLOTSTATUS_NOTREADY 0x01 /* Card not initialized */
#define MMCSD_SLOTSTATUS_NODISK 0x02 /* No card in the slot */
#define MMCSD_SLOTSTATUS_WRPROTECT 0x04 /* Card is write protected */
#define MMCSD_SLOTSTATUS_MEDIACHGD 0x08 /* Media changed in slot */
/* Values in the MMC/SD command table ***************************************/
/* These define the expected arguments of the MMC/SD command */
#define MMCSD_CMDARG_NONE 0
#define MMCSD_CMDARG_BLKLEN 1
#define MMCSD_CMDARG_ADDRESS 2
#define MMCSD_CMDARG_DUMMY 3
/* These define the value returned by the MMC/SD command */
#define MMCSD_CMDRESP_R1 0
#define MMCSD_CMDRESP_R1B 1
#define MMCSD_CMDRESP_R2 2
#define MMCSD_CMDRESP_R3 3
/* Fudge factor for SD read timeout: ~100msec, Write Time out ~250ms. Units
* of Hz.
*/
#define SD_READACCESSHZ 7
#define SD_WRITEACCESSHZ 3
/****************************************************************************
* Private Types
****************************************************************************/
/* This structure represents the state of one card slot */
struct mmcsd_slot_s
{
FAR struct spi_dev_s *spi; /* SPI port bound to this slot */
sem_t sem; /* Assures mutually exclusive accesss to card and SPI */
ubyte state; /* State of the slot (see MMCSD_SLOTSTATUS_* definitions) */
ubyte type; /* Disk type */
ubyte csd[16]; /* Copy of card CSD */
uint16 sectorsize; /* Media block size (in bytes) */
uint32 nsectors; /* Number of blocks on the media */
uint32 taccess; /* Card access time */
uint32 twrite; /* Card write time */
};
struct mmcsd_cmdinfo_s
{
ubyte cmd;
ubyte arg;
ubyte resp;
};
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/* Misc *********************************************************************/
static void mmcsd_semtake(sem_t *sem);
/* Card SPI interface *******************************************************/
static int mmcsd_waitready(FAR struct mmcsd_slot_s *slot);
static uint32 mmcsd_sendcmd(FAR struct mmcsd_slot_s *slot,
const struct mmcsd_cmdinfo_s *cmd, uint32 arg);
static void mmcsd_setblklen(FAR struct mmcsd_slot_s *slot, uint32 length);
static void mmcsd_decodecsd(FAR struct mmcsd_slot_s *slot, ubyte *csd);
static void mmcsd_checkwrprotect(FAR struct mmcsd_slot_s *slot, ubyte *csd);
static int mmcsd_getcardinfo(FAR struct mmcsd_slot_s *slot, ubyte *buffer,
const struct mmcsd_cmdinfo_s *cmd);
#define mmcsd_getcsd(slot, csd) mmcsd_getcardinfo(slot, csd, &g_cmd9);
#define mmcsd_getcid(slot, cid) mmcsd_getcardinfo(slot, cid, &g_cmd10);
/* Block driver interfaces **************************************************/
static int mmcsd_open(FAR struct inode *inode);
static int mmcsd_close(FAR struct inode *inode);
static ssize_t mmcsd_read(FAR struct inode *inode, unsigned char *buffer,
size_t start_sector, unsigned int nsectors);
#if defined(CONFIG_FS_WRITABLE) && !defined(CONFIG_MMCSD_READONLY)
static ssize_t mmcsd_write(FAR struct inode *inode, const unsigned char *buffer,
size_t start_sector, unsigned int nsectors);
#endif
static int mmcsd_geometry(FAR struct inode *inode, struct geometry *geometry);
/* Initialization ***********************************************************/
static int mmcsd_mediainitialize(FAR struct mmcsd_slot_s *slot);
static void mmcsd_mediachanged(void *arg);
/****************************************************************************
* Private Data
****************************************************************************/
/* Driver state *************************************************************/
/* These are the lock driver methods supported by this file */
static const struct block_operations g_bops =
{
mmcsd_open, /* open */
mmcsd_close, /* close */
mmcsd_read, /* read */
#if defined(CONFIG_FS_WRITABLE) && !defined(CONFIG_MMCSD_READONLY)
mmcsd_write, /* write */
#else
NULL, /* write */
#endif
mmcsd_geometry, /* geometry */
NULL /* ioctl */
};
/* A slot structure allocated for each configured slot */
static struct mmcsd_slot_s g_mmcsdslot[CONFIG_MMCSD_NSLOTS];
/* Timing *******************************************************************/
/* We will use the TRAN_SPEED from the CSD to determine the maximum SPI
* clocking (TRAN_SPEED defines the maximum transfer rate per bit per data
* line).
*
* The CSD TRAN_SPEED is provided as a 3 bit rate unit (RU) and a 4 bit time
* value (TU). We need the transfer frequency which is: RU*TU bits/sec
*
* g_transpeedru holds RU/10 and g_transpeedtu holds TU*10 so that the
* correct value is returned in the product
*/
static const uint32 g_transpeedru[8] =
{
10000, /* 0: 10 Kbit/sec / 10 */
100000, /* 1: 1 Mbit/sec / 10 */
1000000, /* 2: 10 Mbit/sec / 10 */
10000000, /* 3: 100 Mbit/sec / 10*/
0, 0, 0, 0 /* 4-7: Reserved values */
};
static const uint32 g_transpeedtu[16] =
{
0, 10, 12, 13, /* 0-3: Reserved, 1.0, 1.1, 1.2, 1.3 */
15, 20, 25, 30, /* 4-7: 1.5, 2.0, 2.5, 3.0 */
35, 40, 45, 50, /* 8-11: 3.5, 4.0, 4.5, 5.0 */
55, 60, 70, 80, /* 12-15: 5.5, 6.0, 7.0, 8.0 */
};
/* The TAAC defines the asynchronous part of the data access time. The
* read access time the sum of the TAAC and the NSAC. These define the
* time from the end bit of the read command to start bit of the data block.
*
* The TAAC consists of a 3-bit time unit (TU) and a 4-bit time value (TV).
* The access we need time is then given by:
*
* taccess = spifrequency / (TU*TV) + NAC
*
* g_taactu holds the (1 / TU / 100 ) and g_taactv holds (100 / TV) so
* that taccess can be computed without division.
*/
static const uint32 g_taactu[8] =
{
10000000, /* 0: 1 ns -> 1,000,000,000 Hz / 100 = 10,000,000 */
1000000, /* 1: 10 ns -> 100,000,000 Hz / 100 = 1,000,000 */
100000, /* 2: 100 ns -> 10,000,000 Hz / 100 = 100,000 */
10000, /* 3: 1 us -> 1,000,000 Hz / 100 = 10,000 */
1000, /* 4: 10 us -> 100,000 Hz / 100 = 1,000 */
100, /* 5: 100 us -> 10,000 Hz / 100 = 100 */
10, /* 6: 1 ms -> 1,000 Hz / 100 = 10 */
1, /* 7: 10 ms -> 100 Hz / 100 = 1 */
};
static const uint32 g_taactv[] =
{
0, 100, 83, 77, /* 0-3: Reserved, 100/1.0, 100/1.2, 100/1.3 */
67, 50, 40, 33, /* 4-7: 100/1.5, 100/2.0, 100/2.5, 100/3.0 */
29, 25, 22, 20, /* 8-11: 100/3.5, 100/4.0, 100/4.5, 100/5.0 */
18, 17, 14, 13 /* 12-15: 100/5.5, 100/6.0, 100/7.0, 100/8.0 */
};
/* Commands *****************************************************************/
static const struct mmcsd_cmdinfo_s g_cmd0 = {0x40, MMCSD_CMDARG_NONE, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd1 = {0x41, MMCSD_CMDARG_NONE, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd9 = {0x49, MMCSD_CMDARG_NONE, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd10 = {0x4a, MMCSD_CMDARG_NONE, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd12 = {0x4c, MMCSD_CMDARG_NONE, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd13 = {0x4d, MMCSD_CMDARG_NONE, MMCSD_CMDRESP_R2};
static const struct mmcsd_cmdinfo_s g_cmd16 = {0x50, MMCSD_CMDARG_BLKLEN, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd17 = {0x51, MMCSD_CMDARG_ADDRESS, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd18 = {0x52, MMCSD_CMDARG_ADDRESS, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd24 = {0x58, MMCSD_CMDARG_ADDRESS, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd25 = {0x59, MMCSD_CMDARG_ADDRESS, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd27 = {0x5b, MMCSD_CMDARG_NONE, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd28 = {0x5c, MMCSD_CMDARG_ADDRESS, MMCSD_CMDRESP_R1B};
static const struct mmcsd_cmdinfo_s g_cmd29 = {0x5d, MMCSD_CMDARG_ADDRESS, MMCSD_CMDRESP_R1B};
static const struct mmcsd_cmdinfo_s g_cmd30 = {0x5e, MMCSD_CMDARG_ADDRESS, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd32 = {0x60, MMCSD_CMDARG_ADDRESS, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd33 = {0x61, MMCSD_CMDARG_ADDRESS, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd34 = {0x62, MMCSD_CMDARG_ADDRESS, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd35 = {0x63, MMCSD_CMDARG_ADDRESS, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd36 = {0x64, MMCSD_CMDARG_ADDRESS, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd37 = {0x65, MMCSD_CMDARG_ADDRESS, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd38 = {0x66, MMCSD_CMDARG_DUMMY, MMCSD_CMDRESP_R1B};
static const struct mmcsd_cmdinfo_s g_cmd42 = {0x6a, MMCSD_CMDARG_DUMMY, MMCSD_CMDRESP_R1B};
static const struct mmcsd_cmdinfo_s g_cmd55 = {0x77, MMCSD_CMDARG_NONE, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd56 = {0x78, MMCSD_CMDARG_NONE, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_cmd58 = {0x7a, MMCSD_CMDARG_NONE, MMCSD_CMDRESP_R3};
static const struct mmcsd_cmdinfo_s g_cmd59 = {0x7b, MMCSD_CMDARG_DUMMY, MMCSD_CMDRESP_R1};
static const struct mmcsd_cmdinfo_s g_acmd41 = {0x69, MMCSD_CMDARG_NONE, MMCSD_CMDRESP_R1};
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: mmcsd_semtake
****************************************************************************/
static void mmcsd_semtake(sem_t *sem)
{
while (sem_wait(sem) != 0)
{
/* The only case that an error should occur here is if the wait was
* awakened by a signal.
*/
ASSERT(errno == EINTR);
}
}
#define mmcsd_semgive(sem) sem_post(sem)
/****************************************************************************
* Name: mmcsd_waitready
*
* Description:
* Wait until the the card is no longer busy
*
****************************************************************************/
static int mmcsd_waitready(FAR struct mmcsd_slot_s *slot)
{
FAR struct spi_dev_s *spi = slot->spi;
ubyte response;
int i;
/* Wait until the card is no longer busy */
for (i = 0; i < slot->twrite; i++)
{
response = SPI_SNDBYTE(spi, 0xff);
if (response == 0xff)
{
return OK;
}
}
fdbg("Card still busy, last response: %02x\n", response);
return -EBUSY;
}
/****************************************************************************
* Name: mmcsd_sendcmd
*
* Description:
* Send a command to MMC
*
****************************************************************************/
static uint32 mmcsd_sendcmd(FAR struct mmcsd_slot_s *slot,
const struct mmcsd_cmdinfo_s *cmd, uint32 arg)
{
FAR struct spi_dev_s *spi = slot->spi;
uint32 result;
ubyte response = 0xff;
int i;
/* Select SPI */
SPI_SELECT(spi, SPIDEV_MMCSD, TRUE);
/* Send command code */
SPI_SNDBYTE(spi, cmd->cmd);
/* Send command's arguments */
if (cmd->arg == MMCSD_CMDARG_NONE)
{
SPI_SNDBYTE(spi, 0x00);
SPI_SNDBYTE(spi, 0x00);
SPI_SNDBYTE(spi, 0x00);
SPI_SNDBYTE(spi, 0x00);
}
else
{
SPI_SNDBYTE(spi, arg >> 24);
SPI_SNDBYTE(spi, arg >> 16);
SPI_SNDBYTE(spi, arg >> 8);
SPI_SNDBYTE(spi, arg);
}
/* Send CRC if needed. The SPI interface is initialized in non-protected
* mode. However, the reset command (CMD0) is received by the card while it
* is still in SD mode and, therefore, must have a valid CRC field.
*/
if (cmd->cmd == 0x40)
{
SPI_SNDBYTE(spi, 0x95);
}
else
{
SPI_SNDBYTE(spi, 0xff);
}
/* Get the response to the command */
for (i = 0; i < 9 && response == 0xff; i++)
{
response = SPI_SNDBYTE(spi, 0xff);
}
if (i == 0)
{
fdbg("Failed: i=%d response=%02x\n", i, response);
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
return (uint32)-1;
}
/* Interpret the response according to the command */
switch (cmd->resp)
{
case MMCSD_CMDRESP_R1B:
{
uint32 busy = 0;
for (i = 0; i < slot->twrite && busy != 0xff; i++)
{
busy = SPI_SNDBYTE(spi, 0xff);
}
fvdbg("Return R1B=%02x\n", response);
}
return (uint32)response;
case MMCSD_CMDRESP_R1:
{
fvdbg("Return R1=%02x\n", response);
}
return (uint32)response;
case MMCSD_CMDRESP_R2:
{
result = ((uint32) response << 8) & 0x0000ff00;
result |= SPI_SNDBYTE(spi, 0xff) & 0xff;
fvdbg("Return R2=%04x\n", result);
}
return result;
case MMCSD_CMDRESP_R3:
default:
{
result = ((uint32) response << 24) & 0xff000000;
result |= ((uint32) SPI_SNDBYTE(spi, 0xff) << 16) & 0x00ff0000;
result |= ((uint32) SPI_SNDBYTE(spi, 0xff) << 8) & 0x0000ff00;
result |= SPI_SNDBYTE(spi, 0xff) & 0xff;
fvdbg("Return R3=%08x\n", result);
}
return result;
}
}
/****************************************************************************
* Name: mmcsd_setblklen
*
* Description:
* Set block length
*
****************************************************************************/
static void mmcsd_setblklen(FAR struct mmcsd_slot_s *slot, uint32 length)
{
FAR struct spi_dev_s *spi = slot->spi;
uint32 result;
result = mmcsd_sendcmd(slot, &g_cmd16, length);
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
}
/****************************************************************************
* Name: mmcsd_decodecsd
*
* Description:
*
****************************************************************************/
static void mmcsd_decodecsd(FAR struct mmcsd_slot_s *slot, ubyte *csd)
{
FAR struct spi_dev_s *spi = slot->spi;
uint32 frequency;
/* Calculate SPI max clock */
frequency =
g_transpeedru[MMCSD_CSD_TRANSPEED_TIMEVALUE(csd)] *
g_transpeedtu[MMCSD_CSD_TRANSPEED_TRANSFERRATEUNIT(csd)];
if (frequency > 20000000)
{
frequency = 20000000;
}
/* Set the SPI frequency to that value */
frequency = SPI_SETFREQUENCY(spi, frequency);
/* Now determine the delay to */
if (slot->type == MMCSD_CARDTYPE_MMC)
{
slot->taccess =
g_taactu[MMCSD_CSD_TAAC_TIMEUNIT(csd)] *
g_taactv[MMCSD_CSD_TAAC_TIMEVALUE(csd)];
slot->taccess = frequency / slot->taccess;
slot->taccess += 1 << (MMCSD_CSD_NSAC(csd) + 4);
slot->taccess *= 10;
slot->twrite = slot->taccess * MMCSD_CSD_R2WFACTOR(csd);
}
else
{
slot->taccess = frequency / SD_READACCESSHZ;
slot->twrite = frequency / SD_WRITEACCESSHZ;
}
fvdbg("Frequency: %d\n", frequency);
fvdbg("Read access time: %d\n", slot->taccess);
fvdbg("Write access time: %d\n", slot->twrite);
/* Get the physical geometry of the card: sector size and number of
* sectors. The card's total capacity is computed from
*
* capacity = BLOCKNR * BLOCK_LEN
* BLOCKNR = (C_SIZE+1)*MULT
* MULT = 2**(C_SIZE_MULT+2) (C_SIZE_MULT < 8)
* BLOCK_LEN = 2**READD_BL_LEN (READ_BL_LEN < 12)
*
* Or
*
* capacity = ((C_SIZE+1) << (READD_BL_LEN + C_SIZE_MULT + 2))
*
* In units of the sector size (1 << READ_BL_LEN), then simplifies to
*
* nsectors = ((C_SIZE+1) << (C_SIZE_MULT + 2))
*/
if (MMCSD_CSD_CSDSTRUCT(csd) == 1)
{
/* SDC ver 2.00 */
/* Note: On SD card WRITE_BL_LEN is always the same as READ_BL_LEN */
slot->sectorsize = 1 << SD20_CSD_READBLLEN(csd);
slot->nsectors = (SD20_CSD_CSIZE(csd) + 1) << (SD20_CSD_CSIZEMULT(csd) + 2);
}
else
{
/* MMC or SD ver 1.xx */
/* Note: On SD card WRITE_BL_LEN is always the same as READ_BL_LEN */
slot->sectorsize = 1 << MMCSD_CSD_READBLLEN(csd);
slot->nsectors = (MMCSD_CSD_CSIZE(csd) + 1) << (MMCSD_CSD_CSIZEMULT(csd) + 2);
}
fvdbg("Sector size: %d\n", slot->sectorsize);
fvdbg("Number of sectors: %d\n", slot->nsectors);
}
/****************************************************************************
* Name: mmcsd_checkwrprotect
*
* Description:
*
****************************************************************************/
static void mmcsd_checkwrprotect(FAR struct mmcsd_slot_s *slot, ubyte *csd)
{
FAR struct spi_dev_s *spi = slot->spi;
/* Check if (1) the slot is reporting that reporting that write protection
* is set, (2) the card reports permanent write protect, or (2) the card
* reports temporary write protect.
*/
if ((SPI_STATUS(spi, SPIDEV_MMCSD) & SPI_STATUS_WRPROTECTED) != 0 ||
MMCSD_CSD_PERMWRITEPROTECT(csd) ||
MMCSD_CSD_TMPWRITEPROTECT(csd))
{
slot->state |= MMCSD_SLOTSTATUS_WRPROTECT;
}
else
{
slot->state &= ~MMCSD_SLOTSTATUS_WRPROTECT;
}
}
/****************************************************************************
* Name: mmcsd_getcardinfo
*
* Description:
* Read CSD or CID registers
*
****************************************************************************/
static int mmcsd_getcardinfo(FAR struct mmcsd_slot_s *slot, ubyte *buffer,
const struct mmcsd_cmdinfo_s *cmd)
{
FAR struct spi_dev_s *spi = slot->spi;
uint32 result;
ubyte response;
int i;
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
SPI_SNDBYTE(spi, 0xff);
/* Send the CMD9 or CMD10 */
result = mmcsd_sendcmd(slot, cmd, 0);
if (result != MMCSD_SPIR1_OK)
{
fdbg("CMD9/10 failed: R1=%02x\n", result);
goto errout_with_eio;
}
/* Try up to 8 times to find the start of block (or until an error occurs) */
for (i = 0; i < 8; i++)
{
response = SPI_SNDBYTE(spi, 0xff);
fvdbg("%d. SPI sndbyte returned %02x\n", i, response);
/* If a read operation fails and the card cannot provide the requested
* data, it will send a data error token instead. The 4 least
* significant bits are the same as those in the R2 response.
*/
if (response != 0 && (response & MMCSD_SPIDET_UPPER) == 0)
{
fdbg("%d. Data transfer error: %02x\n", i, response);
goto errout_with_eio;
}
else if (response == MMCSD_SPIDT_STARTBLKSNGL)
{
for (i = 0; i < 16; ++i)
{
*buffer++ = SPI_SNDBYTE(spi, 0xff);
}
/* CRC receive */
(void)SPI_SNDBYTE(spi, 0xff);
(void)SPI_SNDBYTE(spi, 0xff);
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
return OK;
}
}
errout_with_eio:
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
return -EIO;
}
/****************************************************************************
* Block Driver Operations
****************************************************************************/
/****************************************************************************
* Name: mmcsd_open
*
* Description: Open the block device
*
****************************************************************************/
static int mmcsd_open(FAR struct inode *inode)
{
FAR struct mmcsd_slot_s *slot;
FAR struct spi_dev_s *spi;
int ret;
fvdbg("Entry\n");
#ifdef CONFIG_DEBUG
if (!inode || !inode->i_private)
{
fdbg("Internal confusion\n");
return -EIO;
}
#endif
/* Extract our private data from the inode structure */
slot = (FAR struct mmcsd_slot_s *)inode->i_private;
spi = slot->spi;
#ifdef CONFIG_DEBUG
if (!spi)
{
fdbg("Internal confusion\n");
return -EIO;
}
#endif
/* Select the slave */
mmcsd_semtake(&slot->sem);
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
/* Verify that the MMC/SD card is alive and ready for business */
ret = mmcsd_waitready(slot);
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
mmcsd_semgive(&slot->sem);
return ret;
}
/****************************************************************************
* Name: mmcsd_close
*
* Description: close the block device
*
****************************************************************************/
static int mmcsd_close(FAR struct inode *inode)
{
fvdbg("Entry\n");
return OK;
}
/****************************************************************************
* Name: mmcsd_read
*
* Description: Read the specified numer of sectors
*
****************************************************************************/
static ssize_t mmcsd_read(FAR struct inode *inode, unsigned char *buffer,
size_t start_sector, unsigned int nsectors)
{
FAR struct mmcsd_slot_s *slot;
FAR struct spi_dev_s *spi;
size_t nbytes;
off_t offset;
ubyte response;
int i;
fvdbg("start_sector=%d nsectors=%d\n", start_sector, nsectors);
#ifdef CONFIG_DEBUG
if (!buffer)
{
fdbg("Invalid parameters\n");
return -EINVAL;
}
if (!inode || !inode->i_private)
{
fdbg("Internal confusion\n");
return -EIO;
}
#endif
/* Extract our private data from the inode structure */
slot = (FAR struct mmcsd_slot_s *)inode->i_private;
spi = slot->spi;
#ifdef CONFIG_DEBUG
if (!spi)
{
fdbg("Internal confusion\n");
return -EIO;
}
#endif
/* Verify that card is availabled */
if (slot->state & MMCSD_SLOTSTATUS_NOTREADY)
{
fdbg("Slot not ready\n");
return -ENODEV;
}
/* Do nothing on zero-length transfer */
if (nsectors < 1)
{
return 0;
}
/* Convert sector and nsectors to nbytes and byte offset */
nbytes = nsectors * slot->sectorsize;
offset = start_sector * slot->sectorsize;
fvdbg("nbytes=%d offset=%d\n", nbytes, offset);
/* Select the slave and synchronize */
mmcsd_semtake(&slot->sem);
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
(void)SPI_SNDBYTE(spi, 0xff);
/* Send CMD17: Reads a block of the size selected by the SET_BLOCKLEN
* command and verify that good R1 status is returned
*/
response = mmcsd_sendcmd(slot, &g_cmd17, offset);
if (response != MMCSD_SPIR1_OK)
{
fdbg("CMD17 failed: R1=%02x\n", response);
goto errout_with_eio;
}
/* Loop only for the computed timeout */
for (i = 0; i < slot->taccess; i++)
{
/* Synchronize */
response = SPI_SNDBYTE(spi, 0xff);
fvdbg("(%d) SPI sndbyte returned %02x\n", i, response);
/* If a read operation fails and the card cannot provide the requested
* data, it will send a data error token instead. The 4 least
* significant bits are the same as those in the R2 response.
*/
if (response != 0 && (response & MMCSD_SPIDET_UPPER) == 0)
{
fdbg("(%d) Data transfer error: %02x\n", i, response);
goto errout_with_eio;
}
else if (response == MMCSD_SPIDT_STARTBLKSNGL)
{
/* Receive the block of data */
SPI_RECVBLOCK(spi, buffer, nbytes);
/* Receive and ignore the two CRC bytes */
(void)SPI_SNDBYTE(spi, 0xff);
(void)SPI_SNDBYTE(spi, 0xff);
/* On success, return the number of sectors transfer */
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
mmcsd_semgive(&slot->sem);
fvdbg("(%d) Read %d bytes:\n", i, nbytes);
mmcsd_dumpbuffer(buffer, nbytes);
return nsectors;
}
}
errout_with_eio:
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
mmcsd_semgive(&slot->sem);
return -EIO;
}
/****************************************************************************
* Name: mmcsd_write
*
* Description:
* Write the specified number of sectors
*
****************************************************************************/
#if defined(CONFIG_FS_WRITABLE) && !defined(CONFIG_MMCSD_READONLY)
static ssize_t mmcsd_write(FAR struct inode *inode, const unsigned char *buffer,
size_t start_sector, unsigned int nsectors)
{
FAR struct mmcsd_slot_s *slot;
FAR struct spi_dev_s *spi;
size_t nbytes;
off_t offset;
ubyte response;
int ret;
fvdbg("start_sector=%d nsectors=%d\n", start_sector, nsectors);
#ifdef CONFIG_DEBUG
if (!buffer)
{
fdbg("Invalid parameters\n");
return -EINVAL;
}
if (!inode || !inode->i_private)
{
fdbg("Internal confusion\n");
return -EIO;
}
#endif
/* Extract our private data from the inode structure */
slot = (FAR struct mmcsd_slot_s *)inode->i_private;
spi = slot->spi;
#ifdef CONFIG_DEBUG
if (!spi)
{
fdbg("Internal confusion\n");
return -EIO;
}
#endif
/* Verify that card is availabled */
if (slot->state & MMCSD_SLOTSTATUS_NOTREADY)
{
fdbg("Slot not ready\n");
return -ENODEV;
}
/* Verify that the card is write enabled */
if (slot->state & MMCSD_SLOTSTATUS_WRPROTECT)
{
fdbg("Not write enabled\n");
return -EACCES;
}
/* Do nothing on zero-length transfer */
if (nsectors < 1)
{
return 0;
}
/* Convert sector and nsectors to nbytes and byte offset */
nbytes = nsectors * slot->sectorsize;
offset = start_sector * slot->sectorsize;
fvdbg("Writing %d bytes to offset %d:\n", nbytes, offset);
mmcsd_dumpbuffer(buffer, nbytes);
/* Select the slave and synchronize */
mmcsd_semtake(&slot->sem);
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
(void)SPI_SNDBYTE(spi, 0xff);
/* Send CMD24 (WRITE_BLOCK) and verify that good R1 status is returned */
response = mmcsd_sendcmd(slot, &g_cmd24, offset);
if (response != MMCSD_SPIR1_OK)
{
fdbg("CMD24 failed: R1=%02x\n", response);
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
ret = -EIO;
goto errout_with_sem;
}
/* Start the block transfer:
* 1. 0xff (sync)
* 2. 0xfe (start of block)
* 3. Followed by the block of data
*/
(void)SPI_SNDBYTE(spi, 0xff);
(void)SPI_SNDBYTE(spi, MMCSD_SPIDT_STARTBLKSNGL);
(void)SPI_SNDBLOCK(spi, buffer, nbytes);
/* Add the bogus CRC. By default, the SPI interface is initialized in
* non-protected mode. However, we still have to send bogus CRC values
*/
(void)SPI_SNDBYTE(spi, 0xff);
(void)SPI_SNDBYTE(spi, 0xff);
/* Now get the data response */
response = SPI_SNDBYTE(spi, 0xff);
if ((response & MMCSD_SPIDR_MASK) != MMCSD_SPIDR_ACCEPTED)
{
fdbg("Bad data response: %02x\n", response);
ret = -EIO;
goto errout_with_sem;
}
/* Wait until the card is no longer busy */
ret = mmcsd_waitready(slot);
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
mmcsd_semgive(&slot->sem);
/* Verify that the card successfully became non-busy */
if (ret < 0)
{
return ret;
}
/* The success return value is the number of sectors written */
return nsectors;
errout_with_sem:
mmcsd_semgive(&slot->sem);
return ret;
}
#endif
/****************************************************************************
* Name: mmcsd_geometry
*
* Description:
* Return device geometry
*
****************************************************************************/
static int mmcsd_geometry(FAR struct inode *inode, struct geometry *geometry)
{
FAR struct mmcsd_slot_s *slot;
FAR struct spi_dev_s *spi;
ubyte csd[16];
int ret;
#ifdef CONFIG_DEBUG
if (!geometry)
{
fdbg("Invalid parameters\n");
return -EINVAL;
}
if (!inode || !inode->i_private)
{
fdbg("Internal confusion\n");
return -EIO;
}
#endif
/* Extract our private data from the inode structure */
slot = (FAR struct mmcsd_slot_s *)inode->i_private;
spi = slot->spi;
#ifdef CONFIG_DEBUG
if (!spi)
{
fdbg("Internal confusion\n");
return -EIO;
}
#endif
/* Re-sample the CSD */
mmcsd_semtake(&slot->sem);
ret = mmcsd_getcsd(slot, csd);
if (ret < 0)
{
mmcsd_semgive(&slot->sem);
fdbg("mmcsd_getcsd returned %d\n", ret);
return ret;
}
/* Check for changes related to write protection */
mmcsd_checkwrprotect(slot, csd);
/* Then return the card geometry */
geometry->geo_available =
((slot->state & (MMCSD_SLOTSTATUS_NOTREADY|MMCSD_SLOTSTATUS_NODISK)) == 0);
geometry->geo_mediachanged =
((slot->state & MMCSD_SLOTSTATUS_MEDIACHGD) != 0);
#if defined(CONFIG_FS_WRITABLE) && !defined(CONFIG_MMCSD_READONLY)
geometry->geo_writeenabled =
((slot->state & MMCSD_SLOTSTATUS_WRPROTECT) == 0);
#else
geometry->geo_writeenabled = FALSE;
#endif
geometry->geo_nsectors = slot->nsectors;
geometry->geo_sectorsize = slot->sectorsize;
/* After reporting mediachanged, clear the indication so that it is not
* reported again.
*/
slot->state &= ~MMCSD_SLOTSTATUS_MEDIACHGD;
mmcsd_semgive(&slot->sem);
fvdbg("geo_available: %d\n", geometry->geo_available);
fvdbg("geo_mediachanged: %d\n", geometry->geo_mediachanged);
fvdbg("geo_writeenabled: %d\n", geometry->geo_writeenabled);
fvdbg("geo_nsectors: %d\n", geometry->geo_nsectors);
fvdbg("geo_sectorsize: %d\n", geometry->geo_sectorsize);
return OK;
}
/****************************************************************************
* Initialization
****************************************************************************/
/****************************************************************************
* Name: mmcsd_mediainitialize
*
* Description:
* Detect media and initialize
*
****************************************************************************/
static int mmcsd_mediainitialize(FAR struct mmcsd_slot_s *slot)
{
FAR struct spi_dev_s *spi = slot->spi;
ubyte csd[16];
uint32 result = MMCSD_SPIR1_IDLESTATE;
int i, j;
/* Assume that the card is not ready (we'll clear this on successful car
* initialization.
*/
slot->state |= MMCSD_SLOTSTATUS_NOTREADY;
/* Check if there is a card present in the slot. This is normally a matter is
* of GPIO sensing and does not really involve SPI, but by putting this
* functionality in the SPI interface, we encapuslate the SPI MMC/SD
* interface
*/
if ((SPI_STATUS(spi, SPIDEV_MMCSD) & SPI_STATUS_PRESENT) == 0)
{
fdbg("No card present\n");
slot->state |= MMCSD_SLOTSTATUS_NODISK;
return -ENODEV;
}
/* Clock Freq. Identification Mode < 400kHz */
SPI_SETFREQUENCY(spi, MMCSD_IDMODE_CLOCK);
/* Set the maximum access time out */
slot->taccess = MMCSD_IDMODE_CLOCK / SD_READACCESSHZ;
/* The SD card wakes up in SD mode. It will enter SPI mode if the chip select signal is
* asserted (negative) during the reception of the reset command (CMD0) and the card is in
* IDLE state.
*/
/* After power up at least 74 clock cycles are required prior to starting bus communication */
fvdbg("Send CMD0\n");
for (i = 0; i < 2; i++)
{
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
for (j = 10; j; j--)
{
SPI_SNDBYTE(spi, 0xff);
}
/* Send CMD0 (GO_TO_IDLE) to put MMC/SD in IDLE/SPI mode */
result = mmcsd_sendcmd(slot, &g_cmd0, 0);
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
/* Return from CMD0 is R1 which should now show IDLE STATE */
if (result == MMCSD_SPIR1_IDLESTATE)
{
fvdbg("Card is in IDLE state\n");
break;
}
}
/* Verify that we exit the above loop with the card reporting IDLE state */
if (result != MMCSD_SPIR1_IDLESTATE)
{
fdbg("Send CMD0 failed: R1=%02x\n", result);
return -EIO;
}
/* Determinate Card type SD or MMC */
slot->type = MMCSD_CARDTYPE_MMC;
for (i = 100; i; --i)
{
fvdbg("%d. Send CMD55\n", i);
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
SPI_SNDBYTE(spi, 0xff);
result = mmcsd_sendcmd(slot, &g_cmd55, 0);
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
fvdbg("%d. Send ACMD41\n", i);
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
SPI_SNDBYTE(spi, 0xff);
result = mmcsd_sendcmd(slot, &g_acmd41, 0);
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
/* If this is an MMC card, it will response with ILLEGAL COMMAND */
if (result & MMCSD_SPIR1_ILLEGALCMD)
{
/* MMC card may be CMD1 for MMC Init sequence will be complete within
* 500ms */
for (i = 100; i; --i)
{
fvdbg("%d. Send CMD1\n", i);
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
SPI_SNDBYTE(spi, 0xff);
result = mmcsd_sendcmd(slot, &g_cmd1, 0);
SPI_SELECT(spi, SPIDEV_MMCSD, FALSE);
if (result == MMCSD_SPIR1_OK)
{
fvdbg("%d. Identified MMC card\n", i);
slot->type = MMCSD_CARDTYPE_MMC;
break;
}
up_mdelay(50);
}
break;
}
else if (result == MMCSD_SPIR1_OK)
{
fvdbg("%d. Identified SD card\n", i);
slot->type = MMCSD_CARDTYPE_SD;
break;
}
up_mdelay(50);
}
if (i == 0)
{
fdbg("Retry exhausted\n");
return -EIO;
}
/* Read CSD. CSD must always be valid */
fvdbg("Get CSD\n");
result = mmcsd_getcsd(slot, csd);
if (result != OK)
{
fdbg("mmcsd_getcsd(CMD9) failed: %d\n", result);
return -EIO;
}
#if defined(CONFIG_DEBUG) && defined(CONFIG_DEBUG_FS)
if (slot->type == MMCSD_CARDTYPE_MMC)
{
fdbg("Found MMC card\n");
}
else if (MMCSD_CSD_CSDSTRUCT(csd) == 1)
{
fdbg("Found SDHC card\n");
}
else
{
fdbg("Found SD card\n");
}
mmcsd_dmpcsd(csd, slot->type);
#endif
/* CSD data and set block size */
mmcsd_decodecsd(slot, csd);
mmcsd_checkwrprotect(slot, csd);
mmcsd_setblklen(slot, slot->sectorsize);
slot->state &= ~MMCSD_SLOTSTATUS_NOTREADY;
return OK;
}
/****************************************************************************
* Name: mmcsd_mediachanged
*
* Description:
* Handle initialization/media change events
*
****************************************************************************/
static void mmcsd_mediachanged(void *arg)
{
struct mmcsd_slot_s *slot = (struct mmcsd_slot_s*)arg;
FAR struct spi_dev_s *spi;
ubyte oldstate;
int ret;
#ifdef CONFIG_DEBUG
if (!slot || !slot->spi)
{
fdbg("Internal confusion\n");
return;
}
#endif
spi = slot->spi;
/* Save the current slot state and reassess the new state */
mmcsd_semtake(&slot->sem);
oldstate = slot->state;
/* Check if media was removed or inserted */
slot->state &= ~(MMCSD_SLOTSTATUS_NODISK|MMCSD_SLOTSTATUS_NOTREADY|MMCSD_SLOTSTATUS_MEDIACHGD);
if ((SPI_STATUS(spi, SPIDEV_MMCSD) & SPI_STATUS_PRESENT) == 0)
{
/* Media is not present */
fdbg("No card present\n");
slot->state |= (MMCSD_SLOTSTATUS_NODISK|MMCSD_SLOTSTATUS_NOTREADY);
/* Was media removed? */
if ((oldstate & MMCSD_SLOTSTATUS_NODISK) == 0)
{
slot->state |= MMCSD_SLOTSTATUS_MEDIACHGD;
}
}
/* Media is present, was it just inserted? Or, if it was previously not ready,
* then try re-initializing it
*/
else if ((oldstate & (MMCSD_SLOTSTATUS_NODISK|MMCSD_SLOTSTATUS_NOTREADY)) != 0)
{
/* (Re-)ininitialize for the media in the slot */
ret = mmcsd_mediainitialize(slot);
if (ret == 0)
{
fvdbg("mmcsd_mediainitialize returned OK\n");
slot->state |= MMCSD_SLOTSTATUS_MEDIACHGD;
}
}
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: mmcsd_spislotinitialize
*
* Description:
* Initialize one slot for operation using the SPI MMC/SD interface
*
* Input Parameters:
* minor - The MMC/SD minor device number. The MMC/SD device will be
* registered as /dev/mmcsdN where N is the minor number
* slotno - The slot number to use. This is only meaningful for architectures
* that support multiple MMC/SD slots. This value must be in the range
* {0, ..., CONFIG_MMCSD_NSLOTS}.
* spi - And instance of an SPI interface obtained by called
* up_spiinitialize() with the appropriate port number (see spi.h)
*
****************************************************************************/
int mmcsd_spislotinitialize(int minor, int slotno, FAR struct spi_dev_s *spi)
{
struct mmcsd_slot_s *slot;
char devname[16];
int ret;
#ifdef CONFIG_DEBUG
if ((unsigned)slotno >= CONFIG_MMCSD_NSLOTS || (unsigned)minor > 255 || !spi)
{
fdbg("Invalid arguments\n");
return -EINVAL;
}
#endif
/* Select the slot structure */
slot = &g_mmcsdslot[slotno];
memset(slot, 0, sizeof(struct mmcsd_slot_s));
sem_init(&slot->sem, 0, 1);
#ifdef CONFIG_DEBUG
if (slot->spi)
{
fdbg("Already registered\n");
return -EBUSY;
}
#endif
/* Bind the SPI port to the slot */
slot->spi = spi;
/* Ininitialize for the media in the slot (if any) */
ret = mmcsd_mediainitialize(slot);
if (ret == 0)
{
fvdbg("mmcsd_mediainitialize returned OK\n");
slot->state |= MMCSD_SLOTSTATUS_MEDIACHGD;
}
/* Create a MMC/SD device name */
snprintf(devname, 16, "/dev/mmcsd%d", minor);
/* Register the driver, even on a failure condition. A
* card may be inserted later, for example.
*/
ret = register_blockdriver(devname, &g_bops, MMCSD_MODE, slot);
if (ret < 0)
{
fdbg("register_blockdriver failed: %d\n", -ret);
slot->spi = NULL;
return ret;
}
/* Register a media change callback to handler insertion and
* removal of cards.
*/
(void)SPI_REGISTERCALLBACK(spi, mmcsd_mediachanged, (void*)slot);
return OK;
}
Reference in New Issue View Git Blame Copy Permalink