4c167b0729
Signed-off-by: Xiang Xiao <xiaoxiang@xiaomi.com>
3644 lines
109 KiB
C
3644 lines
109 KiB
C
/****************************************************************************
|
|
* 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/semaphore.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)50000) /* 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 */
|
|
#define MMCSD_BLOCK_WDATADELAY (260) /* Wait up to 260MS to write one data block */
|
|
|
|
#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
|
|
|
|
/****************************************************************************
|
|
* 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 */
|
|
sem_t sem; /* 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 */
|
|
|
|
#ifdef CONFIG_HAVE_LONG_LONG
|
|
uint64_t capacity; /* Total capacity of volume */
|
|
#else
|
|
uint32_t capacity; /* Total capacity of volume (Limited to 4Gb) */
|
|
#endif
|
|
};
|
|
|
|
/****************************************************************************
|
|
* Private Function Prototypes
|
|
****************************************************************************/
|
|
|
|
/* Misc Helpers *************************************************************/
|
|
|
|
static int mmcsd_takesem(FAR struct mmcsd_state_s *priv);
|
|
|
|
#ifndef CONFIG_SDIO_MUXBUS
|
|
# define mmcsd_givesem(p) nxsem_post(&priv->sem);
|
|
#endif
|
|
|
|
/* 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);
|
|
|
|
/****************************************************************************
|
|
* 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_takesem(FAR struct mmcsd_state_s *priv)
|
|
{
|
|
int ret;
|
|
|
|
/* Take the semaphore, giving exclusive access to the driver (perhaps
|
|
* waiting)
|
|
*/
|
|
|
|
ret = nxsem_wait_uninterruptible(&priv->sem);
|
|
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
|
|
|
|
return ret;
|
|
}
|
|
|
|
#ifdef CONFIG_SDIO_MUXBUS
|
|
static void mmcsd_givesem(FAR struct mmcsd_state_s *priv)
|
|
{
|
|
/* Release the SDIO bus lock, then the MMC/SD driver semaphore in the
|
|
* opposite order that they were taken to assure that no deadlock
|
|
* conditions will arise.
|
|
*/
|
|
|
|
SDIO_LOCK(priv->dev, FALSE);
|
|
nxsem_post(&priv->sem);
|
|
}
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* 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)
|
|
{
|
|
/* 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);
|
|
}
|
|
#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
|
|
* priv->capacity Total capacity of volume
|
|
*
|
|
****************************************************************************/
|
|
|
|
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);
|
|
#ifdef CONFIG_HAVE_LONG_LONG
|
|
priv->capacity = ((uint64_t)(priv->nblocks)) << readbllen;
|
|
#else
|
|
priv->capacity = (priv->nblocks << readbllen);
|
|
#endif
|
|
|
|
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);
|
|
#ifdef CONFIG_HAVE_LONG_LONG
|
|
priv->capacity = ((uint64_t)(csize + 1)) << 19;
|
|
#else
|
|
priv->capacity = (csize + 1) << 19;
|
|
#endif
|
|
priv->blockshift = 9;
|
|
priv->blocksize = 1 << 9;
|
|
priv->nblocks = priv->capacity >> 9;
|
|
|
|
#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);
|
|
priv->capacity = (priv->nblocks << 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)(priv->capacity / 1024), 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 (!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;
|
|
}
|
|
|
|
/* 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_takesem(priv);
|
|
if (ret < 0)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
priv->crefs++;
|
|
mmcsd_givesem(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_takesem(priv);
|
|
if (ret < 0)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
priv->crefs--;
|
|
mmcsd_givesem(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_takesem(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_givesem(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_takesem(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_givesem(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)
|
|
{
|
|
/* Is there a (supported) card inserted in the slot? */
|
|
|
|
priv = (FAR struct mmcsd_state_s *)inode->i_private;
|
|
ret = mmcsd_takesem(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_givesem(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_takesem(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;
|
|
|
|
default:
|
|
ret = -ENOTTY;
|
|
break;
|
|
}
|
|
|
|
mmcsd_givesem(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_takesem(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_givesem(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 ((priv->buswidth & MMCSD_SCR_BUSWIDTH_4BIT) != 0 &&
|
|
(priv->caps & SDIO_CAPS_1BIT_ONLY) == 0)
|
|
{
|
|
/* 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 wide, 4-bit bus 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;
|
|
}
|
|
|
|
/* Configure the SDIO peripheral */
|
|
|
|
finfo("Wide bus operation selected\n");
|
|
SDIO_WIDEBUS(priv->dev, true);
|
|
priv->widebus = true;
|
|
|
|
SDIO_CLOCK(priv->dev, CLOCK_SD_TRANSFER_4BIT);
|
|
nxsig_usleep(MMCSD_CLK_DELAY);
|
|
return OK;
|
|
}
|
|
|
|
/* Wide bus operation not supported */
|
|
|
|
fwarn("WARNING: Card does not support wide-bus operation\n");
|
|
return -ENOSYS;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* 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.
|
|
*/
|
|
|
|
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, 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)
|
|
*/
|
|
|
|
mmcsd_sendcmdpoll(priv, MMCSD_CMD9, 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;
|
|
}
|
|
|
|
/* 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);
|
|
|
|
/* 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;
|
|
}
|
|
|
|
/* 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,
|
|
* but it has to be done in data-transfer mode.
|
|
*/
|
|
|
|
if (IS_BLOCK(priv->type))
|
|
{
|
|
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);
|
|
|
|
/* Select high speed MMC clocking (which may depend on the DSR setting) */
|
|
|
|
SDIO_CLOCK(priv->dev, CLOCK_MMC_TRANSFER);
|
|
nxsig_usleep(MMCSD_CLK_DELAY);
|
|
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;
|
|
}
|
|
|
|
#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, 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)
|
|
{
|
|
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);
|
|
|
|
/* Return value: One sector read */
|
|
|
|
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);
|
|
|
|
/* 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);
|
|
|
|
/* 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;
|
|
|
|
/* 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;
|
|
}
|
|
|
|
/* 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)
|
|
{
|
|
ferr("ERROR: CMD1 RECVR3: %d\n", ret);
|
|
}
|
|
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 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 his 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 */
|
|
|
|
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 ready!\n");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#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)
|
|
{
|
|
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? */
|
|
|
|
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:
|
|
|
|
/* SD version 2.x with byte addressing */
|
|
|
|
case MMCSD_CARDTYPE_SDV2:
|
|
|
|
/* SD version 2.x with block addressing */
|
|
|
|
case MMCSD_CARDTYPE_SDV2 | MMCSD_CARDTYPE_BLOCK:
|
|
ret = mmcsd_sdinitialize(priv);
|
|
break;
|
|
|
|
/* MMC card with byte addressing */
|
|
|
|
case MMCSD_CARDTYPE_MMC:
|
|
|
|
/* MMC card with block addressing */
|
|
|
|
case MMCSD_CARDTYPE_MMC | MMCSD_CARDTYPE_BLOCK:
|
|
#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: %lu Kbytes\n",
|
|
(unsigned long)(priv->capacity / 1024));
|
|
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->capacity = 0; /* Capacity=0 sometimes means no media */
|
|
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. */
|
|
|
|
SDIO_WIDEBUS(priv->dev, false);
|
|
priv->widebus = false;
|
|
|
|
/* 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_takesem(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_givesem(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_givesem(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));
|
|
nxsem_init(&priv->sem, 0, 1);
|
|
|
|
/* 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:
|
|
nxsem_destroy(&priv->sem);
|
|
kmm_free(priv);
|
|
return ret;
|
|
}
|
|
|
|
#endif /* defined (CONFIG_MMCSD) && defined (CONFIG_MMCSD_SDIO) */
|