/***************************************************************************** * * 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; }