/****************************************************************************
* arch/arm/src/lpc17xx/lpc17_sdcard.c
*
* Copyright (C) 2013-2014 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdint.h>
#include <stdbool.h>
#include <semaphore.h>
#include <string.h>
#include <assert.h>
#include <debug.h>
#include <errno.h>
#include <nuttx/wdog.h>
#include <nuttx/clock.h>
#include <nuttx/arch.h>
#include <nuttx/sdio.h>
#include <nuttx/wqueue.h>
#include <nuttx/mmcsd.h>
#include <arch/irq.h>
#include <arch/board/board.h>
#include "chip.h"
#include "up_arch.h"
#include "lpc17_gpdma.h"
#include "lpc17_gpio.h"
#include "lpc17_sdcard.h"
#include "chip/lpc17_syscon.h"
#include "chip/lpc17_pinconfig.h"
#if CONFIG_LPC17_SDCARD
/****************************************************************************
* Pre-Processor Definitions
****************************************************************************/
/* Configuration ************************************************************/
/* Required system configuration options:
*
* CONFIG_ARCH_DMA - Enable architecture-specific DMA subsystem
* initialization. Required if CONFIG_SDIO_DMA is enabled.
* CONFIG_LPC17_GPDMA - Enable LPC17XX GPDMA support. Required if
* CONFIG_SDIO_DMA is enabled
* CONFIG_SCHED_WORKQUEUE -- Callback support requires work queue support.
*
* Driver-specific configuration options:
*
* CONFIG_SDIO_MUXBUS - Setting this configuration enables some locking
* APIs to manage concurrent accesses on the SD card bus. This is not
* needed for the simple case of a single SD card, for example.
* CONFIG_SDIO_DMA - Enable SD card DMA. This is a marginally optional.
* For most usages, SD accesses will cause data overruns if used without DMA.
* NOTE the above system DMA configuration options.
* CONFIG_SDIO_WIDTH_D1_ONLY - This may be selected to force the driver
* operate with only a single data line (the default is to use all
* 4 SD data lines).
* CONFIG_SDCARD_DMAPRIO - SD card DMA priority. This can be selected if
* CONFIG_SDIO_DMA is enabled.
* CONFIG_DEBUG_SDIO - Enables some very low-level debug output
* This also requires CONFIG_DEBUG_FS and CONFIG_DEBUG_VERBOSE
*/
#if defined(CONFIG_SDIO_DMA) && !defined(CONFIG_LPC17_GPDMA)
# warning "CONFIG_SDIO_DMA support requires CONFIG_LPC17_GPDMA"
#endif
#ifndef CONFIG_SDIO_DMA
# warning "Large Non-DMA transfer may result in RX overrun failures"
#endif
#ifndef CONFIG_SCHED_WORKQUEUE
# error "Callback support requires CONFIG_SCHED_WORKQUEUE"
#endif
#ifdef CONFIG_SDIO_DMA
# define CONFIG_SDCARD_DMAPRIO DMA_SCR_PRIVERYHI
# if (CONFIG_SDCARD_DMAPRIO & ~DMA_SCR_PL_MASK) != 0
# error "Illegal value for CONFIG_SDCARD_DMAPRIO"
# endif
#endif
#if !defined(CONFIG_DEBUG_FS) || !defined(CONFIG_DEBUG)
# undef CONFIG_DEBUG_SDIO
#endif
/* Friendly CLKCR bit re-definitions ****************************************/
/* Mode dependent settings. These depend on clock devisor settings that must
* be defined in the board-specific board.h header file: SDCARD_INIT_CLKDIV,
* SDCARD_MMCXFR_CLKDIV, and SDCARD_SDXFR_CLKDIV.
*/
#define LPC17_CLCKCR_INIT (SDCARD_INIT_CLKDIV|SDCARD_CLOCK_WIDBUS_D1)
#define SDCARD_CLOCK_MMCXFR (SDCARD_MMCXFR_CLKDIV|SDCARD_CLOCK_WIDBUS_D1)
#define SDCARD_CLOCK_SDXFR (SDCARD_SDXFR_CLKDIV|SDCARD_CLOCK_WIDBUS_D1)
#define SDCARD_CLOCK_SDWIDEXFR (SDCARD_SDXFR_CLKDIV|SDCARD_CLOCK_WIDBUS_D4)
/* Timing */
#define SDCARD_CMDTIMEOUT (100000)
#define SDCARD_LONGTIMEOUT (0x7fffffff)
/* Big DTIMER setting */
#define SDCARD_DTIMER_DATATIMEOUT (0x000fffff)
/* DMA channel/stream configuration register settings. The following
* must be selected. The DMA driver will select the remaining fields.
*
* - 32-bit DMA
* - Memory increment
* - Direction (memory-to-peripheral, peripheral-to-memory)
* - Memory burst size (F4 only)
*/
/* DMA control register settings. All CONTROL register fields need to be
* specified except for the transfer size which is passed as a separate
* parameter and for the terminal count interrupt enable bit which is
* controlled by the driver.
*/
#define SDCARD_RXDMA32_CONTROL (DMACH_CONTROL_SBSIZE_8|DMACH_CONTROL_DBSIZE_8|\
DMACH_CONTROL_SWIDTH_32BIT|DMACH_CONTROL_DWIDTH_32BIT|\
DMACH_CONTROL_DI)
#define SDCARD_TXDMA32_CONTROL (DMACH_CONTROL_SBSIZE_8|DMACH_CONTROL_DBSIZE_8|\
DMACH_CONTROL_SWIDTH_32BIT|DMACH_CONTROL_DWIDTH_32BIT|\
DMACH_CONTROL_SI)
/* DMA configuration register settings. Only the SRCPER, DSTPER, and
* XFRTTYPE fields of the CONFIG register need be specified.
*/
#define SDCARD_RXDMA32_CONFIG (DMACH_CONFIG_SRCPER_SDCARD|DMACH_CONFIG_XFRTYPE_P2M_SC)
#define SDCARD_TXDMA32_CONFIG (DMACH_CONFIG_DSTPER_SDCARD|DMACH_CONFIG_XFRTYPE_M2P_DC)
/* FIFO sizes */
#define SDCARD_HALFFIFO_WORDS (8)
#define SDCARD_HALFFIFO_BYTES (8*4)
/* Data transfer interrupt mask bits */
#define SDCARD_RECV_MASK (SDCARD_MASK0_DCRCFAILIE|SDCARD_MASK0_DTIMEOUTIE|\
SDCARD_MASK0_DATAENDIE|SDCARD_MASK0_RXOVERRIE|\
SDCARD_MASK0_RXFIFOHFIE|SDCARD_MASK0_STBITERRIE)
#define SDCARD_SEND_MASK (SDCARD_MASK0_DCRCFAILIE|SDCARD_MASK0_DTIMEOUTIE|\
SDCARD_MASK0_DATAENDIE|SDCARD_MASK0_TXUNDERRIE|\
SDCARD_MASK0_TXFIFOHEIE|SDCARD_MASK0_STBITERRIE)
#define SDCARD_DMARECV_MASK (SDCARD_MASK0_DCRCFAILIE|SDCARD_MASK0_DTIMEOUTIE|\
SDCARD_MASK0_DATAENDIE|SDCARD_MASK0_RXOVERRIE|\
SDCARD_MASK0_STBITERRIE)
#define SDCARD_DMASEND_MASK (SDCARD_MASK0_DCRCFAILIE|SDCARD_MASK0_DTIMEOUTIE|\
SDCARD_MASK0_DATAENDIE|SDCARD_MASK0_TXUNDERRIE|\
SDCARD_MASK0_STBITERRIE)
/* Event waiting interrupt mask bits */
#define SDCARD_CMDDONE_STA (SDCARD_STATUS_CMDSENT)
#define SDCARD_RESPDONE_STA (SDCARD_STATUS_CTIMEOUT|SDCARD_STATUS_CCRCFAIL|\
SDCARD_STATUS_CMDREND)
#define SDCARD_XFRDONE_STA (0)
#define SDCARD_CMDDONE_MASK (SDCARD_MASK0_CMDSENTIE)
#define SDCARD_RESPDONE_MASK (SDCARD_MASK0_CCRCFAILIE|SDCARD_MASK0_CTIMEOUTIE|\
SDCARD_MASK0_CMDRENDIE)
#define SDCARD_XFRDONE_MASK (0)
#define SDCARD_CMDDONE_ICR (SDCARD_CLEAR_CMDSENTC)
#define SDCARD_RESPDONE_ICR (SDCARD_CLEAR_CTIMEOUTC|SDCARD_CLEAR_CCRCFAILC|\
SDCARD_CLEAR_CMDRENDC)
#define SDCARD_XFRDONE_ICR (SDCARD_CLEAR_DATAENDC|SDCARD_CLEAR_DCRCFAILC|\
SDCARD_CLEAR_DTIMEOUTC|SDCARD_CLEAR_RXOVERRC|\
SDCARD_CLEAR_TXUNDERRC|SDCARD_CLEAR_STBITERRC)
#define SDCARD_WAITALL_ICR (SDCARD_CMDDONE_ICR|SDCARD_RESPDONE_ICR|\
SDCARD_XFRDONE_ICR)
/* Let's wait until we have both SD card transfer complete and DMA complete. */
#define SDCARD_XFRDONE_FLAG (1)
#define SDCARD_DMADONE_FLAG (2)
#define SDCARD_ALLDONE (3)
/* Register logging support */
#ifdef CONFIG_DEBUG_SDIO
# ifdef CONFIG_SDIO_DMA
# define SAMPLENDX_BEFORE_SETUP 0
# define SAMPLENDX_BEFORE_ENABLE 1
# define SAMPLENDX_AFTER_SETUP 2
# define SAMPLENDX_END_TRANSFER 3
# define SAMPLENDX_DMA_CALLBACK 4
# define DEBUG_NSAMPLES 5
# else
# define SAMPLENDX_BEFORE_SETUP 0
# define SAMPLENDX_AFTER_SETUP 1
# define SAMPLENDX_END_TRANSFER 2
# define DEBUG_NSAMPLES 3
# endif
#endif
/****************************************************************************
* Private Types
****************************************************************************/
/* This structure defines the state of the LPC17XX SD card interface */
struct lpc17_dev_s
{
struct sdio_dev_s dev; /* Standard, base SD card interface */
/* LPC17XX-specific extensions */
/* Event support */
sem_t waitsem; /* Implements event waiting */
sdio_eventset_t waitevents; /* Set of events to be waited for */
uint32_t waitmask; /* Interrupt enables for event waiting */
volatile sdio_eventset_t wkupevent; /* The event that caused the wakeup */
WDOG_ID waitwdog; /* Watchdog that handles event timeouts */
/* Callback support */
uint8_t cdstatus; /* Card status */
sdio_eventset_t cbevents; /* Set of events to be cause callbacks */
worker_t callback; /* Registered callback function */
void *cbarg; /* Registered callback argument */
struct work_s cbwork; /* Callback work queue structure */
/* Interrupt mode data transfer support */
uint32_t *buffer; /* Address of current R/W buffer */
size_t remaining; /* Number of bytes remaining in the transfer */
uint32_t xfrmask; /* Interrupt enables for data transfer */
/* DMA data transfer support */
bool widebus; /* Required for DMA support */
#ifdef CONFIG_SDIO_DMA
volatile uint8_t xfrflags; /* Used to synchronize SD card and DMA completion events */
bool dmamode; /* true: DMA mode transfer */
DMA_HANDLE dma; /* Handle for DMA channel */
#endif
};
/* Register logging support */
#ifdef CONFIG_DEBUG_SDIO
struct lpc17_sdcard_regs_s
{
uint8_t pwr;
uint16_t clkcr;
uint16_t dctrl;
uint32_t dtimer;
uint32_t dlen;
uint32_t dcount;
uint32_t sta;
uint32_t mask;
uint32_t fifocnt;
};
struct lpc17_sampleregs_s
{
struct lpc17_sdcard_regs_s sdcard;
#if defined(CONFIG_DEBUG_DMA) && defined(CONFIG_SDIO_DMA)
struct lpc17_dmaregs_s dma;
#endif
};
#endif
/****************************************************************************
* Private Function Prototypes
****************************************************************************/
/* Low-level helpers ********************************************************/
static void lpc17_takesem(struct lpc17_dev_s *priv);
#define lpc17_givesem(priv) (sem_post(&priv->waitsem))
static inline void lpc17_setclock(uint32_t clkcr);
static void lpc17_configwaitints(struct lpc17_dev_s *priv, uint32_t waitmask,
sdio_eventset_t waitevents, sdio_eventset_t wkupevents);
static void lpc17_configxfrints(struct lpc17_dev_s *priv, uint32_t xfrmask);
static void lpc17_setpwrctrl(uint32_t pwrctrl);
static inline uint32_t lpc17_getpwrctrl(void);
/* DMA Helpers **************************************************************/
#ifdef CONFIG_DEBUG_SDIO
static void lpc17_sampleinit(void);
static void lpc17_sdcard_sample(struct lpc17_sdcard_regs_s *regs);
static void lpc17_sample(struct lpc17_dev_s *priv, int index);
static void lpc17_sdcard_dump(struct lpc17_sdcard_regs_s *regs, const char *msg);
static void lpc17_dumpsample(struct lpc17_dev_s *priv,
struct lpc17_sampleregs_s *regs, const char *msg);
static void lpc17_dumpsamples(struct lpc17_dev_s *priv);
#else
# define lpc17_sampleinit()
# define lpc17_sample(priv,index)
# define lpc17_dumpsamples(priv)
#endif
#ifdef CONFIG_SDIO_DMA
static void lpc17_dmacallback(DMA_HANDLE handle, void *arg, int status);
#endif
/* Data Transfer Helpers ****************************************************/
static uint8_t lpc17_log2(uint16_t value);
static void lpc17_dataconfig(uint32_t timeout, uint32_t dlen, uint32_t dctrl);
static void lpc17_datadisable(void);
static void lpc17_sendfifo(struct lpc17_dev_s *priv);
static void lpc17_recvfifo(struct lpc17_dev_s *priv);
static void lpc17_eventtimeout(int argc, uint32_t arg);
static void lpc17_endwait(struct lpc17_dev_s *priv, sdio_eventset_t wkupevent);
static void lpc17_endtransfer(struct lpc17_dev_s *priv, sdio_eventset_t wkupevent);
/* Interrupt Handling *******************************************************/
static int lpc17_interrupt(int irq, void *context);
/* SD Card Interface Methods ************************************************/
/* Mutual exclusion */
#ifdef CONFIG_SDIO_MUXBUS
static int lpc17_lock(FAR struct sdio_dev_s *dev, bool lock);
#endif
/* Initialization/setup */
static void lpc17_reset(FAR struct sdio_dev_s *dev);
static uint8_t lpc17_status(FAR struct sdio_dev_s *dev);
static void lpc17_widebus(FAR struct sdio_dev_s *dev, bool enable);
static void lpc17_clock(FAR struct sdio_dev_s *dev,
enum sdio_clock_e rate);
static int lpc17_attach(FAR struct sdio_dev_s *dev);
/* Command/Status/Data Transfer */
static int lpc17_sendcmd(FAR struct sdio_dev_s *dev, uint32_t cmd,
uint32_t arg);
static int lpc17_recvsetup(FAR struct sdio_dev_s *dev, FAR uint8_t *buffer,
size_t nbytes);
static int lpc17_sendsetup(FAR struct sdio_dev_s *dev,
FAR const uint8_t *buffer, uint32_t nbytes);
static int lpc17_cancel(FAR struct sdio_dev_s *dev);
static int lpc17_waitresponse(FAR struct sdio_dev_s *dev, uint32_t cmd);
static int lpc17_recvshortcrc(FAR struct sdio_dev_s *dev, uint32_t cmd,
uint32_t *rshort);
static int lpc17_recvlong(FAR struct sdio_dev_s *dev, uint32_t cmd,
uint32_t rlong[4]);
static int lpc17_recvshort(FAR struct sdio_dev_s *dev, uint32_t cmd,
uint32_t *rshort);
static int lpc17_recvnotimpl(FAR struct sdio_dev_s *dev, uint32_t cmd,
uint32_t *rnotimpl);
/* EVENT handler */
static void lpc17_waitenable(FAR struct sdio_dev_s *dev,
sdio_eventset_t eventset);
static sdio_eventset_t
lpc17_eventwait(FAR struct sdio_dev_s *dev, uint32_t timeout);
static void lpc17_callbackenable(FAR struct sdio_dev_s *dev,
sdio_eventset_t eventset);
static int lpc17_registercallback(FAR struct sdio_dev_s *dev,
worker_t callback, void *arg);
/* DMA */
#ifdef CONFIG_SDIO_DMA
static bool lpc17_dmasupported(FAR struct sdio_dev_s *dev);
static int lpc17_dmarecvsetup(FAR struct sdio_dev_s *dev,
FAR uint8_t *buffer, size_t buflen);
static int lpc17_dmasendsetup(FAR struct sdio_dev_s *dev,
FAR const uint8_t *buffer, size_t buflen);
#endif
/* Initialization/uninitialization/reset ************************************/
static void lpc17_callback(void *arg);
static void lpc17_default(void);
/****************************************************************************
* Private Data
****************************************************************************/
struct lpc17_dev_s g_scard_dev =
{
.dev =
{
#ifdef CONFIG_SDIO_MUXBUS
.lock = lpc17_lock,
#endif
.reset = lpc17_reset,
.status = lpc17_status,
.widebus = lpc17_widebus,
.clock = lpc17_clock,
.attach = lpc17_attach,
.sendcmd = lpc17_sendcmd,
.recvsetup = lpc17_recvsetup,
.sendsetup = lpc17_sendsetup,
.cancel = lpc17_cancel,
.waitresponse = lpc17_waitresponse,
.recvR1 = lpc17_recvshortcrc,
.recvR2 = lpc17_recvlong,
.recvR3 = lpc17_recvshort,
.recvR4 = lpc17_recvnotimpl,
.recvR5 = lpc17_recvnotimpl,
.recvR6 = lpc17_recvshortcrc,
.recvR7 = lpc17_recvshort,
.waitenable = lpc17_waitenable,
.eventwait = lpc17_eventwait,
.callbackenable = lpc17_callbackenable,
.registercallback = lpc17_registercallback,
#ifdef CONFIG_SDIO_DMA
.dmasupported = lpc17_dmasupported,
.dmarecvsetup = lpc17_dmarecvsetup,
.dmasendsetup = lpc17_dmasendsetup,
#endif
},
};
/* Register logging support */
#ifdef CONFIG_DEBUG_SDIO
static struct lpc17_sampleregs_s g_sampleregs[DEBUG_NSAMPLES];
#endif
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Low-level Helpers
****************************************************************************/
/****************************************************************************
* Name: lpc17_takesem
*
* Description:
* Take the wait semaphore (handling false alarm wakeups due to the receipt
* of signals).
*
* Input Parameters:
* dev - Instance of the SD card device driver state structure.
*
* Returned Value:
* None
*
****************************************************************************/
static void lpc17_takesem(struct lpc17_dev_s *priv)
{
/* Take the semaphore (perhaps waiting) */
while (sem_wait(&priv->waitsem) != 0)
{
/* The only case that an error should occr here is if the wait was
* awakened by a signal.
*/
ASSERT(errno == EINTR);
}
}
/****************************************************************************
* Name: lpc17_setclock
*
* Description:
* Modify oft-changed bits in the CLKCR register. Only the following bit-
* fields are changed:
*
* CLKDIV, PWRSAV, BYPASS, and WIDBUS
*
* Input Parameters:
* clkcr - A new CLKCR setting for the above mentions bits (other bits
* are ignored.
*
* Returned Value:
* None
*
****************************************************************************/
static inline void lpc17_setclock(uint32_t clkcr)
{
uint32_t regval = getreg32(LPC17_SDCARD_CLOCK);
/* Clear CLKDIV, PWRSAV, BYPASS, and WIDBUS bits */
regval &= ~(SDCARD_CLOCK_CLKDIV_MASK|SDCARD_CLOCK_PWRSAV|SDCARD_CLOCK_BYPASS|
SDCARD_CLOCK_WIDBUS|SDCARD_CLOCK_CLKEN);
/* Replace with user provided settings */
clkcr &= (SDCARD_CLOCK_CLKDIV_MASK|SDCARD_CLOCK_PWRSAV|SDCARD_CLOCK_BYPASS|
SDCARD_CLOCK_WIDBUS|SDCARD_CLOCK_CLKEN);
regval |= clkcr;
putreg32(regval, LPC17_SDCARD_CLOCK);
fvdbg("CLKCR: %08x PWR: %08x\n",
getreg32(LPC17_SDCARD_CLOCK), getreg32(LPC17_SDCARD_PWR));
}
/****************************************************************************
* Name: lpc17_configwaitints
*
* Description:
* Enable/disable SD card interrupts needed to suport the wait function
*
* Input Parameters:
* priv - A reference to the SD card device state structure
* waitmask - The set of bits in the SD card MASK register to set
* waitevents - Waited for events
* wkupevent - Wake-up events
*
* Returned Value:
* None
*
****************************************************************************/
static void lpc17_configwaitints(struct lpc17_dev_s *priv, uint32_t waitmask,
sdio_eventset_t waitevents,
sdio_eventset_t wkupevent)
{
irqstate_t flags;
/* Save all of the data and set the new interrupt mask in one, atomic
* operation.
*/
flags = irqsave();
priv->waitevents = waitevents;
priv->wkupevent = wkupevent;
priv->waitmask = waitmask;
#ifdef CONFIG_SDIO_DMA
priv->xfrflags = 0;
#endif
putreg32(priv->xfrmask | priv->waitmask, LPC17_SDCARD_MASK0);
irqrestore(flags);
}
/****************************************************************************
* Name: lpc17_configxfrints
*
* Description:
* Enable SD card interrupts needed to support the data transfer event
*
* Input Parameters:
* priv - A reference to the SD card device state structure
* xfrmask - The set of bits in the SD card MASK register to set
*
* Returned Value:
* None
*
****************************************************************************/
static void lpc17_configxfrints(struct lpc17_dev_s *priv, uint32_t xfrmask)
{
irqstate_t flags;
flags = irqsave();
priv->xfrmask = xfrmask;
putreg32(priv->xfrmask | priv->waitmask, LPC17_SDCARD_MASK0);
irqrestore(flags);
}
/****************************************************************************
* Name: lpc17_setpwrctrl
*
* Description:
* Change the PWRCTRL field of the SD card POWER register to turn the SD card
* ON or OFF
*
* Input Parameters:
* clkcr - A new PWRCTRL setting
*
* Returned Value:
* None
*
****************************************************************************/
static void lpc17_setpwrctrl(uint32_t pwrctrl)
{
uint32_t regval;
/* Set the new value of the PWRCTRL field of the PWR register. Also, as a
* side-effect, clear the OPENDRAIN and ROD bits as well.
*/
regval = getreg32(LPC17_SDCARD_PWR);
regval &= ~(SDCARD_PWR_CTRL_MASK | SDCARD_PWR_OPENDRAIN | SDCARD_PWR_ROD);
regval |= pwrctrl;
putreg32(regval, LPC17_SDCARD_PWR);
}
/****************************************************************************
* Name: lpc17_getpwrctrl
*
* Description:
* Return the current value of the the PWRCTRL field of the SD card P
* register. This function can be used to see if the SD card is powered ON
* or OFF
*
* Input Parameters:
* None
*
* Returned Value:
* The current value of the the PWRCTRL field of the SD card PWR register.
*
****************************************************************************/
static inline uint32_t lpc17_getpwrctrl(void)
{
/* Extract and return the PWRCTRL field of the PWR register. */
return getreg32(LPC17_SDCARD_PWR) & SDCARD_PWR_CTRL_MASK;
}
/****************************************************************************
* DMA Helpers
****************************************************************************/
/****************************************************************************
* Name: lpc17_sampleinit
*
* Description:
* Setup prior to collecting DMA samples
*
****************************************************************************/
#ifdef CONFIG_DEBUG_SDIO
static void lpc17_sampleinit(void)
{
memset(g_sampleregs, 0xff, DEBUG_NSAMPLES * sizeof(struct lpc17_sampleregs_s));
}
#endif
/****************************************************************************
* Name: lpc17_sdcard_sample
*
* Description:
* Sample SD card registers
*
****************************************************************************/
#ifdef CONFIG_DEBUG_SDIO
static void lpc17_sdcard_sample(struct lpc17_sdcard_regs_s *regs)
{
regs->pwr = (uint8_t)getreg32(LPC17_SDCARD_PWR);
regs->clkcr = (uint16_t)getreg32(LPC17_SDCARD_CLOCK);
regs->dctrl = (uint16_t)getreg32(LPC17_SDCARD_DCTRL);
regs->dtimer = getreg32(LPC17_SDCARD_DTIMER);
regs->dlen = getreg32(LPC17_SDCARD_DLEN);
regs->dcount = getreg32(LPC17_SDCARD_DCOUNT);
regs->sta = getreg32(LPC17_SDCARD_STATUS);
regs->mask = getreg32(LPC17_SDCARD_MASK0);
regs->fifocnt = getreg32(LPC17_SDCARD_FIFOCNT);
}
#endif
/****************************************************************************
* Name: lpc17_sample
*
* Description:
* Sample SD card/DMA registers
*
****************************************************************************/
#ifdef CONFIG_DEBUG_SDIO
static void lpc17_sample(struct lpc17_dev_s *priv, int index)
{
struct lpc17_sampleregs_s *regs = &g_sampleregs[index];
#if defined(CONFIG_DEBUG_DMA) && defined(CONFIG_SDIO_DMA)
if (priv->dmamode)
{
lpc17_dmasample(priv->dma, ®s->dma);
}
#endif
lpc17_sdcard_sample(®s->sdcard);
}
#endif
/****************************************************************************
* Name: lpc17_sdcard_dump
*
* Description:
* Dump one register sample
*
****************************************************************************/
#ifdef CONFIG_DEBUG_SDIO
static void lpc17_sdcard_dump(struct lpc17_sdcard_regs_s *regs, const char *msg)
{
fdbg("SD Card Registers: %s\n", msg);
fdbg(" POWER[%08x]: %08x\n", LPC17_SDCARD_PWR, regs->pwr);
fdbg(" CLKCR[%08x]: %08x\n", LPC17_SDCARD_CLOCK, regs->clkcr);
fdbg(" DCTRL[%08x]: %08x\n", LPC17_SDCARD_DCTRL, regs->dctrl);
fdbg(" DTIMER[%08x]: %08x\n", LPC17_SDCARD_DTIMER, regs->dtimer);
fdbg(" DLEN[%08x]: %08x\n", LPC17_SDCARD_DLEN, regs->dlen);
fdbg(" DCOUNT[%08x]: %08x\n", LPC17_SDCARD_DCOUNT, regs->dcount);
fdbg(" STA[%08x]: %08x\n", LPC17_SDCARD_STATUS, regs->sta);
fdbg(" MASK[%08x]: %08x\n", LPC17_SDCARD_MASK0, regs->mask);
fdbg("FIFOCNT[%08x]: %08x\n", LPC17_SDCARD_FIFOCNT, regs->fifocnt);
}
#endif
/****************************************************************************
* Name: lpc17_dumpsample
*
* Description:
* Dump one register sample
*
****************************************************************************/
#ifdef CONFIG_DEBUG_SDIO
static void lpc17_dumpsample(struct lpc17_dev_s *priv,
struct lpc17_sampleregs_s *regs, const char *msg)
{
#if defined(CONFIG_DEBUG_DMA) && defined(CONFIG_SDIO_DMA)
if (priv->dmamode)
{
lpc17_dmadump(priv->dma, ®s->dma, msg);
}
#endif
lpc17_sdcard_dump(®s->sdcard, msg);
}
#endif
/****************************************************************************
* Name: lpc17_dumpsamples
*
* Description:
* Dump all sampled register data
*
****************************************************************************/
#ifdef CONFIG_DEBUG_SDIO
static void lpc17_dumpsamples(struct lpc17_dev_s *priv)
{
lpc17_dumpsample(priv, &g_sampleregs[SAMPLENDX_BEFORE_SETUP], "Before setup");
#if defined(CONFIG_DEBUG_DMA) && defined(CONFIG_SDIO_DMA)
if (priv->dmamode)
{
lpc17_dumpsample(priv, &g_sampleregs[SAMPLENDX_BEFORE_ENABLE], "Before DMA enable");
}
#endif
lpc17_dumpsample(priv, &g_sampleregs[SAMPLENDX_AFTER_SETUP], "After setup");
lpc17_dumpsample(priv, &g_sampleregs[SAMPLENDX_END_TRANSFER], "End of transfer");
#if defined(CONFIG_DEBUG_DMA) && defined(CONFIG_SDIO_DMA)
if (priv->dmamode)
{
lpc17_dumpsample(priv, &g_sampleregs[SAMPLENDX_DMA_CALLBACK], "DMA Callback");
}
#endif
}
#endif
/****************************************************************************
* Name: lpc17_dmacallback
*
* Description:
* Called when SD card DMA completes
*
****************************************************************************/
#ifdef CONFIG_SDIO_DMA
static void lpc17_dmacallback(DMA_HANDLE handle, void *arg, int status)
{
FAR struct lpc17_dev_s *priv = (FAR struct lpc17_dev_s *)arg;
DEBUGASSERT(priv->dmamode);
sdio_eventset_t result;
/* In the normal case, SD card appears to handle the End-Of-Transfer interrupt
* first with the End-Of-DMA event occurring significantly later. On
* transfer errors, however, the DMA error will occur before the End-of-
* Transfer.
*/
lpc17_sample((struct lpc17_dev_s*)arg, SAMPLENDX_DMA_CALLBACK);
/* Get the result of the DMA transfer */
if (status < 0)
{
flldbg("DMA error %d, remaining: %d\n", status, priv->remaining);
result = SDIOWAIT_ERROR;
}
else
{
result = SDIOWAIT_TRANSFERDONE;
}
/* Then terminate the transfer if this completes all of the steps in the
* transfer OR if a DMA error occurred. In the non-error case, we should
* already have the SD card transfer done interrupt. If not, the transfer
* will appropriately time out.
*/
priv->xfrflags |= SDCARD_DMADONE_FLAG;
if (priv->xfrflags == SDCARD_ALLDONE || result == SDIOWAIT_ERROR)
{
lpc17_endtransfer(priv, result);
}
}
#endif
/****************************************************************************
* Data Transfer Helpers
****************************************************************************/
/****************************************************************************
* Name: lpc17_log2
*
* Description:
* Take (approximate) log base 2 of the provided number (Only works if the
* provided number is a power of 2).
*
****************************************************************************/
static uint8_t lpc17_log2(uint16_t value)
{
uint8_t log2 = 0;
/* 0000 0000 0000 0001 -> return 0,
* 0000 0000 0000 001x -> return 1,
* 0000 0000 0000 01xx -> return 2,
* 0000 0000 0000 1xxx -> return 3,
* ...
* 1xxx xxxx xxxx xxxx -> return 15,
*/
DEBUGASSERT(value > 0);
while (value != 1)
{
value >>= 1;
log2++;
}
return log2;
}
/****************************************************************************
* Name: lpc17_dataconfig
*
* Description:
* Configure the SD card data path for the next data transfer
*
****************************************************************************/
static void lpc17_dataconfig(uint32_t timeout, uint32_t dlen, uint32_t dctrl)
{
uint32_t regval = 0;
/* Enable data path */
putreg32(timeout, LPC17_SDCARD_DTIMER); /* Set DTIMER */
putreg32(dlen, LPC17_SDCARD_DLEN); /* Set DLEN */
/* Configure DCTRL DTDIR, DTMODE, and DBLOCKSIZE fields and set the DTEN
* field
*/
regval = getreg32(LPC17_SDCARD_DCTRL);
regval &= ~(SDCARD_DCTRL_DTDIR|SDCARD_DCTRL_DTMODE|SDCARD_DCTRL_DBLOCKSIZE_MASK);
dctrl &= (SDCARD_DCTRL_DTDIR|SDCARD_DCTRL_DTMODE|SDCARD_DCTRL_DBLOCKSIZE_MASK);
regval |= (dctrl|SDCARD_DCTRL_DTEN);
putreg32(regval, LPC17_SDCARD_DCTRL);
}
/****************************************************************************
* Name: lpc17_datadisable
*
* Description:
* Disable the SD card data path setup by lpc17_dataconfig() and
* disable DMA.
*
****************************************************************************/
static void lpc17_datadisable(void)
{
uint32_t regval;
/* Disable the data path */
putreg32(SDCARD_DTIMER_DATATIMEOUT, LPC17_SDCARD_DTIMER); /* Reset DTIMER */
putreg32(0, LPC17_SDCARD_DLEN); /* Reset DLEN */
/* Reset DCTRL DTEN, DTDIR, DTMODE, DMAEN, and DBLOCKSIZE fields */
regval = getreg32(LPC17_SDCARD_DCTRL);
regval &= ~(SDCARD_DCTRL_DTEN|SDCARD_DCTRL_DTDIR|SDCARD_DCTRL_DTMODE|
SDCARD_DCTRL_DMAEN|SDCARD_DCTRL_DBLOCKSIZE_MASK);
putreg32(regval, LPC17_SDCARD_DCTRL);
}
/****************************************************************************
* Name: lpc17_sendfifo
*
* Description:
* Send SD card data in interrupt mode
*
* Input Parameters:
* priv - An instance of the SD card device interface
*
* Returned Value:
* None
*
****************************************************************************/
static void lpc17_sendfifo(struct lpc17_dev_s *priv)
{
union
{
uint32_t w;
uint8_t b[4];
} data;
/* Loop while there is more data to be sent and the RX FIFO is not full */
while (priv->remaining > 0 &&
(getreg32(LPC17_SDCARD_STATUS) & SDCARD_STATUS_TXFIFOF) == 0)
{
/* Is there a full word remaining in the user buffer? */
if (priv->remaining >= sizeof(uint32_t))
{
/* Yes, transfer the word to the TX FIFO */
data.w = *priv->buffer++;
priv->remaining -= sizeof(uint32_t);
}
else
{
/* No.. transfer just the bytes remaining in the user buffer,
* padding with zero as necessary to extend to a full word.
*/
uint8_t *ptr = (uint8_t *)priv->remaining;
int i;
data.w = 0;
for (i = 0; i < priv->remaining; i++)
{
data.b[i] = *ptr++;
}
/* Now the transfer is finished */
priv->remaining = 0;
}
/* Put the word in the FIFO */
putreg32(data.w, LPC17_SDCARD_FIFO);
}
}
/****************************************************************************
* Name: lpc17_recvfifo
*
* Description:
* Receive SD card data in interrupt mode
*
* Input Parameters:
* priv - An instance of the SD card device interface
*
* Returned Value:
* None
*
****************************************************************************/
static void lpc17_recvfifo(struct lpc17_dev_s *priv)
{
union
{
uint32_t w;
uint8_t b[4];
} data;
/* Loop while there is space to store the data and there is more
* data available in the RX FIFO.
*/
while (priv->remaining > 0 &&
(getreg32(LPC17_SDCARD_STATUS) & SDCARD_STATUS_RXDAVL) != 0)
{
/* Read the next word from the RX FIFO */
data.w = getreg32(LPC17_SDCARD_FIFO);
if (priv->remaining >= sizeof(uint32_t))
{
/* Transfer the whole word to the user buffer */
*priv->buffer++ = data.w;
priv->remaining -= sizeof(uint32_t);
}
else
{
/* Transfer any trailing fractional word */
uint8_t *ptr = (uint8_t*)priv->buffer;
int i;
for (i = 0; i < priv->remaining; i++)
{
*ptr++ = data.b[i];
}
/* Now the transfer is finished */
priv->remaining = 0;
}
}
}
/****************************************************************************
* Name: lpc17_eventtimeout
*
* Description:
* The watchdog timeout setup when the event wait start has expired without
* any other waited-for event occurring.
*
* Input Parameters:
* argc - The number of arguments (should be 1)
* arg - The argument (state structure reference cast to uint32_t)
*
* Returned Value:
* None
*
* Assumptions:
* Always called from the interrupt level with interrupts disabled.
*
****************************************************************************/
static void lpc17_eventtimeout(int argc, uint32_t arg)
{
struct lpc17_dev_s *priv = (struct lpc17_dev_s *)arg;
/* There is always race conditions with timer expirations. */
DEBUGASSERT((priv->waitevents & SDIOWAIT_TIMEOUT) != 0 || priv->wkupevent != 0);
/* Is a data transfer complete event expected? */
if ((priv->waitevents & SDIOWAIT_TIMEOUT) != 0)
{
/* Yes.. wake up any waiting threads */
lpc17_endwait(priv, SDIOWAIT_TIMEOUT);
flldbg("Timeout: remaining: %d\n", priv->remaining);
}
}
/****************************************************************************
* Name: lpc17_endwait
*
* Description:
* Wake up a waiting thread if the waited-for event has occurred.
*
* Input Parameters:
* priv - An instance of the SD card device interface
* wkupevent - The event that caused the wait to end
*
* Returned Value:
* None
*
* Assumptions:
* Always called from the interrupt level with interrupts disabled.
*
****************************************************************************/
static void lpc17_endwait(struct lpc17_dev_s *priv, sdio_eventset_t wkupevent)
{
/* Cancel the watchdog timeout */
(void)wd_cancel(priv->waitwdog);
/* Disable event-related interrupts */
lpc17_configwaitints(priv, 0, 0, wkupevent);
/* Wake up the waiting thread */
lpc17_givesem(priv);
}
/****************************************************************************
* Name: lpc17_endtransfer
*
* Description:
* Terminate a transfer with the provided status. This function is called
* only from the SD card interrupt handler when end-of-transfer conditions
* are detected.
*
* Input Parameters:
* priv - An instance of the SD card device interface
* wkupevent - The event that caused the transfer to end
*
* Returned Value:
* None
*
* Assumptions:
* Always called from the interrupt level with interrupts disabled.
*
****************************************************************************/
static void lpc17_endtransfer(struct lpc17_dev_s *priv, sdio_eventset_t wkupevent)
{
/* Disable all transfer related interrupts */
lpc17_configxfrints(priv, 0);
/* Clearing pending interrupt status on all transfer related interrupts */
putreg32(SDCARD_XFRDONE_ICR, LPC17_SDCARD_CLEAR);
/* If this was a DMA transfer, make sure that DMA is stopped */
#ifdef CONFIG_SDIO_DMA
if (priv->dmamode)
{
/* DMA debug instrumentation */
lpc17_sample(priv, SAMPLENDX_END_TRANSFER);
/* Make sure that the DMA is stopped (it will be stopped automatically
* on normal transfers, but not necessarily when the transfer terminates
* on an error condition).
*/
lpc17_dmastop(priv->dma);
}
#endif
/* Mark the transfer finished */
priv->remaining = 0;
/* Is a thread wait for these data transfer complete events? */
if ((priv->waitevents & wkupevent) != 0)
{
/* Yes.. wake up any waiting threads */
lpc17_endwait(priv, wkupevent);
}
}
/****************************************************************************
* Interrrupt Handling
****************************************************************************/
/****************************************************************************
* Name: lpc17_interrupt
*
* Description:
* SD card interrupt handler
*
* Input Parameters:
* dev - An instance of the SD card device interface
*
* Returned Value:
* None
*
****************************************************************************/
static int lpc17_interrupt(int irq, void *context)
{
struct lpc17_dev_s *priv = &g_scard_dev;
uint32_t enabled;
uint32_t pending;
/* Loop while there are pending interrupts. Check the SD card status
* register. Mask out all bits that don't correspond to enabled
* interrupts. (This depends on the fact that bits are ordered
* the same in both the STA and MASK register). If there are non-zero
* bits remaining, then we have work to do here.
*/
while ((enabled = getreg32(LPC17_SDCARD_STATUS) & getreg32(LPC17_SDCARD_MASK0)) != 0)
{
/* Handle in progress, interrupt driven data transfers ****************/
pending = enabled & priv->xfrmask;
if (pending != 0)
{
#ifdef CONFIG_SDIO_DMA
if (!priv->dmamode)
#endif
{
/* Is the RX FIFO half full or more? Is so then we must be
* processing a receive transaction.
*/
if ((pending & SDCARD_STATUS_RXFIFOHF) != 0)
{
/* Receive data from the RX FIFO */
lpc17_recvfifo(priv);
}
/* Otherwise, Is the transmit FIFO half empty or less? If so we must
* be processing a send transaction. NOTE: We can't be processing
* both!
*/
else if ((pending & SDCARD_STATUS_TXFIFOHE) != 0)
{
/* Send data via the TX FIFO */
lpc17_sendfifo(priv);
}
}
/* Handle data end events */
if ((pending & SDCARD_STATUS_DATAEND) != 0)
{
/* Handle any data remaining the RX FIFO. If the RX FIFO is
* less than half full at the end of the transfer, then no
* half-full interrupt will be received.
*/
/* Was this transfer performed in DMA mode? */
#ifdef CONFIG_SDIO_DMA
if (priv->dmamode)
{
/* Yes.. Terminate the transfers only if the DMA has also
* finished.
*/
priv->xfrflags |= SDCARD_XFRDONE_FLAG;
if (priv->xfrflags == SDCARD_ALLDONE)
{
lpc17_endtransfer(priv, SDIOWAIT_TRANSFERDONE);
}
/* Otherwise, just disable futher transfer interrupts and
* wait for the DMA complete event.
*/
else
{
lpc17_configxfrints(priv, 0);
}
}
else
#endif
{
/* Receive data from the RX FIFO */
lpc17_recvfifo(priv);
/* Then terminate the transfer */
lpc17_endtransfer(priv, SDIOWAIT_TRANSFERDONE);
}
}
/* Handle data block send/receive CRC failure */
else if ((pending & SDCARD_STATUS_DCRCFAIL) != 0)
{
/* Terminate the transfer with an error */
flldbg("ERROR: Data block CRC failure, remaining: %d\n", priv->remaining);
lpc17_endtransfer(priv, SDIOWAIT_TRANSFERDONE|SDIOWAIT_ERROR);
}
/* Handle data timeout error */
else if ((pending & SDCARD_STATUS_DTIMEOUT) != 0)
{
/* Terminate the transfer with an error */
flldbg("ERROR: Data timeout, remaining: %d\n", priv->remaining);
lpc17_endtransfer(priv, SDIOWAIT_TRANSFERDONE|SDIOWAIT_TIMEOUT);
}
/* Handle RX FIFO overrun error */
else if ((pending & SDCARD_STATUS_RXOVERR) != 0)
{
/* Terminate the transfer with an error */
flldbg("ERROR: RX FIFO overrun, remaining: %d\n", priv->remaining);
lpc17_endtransfer(priv, SDIOWAIT_TRANSFERDONE|SDIOWAIT_ERROR);
}
/* Handle TX FIFO underrun error */
else if ((pending & SDCARD_STATUS_TXUNDERR) != 0)
{
/* Terminate the transfer with an error */
flldbg("ERROR: TX FIFO underrun, remaining: %d\n", priv->remaining);
lpc17_endtransfer(priv, SDIOWAIT_TRANSFERDONE|SDIOWAIT_ERROR);
}
/* Handle start bit error */
else if ((pending & SDCARD_STATUS_STBITERR) != 0)
{
/* Terminate the transfer with an error */
flldbg("ERROR: Start bit, remaining: %d\n", priv->remaining);
lpc17_endtransfer(priv, SDIOWAIT_TRANSFERDONE|SDIOWAIT_ERROR);
}
}
/* Handle wait events *************************************************/
pending = enabled & priv->waitmask;
if (pending != 0)
{
/* Is this a response completion event? */
if ((pending & SDCARD_RESPDONE_STA) != 0)
{
/* Yes.. Is their a thread waiting for response done? */
if ((priv->waitevents & SDIOWAIT_RESPONSEDONE) != 0)
{
/* Yes.. wake the thread up */
putreg32(SDCARD_RESPDONE_ICR|SDCARD_CMDDONE_ICR, LPC17_SDCARD_CLEAR);
lpc17_endwait(priv, SDIOWAIT_RESPONSEDONE);
}
}
/* Is this a command completion event? */
if ((pending & SDCARD_CMDDONE_STA) != 0)
{
/* Yes.. Is their a thread waiting for command done? */
if ((priv->waitevents & SDIOWAIT_RESPONSEDONE) != 0)
{
/* Yes.. wake the thread up */
putreg32(SDCARD_CMDDONE_ICR, LPC17_SDCARD_CLEAR);
lpc17_endwait(priv, SDIOWAIT_CMDDONE);
}
}
}
}
return OK;
}
/****************************************************************************
* SD card Interface Methods
****************************************************************************/
/****************************************************************************
* Name: lpc17_lock
*
* Description:
* Locks the bus. Function calls low-level multiplexed bus routines to
* resolve bus requests and acknowledgment issues.
*
* Input Parameters:
* dev - An instance of the SD card device interface
* lock - TRUE to lock, FALSE to unlock.
*
* Returned Value:
* OK on success; a negated errno on failure
*
****************************************************************************/
#ifdef CONFIG_SDIO_MUXBUS
static int lpc17_lock(FAR struct sdio_dev_s *dev, bool lock)
{
/* Single SD card instance so there is only one possibility. The multiplex
* bus is part of board support package.
*/
lpc17_muxbus_sdio_lock(lock);
return OK;
}
#endif
/****************************************************************************
* Name: lpc17_reset
*
* Description:
* Reset the SD card controller. Undo all setup and initialization.
*
* Input Parameters:
* dev - An instance of the SD card device interface
*
* Returned Value:
* None
*
****************************************************************************/
static void lpc17_reset(FAR struct sdio_dev_s *dev)
{
FAR struct lpc17_dev_s *priv = (FAR struct lpc17_dev_s *)dev;
irqstate_t flags;
uint32_t regval;
/* Disable clocking */
flags = irqsave();
/* Disable the SD Interface */
regval = getreg32(LPC17_SDCARD_CLOCK);
regval &= ~SDCARD_CLOCK_CLKEN;
putreg32(regval, LPC17_SDCARD_CLOCK);
lpc17_setpwrctrl(SDCARD_PWR_CTRL_OFF);
/* Put SD card registers in their default, reset state */
lpc17_default();
/* Reset data */
priv->waitevents = 0; /* Set of events to be waited for */
priv->waitmask = 0; /* Interrupt enables for event waiting */
priv->wkupevent = 0; /* The event that caused the wakeup */
#ifdef CONFIG_SDIO_DMA
priv->xfrflags = 0; /* Used to synchronize SD card and DMA completion events */
#endif
wd_cancel(priv->waitwdog); /* Cancel any timeouts */
/* Interrupt mode data transfer support */
priv->buffer = 0; /* Address of current R/W buffer */
priv->remaining = 0; /* Number of bytes remaining in the transfer */
priv->xfrmask = 0; /* Interrupt enables for data transfer */
/* DMA data transfer support */
priv->widebus = false; /* Required for DMA support */
#ifdef CONFIG_SDIO_DMA
priv->dmamode = false; /* true: DMA mode transfer */
#endif
/* Configure and enable the SD card peripheral */
lpc17_setclock(LPC17_CLCKCR_INIT|SDCARD_CLOCK_CLKEN);
lpc17_setpwrctrl(SDCARD_PWR_CTRL_ON);
irqrestore(flags);
fvdbg("CLCKR: %08x POWER: %08x\n",
getreg32(LPC17_SDCARD_CLOCK), getreg32(LPC17_SDCARD_PWR));
}
/****************************************************************************
* Name: lpc17_status
*
* Description:
* Get SD card status.
*
* Input Parameters:
* dev - Device-specific state data
*
* Returned Value:
* Returns a bitset of status values (see lpc17_status_* defines)
*
****************************************************************************/
static uint8_t lpc17_status(FAR struct sdio_dev_s *dev)
{
struct lpc17_dev_s *priv = (struct lpc17_dev_s *)dev;
return priv->cdstatus;
}
/****************************************************************************
* Name: lpc17_widebus
*
* Description:
* Called after change in Bus width has been selected (via ACMD6). Most
* controllers will need to perform some special operations to work
* correctly in the new bus mode.
*
* Input Parameters:
* dev - An instance of the SD card device interface
* wide - true: wide bus (4-bit) bus mode enabled
*
* Returned Value:
* None
*
****************************************************************************/
static void lpc17_widebus(FAR struct sdio_dev_s *dev, bool wide)
{
struct lpc17_dev_s *priv = (struct lpc17_dev_s *)dev;
priv->widebus = wide;
}
/****************************************************************************
* Name: lpc17_clock
*
* Description:
* Enable/disable SD card clocking
*
* Input Parameters:
* dev - An instance of the SD card device interface
* rate - Specifies the clocking to use (see enum sdio_clock_e)
*
* Returned Value:
* None
*
****************************************************************************/
static void lpc17_clock(FAR struct sdio_dev_s *dev, enum sdio_clock_e rate)
{
uint32_t clkcr;
switch (rate)
{
/* Disable clocking (with default ID mode divisor) */
default:
case CLOCK_SDIO_DISABLED:
clkcr = LPC17_CLCKCR_INIT;
return;
/* Enable in initial ID mode clocking (<400KHz) */
case CLOCK_IDMODE:
clkcr = (LPC17_CLCKCR_INIT | SDCARD_CLOCK_CLKEN);
break;
/* Enable in MMC normal operation clocking */
case CLOCK_MMC_TRANSFER:
clkcr = (SDCARD_CLOCK_MMCXFR | SDCARD_CLOCK_CLKEN);
lpc17_setpwrctrl(SDCARD_PWR_OPENDRAIN);
break;
/* SD normal operation clocking (wide 4-bit mode) */
case CLOCK_SD_TRANSFER_4BIT:
#ifndef CONFIG_SDIO_WIDTH_D1_ONLY
clkcr = (SDCARD_CLOCK_SDWIDEXFR | SDCARD_CLOCK_CLKEN);
break;
#endif
/* SD normal operation clocking (narrow 1-bit mode) */
case CLOCK_SD_TRANSFER_1BIT:
clkcr = (SDCARD_CLOCK_SDXFR | SDCARD_CLOCK_CLKEN);
break;
}
/* Set the new clock frequency along with the clock enable/disable bit */
lpc17_setclock(clkcr);
}
/****************************************************************************
* Name: lpc17_attach
*
* Description:
* Attach and prepare interrupts
*
* Input Parameters:
* dev - An instance of the SD card device interface
*
* Returned Value:
* OK on success; A negated errno on failure.
*
****************************************************************************/
static int lpc17_attach(FAR struct sdio_dev_s *dev)
{
int ret;
/* Attach the SD card interrupt handler */
ret = irq_attach(LPC17_IRQ_MCI, lpc17_interrupt);
if (ret == OK)
{
/* Disable all interrupts at the SD card controller and clear static
* interrupt flags
*/
putreg32(SDCARD_MASK0_RESET, LPC17_SDCARD_MASK0);
putreg32(SDCARD_CLEAR_STATICFLAGS, LPC17_SDCARD_CLEAR);
/* Enable SD card interrupts at the NVIC. They can now be enabled at
* the SD card controller as needed.
*/
up_enable_irq(LPC17_IRQ_MCI);
}
return ret;
}
/****************************************************************************
* Name: lpc17_sendcmd
*
* Description:
* Send the SD card command
*
* Input Parameters:
* dev - An instance of the SD card device interface
* cmd - The command to send (32-bits, encoded)
* arg - 32-bit argument required with some commands
*
* Returned Value:
* None
*
****************************************************************************/
static int lpc17_sendcmd(FAR struct sdio_dev_s *dev, uint32_t cmd, uint32_t arg)
{
uint32_t regval;
uint32_t cmdidx;
/* Set the SD card Argument value */
putreg32(arg, LPC17_SDCARD_ARG);
/* Clear CMDINDEX, WAITRESP, WAITINT, WAITPEND, and CPSMEN bits */
regval = getreg32(LPC17_SDCARD_CMD);
regval &= ~(SDCARD_CMD_INDEX_MASK|SDCARD_CMD_WAITRESP_MASK|
SDCARD_CMD_WAITINT|SDCARD_CMD_WAITPEND|SDCARD_CMD_CPSMEN);
/* Set WAITRESP bits */
switch (cmd & MMCSD_RESPONSE_MASK)
{
case MMCSD_NO_RESPONSE:
regval |= SDCARD_CMD_NORESPONSE;
break;
case MMCSD_R1_RESPONSE:
case MMCSD_R1B_RESPONSE:
case MMCSD_R3_RESPONSE:
case MMCSD_R4_RESPONSE:
case MMCSD_R5_RESPONSE:
case MMCSD_R6_RESPONSE:
case MMCSD_R7_RESPONSE:
regval |= SDCARD_CMD_SHORTRESPONSE;
break;
case MMCSD_R2_RESPONSE:
regval |= SDCARD_CMD_LONGRESPONSE;
break;
}
/* Set CPSMEN and the command index */
cmdidx = (cmd & MMCSD_CMDIDX_MASK) >> MMCSD_CMDIDX_SHIFT;
regval |= cmdidx | SDCARD_CMD_CPSMEN;
fvdbg("cmd: %08x arg: %08x regval: %08x\n", cmd, arg, regval);
/* Write the SD card CMD */
putreg32(SDCARD_RESPDONE_ICR|SDCARD_CMDDONE_ICR, LPC17_SDCARD_CLEAR);
putreg32(regval, LPC17_SDCARD_CMD);
return OK;
}
/****************************************************************************
* Name: lpc17_recvsetup
*
* Description:
* Setup hardware in preparation for data transfer from the card in non-DMA
* (interrupt driven mode). This method will do whatever controller setup
* is necessary. This would be called for SD memory just BEFORE sending
* CMD13 (SEND_STATUS), CMD17 (READ_SINGLE_BLOCK), CMD18
* (READ_MULTIPLE_BLOCKS), ACMD51 (SEND_SCR), etc. Normally, SDCARD_WAITEVENT
* will be called to receive the indication that the transfer is complete.
*
* Input Parameters:
* dev - An instance of the SD card device interface
* buffer - Address of the buffer in which to receive the data
* nbytes - The number of bytes in the transfer
*
* Returned Value:
* Number of bytes sent on success; a negated errno on failure
*
****************************************************************************/
static int lpc17_recvsetup(FAR struct sdio_dev_s *dev, FAR uint8_t *buffer,
size_t nbytes)
{
struct lpc17_dev_s *priv = (struct lpc17_dev_s *)dev;
uint32_t dblocksize;
DEBUGASSERT(priv != NULL && buffer != NULL && nbytes > 0);
DEBUGASSERT(((uint32_t)buffer & 3) == 0);
/* Reset the DPSM configuration */
lpc17_datadisable();
lpc17_sampleinit();
lpc17_sample(priv, SAMPLENDX_BEFORE_SETUP);
/* Save the destination buffer information for use by the interrupt handler */
priv->buffer = (uint32_t*)buffer;
priv->remaining = nbytes;
#ifdef CONFIG_SDIO_DMA
priv->dmamode = false;
#endif
/* Then set up the SD card data path */
dblocksize = lpc17_log2(nbytes) << SDCARD_DCTRL_DBLOCKSIZE_SHIFT;
lpc17_dataconfig(SDCARD_DTIMER_DATATIMEOUT, nbytes, dblocksize|SDCARD_DCTRL_DTDIR);
/* And enable interrupts */
lpc17_configxfrints(priv, SDCARD_RECV_MASK);
lpc17_sample(priv, SAMPLENDX_AFTER_SETUP);
return OK;
}
/****************************************************************************
* Name: lpc17_sendsetup
*
* Description:
* Setup hardware in preparation for data transfer from the card. This method
* will do whatever controller setup is necessary. This would be called
* for SD memory just AFTER sending CMD24 (WRITE_BLOCK), CMD25
* (WRITE_MULTIPLE_BLOCK), ... and before SDCARD_SENDDATA is called.
*
* Input Parameters:
* dev - An instance of the SD card device interface
* buffer - Address of the buffer containing the data to send
* nbytes - The number of bytes in the transfer
*
* Returned Value:
* Number of bytes sent on success; a negated errno on failure
*
****************************************************************************/
static int lpc17_sendsetup(FAR struct sdio_dev_s *dev, FAR const uint8_t *buffer,
size_t nbytes)
{
struct lpc17_dev_s *priv = (struct lpc17_dev_s *)dev;
uint32_t dblocksize;
DEBUGASSERT(priv != NULL && buffer != NULL && nbytes > 0);
DEBUGASSERT(((uint32_t)buffer & 3) == 0);
/* Reset the DPSM configuration */
lpc17_datadisable();
lpc17_sampleinit();
lpc17_sample(priv, SAMPLENDX_BEFORE_SETUP);
/* Save the source buffer information for use by the interrupt handler */
priv->buffer = (uint32_t*)buffer;
priv->remaining = nbytes;
#ifdef CONFIG_SDIO_DMA
priv->dmamode = false;
#endif
/* Then set up the SD card data path */
dblocksize = lpc17_log2(nbytes) << SDCARD_DCTRL_DBLOCKSIZE_SHIFT;
lpc17_dataconfig(SDCARD_DTIMER_DATATIMEOUT, nbytes, dblocksize);
/* Enable TX interrrupts */
lpc17_configxfrints(priv, SDCARD_SEND_MASK);
lpc17_sample(priv, SAMPLENDX_AFTER_SETUP);
return OK;
}
/****************************************************************************
* Name: lpc17_cancel
*
* Description:
* Cancel the data transfer setup of SDCARD_RECVSETUP, SDCARD_SENDSETUP,
* SDCARD_DMARECVSETUP or SDCARD_DMASENDSETUP. This must be called to cancel
* the data transfer setup if, for some reason, you cannot perform the
* transfer.
*
* Input Parameters:
* dev - An instance of the SD card device interface
*
* Returned Value:
* OK is success; a negated errno on failure
*
****************************************************************************/
static int lpc17_cancel(FAR struct sdio_dev_s *dev)
{
struct lpc17_dev_s *priv = (struct lpc17_dev_s*)dev;
/* Disable all transfer- and event- related interrupts */
lpc17_configxfrints(priv, 0);
lpc17_configwaitints(priv, 0, 0, 0);
/* Clearing pending interrupt status on all transfer- and event- related
* interrupts
*/
putreg32(SDCARD_WAITALL_ICR, LPC17_SDCARD_CLEAR);
/* Cancel any watchdog timeout */
(void)wd_cancel(priv->waitwdog);
/* If this was a DMA transfer, make sure that DMA is stopped */
#ifdef CONFIG_SDIO_DMA
if (priv->dmamode)
{
/* Make sure that the DMA is stopped (it will be stopped automatically
* on normal transfers, but not necessarily when the transfer terminates
* on an error condition.
*/
lpc17_dmastop(priv->dma);
}
#endif
/* Mark no transfer in progress */
priv->remaining = 0;
return OK;
}
/****************************************************************************
* Name: lpc17_waitresponse
*
* Description:
* Poll-wait for the response to the last command to be ready.
*
* Input Parameters:
* dev - An instance of the SD card device interface
* cmd - The command that was sent. See 32-bit command definitions above.
*
* Returned Value:
* OK is success; a negated errno on failure
*
****************************************************************************/
static int lpc17_waitresponse(FAR struct sdio_dev_s *dev, uint32_t cmd)
{
int32_t timeout;
uint32_t events;
switch (cmd & MMCSD_RESPONSE_MASK)
{
case MMCSD_NO_RESPONSE:
events = SDCARD_CMDDONE_STA;
timeout = SDCARD_CMDTIMEOUT;
break;
case MMCSD_R1_RESPONSE:
case MMCSD_R1B_RESPONSE:
case MMCSD_R2_RESPONSE:
case MMCSD_R6_RESPONSE:
events = SDCARD_RESPDONE_STA;
timeout = SDCARD_LONGTIMEOUT;
break;
case MMCSD_R4_RESPONSE:
case MMCSD_R5_RESPONSE:
return -ENOSYS;
case MMCSD_R3_RESPONSE:
case MMCSD_R7_RESPONSE:
events = SDCARD_RESPDONE_STA;
timeout = SDCARD_CMDTIMEOUT;
break;
default:
return -EINVAL;
}
/* Then wait for the response (or timeout) */
while ((getreg32(LPC17_SDCARD_STATUS) & events) == 0)
{
if (--timeout <= 0)
{
fdbg("ERROR: Timeout cmd: %08x events: %08x STA: %08x\n",
cmd, events, getreg32(LPC17_SDCARD_STATUS));
return -ETIMEDOUT;
}
}
putreg32(SDCARD_CMDDONE_ICR, LPC17_SDCARD_CLEAR);
return OK;
}
/****************************************************************************
* Name: lpc17_recvRx
*
* Description:
* Receive response to SD card command. Only the critical payload is
* returned -- that is 32 bits for 48 bit status and 128 bits for 136 bit
* status. The driver implementation should verify the correctness of
* the remaining, non-returned bits (CRCs, CMD index, etc.).
*
* Input Parameters:
* dev - An instance of the SD card device interface
* Rx - Buffer in which to receive the response
*
* Returned Value:
* Number of bytes sent on success; a negated errno on failure. Here a
* failure means only a faiure to obtain the requested reponse (due to
* transport problem -- timeout, CRC, etc.). The implementation only
* assures that the response is returned intacta and does not check errors
* within the response itself.
*
****************************************************************************/
static int lpc17_recvshortcrc(FAR struct sdio_dev_s *dev, uint32_t cmd, uint32_t *rshort)
{
#ifdef CONFIG_DEBUG
uint32_t respcmd;
#endif
uint32_t regval;
int ret = OK;
/* R1 Command response (48-bit)
* 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 card status
* 7:1 bit6 - bit0 CRC7
* 0 1 End bit
*
* R1b Identical to R1 with the additional busy signaling via the data
* line.
*
* 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
*/
#ifdef CONFIG_DEBUG
if (!rshort)
{
fdbg("ERROR: rshort=NULL\n");
ret = -EINVAL;
}
/* Check that this is the correct response to this command */
else if ((cmd & MMCSD_RESPONSE_MASK) != MMCSD_R1_RESPONSE &&
(cmd & MMCSD_RESPONSE_MASK) != MMCSD_R1B_RESPONSE &&
(cmd & MMCSD_RESPONSE_MASK) != MMCSD_R6_RESPONSE)
{
fdbg("ERROR: Wrong response CMD=%08x\n", cmd);
ret = -EINVAL;
}
else
#endif
{
/* Check if a timeout or CRC error occurred */
regval = getreg32(LPC17_SDCARD_STATUS);
if ((regval & SDCARD_STATUS_CTIMEOUT) != 0)
{
fdbg("ERROR: Command timeout: %08x\n", regval);
ret = -ETIMEDOUT;
}
else if ((regval & SDCARD_STATUS_CCRCFAIL) != 0)
{
fdbg("ERROR: CRC failure: %08x\n", regval);
ret = -EIO;
}
#ifdef CONFIG_DEBUG
else
{
/* Check response received is of desired command */
respcmd = getreg32(LPC17_SDCARD_RESPCMD);
if ((uint8_t)(respcmd & SDCARD_RESPCMD_MASK) != (cmd & MMCSD_CMDIDX_MASK))
{
fdbg("ERROR: RESCMD=%02x CMD=%08x\n", respcmd, cmd);
ret = -EINVAL;
}
}
#endif
}
/* Clear all pending message completion events and return the R1/R6 response */
putreg32(SDCARD_RESPDONE_ICR|SDCARD_CMDDONE_ICR, LPC17_SDCARD_CLEAR);
*rshort = getreg32(LPC17_SDCARD_RESP0);
return ret;
}
static int lpc17_recvlong(FAR struct sdio_dev_s *dev, uint32_t cmd, uint32_t rlong[4])
{
uint32_t regval;
int ret = OK;
/* R2 CID, CSD register (136-bit)
* 135 0 Start bit
* 134 0 Transmission bit (0=from card)
* 133:128 bit5 - bit0 Reserved
* 127:1 bit127 - bit1 127-bit CID or CSD register
* (including internal CRC)
* 0 1 End bit
*/
#ifdef CONFIG_DEBUG
/* Check that R1 is the correct response to this command */
if ((cmd & MMCSD_RESPONSE_MASK) != MMCSD_R2_RESPONSE)
{
fdbg("ERROR: Wrong response CMD=%08x\n", cmd);
ret = -EINVAL;
}
else
#endif
{
/* Check if a timeout or CRC error occurred */
regval = getreg32(LPC17_SDCARD_STATUS);
if (regval & SDCARD_STATUS_CTIMEOUT)
{
fdbg("ERROR: Timeout STA: %08x\n", regval);
ret = -ETIMEDOUT;
}
else if (regval & SDCARD_STATUS_CCRCFAIL)
{
fdbg("ERROR: CRC fail STA: %08x\n", regval);
ret = -EIO;
}
}
/* Return the long response */
putreg32(SDCARD_RESPDONE_ICR|SDCARD_CMDDONE_ICR, LPC17_SDCARD_CLEAR);
if (rlong)
{
rlong[0] = getreg32(LPC17_SDCARD_RESP0);
rlong[1] = getreg32(LPC17_SDCARD_RESP1);
rlong[2] = getreg32(LPC17_SDCARD_RESP2);
rlong[3] = getreg32(LPC17_SDCARD_RESP3);
}
return ret;
}
static int lpc17_recvshort(FAR struct sdio_dev_s *dev, uint32_t cmd, uint32_t *rshort)
{
uint32_t regval;
int ret = OK;
/* R3 OCR (48-bit)
* 47 0 Start bit
* 46 0 Transmission bit (0=from card)
* 45:40 bit5 - bit0 Reserved
* 39:8 bit31 - bit0 32-bit OCR register
* 7:1 bit6 - bit0 Reserved
* 0 1 End bit
*/
/* Check that this is the correct response to this command */
#ifdef CONFIG_DEBUG
if ((cmd & MMCSD_RESPONSE_MASK) != MMCSD_R3_RESPONSE &&
(cmd & MMCSD_RESPONSE_MASK) != MMCSD_R7_RESPONSE)
{
fdbg("ERROR: Wrong response CMD=%08x\n", cmd);
ret = -EINVAL;
}
else
#endif
{
/* Check if a timeout occurred (Apparently a CRC error can terminate
* a good response)
*/
regval = getreg32(LPC17_SDCARD_STATUS);
if (regval & SDCARD_STATUS_CTIMEOUT)
{
fdbg("ERROR: Timeout STA: %08x\n", regval);
ret = -ETIMEDOUT;
}
}
putreg32(SDCARD_RESPDONE_ICR|SDCARD_CMDDONE_ICR, LPC17_SDCARD_CLEAR);
if (rshort)
{
*rshort = getreg32(LPC17_SDCARD_RESP0);
}
return ret;
}
/* MMC responses not supported */
static int lpc17_recvnotimpl(FAR struct sdio_dev_s *dev, uint32_t cmd, uint32_t *rnotimpl)
{
putreg32(SDCARD_RESPDONE_ICR|SDCARD_CMDDONE_ICR, LPC17_SDCARD_CLEAR);
return -ENOSYS;
}
/****************************************************************************
* Name: lpc17_waitenable
*
* Description:
* Enable/disable of a set of SD card wait events. This is part of the
* the SDCARD_WAITEVENT sequence. The set of to-be-waited-for events is
* configured before calling lpc17_eventwait. This is done in this way
* to help the driver to eliminate race conditions between the command
* setup and the subsequent events.
*
* The enabled events persist until either (1) SDCARD_WAITENABLE is called
* again specifying a different set of wait events, or (2) SDCARD_EVENTWAIT
* returns.
*
* Input Parameters:
* dev - An instance of the SD card device interface
* eventset - A bitset of events to enable or disable (see SDIOWAIT_*
* definitions). 0=disable; 1=enable.
*
* Returned Value:
* None
*
****************************************************************************/
static void lpc17_waitenable(FAR struct sdio_dev_s *dev,
sdio_eventset_t eventset)
{
struct lpc17_dev_s *priv = (struct lpc17_dev_s*)dev;
uint32_t waitmask;
DEBUGASSERT(priv != NULL);
/* Disable event-related interrupts */
lpc17_configwaitints(priv, 0, 0, 0);
/* Select the interrupt mask that will give us the appropriate wakeup
* interrupts.
*/
waitmask = 0;
if ((eventset & SDIOWAIT_CMDDONE) != 0)
{
waitmask |= SDCARD_CMDDONE_MASK;
}
if ((eventset & SDIOWAIT_RESPONSEDONE) != 0)
{
waitmask |= SDCARD_RESPDONE_MASK;
}
if ((eventset & SDIOWAIT_TRANSFERDONE) != 0)
{
waitmask |= SDCARD_XFRDONE_MASK;
}
/* Enable event-related interrupts */
putreg32(SDCARD_WAITALL_ICR, LPC17_SDCARD_CLEAR);
lpc17_configwaitints(priv, waitmask, eventset, 0);
}
/****************************************************************************
* Name: lpc17_eventwait
*
* Description:
* Wait for one of the enabled events to occur (or a timeout). Note that
* all events enabled by SDCARD_WAITEVENTS are disabled when lpc17_eventwait
* returns. SDCARD_WAITEVENTS must be called again before lpc17_eventwait
* can be used again.
*
* Input Parameters:
* dev - An instance of the SD card device interface
* timeout - Maximum time in milliseconds to wait. Zero means immediate
* timeout with no wait. The timeout value is ignored if
* SDIOWAIT_TIMEOUT is not included in the waited-for eventset.
*
* Returned Value:
* Event set containing the event(s) that ended the wait. Should always
* be non-zero. All events are disabled after the wait concludes.
*
****************************************************************************/
static sdio_eventset_t lpc17_eventwait(FAR struct sdio_dev_s *dev,
uint32_t timeout)
{
struct lpc17_dev_s *priv = (struct lpc17_dev_s*)dev;
sdio_eventset_t wkupevent = 0;
irqstate_t flags;
int ret;
/* There is a race condition here... the event may have completed before
* we get here. In this case waitevents will be zero, but wkupevents will
* be non-zero (and, hopefully, the semaphore count will also be non-zero.
*/
flags = irqsave();
DEBUGASSERT(priv->waitevents != 0 || priv->wkupevent != 0);
/* Check if the timeout event is specified in the event set */
if ((priv->waitevents & SDIOWAIT_TIMEOUT) != 0)
{
int delay;
/* Yes.. Handle a cornercase: The user request a timeout event but
* with timeout == 0?
*/
if (!timeout)
{
/* Then just tell the caller that we already timed out */
wkupevent = SDIOWAIT_TIMEOUT;
goto errout;
}
/* Start the watchdog timer */
delay = MSEC2TICK(timeout);
ret = wd_start(priv->waitwdog, delay, (wdentry_t)lpc17_eventtimeout,
1, (uint32_t)priv);
if (ret != OK)
{
fdbg("ERROR: wd_start failed: %d\n", ret);
}
}
/* Loop until the event (or the timeout occurs). Race conditions are avoided
* by calling lpc17_waitenable prior to triggering the logic that will cause
* the wait to terminate. Under certain race conditions, the waited-for
* may have already occurred before this function was called!
*/
for (;;)
{
/* Wait for an event in event set to occur. If this the event has already
* occurred, then the semaphore will already have been incremented and
* there will be no wait.
*/
lpc17_takesem(priv);
wkupevent = priv->wkupevent;
/* Check if the event has occurred. When the event has occurred, then
* evenset will be set to 0 and wkupevent will be set to a nonzero value.
*/
if (wkupevent != 0)
{
/* Yes... break out of the loop with wkupevent non-zero */
break;
}
}
/* Disable event-related interrupts */
lpc17_configwaitints(priv, 0, 0, 0);
#ifdef CONFIG_SDIO_DMA
priv->xfrflags = 0;
#endif
errout:
irqrestore(flags);
lpc17_dumpsamples(priv);
return wkupevent;
}
/****************************************************************************
* Name: lpc17_callbackenable
*
* Description:
* Enable/disable of a set of SD card callback events. This is part of the
* the SD card callback sequence. The set of events is configured to enabled
* callbacks to the function provided in lpc17_registercallback.
*
* Events are automatically disabled once the callback is performed and no
* further callback events will occur until they are again enabled by
* calling this methos.
*
* Input Parameters:
* dev - An instance of the SD card device interface
* eventset - A bitset of events to enable or disable (see SDIOMEDIA_*
* definitions). 0=disable; 1=enable.
*
* Returned Value:
* None
*
****************************************************************************/
static void lpc17_callbackenable(FAR struct sdio_dev_s *dev,
sdio_eventset_t eventset)
{
struct lpc17_dev_s *priv = (struct lpc17_dev_s*)dev;
fvdbg("eventset: %02x\n", eventset);
DEBUGASSERT(priv != NULL);
priv->cbevents = eventset;
lpc17_callback(priv);
}
/****************************************************************************
* Name: lpc17_registercallback
*
* Description:
* Register a callback that that will be invoked on any media status
* change. Callbacks should not be made from interrupt handlers, rather
* interrupt level events should be handled by calling back on the work
* thread.
*
* When this method is called, all callbacks should be disabled until they
* are enabled via a call to SDCARD_CALLBACKENABLE
*
* Input Parameters:
* dev - Device-specific state data
* callback - The funtion to call on the media change
* arg - A caller provided value to return with the callback
*
* Returned Value:
* 0 on success; negated errno on failure.
*
****************************************************************************/
static int lpc17_registercallback(FAR struct sdio_dev_s *dev,
worker_t callback, void *arg)
{
struct lpc17_dev_s *priv = (struct lpc17_dev_s*)dev;
/* Disable callbacks and register this callback and is argument */
fvdbg("Register %p(%p)\n", callback, arg);
DEBUGASSERT(priv != NULL);
priv->cbevents = 0;
priv->cbarg = arg;
priv->callback = callback;
return OK;
}
/****************************************************************************
* Name: lpc17_dmasupported
*
* Description:
* Return true if the hardware can support DMA
*
* Input Parameters:
* dev - An instance of the SD card device interface
*
* Returned Value:
* true if DMA is supported.
*
****************************************************************************/
#ifdef CONFIG_SDIO_DMA
static bool lpc17_dmasupported(FAR struct sdio_dev_s *dev)
{
return true;
}
#endif
/****************************************************************************
* Name: lpc17_dmarecvsetup
*
* Description:
* Setup to perform a read DMA. If the processor supports a data cache,
* then this method will also make sure that the contents of the DMA memory
* and the data cache are coherent. For read transfers this may mean
* invalidating the data cache.
*
* Input Parameters:
* dev - An instance of the SD card device interface
* buffer - The memory to DMA from
* buflen - The size of the DMA transfer in bytes
*
* Returned Value:
* OK on success; a negated errno on failure
*
****************************************************************************/
#ifdef CONFIG_SDIO_DMA
static int lpc17_dmarecvsetup(FAR struct sdio_dev_s *dev, FAR uint8_t *buffer,
size_t buflen)
{
struct lpc17_dev_s *priv = (struct lpc17_dev_s *)dev;
uint32_t dblocksize;
uint32_t regval;
int ret = -EINVAL;
DEBUGASSERT(priv != NULL && buffer != NULL && buflen > 0);
DEBUGASSERT(((uint32_t)buffer & 3) == 0);
/* Reset the DPSM configuration */
lpc17_datadisable();
/* Wide bus operation is required for DMA */
if (priv->widebus)
{
lpc17_sampleinit();
lpc17_sample(priv, SAMPLENDX_BEFORE_SETUP);
/* Save the destination buffer information for use by the interrupt handler */
priv->buffer = (uint32_t*)buffer;
priv->remaining = buflen;
priv->dmamode = true;
/* Then set up the SD card data path */
dblocksize = lpc17_log2(buflen) << SDCARD_DCTRL_DBLOCKSIZE_SHIFT;
lpc17_dataconfig(SDCARD_DTIMER_DATATIMEOUT, buflen, dblocksize|SDCARD_DCTRL_DTDIR);
/* Configure the RX DMA */
lpc17_configxfrints(priv, SDCARD_DMARECV_MASK);
regval = getreg32(LPC17_SDCARD_DCTRL);
regval |= SDCARD_DCTRL_DMAEN;
putreg32(regval, LPC17_SDCARD_DCTRL);
ret = lpc17_dmasetup(priv->dma, SDCARD_RXDMA32_CONTROL,
SDCARD_RXDMA32_CONFIG, LPC17_SDCARD_FIFO,
(uint32_t)buffer, (buflen + 3) >> 2);
if (ret == OK)
{
/* Start the DMA */
lpc17_sample(priv, SAMPLENDX_BEFORE_ENABLE);
lpc17_dmastart(priv->dma, lpc17_dmacallback, priv);
lpc17_sample(priv, SAMPLENDX_AFTER_SETUP);
}
}
return ret;
}
#endif
/****************************************************************************
* Name: lpc17_dmasendsetup
*
* Description:
* Setup to perform a write DMA. If the processor supports a data cache,
* then this method will also make sure that the contents of the DMA memory
* and the data cache are coherent. For write transfers, this may mean
* flushing the data cache.
*
* Input Parameters:
* dev - An instance of the SD card device interface
* buffer - The memory to DMA into
* buflen - The size of the DMA transfer in bytes
*
* Returned Value:
* OK on success; a negated errno on failure
*
****************************************************************************/
#ifdef CONFIG_SDIO_DMA
static int lpc17_dmasendsetup(FAR struct sdio_dev_s *dev,
FAR const uint8_t *buffer, size_t buflen)
{
struct lpc17_dev_s *priv = (struct lpc17_dev_s *)dev;
uint32_t dblocksize;
uint32_t regval;
int ret = -EINVAL;
DEBUGASSERT(priv != NULL && buffer != NULL && buflen > 0);
DEBUGASSERT(((uint32_t)buffer & 3) == 0);
/* Reset the DPSM configuration */
lpc17_datadisable();
/* Wide bus operation is required for DMA */
if (priv->widebus)
{
lpc17_sampleinit();
lpc17_sample(priv, SAMPLENDX_BEFORE_SETUP);
/* Save the source buffer information for use by the interrupt handler */
priv->buffer = (uint32_t*)buffer;
priv->remaining = buflen;
priv->dmamode = true;
/* Then set up the SD card data path */
dblocksize = lpc17_log2(buflen) << SDCARD_DCTRL_DBLOCKSIZE_SHIFT;
lpc17_dataconfig(SDCARD_DTIMER_DATATIMEOUT, buflen, dblocksize);
/* Configure the TX DMA */
ret = lpc17_dmasetup(priv->dma, SDCARD_TXDMA32_CONTROL,
SDCARD_TXDMA32_CONFIG, (uint32_t)buffer,
LPC17_SDCARD_FIFO, (buflen + 3) >> 2);
if (ret == OK)
{
lpc17_sample(priv, SAMPLENDX_BEFORE_ENABLE);
regval = getreg32(LPC17_SDCARD_DCTRL);
regval |= SDCARD_DCTRL_DMAEN;
putreg32(regval, LPC17_SDCARD_DCTRL);
/* Start the DMA */
lpc17_dmastart(priv->dma, lpc17_dmacallback, priv);
lpc17_sample(priv, SAMPLENDX_AFTER_SETUP);
/* Enable TX interrrupts */
lpc17_configxfrints(priv, SDCARD_DMASEND_MASK);
}
}
return ret;
}
#endif
/****************************************************************************
* Initialization/uninitialization/reset
****************************************************************************/
/****************************************************************************
* Name: lpc17_callback
*
* Description:
* Perform callback.
*
* Assumptions:
* This function does not execute in the context of an interrupt handler.
* It may be invoked on any user thread or scheduled on the work thread
* from an interrupt handler.
*
****************************************************************************/
static void lpc17_callback(void *arg)
{
struct lpc17_dev_s *priv = (struct lpc17_dev_s*)arg;
/* Is a callback registered? */
DEBUGASSERT(priv != NULL);
fvdbg("Callback %p(%p) cbevents: %02x cdstatus: %02x\n",
priv->callback, priv->cbarg, priv->cbevents, priv->cdstatus);
if (priv->callback)
{
/* Yes.. Check for enabled callback events */
if ((priv->cdstatus & SDIO_STATUS_PRESENT) != 0)
{
/* Media is present. Is the media inserted event enabled? */
if ((priv->cbevents & SDIOMEDIA_INSERTED) == 0)
{
/* No... return without performing the callback */
return;
}
}
else
{
/* Media is not present. Is the media eject event enabled? */
if ((priv->cbevents & SDIOMEDIA_EJECTED) == 0)
{
/* No... return without performing the callback */
return;
}
}
/* Perform the callback, disabling further callbacks. Of course, the
* the callback can (and probably should) re-enable callbacks.
*/
priv->cbevents = 0;
/* Callbacks cannot be performed in the context of an interrupt handler.
* If we are in an interrupt handler, then queue the callback to be
* performed later on the work thread.
*/
if (up_interrupt_context())
{
/* Yes.. queue it */
fvdbg("Queuing callback to %p(%p)\n", priv->callback, priv->cbarg);
(void)work_queue(HPWORK, &priv->cbwork, (worker_t)priv->callback, priv->cbarg, 0);
}
else
{
/* No.. then just call the callback here */
fvdbg("Callback to %p(%p)\n", priv->callback, priv->cbarg);
priv->callback(priv->cbarg);
}
}
}
/****************************************************************************
* Name: lpc17_default
*
* Description:
* Restore SD card registers to their default, reset values
*
****************************************************************************/
static void lpc17_default(void)
{
putreg32(SDCARD_PWR_RESET, LPC17_SDCARD_PWR);
putreg32(SDCARD_CLOCK_RESET, LPC17_SDCARD_CLOCK);
putreg32(SDCARD_ARG_RESET, LPC17_SDCARD_ARG);
putreg32(SDCARD_CMD_RESET, LPC17_SDCARD_CMD);
putreg32(SDCARD_DTIMER_RESET, LPC17_SDCARD_DTIMER);
putreg32(SDCARD_DLEN_RESET, LPC17_SDCARD_DLEN);
putreg32(SDCARD_DCTRL_RESET, LPC17_SDCARD_DCTRL);
putreg32(SDCARD_CLEAR_RESET, LPC17_SDCARD_CLEAR);
putreg32(SDCARD_MASK0_RESET, LPC17_SDCARD_MASK0);
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: sdio_initialize
*
* Description:
* Initialize SD card for operation.
*
* Input Parameters:
* slotno - Not used.
*
* Returned Values:
* A reference to an SD card interface structure. NULL is returned on failures.
*
****************************************************************************/
FAR struct sdio_dev_s *sdio_initialize(int slotno)
{
uint32_t regval;
/* There is only one slot */
struct lpc17_dev_s *priv = &g_scard_dev;
/* Enable power on SD Interface */
regval = getreg32(LPC17_SYSCON_PCONP);
regval |= SYSCON_PCONP_PCSDC;
putreg32(regval, LPC17_SYSCON_PCONP);
/* Initialize the SD card slot structure */
sem_init(&priv->waitsem, 0, 0);
priv->waitwdog = wd_create();
DEBUGASSERT(priv->waitwdog);
#ifdef CONFIG_SDIO_DMA
/* Configure the SDCARD DMA request */
lpc17_dmaconfigure(DMA_REQ_SDCARD, DMA_DMASEL_SDCARD);
/* Allocate a DMA channel for SDCARD DMA */
priv->dma = lpc17_dmachannel();
DEBUGASSERT(priv->dma);
#endif
/* Configure GPIOs for 4-bit, wide-bus operation.
*
* If bus is multiplexed then there is a custom bus configuration utility
* in the scope of the board support package.
*/
#ifndef CONFIG_SDIO_MUXBUS
lpc17_configgpio(GPIO_SD_DAT0);
#ifndef CONFIG_SDIO_WIDTH_D1_ONLY
lpc17_configgpio(GPIO_SD_DAT1);
lpc17_configgpio(GPIO_SD_DAT2);
lpc17_configgpio(GPIO_SD_DAT3);
#endif
lpc17_configgpio(GPIO_SD_CLK);
lpc17_configgpio(GPIO_SD_CMD);
#endif
/* Reset the card and assure that it is in the initial, unconfigured
* state.
*/
lpc17_reset(&priv->dev);
return &g_scard_dev.dev;
}
/****************************************************************************
* Name: sdio_mediachange
*
* Description:
* Called by board-specific logic -- posssible from an interrupt handler --
* in order to signal to the driver that a card has been inserted or
* removed from the slot
*
* Input Parameters:
* dev - An instance of the SD card driver device state structure.
* cardinslot - true is a card has been detected in the slot; false if a
* card has been removed from the slot. Only transitions
* (inserted->removed or removed->inserted should be reported)
*
* Returned Values:
* None
*
****************************************************************************/
void sdio_mediachange(FAR struct sdio_dev_s *dev, bool cardinslot)
{
struct lpc17_dev_s *priv = (struct lpc17_dev_s *)dev;
uint8_t cdstatus;
irqstate_t flags;
/* Update card status */
flags = irqsave();
cdstatus = priv->cdstatus;
if (cardinslot)
{
priv->cdstatus |= SDIO_STATUS_PRESENT;
}
else
{
priv->cdstatus &= ~SDIO_STATUS_PRESENT;
}
fvdbg("cdstatus OLD: %02x NEW: %02x\n", cdstatus, priv->cdstatus);
/* Perform any requested callback if the status has changed */
if (cdstatus != priv->cdstatus)
{
lpc17_callback(priv);
}
irqrestore(flags);
}
/****************************************************************************
* Name: sdio_wrprotect
*
* Description:
* Called by board-specific logic to report if the card in the slot is
* mechanically write protected.
*
* Input Parameters:
* dev - An instance of the SD card driver device state structure.
* wrprotect - true is a card is writeprotected.
*
* Returned Values:
* None
*
****************************************************************************/
void sdio_wrprotect(FAR struct sdio_dev_s *dev, bool wrprotect)
{
struct lpc17_dev_s *priv = (struct lpc17_dev_s *)dev;
irqstate_t flags;
/* Update card status */
flags = irqsave();
if (wrprotect)
{
priv->cdstatus |= SDIO_STATUS_WRPROTECTED;
}
else
{
priv->cdstatus &= ~SDIO_STATUS_WRPROTECTED;
}
fvdbg("cdstatus: %02x\n", priv->cdstatus);
irqrestore(flags);
}
#endif /* CONFIG_LPC17_SDCARD */
