chinky/rtt-f030
chinky
/
rtt-f030
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
rtt-f030/bsp/AE210P/driver/sd/sdd.c

2952 lines
82 KiB
C
Raw Blame History

/*****************************************************************************
*
* Copyright Andes Technology Corporation 2007-2008
* All Rights Reserved.
*
* Revision History:
*
* Aug.21.2007 Created.
****************************************************************************/
/*****************************************************************************
*
* FILE NAME VERSION
*
* sdd.c
*
* DESCRIPTION
*
* SD driver implementation. (Nucleus I/O Driver Architecture)
*
* SDC CONTROL LOGIC
*
* -------------------------------------------------------------------------
* SDC controls <-> SDC Registers <-> SD In-Card Controller
* -------------------------------------------------------------------------
* SD commands <-> SDC CMD/RSP reg <-> SD Command/Data Line
* -------------------------------------------------------------------------
* SD data <-> SDC Data Window <-> SD Memory
* -------------------------------------------------------------------------
*
* DATA STRUCTURES
*
* None
*
* DEPENDENCIES
*
* sdd.h SD driver common header file
*
****************************************************************************/
#include "sdd.h"
#include "sdd_sd.h"
#include "../../library/ndsvfs/sys_arch.h"
#include "../../library/ndsvfs/include/ndsbdev.h"
#include "bsp_hal.h"
static uint32_t sdd_hisr_stack[SDD_HISR_STACK_SIZE];
/* driver context */
static SDD_DATA sdd __attribute__ ((aligned(4))) = { 0};
#if (SDD_VFS_SUPPORT)
// sdc block device context
static NDS_BDEV sdd_bdev __attribute__((aligned(4))) = {0};
#endif // SDD_VFS_SUPPORT
/*****************************************************************************
* FUNCTION
*
* _sdd_alloc_dma_channel
*
* DESCRIPTION
*
*
* This function allocate a dma channel for use of sd data transfer.
*
* NOTE
*
*
* INPUTS
*
* None
*
* OUTPUTS
*
* None
*
****************************************************************************/
static inline uint32_t _sdd_alloc_dma_channel(void)
{
uint32_t status = HAL_SUCCESS;
/*
* This is function is for code path simplification so it will not
* check validity of sdd struct again.
*/
/* Try APB DMA first ... */
/* (in) DMAD_DMAC_AHB_CORE, DMAD_DMAC_APB_CORE */
sdd.dma_ch.controller = DMAD_DMAC_APB_CORE;
/* (in) Burst mode (0: no burst 1-, 1: burst 4- data cycles per dma cycle) */
sdd.dma_ch.apbch_req.burst_mode = 0;
/* (in) APBBR_DATAWIDTH_4(word), APBBR_DATAWIDTH_2(half-word), APBBR_DATAWIDTH_1(byte) */
sdd.dma_ch.apbch_req.data_width = APBBR_DATAWIDTH_4;
/* (in) APBBR_ADDRINC_xxx */
sdd.dma_ch.apbch_req.src_addr_ctrl = APBBR_ADDRINC_FIXED;
/* (in) APBBR_REQN_xxx (also used to help determine bus selection) */
sdd.dma_ch.apbch_req.src_index = _dmad_get_reqn(sdd.dma_ch.controller, APB_SDC);
/* (in) APBBR_ADDRINC_xxx */
sdd.dma_ch.apbch_req.dst_addr_ctrl = APBBR_ADDRINC_I4X;
/* (in) APBBR_REQN_xxx (also used to help determine bus selection) */
sdd.dma_ch.apbch_req.dst_index = APBBR_REQN_NONE;
status = _dmad_channel_alloc(&sdd.dma_ch, HAL_TRUE);
if (status != HAL_SUCCESS) {
if (status != HAL_ERR_UNAVAILABLE)
return status;
/* Try AHB DMAC again for lucky ... */
/* (in) DMAD_DMAC_AHB_CORE, DMAD_DMAC_APB_CORE */
sdd.dma_ch.controller = DMAD_DMAC_AHB_CORE;
/* (in) non-zero if src and dst have different clock domain */
sdd.dma_ch.ahbch_req.sync = 1;
/* (in) DMAC_CSR_CHPRI_0 (lowest) ~ DMAC_CSR_CHPRI_3 (highest) */
sdd.dma_ch.ahbch_req.priority = DMAC_CSR_CHPRI_0;
/* (in) non-zero to enable hardware handshake mode */
sdd.dma_ch.ahbch_req.hw_handshake = 1;
/* (in) DMAC_CSR_SIZE_1 ~ DMAC_CSR_SIZE_256 */
sdd.dma_ch.ahbch_req.burst_size = DMAC_CSR_SIZE_1;
/* (in) DMAC_CSR_WIDTH_8, DMAC_CSR_WIDTH_16, or DMAC_CSR_WIDTH_32 */
sdd.dma_ch.ahbch_req.src_width = DMAC_CSR_WIDTH_32;
/* (in) DMAC_CSR_AD_INC, DMAC_CSR_AD_DEC, or DMAC_CSR_AD_FIX */
sdd.dma_ch.ahbch_req.src_addr_ctrl = DMAC_CSR_AD_FIX;
/* (in) DMAC_REQN_xxx (also used to help determine channel number) */
sdd.dma_ch.ahbch_req.src_index = DMAC_REQN_SDC;
sdd.dma_ch.ahbch_req.src_reqn = _dmad_get_reqn(sdd.dma_ch.controller, AHB_SDC);
/* (in) DMAC_CSR_WIDTH_8, DMAC_CSR_WIDTH_16, or DMAC_CSR_WIDTH_32 */
sdd.dma_ch.ahbch_req.dst_width = DMAC_CSR_WIDTH_32;
/* (in) DMAC_CSR_AD_INC, DMAC_CSR_AD_DEC, or DMAC_CSR_AD_FIX */
sdd.dma_ch.ahbch_req.dst_addr_ctrl = DMAC_CSR_AD_INC;
/* (in) DMAC_REQN_xxx (also used to help determine channel number) */
sdd.dma_ch.ahbch_req.dst_index = DMAC_REQN_NONE;
sdd.dma_ch.ahbch_req.dst_reqn = AHB_REQN_NONE;
status = _dmad_channel_alloc(&sdd.dma_ch, HAL_TRUE);
}
SDD_TRACE(("sdd dma channel(%d) controller(%d)\r\n",
sdd.dma_ch.channel, sdd.dma_ch.controller));
return status;
}
static inline void _sdd_free_dma_channel(void)
{
_dmad_channel_free(&sdd.dma_ch);
}
/*****************************************************************************
* FUNCTION
*
* _sdd_cd_reset
*
* DESCRIPTION
*
* This function performs card-detection initialization and card remove
* clean-up tasks.
*
* NOTE
*
*
* INPUTS
*
* insert : non-zero to perform card-inserting tasks, zero for removing.
*
* OUTPUTS
*
* uint32_t : Returns HAL_SUCCESS if successful initialization,
* else positive value is SSPD-specific error code,
* else negative value is NU system error code.
*
****************************************************************************/
static uint32_t _sdd_cd_reset(uint8_t insert)
{
uint32_t status = HAL_SUCCESS; /* Return status code */
SD_R32 sd_rsp32; /* SD card command response 32-bit */
SD_R128 sd_rsp128; /* SD card command response 128-bit */
char *tmp_str;
uint32_t tmp_val;
SDD_TRACE(("_sdd_cd_reset\r\n"));
/* ------------ */
/* Reset host SDC */
SETB32(SDC_CMD, SDC_SDC_RST_BIT);
while (GETB32(SDC_CMD, SDC_SDC_RST_BIT) != 0) ;
/* Perform card removal tasks */
if (insert != HAL_TRUE) {
/* Stop pending DMA ? */
/* Turn off SD bus power */
CLRB32(SDC_PWR_CTL, SDC_SD_POWER_ON_BIT);
/* Turn off SD bus clock */
SETB32(SDC_CLK_CTL, SDC_CLK_DIS_BIT);
/* Setup removed flag */
sdd.card_desc.rca = 0;
#if (SDD_VFS_SUPPORT)
// notify file system layer, if any ...
if (sdd_bdev.propagate_event != HAL_NULL)
sdd_bdev.propagate_event(&sdd_bdev, NDSBDEV_DEVICE_UNPLUG, HAL_NULL);
#endif // SDD_VFS_SUPPORT
return HAL_SUCCESS;
}
/* ------------ */
/* Turn on SD card power using default voltage level */
SETB32(SDC_PWR_CTL, SDC_SD_POWER_ON_BIT);
_nds_kwait(0x1000);
/* ------------ */
/* Turn on SD bus clock, apply max freq-division value (smallest frequency) */
OUT32(SDC_CLK_CTL, (SDC_CLK_ON << SDC_CLK_DIS_BIT) |
(SDC_CLK_SD << SDC_CLK_SD_BIT) | SDC_CLK_DIV_MASK);
_nds_kwait(0x1000);
SDD_TRACE(("power-on & clock-on!\r\n"));
/* Perform card initialization & identification process */
/* Idle State -> Ready State */
/* - CMD0 */
SDD_TRACE(("CMD0\r\n"));
status = _sd_cmd0();
if (status != HAL_SUCCESS)
goto _err_exit;
/* - CMD8 */
SDD_TRACE(("CMD8\r\n"));
status = _sd_cmd8(SD_CMD8_MAKE_ARG(SD_VHS_2_7V_3_6V, SD_CMD8_DEFAULT_PTN), &sd_rsp32);
if (status != HAL_SUCCESS) {
if ((status != SDD_RSP_TIMEOUT) && (status != SDD_CMD_TIMEOUT))
goto _err_exit;
sdd.card_desc.version = SDD_SPEC_1XX;
}
else {
/* version 2.0 or later card */
/* validates CMD8 response */
if ((SD_R7_GET_PTN(sd_rsp32) != 0xaa) || (SD_R7_GET_VHS(sd_rsp32) == 0x00)) {
/* unusable card */
status = SDD_INVALID_MEDIA;
goto _err_exit;
}
sdd.card_desc.version = SDD_SPEC_200;
}
/* - ACMD41 */
SDD_TRACE(("ACMD41\r\n"));
{
uint32_t retry = 0;
uint32_t timeout = 1;
uint32_t sd_hcs = SD_HCS_SD; /* SD(0) or SDHC(1) for ACMD41 */
/*
* HCS should be 0 if CMD8 does not response.
* HCS is 1 if host supports SDHC (AG101 does not support SDHC).
*/
if (sdd.card_desc.version == SDD_SPEC_200)
{
sd_hcs = SD_HCS_SDHC;
}
/* issue ACMD41 to get OCR */
while (retry++ < SD_ACMD41_MAX_RETRY_COUNT) {
/* cases: */
/* - v2.0 or latter SD memory card - voltage mismatch */
/* - v1.x SD memory card */
/* - not SD memory card */
SDD_TRACE(("cmd55\r\n"));
/* notify card we're going to send an ACMD, RCA is 0x00 in card's idle state */
status = _sd_cmd55(0x00, &sd_rsp32);
if (status != HAL_SUCCESS)
goto _err_exit;
if (SD_CSR_GET_APP_CMD(sd_rsp32) == 0) {
/* error if card was not expecting ACMD */
status = SDD_NOT_SUPPORT_ACMD;
goto _err_exit;
}
SDD_TRACE(("acmd41\r\n"));
status = _sd_acmd41(SD_ACMD41_MAKE_ARG(sd_hcs), &sd_rsp32);
if (status != HAL_SUCCESS) {
/* no response - not a SD memory card */
goto _err_exit;
}
/* Continue if the OCR power state is not ready yet */
if (SD_OCR_GET_BUSY(sd_rsp32) == 1) {
/* card power up status is ready */
sdd.card_desc.card_ccs =
((SD_OCR_GET_CCS(sd_rsp32) == SD_CCS_SDHC) ? SDD_CCS_SDHC : SDD_CCS_SD);
sdd.card_desc.vdd_window = SD_OCR_GET_VDD(sd_rsp32);
timeout = 0;
break;
}
}
if (timeout) {
/*
* unusable card
* - no compatible voltage range (go to inactive state)
* - timeout (no resposne or timeout)
*/
SDD_TRACE(("timeout!\r\n"));
status = SDD_INVALID_MEDIA;
goto _err_exit;
}
}
/* Ready State -> Identification State */
/* - CMD2 */
SDD_TRACE(("CMD2\r\n"));
status = _sd_cmd2(&sd_rsp128);
if (status != HAL_SUCCESS)
goto _err_exit;
sdd.card_desc.mfg_id = SD_CID_GET_MID(sd_rsp128); /* ID */
tmp_str = (char *)SD_CID_GET_OID_PTR(sd_rsp128); /* string */
sdd.card_desc.oem_id[0] = tmp_str[0];
sdd.card_desc.oem_id[1] = tmp_str[1];
sdd.card_desc.oem_id[2] = 0x00;
tmp_str = (char *)SD_CID_GET_PNM_PTR(sd_rsp128); /* string */
sdd.card_desc.prod_name[0] = tmp_str[0];
sdd.card_desc.prod_name[1] = tmp_str[1];
sdd.card_desc.prod_name[2] = tmp_str[2];
sdd.card_desc.prod_name[3] = tmp_str[3];
sdd.card_desc.prod_name[4] = tmp_str[4];
sdd.card_desc.prod_name[5] = 0x00;
tmp_val = (uint32_t) SD_CID_GET_PRV(sd_rsp128); /* BCD */
sdd.card_desc.prod_rev[0] = (char)((tmp_val >> 4) + 0x30);
sdd.card_desc.prod_rev[1] = (char)'.';
sdd.card_desc.prod_rev[2] = (char)((tmp_val & 0x0f) + 0x30);
sdd.card_desc.prod_rev[3] = 0x00;
sdd.card_desc.prod_sn = (uint32_t) SD_CID_GET_PSN(sd_rsp128); /* 32-bit word value */
tmp_val = (uint32_t) SD_CID_GET_MDT(sd_rsp128); /* 12-bit value */
sdd.card_desc.mfg_year = (uint16_t) (tmp_val >> 4) + 2000;
sdd.card_desc.mfg_month = (uint16_t) (tmp_val & 0x0f);
SDD_TRACE(("oem_id : 0x%081x\r\n", sdd.card_desc.oem_id));
SDD_TRACE(("prod_name : %s\r\n", sdd.card_desc.prod_name));
SDD_TRACE(("prod_rev : 0x%081x\r\n",sdd.card_desc.prod_rev));
SDD_TRACE(("prod_sn : 0x%08lx\r\n", sdd.card_desc.prod_sn));
SDD_TRACE(("mfg_year : %d\r\n", sdd.card_desc.mfg_year));
SDD_TRACE(("mfg_month : %d\r\n", sdd.card_desc.mfg_month));
/* Identification -> Standby State */
/* - CMD3 */
SDD_TRACE(("CMD3\r\n"));
status = _sd_cmd3(&sd_rsp32);
if (status != HAL_SUCCESS)
goto _err_exit;
if (SD_R6_GET_CSR_ERR(sd_rsp32)) {
status = SDD_CMD_ERROR;
goto _err_exit;
}
sdd.card_desc.rca = SD_R6_GET_RCA(sd_rsp32);
SDD_TRACE(("New RCA: 0x%08lx\r\n", sdd.card_desc.rca));
/*
* Get CSD register (Standby -> Standby)
* (Majorly we need the data access timing and SD bus clock)
*/
/* - CMD9 */
SDD_TRACE(("Get CSD (CMD9)\r\n"));
status = _sd_cmd9(sdd.card_desc.rca, &sd_rsp128);
if (status != HAL_SUCCESS)
goto _err_exit;
tmp_val = SD_CSD_GET_CSD_STRUCTURE(sd_rsp128);
SDD_TRACE(("CSD r0: 0x%08lx\r\n", sd_rsp128.r[0]));
SDD_TRACE(("CSD r1: 0x%08lx\r\n", sd_rsp128.r[1]));
SDD_TRACE(("CSD r2: 0x%08lx\r\n", sd_rsp128.r[2]));
SDD_TRACE(("CSD r3: 0x%08lx\r\n", sd_rsp128.r[3]));
{
static uint32_t taac_tu2ns[] = {
/*
* Note: Due to minimum is 1, taac did not divided by 10 initially.
* Values derived from this taac has to be divided by 10.
*/
1, 10, 100, 1000, 10000, 100000, 1000000, 10000000
};
static uint32_t ts_tu2bps[] = {
/*
* Note: Reserved index (4~7) will map to 0,
* others are divided by 10 to avoid floating point operation.
*/
1000, 100000, 1000000, 10000000, 0, 0, 0, 0
};
static uint32_t taac_ts_tv2flt[] = {
/*
* Note: Reserved index (0) will map to 0,
* other value are multiplied with 10 to avoid floating point operation.
*/
0, 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60,
70, 80
};
if (tmp_val == 0x00) {
/* Standard SD */
float sdc_clk_ns; /* SDC to card bus clock */
float sdc_read_to_ns, sdc_write_to_ns; /* read/write timeout (ns) */
SDD_TRACE(("CSD v1.0\r\n"));
SDD_TRACE(("taac : 0x%08lx\r\n", SD_CSD_GET_TAAC(sd_rsp128)));
SDD_TRACE(("nsac : 0x%08lx\r\n", SD_CSD_GET_NSAC(sd_rsp128)));
/* CSD structure version */
sdd.card_desc.csd_ver = 0x01;
/* obtain card maximum transfer speed (bps) */
tmp_val = SD_CSD_GET_TRAN_SPEED(sd_rsp128);
sdd.card_desc.max_dataline_rate =
(taac_ts_tv2flt[SD_TRAN_SPEED_TV(tmp_val)] *
ts_tu2bps[SD_TRAN_SPEED_TU(tmp_val)]);
SDD_TRACE(("line_speed : 0x%08lx (bps)\r\n", sdd.card_desc.max_dataline_rate));
/* AG101 SDC transfer speed limits */
// if (sdd.card_desc.max_dataline_rate > 25000000)
// sdd.card_desc.max_dataline_rate = 25000000;
/*
* assume we would like to reach the maximum transfer speed,
* backward derive SDC_CLK_DIC ...
*/
sdd.card_desc.sdc_clk_div =
MB_PCLK / (sdd.card_desc.max_dataline_rate << 1);
if (sdd.card_desc.sdc_clk_div > 0)
sdd.card_desc.sdc_clk_div -= 1;
/* obtain real SDC clock frequency */
sdd.card_desc.sdc_clk_freq =
MB_PCLK / ((sdd.card_desc.sdc_clk_div + 1) << 1);
/*
* obtain card read access time 1 (TAAC, ns)
* note that this is 10x value, use of taac has to be divide by 10.
*/
tmp_val = SD_CSD_GET_TAAC(sd_rsp128);
sdd.card_desc.async_access_time =
taac_ts_tv2flt[SD_TAAC_TV(tmp_val)] *
taac_tu2ns[SD_TAAC_TU(tmp_val)];
/* obtain card read access time 2 (NSAC * 100, clocks) */
sdd.card_desc.read_access_clks = SD_CSD_GET_NSAC(sd_rsp128) * 100; /* (NSAC * 100) Hz */
/* obtain programming time multiplication factor */
sdd.card_desc.prog_factor = (1 << SD_CSD_GET_R2W_FACTOR(sd_rsp128));
/* obtain total read (TAAC + NSAC) & write (R2W * read) access timeout (x100) */
sdc_clk_ns = 1000000000.0f / (float)sdd.card_desc.sdc_clk_freq; /* SDC clock period (ns) */
sdc_read_to_ns =
(float)sdd.card_desc.read_access_clks * sdc_clk_ns * 100.0f +
(float)sdd.card_desc.async_access_time * 10.0f;
sdc_write_to_ns = (float)sdd.card_desc.prog_factor * sdc_read_to_ns;
/* obtain read and write timeout value */
/* read_timeout = min(100ms, 100 x read_access_time_ms) */
if (sdc_read_to_ns > 100000000.0f)
sdc_read_to_ns = 100000000.0f;
sdd.card_desc.read_timeout_clks = (uint32_t) (sdc_read_to_ns / sdc_clk_ns);
/* write_timeout = min(100ms, 100 x write_access_time_ms) */
if (sdc_write_to_ns > 100000000.0f)
sdc_write_to_ns = 100000000.0f;
sdd.card_desc.write_timeout_clks = (uint32_t) (sdc_write_to_ns / sdc_clk_ns);
/* command class support list */
sdd.card_desc.cmd_class = SD_CSD_GET_CCC(sd_rsp128);
/* read parameters */
/* should be 512, 1024, or 2048 */
sdd.card_desc.max_read_block_len = (uint16_t) (1 << SD_CSD_GET_READ_BL_LEN(sd_rsp128));
/* should be 1 for SD memory card */
sdd.card_desc.partial_block_read = (uint8_t) SD_CSD_GET_READ_BL_PARTIAL(sd_rsp128);
sdd.card_desc.read_block_misalign = (uint8_t) SD_CSD_GET_READ_BLK_MISALIGN(sd_rsp128); /* 0 or 1 */
/* write parameters */
sdd.card_desc.max_write_block_len = (uint16_t) (1 << SD_CSD_GET_WRITE_BL_LEN(sd_rsp128)); /* should be same as read-block size in SD memory card */
sdd.card_desc.partial_block_write = (uint8_t) SD_CSD_GET_WRITE_BL_PARTIAL(sd_rsp128); /* 0 or 1 */
sdd.card_desc.write_block_misalign = (uint8_t) SD_CSD_GET_WRITE_BLK_MISALIGN(sd_rsp128); /* 0 or 1 */
/* erase parameters */
sdd.card_desc.erase_single_block = (uint8_t) SD_CSD_GET_ERASE_BLK_EN(sd_rsp128); /* 0 or 1 */
sdd.card_desc.erase_sector_size = (uint8_t) SD_CSD_GET_SECTOR_SIZE(sd_rsp128); /* 0~127 means 1~128 number of write block size */
sdd.card_desc.file_format = (uint8_t) SD_CSD_GET_FILE_FORMAT(sd_rsp128);
/* write protect parameters */
sdd.card_desc.wp_group_size = (uint8_t) SD_CSD_GET_WP_GRP_SIZE(sd_rsp128); /* 0~127 means 1~128 number of erase sector size */
sdd.card_desc.wp_group_enable = (uint8_t) SD_CSD_GET_WP_GRP_ENABLE(sd_rsp128); /* 0 or 1 */
sdd.card_desc.wp_permanent = (uint8_t) SD_CSD_GET_PERM_WRITE_PROTECT(sd_rsp128); /* 0 or 1 */
sdd.card_desc.wp_temp = (uint8_t) SD_CSD_GET_TMP_WRITE_PROTECT(sd_rsp128); /* 0 or 1 */
/* other parameters */
sdd.card_desc.copy = (uint8_t) SD_CSD_GET_COPY(sd_rsp128); /* 0 or 1 */
sdd.card_desc.dsr_imp = (uint8_t) SD_CSD_GET_DSR_IMP(sd_rsp128); /* 0 or 1 */
/* card capacity parameters */
sdd.card_desc.c_size = (uint32_t) SD_CSD1_GET_C_SIZE(sd_rsp128); /* 12-bit value */
sdd.card_desc.c_size_mult = (uint32_t) SD_CSD1_GET_C_SIZE_MULT(sd_rsp128); /* 3-bit value */
/* calculate card capacity of user data (unit of 512-bytes) */
sdd.card_desc.card_capacity =
((sdd.card_desc.c_size +
1) * (1 << (sdd.card_desc.c_size_mult + 2))) >> 9;
sdd.card_desc.card_capacity *=
sdd.card_desc.max_read_block_len;
}
else if (tmp_val == 0x01) {
/* SDHC (or Standard SD with CSD 2.0?) */
/*static uint32_t soc_pclk = 50000000; // (assume PCLK 50M) todo: fix it! */
float sdc_clk_ns;
SDD_TRACE(("CSD v2.0\r\n"));
SDD_TRACE(("taac(r/o) : 0x%08lx\r\n",
SD_CSD_GET_TAAC(sd_rsp128)));
SDD_TRACE(("nsac(r/o) : 0x%08lx\r\n",
SD_CSD_GET_NSAC(sd_rsp128)));
/* CSD structure version */
sdd.card_desc.csd_ver = 0x02;
/* obtain card maximum transfer speed (bps) */
tmp_val = SD_CSD_GET_TRAN_SPEED(sd_rsp128); /* same as 1.0 */
sdd.card_desc.max_dataline_rate =
(taac_ts_tv2flt[SD_TRAN_SPEED_TV(tmp_val)] *
ts_tu2bps[SD_TRAN_SPEED_TU(tmp_val)]);
SDD_TRACE(("line_speed : 0x%08lx (bps)\r\n",
sdd.card_desc.max_dataline_rate));
/* AG101 SDC transfer speed limits */
// if (sdd.card_desc.max_dataline_rate > 25000000)
// sdd.card_desc.max_dataline_rate = 25000000;
/*
* assume we would like to reach the maximum transfer speed,
* backward derive SDC_CLK_DIC ...
*/
sdd.card_desc.sdc_clk_div =
MB_PCLK / (sdd.card_desc.max_dataline_rate << 1);
if (sdd.card_desc.sdc_clk_div > 0)
sdd.card_desc.sdc_clk_div -= 1;
/* obtain real SDC clock frequency */
sdd.card_desc.sdc_clk_freq =
MB_PCLK / ((sdd.card_desc.sdc_clk_div + 1) << 1);
/* obtain card read access time 1 (TAAC, ns) */
/* note that this is 10x value, use of taac has to be divide by 10. */
// tmp_val = SD_CSD_GET_TAAC(sd_rsp128);
// sdd.card_desc.async_access_time =
// taac_ts_tv2flt[SD_TAAC_TV(tmp_val)] * taac_tu2ns[SD_TAAC_TU(tmp_val)];
/* obtain card read access time 2 (NSAC * 100, clocks) */
// sdd.card_desc.read_access_clks = SD_CSD_GET_NSAC(sd_rsp128) * 100; // (NSAC * 100) Hz */
/* obtain programming time multiplication factor */
sdd.card_desc.prog_factor = (1 << SD_CSD_GET_R2W_FACTOR(sd_rsp128)); /* should be 4 */
/* obtain total read (TAAC + NSAC) & write (R2W * read) access timeout (x100) */
sdc_clk_ns = 1000000000.0f / (float)sdd.card_desc.sdc_clk_freq; /* SDC clock period (ns) */
/* obtain read and write timeout value */
sdd.card_desc.read_timeout_clks = (uint32_t) (100000000.0f / sdc_clk_ns); /* 100ms according to spec 2.0 */
sdd.card_desc.write_timeout_clks = (uint32_t) (250000000.0f / sdc_clk_ns); /* 250ms according to spec 2.0 */
/* command class support list */
sdd.card_desc.cmd_class = SD_CSD_GET_CCC(sd_rsp128); /* same as 1.0 */
/* read parameters */
sdd.card_desc.max_read_block_len = (uint16_t) (1 << SD_CSD_GET_READ_BL_LEN(sd_rsp128)); /* should be 512 bytes */
sdd.card_desc.partial_block_read = (uint8_t) SD_CSD_GET_READ_BL_PARTIAL(sd_rsp128); /* should be 0 */
sdd.card_desc.read_block_misalign = (uint8_t) SD_CSD_GET_READ_BLK_MISALIGN(sd_rsp128); /* should be 0 */
/* write parameters */
sdd.card_desc.max_write_block_len = (uint16_t) (1 << SD_CSD_GET_WRITE_BL_LEN(sd_rsp128)); /* should be 512 bytes */
sdd.card_desc.partial_block_write = (uint8_t) SD_CSD_GET_WRITE_BL_PARTIAL(sd_rsp128); /* should be 0 */
sdd.card_desc.write_block_misalign = (uint8_t) SD_CSD_GET_WRITE_BLK_MISALIGN(sd_rsp128); /* should be 0 */
/* erase parameters */
sdd.card_desc.erase_single_block = (uint8_t) SD_CSD_GET_ERASE_BLK_EN(sd_rsp128); /* should be 1 */
sdd.card_desc.erase_sector_size = (uint8_t) SD_CSD_GET_SECTOR_SIZE(sd_rsp128); /* should be 64 KBytes (not relate to erase) */
sdd.card_desc.file_format = (uint8_t) SD_CSD_GET_FILE_FORMAT(sd_rsp128); /* should be 0 */
/* write protect parameters */
sdd.card_desc.wp_group_size = (uint8_t) SD_CSD_GET_WP_GRP_SIZE(sd_rsp128); /* should be 0 */
sdd.card_desc.wp_group_enable = (uint8_t) SD_CSD_GET_WP_GRP_ENABLE(sd_rsp128); /* should be 0 */
sdd.card_desc.wp_permanent = (uint8_t) SD_CSD_GET_PERM_WRITE_PROTECT(sd_rsp128); /* same as 1.0 */
sdd.card_desc.wp_temp = (uint8_t) SD_CSD_GET_TMP_WRITE_PROTECT(sd_rsp128); /* same as 1.0 */
/* other parameters */
sdd.card_desc.copy = (uint8_t) SD_CSD_GET_COPY(sd_rsp128); /* same as 1.0 */
sdd.card_desc.dsr_imp = (uint8_t) SD_CSD_GET_DSR_IMP(sd_rsp128); /* same as 1.0 */
/* card capacity parameters */
sdd.card_desc.c_size =
(uint32_t) SD_CSD2_GET_C_SIZE(sd_rsp128);
/* calculate card capacity of user data (unit of 512-bytes) */
sdd.card_desc.card_capacity = sdd.card_desc.c_size + 1; /* (c_size + 1) * 512 / 512 (KBytes) */
sdd.card_desc.card_capacity *=
sdd.card_desc.max_read_block_len;
}
else {
SDD_TRACE(("Unknown CSD version!\r\n"));
sdd.card_desc.csd_ver = 0x00;
status = SDD_INVALID_MEDIA;
goto _err_exit;
}
}
SDD_TRACE(("card_capacity: 0x%08lx (KB)\r\n", sdd.card_desc.card_capacity));
SDD_TRACE(("clk_div: 0x%08lx\r\n", sdd.card_desc.sdc_clk_div));
SDD_TRACE(("clk_freq: %d Hz\r\n", sdd.card_desc.sdc_clk_freq));
SDD_TRACE(("read_timeout_clks: 0x%08lx\r\n", sdd.card_desc.read_timeout_clks));
SDD_TRACE(("write_timeout_clks: 0x%08lx\r\n", sdd.card_desc.write_timeout_clks));
/* ------------ */
/* Now we know how to setup SD bus clock for maximum data transfer rate ... */
OUT32(SDC_CLK_CTL, (SDC_CLK_ON << SDC_CLK_DIS_BIT) | (SDC_CLK_SD << SDC_CLK_SD_BIT) |
((sdd.card_desc.sdc_clk_div << SDC_CLK_DIV_SHIFT) & SDC_CLK_DIV_MASK));
_nds_kwait(0x1000);
/* ------------ */
/*
* Get SCR register (Standby -> Transfer -> Standby)
* (Majorly we need the data bus width)
*/
SDD_TRACE(("Get SCR\r\n"));
status = _sd_select_card(sdd.card_desc.rca); /* standby -> transfer */
if (status != HAL_SUCCESS)
goto _err_exit;
/*
* send SD command to setup read-block-size
* (SD memory card read block size could smaller than 512)
*/
SDD_TRACE(("cmd16\r\n"));
status = _sd_cmd16(8, &sd_rsp32); /* read 64 bits data */
if (status != HAL_SUCCESS)
goto _err_exit;
/* set SDC data timeout register */
// OUT32(SDC_DATA_TIMER, 0xffffffff); /* use sdd.card_desc.read_timeout_clks ? */
OUT32(SDC_DATA_TIMER, sdd.card_desc.read_timeout_clks);
/* set SDC data length register */
OUT32(SDC_DATA_LEN, 8); /* read 64 bits data */
/* set SDC data control register */
OUT32(SDC_DATA_CR, SDC_DATA_EN_MASK | ((3 << SDC_BLK_SIZE_SHIFT) & SDC_BLK_SIZE_MASK)); /* 2^3 = 8 bytes */
/* send SD command to readback SCR register */
SDD_TRACE(("cmd55\r\n"));
status = _sd_cmd55(sdd.card_desc.rca, &sd_rsp32);
if (status != HAL_SUCCESS)
goto _err_exit;
SDD_TRACE(("acmd51\r\n"));
status = _sd_acmd51(&sd_rsp32);
if (status != HAL_SUCCESS)
goto _err_exit;
/* pio-mode read-back */
tmp_val = 0;
while (tmp_val++ < SD_READ_MAX_RETRY_COUNT) {
uint32_t sdc_status = IN32(SDC_STATUS);
if (sdc_status & (SDC_SR_CARD_DETECT_MASK | SDC_SR_DATA_TIMEOUT_MASK | SDC_SR_DATA_CRC_FAIL_MASK)) {
status = SDD_READ_DATA_ERROR;
goto _err_exit;
}
if (sdc_status & (SDC_SR_FIFO_ORUN_MASK | SDC_SR_DATA_END_MASK))
break;
}
/* ACMD51/ACMD13 data are MSB first (big-endian) */
sd_rsp128.r[3] = IN32(SDC_DATA_WIN); /* [63:32] BE */
sd_rsp128.r[2] = IN32(SDC_DATA_WIN); /* [31:00] BE */
/* reorder byte endian inside the 32-bit word */
sd_rsp128.b[0] = sd_rsp128.b[11];
sd_rsp128.b[1] = sd_rsp128.b[10];
sd_rsp128.b[2] = sd_rsp128.b[9];
sd_rsp128.b[3] = sd_rsp128.b[8];
sd_rsp128.b[4] = sd_rsp128.b[15];
sd_rsp128.b[5] = sd_rsp128.b[14];
sd_rsp128.b[6] = sd_rsp128.b[13];
sd_rsp128.b[7] = sd_rsp128.b[12];
sdd.card_desc.scr_ver = (uint8_t) SD_SCR_GET_SCR_STRUCTURE(sd_rsp128);
sdd.card_desc.spec_ver = (uint8_t) SD_SCR_GET_SD_SPEC(sd_rsp128);
sdd.card_desc.erase_val = (uint8_t) SD_SCR_GET_DATA_STAT_AFTER_ERASE(sd_rsp128);
sdd.card_desc.security_ver = (uint8_t) SD_SCR_GET_SD_SECURITY(sd_rsp128);
sdd.card_desc.bus_width = (uint8_t) SD_SCR_GET_SD_BUS_WIDTHS(sd_rsp128);
SDD_TRACE(("lw : 0x%08lx\r\n", sd_rsp128.r[2]));
SDD_TRACE(("hw : 0x%08lx\r\n", sd_rsp128.r[3]));
SDD_TRACE(("SCR_ver : 0x%08lx\r\n", sdd.card_desc.scr_ver));
SDD_TRACE(("spec_ver : 0x%08lx\r\n", sdd.card_desc.spec_ver));
SDD_TRACE(("erase_val: 0x%08lx\r\n", sdd.card_desc.erase_val));
SDD_TRACE(("secu_ver : 0x%08lx\r\n", sdd.card_desc.security_ver));
SDD_TRACE(("bus_width: 0x%08lx\r\n", sdd.card_desc.bus_width));
if ((IN32(SDC_BUS_WIDTH) & SDC_WIDE_BUS_SUPPORT_MASK) &&
(sdd.card_desc.bus_width & 0x04)) {
SDD_TRACE(("SDC configured to wide bus!\r\n"));
SDD_TRACE(("cmd55\r\n"));
status = _sd_cmd55(sdd.card_desc.rca, &sd_rsp32);
if (status != HAL_SUCCESS)
goto _err_exit;
SDD_TRACE(("acmd6\r\n"));
status = _sd_acmd6(SD_ACMD6_MAKE_ARG(SD_BUS_WIDTH_ARG_4BIT), &sd_rsp32);
if (status != HAL_SUCCESS)
goto _err_exit;
SDD_TRACE(("sdc_bus_width\r\n"));
OUT32(SDC_BUS_WIDTH, SDC_WIDE_BUS_SUPPORT_MASK | SDC_WIDE_BUS_MASK);
}
else {
SDD_TRACE(("SDC configured to single bus!\r\n"));
SDD_TRACE(("cmd55\r\n"));
status = _sd_cmd55(sdd.card_desc.rca, &sd_rsp32);
if (status != HAL_SUCCESS)
goto _err_exit;
SDD_TRACE(("acmd6\r\n"));
status = _sd_acmd6(SD_ACMD6_MAKE_ARG(SD_BUS_WIDTH_ARG_1BIT), &sd_rsp32);
if (status != HAL_SUCCESS)
goto _err_exit;
OUT32(SDC_BUS_WIDTH, SDC_WIDE_BUS_SUPPORT_MASK | SDC_SINGLE_BUS_MASK);
}
/* transfer -> standby */
// status = _sd_deselect_card(sdd.card_desc.rca);
// if (status != HAL_SUCCESS)
// goto _err_exit;
/*
* Turn on SD card power using voltage level obtained from card OCR
* todo: use default? flib doesn't setup voltage value?
*/
// SETB32(SDC_PWR_CTL, SDC_SD_POWER_ON_BIT);
// _nds_kwait(0x1000);
return HAL_SUCCESS;
_err_exit:
SDD_TRACE(("_err_exit!\r\n"));
/* Turn off SD bus power */
CLRB32(SDC_PWR_CTL, SDC_SD_POWER_ON_BIT);
/* Turn off SD bus clock */
SETB32(SDC_CLK_CTL, SDC_CLK_DIS_BIT);
/* Setup removed flag */
sdd.card_desc.rca = 0;
#if (SDD_VFS_SUPPORT)
// notify file system layer, if any ...
if (sdd_bdev.propagate_event != HAL_NULL)
sdd_bdev.propagate_event(&sdd_bdev, NDSBDEV_DEVICE_UNPLUG, HAL_NULL);
#endif // SDD_VFS_SUPPORT
return status;
}
#if 0
/*****************************************************************************
* FUNCTION
*
* _sdd_read_sector_pio
*
* DESCRIPTION
*
* This function performs a sector of data PIO transfer from the SD memory
* card.
*
* NOTE
*
*
* INPUTS
*
* sector :
* sector_cnt :
* io_buff :
*
* OUTPUTS
*
* uint32_t : Returns HAL_SUCCESS if successful initialization,
* else positive value is SSPD-specific error code,
* else negative value is NU system error code.
*
****************************************************************************/
uint32_t _sdd_read_sector_pio(uint32_t sector, uint8_t * io_buff)
{
uint32_t status = SDD_INVALID_FUNCTION;
uint32_t sdc_status;
SD_R32 sd_rsp32;
uint32_t retry = 0;
uint32_t word_cnt;
uint32_t fifo_depth;
SDD_TRACE(("\r\n_sdd_read_sector_pio\r\n"));
if (sector > (sdd.card_desc.card_capacity << 1)) {
SDD_TRACE(("Invalid sector address!\r\n"));
return SDD_INVLAID_ADDRESS;
}
/* todo: sector size */
/* standby -> transfer */
SDD_TRACE(("- select_card\r\n"));
status = _sd_select_card(sdd.card_desc.rca);
if (status != HAL_SUCCESS)
goto _err_exit;
/* send SD command to setup read-block-size */
/* todo: assume sector size is 512 bytes */
SDD_TRACE(("- cmd16\r\n"));
status = _sd_cmd16(SDD_SECTOR_SIZE, &sd_rsp32);
if (status != HAL_SUCCESS)
goto _err_exit;
/* set SDC data timeout register */
OUT32(SDC_DATA_TIMER, sdd.card_desc.read_timeout_clks);
/* set SDC data length register */
OUT32(SDC_DATA_LEN, SDD_SECTOR_SIZE);
/* set SDC data control register */
OUT32(SDC_DATA_CR, SDC_DATA_EN_MASK | ((SDD_POWER_OF_SECTOR_SIZE << SDC_BLK_SIZE_SHIFT) & SDC_BLK_SIZE_MASK)); /* 2^9 = 512 bytes */
/* send SD command to readback data */
SDD_TRACE(("- cmd17\r\n"));
if (sdd.card_desc.card_ccs == SDD_CCS_SD)
status = _sd_cmd17(sector * SDD_SECTOR_SIZE, &sd_rsp32); /* address unit is byte for SD */
else
status = _sd_cmd17(sector, &sd_rsp32); /* address unit is 512 bytes for SDHC */
if (status != HAL_SUCCESS)
goto _err_exit;
SDD_TRACE(("- wait until card is sending out data\r\n"));
_nds_kwait(0x1000); /* hw need delay ? */
/*status = _sd_wait_sending_state(sdd.card_desc.rca); */
/*if (status != HAL_SUCCESS) */
/* goto _err_exit; */
SDD_TRACE(("- read back data\r\n"));
/* per 32-bit word read back */
word_cnt = SDD_SECTOR_SIZE >> 2;
while (word_cnt > 0) {
retry = 0;
while (retry++ < SD_READ_MAX_RETRY_COUNT) {
sdc_status = IN32(SDC_STATUS);
if (sdc_status &
(SDC_SR_CARD_DETECT_MASK | SDC_SR_DATA_TIMEOUT_MASK
| SDC_SR_DATA_CRC_FAIL_MASK)) {
SDD_TRACE(("- data error/timeout or card removed, sdc_status: 0x%08lx\r\n", sdc_status));
status = SDD_READ_DATA_ERROR;
goto _err_exit;
}
if (sdc_status &
(SDC_SR_FIFO_ORUN_MASK | SDC_SR_DATA_END_MASK)) {
SETB32(SDC_CLEAR, SDC_FIFO_ORUN_BIT);
retry = 0xffffffff; /* success */
break;
}
}
if (retry != 0xffffffff) {
/* wait data timeout */
SDD_TRACE(("- timeout, sdc_status: 0x%08lx\r\n",
sdc_status));
status = SDD_READ_DATA_ERROR;
goto _err_exit;
}
fifo_depth = SDC_FIFO_WORD_DEPTH;
while (fifo_depth-- > 0) {
/* CMD17/18/24/25 ACMD18/25 data are LSB first (little-endian) */
*((uint32_t *) io_buff) = IN32(SDC_DATA_WIN); /* just mem-move so no data endian issue. */
io_buff += 4;
if (--word_cnt == 0)
break;
}
}
SDD_TRACE(("- data read completed\r\n"));
return HAL_SUCCESS;
_err_exit:
SDD_TRACE(("- error on data read\r\n"));
return status;
}
#endif
/*****************************************************************************
* FUNCTION
*
* _sdd_read_sectors_pio
*
* DESCRIPTION
*
* This function performs PIO data transfer from the SD memory card in
* multiple unit of sectors.
*
* NOTE
*
*
* INPUTS
*
* sector :
* sector_cnt :
* io_buff :
*
* OUTPUTS
*
* uint32_t : Returns HAL_SUCCESS if successful initialization,
* else positive value is SSPD-specific error code,
* else negative value is NU system error code.
*
****************************************************************************/
static uint32_t _sdd_read_sectors_pio(uint32_t sector, uint32_t sector_cnt,
uint8_t * io_buff)
{
uint32_t status = SDD_INVALID_FUNCTION;
uint32_t sdc_status;
SD_R32 sd_rsp32;
uint32_t retry = 0;
uint32_t word_cnt;
uint32_t fifo_depth;
SDD_TRACE(("\r\n_sdd_read_sectors_pio\r\n"));
if (sector > (sdd.card_desc.card_capacity << 1)) {
SDD_TRACE(("Invalid sector address!\r\n"));
return SDD_INVLAID_ADDRESS;
}
if ((sector_cnt == 0) || (((sector + sector_cnt) > (sdd.card_desc.card_capacity << 1)))) {
SDD_TRACE(("Invalid sector address range!\r\n"));
return SDD_INVLAID_ADDR_RANGE;
}
/* todo: sector size */
/* standby -> transfer */
SDD_TRACE(("- select_card\r\n"));
status = _sd_select_card(sdd.card_desc.rca);
if (status != HAL_SUCCESS)
goto _err_exit;
/* send SD command to setup read-block-size */
/* todo: assume sector size is 512 bytes */
SDD_TRACE(("- cmd16\r\n"));
status = _sd_cmd16(SDD_SECTOR_SIZE, &sd_rsp32);
if (status != HAL_SUCCESS)
goto _err_exit;
/* set SDC data timeout register */
OUT32(SDC_DATA_TIMER, sdd.card_desc.read_timeout_clks);
/* set SDC data length register */
OUT32(SDC_DATA_LEN, sector_cnt * SDD_SECTOR_SIZE);
/* set SDC data control register */
OUT32(SDC_DATA_CR, SDC_DATA_EN_MASK | ((SDD_POWER_OF_SECTOR_SIZE << SDC_BLK_SIZE_SHIFT) & SDC_BLK_SIZE_MASK)); /* 2^9 = 512 bytes */
/* send SD command to readback data */
SDD_TRACE(("- cmd18\r\n"));
if (sdd.card_desc.card_ccs == SDD_CCS_SD)
status = _sd_cmd18(sector * SDD_SECTOR_SIZE, &sd_rsp32); /* address unit is byte for SD */
else
status = _sd_cmd18(sector, &sd_rsp32); /* address unit is 512 bytes for SDHC */
if (status != HAL_SUCCESS)
goto _err_exit;
SDD_TRACE(("- wait until card is sending out data\r\n"));
_nds_kwait(0x1000); /* hw need delay ? */
/* This method will dirty SDC_STATUS so not been used. */
// status = _sd_wait_sending_state(sdd.card_desc.rca);
// if (status != HAL_SUCCESS)
// goto _err_exit;
/* per sector PIO read back */
OUT32(SDC_CLEAR, 0x3ff);
SDD_TRACE(("- read back data\r\n"));
while (sector_cnt-- > 0) {
/* per 32-bit word read back */
word_cnt = SDD_SECTOR_SIZE >> 2;
while (word_cnt > 0) {
retry = 0;
while (retry++ < SD_READ_MAX_RETRY_COUNT) {
sdc_status = IN32(SDC_STATUS);
if (sdc_status &
(SDC_SR_CARD_DETECT_MASK |
SDC_SR_DATA_TIMEOUT_MASK |
SDC_SR_DATA_CRC_FAIL_MASK)) {
SDD_TRACE(("- data error/timeout or card removed, sdc_status: 0x%08lx\r\n", sdc_status));
status = SDD_READ_DATA_ERROR;
goto _err_exit;
}
if (sdc_status & (SDC_SR_FIFO_ORUN_MASK | SDC_SR_DATA_END_MASK)) {
retry = 0xffffffff; /* success */
break;
}
}
if (retry != 0xffffffff) {
/* wait data timeout */
SDD_TRACE(("- timeout, sdc_status: 0x%08lx\r\n", sdc_status));
status = SDD_READ_DATA_ERROR;
goto _err_exit;
}
fifo_depth = SDC_FIFO_WORD_DEPTH;
SETB32(SDC_CLEAR, SDC_FIFO_ORUN_BIT);
while (fifo_depth-- > 0) {
/* CMD17/18/24/25 ACMD18/25 data are LSB first (little-endian) */
*((uint32_t *) io_buff) = IN32(SDC_DATA_WIN); /* just mem-move so no data endian issue. */
io_buff += 4;
if (--word_cnt == 0)
break;
}
}
}
_nds_kwait(0x1000); /* hw need delay ? */
/* Stop data transmission */
SDD_TRACE(("- stop transmission\r\n"));
status = _sd_stop_transmission(sdd.card_desc.rca);
/* FIXME this part is marked for qemu */
#if 0
if (status != HAL_SUCCESS)
goto _err_exit;
#endif
SDD_TRACE(("- data read completed\r\n"));
return HAL_SUCCESS;
_err_exit:
SDD_TRACE(("- error on data read! status(0x%08lx)\r\n", status));
return status;
}
extern int dmad_apb_config_dir(const DMAD_CHANNEL_REQUEST_DESC *ch_req, uint8_t dir);
/*****************************************************************************
* FUNCTION
*
* _sdd_read_sectors_dma
*
* DESCRIPTION
*
* This function performs DMA data transfer from the SD memory card in
* multiple unit of sectors.
*
* NOTE
*
*
* INPUTS
*
* sector :
* sector_cnt :
* io_buff :
*
* OUTPUTS
*
* uint32_t : Returns HAL_SUCCESS if successful initialization,
* else positive value is SSPD-specific error code,
* else negative value is NU system error code.
*
****************************************************************************/
static uint32_t _sdd_read_sectors_dma(uint32_t sector, uint32_t sector_cnt,
uint8_t * io_buff)
{
uint32_t status = SDD_INVALID_FUNCTION;
SD_R32 sd_rsp32;
DMAD_DRB *drb;
SDD_TRACE(("\r\n_sdd_read_sectors_dma\r\n"));
if (sector > (sdd.card_desc.card_capacity << 1)) {
SDD_TRACE(("Invalid sector address!\r\n"));
return SDD_INVLAID_ADDRESS;
}
if ((sector_cnt == 0) || (((sector + sector_cnt) > (sdd.card_desc.card_capacity << 1)))) {
SDD_TRACE(("Invalid sector address range!\r\n"));
return SDD_INVLAID_ADDR_RANGE;
}
/* todo: sector size */
/* standby -> transfer */
SDD_TRACE(("- select_card\r\n"));
status = _sd_select_card(sdd.card_desc.rca);
if (status != HAL_SUCCESS)
goto _safe_exit;
/* send SD command to setup read-block-size */
/* todo: assume sector size is 512 bytes */
SDD_TRACE(("- cmd16\r\n"));
status = _sd_cmd16(SDD_SECTOR_SIZE, &sd_rsp32);
if (status != HAL_SUCCESS)
goto _safe_exit;
/* set SDC data timeout register */
OUT32(SDC_DATA_TIMER, sdd.card_desc.read_timeout_clks);
/* set SDC data length register */
OUT32(SDC_DATA_LEN, sector_cnt * SDD_SECTOR_SIZE);
/* set SDC data control register */
OUT32(SDC_DATA_CR, SDC_DATA_EN_MASK | SDC_DMA_EN_MASK | ((SDD_POWER_OF_SECTOR_SIZE << SDC_BLK_SIZE_SHIFT) & SDC_BLK_SIZE_MASK)); /* 2^9 = 512 bytes */
/* send SD command to readback data */
SDD_TRACE(("- cmd18\r\n"));
if (sdd.card_desc.card_ccs == SDD_CCS_SD)
status = _sd_cmd18(sector * SDD_SECTOR_SIZE, &sd_rsp32); /* address unit is byte for SD */
else
status = _sd_cmd18(sector, &sd_rsp32); /* address unit is 512 bytes for SDHC */
if (status != HAL_SUCCESS)
goto _safe_exit;
SDD_TRACE(("- wait until card is sending out data\r\n"));
// _nds_kwait(0x1000); /* hw need delay ? */
/* This method will dirty SDC_STATUS so not been used. */
// status = _sd_wait_sending_state(sdd.card_desc.rca);
// if (status != HAL_SUCCESS)
// goto _err_exit;
/* per sector DMA read back */
/* CMD17/18/24/25 ACMD18/25 data are LSB first (little-endian) */
SDD_TRACE(("- read back data\r\n"));
dmad_apb_config_dir(&sdd.dma_ch,DMAD_DIR_A0_TO_A1);
while (sector_cnt-- > 0) {
status = _dmad_alloc_drb(&sdd.dma_ch, &drb);
if (status != HAL_SUCCESS)
goto _safe_exit;
drb->src_addr = (void *)SDC_DATA_WIN;
drb->dst_addr = (void *)io_buff;
drb->req_size = SDD_SECTOR_SIZE >> 2; /* multiple counts of transfer width */
if (sector_cnt == 0)
drb->completion_sem = &sdd.dma_sem;
/* Submit DRB */
status = _dmad_submit_request(&sdd.dma_ch, drb);
if (status != HAL_SUCCESS)
goto _safe_exit;
/* Point to next buffer location */
io_buff += SDD_SECTOR_SIZE;
}
/* Wait DMA completion */
/* - method 1: sync with semaphore */
/* - method 2: check SDC status register SDC_STATUS[7] */
if (1){
DEBUG(0, 1, "- wait dma completion ...\n");
status = hal_pend_semaphore(&sdd.dma_sem, 300);
if (status == HAL_ERR_TIMEOUT) {
DEBUG(1, 1, "- wait dma completion timeout (might not an error)\n");
goto _safe_exit;
}
else if (status != HAL_SUCCESS) {
DEBUG(1, 1, "- wait dma completion failed! (0x%08lx)\n", status);
goto _safe_exit;
}
}
else {
uint32_t retry = 0;
uint32_t sdc_status;
SDD_TRACE(("- polling dma completion status ...\r\n"));
while (retry++ < SD_READ_MAX_RETRY_COUNT) {
sdc_status = IN32(SDC_STATUS);
if (sdc_status &
(SDC_SR_CARD_DETECT_MASK | SDC_SR_DATA_TIMEOUT_MASK
| SDC_SR_DATA_CRC_FAIL_MASK)) {
SDD_TRACE(("- data error/timeout or card removed, sdc_status: 0x%08lx\r\n", sdc_status));
status = SDD_READ_DATA_ERROR;
break; /* todo: report error to upper layer? */
}
if (sdc_status & (SDC_SR_FIFO_ORUN_MASK | SDC_SR_DATA_END_MASK)) {
SETB32(SDC_CLEAR, SDC_FIFO_ORUN_BIT);
retry = 0xffffffff; /* success */
break;
}
}
}
/* Stop data transmission anyway after waiting. */
SDD_TRACE(("- stop transmission\r\n"));
status = _sd_stop_transmission(sdd.card_desc.rca);
/* FIXME this part is marked for qemu */
#if 0
if (status != HAL_SUCCESS)
goto _safe_exit;
#endif
status = HAL_SUCCESS;
_safe_exit:
#if (SDD_DEBUG_TRACE)
if (status == HAL_SUCCESS)
SDD_TRACE(("- data read completed\r\n"));
else
SDD_TRACE(("- error on data read\r\n"));
#endif /* SDD_DEBUG_TRACE */
return status;
}
#if 0
/*****************************************************************************
* FUNCTION
*
* _sdd_write_sector_pio
*
* DESCRIPTION
*
* This function performs a sector of data PIO transfer to the SD memory
* card.
*
* NOTE
*
*
* INPUTS
*
* sector :
* io_buff :
*
* OUTPUTS
*
* uint32_t : Returns HAL_SUCCESS if successful initialization,
* else positive value is SSPD-specific error code,
* else negative value is NU system error code.
*
****************************************************************************/
uint32_t _sdd_write_sector_pio(uint32_t sector, uint8_t * io_buff)
{
uint32_t status = SDD_INVALID_FUNCTION;
uint32_t sdc_status;
SD_R32 sd_rsp32;
uint32_t retry = 0;
uint32_t word_cnt;
uint32_t fifo_depth;
SDD_TRACE(("\r\n_sdd_write_sector_pio\r\n"));
if (sector > (sdd.card_desc.card_capacity << 1)) {
SDD_TRACE(("Invalid sector address!\r\n"));
return SDD_INVLAID_ADDRESS;
}
if (GETB32(SDC_STATUS, SDC_SR_WRITE_PROT_BIT)) {
SDD_TRACE(("Card is write protected!\r\n"));
return SDD_WRITE_PROTECTED;
}
/* todo: sector size */
/* standby -> transfer */
SDD_TRACE(("- select_card\r\n"));
status = _sd_select_card(sdd.card_desc.rca);
if (status != HAL_SUCCESS)
goto _err_exit;
/* send SD command to setup write-block-size */
/* todo: assume sector size is 512 bytes */
SDD_TRACE(("- cmd16\r\n"));
status = _sd_cmd16(SDD_SECTOR_SIZE, &sd_rsp32);
if (status != HAL_SUCCESS)
goto _err_exit;
/* set SDC data timeout register */
OUT32(SDC_DATA_TIMER, sdd.card_desc.write_timeout_clks);
/* set SDC data length register */
OUT32(SDC_DATA_LEN, SDD_SECTOR_SIZE);
/* set SDC data control register */
OUT32(SDC_DATA_CR, SDC_DATA_EN_MASK | SDC_DATA_WRITE_MASK | ((SDD_POWER_OF_SECTOR_SIZE << SDC_BLK_SIZE_SHIFT) & SDC_BLK_SIZE_MASK)); /* 2^9 = 512 bytes */
/* send SD command to write data */
SDD_TRACE(("- cmd24\r\n"));
if (sdd.card_desc.card_ccs == SDD_CCS_SD)
status = _sd_cmd24(sector * SDD_SECTOR_SIZE, &sd_rsp32); /* address unit is byte for SD */
else
status = _sd_cmd24(sector, &sd_rsp32); /* address unit is 512 bytes for SDHC */
if (status != HAL_SUCCESS)
goto _err_exit;
SDD_TRACE(("- wait ready to write out data\r\n"));
_nds_kwait(0x1000); /* hw need delay ? */
/*status = _sd_wait_receiving_state(sdd.card_desc.rca); // This method look not necessary for writing. */
/*if (status != HAL_SUCCESS) */
/* goto _err_exit; */
/* per sector PIO write out */
SDD_TRACE(("- write out data\r\n"));
/* clear SDC status bits before sending data */
OUT32(SDC_CLEAR, SDC_CLEAR_ALL);
/* per 32-bit word write out */
word_cnt = SDD_SECTOR_SIZE >> 2;
while (word_cnt > 0) {
fifo_depth = SDC_FIFO_WORD_DEPTH;
while (fifo_depth-- > 0) {
/* CMD17/18/24/25 ACMD18/25 data are LSB first (little-endian) */
OUT32(SDC_DATA_WIN, *((uint32_t *) io_buff)); /* just mem-move so no data endian issue. */
io_buff += 4;
if (--word_cnt == 0)
goto _complete_exit;
}
retry = 0;
while (retry++ < SD_WRITE_MAX_RETRY_COUNT) {
sdc_status = IN32(SDC_STATUS);
if (sdc_status &
(SDC_SR_CARD_DETECT_MASK | SDC_SR_DATA_TIMEOUT_MASK
| SDC_SR_DATA_CRC_FAIL_MASK)) {
status = SDD_WRITE_DATA_ERROR;
goto _err_exit;
}
if (sdc_status &
(SDC_SR_FIFO_URUN_MASK | SDC_SR_DATA_END_MASK)) {
SETB32(SDC_CLEAR, SDC_FIFO_URUN_BIT);
retry = 0xffffffff; /* success */
break;
}
}
if (retry != 0xffffffff) {
/* wait data timeout */
SDD_TRACE(("- timeout, sdc_status: 0x%08lx\r\n",
sdc_status));
/*SDD_TRACE(("- wait again by polling CSR\r\n")); */
/*status = _sd_wait_receiving_state(sdd.card_desc.rca); */
/*if (status != HAL_SUCCESS) */
goto _err_exit;
/*SDD_TRACE(("- card ready, sdc_status: 0x%08lx\r\n", IN32(SDC_STATUS))); */
}
}
_complete_exit:
/* Wait host SDC shift-out FIFO data */
SDD_TRACE(("- final check sdc_status\r\n"));
retry = 0;
while (retry++ < SD_WRITE_MAX_RETRY_COUNT) {
sdc_status = IN32(SDC_STATUS);
if (sdc_status &
(SDC_SR_CARD_DETECT_MASK | SDC_SR_DATA_TIMEOUT_MASK |
SDC_SR_DATA_CRC_FAIL_MASK)) {
status = SDD_WRITE_DATA_ERROR;
goto _err_exit;
}
if ((sdc_status == 0) || (sdc_status & SDC_SR_DATA_END_MASK)) {
break;
}
}
SDD_TRACE(("- data write completed\r\n"));
return HAL_SUCCESS;
_err_exit:
SDD_TRACE(("- error on data write\r\n"));
return status;
}
#endif
/*****************************************************************************
* FUNCTION
*
* _sdd_write_sectors_pio
*
* DESCRIPTION
*
* This function performs PIO data transfer to the SD memory card in
* multiple unit of sectors.
*
* NOTE
*
*
* INPUTS
*
* sector :
* sector_cnt :
* io_buff :
*
* OUTPUTS
*
* uint32_t : Returns HAL_SUCCESS if successful initialization,
* else positive value is SSPD-specific error code,
* else negative value is NU system error code.
*
****************************************************************************/
static uint32_t _sdd_write_sectors_pio(uint32_t sector, uint32_t sector_cnt,
uint8_t * io_buff)
{
uint32_t status = SDD_INVALID_FUNCTION;
uint32_t sdc_status;
SD_R32 sd_rsp32;
uint32_t retry = 0;
uint32_t word_cnt;
uint32_t fifo_depth;
if (sector > (sdd.card_desc.card_capacity << 1)) {
SDD_TRACE(("Invalid sector address!\r\n"));
return SDD_INVLAID_ADDRESS;
}
if ((sector_cnt == 0) || (((sector + sector_cnt) > (sdd.card_desc.card_capacity << 1)))) {
SDD_TRACE(("Invalid sector address range!\r\n"));
return SDD_INVLAID_ADDR_RANGE;
}
if (GETB32(SDC_STATUS, SDC_SR_WRITE_PROT_BIT)) {
SDD_TRACE(("Card is write protected!\r\n"));
return SDD_WRITE_PROTECTED;
}
/* todo: sector size */
/* standby -> transfer */
SDD_TRACE(("- select_card\r\n"));
status = _sd_select_card(sdd.card_desc.rca);
if (status != HAL_SUCCESS)
goto _err_exit;
/* send SD command to setup write-block-size */
/* todo: assume sector size is 512 bytes */
SDD_TRACE(("- cmd16\r\n"));
status = _sd_cmd16(SDD_SECTOR_SIZE, &sd_rsp32);
if (status != HAL_SUCCESS)
goto _err_exit;
/* set SDC data timeout register */
OUT32(SDC_DATA_TIMER, sdd.card_desc.write_timeout_clks);
/* set SDC data length register */
OUT32(SDC_DATA_LEN, sector_cnt * SDD_SECTOR_SIZE);
/* set SDC data control register */
OUT32(SDC_DATA_CR, SDC_DATA_EN_MASK | SDC_DATA_WRITE_MASK | ((SDD_POWER_OF_SECTOR_SIZE << SDC_BLK_SIZE_SHIFT) & SDC_BLK_SIZE_MASK)); /* 2^9 = 512 bytes */
/* send SD command to write data */
SDD_TRACE(("- cmd25\r\n"));
if (sdd.card_desc.card_ccs == SDD_CCS_SD)
status = _sd_cmd25(sector * SDD_SECTOR_SIZE, &sd_rsp32); /* address unit is byte for SD */
else
status = _sd_cmd25(sector, &sd_rsp32); /* address unit is 512 bytes for SDHC */
if (status != HAL_SUCCESS)
goto _err_exit;
SDD_TRACE(("- wait ready to write out data\r\n"));
_nds_kwait(0x1000); /* hw need delay ? */
/* This method look not necessary for writing. */
// status = _sd_wait_receiving_state(sdd.card_desc.rca);
// if (status != HAL_SUCCESS) */
// goto _err_exit; */
/* per sector PIO write out */
OUT32(SDC_CLEAR, 0x3ff);
SDD_TRACE(("- write out data\r\n"));
while (sector_cnt-- > 0) {
/* per 32-bit word write out */
word_cnt = SDD_SECTOR_SIZE >> 2;
while (word_cnt > 0) {
SDD_TRACE(("- word_cnt: 0x%08lx\r\n", word_cnt));
fifo_depth = SDC_FIFO_WORD_DEPTH;
while ((fifo_depth-- > 0) && (word_cnt-- > 0)) {
/* CMD17/18/24/25 ACMD18/25 data are LSB first (little-endian) */
OUT32(SDC_DATA_WIN, *((uint32_t *) io_buff)); /* just mem-move so no data endian issue. */
io_buff += 4;
}
if (word_cnt == 0)
break;
retry = 0;
while (retry++ < SD_WRITE_MAX_RETRY_COUNT) {
sdc_status = IN32(SDC_STATUS);
if (sdc_status &
(SDC_SR_CARD_DETECT_MASK |
SDC_SR_DATA_TIMEOUT_MASK |
SDC_SR_DATA_CRC_FAIL_MASK)) {
status = SDD_WRITE_DATA_ERROR;
goto _err_exit;
}
if (sdc_status &
(SDC_SR_FIFO_URUN_MASK |
SDC_SR_DATA_END_MASK)) {
SETB32(SDC_CLEAR, SDC_FIFO_URUN_BIT);
retry = 0xffffffff; /* success */
break;
}
}
if (retry != 0xffffffff) {
/* wait data timeout */
SDD_TRACE(("- timeout, sdc_status: 0x%08lx\r\n", sdc_status));
// SDD_TRACE(("- wait again by polling CSR\r\n"));
// status = _sd_wait_receiving_state(sdd.card_desc.rca);
// if (status != HAL_SUCCESS)
goto _err_exit;
SDD_TRACE(("- card ready, sdc_status: 0x%08lx\r\n", IN32(SDC_STATUS)));
}
}
}
/* Wait host SDC shift-out FIFO data */
SDD_TRACE(("- final check sdc_status\r\n"));
retry = 0;
while (retry++ < SD_WRITE_MAX_RETRY_COUNT) {
sdc_status = IN32(SDC_STATUS);
if (sdc_status &
(SDC_SR_CARD_DETECT_MASK | SDC_SR_DATA_TIMEOUT_MASK |
SDC_SR_DATA_CRC_FAIL_MASK)) {
status = SDD_WRITE_DATA_ERROR;
goto _err_exit;
}
if ((sdc_status == 0) || (sdc_status & SDC_SR_DATA_END_MASK))
break;
}
/* Stop data transmission */
SDD_TRACE(("- stop transmission\r\n"));
status = _sd_stop_transmission(sdd.card_desc.rca);
/* FIXME this part is marked for qemu */
#if 0
if (status != HAL_SUCCESS)
goto _err_exit;
#endif
SDD_TRACE(("- data write completed\r\n"));
return HAL_SUCCESS;
_err_exit:
SDD_TRACE(("- error on data write\r\n"));
return status;
}
/*****************************************************************************
* FUNCTION
*
* _sdd_write_sectors_dma
*
* DESCRIPTION
*
* This function performs DMA data transfer to the SD memory card in
* multiple unit of sectors.
*
* NOTE
*
*
* INPUTS
*
* sector :
* sector_cnt :
* io_buff :
*
* OUTPUTS
*
* uint32_t : Returns HAL_SUCCESS if successful initialization,
* else positive value is SSPD-specific error code,
* else negative value is NU system error code.
*
****************************************************************************/
static uint32_t _sdd_write_sectors_dma(uint32_t sector, uint32_t sector_cnt,
uint8_t * io_buff)
{
uint32_t status = SDD_INVALID_FUNCTION;
SD_R32 sd_rsp32;
uint32_t retry;
uint32_t sdc_status;
DMAD_DRB *drb;
#if 0
if (sector > (sdd.card_desc.card_capacity << 1)) {
SDD_TRACE(("Invalid sector address!\r\n"));
return SDD_INVLAID_ADDRESS;
}
if ((sector_cnt == 0) || (((sector + sector_cnt) > (sdd.card_desc.card_capacity << 1)))) {
SDD_TRACE(("Invalid sector address range!\r\n"));
return SDD_INVLAID_ADDR_RANGE;
}
#endif
if (GETB32(SDC_STATUS, SDC_SR_WRITE_PROT_BIT)) {
SDD_TRACE(("Card is write protected!\r\n"));
return SDD_WRITE_PROTECTED;
}
/* todo: sector size */
/* reset dam wait event */
// hal_set_semaphore(&sdd.dma_sem, 0);
/* standby -> transfer */
SDD_TRACE(("- select_card\r\n"));
status = _sd_select_card(sdd.card_desc.rca);
if (status != HAL_SUCCESS)
goto _safe_exit;
/* send SD command to setup write-block-size */
/* todo: assume sector size is 512 bytes */
SDD_TRACE(("- cmd16\r\n"));
status = _sd_cmd16(SDD_SECTOR_SIZE, &sd_rsp32);
if (status != HAL_SUCCESS)
goto _safe_exit;
/* set SDC data timeout register */
OUT32(SDC_DATA_TIMER, sdd.card_desc.write_timeout_clks);
/* set SDC data length register */
OUT32(SDC_DATA_LEN, sector_cnt * SDD_SECTOR_SIZE);
/* set SDC data control register */
OUT32(SDC_DATA_CR, SDC_DATA_EN_MASK | SDC_DATA_WRITE_MASK | SDC_DMA_EN_MASK | ((SDD_POWER_OF_SECTOR_SIZE << SDC_BLK_SIZE_SHIFT) & SDC_BLK_SIZE_MASK)); /* 2^9 = 512 bytes */
/* send SD command to write data */
SDD_TRACE(("- cmd25\r\n"));
if (sdd.card_desc.card_ccs == SDD_CCS_SD)
status = _sd_cmd25(sector * SDD_SECTOR_SIZE, &sd_rsp32); /* address unit is byte for SD */
else
status = _sd_cmd25(sector, &sd_rsp32); /* address unit is 512 bytes for SDHC */
if (status != HAL_SUCCESS)
goto _safe_exit;
SDD_TRACE(("- wait ready to write out data\r\n"));
_nds_kwait(0x1000); /* hw need delay ? */
/* This method look not necessary for writing. */
// status = _sd_wait_receiving_state(sdd.card_desc.rca);
// if (status != HAL_SUCCESS) */
// goto _err_exit; */
/* per sector DMA write out */
SDD_TRACE(("- write out data\r\n"));
dmad_apb_config_dir(&sdd.dma_ch, DMAD_DIR_A1_TO_A0);
if(hal_create_semaphore(&sdd.dma_sem, 0, 0) == HAL_FAILURE)
SDD_TRACE(("Failed to create dma semaphore\r\n"));
while (sector_cnt-- > 0) {
SDD_TRACE(("sector_cnt: %ld\r\n", sector_cnt));
/* Prepare DRB */
status = _dmad_alloc_drb(&sdd.dma_ch, &drb);
if (status != HAL_SUCCESS)
goto _safe_exit;
drb->src_addr = (void *)io_buff;
drb->dst_addr = (void *)SDC_DATA_WIN;
drb->req_size = SDD_SECTOR_SIZE >> 2; /* multiple counts of transfer width */
if (sector_cnt == 0)
drb->completion_sem = &sdd.dma_sem; /* Register DMA completion notification */
/* Submit DRB */
status = _dmad_submit_request(&sdd.dma_ch, drb);
if (status != HAL_SUCCESS)
goto _safe_exit;
/* Point to next buffer location */
io_buff += SDD_SECTOR_SIZE;
}
/*
* Wait DMA completion
* - method 1: sync with semaphore
* - method 2: check SDC status register SDC_STATUS[7]
*/
status = hal_pend_semaphore(&sdd.dma_sem, 600); /* 6 sec */
/* Check waiting status */
if (status == HAL_ERR_TIMEOUT) {
SDD_TRACE(("- wait dma completion timeout (might not an error)\r\n"));
goto _safe_exit;
}
else if (status != HAL_SUCCESS) {
SDD_TRACE(("- wait dma completion failed\r\n"));
goto _safe_exit;
}
/* Wait host SDC shift-out FIFO data */
SDD_TRACE(("- final check sdc_status\r\n"));
retry = 0;
while (retry++ < SD_WRITE_MAX_RETRY_COUNT) {
sdc_status = IN32(SDC_STATUS);
if (sdc_status &
(SDC_SR_CARD_DETECT_MASK | SDC_SR_DATA_TIMEOUT_MASK |
SDC_SR_DATA_CRC_FAIL_MASK)) {
status = SDD_WRITE_DATA_ERROR;
goto _safe_exit;
}
if ((sdc_status == 0) || (sdc_status & SDC_SR_DATA_END_MASK))
break;
}
/* Stop data transmission */
SDD_TRACE(("- stop transmission\r\n"));
status = _sd_stop_transmission(sdd.card_desc.rca);
/* FIXME this part is marked for qemu */
#if 0
if (status != HAL_SUCCESS)
goto _safe_exit;
#endif
status = HAL_SUCCESS;
_safe_exit:
#if (SDD_DEBUG_TRACE)
if (status == HAL_SUCCESS)
SDD_TRACE(("- data read completed\r\n"));
else
SDD_TRACE(("- error on data read\r\n"));
#endif /* SDD_DEBUG_TRACE */
return status;
}
/*****************************************************************************
* FUNCTION
*
* _sdd_lisr
*
* DESCRIPTION
*
* This is the ISR that services SD card detection interrupt on the NDS32
* evb platform.
*
* NOTE
*
* Card Detection Procedures (LISR)
* LISR set HISR activation state flag
* LISR activates HISR
* call _sdd_cd_reset() to perform card insertion or removal tasks.
*
* Card Detection Procedures (_sdd_init)
* Perform basic SD controller register setup
* Checks SDC_SR_CARD_DETECT_BIT bit
* call _sdd_cd_reset() to perform card insertion or removal tasks.
*
* INPUTS
*
* vector : Interrupt vector number
*
* OUTPUTS
*
* none
*
****************************************************************************/
void _sdd_lisr(int vector)
{
DEBUG(1, 1, "_sdd_lisr\r\n");
printf("hal_raise_bh0\n");
/* Fault invocation checking */
if (vector != IRQ_SDC_VECTOR )
hal_system_error(HAL_ERR_UNHANDLED_INTERRUPT);
/* Mask : Disable SDC interrupt */
hal_intc_irq_disable(IRQ_SDC_VECTOR);
/* Ack : Clean SDC interrupt pending */
hal_intc_irq_clean(IRQ_SDC_VECTOR);
printf("hal_raise_bh1\n");
if (GETB32(SDC_STATUS, SDC_SR_CARD_CHANGE_BIT)) {
SETB32(SDC_CLEAR, SDC_CARD_CHANGE_BIT);
/* Set HISR status register to get channel number */
sdd.hisr_as |= SDD_HISR_AS_CD;
printf("hal_raise_bh2\n");
hal_raise_bh(&sdd.hisr); /* Activate HISR to complete deferred tasks */
}
else {
printf("hal_raise_bh3\n");
/* todo: handle other interrupts. */
OUT32(SDC_CLEAR, SDC_CLEAR_ALL);
}
/* Unmask : Enable SDC interrupt */
hal_intc_irq_enable(IRQ_SDC_VECTOR);
}
/*****************************************************************************
* FUNCTION
*
* _sdd_hisr
*
* DESCRIPTION
*
* This is the HISR that services SD card detection interrupt on the NDS32
* evb platform.
*
* NOTE
*
*
* INPUTS
*
*
*
* OUTPUTS
*
* none
*
****************************************************************************/
void _sdd_hisr(void *param)
{
hal_bh_t *bh = (hal_bh_t *)param;
uint32_t core_intl;
uint8_t hisr_as; /* HISR activation state - Card Detection */
while (1){
DEBUG(1, 1, "_sdd_hisr before\n");
hal_pend_semaphore(&bh->sem, HAL_SUSPEND);
/*
* Disable CPU interrupt
* Todo: frequently int-disable due to frequently HISR-call may cause problems?
*/
core_intl = hal_global_int_ctl(HAL_DISABLE_INTERRUPTS);
/* Clone HISR activation state */
hisr_as = sdd.hisr_as;
sdd.hisr_as &= ~(uint32_t) SDD_HISR_AS_CD;
/* Enable CPU interrupt */
hal_global_int_ctl(core_intl);
/* Card detect initialization */
if (hisr_as & SDD_HISR_AS_CD) {
if (GETB32(SDC_STATUS, SDC_SR_CARD_DETECT_BIT)) {
SDD_TRACE(("SD card removed!\r\n"));
/* Perform card-remove tasks (turn off clock ...) */
_sdd_cd_reset(HAL_FALSE);
}
else {
SDD_TRACE(("SD card inserted!\r\n"));
/* Reset card and get device parameters */
_sdd_cd_reset(HAL_TRUE);
}
}
}
}
#if (SDD_VFS_SUPPORT)
//STATUS _sdd_read_sectors(SDD_IOCTL_READ_SECTORS_PARAM *iop);
STATUS _sdd_read_sectors_bdev(NDS_BDEV *bdev, UINT32 sector, UINT32 sector_count, void *buffer)
{
STATUS io_status;
SDD_DEVICE sdd_dev; // FIXME, NDS_SD_ReadSectors doesn't use this argument actully
BDEV_TRACE(("_sdd_read_sectors_bdev()\r\n"));
BDEV_TRACE((" read start at sector (0x%08lx + 0x%08lx = 0x%08lx) count (0x%08lx)\r\n",
bdev->start, sector, bdev->start + sector, sector_count));
#ifndef CONFIG_PLAT_QEMU
io_status = NDS_SD_ReadSectors(&sdd_dev, bdev->start + sector, sector_count, 512, buffer);
#else
io_status = NDS_SD_ReadSectors(&sdd_dev, sector, sector_count, 512, buffer);
#endif
#if 0
if (NU_Current_Task_Pointer() != HAL_NULL)
{
// obtain exclusive access to driver
request.nu_function = NU_ASSIGN;
request.nu_timeout = NU_SUSPEND;
status = NU_Request_Driver(&sdd_dcb, &request);
if (status != NU_SUCCESS)
return status;
}
// perform i/o operation
BDEV_TRACE((" read start at sector (0x%08lx + 0x%08lx = 0x%08lx) count (0x%08lx)\r\n",
bdev->start, sector, bdev->start + sector, sector_count));
iop.lba_sector = bdev->start + sector;
iop.sector_count = sector_count;
iop.sector_size = SDD_SECTOR_SIZE;
iop.io_buff = buffer;
io_status = _sdd_read_sectors(&iop);
if (NU_Current_Task_Pointer() != HAL_NULL)
{
// release exclusive access to driver
request.nu_function = NU_RELEASE;
status = NU_Request_Driver(&sdd_dcb, &request);
if (status != NU_SUCCESS)
return status;
}
#endif
return io_status;
}
//STATUS _sdd_write_sectors(SDD_IOCTL_WRITE_SECTORS_PARAM *iop);
STATUS _sdd_write_sectors_bdev(NDS_BDEV *bdev, UINT32 sector, UINT32 sector_count, void *buffer)
{
STATUS io_status;
SDD_DEVICE sdd_dev; // FIXME, NDS_SD_ReadSectors doesn't use this argument actully
BDEV_TRACE(("_sdd_write_sectors_bdev()\r\n"));
#ifndef CONFIG_PLAT_QEMU
io_status = NDS_SD_WriteSectors(&sdd_dev, bdev->start + sector, sector_count, 512, buffer);
#else
io_status = NDS_SD_WriteSectors(&sdd_dev, sector, sector_count, 512, buffer);
#endif
#if 0
if (NU_Current_Task_Pointer() != HAL_NULL)
{
// obtain exclusive access to driver
request.nu_function = NU_ASSIGN;
request.nu_timeout = NU_SUSPEND;
status = NU_Request_Driver(&sdd_dcb, &request);
if (status != NU_SUCCESS)
return status;
}
// perform i/o operation
BDEV_TRACE((" write start at sector (0x%08lx + 0x%08lx = 0x%08lx) count (0x%08lx)\r\n",
bdev->start, sector, bdev->start + sector, sector_count));
iop.lba_sector = bdev->start + sector;
iop.sector_count = sector_count;
iop.sector_size = SDD_SECTOR_SIZE;
iop.io_buff = buffer;
io_status = _sdd_write_sectors(&iop);
if (NU_Current_Task_Pointer() != HAL_NULL)
{
// release exclusive access to driver
request.nu_function = NU_RELEASE;
status = NU_Request_Driver(&sdd_dcb, &request);
if (status != NU_SUCCESS)
return status;
}
#endif
BDEV_TRACE((" status (0x%08lx)\r\n", io_status));
return io_status;
}
#endif // SDD_VFS_SUPPORT
/*****************************************************************************
* FUNCTION
*
* _sdd_init
*
* DESCRIPTION
*
* This function initializes the SDC device.
*
* NOTE
*
* SD/MEM : PC-Card Memory mode, PC-Card I/O mode, True-IDE.
* SDIO : Todo.
* SDHC : Not supported.
* MMC : Todo.
*
* Todo : Resource leaks is not recovered if error happens
* during init process. Client currently has to do
* TERMINATE request anyway, if driver load/unload
* resource control is a necessary, no-matter the
* initialization process is successful or not.
*
* INPUTS
*
* sdd_dev : user device struct
*
* OUTPUTS
*
* uint32_t : Returns HAL_SUCCESS if successful initialization,
* else positive value is SDD-specific error code,
* else negative value is NU system error code.
*
****************************************************************************/
static uint32_t _sdd_init(SDD_DEVICE * sdd_dev)
{
uint32_t status = HAL_SUCCESS;
uint32_t core_intl;
SDD_TRACE(("_sdd_init()\r\n"));
/* Perform Parameter Checking */
#if (!SDD_SMALL_FOOTPRINT)
/* Check supplemental init structure */
if (sdd_dev == HAL_NULL) {
SDD_TRACE(("null sdd_dev!\r\n"));
return HAL_ERR_INVALID_POINTER;
}
/* Check duplicated device initialization */
if (sdd.valid != 0) {
/* Error if the device has been initialized */
SDD_TRACE(("sdd.valid is non-zero!\r\n"));
return SDD_INVALID_INIT;
}
#endif /* (!SDD_SMALL_FOOTPRINT) */
/* Initialize SDC driver resources */
/* Allocate DMA channel if user requested static DMA channel mode */
switch (sdd_dev->dma) {
case SDD_DMA_NONE:
case SDD_DMA_DCH:
break;
case SDD_DMA_SCH:
status = _sdd_alloc_dma_channel();
if (status != HAL_SUCCESS)
return status;
break;
default:
return SDD_INVALID_PARAMETER;
}
sdd.dma = sdd_dev->dma;
/*
* Allocate mutex (a semaphore with init count == 1)
* for driver access control
*/
status = hal_create_mutex(&sdd.semaphore, "sdd_sem");
if (status != HAL_SUCCESS) {
SDD_TRACE(("Failed to create SD driver semaphore!\r\n"));
return status;
}
/*
* Allocate synchronization object for SDD to receive DMA completion notfication
* (init count is 0 so any obtain have to wait first)
*/
status = hal_create_semaphore(&sdd.dma_sem, 0, 0);
if (status != HAL_SUCCESS) {
SDD_TRACE(("Failed to allocate SD driver dma semaphore!\r\n"));
hal_destroy_mutex(&sdd.semaphore);
return status;
}
/* Register LISR to receive SDC events */
if (sdd.lisr_registered == 0) {
/* Register LISR for SDC events interrupt */
status = hal_register_isr(IRQ_SDC_VECTOR, _sdd_lisr, (void*)0);
if (status != HAL_SUCCESS) {
SDD_TRACE(("Failed to register SD driver LISR!\r\n"));
hal_destroy_mutex(&sdd.semaphore);
hal_destroy_semaphore(&sdd.dma_sem);
return status;
}
sdd.lisr_registered = 1;
}
/* Register HISR to perform deferred SDC ISR tasks */
if (sdd.hisr_registered == 0) {
sdd.hisr.th.fn = _sdd_hisr;
sdd.hisr.th.arg = &sdd.hisr;
sdd.hisr.th.ptos = &sdd_hisr_stack[SDD_HISR_STACK_SIZE];
sdd.hisr.th.stack_size = sizeof(sdd_hisr_stack);
sdd.hisr.th.prio = CONFIG_SDD_HISR_PRIORITY;
sdd.hisr.th.name = "SD BH";
status = hal_create_bh(&sdd.hisr);
if (status != HAL_SUCCESS) {
DEBUG(1, 1, "Failed to create SD driver HISR!\r\n");
hal_destroy_mutex(&sdd.semaphore);
hal_destroy_semaphore(&sdd.dma_sem);
return status;
}
sdd.hisr_registered = 1;
}
/* Update driver data */
#if (SDD_VFS_SUPPORT)
// Init SDD-specific bdev object
sdd_bdev.next = HAL_NULL;
sdd_bdev.dev_id = 0;
sdd_bdev.vol_id = 0;
sdd_bdev.type = 0;
sdd_bdev.start = 0;
sdd_bdev.blocks = 0;
sdd_bdev.propagate_event = HAL_NULL;
sdd_bdev.read_sectors = _sdd_read_sectors_bdev;
sdd_bdev.write_sectors = _sdd_write_sectors_bdev;
sdd_dev->bdev_id = &sdd_bdev;
#endif // SDD_VFS_SUPPORT
/*
* Initialize SDC device
*
* SD card initialization and identification are performed either at
* - when the card was inserted (i.e., triggered from ISR and HISR), or
* - when this init routine was invoked and the card was already in the slot.
*/
/* Disable CPU interrupt */
core_intl = hal_global_int_ctl(HAL_DISABLE_INTERRUPTS);
/* - Disable SDC interrupt */
hal_intc_irq_disable(IRQ_SDC_VECTOR);
/* - Clear SDC interrupt status */
hal_intc_irq_clean(IRQ_SDC_VECTOR);
/* - Setup SDC interrupt trigger mode - level trigger */
/* - Setup SDC interrupt trigger level - assert high */
hal_intc_irq_config(IRQ_SDC_VECTOR,IRQ_LEVEL_TRIGGER, IRQ_ACTIVE_HIGH);
/* - Enable SDC interrupt */
hal_intc_irq_enable(IRQ_SDC_VECTOR);
#if 0
#if(NO_EXTERNAL_INT_CTL==1)
/* FIXME
* - Setup SDC interrupt trigger mode */
/* - Enable SDC interrupt */
SR_SETB32(NDS32_SR_INT_MASK2,IRQ_SDC_VECTOR );
#else
/* INTC */
/* - Disable SDC interrupt */
CLRB32(INTC_HW1_ER, IRQ_SDC_VECTOR);
/* - Clear SDC interrupt status */
SETB32(INTC_HW1_CLR, IRQ_SDC_VECTOR);
/* - Setup SDC interrupt trigger mode - level trigger */
CLRB32(INTC_HW1_TMR, IRQ_SDC_VECTOR);
/* - Setup SDC interrupt trigger level - assert high */
CLRB32(INTC_HW1_TLR, IRQ_SDC_VECTOR);
/* - Enable SDC interrupt */
SETB32(INTC_HW1_ER, IRQ_SDC_VECTOR);
#endif
#endif
/* APBMCLKOFF */
/* todo */
/*
* SDC_PWR_CTL
* SD_POWER 0 (default: 0x00) (leave bootup default?)
* SD_POWER_ON 0 (off) (default: 0x10)
*/
CLRB32(SDC_PWR_CTL, SDC_SD_POWER_ON_BIT);
_nds_kwait(0x4000);
/*
* SDC_CLK_CTL
* CLK_DIV 0x7f (default: 0x7f, result in 97.66K ~ 683.59K SD bus freq)
* CLK_SD 1 (default: 1 (SD))
* CLK_DIS 1 (off) (default: 0x01)
*/
OUT32(SDC_CLK_CTL, (SDC_CLK_OFF << SDC_CLK_DIS_BIT) |
(SDC_CLK_SD << SDC_CLK_SD_BIT) | SDC_CLK_DIV_MASK);
/*
* SDC_MASK (note: spec "mask" means "enable", spec uses wrong term to describe this register)
* RSP_CRC_FAIL mask int
* DATA_CRC_FAIL mask int
* RSP_TIMEOUT mask int
* DATA_TIMEOUT mask int
* RSP_CRC_OK mask int
* DATA_CRC_OK mask int
* CMD_SENT mask int
* DATA_END mask int
* FIFO_U_RUN mask int
* FIFO_O_RUN mask int
* CARD_CHANGE enable int
*/
OUT32(SDC_MASK, SDC_CARD_CHANGE_MASK);
/* SDC_CLEAR */
/* Clear all */
OUT32(SDC_CLEAR, SDC_CLEAR_ALL);
/*
* Following host controller register register setting needs information
* from the card, hence is postponed in the card initialization and
* identification routine.
*
* Data setup (need CSD/SCR)
*
* SDC_DATA_CR (setup before data transfer)
* SDC_DATA_TIMER (TAAC/NSAC)
* SDC_DATA_LEN (READ/WRITE/ERASE_BL_LEN, SECTOR_SIZE)
* SDC_BUS_WIDTH (SCR::SD_BUS_WIDTHS)
*
* Power/Clock settings (need OCR)
*
* SDC_PWR_CTL (OCR::Vdd)
* SDC_CLK_CTL (fod, fpp)
*/
/*
* Detect card and perform card-detection initialization, if the is
* already in the slot before we re-enable interrupt.
*/
if (GETB32(SDC_STATUS, SDC_SR_CARD_DETECT_BIT)) {
/* Perform card-remove tasks (turn off clock ...) */
SDD_TRACE(("SD card is not in slot!\r\n"));
_sdd_cd_reset(HAL_FALSE);
}
else {
/* Reset card and get device parameters */
SDD_TRACE(("SD card is in slot!\r\n"));
_sdd_cd_reset(HAL_TRUE);
//_sdd_cd_reset(HAL_TRUE);
//_sdd_cd_reset(HAL_TRUE);
//_sdd_cd_reset(HAL_TRUE);
// FIXME
}
/* Restore CPU interrupt controller to previous level */
hal_global_int_ctl(core_intl);
/* Mark driver state as valid */
sdd.valid = 1;
return HAL_SUCCESS;
}
/*****************************************************************************
* FUNCTION
*
* _sdd_unload
*
* DESCRIPTION
*
* Remove all the device resource so the driver could be removed safely.
*
* NOTE
*
* INPUTS
*
* none
*
* OUTPUTS
*
* uint32_t : Returns HAL_SUCCESS if successful initialization,
* else positive value is SDD-specific error code,
* else negative value is NU system error code.
*
****************************************************************************/
static uint32_t _sdd_unload(void)
{
uint32_t status;
#if (!SDD_SMALL_FOOTPRINT)
/* Validate to terminate an already initialized driver state */
if (sdd.valid == 0)
return HAL_ERR_INVALID_DRIVER;
#endif /* (!SDD_SMALL_FOOTPRINT) */
// Notify file system
#if (SDD_VFS_SUPPORT)
if (sdd_bdev.propagate_event != HAL_NULL)
sdd_bdev.propagate_event(&sdd_bdev, NDSBDEV_DEVICE_UNPLUG, HAL_NULL);
sdd_bdev.next = HAL_NULL;
sdd_bdev.dev_id = 0;
sdd_bdev.vol_id = 0;
sdd_bdev.type = 0;
sdd_bdev.start = 0;
sdd_bdev.blocks = 0;
sdd_bdev.propagate_event = HAL_NULL;
sdd_bdev.read_sectors = HAL_NULL;
sdd_bdev.write_sectors = HAL_NULL;
#endif // SDD_VFS_SUPPORT
/* Shutdown device operation */
/* Release driver resources */
if (sdd.dma == SDD_DMA_SCH)
_sdd_free_dma_channel();
status = hal_destroy_bh(&sdd.hisr);
if (status != HAL_SUCCESS)
return status;
status = hal_destroy_semaphore(&sdd.dma_sem);
if (status != HAL_SUCCESS)
return status;
status = hal_destroy_mutex(&sdd.semaphore);
if (status != HAL_SUCCESS)
return status;
sdd.valid = 0;
return HAL_SUCCESS;
}
/*****************************************************************************
* FUNCTION
*
* _sdd_lock
*
* DESCRIPTION
*
* Obtain exclusive access to the devcie driver.
*
* NOTE
*
* INPUTS
*
* none
*
* OUTPUTS
*
* uint32_t : Returns HAL_SUCCESS if successful initialization,
* else positive value is SDD-specific error code,
* else negative value is NU system error code.
*
****************************************************************************/
static inline uint32_t _sdd_lock(void)
{
#if (!SDD_SMALL_FOOTPRINT)
if (sdd.valid == 0)
return HAL_ERR_INVALID_DRIVER;
#endif /* (!SDD_SMALL_FOOTPRINT) */
return hal_wait_for_mutex(&sdd.semaphore, HAL_SUSPEND);
}
/*****************************************************************************
* FUNCTION
*
* _sdd_unlock
*
* DESCRIPTION
*
* Release exclusive access to the device driver.
*
* NOTE
*
* INPUTS
*
* none
*
* OUTPUTS
*
* uint32_t : Returns HAL_SUCCESS if successful initialization,
* else positive value is SDD-specific error code,
* else negative value is NU system error code.
*
****************************************************************************/
static inline uint32_t _sdd_unlock(void)
{
#if (!SDD_SMALL_FOOTPRINT)
if (sdd.valid == 0)
return HAL_ERR_INVALID_DRIVER;
#endif /* (!SDD_SMALL_FOOTPRINT) */
return hal_release_mutex(&sdd.semaphore);
}
/*****************************************************************************
* FUNCTION
*
* _sdd_read_sectors
*
* DESCRIPTION
*
* Read sectors of data from the card. This is the DMA/PIO mode data-
* read dispatch function for client IOCTL request.
*
* NOTE
*
* INPUTS
*
* iop : pointer to SDD_IOCTL_READ_SECTORS_PARAM struct which
* specifies the IOCTL parameters.
*
* OUTPUTS
*
* uint32_t : Returns HAL_SUCCESS if successful initialization,
* else positive value is SDD-specific error code,
* else negative value is NU system error code.
*
****************************************************************************/
static uint32_t _sdd_read_sectors(SDD_IOCTL_READ_SECTORS_PARAM * iop)
{
uint32_t sector = iop->lba_sector;
uint32_t sector_cnt = iop->sector_count;
uint8_t *io_buff = (uint8_t *) iop->io_buff;
uint32_t status;
uint32_t core_intl;
uint32_t rca = 0;
SDD_TRACE(("\r\n_sdd_read_sectors\r\n"));
/* Disable CPU interrupt */
core_intl = hal_global_int_ctl(HAL_DISABLE_INTERRUPTS);
/* Check if SD card has been initialized to transfer state */
rca = sdd.card_desc.rca;
/* Restore CPU interrupt controller to previous level */
hal_global_int_ctl(core_intl);
/* Reject if SD card is not initialized to transfer state */
if (rca == 0)
return SDD_INVALID_INIT;
/* Data transfer ... */
if ((sdd.dma != SDD_DMA_NONE) /* && (hal_current() != HAL_NULL) */ ) {
SDD_TRACE(("dma - sector(%ld) counts(%ld)\r\n", sector,
sector_cnt));
if (sdd.dma == SDD_DMA_DCH) {
status = _sdd_alloc_dma_channel();
if (status != HAL_SUCCESS)
return status;
}
while (sector_cnt > 0) {
/*
* SDC data length register max is 24 bits (32768 sectors).
* Divided by 2 for safe in case sector size is larger than 512 bytes.
* (so max sector size should be less than 1024 bytes)
*/
if (sector_cnt >= 16384) {
/* Use SD multiple block transfer for sectors. */
status = _sdd_read_sectors_dma(sector, 16384, io_buff);
if (status != HAL_SUCCESS) {
/* Release DMA channel */
if (sdd.dma == SDD_DMA_DCH)
_sdd_free_dma_channel();
return status;
}
sector += 16384;
sector_cnt -= 16384;
io_buff += SDD_SECTOR_SIZE * 16384;
}
else {
/* Use SD multiple block transfer for all sectors. */
status = _sdd_read_sectors_dma(sector, sector_cnt, io_buff);
sector_cnt = 0;
}
}
/* Wait for DMA completion signal */
/* Release DMA channel */
if (sdd.dma == SDD_DMA_DCH)
_sdd_free_dma_channel();
}
else {
/* PIO mode data transfer */
SDD_TRACE(("pio - sector(%ld) counts(%ld)\r\n", sector, sector_cnt));
while (sector_cnt > 0) {
/*
* SDC data length register max is 24 bits (32768 sectors).
* Divided by 2 for safe in case sector size is larger than 512 bytes.
* (so max sector size should be less than 1024 bytes)
*/
if (sector_cnt >= 16384) {
/* Use SD multiple block transfer for sectors. */
status = _sdd_read_sectors_pio(sector, 16384, io_buff);
if (status != HAL_SUCCESS)
return status;
sector += 16384;
sector_cnt -= 16384;
io_buff += SDD_SECTOR_SIZE * 16384;
}
else {
/* Use SD multiple block transfer for all sectors. */
status = _sdd_read_sectors_pio(sector, sector_cnt, io_buff);
sector_cnt = 0;
}
}
}
return HAL_SUCCESS;
}
/*****************************************************************************
* FUNCTION
*
* _sdd_write_sectors
*
* DESCRIPTION
*
* Write sectors of data to the card. This is the DMA/PIO mode data-
* write dispatch function for client IOCTL request.
*
* NOTE
*
* INPUTS
*
* iop : pointer to SDD_IOCTL_READ_SECTORS_PARAM struct which
* specifies the IOCTL parameters.
*
* OUTPUTS
*
* uint32_t : Returns HAL_SUCCESS if successful initialization,
* else positive value is SDD-specific error code,
* else negative value is NU system error code.
*
****************************************************************************/
static uint32_t _sdd_write_sectors(SDD_IOCTL_WRITE_SECTORS_PARAM * iop)
{
uint32_t sector = iop->lba_sector;
uint32_t sector_cnt = iop->sector_count;
uint8_t *io_buff = (uint8_t *) iop->io_buff;
uint32_t status;
uint32_t core_intl;
uint32_t rca = 0;
SDD_TRACE(("\r\n_sdd_write_sectors\r\n"));
/* Disable CPU interrupt */
core_intl = hal_global_int_ctl(HAL_DISABLE_INTERRUPTS);
/* Check if SD card has been initialized to transfer state */
rca = sdd.card_desc.rca;
/* Restore CPU interrupt controller to previous level */
hal_global_int_ctl(core_intl);
/* Reject if SD card is not initialized to transfer state */
if (rca == 0)
return SDD_INVALID_INIT;
/* Data transfer ... */
if ((sdd.dma != SDD_DMA_NONE) /* && (hal_current() != HAL_NULL) */ ) {
SDD_TRACE(("dma - sector(%ld) counts(%ld)\r\n", sector,
sector_cnt));
if (sdd.dma != SDD_DMA_SCH) {
status = _sdd_alloc_dma_channel();
if (status != HAL_SUCCESS)
return status;
}
while (sector_cnt > 0) {
/*
* SDC data length register max is 24 bits (32768 sectors).
* Divided by 2 for safe in case sector size is larger than 512 bytes.
* (so max sector size should be less than 1024 bytes)
*/
if (sector_cnt >= 16384) {
/* Use SD multiple block transfer for sectors. */
status = _sdd_write_sectors_dma(sector, 16384, io_buff);
if (status != HAL_SUCCESS) {
if (sdd.dma == SDD_DMA_DCH)
_sdd_free_dma_channel();
return status;
}
sector += 16384;
sector_cnt -= 16384;
io_buff += SDD_SECTOR_SIZE * 16384;
}
else {
/* Use SD multiple block transfer for all sectors. */
status = _sdd_write_sectors_dma(sector, sector_cnt, io_buff);
sector_cnt = 0;
}
}
/* Wait for DMA completion signal */
/* Release DMA channel */
if (sdd.dma == SDD_DMA_DCH)
_sdd_free_dma_channel();
}
else {
/* PIO mode data transfer */
SDD_TRACE(("pio - sector(%ld) counts(%ld)\r\n", sector,
sector_cnt));
while (sector_cnt > 0) {
/*
* SDC data length register max is 24 bits (32768 sectors).
* Divided by 2 for safe in case sector size is larger than 512 bytes.
* (so max sector size should be less than 1024 bytes)
*/
if (sector_cnt >= 16384) {
/* Use SD multiple block transfer for sectors. */
status = _sdd_write_sectors_pio(sector, 16384, io_buff);
if (status != HAL_SUCCESS)
return status;
sector += 16384;
sector_cnt -= 16384;
io_buff += SDD_SECTOR_SIZE * 16384;
}
else {
/* Use SD multiple block transfer for all sectors. */
status = _sdd_write_sectors_pio(sector, sector_cnt, io_buff);
sector_cnt = 0;
}
}
}
return HAL_SUCCESS;
}
/*****************************************************************************
* FUNCTION
*
* _sdd_ioctl
*
* DESCRIPTION
*
* This function execute I/O control commands to SDC driver.
*
* NOTE
*
*
* INPUTS
*
* driver : device object/control_block
* request : request function and supplemental parameters
*
* OUTPUTS
*
* uint32_t : Returns HAL_SUCCESS if successful initialization,
* else positive value is SDD-specific error code,
* else negative value is NU system error code.
*
****************************************************************************/
static inline uint32_t _sdd_ioctl(uint32_t ioctl, void *param)
{
uint32_t status = HAL_SUCCESS;
#if (!SDD_SMALL_FOOTPRINT)
/* Validate to terminate an already initialized driver state */
if (sdd.valid == 0)
return HAL_ERR_INVALID_DRIVER;
#endif /* (!UARTD_SMALL_FOOTPRINT) */
if (param == HAL_NULL)
return SDD_INVALID_PARAMETER;
switch (ioctl) {
case SDD_IOCTL_READ_SECTORS:
/* Parameter: pointer to SDD_IOCTL_READ_SECTORS_PARAM struct */
status = _sdd_read_sectors((SDD_IOCTL_READ_SECTORS_PARAM *) param);
break;
case SDD_IOCTL_WRITE_SECTORS:
/* Parameter: pointer to SDD_IOCTL_READ_SECTORS_PARAM struct */
status = _sdd_write_sectors((SDD_IOCTL_WRITE_SECTORS_PARAM *) param);
break;
default:
status = SDD_INVALID_IOCTL;
break;
}
return status;
}
/*****************************************************************************
* FUNCTION
*
* NDS_SD_Init
*
* DESCRIPTION
*
* This function initializes the SD device.
*
* INPUTS
*
* sdd_dev : User mode SDD device structure.
*
* OUTPUTS
*
* uint32_t : Returns HAL_SUCCESS if successful initialization,
* else a negative value is returned.
*
****************************************************************************/
uint32_t NDS_SD_Init(SDD_DEVICE * sdd_dev)
{
return _sdd_init(sdd_dev);
}
/*****************************************************************************
* FUNCTION
* NDS_SD_Unload
*
* DESCRIPTION
*
* This function terminates all SD transaction and unload the driver.
*
* INPUTS
*
* None.
*
* OUTPUTS
*
* None.
*
****************************************************************************/
void NDS_SD_Unload()
{
_sdd_unload();
}
/*****************************************************************************
* FUNCTION
*
* NDS_SD_ReadSectors
*
* DESCRIPTION
*
* This function read sectors of data from the SD memory card.
*
* INPUTS
*
* sdd_dev : User mode SDD device structure.
* sector : The starting LBA sector number.
* sector_count : Number of sectors to read.
* sector_size : Size of a sector in bytes.
* buffer : Pointer to a user buffer to hold the readback data.
*
* OUTPUTS
*
* uint32_t : Returns HAL_SUCCESS if successful initialization,
* else a negative value is returned.
*
****************************************************************************/
uint32_t NDS_SD_ReadSectors(SDD_DEVICE * sdd_dev, uint32_t sector,
uint32_t sector_count, uint32_t sector_size,
void *buffer)
{
uint32_t status;
uint32_t io_status;
SDD_IOCTL_READ_SECTORS_PARAM iop;
status = _sdd_lock();
if (status != HAL_SUCCESS)
hal_system_error(status);
iop.lba_sector = sector;
iop.sector_count = sector_count;
iop.sector_size = sector_size;
iop.io_buff = buffer;
io_status = _sdd_read_sectors(&iop);
status = _sdd_unlock();
if (status != HAL_SUCCESS)
hal_system_error(status);
return io_status;
}
/*****************************************************************************
* FUNCTION
*
* NDS_SD_WriteSectors
*
* DESCRIPTION
*
* This function write sectors of data to the SD memory card.
*
* INPUTS
*
* sdd_dev : User mode SDD device structure.
* sector : The starting LBA sector number.
* sector_count : Number of sectors to write.
* sector_size : Size of a sector in bytes.
* buffer : Pointer to a user buffer of data to be written to the card.
*
* OUTPUTS
*
* uint32_t : Returns HAL_SUCCESS if successful initialization,
* else a negative value is returned.
*
****************************************************************************/
uint32_t NDS_SD_WriteSectors(SDD_DEVICE * sdd_dev, uint32_t sector,
uint32_t sector_count, uint32_t sector_size,
void *buffer)
{
uint32_t status;
uint32_t io_status;
SDD_IOCTL_WRITE_SECTORS_PARAM iop;
status = _sdd_lock();
if (status != HAL_SUCCESS)
hal_system_error(status);
iop.lba_sector = sector;
iop.sector_count = sector_count;
iop.sector_size = sector_size;
iop.io_buff = buffer;
io_status = _sdd_write_sectors(&iop);
status = _sdd_unlock();
if (status != HAL_SUCCESS)
hal_system_error(status);
return io_status;
}
Reference in New Issue View Git Blame Copy Permalink