sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
37fc0a0208
nuttx/drivers/mmcsd/mmcsd_sdio.c
dongjiuzhu1 37fc0a0208 drivers/mmcsd_sdio: config timout to write one data block 
Some hardware needs to config this delay to write one data block, because
the hardware needs more time to wear leveling and bad block manage.

Signed-off-by: dongjiuzhu1 <dongjiuzhu1@xiaomi.com>
2023-07-28 05:01:36 -07:00

4201 lines
124 KiB
C
Raw Blame History

/****************************************************************************
* drivers/mmcsd/mmcsd_sdio.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#if defined (CONFIG_MMCSD) && defined (CONFIG_MMCSD_SDIO)
#include <nuttx/compiler.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <debug.h>
#include <errno.h>
#include <nuttx/kmalloc.h>
#include <nuttx/signal.h>
#include <nuttx/fs/fs.h>
#include <nuttx/fs/ioctl.h>
#include <nuttx/clock.h>
#include <nuttx/arch.h>
#include <nuttx/sdio.h>
#include <nuttx/mmcsd.h>
#include <nuttx/mutex.h>
#include "mmcsd.h"
#include "mmcsd_sdio.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* The maximum number of references on the driver (because a uint8_t is used.
* Use a larger type if more references are needed.
*/
#define MAX_CREFS 0xff
/* Timing (all in units of microseconds) */
#define MMCSD_POWERUP_DELAY ((useconds_t)250) /* 74 clock cycles @ 400KHz = 185uS */
#define MMCSD_IDLE_DELAY ((useconds_t)100000) /* Short delay to allow change to IDLE state */
#define MMCSD_DSR_DELAY ((useconds_t)100000) /* Time to wait after setting DSR */
#define MMCSD_CLK_DELAY ((useconds_t)5000) /* Delay after changing clock speeds */
/* Data delays (all in units of milliseconds).
*
* For MMC & SD V1.x, these should be based on Nac = TAAC + NSAC; The
* maximum value of TAAC is 80MS and the maximum value of NSAC is 25.5K
* clock cycle. For SD V2.x, a fixed delay of 100MS is recommend which is
* pretty close to the worst case SD V1.x Nac. Here we just use 100MS
* delay for all data transfers.
*/
#define MMCSD_SCR_DATADELAY (100) /* Wait up to 100MS to get SCR */
#define MMCSD_BLOCK_RDATADELAY (100) /* Wait up to 100MS to get one data block */
/* Wait timeout to write one data block */
#define MMCSD_BLOCK_WDATADELAY CONFIG_MMCSD_BLOCK_WDATADELAY
#define IS_EMPTY(priv) (priv->type == MMCSD_CARDTYPE_UNKNOWN)
#if CONFIG_MMCSD_MULTIBLOCK_LIMIT == 0
# define MMCSD_MULTIBLOCK_LIMIT SSIZE_MAX
#else
# define MMCSD_MULTIBLOCK_LIMIT CONFIG_MMCSD_MULTIBLOCK_LIMIT
#endif
#define MMCSD_CAPACITY(b, s) ((s) >= 10 ? (b) << ((s) - 10) : (b) >> (10 - (s)))
/****************************************************************************
* Private Types
****************************************************************************/
/* This structure is contains the unique state of the MMC/SD block driver */
struct mmcsd_state_s
{
FAR struct sdio_dev_s *dev; /* The SDIO device bound to this instance */
uint8_t crefs; /* Open references on the driver */
mutex_t lock; /* Assures mutually exclusive access to the slot */
/* Status flags */
uint8_t probed:1; /* true: mmcsd_probe() discovered a card */
uint8_t widebus:1; /* true: Wide 4-bit bus selected */
uint8_t mediachanged:1; /* true: Media changed since last check */
uint8_t wrbusy:1; /* true: Last transfer was a write, card may be busy */
uint8_t wrprotect:1; /* true: Card is write protected (from CSD) */
uint8_t locked:1; /* true: Media is locked (from R1) */
uint8_t dsrimp:1; /* true: card supports CMD4/DSR setting (from CSD) */
#ifdef CONFIG_SDIO_DMA
uint8_t dma:1; /* true: hardware supports DMA */
#endif
uint8_t mode:2; /* (See MMCSDMODE_* definitions) */
uint8_t type:4; /* Card type (See MMCSD_CARDTYPE_* definitions) */
uint8_t buswidth:4; /* Bus widths supported (SD only) */
sdio_capset_t caps; /* SDIO driver capabilities/limitations */
uint16_t selblocklen; /* The currently selected block length */
uint16_t rca; /* Relative Card Address (RCS) register */
/* Memory card geometry (extracted from the CSD) */
uint8_t blockshift; /* Log2 of blocksize */
uint16_t blocksize; /* Read block length (== block size) */
uint32_t nblocks; /* Number of blocks */
};
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/* Misc Helpers *************************************************************/
static int mmcsd_lock(FAR struct mmcsd_state_s *priv);
static void mmcsd_unlock(FAR struct mmcsd_state_s *priv);
/* Command/response helpers *************************************************/
static int mmcsd_sendcmdpoll(FAR struct mmcsd_state_s *priv,
uint32_t cmd, uint32_t arg);
static int mmcsd_recv_r1(FAR struct mmcsd_state_s *priv, uint32_t cmd);
static int mmcsd_recv_r6(FAR struct mmcsd_state_s *priv, uint32_t cmd);
static int mmcsd_get_scr(FAR struct mmcsd_state_s *priv,
uint32_t scr[2]);
static void mmcsd_decode_csd(FAR struct mmcsd_state_s *priv,
uint32_t csd[4]);
#ifdef CONFIG_DEBUG_FS_INFO
static void mmcsd_decode_cid(FAR struct mmcsd_state_s *priv,
uint32_t cid[4]);
#else
# define mmcsd_decode_cid(priv,cid)
#endif
static void mmcsd_decode_scr(FAR struct mmcsd_state_s *priv,
uint32_t scr[2]);
static int mmcsd_get_r1(FAR struct mmcsd_state_s *priv,
FAR uint32_t *r1);
static int mmcsd_verifystate(FAR struct mmcsd_state_s *priv,
uint32_t status);
/* Transfer helpers *********************************************************/
static bool mmcsd_wrprotected(FAR struct mmcsd_state_s *priv);
static int mmcsd_eventwait(FAR struct mmcsd_state_s *priv,
sdio_eventset_t failevents);
static int mmcsd_transferready(FAR struct mmcsd_state_s *priv);
#if MMCSD_MULTIBLOCK_LIMIT != 1
static int mmcsd_stoptransmission(FAR struct mmcsd_state_s *priv);
#endif
static int mmcsd_setblocklen(FAR struct mmcsd_state_s *priv,
uint32_t blocklen);
static ssize_t mmcsd_readsingle(FAR struct mmcsd_state_s *priv,
FAR uint8_t *buffer, off_t startblock);
#if MMCSD_MULTIBLOCK_LIMIT != 1
static ssize_t mmcsd_readmultiple(FAR struct mmcsd_state_s *priv,
FAR uint8_t *buffer, off_t startblock,
size_t nblocks);
#endif
static ssize_t mmcsd_writesingle(FAR struct mmcsd_state_s *priv,
FAR const uint8_t *buffer,
off_t startblock);
#if MMCSD_MULTIBLOCK_LIMIT != 1
static ssize_t mmcsd_writemultiple(FAR struct mmcsd_state_s *priv,
FAR const uint8_t *buffer,
off_t startblock,
size_t nblocks);
#endif
/* Block driver methods *****************************************************/
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, FAR unsigned char *buffer,
blkcnt_t startsector, unsigned int nsectors);
static ssize_t mmcsd_write(FAR struct inode *inode,
FAR const unsigned char *buffer,
blkcnt_t startsector,
unsigned int nsectors);
static int mmcsd_geometry(FAR struct inode *inode,
FAR struct geometry *geometry);
static int mmcsd_ioctl(FAR struct inode *inode, int cmd,
unsigned long arg);
/* Initialization/uninitialization/reset ************************************/
static void mmcsd_mediachange(FAR void *arg);
static int mmcsd_widebus(FAR struct mmcsd_state_s *priv);
#ifdef CONFIG_MMCSD_MMCSUPPORT
static int mmcsd_mmcinitialize(FAR struct mmcsd_state_s *priv);
static int mmcsd_read_csd(FAR struct mmcsd_state_s *priv);
#endif
static int mmcsd_sdinitialize(FAR struct mmcsd_state_s *priv);
static int mmcsd_cardidentify(FAR struct mmcsd_state_s *priv);
static int mmcsd_probe(FAR struct mmcsd_state_s *priv);
static int mmcsd_removed(FAR struct mmcsd_state_s *priv);
static int mmcsd_hwinitialize(FAR struct mmcsd_state_s *priv);
static void mmcsd_hwuninitialize(FAR struct mmcsd_state_s *priv);
#ifdef CONFIG_MMCSD_IOCSUPPORT
static int mmcsd_iocmd(FAR struct mmcsd_state_s *priv,
FAR struct mmc_ioc_cmd *ic_ptr);
static int mmcsd_multi_iocmd(FAR struct mmcsd_state_s *priv,
FAR struct mmc_ioc_multi_cmd *imc_ptr);
#endif
/****************************************************************************
* Private Data
****************************************************************************/
static const struct block_operations g_bops =
{
mmcsd_open, /* open */
mmcsd_close, /* close */
mmcsd_read, /* read */
mmcsd_write, /* write */
mmcsd_geometry, /* geometry */
mmcsd_ioctl /* ioctl */
};
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Misc Helpers
****************************************************************************/
static int mmcsd_lock(FAR struct mmcsd_state_s *priv)
{
int ret;
/* Take the lock, giving exclusive access to the driver (perhaps
* waiting)
*/
if (!up_interrupt_context() && !sched_idletask())
{
ret = nxmutex_lock(&priv->lock);
if (ret < 0)
{
return ret;
}
/* Lock the bus if mutually exclusive access to the
* SDIO bus is required on this platform.
*/
#ifdef CONFIG_SDIO_MUXBUS
SDIO_LOCK(priv->dev, TRUE);
#endif
}
else
{
ret = OK;
}
return ret;
}
static void mmcsd_unlock(FAR struct mmcsd_state_s *priv)
{
if (!up_interrupt_context() && !sched_idletask())
{
/* Release the SDIO bus lock, then the MMC/SD driver mutex in the
* opposite order that they were taken to assure that no deadlock
* conditions will arise.
*/
#ifdef CONFIG_SDIO_MUXBUS
SDIO_LOCK(priv->dev, FALSE);
#endif
nxmutex_unlock(&priv->lock);
}
}
/****************************************************************************
* Command/Response Helpers
****************************************************************************/
/****************************************************************************
* Name: mmcsd_sendcmdpoll
*
* Description:
* Send a command and poll-wait for the response.
*
****************************************************************************/
static int mmcsd_sendcmdpoll(FAR struct mmcsd_state_s *priv, uint32_t cmd,
uint32_t arg)
{
int ret;
/* Send the command */
ret = SDIO_SENDCMD(priv->dev, cmd, arg);
if (ret == OK)
{
/* Then poll-wait until the response is available */
ret = SDIO_WAITRESPONSE(priv->dev, cmd);
if (ret != OK)
{
ferr("ERROR: Wait for response to cmd: %08" PRIx32
" failed: %d\n",
cmd, ret);
}
}
return ret;
}
/****************************************************************************
* Name: mmcsd_sendcmd4
*
* Description:
* Set the Driver Stage Register (DSR) if (1) a CONFIG_MMCSD_DSR has been
* provided and (2) the card supports a DSR register. If no DSR value
* the card default value (0x0404) will be used.
*
****************************************************************************/
static inline int mmcsd_sendcmd4(FAR struct mmcsd_state_s *priv)
{
int ret = OK;
#ifdef CONFIG_MMCSD_DSR
/* The dsr_imp bit from the CSD will tell us if the card supports setting
* the DSR via CMD4 or not.
*/
if (priv->dsrimp != false)
{
finfo("Card supports DSR - send DSR.\n");
/* CMD4 = SET_DSR will set the cards DSR register. The DSR and CMD4
* support are optional. However, since this is a broadcast command
* with no response (like CMD0), we will never know if the DSR was
* set correctly or not
*/
mmcsd_sendcmdpoll(priv, MMCSD_CMD4, CONFIG_MMCSD_DSR << 16);
nxsig_usleep(MMCSD_DSR_DELAY);
/* Send it again to have more confidence */
mmcsd_sendcmdpoll(priv, MMCSD_CMD4, CONFIG_MMCSD_DSR << 16);
nxsig_usleep(MMCSD_DSR_DELAY);
}
else
{
finfo("Card does not support DSR.\n");
}
#endif
return ret;
}
/****************************************************************************
* Name: mmcsd_recv_r1
*
* Description:
* Receive R1 response and check for errors.
*
****************************************************************************/
static int mmcsd_recv_r1(FAR struct mmcsd_state_s *priv, uint32_t cmd)
{
uint32_t r1;
int ret;
/* Get the R1 response from the hardware */
ret = SDIO_RECVR1(priv->dev, cmd, &r1);
if (ret == OK)
{
/* Check if R1 reports an error */
if ((r1 & MMCSD_R1_ERRORMASK) != 0)
{
/* Card locked is considered an error. Save the card locked
* indication for later use.
*/
ferr("ERROR: R1=%08" PRIx32 "\n", r1);
priv->locked = ((r1 & MMCSD_R1_CARDISLOCKED) != 0);
ret = -EIO;
}
}
return ret;
}
/****************************************************************************
* Name: mmcsd_recv_r6
*
* Description:
* Receive R6 response and check for errors. On success, priv->rca is set
* to the received RCA
*
****************************************************************************/
static int mmcsd_recv_r6(FAR struct mmcsd_state_s *priv, uint32_t cmd)
{
uint32_t r6 = 0;
int ret;
/* R6 Published RCA Response (48-bit, SD card only)
* 47 0 Start bit
* 46 0 Transmission bit (0=from card)
* 45:40 bit5 - bit0 Command index (0-63)
* 39:8 bit31 - bit0 32-bit Argument Field, consisting of:
* [31:16] New published RCA of card
* [15:0] Card status bits {23,22,19,12:0}
* 7:1 bit6 - bit0 CRC7
* 0 1 End bit
*
* Get the R6 response from the hardware
*/
ret = SDIO_RECVR6(priv->dev, cmd, &r6);
if (ret == OK)
{
/* Check if R6 reports an error */
if ((r6 & MMCSD_R6_ERRORMASK) == 0)
{
/* No, save the RCA and return success */
priv->rca = (uint16_t)(r6 >> 16);
return OK;
}
/* Otherwise, return an I/O failure */
ret = -EIO;
}
ferr("ERROR: Failed to get RCA. R6=%08" PRIx32 ": %d\n", r6, ret);
return ret;
}
/****************************************************************************
* Name: mmcsd_get_scr
*
* Description:
* Obtain the SD card's Configuration Register (SCR)
*
* Returned Value:
* OK on success; a negated ernno on failure.
*
****************************************************************************/
static int mmcsd_get_scr(FAR struct mmcsd_state_s *priv, uint32_t scr[2])
{
int ret;
/* Set Block Size To 8 Bytes */
ret = mmcsd_setblocklen(priv, 8);
if (ret != OK)
{
ferr("ERROR: mmcsd_setblocklen failed: %d\n", ret);
return ret;
}
/* Setup up to receive data with interrupt mode */
SDIO_BLOCKSETUP(priv->dev, 8, 1);
SDIO_RECVSETUP(priv->dev, (FAR uint8_t *)scr, 8);
SDIO_WAITENABLE(priv->dev,
SDIOWAIT_TRANSFERDONE | SDIOWAIT_TIMEOUT | SDIOWAIT_ERROR,
MMCSD_SCR_DATADELAY);
/* Send CMD55 APP_CMD with argument as card's RCA */
mmcsd_sendcmdpoll(priv, SD_CMD55, (uint32_t)priv->rca << 16);
ret = mmcsd_recv_r1(priv, SD_CMD55);
if (ret != OK)
{
ferr("ERROR: RECVR1 for CMD55 failed: %d\n", ret);
SDIO_CANCEL(priv->dev);
return ret;
}
/* Send ACMD51 SD_APP_SEND_SCR with argument as 0 to start data receipt */
mmcsd_sendcmdpoll(priv, SD_ACMD51, 0);
ret = mmcsd_recv_r1(priv, SD_ACMD51);
if (ret != OK)
{
ferr("ERROR: RECVR1 for ACMD51 failed: %d\n", ret);
SDIO_CANCEL(priv->dev);
return ret;
}
/* Wait for data to be transferred */
ret = mmcsd_eventwait(priv, SDIOWAIT_TIMEOUT | SDIOWAIT_ERROR);
if (ret != OK)
{
ferr("ERROR: mmcsd_eventwait for READ DATA failed: %d\n", ret);
}
return ret;
}
/****************************************************************************
* Name: mmcsd_decode_csd
*
* Description:
* Decode and extract necessary information from the CSD. If debug is
* enabled, then decode and show the full contents of the CSD.
*
* Returned Value:
* OK on success; a negated ernno on failure. On success, the following
* values will be set in the driver state structure:
*
* priv->dsrimp true: card supports CMD4/DSR setting (from CSD)
* priv->wrprotect true: card is write protected (from CSD)
* priv->blocksize Read block length (== block size)
* priv->nblocks Number of blocks
*
****************************************************************************/
static void mmcsd_decode_csd(FAR struct mmcsd_state_s *priv, uint32_t csd[4])
{
#ifdef CONFIG_DEBUG_FS_INFO
struct mmcsd_csd_s decoded;
#endif
unsigned int readbllen;
bool permwriteprotect;
bool tmpwriteprotect;
/* Word 1: Bits 127-96:
*
* CSD_STRUCTURE 127:126 CSD structure
* SPEC_VERS 125:122 (MMC) Spec version
* TAAC 119:112 Data read access-time-1
* TIME_VALUE 6:3 Time mantissa
* TIME_UNIT 2:0 Time exponent
* NSAC 111:104 Data read access-time-2 in CLK
* cycle(NSAC*100)
* TRAN_SPEED 103:96 Max. data transfer rate
* TIME_VALUE 6:3 Rate exponent
* TRANSFER_RATE_UNIT 2:0 Rate mantissa
*/
#ifdef CONFIG_DEBUG_FS_INFO
memset(&decoded, 0, sizeof(struct mmcsd_csd_s));
decoded.csdstructure = csd[0] >> 30;
decoded.mmcspecvers = (csd[0] >> 26) & 0x0f;
decoded.taac.timevalue = (csd[0] >> 19) & 0x0f;
decoded.taac.timeunit = (csd[0] >> 16) & 7;
decoded.nsac = (csd[0] >> 8) & 0xff;
decoded.transpeed.timevalue = (csd[0] >> 3) & 0x0f;
decoded.transpeed.transferrateunit = csd[0] & 7;
#endif
/* Word 2: Bits 64:95
* CCC 95:84 Card command classes
* READ_BL_LEN 83:80 Max. read data block length
* READ_BL_PARTIAL 79:79 Partial blocks for read allowed
* WRITE_BLK_MISALIGN 78:78 Write block misalignment
* READ_BLK_MISALIGN 77:77 Read block misalignment
* DSR_IMP 76:76 DSR implemented
* Byte addressed SD and MMC:
* C_SIZE 73:62 Device size
* Block addressed SD:
* 75:70 (reserved)
* C_SIZE 48:69 Device size
*/
priv->dsrimp = (csd[1] >> 12) & 1;
readbllen = (csd[1] >> 16) & 0x0f;
#ifdef CONFIG_DEBUG_FS_INFO
decoded.ccc = (csd[1] >> 20) & 0x0fff;
decoded.readbllen = (csd[1] >> 16) & 0x0f;
decoded.readblpartial = (csd[1] >> 15) & 1;
decoded.writeblkmisalign = (csd[1] >> 14) & 1;
decoded.readblkmisalign = (csd[1] >> 13) & 1;
decoded.dsrimp = priv->dsrimp;
#endif
/* Word 3: Bits 32-63
*
* Byte addressed SD:
* C_SIZE 73:62 Device size
* VDD_R_CURR_MIN 61:59 Max. read current at Vcc min
* VDD_R_CURR_MAX 58:56 Max. read current at Vcc max
* VDD_W_CURR_MIN 55:53 Max. write current at Vcc min
* VDD_W_CURR_MAX 52:50 Max. write current at Vcc max
* C_SIZE_MULT 49:47 Device size multiplier
* SD_ER_BLK_EN 46:46 Erase single block enable (SD only)
* SD_SECTOR_SIZE 45:39 Erase sector size
* SD_WP_GRP_SIZE 38:32 Write protect group size
* Block addressed SD:
* 75:70 (reserved)
* C_SIZE 48:69 Device size
* 47:47 (reserved)
* SD_ER_BLK_EN 46:46 Erase single block enable (SD only)
* SD_SECTOR_SIZE 45:39 Erase sector size
* SD_WP_GRP_SIZE 38:32 Write protect group size
* MMC:
* C_SIZE 73:62 Device size
* VDD_R_CURR_MIN 61:59 Max. read current at Vcc min
* VDD_R_CURR_MAX 58:56 Max. read current at Vcc max
* VDD_W_CURR_MIN 55:53 Max. write current at Vcc min
* VDD_W_CURR_MAX 52:50 Max. write current at Vcc max
* C_SIZE_MULT 49:47 Device size multiplier
* MMC_SECTOR_SIZE 46:42 Erase sector size
* MMC_ER_GRP_SIZE 41:37 Erase group size (MMC)
* MMC_WP_GRP_SIZE 36:32 Write protect group size
*/
if (IS_BLOCK(priv->type))
{
#ifdef CONFIG_MMCSD_MMCSUPPORT
if (IS_MMC(priv->type))
{
/* Block addressed MMC:
*
* C_SIZE: 73:64 from Word 2 and 63:62 from Word 3
*/
/* If the card is MMC and it has Block addressing
* then the correct number of blocks should already be
* read from extended CSD register.
*/
#ifdef CONFIG_DEBUG_FS_INFO
uint16_t csize = ((csd[1] & 0x03ff) << 2) |
((csd[2] >> 30) & 3);
uint8_t csizemult = (csd[2] >> 15) & 7;
#endif
priv->blockshift = readbllen;
priv->blocksize = (1 << readbllen);
if (priv->blocksize > 512)
{
priv->blocksize = 512;
priv->blockshift = 9;
}
#ifdef CONFIG_DEBUG_FS_INFO
decoded.u.mmc.csize = csize;
decoded.u.mmc.vddrcurrmin = (csd[2] >> 27) & 7;
decoded.u.mmc.vddrcurrmax = (csd[2] >> 24) & 7;
decoded.u.mmc.vddwcurrmin = (csd[2] >> 21) & 7;
decoded.u.mmc.vddwcurrmax = (csd[2] >> 18) & 7;
decoded.u.mmc.csizemult = csizemult;
decoded.u.mmc.er.mmc22.sectorsize = (csd[2] >> 10) & 0x1f;
decoded.u.mmc.er.mmc22.ergrpsize = (csd[2] >> 5) & 0x1f;
decoded.u.mmc.mmcwpgrpsize = csd[2] & 0x1f;
#endif
}
else
#endif
{
/* Block addressed SD:
*
* C_SIZE: 69:64 from Word 2 and 63:48 from Word 3
*
* 512 = (1 << 9)
* 1024 = (1 << 10)
* 512*1024 = (1 << 19)
*/
uint32_t csize = ((csd[1] & 0x3f) << 16) | (csd[2] >> 16);
priv->blockshift = 9;
priv->blocksize = 1 << 9;
priv->nblocks = (csize + 1) << (19 - priv->blockshift);
#ifdef CONFIG_DEBUG_FS_INFO
decoded.u.sdblock.csize = csize;
decoded.u.sdblock.sderblen = (csd[2] >> 14) & 1;
decoded.u.sdblock.sdsectorsize = (csd[2] >> 7) & 0x7f;
decoded.u.sdblock.sdwpgrpsize = csd[2] & 0x7f;
#endif
}
}
else
{
/* Byte addressed SD:
*
* C_SIZE: 73:64 from Word 2 and 63:62 from Word 3
*/
uint16_t csize = ((csd[1] & 0x03ff) << 2) |
((csd[2] >> 30) & 3);
uint8_t csizemult = (csd[2] >> 15) & 7;
priv->nblocks = ((uint32_t)csize + 1) *
(1 << (csizemult + 2));
priv->blockshift = readbllen;
priv->blocksize = (1 << readbllen);
/* Some devices, such as 2Gb devices, report blocksizes larger than
* 512 bytes but still expect to be accessed with a 512 byte blocksize.
*
* NOTE: A minor optimization would be to eliminated priv->blocksize
* and priv->blockshift: Those values will be 512 and 9 in all cases
* anyway.
*/
if (priv->blocksize > 512)
{
priv->nblocks <<= (priv->blockshift - 9);
priv->blocksize = 512;
priv->blockshift = 9;
}
#ifdef CONFIG_DEBUG_FS_INFO
if (IS_SD(priv->type))
{
decoded.u.sdbyte.csize = csize;
decoded.u.sdbyte.vddrcurrmin = (csd[2] >> 27) & 7;
decoded.u.sdbyte.vddrcurrmax = (csd[2] >> 24) & 7;
decoded.u.sdbyte.vddwcurrmin = (csd[2] >> 21) & 7;
decoded.u.sdbyte.vddwcurrmax = (csd[2] >> 18) & 7;
decoded.u.sdbyte.csizemult = csizemult;
decoded.u.sdbyte.sderblen = (csd[2] >> 14) & 1;
decoded.u.sdbyte.sdsectorsize = (csd[2] >> 7) & 0x7f;
decoded.u.sdbyte.sdwpgrpsize = csd[2] & 0x7f;
}
#ifdef CONFIG_MMCSD_MMCSUPPORT
else if (IS_MMC(priv->type))
{
decoded.u.mmc.csize = csize;
decoded.u.mmc.vddrcurrmin = (csd[2] >> 27) & 7;
decoded.u.mmc.vddrcurrmax = (csd[2] >> 24) & 7;
decoded.u.mmc.vddwcurrmin = (csd[2] >> 21) & 7;
decoded.u.mmc.vddwcurrmax = (csd[2] >> 18) & 7;
decoded.u.mmc.csizemult = csizemult;
decoded.u.mmc.er.mmc22.sectorsize = (csd[2] >> 10) & 0x1f;
decoded.u.mmc.er.mmc22.ergrpsize = (csd[2] >> 5) & 0x1f;
decoded.u.mmc.mmcwpgrpsize = csd[2] & 0x1f;
}
#endif
#endif
}
/* Word 4: Bits 0-31
* WP_GRP_EN 31:31 Write protect group enable
* MMC DFLT_ECC 30:29 Manufacturer default ECC (MMC only)
* R2W_FACTOR 28:26 Write speed factor
* WRITE_BL_LEN 25:22 Max. write data block length
* WRITE_BL_PARTIAL 21:21 Partial blocks for write allowed
* FILE_FORMAT_GROUP 15:15 File format group
* COPY 14:14 Copy flag (OTP)
* PERM_WRITE_PROTECT 13:13 Permanent write protection
* TMP_WRITE_PROTECT 12:12 Temporary write protection
* FILE_FORMAT 10:11 File format
* ECC 9:8 ECC (MMC only)
* CRC 7:1 CRC
* Not used 0:0
*/
permwriteprotect = (csd[3] >> 13) & 1;
tmpwriteprotect = (csd[3] >> 12) & 1;
priv->wrprotect = (permwriteprotect || tmpwriteprotect);
#ifdef CONFIG_DEBUG_FS_INFO
decoded.wpgrpen = csd[3] >> 31;
decoded.mmcdfltecc = (csd[3] >> 29) & 3;
decoded.r2wfactor = (csd[3] >> 26) & 7;
decoded.writebllen = (csd[3] >> 22) & 0x0f;
decoded.writeblpartial = (csd[3] >> 21) & 1;
decoded.fileformatgrp = (csd[3] >> 15) & 1;
decoded.copy = (csd[3] >> 14) & 1;
decoded.permwriteprotect = permwriteprotect;
decoded.tmpwriteprotect = tmpwriteprotect;
decoded.fileformat = (csd[3] >> 10) & 3;
decoded.mmcecc = (csd[3] >> 8) & 3;
decoded.crc = (csd[3] >> 1) & 0x7f;
finfo("CSD:\n");
finfo(" CSD_STRUCTURE: %d SPEC_VERS: %d (MMC)\n",
decoded.csdstructure, decoded.mmcspecvers);
finfo(" TAAC {TIME_UNIT: %d TIME_VALUE: %d} NSAC: %d\n",
decoded.taac.timeunit, decoded.taac.timevalue, decoded.nsac);
finfo(" TRAN_SPEED {TRANSFER_RATE_UNIT: %d TIME_VALUE: %d}\n",
decoded.transpeed.transferrateunit, decoded.transpeed.timevalue);
finfo(" CCC: %d\n", decoded.ccc);
finfo(" READ_BL_LEN: %d READ_BL_PARTIAL: %d\n",
decoded.readbllen, decoded.readblpartial);
finfo(" WRITE_BLK_MISALIGN: %d READ_BLK_MISALIGN: %d\n",
decoded.writeblkmisalign, decoded.readblkmisalign);
finfo(" DSR_IMP: %d\n",
decoded.dsrimp);
if (IS_BLOCK(priv->type))
{
#ifdef CONFIG_MMCSD_MMCSUPPORT
if (IS_MMC(priv->type))
{
finfo(" MMC Block Addressing:\n");
finfo(" C_SIZE: %d C_SIZE_MULT: %d\n",
decoded.u.mmc.csize, decoded.u.mmc.csizemult);
finfo(" VDD_R_CURR_MIN: %d VDD_R_CURR_MAX: %d\n",
decoded.u.mmc.vddrcurrmin, decoded.u.mmc.vddrcurrmax);
finfo(" VDD_W_CURR_MIN: %d VDD_W_CURR_MAX: %d\n",
decoded.u.mmc.vddwcurrmin, decoded.u.mmc.vddwcurrmax);
finfo(" MMC_SECTOR_SIZE: %d MMC_ER_GRP_SIZE: %d "
"MMC_WP_GRP_SIZE: %d\n",
decoded.u.mmc.er.mmc22.sectorsize,
decoded.u.mmc.er.mmc22.ergrpsize,
decoded.u.mmc.mmcwpgrpsize);
}
else
#endif
{
finfo(" SD Block Addressing:\n");
finfo(" C_SIZE: %d SD_ER_BLK_EN: %d\n",
decoded.u.sdblock.csize, decoded.u.sdblock.sderblen);
finfo(" SD_SECTOR_SIZE: %d SD_WP_GRP_SIZE: %d\n",
decoded.u.sdblock.sdsectorsize,
decoded.u.sdblock.sdwpgrpsize);
}
}
else if (IS_SD(priv->type))
{
finfo(" SD Byte Addressing:\n");
finfo(" C_SIZE: %d C_SIZE_MULT: %d\n",
decoded.u.sdbyte.csize, decoded.u.sdbyte.csizemult);
finfo(" VDD_R_CURR_MIN: %d VDD_R_CURR_MAX: %d\n",
decoded.u.sdbyte.vddrcurrmin, decoded.u.sdbyte.vddrcurrmax);
finfo(" VDD_W_CURR_MIN: %d VDD_W_CURR_MAX: %d\n",
decoded.u.sdbyte.vddwcurrmin, decoded.u.sdbyte.vddwcurrmax);
finfo(" SD_ER_BLK_EN: %d SD_SECTOR_SIZE: %d (SD) "
"SD_WP_GRP_SIZE: %d\n",
decoded.u.sdbyte.sderblen, decoded.u.sdbyte.sdsectorsize,
decoded.u.sdbyte.sdwpgrpsize);
}
#ifdef CONFIG_MMCSD_MMCSUPPORT
else if (IS_MMC(priv->type))
{
finfo(" MMC:\n");
finfo(" C_SIZE: %d C_SIZE_MULT: %d\n",
decoded.u.mmc.csize, decoded.u.mmc.csizemult);
finfo(" VDD_R_CURR_MIN: %d VDD_R_CURR_MAX: %d\n",
decoded.u.mmc.vddrcurrmin, decoded.u.mmc.vddrcurrmax);
finfo(" VDD_W_CURR_MIN: %d VDD_W_CURR_MAX: %d\n",
decoded.u.mmc.vddwcurrmin, decoded.u.mmc.vddwcurrmax);
finfo(" MMC_SECTOR_SIZE: %d MMC_ER_GRP_SIZE: %d "
"MMC_WP_GRP_SIZE: %d\n",
decoded.u.mmc.er.mmc22.sectorsize,
decoded.u.mmc.er.mmc22.ergrpsize,
decoded.u.mmc.mmcwpgrpsize);
}
#endif
finfo(" WP_GRP_EN: %d MMC DFLT_ECC: %d (MMC) R2W_FACTOR: %d\n",
decoded.wpgrpen, decoded.mmcdfltecc, decoded.r2wfactor);
finfo(" WRITE_BL_LEN: %d WRITE_BL_PARTIAL: %d\n",
decoded.writebllen, decoded.writeblpartial);
finfo(" FILE_FORMAT_GROUP: %d COPY: %d\n",
decoded.fileformatgrp, decoded.copy);
finfo(" PERM_WRITE_PROTECT: %d TMP_WRITE_PROTECT: %d\n",
decoded.permwriteprotect, decoded.tmpwriteprotect);
finfo(" FILE_FORMAT: %d ECC: %d (MMC) CRC: %d\n",
decoded.fileformat, decoded.mmcecc, decoded.crc);
finfo("Capacity: %luKb, Block size: %db, nblocks: %d wrprotect: %d\n",
(unsigned long)MMCSD_CAPACITY(priv->nblocks, priv->blockshift),
priv->blocksize, priv->nblocks, priv->wrprotect);
#endif
}
/****************************************************************************
* Name: mmcsd_decode_cid
*
* Description:
* Show the contents of the Card Identification Data (CID) (for debug
* purposes only)
*
****************************************************************************/
#ifdef CONFIG_DEBUG_FS_INFO
static void mmcsd_decode_cid(FAR struct mmcsd_state_s *priv, uint32_t cid[4])
{
struct mmcsd_cid_s decoded;
/* Word 1: Bits 127-96:
* mid - 127-120 8-bit Manufacturer ID
* oid - 119-104 16-bit OEM/Application ID (ascii)
* pnm - 103-64 40-bit Product Name (ascii) + null terminator
* pnm[0] 103:96
*/
decoded.mid = cid[0] >> 24;
decoded.oid = (cid[0] >> 8) & 0xffff;
decoded.pnm[0] = cid[0] & 0xff;
/* Word 2: Bits 64:95
* pnm - 103-64 40-bit Product Name (ascii) + null terminator
* pnm[1] 95:88
* pnm[2] 87:80
* pnm[3] 79:72
* pnm[4] 71:64
*/
decoded.pnm[1] = cid[1] >> 24;
decoded.pnm[2] = (cid[1] >> 16) & 0xff;
decoded.pnm[3] = (cid[1] >> 8) & 0xff;
decoded.pnm[4] = cid[1] & 0xff;
decoded.pnm[5] = '\0';
/* Word 3: Bits 32-63
* prv - 63-56 8-bit Product revision
* psn - 55-24 32-bit Product serial number
*/
decoded.prv = cid[2] >> 24;
decoded.psn = cid[2] << 8;
/* Word 4: Bits 0-31
* psn - 55-24 32-bit Product serial number
* 23-20 4-bit (reserved)
* mdt - 19:8 12-bit Manufacturing date
* crc - 7:1 7-bit CRC7
*/
decoded.psn |= cid[3] >> 24;
decoded.mdt = (cid[3] >> 8) & 0x0fff;
decoded.crc = (cid[3] >> 1) & 0x7f;
finfo("mid: %02x oid: %04x pnm: %s prv: %d psn: %lu mdt: %02x crc: %02x\n",
decoded.mid, decoded.oid, decoded.pnm, decoded.prv,
(unsigned long)decoded.psn, decoded.mdt, decoded.crc);
}
#endif
/****************************************************************************
* Name: mmcsd_decode_scr
*
* Description:
* Show the contents of the SD Configuration Register (SCR). The only
* value retained is: priv->buswidth;
*
****************************************************************************/
static void mmcsd_decode_scr(FAR struct mmcsd_state_s *priv, uint32_t scr[2])
{
#ifdef CONFIG_DEBUG_FS_INFO
struct mmcsd_scr_s decoded;
#endif
/* Word 1, bits 63:32
* SCR_STRUCTURE 63:60 4-bit SCR structure version
* SD_VERSION 59:56 4-bit SD memory spec. version
* DATA_STATE_AFTER_ERASE 55:55 1-bit erase status
* SD_SECURITY 54:52 3-bit SD security support level
* SD_BUS_WIDTHS 51:48 4-bit bus width indicator
* Reserved 47:32 16-bit SD reserved space
*/
#ifdef CONFIG_ENDIAN_BIG /* Card transfers SCR in big-endian order */
priv->buswidth = (scr[0] >> 16) & 15;
#else
priv->buswidth = (scr[0] >> 8) & 15;
#endif
#ifdef CONFIG_DEBUG_FS_INFO
#ifdef CONFIG_ENDIAN_BIG
/* Card SCR is big-endian order / CPU also big-endian
* 60 56 52 48 44 40 36 32
* VVVV SSSS ESSS BBBB RRRR RRRR RRRR RRRR
*/
decoded.scrversion = scr[0] >> 28;
decoded.sdversion = (scr[0] >> 24) & 15;
decoded.erasestate = (scr[0] >> 23) & 1;
decoded.security = (scr[0] >> 20) & 7;
#else
/* Card SCR is big-endian order / CPU is little-endian
* 36 32 44 40 52 48 60 56
* RRRR RRRR RRRR RRRR ESSS BBBB VVVV SSSS
*/
decoded.scrversion = (scr[0] >> 4) & 15;
decoded.sdversion = scr[0] & 15;
decoded.erasestate = (scr[0] >> 15) & 1;
decoded.security = (scr[0] >> 12) & 7;
#endif
decoded.buswidth = priv->buswidth;
#endif
/* Word 1, bits 63:32
* Reserved 31:0 32-bits reserved for manufacturing usage.
*/
#ifdef CONFIG_DEBUG_FS_INFO
decoded.mfgdata = scr[1]; /* Might be byte reversed! */
finfo("SCR:\n");
finfo(" SCR_STRUCTURE: %d SD_VERSION: %d\n",
decoded.scrversion, decoded.sdversion);
finfo(" DATA_STATE_AFTER_ERASE: %d SD_SECURITY: %d SD_BUS_WIDTHS: %x\n",
decoded.erasestate, decoded.security, decoded.buswidth);
finfo(" Manufacturing data: %08x\n",
decoded.mfgdata);
#endif
}
/****************************************************************************
* Name: mmcsd_get_r1
*
* Description:
* Get the R1 status of the card using CMD13
*
****************************************************************************/
static int mmcsd_get_r1(FAR struct mmcsd_state_s *priv, FAR uint32_t *r1)
{
uint32_t local_r1;
int ret;
DEBUGASSERT(priv != NULL && r1 != NULL);
/* Send CMD13, SEND_STATUS. The addressed card responds by sending its
* R1 card status register.
*/
mmcsd_sendcmdpoll(priv, MMCSD_CMD13, (uint32_t)priv->rca << 16);
ret = SDIO_RECVR1(priv->dev, MMCSD_CMD13, &local_r1);
if (ret == OK)
{
/* Check if R1 reports an error */
if ((local_r1 & MMCSD_R1_ERRORMASK) != 0)
{
/* Card locked is considered an error. Save the card locked
* indication for later use.
*/
priv->locked = ((local_r1 & MMCSD_R1_CARDISLOCKED) != 0);
/* We must tell someone which error bits were set. */
fwarn("WARNING: mmcsd_get_r1 returned errors: R1=%08" PRIx32 "\n",
local_r1);
ret = -EIO;
}
else
{
/* No errors, return R1 */
*r1 = local_r1;
}
}
return ret;
}
/****************************************************************************
* Name: mmcsd_verifystate
*
* Description:
* Verify that the card is in STANDBY state
*
****************************************************************************/
static int mmcsd_verifystate(FAR struct mmcsd_state_s *priv, uint32_t state)
{
uint32_t r1;
int ret;
/* Get the current R1 status from the card */
ret = mmcsd_get_r1(priv, &r1);
if (ret != OK)
{
ferr("ERROR: mmcsd_get_r1 failed: %d\n", ret);
return ret;
}
/* Now check if the card is in the expected state. */
if (IS_STATE(r1, state))
{
/* Yes.. return Success */
priv->wrbusy = false;
return OK;
}
return -EINVAL;
}
/****************************************************************************
* Transfer Helpers
****************************************************************************/
/****************************************************************************
* Name: mmcsd_wrprotected
*
* Description:
* Return true if the card is nlocked or write protected.
*
****************************************************************************/
static bool mmcsd_wrprotected(FAR struct mmcsd_state_s *priv)
{
/* Check if the card is locked (priv->locked) or write protected either (1)
* via software as reported via the CSD and retained in priv->wrprotect or
* (2) via the mechanical write protect on the card (which we get from the
* SDIO driver via SDIO_WRPROTECTED)
*/
return (priv->wrprotect || priv->locked || SDIO_WRPROTECTED(priv->dev));
}
/****************************************************************************
* Name: mmcsd_eventwait
*
* Description:
* Wait for the specified events to occur. Check for wakeup on error
* events.
*
****************************************************************************/
static int mmcsd_eventwait(FAR struct mmcsd_state_s *priv,
sdio_eventset_t failevents)
{
sdio_eventset_t wkupevent;
/* Wait for the set of events enabled by SDIO_EVENTENABLE. */
wkupevent = SDIO_EVENTWAIT(priv->dev);
/* SDIO_EVENTWAIT returns the event set containing the event(s) that ended
* the wait. It should always be non-zero, but may contain failure as
* well as success events. Check if it contains any failure events.
*/
if ((wkupevent & failevents) != 0)
{
/* Yes.. the failure event is probably SDIOWAIT_TIMEOUT */
ferr("ERROR: Awakened with %02x\n", wkupevent);
return wkupevent & SDIOWAIT_TIMEOUT ? -ETIMEDOUT : -EIO;
}
/* Since there are no failure events, we must have been awakened by one
* (or more) success events.
*/
return OK;
}
/****************************************************************************
* Name: mmcsd_transferready
*
* Description:
* Check if the MMC/SD card is ready for the next read or write transfer.
* Ready means: (1) card still in the slot, and (2) if the last transfer
* was a write transfer, the card is no longer busy from that transfer.
*
****************************************************************************/
static int mmcsd_transferready(FAR struct mmcsd_state_s *priv)
{
clock_t starttime;
clock_t elapsed;
uint32_t r1;
int ret;
/* First, check if the card has been removed. */
if (IS_EMPTY(priv) || !SDIO_PRESENT(priv->dev))
{
ferr("ERROR: Card has been removed\n");
return -ENODEV;
}
/* If the last data transfer was not a write, then we do not have to check
* the card status.
*/
else if (!priv->wrbusy)
{
return OK;
}
/* The card is still present and the last transfer was a write transfer.
* Loop, querying the card state. Return when (1) the card is in the
* TRANSFER state, (2) the card stays in the PROGRAMMING state too long,
* or (3) the card is in any other state.
*
* The PROGRAMMING state occurs normally after a WRITE operation. During
* this time, the card may be busy completing the WRITE and is not
* available for other operations. The card will transition from the
* PROGRAMMING state to the TRANSFER state when the card completes the
* WRITE operation.
*/
#if defined(CONFIG_MMCSD_SDIOWAIT_WRCOMPLETE)
ret = mmcsd_eventwait(priv, SDIOWAIT_TIMEOUT | SDIOWAIT_ERROR);
if (ret != OK)
{
ferr("ERROR: mmcsd_eventwait for transfer ready failed: %d\n", ret);
}
#endif
starttime = clock_systime_ticks();
do
{
/* Get the current R1 status from the card */
ret = mmcsd_get_r1(priv, &r1);
if (ret != OK)
{
ferr("ERROR: mmcsd_get_r1 failed: %d\n", ret);
goto errorout;
}
/* Now check if the card is in the expected transfer state. */
if (IS_STATE(r1, MMCSD_R1_STATE_TRAN))
{
/* Yes.. return Success */
priv->wrbusy = false;
return OK;
}
/* Check for the programming state. This is not an error. It means
* that the card is still busy from the last (write) transfer. The
* card can also still be receiving data, for example, if hardware
* receive FIFOs are not yet empty.
*/
else if (!IS_STATE(r1, MMCSD_R1_STATE_PRG) &&
!IS_STATE(r1, MMCSD_R1_STATE_RCV))
{
/* Any other state would be an error in this context. There is
* a possibility that the card is not selected. In this case,
* it could be in STANDBY or DISCONNECTED state and the fix
* might be to send CMD7 to re-select the card. Consider this
* if this error occurs.
*/
ferr("ERROR: Unexpected R1 state: %08" PRIx32 "\n", r1);
ret = -EINVAL;
goto errorout;
}
/* Do not hog the CPU */
nxsig_usleep(1000);
/* We are still in the programming state. Calculate the elapsed
* time... we can't stay in this loop forever!
*/
elapsed = clock_systime_ticks() - starttime;
}
while (elapsed < TICK_PER_SEC);
return -ETIMEDOUT;
errorout:
mmcsd_removed(priv);
return ret;
}
/****************************************************************************
* Name: mmcsd_stoptransmission
*
* Description:
* Send STOP_TRANSMISSION
*
****************************************************************************/
#if MMCSD_MULTIBLOCK_LIMIT != 1
static int mmcsd_stoptransmission(FAR struct mmcsd_state_s *priv)
{
int ret;
/* Send CMD12, STOP_TRANSMISSION, and verify good R1 return status */
mmcsd_sendcmdpoll(priv, MMCSD_CMD12, 0);
ret = mmcsd_recv_r1(priv, MMCSD_CMD12);
if (ret != OK)
{
ferr("ERROR: mmcsd_recv_r1 for CMD12 failed: %d\n", ret);
}
return ret;
}
#endif
/****************************************************************************
* Name: mmcsd_setblocklen
*
* Description:
* Set the block length.
*
****************************************************************************/
static int mmcsd_setblocklen(FAR struct mmcsd_state_s *priv,
uint32_t blocklen)
{
int ret = OK;
/* Is the block length already selected in the card? */
if (priv->selblocklen != blocklen)
{
/* Send CMD16 = SET_BLOCKLEN. This command sets the block length (in
* bytes) for all following block commands (read and write). Default
* block length is specified in the CSD.
*/
mmcsd_sendcmdpoll(priv, MMCSD_CMD16, blocklen);
ret = mmcsd_recv_r1(priv, MMCSD_CMD16);
if (ret == OK)
{
priv->selblocklen = blocklen;
}
else
{
ferr("ERROR: mmcsd_recv_r1 for CMD16 failed: %d\n", ret);
}
}
return ret;
}
/****************************************************************************
* Name: mmcsd_readsingle
*
* Description:
* Read a single block of data.
*
****************************************************************************/
static ssize_t mmcsd_readsingle(FAR struct mmcsd_state_s *priv,
FAR uint8_t *buffer, off_t startblock)
{
off_t offset;
int ret;
finfo("startblock=%jd\n", (intmax_t)startblock);
DEBUGASSERT(priv != NULL && buffer != NULL);
/* Check if the card is locked */
if (priv->locked)
{
ferr("ERROR: Card is locked\n");
return -EPERM;
}
#if defined(CONFIG_SDIO_DMA) && defined(CONFIG_ARCH_HAVE_SDIO_PREFLIGHT)
/* If we think we are going to perform a DMA transfer, make sure that we
* will be able to before we commit the card to the operation.
*/
if ((priv->caps & SDIO_CAPS_DMASUPPORTED) != 0)
{
ret = SDIO_DMAPREFLIGHT(priv->dev, buffer, priv->blocksize);
if (ret != OK)
{
return ret;
}
}
#endif
/* Verify that the card is ready for the transfer. The card may still be
* busy from the preceding write transfer. It would be simpler to check
* for write busy at the end of each write, rather than at the beginning of
* each read AND write, but putting the busy-wait at the beginning of the
* transfer allows for more overlap and, hopefully, better performance
*/
ret = mmcsd_transferready(priv);
if (ret != OK)
{
ferr("ERROR: Card not ready: %d\n", ret);
return ret;
}
/* If this is a byte addressed SD card, then convert sector start sector
* number to a byte offset
*/
if (IS_BLOCK(priv->type))
{
offset = startblock;
}
else
{
offset = startblock << priv->blockshift;
}
finfo("offset=%jd\n", (intmax_t)offset);
/* Select the block size for the card */
ret = mmcsd_setblocklen(priv, priv->blocksize);
if (ret != OK)
{
ferr("ERROR: mmcsd_setblocklen failed: %d\n", ret);
return ret;
}
/* Configure SDIO controller hardware for the read transfer */
SDIO_BLOCKSETUP(priv->dev, priv->blocksize, 1);
SDIO_WAITENABLE(priv->dev,
SDIOWAIT_TRANSFERDONE | SDIOWAIT_TIMEOUT | SDIOWAIT_ERROR,
MMCSD_BLOCK_RDATADELAY);
#ifdef CONFIG_SDIO_DMA
if ((priv->caps & SDIO_CAPS_DMASUPPORTED) != 0)
{
ret = SDIO_DMARECVSETUP(priv->dev, buffer, priv->blocksize);
if (ret != OK)
{
finfo("SDIO_DMARECVSETUP: error %d\n", ret);
SDIO_CANCEL(priv->dev);
return ret;
}
}
else
#endif
{
SDIO_RECVSETUP(priv->dev, buffer, priv->blocksize);
}
/* Send CMD17, READ_SINGLE_BLOCK: Read a block of the size selected
* by the mmcsd_setblocklen() and verify that good R1 status is
* returned. The card state should change from Transfer to Sending-Data
* state.
*/
mmcsd_sendcmdpoll(priv, MMCSD_CMD17, offset);
ret = mmcsd_recv_r1(priv, MMCSD_CMD17);
if (ret != OK)
{
ferr("ERROR: mmcsd_recv_r1 for CMD17 failed: %d\n", ret);
SDIO_CANCEL(priv->dev);
return ret;
}
/* Then wait for the data transfer to complete */
ret = mmcsd_eventwait(priv, SDIOWAIT_TIMEOUT | SDIOWAIT_ERROR);
if (ret != OK)
{
ferr("ERROR: CMD17 transfer failed: %d\n", ret);
return ret;
}
/* Return value: One sector read */
return 1;
}
/****************************************************************************
* Name: mmcsd_readmultiple
*
* Description:
* Read multiple, contiguous blocks of data from the physical device.
*
****************************************************************************/
#if MMCSD_MULTIBLOCK_LIMIT != 1
static ssize_t mmcsd_readmultiple(FAR struct mmcsd_state_s *priv,
FAR uint8_t *buffer, off_t startblock,
size_t nblocks)
{
size_t nbytes = nblocks << priv->blockshift;
off_t offset;
int ret;
finfo("startblock=%jd nblocks=%zu\n", (intmax_t)startblock, nblocks);
DEBUGASSERT(priv != NULL && buffer != NULL && nblocks > 1);
/* Check if the card is locked */
if (priv->locked)
{
ferr("ERROR: Card is locked\n");
return -EPERM;
}
#if defined(CONFIG_SDIO_DMA) && defined(CONFIG_ARCH_HAVE_SDIO_PREFLIGHT)
/* If we think we are going to perform a DMA transfer, make sure that we
* will be able to before we commit the card to the operation.
*/
if ((priv->caps & SDIO_CAPS_DMASUPPORTED) != 0)
{
ret = SDIO_DMAPREFLIGHT(priv->dev, buffer, nbytes);
if (ret != OK)
{
return ret;
}
}
#endif
/* Verify that the card is ready for the transfer. The card may still be
* busy from the preceding write transfer. It would be simpler to check
* for write busy at the end of each write, rather than at the beginning of
* each read AND write, but putting the busy-wait at the beginning of the
* transfer allows for more overlap and, hopefully, better performance
*/
ret = mmcsd_transferready(priv);
if (ret != OK)
{
ferr("ERROR: Card not ready: %d\n", ret);
return ret;
}
/* If this is a byte addressed SD card, then convert both the total
* transfer size to bytes and the sector start sector number to a byte
* offset
*/
if (IS_BLOCK(priv->type))
{
offset = startblock;
}
else
{
offset = startblock << priv->blockshift;
}
finfo("nbytes=%zu byte offset=%jd\n", nbytes, (intmax_t)offset);
/* Select the block size for the card */
ret = mmcsd_setblocklen(priv, priv->blocksize);
if (ret != OK)
{
ferr("ERROR: mmcsd_setblocklen failed: %d\n", ret);
return ret;
}
/* Configure SDIO controller hardware for the read transfer */
SDIO_BLOCKSETUP(priv->dev, priv->blocksize, nblocks);
SDIO_WAITENABLE(priv->dev,
SDIOWAIT_TRANSFERDONE | SDIOWAIT_TIMEOUT | SDIOWAIT_ERROR,
nblocks * MMCSD_BLOCK_RDATADELAY);
#ifdef CONFIG_SDIO_DMA
if ((priv->caps & SDIO_CAPS_DMASUPPORTED) != 0)
{
ret = SDIO_DMARECVSETUP(priv->dev, buffer, nbytes);
if (ret != OK)
{
finfo("SDIO_DMARECVSETUP: error %d\n", ret);
SDIO_CANCEL(priv->dev);
return ret;
}
}
else
#endif
{
SDIO_RECVSETUP(priv->dev, buffer, nbytes);
}
/* Send CMD18, READ_MULT_BLOCK: Read a block of the size selected by
* the mmcsd_setblocklen() and verify that good R1 status is returned
*/
mmcsd_sendcmdpoll(priv, MMCSD_CMD18, offset);
ret = mmcsd_recv_r1(priv, MMCSD_CMD18);
if (ret != OK)
{
ferr("ERROR: mmcsd_recv_r1 for CMD18 failed: %d\n", ret);
SDIO_CANCEL(priv->dev);
return ret;
}
/* Wait for the transfer to complete */
ret = mmcsd_eventwait(priv, SDIOWAIT_TIMEOUT | SDIOWAIT_ERROR);
if (ret != OK)
{
ferr("ERROR: CMD18 transfer failed: %d\n", ret);
return ret;
}
/* Send STOP_TRANSMISSION */
ret = mmcsd_stoptransmission(priv);
if (ret != OK)
{
ferr("ERROR: mmcsd_stoptransmission failed: %d\n", ret);
}
/* On success, return the number of blocks read */
return nblocks;
}
#endif
/****************************************************************************
* Name: mmcsd_writesingle
*
* Description:
* Write a single block of data to the physical device.
*
****************************************************************************/
static ssize_t mmcsd_writesingle(FAR struct mmcsd_state_s *priv,
FAR const uint8_t *buffer, off_t startblock)
{
off_t offset;
int ret;
finfo("startblock=%jd\n", (intmax_t)startblock);
DEBUGASSERT(priv != NULL && buffer != NULL);
/* Check if the card is locked or write protected (either via software or
* via the mechanical write protect on the card)
*/
if (mmcsd_wrprotected(priv))
{
ferr("ERROR: Card is locked or write protected\n");
return -EPERM;
}
#if defined(CONFIG_SDIO_DMA) && defined(CONFIG_ARCH_HAVE_SDIO_PREFLIGHT)
/* If we think we are going to perform a DMA transfer, make sure that we
* will be able to before we commit the card to the operation.
*/
if ((priv->caps & SDIO_CAPS_DMASUPPORTED) != 0)
{
ret = SDIO_DMAPREFLIGHT(priv->dev, buffer, priv->blocksize);
if (ret != OK)
{
return ret;
}
}
#endif
/* Verify that the card is ready for the transfer. The card may still be
* busy from the preceding write transfer. It would be simpler to check
* for write busy at the end of each write, rather than at the beginning of
* each read AND write, but putting the busy-wait at the beginning of the
* transfer allows for more overlap and, hopefully, better performance
*/
ret = mmcsd_transferready(priv);
if (ret != OK)
{
ferr("ERROR: Card not ready: %d\n", ret);
return ret;
}
/* If this is a byte addressed SD card, then convert sector start sector
* number to a byte offset
*/
if (IS_BLOCK(priv->type))
{
offset = startblock;
}
else
{
offset = startblock << priv->blockshift;
}
finfo("offset=%jd\n", (intmax_t)offset);
/* Select the block size for the card */
ret = mmcsd_setblocklen(priv, priv->blocksize);
if (ret != OK)
{
ferr("ERROR: mmcsd_setblocklen failed: %d\n", ret);
return ret;
}
/* If Controller does not need DMA setup before the write then send CMD24
* now.
*/
if ((priv->caps & SDIO_CAPS_DMABEFOREWRITE) == 0)
{
/* Send CMD24, WRITE_BLOCK, and verify good R1 status is returned */
mmcsd_sendcmdpoll(priv, MMCSD_CMD24, offset);
ret = mmcsd_recv_r1(priv, MMCSD_CMD24);
if (ret != OK)
{
ferr("ERROR: mmcsd_recv_r1 for CMD24 failed: %d\n", ret);
return ret;
}
}
/* Configure SDIO controller hardware for the write transfer */
SDIO_BLOCKSETUP(priv->dev, priv->blocksize, 1);
SDIO_WAITENABLE(priv->dev,
SDIOWAIT_TRANSFERDONE | SDIOWAIT_TIMEOUT | SDIOWAIT_ERROR,
MMCSD_BLOCK_WDATADELAY);
#ifdef CONFIG_SDIO_DMA
if ((priv->caps & SDIO_CAPS_DMASUPPORTED) != 0)
{
ret = SDIO_DMASENDSETUP(priv->dev, buffer, priv->blocksize);
if (ret != OK)
{
finfo("SDIO_DMASENDSETUP: error %d\n", ret);
SDIO_CANCEL(priv->dev);
return ret;
}
}
else
#endif
{
SDIO_SENDSETUP(priv->dev, buffer, priv->blocksize);
}
/* If Controller needs DMA setup before write then only send CMD24 now. */
if ((priv->caps & SDIO_CAPS_DMABEFOREWRITE) != 0)
{
/* Send CMD24, WRITE_BLOCK, and verify good R1 status is returned */
mmcsd_sendcmdpoll(priv, MMCSD_CMD24, offset);
ret = mmcsd_recv_r1(priv, MMCSD_CMD24);
if (ret != OK)
{
ferr("ERROR: mmcsd_recv_r1 for CMD24 failed: %d\n", ret);
SDIO_CANCEL(priv->dev);
return ret;
}
}
/* Wait for the transfer to complete */
ret = mmcsd_eventwait(priv, SDIOWAIT_TIMEOUT | SDIOWAIT_ERROR);
if (ret != OK)
{
ferr("ERROR: CMD24 transfer failed: %d\n", ret);
return ret;
}
/* Flag that a write transfer is pending that we will have to check for
* write complete at the beginning of the next transfer.
*/
priv->wrbusy = true;
#if defined(CONFIG_MMCSD_SDIOWAIT_WRCOMPLETE)
/* Arm the write complete detection with timeout */
SDIO_WAITENABLE(priv->dev, SDIOWAIT_WRCOMPLETE | SDIOWAIT_TIMEOUT,
MMCSD_BLOCK_WDATADELAY);
#endif
/* On success, return the number of blocks written */
return 1;
}
/****************************************************************************
* Name: mmcsd_writemultiple
*
* Description:
* Write multiple, contiguous blocks of data to the physical device.
* This function expects that the data to be written is contained in
* one large buffer that is pointed to by buffer.
*
****************************************************************************/
#if MMCSD_MULTIBLOCK_LIMIT != 1
static ssize_t mmcsd_writemultiple(FAR struct mmcsd_state_s *priv,
FAR const uint8_t *buffer,
off_t startblock, size_t nblocks)
{
size_t nbytes = nblocks << priv->blockshift;
off_t offset;
int ret;
int evret = OK;
finfo("startblock=%jd nblocks=%zu\n", (intmax_t)startblock, nblocks);
DEBUGASSERT(priv != NULL && buffer != NULL && nblocks > 1);
/* Check if the card is locked or write protected (either via software or
* via the mechanical write protect on the card)
*/
if (mmcsd_wrprotected(priv))
{
ferr("ERROR: Card is locked or write protected\n");
return -EPERM;
}
#if defined(CONFIG_SDIO_DMA) && defined(CONFIG_ARCH_HAVE_SDIO_PREFLIGHT)
/* If we think we are going to perform a DMA transfer, make sure that we
* will be able to before we commit the card to the operation.
*/
if ((priv->caps & SDIO_CAPS_DMASUPPORTED) != 0)
{
ret = SDIO_DMAPREFLIGHT(priv->dev, buffer, nbytes);
if (ret != OK)
{
return ret;
}
}
#endif
/* Verify that the card is ready for the transfer. The card may still be
* busy from the preceding write transfer. It would be simpler to check
* for write busy at the end of each write, rather than at the beginning of
* each read AND write, but putting the busy-wait at the beginning of the
* transfer allows for more overlap and, hopefully, better performance
*/
ret = mmcsd_transferready(priv);
if (ret != OK)
{
ferr("ERROR: Card not ready: %d\n", ret);
return ret;
}
/* If this is a byte addressed SD card, then convert both the total
* transfer size to bytes and the sector start sector number to a byte
* offset
*/
if (IS_BLOCK(priv->type))
{
offset = startblock;
}
else
{
offset = startblock << priv->blockshift;
}
finfo("nbytes=%zu byte offset=%jd\n", nbytes, (intmax_t)offset);
/* Select the block size for the card */
ret = mmcsd_setblocklen(priv, priv->blocksize);
if (ret != OK)
{
ferr("ERROR: mmcsd_setblocklen failed: %d\n", ret);
return ret;
}
/* If this is an SD card, then send ACMD23 (SET_WR_BLK_ERASE_COUNT) just
* before sending CMD25 (WRITE_MULTIPLE_BLOCK). This sets the number of
* write blocks to be pre-erased and might make the following multiple
* block write command faster.
*/
if (IS_SD(priv->type))
{
/* Send CMD55, APP_CMD, a verify that good R1 status is returned */
mmcsd_sendcmdpoll(priv, SD_CMD55, (uint32_t)priv->rca << 16);
ret = mmcsd_recv_r1(priv, SD_CMD55);
if (ret != OK)
{
ferr("ERROR: mmcsd_recv_r1 for CMD55 (ACMD23) failed: %d\n", ret);
return ret;
}
/* Send CMD23, SET_WR_BLK_ERASE_COUNT, and verify that good R1 status
* is returned.
*/
mmcsd_sendcmdpoll(priv, SD_ACMD23, nblocks);
ret = mmcsd_recv_r1(priv, SD_ACMD23);
if (ret != OK)
{
ferr("ERROR: mmcsd_recv_r1 for ACMD23 failed: %d\n", ret);
return ret;
}
}
/* If Controller does not need DMA setup before the write then send CMD25
* now.
*/
if ((priv->caps & SDIO_CAPS_DMABEFOREWRITE) == 0)
{
/* Send CMD25, WRITE_MULTIPLE_BLOCK, and verify that good R1 status
* is returned
*/
mmcsd_sendcmdpoll(priv, MMCSD_CMD25, offset);
ret = mmcsd_recv_r1(priv, MMCSD_CMD25);
if (ret != OK)
{
ferr("ERROR: mmcsd_recv_r1 for CMD25 failed: %d\n", ret);
return ret;
}
}
/* Configure SDIO controller hardware for the write transfer */
SDIO_BLOCKSETUP(priv->dev, priv->blocksize, nblocks);
SDIO_WAITENABLE(priv->dev,
SDIOWAIT_TRANSFERDONE | SDIOWAIT_TIMEOUT | SDIOWAIT_ERROR,
nblocks * MMCSD_BLOCK_WDATADELAY);
#ifdef CONFIG_SDIO_DMA
if ((priv->caps & SDIO_CAPS_DMASUPPORTED) != 0)
{
ret = SDIO_DMASENDSETUP(priv->dev, buffer, nbytes);
if (ret != OK)
{
finfo("SDIO_DMASENDSETUP: error %d\n", ret);
SDIO_CANCEL(priv->dev);
return ret;
}
}
else
#endif
{
SDIO_SENDSETUP(priv->dev, buffer, nbytes);
}
/* If Controller needs DMA setup before write then only send CMD25 now. */
if ((priv->caps & SDIO_CAPS_DMABEFOREWRITE) != 0)
{
/* Send CMD25, WRITE_MULTIPLE_BLOCK, and verify that good R1 status
* is returned
*/
mmcsd_sendcmdpoll(priv, MMCSD_CMD25, offset);
ret = mmcsd_recv_r1(priv, MMCSD_CMD25);
if (ret != OK)
{
ferr("ERROR: mmcsd_recv_r1 for CMD25 failed: %d\n", ret);
SDIO_CANCEL(priv->dev);
return ret;
}
}
/* Wait for the transfer to complete */
evret = mmcsd_eventwait(priv, SDIOWAIT_TIMEOUT | SDIOWAIT_ERROR);
if (evret != OK)
{
ferr("ERROR: CMD25 transfer failed: %d\n", evret);
/* If we return from here, we probably leave the sd-card in
* Receive-data State. Instead, we will remember that
* an error occurred and try to execute the STOP_TRANSMISSION
* to put the sd-card back into Transfer State.
*/
}
/* Send STOP_TRANSMISSION */
ret = mmcsd_stoptransmission(priv);
if (evret != OK)
{
return evret;
}
if (ret != OK)
{
ferr("ERROR: mmcsd_stoptransmission failed: %d\n", ret);
return ret;
}
/* Flag that a write transfer is pending that we will have to check for
* write complete at the beginning of the next transfer.
*/
priv->wrbusy = true;
#if defined(CONFIG_MMCSD_SDIOWAIT_WRCOMPLETE)
/* Arm the write complete detection with timeout */
SDIO_WAITENABLE(priv->dev, SDIOWAIT_WRCOMPLETE | SDIOWAIT_TIMEOUT,
nblocks * MMCSD_BLOCK_WDATADELAY);
#endif
/* On success, return the number of blocks written */
return nblocks;
}
#endif
/****************************************************************************
* Name: mmcsd_open
*
* Description: Open the block device
*
****************************************************************************/
static int mmcsd_open(FAR struct inode *inode)
{
FAR struct mmcsd_state_s *priv;
int ret;
finfo("Entry\n");
DEBUGASSERT(inode && inode->i_private);
priv = (FAR struct mmcsd_state_s *)inode->i_private;
/* Just increment the reference count on the driver */
DEBUGASSERT(priv->crefs < MAX_CREFS);
ret = mmcsd_lock(priv);
if (ret < 0)
{
return ret;
}
priv->crefs++;
mmcsd_unlock(priv);
return OK;
}
/****************************************************************************
* Name: mmcsd_close
*
* Description: close the block device
*
****************************************************************************/
static int mmcsd_close(FAR struct inode *inode)
{
FAR struct mmcsd_state_s *priv;
int ret;
finfo("Entry\n");
DEBUGASSERT(inode && inode->i_private);
priv = (FAR struct mmcsd_state_s *)inode->i_private;
/* Decrement the reference count on the block driver */
DEBUGASSERT(priv->crefs > 0);
ret = mmcsd_lock(priv);
if (ret < 0)
{
return ret;
}
priv->crefs--;
mmcsd_unlock(priv);
return OK;
}
/****************************************************************************
* Name: mmcsd_read
*
* Description:
* Read the specified number of sectors from the read-ahead buffer or from
* the physical device.
*
****************************************************************************/
static ssize_t mmcsd_read(FAR struct inode *inode, unsigned char *buffer,
blkcnt_t startsector, unsigned int nsectors)
{
FAR struct mmcsd_state_s *priv;
size_t sector;
size_t endsector;
ssize_t nread;
ssize_t ret = nsectors;
DEBUGASSERT(inode && inode->i_private);
priv = (FAR struct mmcsd_state_s *)inode->i_private;
finfo("startsector: %" PRIuOFF " nsectors: %u sectorsize: %d\n",
startsector, nsectors, priv->blocksize);
if (nsectors > 0)
{
ret = mmcsd_lock(priv);
if (ret < 0)
{
return ret;
}
ret = nsectors;
endsector = startsector + nsectors;
for (sector = startsector; sector < endsector; sector += nread)
{
/* Read this sector into the user buffer */
#if MMCSD_MULTIBLOCK_LIMIT == 1
/* Read each block using only the single block transfer method */
nread = mmcsd_readsingle(priv, buffer, sector);
#else
nread = endsector - sector;
if (nread > MMCSD_MULTIBLOCK_LIMIT)
{
nread = MMCSD_MULTIBLOCK_LIMIT;
}
if (nread == 1)
{
nread = mmcsd_readsingle(priv, buffer, sector);
}
else
{
nread = mmcsd_readmultiple(priv, buffer, sector, nread);
}
#endif
if (nread < 0)
{
ret = nread;
break;
}
/* Increment the buffer pointer by the sector size */
buffer += nread * priv->blocksize;
}
mmcsd_unlock(priv);
}
/* On success, return the number of blocks read */
return ret;
}
/****************************************************************************
* Name: mmcsd_write
*
* Description:
* Write the specified number of sectors to the write buffer or to the
* physical device.
*
****************************************************************************/
static ssize_t mmcsd_write(FAR struct inode *inode,
FAR const unsigned char *buffer,
blkcnt_t startsector, unsigned int nsectors)
{
FAR struct mmcsd_state_s *priv;
size_t sector;
size_t endsector;
ssize_t nwrite;
ssize_t ret = nsectors;
DEBUGASSERT(inode && inode->i_private);
priv = (FAR struct mmcsd_state_s *)inode->i_private;
finfo("startsector: %" PRIuOFF " nsectors: %u sectorsize: %d\n",
startsector, nsectors, priv->blocksize);
if (nsectors > 0)
{
ret = mmcsd_lock(priv);
if (ret < 0)
{
return ret;
}
ret = nsectors;
endsector = startsector + nsectors;
for (sector = startsector; sector < endsector; sector += nwrite)
{
/* Write this sector into the user buffer */
#if MMCSD_MULTIBLOCK_LIMIT == 1
/* Write each block using only the single block transfer method */
nwrite = mmcsd_writesingle(priv, buffer, sector);
#else
nwrite = endsector - sector;
if (nwrite > MMCSD_MULTIBLOCK_LIMIT)
{
nwrite = MMCSD_MULTIBLOCK_LIMIT;
}
if (nwrite == 1)
{
nwrite = mmcsd_writesingle(priv, buffer, sector);
}
else
{
nwrite = mmcsd_writemultiple(priv, buffer, sector, nwrite);
}
#endif
if (nwrite < 0)
{
ret = nwrite;
break;
}
/* Increment the buffer pointer by the sector size */
buffer += nwrite * priv->blocksize;
}
mmcsd_unlock(priv);
}
/* On success, return the number of blocks written */
return ret;
}
/****************************************************************************
* Name: mmcsd_geometry
*
* Description: Return device geometry
*
****************************************************************************/
static int mmcsd_geometry(FAR struct inode *inode, struct geometry *geometry)
{
FAR struct mmcsd_state_s *priv;
int ret = -EINVAL;
finfo("Entry\n");
DEBUGASSERT(inode && inode->i_private);
if (geometry)
{
memset(geometry, 0, sizeof(*geometry));
/* Is there a (supported) card inserted in the slot? */
priv = (FAR struct mmcsd_state_s *)inode->i_private;
ret = mmcsd_lock(priv);
if (ret < 0)
{
return ret;
}
if (IS_EMPTY(priv))
{
/* No.. return ENODEV */
finfo("IS_EMPTY\n");
ret = -ENODEV;
}
else
{
/* Yes.. return the geometry of the card */
geometry->geo_available = true;
geometry->geo_mediachanged = priv->mediachanged;
geometry->geo_writeenabled = !mmcsd_wrprotected(priv);
geometry->geo_nsectors = priv->nblocks;
geometry->geo_sectorsize = priv->blocksize;
finfo("available: true mediachanged: %s writeenabled: %s\n",
geometry->geo_mediachanged ? "true" : "false",
geometry->geo_writeenabled ? "true" : "false");
finfo("nsectors: %lu sectorsize: %" PRIi16 "\n",
(unsigned long)geometry->geo_nsectors,
geometry->geo_sectorsize);
priv->mediachanged = false;
ret = OK;
}
mmcsd_unlock(priv);
}
return ret;
}
/****************************************************************************
* Name: mmcsd_ioctl
*
* Description: Return device geometry
*
****************************************************************************/
static int mmcsd_ioctl(FAR struct inode *inode, int cmd, unsigned long arg)
{
FAR struct mmcsd_state_s *priv;
int ret;
finfo("Entry\n");
DEBUGASSERT(inode && inode->i_private);
priv = (FAR struct mmcsd_state_s *)inode->i_private;
/* Process the IOCTL by command */
ret = mmcsd_lock(priv);
if (ret < 0)
{
return ret;
}
switch (cmd)
{
case BIOC_PROBE: /* Check for media in the slot */
{
finfo("BIOC_PROBE\n");
/* Probe the MMC/SD slot for media */
ret = mmcsd_probe(priv);
if (ret != OK)
{
ferr("ERROR: mmcsd_probe failed: %d\n", ret);
}
}
break;
case BIOC_EJECT: /* Media has been removed from the slot */
{
finfo("BIOC_EJECT\n");
/* Process the removal of the card */
ret = mmcsd_removed(priv);
if (ret != OK)
{
ferr("ERROR: mmcsd_removed failed: %d\n", ret);
}
/* Enable logic to detect if a card is re-inserted */
SDIO_CALLBACKENABLE(priv->dev, SDIOMEDIA_INSERTED);
}
break;
#ifdef CONFIG_MMCSD_IOCSUPPORT
case MMC_IOC_CMD: /* MMCSD device ioctl commands */
{
finfo("MMC_IOC_CMD\n");
ret = mmcsd_iocmd(priv, (FAR struct mmc_ioc_cmd *)arg);
if (ret != OK)
{
ferr("ERROR: mmcsd_iocmd failed: %d\n", ret);
}
}
break;
case MMC_IOC_MULTI_CMD: /* MMCSD device ioctl muti commands */
{
finfo("MMC_IOC_MULTI_CMD\n");
ret = mmcsd_multi_iocmd(priv, (FAR struct mmc_ioc_multi_cmd *)arg);
if (ret != OK)
{
ferr("ERROR: mmcsd_iocmd failed: %d\n", ret);
}
}
break;
#endif
default:
ret = -ENOTTY;
break;
}
mmcsd_unlock(priv);
return ret;
}
/****************************************************************************
* Initialization/uninitialization/reset
****************************************************************************/
/****************************************************************************
* Name: mmcsd_mediachange
*
* Description:
* This is a callback function from the SDIO driver that indicates that
* there has been a change in the slot... either a card has been inserted
* or a card has been removed.
*
* Assumptions:
* This callback is NOT supposd to run in the context of an interrupt
* handler; it is probably running in the context of work thread.
*
****************************************************************************/
static void mmcsd_mediachange(FAR void *arg)
{
FAR struct mmcsd_state_s *priv = (FAR struct mmcsd_state_s *)arg;
int ret;
finfo("arg: %p\n", arg);
DEBUGASSERT(priv);
/* Is there a card present in the slot? */
ret = mmcsd_lock(priv);
if (ret < 0)
{
return;
}
if (SDIO_PRESENT(priv->dev))
{
/* Yes... process the card insertion. This could cause chaos if we
* think that a card is already present and there are mounted file
* systems! NOTE that mmcsd_probe() will always re-enable callbacks
* appropriately.
*/
mmcsd_probe(priv);
}
else
{
/* No... process the card removal. This could have very bad
* implications for any mounted file systems! NOTE that
* mmcsd_removed() does NOT re-enable callbacks so we will need to
* do that here.
*/
mmcsd_removed(priv);
/* Enable logic to detect if a card is re-inserted */
SDIO_CALLBACKENABLE(priv->dev, SDIOMEDIA_INSERTED);
}
mmcsd_unlock(priv);
}
/****************************************************************************
* Name: mmcsd_widebus
*
* Description:
* An SD card has been inserted and its SCR has been obtained. Select wide
* (4-bit) bus operation if the card supports it.
*
* Assumptions:
* This function is called only once per card insertion as part of the SD
* card initialization sequence. It is not necessary to reselect the card
* there is not need to check if wide bus operation has already been
* selected.
*
****************************************************************************/
static int mmcsd_widebus(FAR struct mmcsd_state_s *priv)
{
int ret;
/* Check if the SD card supports wide bus operation (as reported in the
* SCR or in the SDIO driver capabililities)
*/
if (IS_SD(priv->type) &&
(priv->buswidth & MMCSD_SCR_BUSWIDTH_4BIT) != 0 &&
(priv->caps & SDIO_CAPS_1BIT_ONLY) == 0)
{
/* SD card supports 4-bit BUS and host settings is not 1-bit only. */
finfo("Setting SD BUS width to 4-bit. Card type: %d\n", priv->type);
/* Disconnect any CD/DAT3 pull up using ACMD42. ACMD42 is optional and
* need not be supported by all SD calls.
*
* First end CMD55 APP_CMD with argument as card's RCA.
*/
mmcsd_sendcmdpoll(priv, SD_CMD55, (uint32_t)priv->rca << 16);
ret = mmcsd_recv_r1(priv, SD_CMD55);
if (ret != OK)
{
ferr("ERROR: RECVR1 for CMD55 of ACMD42: %d\n", ret);
return ret;
}
/* Then send ACMD42 with the argument to disconnect the CD/DAT3
* pull-up
*
* TODO: May want to disable, then re-enable around data transfers
* to support card detection"
*/
mmcsd_sendcmdpoll(priv, SD_ACMD42, MMCSD_ACMD42_CD_DISCONNECT);
ret = mmcsd_recv_r1(priv, SD_ACMD42);
if (ret != OK)
{
fwarn("WARNING: SD card does not support ACMD42: %d\n", ret);
return ret;
}
/* Now send ACMD6 to select bus width operation, beginning
* with CMD55, APP_CMD:
*/
mmcsd_sendcmdpoll(priv, SD_CMD55, (uint32_t)priv->rca << 16);
ret = mmcsd_recv_r1(priv, SD_CMD55);
if (ret != OK)
{
ferr("ERROR: RECVR1 for CMD55 of ACMD6: %d\n", ret);
return ret;
}
/* Then send ACMD6 */
mmcsd_sendcmdpoll(priv, SD_ACMD6, MMCSD_ACMD6_BUSWIDTH_4);
ret = mmcsd_recv_r1(priv, SD_ACMD6);
if (ret != OK)
{
return ret;
}
}
#ifdef CONFIG_MMCSD_MMCSUPPORT
else if (IS_MMC(priv->type) &&
((priv->buswidth & MMCSD_SCR_BUSWIDTH_4BIT) != 0 &&
(priv->caps & SDIO_CAPS_1BIT_ONLY) == 0))
{
/* SD card supports 4-bit BUS and host settings is not 1-bit only.
* Configuring MMC - Use MMC_SWITCH access modes.
*/
mmcsd_sendcmdpoll(priv, MMCSD_CMD6,
MMCSD_CMD6_MODE_WRITE_BYTE | MMCSD_CMD6_BUSWIDTH_RW |
MMCSD_CMD6_BUS_WIDTH_4);
ret = mmcsd_recv_r1(priv, MMCSD_CMD6);
if (ret != OK)
{
ferr("ERROR: (MMCSD_CMD6) Setting MMC BUS width: %d\n", ret);
return ret;
}
}
#endif /* #ifdef CONFIG_MMCSD_MMCSUPPORT */
else
{
fwarn("No card inserted.\n");
SDIO_WIDEBUS(priv->dev, false);
priv->widebus = false;
SDIO_CLOCK(priv->dev, CLOCK_SDIO_DISABLED);
nxsig_usleep(MMCSD_CLK_DELAY);
return OK;
}
/* Configure the SDIO peripheral */
if ((priv->buswidth & MMCSD_SCR_BUSWIDTH_4BIT) != 0)
{
finfo("Wide bus operation selected\n");
SDIO_WIDEBUS(priv->dev, true);
priv->widebus = true;
}
else
{
finfo("Narrow bus operation selected\n");
SDIO_WIDEBUS(priv->dev, false);
priv->widebus = false;
}
if (IS_SD(priv->type))
{
if ((priv->buswidth & MMCSD_SCR_BUSWIDTH_4BIT) != 0)
{
SDIO_CLOCK(priv->dev, CLOCK_SD_TRANSFER_4BIT);
}
else
{
SDIO_CLOCK(priv->dev, CLOCK_SD_TRANSFER_1BIT);
}
}
#ifdef CONFIG_MMCSD_MMCSUPPORT
else
{
SDIO_CLOCK(priv->dev, CLOCK_MMC_TRANSFER);
}
#endif /* #ifdef CONFIG_MMCSD_MMCSUPPORT */
nxsig_usleep(MMCSD_CLK_DELAY);
return OK;
}
/****************************************************************************
* Name: mmcsd_mmcinitialize
*
* Description:
* We believe that there is an MMC card in the slot. Attempt to initialize
* and configure the MMC card. This is called only from mmcsd_probe().
*
****************************************************************************/
#ifdef CONFIG_MMCSD_MMCSUPPORT
static int mmcsd_mmcinitialize(FAR struct mmcsd_state_s *priv)
{
uint32_t cid[4];
uint32_t csd[4];
int ret;
/* At this point, slow, ID mode clocking has been supplied to the card
* and CMD0 has been sent successfully. CMD1 succeeded and ACMD41 failed
* so there is good evidence that we have an MMC card inserted into the
* slot.
*
* Send CMD2, ALL_SEND_CID. This implementation supports only one MMC
* slot. If multiple cards were installed, each card would respond to
* CMD2 by sending its CID (only one card completes the response at a
* time). The driver should send CMD2 and assign an RCAs until no
* response to ALL_SEND_CID is received. CMD2 causes transition to
* identification state / card-identification mode.
*/
finfo("Initialising MMC card.\n");
mmcsd_sendcmdpoll(priv, MMCSD_CMD2, 0);
ret = SDIO_RECVR2(priv->dev, MMCSD_CMD2, cid);
if (ret != OK)
{
ferr("ERROR: SDIO_RECVR2 for MMC CID failed: %d\n", ret);
return ret;
}
mmcsd_decode_cid(priv, cid);
/* Send CMD3, SET_RELATIVE_ADDR. This command is used to assign a logical
* address to the card. For MMC, the host assigns the address. CMD3 causes
* transition to standby state/data-transfer mode
*/
priv->rca = 1; /* There is only one card */
mmcsd_sendcmdpoll(priv, MMC_CMD3, (uint32_t)priv->rca << 16);
ret = mmcsd_recv_r1(priv, MMC_CMD3);
if (ret != OK)
{
ferr("ERROR: mmcsd_recv_r1(CMD3) failed: %d\n", ret);
return ret;
}
/* This should have caused a transition to standby state. However, this
* will not be reflected in the present R1/6 status. R1/6 contains the
* state of the card when the command was received, not when it
* completed execution.
*
* Verify that we are in standby state/data-transfer mode
*/
ret = mmcsd_verifystate(priv, MMCSD_R1_STATE_STBY);
if (ret != OK)
{
ferr("ERROR: Failed to enter standby state\n");
return ret;
}
/* Send CMD9, SEND_CSD in standby state/data-transfer mode to obtain the
* Card Specific Data (CSD) register, e.g., block length, card storage
* capacity, etc. (Stays in standby state/data-transfer mode).
* NOTE in v2.0 high capacity cards, the following values are always
* returned:
* - write block length = 9 = 2^9 = 512
* - read block length = 9 = 512
* - rw2 factor = 0x2 (010b)
* - size_mult = 0
* We can't decode the CSD register yet as we also need to read the
* extended CSD register.
*/
mmcsd_sendcmdpoll(priv, MMCSD_CMD9, (uint32_t)priv->rca << 16);
ret = SDIO_RECVR2(priv->dev, MMCSD_CMD9, csd);
if (ret != OK)
{
ferr("ERROR: Could not get SD CSD register: %d\n", ret);
return ret;
}
/* Decode the CSD register to obtain version. We will need to
* decode further if card is v4.0 or higher as it supports
* ext_csd commands.
*/
mmcsd_decode_csd(priv, csd);
/* Set the Driver Stage Register (DSR) if (1) a CONFIG_MMCSD_DSR has been
* provided and (2) the card supports a DSR register. If no DSR value
* the card default value (0x0404) will be used.
*/
mmcsd_sendcmd4(priv);
/* Select the card.
* Send CMD7 with the argument == RCA in order to select the card
* and send it in data-trasfer mode. Since we are supporting
* only a single card, we just leave the card selected all of the time.
*/
mmcsd_sendcmdpoll(priv, MMCSD_CMD7S, (uint32_t)priv->rca << 16);
ret = mmcsd_recv_r1(priv, MMCSD_CMD7S);
if (ret != OK)
{
ferr("ERROR: mmcsd_recv_r1 for CMD7 failed: %d\n", ret);
return ret;
}
/* If the hardware only supports 4-bit transfer mode then we forced to
* attempt to setup the card in this mode before checking the ext CSD
* register.
*/
if ((priv->caps & SDIO_CAPS_4BIT_ONLY) != 0)
{
/* Select width (4-bit) bus operation */
priv->buswidth = MMCSD_SCR_BUSWIDTH_4BIT;
ret = mmcsd_widebus(priv);
if (ret != OK)
{
ferr("ERROR: Failed to set wide bus operation: %d\n", ret);
}
}
/* CSD Decoding for MMC should be done after entering in data-transfer mode
* because if the card has block addressing then extended CSD register
* must be read in order to get the right number of blocks and capacity,
* and BUS width but it has to be done in data-transfer mode.
*/
if (IS_BLOCK(priv->type))
{
finfo("Card supports eMMC spec 4.0 (or greater). Reading ext_csd.\n");
ret = mmcsd_read_csd(priv);
if (ret != OK)
{
ferr("ERROR: Failed to determinate number of blocks: %d\n", ret);
return ret;
}
}
mmcsd_decode_csd(priv, csd);
if ((priv->caps & SDIO_CAPS_4BIT_ONLY) != 0)
{
/* Select width (4-bit) bus operation (if the card supports it) */
ret = mmcsd_widebus(priv);
if (ret != OK)
{
ferr("ERROR: Failed to set wide bus operation: %d\n", ret);
}
}
return OK;
}
/****************************************************************************
* Name: mmcsd_read_csd
*
* Description:
* MMC card is detected with block addressing and this function will read
* the correct number of blocks and capacity. Returns OK if ext CSD is read
* correctly or error in not.
*
* Note: For some MCU architectures, buffer[] must be aligned.
*
****************************************************************************/
static int mmcsd_read_csd(FAR struct mmcsd_state_s *priv)
{
uint8_t buffer[512] aligned_data(16);
int ret;
DEBUGASSERT(priv != NULL);
/* Check if the card is locked */
if (priv->locked)
{
ferr("ERROR: Card is locked\n");
return -EPERM;
}
memset(buffer, 0, sizeof(buffer));
#if defined(CONFIG_SDIO_DMA) && defined(CONFIG_ARCH_HAVE_SDIO_PREFLIGHT)
/* If we think we are going to perform a DMA transfer, make sure that we
* will be able to before we commit the card to the operation.
*/
if ((priv->caps & SDIO_CAPS_DMASUPPORTED) != 0)
{
ret = SDIO_DMAPREFLIGHT(priv->dev, buffer, priv->blocksize);
if (ret != OK)
{
return ret;
}
}
#endif
/* Verify that the card is ready for the transfer. The card may still be
* busy from the preceding write transfer. It would be simpler to check
* for write busy at the end of each write, rather than at the beginning of
* each read AND write, but putting the busy-wait at the beginning of the
* transfer allows for more overlap and, hopefully, better performance
*/
ret = mmcsd_transferready(priv);
if (ret != OK)
{
ferr("ERROR: Card not ready: %d\n", ret);
return ret;
}
/* Select the block size for the card (CMD16) */
ret = mmcsd_setblocklen(priv, 512);
if (ret != OK)
{
ferr("ERROR: mmcsd_setblocklen failed: %d\n", ret);
return ret;
}
/* Configure SDIO controller hardware for the read transfer */
SDIO_BLOCKSETUP(priv->dev, 512, 1);
SDIO_WAITENABLE(priv->dev,
SDIOWAIT_TRANSFERDONE | SDIOWAIT_TIMEOUT | SDIOWAIT_ERROR,
MMCSD_BLOCK_RDATADELAY);
#ifdef CONFIG_SDIO_DMA
if ((priv->caps & SDIO_CAPS_DMASUPPORTED) != 0)
{
finfo("Setting up for DMA transfer.\n");
ret = SDIO_DMARECVSETUP(priv->dev, buffer, 512);
if (ret != OK)
{
finfo("SDIO_DMARECVSETUP: error %d\n", ret);
SDIO_CANCEL(priv->dev);
return ret;
}
}
else
#endif
{
SDIO_RECVSETUP(priv->dev, buffer, 512);
}
/* Send CMD8 in data-transfer mode to obtain the
* extended Card Specific Data (CSD) register, e.g., block length, card
* storage capacity, etc.
*/
mmcsd_sendcmdpoll(priv, MMC_CMD8, 0);
ret = mmcsd_recv_r1(priv, MMC_CMD8);
if (ret != OK)
{
ferr("ERROR: Could not get MMC extended CSD register: %d\n", ret);
SDIO_CANCEL(priv->dev);
return ret;
}
/* Then wait for the data transfer to complete */
ret = mmcsd_eventwait(priv, SDIOWAIT_TIMEOUT | SDIOWAIT_ERROR);
if (ret != OK)
{
ferr("ERROR: CMD17 transfer failed: %d\n", ret);
return ret;
}
priv->nblocks = (buffer[215] << 24) | (buffer[214] << 16) |
(buffer[213] << 8) | buffer[212];
finfo("MMC ext CSD read succsesfully, number of block %" PRId32 "\n",
priv->nblocks);
SDIO_GOTEXTCSD(priv->dev, buffer);
/* Return value: One sector read */
return OK;
}
#endif
/****************************************************************************
* Name: mmcsd_general_cmd_write
*
* Description:
* Send cmd56 data, one sector size
*
****************************************************************************/
static int mmcsd_general_cmd_write(FAR struct mmcsd_state_s *priv,
FAR const uint8_t *buffer,
off_t startblock)
{
int ret;
DEBUGASSERT(priv != NULL && buffer != NULL);
/* Check if the card is locked or write protected (either via software or
* via the mechanical write protect on the card)
*/
if (mmcsd_wrprotected(priv))
{
ferr("ERROR: Card is locked or write protected\n");
return -EPERM;
}
#if defined(CONFIG_SDIO_DMA) && defined(CONFIG_ARCH_HAVE_SDIO_PREFLIGHT)
/* If we think we are going to perform a DMA transfer, make sure that we
* will be able to before we commit the card to the operation.
*/
if ((priv->caps & SDIO_CAPS_DMASUPPORTED) != 0)
{
ret = SDIO_DMAPREFLIGHT(priv->dev, buffer, priv->blocksize);
if (ret != OK)
{
return ret;
}
}
#endif
/* Verify that the card is ready for the transfer. The card may still be
* busy from the preceding write transfer. It would be simpler to check
* for write busy at the end of each write, rather than at the beginning of
* each read AND write, but putting the busy-wait at the beginning of the
* transfer allows for more overlap and, hopefully, better performance
*/
ret = mmcsd_transferready(priv);
if (ret != OK)
{
ferr("ERROR: Card not ready: %d\n", ret);
return ret;
}
/* Select the block size for the card */
ret = mmcsd_setblocklen(priv, priv->blocksize);
if (ret != OK)
{
ferr("ERROR: mmcsd_setblocklen failed: %d\n", ret);
return ret;
}
/* If Controller does not need DMA setup before the write then send CMD56
* now.
*/
if ((priv->caps & SDIO_CAPS_DMABEFOREWRITE) == 0)
{
/* Send CMD56, WRITE_BLOCK, and verify good R1 status is returned */
mmcsd_sendcmdpoll(priv, MMCSD_CMD56WR, startblock);
ret = mmcsd_recv_r1(priv, MMCSD_CMD56WR);
if (ret != OK)
{
ferr("ERROR: mmcsd_recv_r1 for CMD56 failed: %d\n", ret);
return ret;
}
}
/* Configure SDIO controller hardware for the write transfer */
SDIO_BLOCKSETUP(priv->dev, priv->blocksize, 1);
SDIO_WAITENABLE(priv->dev,
SDIOWAIT_TRANSFERDONE | SDIOWAIT_TIMEOUT | SDIOWAIT_ERROR,
MMCSD_BLOCK_WDATADELAY);
#ifdef CONFIG_SDIO_DMA
if ((priv->caps & SDIO_CAPS_DMASUPPORTED) != 0)
{
ret = SDIO_DMASENDSETUP(priv->dev, buffer, priv->blocksize);
if (ret != OK)
{
finfo("SDIO_DMASENDSETUP: error %d\n", ret);
SDIO_CANCEL(priv->dev);
return ret;
}
}
else
#endif
{
SDIO_SENDSETUP(priv->dev, buffer, priv->blocksize);
}
/* If Controller needs DMA setup before write then only send CMD24 now. */
if ((priv->caps & SDIO_CAPS_DMABEFOREWRITE) != 0)
{
/* Send CMD56, WRITE_BLOCK, and verify good R1 status is returned */
mmcsd_sendcmdpoll(priv, MMCSD_CMD56WR, startblock);
ret = mmcsd_recv_r1(priv, MMCSD_CMD56WR);
if (ret != OK)
{
ferr("ERROR: mmcsd_recv_r1 for CMD56 failed: %d\n", ret);
SDIO_CANCEL(priv->dev);
return ret;
}
}
/* Wait for the transfer to complete */
ret = mmcsd_eventwait(priv, SDIOWAIT_TIMEOUT | SDIOWAIT_ERROR);
if (ret != OK)
{
ferr("ERROR: CMD56 transfer failed: %d\n", ret);
return ret;
}
/* Flag that a write transfer is pending that we will have to check for
* write complete at the beginning of the next transfer.
*/
priv->wrbusy = true;
#if defined(CONFIG_MMCSD_SDIOWAIT_WRCOMPLETE)
/* Arm the write complete detection with timeout */
SDIO_WAITENABLE(priv->dev, SDIOWAIT_WRCOMPLETE | SDIOWAIT_TIMEOUT,
MMCSD_BLOCK_WDATADELAY);
#endif
/* On success, return OK */
return OK;
}
/****************************************************************************
* Name: mmcsd_general_cmd_read
*
* Description:
* Read cmd56 data, one sector size
*
****************************************************************************/
static int mmcsd_general_cmd_read(FAR struct mmcsd_state_s *priv,
FAR uint8_t *buffer, off_t startblock)
{
int ret;
DEBUGASSERT(priv != NULL && buffer != NULL);
/* Check if the card is locked */
if (priv->locked)
{
ferr("ERROR: Card is locked\n");
return -EPERM;
}
#if defined(CONFIG_SDIO_DMA) && defined(CONFIG_ARCH_HAVE_SDIO_PREFLIGHT)
/* If we think we are going to perform a DMA transfer, make sure that we
* will be able to before we commit the card to the operation.
*/
if ((priv->caps & SDIO_CAPS_DMASUPPORTED) != 0)
{
ret = SDIO_DMAPREFLIGHT(priv->dev, buffer, priv->blocksize);
if (ret != OK)
{
return ret;
}
}
#endif
/* Verify that the card is ready for the transfer. The card may still be
* busy from the preceding write transfer. It would be simpler to check
* for write busy at the end of each write, rather than at the beginning of
* each read AND write, but putting the busy-wait at the beginning of the
* transfer allows for more overlap and, hopefully, better performance
*/
ret = mmcsd_transferready(priv);
if (ret != OK)
{
ferr("ERROR: Card not ready: %d\n", ret);
return ret;
}
/* Select the block size for the card */
ret = mmcsd_setblocklen(priv, priv->blocksize);
if (ret != OK)
{
ferr("ERROR: mmcsd_setblocklen failed: %d\n", ret);
return ret;
}
/* Configure SDIO controller hardware for the read transfer */
SDIO_BLOCKSETUP(priv->dev, priv->blocksize, 1);
SDIO_WAITENABLE(priv->dev,
SDIOWAIT_TRANSFERDONE | SDIOWAIT_TIMEOUT | SDIOWAIT_ERROR,
MMCSD_BLOCK_RDATADELAY);
#ifdef CONFIG_SDIO_DMA
if ((priv->caps & SDIO_CAPS_DMASUPPORTED) != 0)
{
ret = SDIO_DMARECVSETUP(priv->dev, buffer, priv->blocksize);
if (ret != OK)
{
finfo("SDIO_DMARECVSETUP: error %d\n", ret);
SDIO_CANCEL(priv->dev);
return ret;
}
}
else
#endif
{
SDIO_RECVSETUP(priv->dev, buffer, priv->blocksize);
}
/* Send CMD56: Read a sector size data and verify that good R1
* status is returned.
*/
mmcsd_sendcmdpoll(priv, MMCSD_CMD56RD, startblock);
ret = mmcsd_recv_r1(priv, MMCSD_CMD56RD);
if (ret != OK)
{
ferr("ERROR: mmcsd_recv_r1 for CMD56 failed: %d\n", ret);
SDIO_CANCEL(priv->dev);
return ret;
}
/* Then wait for the data transfer to complete */
ret = mmcsd_eventwait(priv, SDIOWAIT_TIMEOUT | SDIOWAIT_ERROR);
if (ret != OK)
{
ferr("ERROR: CMD56 transfer failed: %d\n", ret);
return ret;
}
/* Return value: OK */
return OK;
}
#ifdef CONFIG_MMCSD_IOCSUPPORT
/****************************************************************************
* Name: mmcsd_iocmd
*
* Description:
* MMCSD device ioctl commands.
*
****************************************************************************/
static int mmcsd_iocmd(FAR struct mmcsd_state_s *priv,
FAR struct mmc_ioc_cmd *ic_ptr)
{
int ret;
DEBUGASSERT(priv != NULL && ic_ptr != NULL);
if (!ic_ptr->is_acmd)
{
uint32_t opcode = ic_ptr->opcode & MMCSD_CMDIDX_MASK;
switch (opcode)
{
case MMCSD_CMDIDX56: /* support general commands */
{
if (ic_ptr->write_flag)
{
ret = mmcsd_general_cmd_write(priv,
(FAR uint8_t *)(uintptr_t)(ic_ptr->data_ptr),
ic_ptr->arg);
if (ret != OK)
{
ferr("mmcsd_iocmd MMCSD_CMDIDX56 write failed.\n");
return ret;
}
}
else
{
ret = mmcsd_general_cmd_read(priv,
(FAR uint8_t *)(uintptr_t)(ic_ptr->data_ptr),
ic_ptr->arg);
if (ret != OK)
{
ferr("mmcsd_iocmd MMCSD_CMDIDX56 read failed.\n");
return ret;
}
}
}
break;
default:
ferr("mmcsd_iocmd opcode unsupported.\n");
return -EINVAL;
}
}
return OK;
}
/****************************************************************************
* Name: mmcsd_multi_iocmd
*
* Description:
* MMCSD device ioctl multi commands.
*
****************************************************************************/
static int mmcsd_multi_iocmd(FAR struct mmcsd_state_s *priv,
FAR struct mmc_ioc_multi_cmd *imc_ptr)
{
int ret;
int i;
DEBUGASSERT(priv != NULL && imc_ptr != NULL);
if (imc_ptr->num_of_cmds > MMC_IOC_MAX_CMDS)
{
ferr("mmcsd_multi_iocmd too many cmds.\n");
return -EINVAL;
}
for (i = 0; i < imc_ptr->num_of_cmds; ++i)
{
ret = mmcsd_iocmd(priv, &imc_ptr->cmds[i]);
if (ret != OK)
{
ferr("cmds %d failed.\n", i);
return ret;
}
}
return OK;
}
#endif
/****************************************************************************
* Name: mmcsd_sdinitialize
*
* Description:
* We believe that there is an SD card in the slot. Attempt to initialize
* and configure the SD card. This is called only from mmcsd_probe().
*
****************************************************************************/
static int mmcsd_sdinitialize(FAR struct mmcsd_state_s *priv)
{
uint32_t cid[4];
uint32_t csd[4];
uint32_t scr[2];
int ret;
/* At this point, clocking has been supplied to the card, both CMD0 and
* ACMD41 (with OCR=0) have been sent successfully, the card is no longer
* busy and (presumably) in the IDLE state so there is good evidence
* that we have an SD card inserted into the slot.
*
* Send CMD2, ALL_SEND_CID. The SD CMD2 is similar to the MMC CMD2 except
* that the buffer type used to transmit to response of the card (SD Memory
* Card: Push-Pull, MMC: Open-Drain). This implementation supports only a
* single SD card. If multiple cards were installed in the slot, each card
* would respond to CMD2 by sending its CID (only one card completes the
* response at a time). The driver should send CMD2 and obtain RCAs until
* no response to ALL_SEND_CID is received.
*
* When an SD card receives the CMD2 command it should transition to the
* identification state/card-identification mode
*/
mmcsd_sendcmdpoll(priv, MMCSD_CMD2, 0);
ret = SDIO_RECVR2(priv->dev, MMCSD_CMD2, cid);
if (ret != OK)
{
ferr("ERROR: SDIO_RECVR2 for SD CID failed: %d\n", ret);
return ret;
}
mmcsd_decode_cid(priv, cid);
/* Send CMD3, SEND_RELATIVE_ADDR. In both protocols, this command is used
* to assign a logical address to the card. For MMC, the host assigns the
* address; for SD, the memory card has this responsibility. CMD3 causes
* transition to standby state/data-transfer mode
*
* Send CMD3 with argument 0, SD card publishes its RCA in the response.
*/
mmcsd_sendcmdpoll(priv, SD_CMD3, 0);
ret = mmcsd_recv_r6(priv, SD_CMD3);
if (ret != OK)
{
ferr("ERROR: mmcsd_recv_r6 for SD RCA failed: %d\n", ret);
return ret;
}
finfo("RCA: %04x\n", priv->rca);
/* This should have caused a transition to standby state. However, this
* will not be reflected in the present R1/6 status. R1/6 contains the
* state of the card when the command was received, not when it
* completed execution.
*
* Verify that we are in standby state/data-transfer mode
*/
ret = mmcsd_verifystate(priv, MMCSD_R1_STATE_STBY);
if (ret != OK)
{
ferr("ERROR: Failed to enter standby state\n");
return ret;
}
/* Send CMD9, SEND_CSD, in standby state/data-transfer mode to obtain the
* Card Specific Data (CSD) register. The argument is the RCA that we
* just obtained from CMD3. The card stays in standby state/data-transfer
* mode.
*/
mmcsd_sendcmdpoll(priv, MMCSD_CMD9, (uint32_t)priv->rca << 16);
ret = SDIO_RECVR2(priv->dev, MMCSD_CMD9, csd);
if (ret != OK)
{
ferr("ERROR: Could not get SD CSD register(%d)\n", ret);
return ret;
}
mmcsd_decode_csd(priv, csd);
/* Send CMD7 with the argument == RCA in order to select the card.
* Since we are supporting only a single card, we just leave the
* card selected all of the time.
*/
mmcsd_sendcmdpoll(priv, MMCSD_CMD7S, (uint32_t)priv->rca << 16);
ret = mmcsd_recv_r1(priv, MMCSD_CMD7S);
if (ret != OK)
{
ferr("ERROR: mmcsd_recv_r1 for CMD7 failed: %d\n", ret);
return ret;
}
/* Set the Driver Stage Register (DSR) if (1) a CONFIG_MMCSD_DSR has been
* provided and (2) the card supports a DSR register. If no DSR value
* the card default value (0x0404) will be used.
*/
mmcsd_sendcmd4(priv);
/* Select high speed SD clocking (which may depend on the DSR setting) */
SDIO_CLOCK(priv->dev, CLOCK_SD_TRANSFER_1BIT);
nxsig_usleep(MMCSD_CLK_DELAY);
/* If the hardware only supports 4-bit transfer mode then we forced to
* attempt to setup the card in this mode before checking the SCR register.
*/
if ((priv->caps & SDIO_CAPS_4BIT_ONLY) != 0)
{
/* Select width (4-bit) bus operation */
priv->buswidth = MMCSD_SCR_BUSWIDTH_4BIT;
ret = mmcsd_widebus(priv);
if (ret != OK)
{
ferr("ERROR: Failed to set wide bus operation: %d\n", ret);
}
}
/* Get the SD card Configuration Register (SCR). We need this now because
* that configuration register contains the indication whether or not
* this card supports wide bus operation.
*/
ret = mmcsd_get_scr(priv, scr);
if (ret != OK)
{
ferr("ERROR: Could not get SD SCR register(%d)\n", ret);
return ret;
}
mmcsd_decode_scr(priv, scr);
if ((priv->caps & SDIO_CAPS_4BIT_ONLY) != 0)
{
/* Select width (4-bit) bus operation (if the card supports it) */
ret = mmcsd_widebus(priv);
if (ret != OK)
{
ferr("ERROR: Failed to set wide bus operation: %d\n", ret);
}
}
/* TODO: If wide-bus selected, then send CMD6 to see if the card supports
* high speed mode. A new SDIO method will be needed to set high speed
* mode.
*/
return OK;
}
/****************************************************************************
* Name: mmcsd_cardidentify
*
* Description:
* We believe that there is media in the slot. Attempt to initialize and
* configure the card. This is called only from mmcsd_probe().
*
****************************************************************************/
static int mmcsd_cardidentify(FAR struct mmcsd_state_s *priv)
{
uint32_t response;
uint32_t sdcapacity = MMCSD_ACMD41_STDCAPACITY;
#ifdef CONFIG_MMCSD_MMCSUPPORT
uint32_t mmccapacity = MMCSD_R3_HIGHCAPACITY;
#endif
clock_t start;
clock_t elapsed;
int ret;
finfo("Identifying card...\n");
/* Assume failure to identify the card */
priv->type = MMCSD_CARDTYPE_UNKNOWN;
/* Check if there is a card present in the slot. This is normally a
* matter is of GPIO sensing.
*/
if (!SDIO_PRESENT(priv->dev))
{
finfo("No card present\n");
return -ENODEV;
}
/* For eMMC, Send CMD0 with argument 0xf0f0f0f0 as per JEDEC v4.41
* for pre-idle. No effect for SD.
*/
mmcsd_sendcmdpoll(priv, MMCSD_CMD0, 0xf0f0f0f0);
nxsig_usleep(MMCSD_IDLE_DELAY);
/* Set ID mode clocking (<400KHz) */
SDIO_CLOCK(priv->dev, CLOCK_IDMODE);
/* After power up at least 74 clock cycles are required prior to starting
* bus communication
*/
up_udelay(MMCSD_POWERUP_DELAY);
/* Then send CMD0 just once is standard procedure */
mmcsd_sendcmdpoll(priv, MMCSD_CMD0, 0);
nxsig_usleep(MMCSD_IDLE_DELAY);
#ifdef CONFIG_MMCSD_MMCSUPPORT
/* Send CMD1 which is supported only by MMC. if there is valid response
* then the card is definitely of MMC type
*/
mmcsd_sendcmdpoll(priv, MMC_CMD1, MMCSD_VDD_33_34 | mmccapacity);
ret = SDIO_RECVR3(priv->dev, MMC_CMD1, &response);
/* Was the operating range set successfully */
if (ret != OK)
{
fwarn("WARNING: CMD1 RECVR3: %d. "
"NOTE: This is expected for SD cards.\n", ret);
/* CMD1 did not succeed, card is not MMC. Return to idle
* to allow the communication to recover before another send.
*/
mmcsd_sendcmdpoll(priv, MMCSD_CMD0, 0);
nxsig_usleep(MMCSD_IDLE_DELAY);
}
else
{
/* CMD1 succeeded... this must be an MMC card */
finfo("MMC card detected\n");
priv->type = MMCSD_CARDTYPE_MMC;
/* Now, check if this is a MMC card/chip that supports block
* addressing
*/
if ((response & MMCSD_R3_HIGHCAPACITY) != 0)
{
finfo("MMC card/chip with block addressing\n");
mmccapacity = MMCSD_R3_HIGHCAPACITY;
priv->type |= MMCSD_CARDTYPE_BLOCK;
}
else
{
mmccapacity = MMCSD_R3_STDCAPACITY;
}
/* Check if the card is busy. Very confusing, BUSY is set LOW
* if the card has not finished its initialization, so it really
* means NOT busy.
*/
if ((response & MMCSD_CARD_BUSY) != 0)
{
/* NO.. We really should check the current state to see if the
* MMC successfully made it to the IDLE state, but at least for
* now, we will simply assume that that is the case.
*
* Then break out of the look with an MMC card identified
*/
finfo("MMC card/chip ready!\n");
return OK;
}
}
if (!IS_MMC(priv->type))
#endif
{
/* Check for SDHC Version 2.x. Send CMD8 to verify SD card interface
* operating condition. CMD 8 is reserved on SD version 1.0 and MMC.
*
* CMD8 Argument:
* [31:12]: Reserved (shall be set to '0')
* [11:8]: Supply Voltage (VHS) 0x1 (Range: 2.7-3.6 V)
* [7:0]: Check Pattern (recommended 0xaa)
* CMD8 Response: R7
*/
ret = mmcsd_sendcmdpoll(priv, SD_CMD8,
MMCSD_CMD8CHECKPATTERN | MMCSD_CMD8VOLTAGE_27);
if (ret == OK)
{
/* CMD8 was sent successfully... Get the R7 response */
ret = SDIO_RECVR7(priv->dev, SD_CMD8, &response);
}
/* Were both the command sent and response received correctly? */
if (ret == OK)
{
/* CMD8 succeeded this is probably a SDHC card. Verify the
* operating voltage and that the check pattern was correctly
* echoed
*/
if (((response & MMCSD_R7VOLTAGE_MASK) == MMCSD_R7VOLTAGE_27) &&
((response & MMCSD_R7ECHO_MASK) == MMCSD_R7CHECKPATTERN))
{
finfo("SD V2.x card\n");
priv->type = MMCSD_CARDTYPE_SDV2;
sdcapacity = MMCSD_ACMD41_HIGHCAPACITY;
}
else
{
ferr("ERROR: R7: %08" PRIx32 "\n", response);
return -EIO;
}
}
}
/* At this point, type is either UNKNOWN, eMMC or SDV2. Try sending
* CMD55 and (maybe) ACMD41 for up to 1 second or until the card
* exits the IDLE state. CMD55 is supported by SD V1.x and SD V2.x,
* but not MMC
*/
start = clock_systime_ticks();
elapsed = 0;
do
{
/* We may have already determined that this card is an MMC card from
* an earlier pass through this loop. In that case, we should
* skip the SD-specific commands.
*/
#ifdef CONFIG_MMCSD_MMCSUPPORT
if (!IS_MMC(priv->type))
#endif
{
/* Send CMD55 with argument = 0 */
mmcsd_sendcmdpoll(priv, SD_CMD55, 0);
ret = mmcsd_recv_r1(priv, SD_CMD55);
if (ret != OK)
{
/* I am a little confused.. I think both SD and MMC cards
* support CMD55 (but maybe only SD cards support CMD55).
* We'll make the the MMC vs. SD decision based on CMD1 and
* ACMD41.
*/
ferr("ERROR: mmcsd_recv_r1(CMD55) failed: %d\n", ret);
}
else
{
/* Send ACMD41 */
mmcsd_sendcmdpoll(priv, SD_ACMD41,
MMCSD_ACMD41_VOLTAGEWINDOW_33_32 |
sdcapacity);
ret = SDIO_RECVR3(priv->dev, SD_ACMD41, &response);
if (ret != OK)
{
/* If the error is a timeout, then it is probably an MMC
* card, but we will make the decision based on CMD1
* below.
*/
ferr("ERROR: ACMD41 RECVR3: %d\n", ret);
}
else
{
/* ACMD41 succeeded. ACMD41 is supported by SD V1.x and
* SD V2.x, but not MMC. If we did not previously
* determine that this is an SD V2.x (via CMD8), then this
* must be SD V1.x
*/
finfo("R3: %08" PRIx32 "\n", response);
if (priv->type == MMCSD_CARDTYPE_UNKNOWN)
{
finfo("SD V1.x card\n");
priv->type = MMCSD_CARDTYPE_SDV1;
}
/* Check if the card is busy. Very confusing, BUSY is set
* LOW if the card has not finished its initialization,
* so it really means NOT busy.
*/
if ((response & MMCSD_CARD_BUSY) != 0)
{
/* No.. We really should check the current state to
* see if the SD card successfully made it to the IDLE
* state, but at least for now, we will simply assume
* that that is the case.
*
* Now, check if this is a SD V2.x card that supports
* block addressing
*/
if ((response & MMCSD_R3_HIGHCAPACITY) != 0)
{
finfo("SD V2.x card with block addressing\n");
DEBUGASSERT(priv->type == MMCSD_CARDTYPE_SDV2);
priv->type |= MMCSD_CARDTYPE_BLOCK;
}
/* And break out of the loop with an card identified */
break;
}
}
}
}
/* If we get here then either (1) CMD55 failed, (2) CMD41 failed, or
* (3) and SD or MMC card has been identified, but it is not yet in
* the IDLE state. If SD card has not been identified, then we might
* be looking at an MMC card. We can send the CMD1 to find out for
* sure. CMD1 is supported by MMC cards, but not by SD cards.
*/
#ifdef CONFIG_MMCSD_MMCSUPPORT
if (IS_MMC(priv->type))
{
/* Send the MMC CMD1 to specify the operating voltage. CMD1 causes
* transition to ready state/ card-identification mode. NOTE: If
* the card does not support this voltage range, it will go the
* inactive state.
*
* NOTE: An MMC card will only respond once to CMD1 (unless it is
* busy). This is part of the logic used to determine how many
* MMC cards are connected (This implementation supports only a
* single MMC card). So we cannot re-send CMD1 without first
* placing the card back into stand-by state (if the card is busy,
* it will automatically go back to the standby state).
*/
mmcsd_sendcmdpoll(priv, MMC_CMD1, MMCSD_VDD_33_34 | mmccapacity);
ret = SDIO_RECVR3(priv->dev, MMC_CMD1, &response);
/* Was the operating range set successfully */
if (ret != OK)
{
ferr("ERROR: CMD1 RECVR3: %d\n", ret);
}
else
{
/* CMD1 succeeded... this must be an MMC card */
finfo("Confirmed MMC card present.\n");
priv->type = MMCSD_CARDTYPE_MMC;
/* Now, check if this is a MMC card/chip that supports block
* addressing
*/
if ((response & MMCSD_R3_HIGHCAPACITY) != 0)
{
mmccapacity = MMCSD_R3_HIGHCAPACITY;
priv->type |= MMCSD_CARDTYPE_BLOCK;
}
else
{
mmccapacity = MMCSD_R3_STDCAPACITY;
}
/* Check if the card is busy. Very confusing, BUSY is set LOW
* if the card has not finished its initialization, so it
* really means NOT busy.
*/
if ((response & MMCSD_CARD_BUSY) != 0)
{
/* NO.. We really should check the current state to see if
* the MMC successfully made it to the IDLE state, but at
* least for now we will simply assume that that is the
* case.
*
* Then break out of the look with an MMC card identified
*/
finfo("MMC card/chip is ready!\n");
break;
}
else
{
finfo("MMC card/chip is busy. Waiting for reply...\n");
}
}
}
#endif
/* Check the elapsed time. We won't keep trying this forever! */
elapsed = clock_systime_ticks() - start;
}
while (elapsed < TICK_PER_SEC); /* On successful reception while 'breaks', see above. */
/* We get here when the above loop completes, either (1) we could not
* communicate properly with the card due to errors (and the loop times
* out), or (2) it is an MMC or SD card that has successfully transitioned
* to the IDLE state (well, at least, it provided its OCR saying that it
* it is no longer busy).
*/
if (elapsed >= TICK_PER_SEC || priv->type == MMCSD_CARDTYPE_UNKNOWN)
{
priv->type = MMCSD_CARDTYPE_UNKNOWN;
ferr("ERROR: Failed to identify card\n");
return -EIO;
}
return OK;
}
/****************************************************************************
* Name: mmcsd_probe
*
* Description:
* Check for media inserted in a slot. Called (1) during initialization to
* see if there was a card in the slot at power up, (2) when/if a media
* insertion event occurs, or (3) if the BIOC_PROBE ioctl command is
* received.
*
****************************************************************************/
static int mmcsd_probe(FAR struct mmcsd_state_s *priv)
{
int ret;
finfo("type: %d probed: %d\n", priv->type, priv->probed);
/* If we have reliable card detection events and if we have
* already probed the card, then we don't need to do anything
* else
*/
#ifdef CONFIG_MMCSD_HAVE_CARDDETECT
if (priv->probed && SDIO_PRESENT(priv->dev))
{
return OK;
}
#endif
/* Otherwise, we are going to probe the card. There are lots of
* possibilities here: We may think that there is a card in the slot,
* or not. There may be a card in the slot, or not. If there is
* card in the slot, perhaps it is a different card than we one we
* think is there? The safest thing to do is to process the card
* removal first and start from known place.
*/
mmcsd_removed(priv);
/* Now.. is there a card in the slot? */
if (SDIO_PRESENT(priv->dev))
{
/* Yes.. probe it. First, what kind of card was inserted? */
finfo("Card present. Probing....\n");
ret = mmcsd_cardidentify(priv);
if (ret != OK)
{
ferr("ERROR: Failed to initialize card: %d\n", ret);
}
else
{
/* Then initialize the driver according to the card type */
switch (priv->type)
{
/* Bit 1: SD version 1.x */
case MMCSD_CARDTYPE_SDV1:
finfo("SD version 1.x .\n");
ret = mmcsd_sdinitialize(priv);
break;
/* SD version 2.x with byte addressing */
case MMCSD_CARDTYPE_SDV2:
finfo("SD version 2.x with byte addressing.\n");
ret = mmcsd_sdinitialize(priv);
break;
/* SD version 2.x with block addressing */
case MMCSD_CARDTYPE_SDV2 | MMCSD_CARDTYPE_BLOCK:
finfo("SD version 2.x with block addressing.\n");
ret = mmcsd_sdinitialize(priv);
break;
/* MMC card with byte addressing */
case MMCSD_CARDTYPE_MMC:
finfo("MMC card with byte addressing.\n");
/* MMC card with block addressing */
case MMCSD_CARDTYPE_MMC | MMCSD_CARDTYPE_BLOCK:
finfo("MMC card with block addressing.\n");
#ifdef CONFIG_MMCSD_MMCSUPPORT
ret = mmcsd_mmcinitialize(priv);
break;
#endif
/* Unknown card type */
case MMCSD_CARDTYPE_UNKNOWN:
default:
ferr("ERROR: Internal confusion: %d\n", priv->type);
ret = -EPERM;
break;
}
/* Was the card configured successfully? */
if (ret == OK)
{
/* Yes... */
finfo("Capacity: %" PRIu32 " Kbytes\n",
MMCSD_CAPACITY(priv->nblocks, priv->blockshift));
priv->mediachanged = true;
}
/* When the card is identified, we have probed this card */
priv->probed = true;
}
/* Regardless of whether or not a card was successfully initialized,
* there is apparently a card inserted. If it wasn't successfully
* initialized, there's nothing we can do about it now. Perhaps it's
* a bad card? The best we can do is wait for the card to be ejected
* and re-inserted. Then we can try to initialize again.
*/
#ifdef CONFIG_MMCSD_HAVE_CARDDETECT
/* Set up to receive asynchronous, media removal events */
SDIO_CALLBACKENABLE(priv->dev, SDIOMEDIA_EJECTED);
#endif
}
else
{
/* There is no card in the slot */
finfo("No card\n");
#ifdef CONFIG_MMCSD_HAVE_CARDDETECT
SDIO_CALLBACKENABLE(priv->dev, SDIOMEDIA_INSERTED);
#endif
ret = -ENODEV;
}
return ret;
}
/****************************************************************************
* Name: mmcsd_removed
*
* Description:
* Disable support for media in the slot. Called (1) when/if a media
* removal event occurs, or (2) if the BIOC_EJECT ioctl command is
* received.
*
****************************************************************************/
static int mmcsd_removed(FAR struct mmcsd_state_s *priv)
{
finfo("type: %d present: %d\n", priv->type, SDIO_PRESENT(priv->dev));
/* Forget the card geometry, pretend the slot is empty (it might not
* be), and that the card has never been initialized.
*/
priv->blocksize = 0;
priv->probed = false;
priv->mediachanged = false;
priv->wrbusy = false;
priv->type = MMCSD_CARDTYPE_UNKNOWN;
priv->rca = 0;
priv->selblocklen = 0;
/* Go back to the default 1-bit data bus. */
priv->buswidth = MMCSD_SCR_BUSWIDTH_1BIT;
SDIO_WIDEBUS(priv->dev, false);
priv->widebus = false;
mmcsd_widebus(priv);
/* Disable clocking to the card */
SDIO_CLOCK(priv->dev, CLOCK_SDIO_DISABLED);
return OK;
}
/****************************************************************************
* Name: mmcsd_hwinitialize
*
* Description:
* One-time hardware initialization. Called only from sdio_slotinitialize.
*
****************************************************************************/
static int mmcsd_hwinitialize(FAR struct mmcsd_state_s *priv)
{
int ret;
ret = mmcsd_lock(priv);
if (ret < 0)
{
return ret;
}
/* Get the capabilities of the SDIO driver */
priv->caps = SDIO_CAPABILITIES(priv->dev);
finfo("DMA supported: %d\n", (priv->caps & SDIO_CAPS_DMASUPPORTED) != 0);
/* Attach and prepare MMC/SD interrupts */
if (SDIO_ATTACH(priv->dev))
{
ferr("ERROR: Unable to attach MMC/SD interrupts\n");
mmcsd_unlock(priv);
return -EBUSY;
}
finfo("Attached MMC/SD interrupts\n");
/* Register a callback so that we get informed if media is inserted or
* removed from the slot (Initially all callbacks are disabled).
*/
SDIO_REGISTERCALLBACK(priv->dev, mmcsd_mediachange, (FAR void *)priv);
/* Is there a card in the slot now? For an MMC/SD card, there are three
* possible card detect mechanisms:
*
* 1. Mechanical insertion that can be detected using the WP switch
* that is closed when a card is inserted into then SD slot (SD
* "hot insertion capable" card connector only)
* 2. Electrical insertion that can be sensed using the pull-up resistor
* on CD/DAT3 (both SD/MMC),
* 3. Or by periodic attempts to initialize the card from software.
*
* The behavior of SDIO_PRESENT() is to use whatever information is
* available on the particular platform. If no card insertion information
* is available (polling only), then SDIO_PRESENT() will always return
* true and we will try to initialize the card.
*/
if (SDIO_PRESENT(priv->dev))
{
/* Yes... probe for a card in the slot */
ret = mmcsd_probe(priv);
if (ret != OK)
{
finfo("Slot not empty, but initialization failed: %d\n", ret);
/* NOTE: The failure to initialize a card does not mean that
* initialization has failed! A card could be installed in the slot
* at a later time. ENODEV is return in this case,
* sdio_slotinitialize will use this return value to set up the
* card inserted callback event.
*/
ret = -ENODEV;
}
}
else
{
/* ENODEV is returned to indicate that no card is inserted in the slot.
* sdio_slotinitialize will use this return value to set up the card
* inserted callback event.
*/
ret = -ENODEV;
}
/* OK is returned only if the slot initialized correctly AND the card in
* the slot was successfully configured.
*/
mmcsd_unlock(priv);
return ret;
}
/****************************************************************************
* Name: mmcsd_hwuninitialize
*
* Description:
* Restore the MMC/SD slot to the uninitialized state. Called only from
* sdio_slotinitialize on a failure to initialize.
*
****************************************************************************/
static void mmcsd_hwuninitialize(FAR struct mmcsd_state_s *priv)
{
mmcsd_removed(priv);
SDIO_RESET(priv->dev);
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: mmcsd_slotinitialize
*
* Description:
* Initialize one slot for operation using the 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
* dev - And instance of an MMC/SD interface. The MMC/SD hardware should
* be initialized and ready to use.
*
****************************************************************************/
int mmcsd_slotinitialize(int minor, FAR struct sdio_dev_s *dev)
{
FAR struct mmcsd_state_s *priv;
char devname[16];
int ret = -ENOMEM;
finfo("minor: %d\n", minor);
/* Sanity check */
#ifdef CONFIG_DEBUG_FEATURES
if (minor < 0 || minor > 255 || !dev)
{
return -EINVAL;
}
#endif
/* Allocate a MMC/SD state structure */
priv = (FAR struct mmcsd_state_s *)
kmm_malloc(sizeof(struct mmcsd_state_s));
if (priv == NULL)
{
return -ENOMEM;
}
/* Initialize the MMC/SD state structure */
memset(priv, 0, sizeof(struct mmcsd_state_s));
nxmutex_init(&priv->lock);
/* Bind the MMCSD driver to the MMCSD state structure */
priv->dev = dev;
/* Initialize the hardware associated with the slot */
ret = mmcsd_hwinitialize(priv);
/* Was the slot initialized successfully? */
if (ret != OK)
{
/* No... But the error ENODEV is returned if hardware
* initialization succeeded but no card is inserted in the slot.
* In this case, the no error occurred, but the driver is still
* not ready.
*/
if (ret == -ENODEV)
{
/* No card in the slot (or if there is, we could not recognize
* it).. Setup to receive the media inserted event
*/
SDIO_CALLBACKENABLE(priv->dev, SDIOMEDIA_INSERTED);
finfo("MMC/SD slot is empty\n");
}
else
{
/* Some other non-recoverable bad thing happened */
ferr("ERROR: Failed to initialize MMC/SD slot: %d\n", ret);
goto errout_with_alloc;
}
}
/* Create a MMCSD device name */
snprintf(devname, 16, "/dev/mmcsd%d", minor);
/* Inode private data is a reference to the MMCSD state structure */
ret = register_blockdriver(devname, &g_bops, 0, priv);
if (ret < 0)
{
ferr("ERROR: register_blockdriver failed: %d\n", ret);
goto errout_with_hwinit;
}
return OK;
errout_with_hwinit:
mmcsd_hwuninitialize(priv);
errout_with_alloc:
nxmutex_destroy(&priv->lock);
kmm_free(priv);
return ret;
}
#endif /* defined (CONFIG_MMCSD) && defined (CONFIG_MMCSD_SDIO) */
Reference in New Issue View Git Blame Copy Permalink