1726 lines
49 KiB
C
1726 lines
49 KiB
C
#include "sys_config.h"
|
||
#include "typesdef.h"
|
||
#include "devid.h"
|
||
#include "list.h"
|
||
#include "dev.h"
|
||
#include "osal/task.h"
|
||
#include "osal/semaphore.h"
|
||
#include "osal/mutex.h"
|
||
#include "lib/sdhost/sdhost.h"
|
||
#include "hal/gpio.h"
|
||
#include "osal/irq.h"
|
||
#include "osal/string.h"
|
||
#include "osal/mutex.h"
|
||
#include "osal/irq.h"
|
||
#include "osal/task.h"
|
||
#include "osal/sleep.h"
|
||
#include "osal/timer.h"
|
||
#include "osal/work.h"
|
||
#ifdef PIN_FROM_PARAM
|
||
#include "pin_param.h"
|
||
#endif
|
||
|
||
|
||
extern uint8_t get_fat_isready();
|
||
struct sdh_device *sdh_test;
|
||
struct os_semaphore sem;
|
||
|
||
#define SD_SAMPLE_VALUE_PRINT (1)
|
||
|
||
#ifdef PSRAM_HEAP
|
||
#define SDHC_HEAP_MALLOC os_malloc_psram
|
||
#define SDHC_HEAP_FREE os_free_psram
|
||
#else
|
||
#define SDHC_HEAP_MALLOC os_malloc
|
||
#define SDHC_HEAP_FREE os_free
|
||
#endif
|
||
|
||
volatile uint32 sdhc_curr_write_byte = 0;
|
||
volatile uint32 sdhc_curr_read_byte = 0;
|
||
volatile uint32 sdhc_last_write_byte = 0;
|
||
volatile uint32 sdhc_last_read_byte = 0;
|
||
|
||
#define be32_to_cpu(x) ((uint32)( \
|
||
(((uint32)(x) & (uint32)0x000000ffUL) << 24) | \
|
||
(((uint32)(x) & (uint32)0x0000ff00UL) << 8) | \
|
||
(((uint32)(x) & (uint32)0x00ff0000UL) >> 8) | \
|
||
(((uint32)(x) & (uint32)0xff000000UL) >> 24)))
|
||
|
||
static uint32 __rt_fls(uint32 val)
|
||
{
|
||
uint32 bit = 32;
|
||
|
||
if (!val)
|
||
return 0;
|
||
if (!(val & 0xffff0000u))
|
||
{
|
||
val <<= 16;
|
||
bit -= 16;
|
||
}
|
||
if (!(val & 0xff000000u))
|
||
{
|
||
val <<= 8;
|
||
bit -= 8;
|
||
}
|
||
if (!(val & 0xf0000000u))
|
||
{
|
||
val <<= 4;
|
||
bit -= 4;
|
||
}
|
||
if (!(val & 0xc0000000u))
|
||
{
|
||
val <<= 2;
|
||
bit -= 2;
|
||
}
|
||
if (!(val & 0x80000000u))
|
||
{
|
||
bit -= 1;
|
||
}
|
||
|
||
return bit;
|
||
}
|
||
|
||
|
||
|
||
|
||
static const uint32 tran_unit[] =
|
||
{
|
||
10000, 100000, 1000000, 10000000,
|
||
0, 0, 0, 0
|
||
};
|
||
|
||
static const uint8 tran_value[] =
|
||
{
|
||
0, 10, 12, 13, 15, 20, 25, 30,
|
||
35, 40, 45, 50, 55, 60, 70, 80,
|
||
};
|
||
|
||
static const uint32 tacc_uint[] =
|
||
{
|
||
1, 10, 100, 1000, 10000, 100000, 1000000, 10000000,
|
||
};
|
||
|
||
static const uint8 tacc_value[] =
|
||
{
|
||
0, 10, 12, 13, 15, 20, 25, 30,
|
||
35, 40, 45, 50, 55, 60, 70, 80,
|
||
};
|
||
|
||
uint32 GET_BITS(uint32 *resp,
|
||
uint32 start,
|
||
uint32 size)
|
||
{
|
||
const int32_t __size = size;
|
||
const uint32 __mask = (__size < 32 ? 1 << __size : 0) - 1;
|
||
const int32_t __off = 3 - ((start) / 32);
|
||
const int32_t __shft = (start) & 31;
|
||
uint32 __res;
|
||
|
||
__res = resp[__off] >> __shft;
|
||
if (__size + __shft > 32)
|
||
__res |= resp[__off-1] << ((32 - __shft) % 32);
|
||
|
||
return __res & __mask;
|
||
}
|
||
|
||
|
||
void sdhost_io_func_init(uint32 req){
|
||
if(req == 1)
|
||
pin_func(HG_SDIOHOST_DEVID,4);
|
||
else
|
||
pin_func(HG_SDIOHOST_DEVID,1);
|
||
}
|
||
|
||
static int32_t sd_parse_scr(struct sdh_device *host)
|
||
{
|
||
struct rt_sd_scr *scr = &host->scr;
|
||
uint32 resp[4];
|
||
|
||
resp[3] = host->resp_scr[1];
|
||
resp[2] = host->resp_scr[0];
|
||
scr->sd_version = GET_BITS(resp, 56, 4);
|
||
scr->sd_bus_widths = GET_BITS(resp, 48, 4);
|
||
|
||
SDHC_WARN_PRINTF("sd_version : %d \t %d\r\n", scr->sd_version, scr->sd_bus_widths);
|
||
return 0;
|
||
}
|
||
#if 1//(defined (TXW81X) || defined (TXW82X))
|
||
static int32_t sd_switch(struct sdh_device *host)
|
||
{
|
||
int32_t ret;
|
||
struct rt_mmcsd_cmd cmd;
|
||
uint8 *buf = os_malloc(64);
|
||
if (!buf)
|
||
{
|
||
SDHC_ERR_PRINTF("mallo err!\r\n");
|
||
return 1;
|
||
}
|
||
|
||
host->data.blksize = 64;
|
||
host->data.blks = 1;
|
||
host->data.err = 0;
|
||
if (((const struct sdhc_hal_ops *)host->dev.ops)->read)
|
||
{
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->read(host, buf);
|
||
if (ret)
|
||
return 1;
|
||
}
|
||
|
||
memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
|
||
|
||
cmd.cmd_code = SD_SWITCH;
|
||
cmd.arg = 0x00FFFFF1;
|
||
cmd.flags = RESP_R1 | CMD_ADTC;
|
||
if (((const struct sdhc_hal_ops *)host->dev.ops)->cmd)
|
||
{
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->cmd(host, &cmd);
|
||
if (ret)
|
||
return 1;
|
||
}
|
||
|
||
if (((const struct sdhc_hal_ops *)host->dev.ops)->complete)
|
||
{
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->complete(host);
|
||
if (ret)
|
||
return 1;
|
||
}
|
||
|
||
if (buf[13] & 0x02)
|
||
host->max_data_rate = 50*1000*1000;
|
||
|
||
#if 0
|
||
for(int itk = 0;itk <64;itk++){
|
||
if(itk%32 == 0)
|
||
SDHC_WARN_PRINTF("\r\n");
|
||
|
||
SDHC_WARN_PRINTF("%02x ",buf[itk]);
|
||
}
|
||
#endif
|
||
|
||
memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
|
||
host->data.blksize = 64;
|
||
host->data.blks = 1;
|
||
host->data.err = 0;
|
||
if (((const struct sdhc_hal_ops *)host->dev.ops)->read)
|
||
{
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->read(host, buf);
|
||
if (ret)
|
||
return 1;
|
||
}
|
||
cmd.cmd_code = SD_SWITCH;
|
||
cmd.arg = 0x80FFFFF1;
|
||
cmd.flags = RESP_R1 | CMD_ADTC;
|
||
if (((const struct sdhc_hal_ops *)host->dev.ops)->cmd)
|
||
{
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->cmd(host, &cmd);
|
||
if (ret)
|
||
return 1;
|
||
}
|
||
|
||
if (((const struct sdhc_hal_ops *)host->dev.ops)->complete)
|
||
{
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->complete(host);
|
||
if (ret)
|
||
return 1;
|
||
}
|
||
|
||
#if 0
|
||
for(int itk = 0;itk <64;itk++){
|
||
if(itk%32 == 0)
|
||
SDHC_WARN_PRINTF("\r\n");
|
||
|
||
SDHC_WARN_PRINTF("%02x ",buf[itk]);
|
||
}
|
||
SDHC_WARN_PRINTF("\r\n");
|
||
#endif
|
||
|
||
if ((buf[16] & 0xF) != 1)
|
||
{
|
||
SDHC_ERR_PRINTF("switching card to high speed failed!");
|
||
return 1;
|
||
}
|
||
SDHC_WARN_PRINTF("switch finish\r\n");
|
||
host->cardflags |= CARD_FLAG_HIGHSPEED;
|
||
os_free(buf);
|
||
return 0;
|
||
}
|
||
#endif
|
||
|
||
unsigned int sd_dwCap;
|
||
static int32_t sd_parse_csd(struct sdh_device *host)
|
||
{
|
||
struct rt_mmcsd_csd *csd = &host->csd;
|
||
uint32 *resp = host->resp_csd;
|
||
|
||
csd->csd_structure = GET_BITS(resp, 126, 2);
|
||
|
||
switch (csd->csd_structure)
|
||
{
|
||
case 0:
|
||
host->cardflags &= ~CARD_FLAG_SDHC;
|
||
csd->taac = GET_BITS(resp, 112, 8);
|
||
csd->nsac = GET_BITS(resp, 104, 8);
|
||
csd->tran_speed = GET_BITS(resp, 96, 8);
|
||
csd->card_cmd_class = GET_BITS(resp, 84, 12);
|
||
csd->rd_blk_len = GET_BITS(resp, 80, 4);
|
||
csd->rd_blk_part = GET_BITS(resp, 79, 1);
|
||
csd->wr_blk_misalign = GET_BITS(resp, 78, 1);
|
||
csd->rd_blk_misalign = GET_BITS(resp, 77, 1);
|
||
csd->dsr_imp = GET_BITS(resp, 76, 1);
|
||
csd->c_size = GET_BITS(resp, 62, 12);
|
||
csd->c_size_mult = GET_BITS(resp, 47, 3);
|
||
csd->r2w_factor = GET_BITS(resp, 26, 3);
|
||
csd->wr_blk_len = GET_BITS(resp, 22, 4);
|
||
csd->wr_blk_partial = GET_BITS(resp, 21, 1);
|
||
csd->csd_crc = GET_BITS(resp, 1, 7);
|
||
|
||
host->card_blksize = 1 << csd->rd_blk_len;
|
||
host->card_capacity = (csd->c_size + 1) << (csd->c_size_mult + 2);
|
||
host->card_capacity *= host->card_blksize;
|
||
host->card_capacity >>= 10; /* unit:KB */
|
||
host->tacc_clks = csd->nsac * 100;
|
||
host->tacc_ns = (tacc_uint[csd->taac&0x07] * tacc_value[(csd->taac&0x78)>>3] + 9) / 10;
|
||
host->max_data_rate = tran_unit[csd->tran_speed&0x07] * tran_value[(csd->tran_speed&0x78)>>3];
|
||
|
||
#if 0
|
||
val = GET_BITS(resp, 115, 4);
|
||
unit = GET_BITS(resp, 112, 3);
|
||
csd->tacc_ns = (tacc_uint[unit] * tacc_value[val] + 9) / 10;
|
||
csd->tacc_clks = GET_BITS(resp, 104, 8) * 100;
|
||
|
||
val = GET_BITS(resp, 99, 4);
|
||
unit = GET_BITS(resp, 96, 3);
|
||
csd->max_data_rate = tran_unit[unit] * tran_value[val];
|
||
csd->ccc = GET_BITS(resp, 84, 12);
|
||
|
||
unit = GET_BITS(resp, 47, 3);
|
||
val = GET_BITS(resp, 62, 12);
|
||
csd->device_size = (1 + val) << (unit + 2);
|
||
|
||
csd->read_bl_len = GET_BITS(resp, 80, 4);
|
||
csd->write_bl_len = GET_BITS(resp, 22, 4);
|
||
csd->r2w_factor = GET_BITS(resp, 26, 3);
|
||
#endif
|
||
break;
|
||
case 1:
|
||
host->cardflags |= CARD_FLAG_SDHC;
|
||
|
||
/*This field is fixed to 0Eh, which indicates 1 ms.
|
||
The host should not use TAAC, NSAC, and R2W_FACTOR
|
||
to calculate timeout and should uses fixed timeout
|
||
values for read and write operations*/
|
||
csd->taac = GET_BITS(resp, 112, 8);
|
||
csd->nsac = GET_BITS(resp, 104, 8);
|
||
csd->tran_speed = GET_BITS(resp, 96, 8);
|
||
csd->card_cmd_class = GET_BITS(resp, 84, 12);
|
||
csd->rd_blk_len = GET_BITS(resp, 80, 4);
|
||
csd->rd_blk_part = GET_BITS(resp, 79, 1);
|
||
csd->wr_blk_misalign = GET_BITS(resp, 78, 1);
|
||
csd->rd_blk_misalign = GET_BITS(resp, 77, 1);
|
||
csd->dsr_imp = GET_BITS(resp, 76, 1);
|
||
csd->c_size = GET_BITS(resp, 48, 22);
|
||
|
||
csd->r2w_factor = GET_BITS(resp, 26, 3);
|
||
csd->wr_blk_len = GET_BITS(resp, 22, 4);
|
||
csd->wr_blk_partial = GET_BITS(resp, 21, 1);
|
||
csd->csd_crc = GET_BITS(resp, 1, 7);
|
||
|
||
host->card_blksize = 512;
|
||
host->card_capacity = (csd->c_size + 1) * 512; /* unit:KB */
|
||
host->tacc_clks = 0;
|
||
host->tacc_ns = 0;
|
||
host->max_data_rate = tran_unit[csd->tran_speed&0x07] * tran_value[(csd->tran_speed&0x78)>>3];
|
||
|
||
#if 0
|
||
csd->tacc_ns = 0;
|
||
csd->tacc_clks = 0;
|
||
|
||
val = GET_BITS(resp, 99, 4);
|
||
unit = GET_BITS(resp, 96, 3);
|
||
csd->max_data_rate = tran_unit[unit] * tran_value[val];
|
||
csd->ccc = GET_BITS(resp, 84, 12);
|
||
|
||
val = GET_BITS(resp, 48, 22);
|
||
csd->device_size = (1 + val) << 10;
|
||
|
||
csd->read_bl_len = 9;
|
||
csd->write_bl_len = 9;
|
||
/* host should not use this factor and should use 250ms for write timeout */
|
||
csd->r2w_factor = 2;
|
||
#endif
|
||
break;
|
||
default:
|
||
SDHC_ERR_PRINTF("unrecognised CSD structure version %d!", csd->csd_structure);
|
||
|
||
return -EINVAL;
|
||
}
|
||
host->card_max_blk_num = host->card_capacity << 1;
|
||
SDHC_WARN_PRINTF("SD card capacity %d KB.\r\n", host->card_capacity);
|
||
SDHC_WARN_PRINTF("SD card max block num %d\r\n", host->card_max_blk_num);
|
||
sd_dwCap = host->card_capacity;
|
||
|
||
return 0;
|
||
}
|
||
|
||
uint32 select_voltage(struct sdh_device *host, uint32 ocr)
|
||
{
|
||
int bit;
|
||
//extern int ffs32_lsb(uint32 value);
|
||
|
||
ocr &= host->valid_ocr;
|
||
|
||
bit = 15;//ffs32_lsb(ocr);
|
||
if (bit)
|
||
{
|
||
bit -= 1;
|
||
|
||
ocr &= 3 << bit;
|
||
|
||
host->io_cfg.vdd = bit;
|
||
//mmcsd_set_iocfg(host);
|
||
if(((const struct sdhc_hal_ops *)host->dev.ops)->iocfg)
|
||
((const struct sdhc_hal_ops *)host->dev.ops)->iocfg(host,&host->io_cfg);
|
||
}
|
||
else
|
||
{
|
||
SDHC_ERR_PRINTF("host doesn't support card's voltages!");
|
||
ocr = 0;
|
||
}
|
||
|
||
return ocr;
|
||
}
|
||
|
||
uint32 sd_power_up(struct sdh_device *host,uint8 bus_w)
|
||
{
|
||
int bit = __rt_fls(host->valid_ocr) - 1;
|
||
|
||
host->io_cfg.vdd = bit;
|
||
if (controller_is_spi(host))
|
||
{
|
||
host->io_cfg.chip_select = MMCSD_CS_HIGH;
|
||
host->io_cfg.bus_mode = MMCSD_BUSMODE_PUSHPULL;
|
||
}
|
||
else
|
||
{
|
||
host->io_cfg.chip_select = MMCSD_CS_IGNORE;
|
||
host->io_cfg.bus_mode = MMCSD_BUSMODE_OPENDRAIN;
|
||
}
|
||
host->io_cfg.power_mode = MMCSD_POWER_UP;
|
||
if(bus_w == MMCSD_BUSWIDTH_4)
|
||
host->io_cfg.bus_width = MMCSD_BUS_WIDTH_4;
|
||
else
|
||
host->io_cfg.bus_width = MMCSD_BUS_WIDTH_1;
|
||
|
||
host->io_cfg.clock = 400000;
|
||
|
||
if(((const struct sdhc_hal_ops *)host->dev.ops)->iocfg)
|
||
((const struct sdhc_hal_ops *)host->dev.ops)->iocfg(host,&host->io_cfg);
|
||
|
||
|
||
/*
|
||
* This delay should be sufficient to allow the power supply
|
||
* to reach the minimum voltage.
|
||
*/
|
||
os_sleep_ms(10);
|
||
|
||
host->io_cfg.clock = host->freq_min;
|
||
host->io_cfg.power_mode = MMCSD_POWER_ON;
|
||
if(((const struct sdhc_hal_ops *)host->dev.ops)->iocfg)
|
||
((const struct sdhc_hal_ops *)host->dev.ops)->iocfg(host,&host->io_cfg);
|
||
|
||
|
||
/*
|
||
* This delay must be at least 74 clock sizes, or 1 ms, or the
|
||
* time required to reach a stable voltage.
|
||
*/
|
||
os_sleep_ms(10);
|
||
return 0;
|
||
}
|
||
|
||
void sd_set_clk(struct sdh_device * host,uint32 clk)
|
||
{
|
||
host->io_cfg.clock = clk;
|
||
host->io_cfg.ioctl_type = LL_SDHC_IOCTRL_SET_CLOCK;
|
||
((const struct sdhc_hal_ops *)host->dev.ops)->iocfg(host,&host->io_cfg);
|
||
}
|
||
|
||
void sd_set_bus_width(struct sdh_device * host,uint32 width)
|
||
{
|
||
host->io_cfg.bus_width = width;
|
||
host->io_cfg.ioctl_type = LL_SDHC_IOCTRL_SET_BUS_WIDTH;
|
||
((const struct sdhc_hal_ops *)host->dev.ops)->iocfg(host,&host->io_cfg);
|
||
}
|
||
|
||
#if (defined (TXW81X) || defined (TXW82X))
|
||
void sd_set_sample(struct sdh_device *host, TYPE_LL_SDHC_SMP_CFG type, uint8 cmd_cmp, uint8 dat_cmp)
|
||
{
|
||
host->io_cfg.smp_type = type;
|
||
host->io_cfg.cmd_crc_sample = cmd_cmp;
|
||
host->io_cfg.dat_crc_sample = dat_cmp;
|
||
host->io_cfg.ioctl_type = LL_SDHC_IOCTRL_SET_SMP;
|
||
((const struct sdhc_hal_ops *)host->dev.ops)->iocfg(host, &host->io_cfg);
|
||
}
|
||
|
||
void sd_delay_config(struct sdh_device *host, TYPE_LL_SDHC_DELAY_SYSCLK dly_cfg, uint8 chain)
|
||
{
|
||
if (dly_cfg == LL_SDHC_DLY_NONE)
|
||
{
|
||
host->io_cfg.delay_flag = 0;
|
||
}else{
|
||
host->io_cfg.delay_flag = 1;
|
||
host->io_cfg.delay_type = ((chain == 0) && (dly_cfg == LL_SDHC_DLY_CHAIN)) ? (LL_SDHC_DLY_NONE) : (dly_cfg);
|
||
host->io_cfg.delay_chain_cnt = chain;
|
||
}
|
||
host->io_cfg.ioctl_type = LL_SDHC_IOCTRL_SET_DELAY_TYPE;
|
||
((const struct sdhc_hal_ops *)host->dev.ops)->iocfg(host, &host->io_cfg);
|
||
}
|
||
|
||
void sd_dat_of_stop_clk_cfg(struct sdh_device *host, uint8 flag)
|
||
{
|
||
host->io_cfg.dat_overflow_stop_flag = flag;
|
||
host->io_cfg.ioctl_type = LL_SDHC_IOCTRL_SET_DAT_OF_STOP_CLK;
|
||
((const struct sdhc_hal_ops *)host->dev.ops)->iocfg(host, &host->io_cfg);
|
||
}
|
||
#endif
|
||
|
||
uint32 send_idle(struct sdh_device * host)
|
||
{
|
||
uint32 ret;
|
||
struct rt_mmcsd_cmd cmd;
|
||
memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
|
||
|
||
cmd.cmd_code = GO_IDLE_STATE;
|
||
cmd.arg = 0;
|
||
cmd.flags = RESP_SPI_R1 | RESP_NONE | CMD_BC;
|
||
|
||
if(((const struct sdhc_hal_ops *)host->dev.ops)->cmd)
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->cmd(host,&cmd);
|
||
else{
|
||
SDHC_ERR_PRINTF("no cmd action register\r\n");
|
||
return 0;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
uint32 send_all_get_cid(struct sdh_device * host,uint32 *cid)
|
||
{
|
||
uint32 ret;
|
||
struct rt_mmcsd_cmd cmd;
|
||
|
||
memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
|
||
|
||
cmd.cmd_code = ALL_SEND_CID;
|
||
cmd.arg = 0;
|
||
cmd.flags = RESP_R2 | CMD_BCR;
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->cmd(host,&cmd);
|
||
|
||
if(ret==0)
|
||
memcpy(cid, cmd.resp, sizeof(uint32) * 4);
|
||
|
||
return ret;
|
||
}
|
||
|
||
uint32 send_get_card_addr(struct sdh_device * host,uint32 *rca)
|
||
{
|
||
uint32 ret;
|
||
struct rt_mmcsd_cmd cmd;
|
||
memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
|
||
cmd.cmd_code = SD_SEND_RELATIVE_ADDR;
|
||
cmd.arg = 0;
|
||
cmd.flags = RESP_R6 | CMD_BCR;
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->cmd(host,&cmd);
|
||
|
||
*rca = cmd.resp[0] >> 16;
|
||
return 0;
|
||
}
|
||
|
||
int32 sd_get_card_status(struct sdh_device * host, uint32 *status){
|
||
struct rt_mmcsd_cmd cmd;
|
||
int ret = RET_OK;
|
||
|
||
memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
|
||
cmd.cmd_code = SEND_STATUS;
|
||
cmd.arg = host->rca << 16;
|
||
cmd.flags = RESP_R1 | CMD_AC;
|
||
if(((const struct sdhc_hal_ops *)host->dev.ops)->cmd)
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->cmd(host,&cmd);
|
||
|
||
*status = cmd.resp[0];
|
||
return ret;
|
||
}
|
||
|
||
uint32 send_card_status(struct sdh_device * host){
|
||
int ret = RET_OK;
|
||
uint32 status = 0;
|
||
|
||
sd_get_card_status(host, &status);
|
||
|
||
status = (status >> 9) & 0xf;
|
||
if (status != MMCSD_CARD_STATUS_TRAN)
|
||
{
|
||
// SDHC_WARN_PRINTF("card status : %d\r\n", status);
|
||
return RET_ERR;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
uint32 send_select_card(struct sdh_device * host)
|
||
{
|
||
struct rt_mmcsd_cmd cmd;
|
||
int ret = 0;
|
||
memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
|
||
|
||
cmd.cmd_code = SELECT_CARD;
|
||
|
||
if (host->rca)
|
||
{
|
||
cmd.arg = host->rca << 16;
|
||
cmd.flags = RESP_R1 | CMD_AC;
|
||
}
|
||
else
|
||
{
|
||
cmd.arg = 0;
|
||
cmd.flags = RESP_NONE | CMD_AC;
|
||
}
|
||
|
||
if(((const struct sdhc_hal_ops *)host->dev.ops)->cmd)
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->cmd(host,&cmd);
|
||
|
||
return ret;
|
||
}
|
||
|
||
uint32 send_if_cond(struct sdh_device * host,uint32 ocr)
|
||
{
|
||
struct rt_mmcsd_cmd cmd;
|
||
int ret = 0;
|
||
uint8 pattern;
|
||
memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
|
||
|
||
cmd.cmd_code = SD_SEND_IF_COND;
|
||
cmd.arg = ((ocr & 0xFF8000) != 0) << 8 | 0xAA;
|
||
cmd.flags = RESP_SPI_R7 | RESP_R7 | CMD_BCR;
|
||
|
||
if(((const struct sdhc_hal_ops *)host->dev.ops)->cmd)
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->cmd(host,&cmd);
|
||
|
||
//if (controller_is_spi(host))
|
||
// pattern = cmd.resp[1] & 0xFF;
|
||
//else
|
||
pattern = cmd.resp[0] & 0xFF;
|
||
|
||
if (pattern != 0xAA)
|
||
return -EINVAL;
|
||
|
||
return ret;
|
||
|
||
}
|
||
|
||
uint32 send_get_csd(struct sdh_device * host,uint32 *csd)
|
||
{
|
||
int ret;
|
||
struct rt_mmcsd_cmd cmd;
|
||
memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
|
||
|
||
cmd.cmd_code = SEND_CSD;
|
||
cmd.arg = host->rca << 16;
|
||
cmd.flags = RESP_R2 | CMD_AC;
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->cmd(host,&cmd);
|
||
|
||
memcpy(csd, cmd.resp, sizeof(uint32) * 4);
|
||
return ret;
|
||
}
|
||
|
||
|
||
uint32 send_app_cmd(struct sdh_device *host,uint32 rca)
|
||
{
|
||
struct rt_mmcsd_cmd cmd = {0};
|
||
int ret = 0;
|
||
|
||
cmd.cmd_code = APP_CMD;
|
||
if(rca){
|
||
cmd.arg = rca << 16;
|
||
cmd.flags = RESP_R1 | CMD_AC;
|
||
}
|
||
else
|
||
{
|
||
cmd.arg = 0;
|
||
cmd.flags = RESP_R1 | CMD_BCR;
|
||
}
|
||
if(((const struct sdhc_hal_ops *)host->dev.ops)->cmd)
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->cmd(host,&cmd);
|
||
return ret;
|
||
}
|
||
|
||
uint32 sd_app_set_bus_width(struct sdh_device *host,int32_t width)
|
||
{
|
||
int ret = 0;
|
||
struct rt_mmcsd_cmd cmd;
|
||
|
||
send_app_cmd(host,host->rca);
|
||
|
||
|
||
memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
|
||
|
||
cmd.cmd_code = SD_APP_SET_BUS_WIDTH;
|
||
cmd.flags = RESP_R1 | CMD_AC;
|
||
|
||
switch (width)
|
||
{
|
||
case MMCSD_BUS_WIDTH_1:
|
||
cmd.arg = MMCSD_BUS_WIDTH_1;
|
||
break;
|
||
case MMCSD_BUS_WIDTH_4:
|
||
cmd.arg = MMCSD_BUS_WIDTH_4;
|
||
break;
|
||
default:
|
||
return -EINVAL;
|
||
}
|
||
|
||
if(((const struct sdhc_hal_ops *)host->dev.ops)->cmd)
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->cmd(host,&cmd);
|
||
|
||
return ret;
|
||
}
|
||
|
||
uint32 send_get_scr(struct sdh_device *host,uint32* scr)
|
||
{
|
||
struct rt_mmcsd_cmd cmd;
|
||
int ret;
|
||
|
||
if(host->flags & MMCSD_BUSWIDTH_4)
|
||
sd_set_bus_width(host, MMCSD_BUS_WIDTH_1);
|
||
|
||
host->data.blksize = 8;
|
||
host->data.blks = 1;
|
||
host->data.err = 0;
|
||
if(((const struct sdhc_hal_ops *)host->dev.ops)->read)
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->read(host,(uint8*)scr);
|
||
|
||
send_app_cmd(host,host->rca);
|
||
memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
|
||
cmd.cmd_code = SD_APP_SEND_SCR;
|
||
cmd.arg = 0;
|
||
cmd.flags = RESP_SPI_R1 | RESP_R1 | CMD_ADTC;
|
||
if(((const struct sdhc_hal_ops *)host->dev.ops)->cmd)
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->cmd(host,&cmd);
|
||
|
||
if (((const struct sdhc_hal_ops *)host->dev.ops)->complete)
|
||
{
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->complete(host);
|
||
if (ret)
|
||
return 0;
|
||
}
|
||
|
||
if(host->data.err != 0)
|
||
return 0;
|
||
|
||
scr[0] = be32_to_cpu(scr[0]);
|
||
scr[1] = be32_to_cpu(scr[1]);
|
||
|
||
SDHC_WARN_PRINTF("scr:%x %x\r\n",scr[0],scr[1]);
|
||
return 1;
|
||
}
|
||
|
||
int32 sd_cmd_stop(struct sdh_device * host)
|
||
{
|
||
int ret = RET_OK;
|
||
|
||
if (!(((const struct sdhc_hal_ops *)host->dev.ops)->cmd)) {
|
||
return RET_ERR;
|
||
}
|
||
|
||
struct rt_mmcsd_cmd cmd;
|
||
memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
|
||
cmd.cmd_code = STOP_TRANSMISSION;
|
||
cmd.arg = 0;
|
||
cmd.flags = RESP_SPI_R1B | RESP_R1B | CMD_AC;
|
||
for (int i = 0; i < 2; i++) {
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->cmd (host, &cmd);
|
||
if (!ret) {
|
||
return RET_OK;
|
||
}
|
||
}
|
||
|
||
return RET_ERR;
|
||
}
|
||
|
||
uint32 sd_tran_stop(struct sdh_device * host)
|
||
{
|
||
int ret = RET_OK;
|
||
|
||
// os_printf("%s %d addr : %d\r\n", __func__, __LINE__, __builtin_return_address(0));
|
||
if ((host->sd_stop)) {
|
||
sd_cmd_stop(host);
|
||
}
|
||
|
||
uint32 sd_status = 0;
|
||
for (int i = 0; i < 5; i++) {
|
||
ret = sd_get_card_status(host, &sd_status);
|
||
if (RET_OK == ret) {
|
||
if (sd_status & 0xFFFF0000) {
|
||
/* sd err */
|
||
os_printf(KERN_ERR"sd-sta:%x\r\n", sd_status);
|
||
}
|
||
sd_status = (sd_status >> 9) & 0xF;
|
||
if (sd_status == MMCSD_CARD_STATUS_TRAN) {
|
||
host->sd_opt = SD_IDLE;
|
||
host->sd_stop = 0;
|
||
return RET_OK;
|
||
} else if ((sd_status == MMCSD_CARD_STATUS_STBY) || (sd_status == MMCSD_CARD_STATUS_DIS)) {
|
||
/* need app reselect card */
|
||
send_select_card(host);
|
||
} else if (sd_status > MMCSD_CARD_STATUS_TRAN) {
|
||
sd_cmd_stop(host);
|
||
} else {
|
||
/* card not init ok，kick SD_OFF */
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
host->sd_opt = SD_OFF;
|
||
return RET_ERR;
|
||
}
|
||
|
||
//给外部接口专门用的停止命令,现在暂时是给文件系统
|
||
uint32 fatfs_sd_tran_stop(struct sdh_device * host)
|
||
{
|
||
int ret;
|
||
os_mutex_lock(&host->lock,osWaitForever);
|
||
ret = sd_tran_stop(host);
|
||
os_mutex_unlock(&host->lock);
|
||
return ret;
|
||
|
||
}
|
||
|
||
int sd_multiple_write(struct sdh_device * host,uint32 lba,uint32 len,uint8 *buf)
|
||
{
|
||
int ret;
|
||
int send_cmd = 1;
|
||
uint32 curr_lba = lba;
|
||
uint32 backup_lba = host->new_lba;
|
||
uint32 block_num = len/SECTOR_SIZE;
|
||
struct rt_mmcsd_cmd cmd;
|
||
uint8 retry_cnt = 0;
|
||
uint8 curr_index = 0;
|
||
uint8 retry_sample_cnt = 0;
|
||
uint8 sample_point_bak = 0;
|
||
uint8 *kick_buf = buf;
|
||
os_mutex_lock(&host->lock,osWaitForever);
|
||
|
||
__retry:
|
||
if(((curr_lba != host->new_lba)||(host->sd_opt != SD_M_W))&& host->sd_stop)
|
||
{
|
||
ret = sd_tran_stop(host);
|
||
if (ret) goto __err;
|
||
host->new_lba = curr_lba;
|
||
send_cmd = 1;
|
||
} else if ((host->sd_opt == SD_IDLE) || (!host->sd_stop)){
|
||
send_cmd = 1;
|
||
if (curr_lba != host->new_lba)
|
||
{
|
||
host->new_lba = curr_lba;
|
||
}
|
||
} else {
|
||
send_cmd = 0;
|
||
}
|
||
|
||
if ((host->new_lba + block_num) > host->card_max_blk_num)
|
||
{
|
||
SDHC_ERR_PRINTF("%s operation lba %d size %d max : %d err\r\n", __func__, host->new_lba, block_num, host->card_max_blk_num);
|
||
host->new_lba = backup_lba;
|
||
ret = RET_ERR;
|
||
goto __err;
|
||
}
|
||
|
||
if (send_cmd) host->sd_stop = (host->single_support) ? (block_num > 1) : (1);//;
|
||
host->new_lba = host->new_lba + block_num;
|
||
host->sd_opt = SD_M_W;
|
||
///////////////////////////////////////////////////////
|
||
memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
|
||
cmd.cmd_code = (host->single_support) ? ((block_num > 1) ? (WRITE_MULTIPLE_BLOCK) : (WRITE_BLOCK)) : (WRITE_MULTIPLE_BLOCK);
|
||
|
||
cmd.arg = curr_lba;
|
||
if (!(host->cardflags & CARD_FLAG_SDHC))
|
||
{
|
||
cmd.arg <<= 9;
|
||
}
|
||
cmd.flags = RESP_SPI_R1 | RESP_R1 | CMD_ADTC;
|
||
if((((const struct sdhc_hal_ops *)host->dev.ops)) && send_cmd){
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->cmd(host,&cmd);
|
||
if(ret){
|
||
sd_tran_stop(host);
|
||
ret = -1;
|
||
goto __err;
|
||
}
|
||
}
|
||
|
||
#if defined(TXW82X) || defined(TXW81X)
|
||
if (host->io_cfg.self_adaption_flag != MMCSD_SMP_DIS)
|
||
{
|
||
sd_delay_config(host, LL_SDHC_DLY_CHAIN, host->sd_write_dly_chain);
|
||
sd_set_sample(host, LL_SDHC_DAT_SMP_CFG_EN, 0, host->sd_write_sample);
|
||
}
|
||
#endif
|
||
|
||
///////////////////////////////////////////////////////
|
||
host->data.blksize = SECTOR_SIZE;
|
||
host->data.blks = block_num;
|
||
host->data.err = 0;
|
||
if((!retry_cnt) && ((uint32)kick_buf >= PSRAM_BASE) ){
|
||
sys_dcache_clean_range_unaligned((void *)kick_buf, len);
|
||
}
|
||
|
||
if(((const struct sdhc_hal_ops *)host->dev.ops)->write)
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->write(host,kick_buf);
|
||
|
||
if (((const struct sdhc_hal_ops *)host->dev.ops)->complete)
|
||
{
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->complete(host);
|
||
#if defined(TXW82X)
|
||
if ((host->sd_write_retry_flag == 0) && (ret == MMCSD_CMP_DATERR) && (host->io_cfg.self_adaption_flag != MMCSD_SMP_EN))
|
||
{
|
||
if (host->sd_write_retry == LL_SDHC_RETRY_SELECT_POINT) {
|
||
/* goto retry */
|
||
host->sd_write_retry = LL_SDHC_RETRY_DEFAULT;
|
||
/* find current pos & change sample point to next */
|
||
for (curr_index = 0; curr_index < host->sd_write_sample_num; curr_index++) {
|
||
if ((host->sd_write_sample_value[curr_index] == host->sd_write_sample)) {
|
||
if (!retry_sample_cnt) {
|
||
sample_point_bak = host->sd_write_sample;
|
||
}
|
||
curr_index++;
|
||
if (curr_index < host->sd_write_sample_num) {
|
||
host->sd_write_sample = host->sd_write_sample_value[curr_index];
|
||
} else {
|
||
host->sd_write_sample = host->sd_write_sample_value[0];
|
||
}
|
||
retry_sample_cnt++;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (retry_sample_cnt >= host->sd_write_sample_num) {
|
||
host->sd_write_sample = sample_point_bak;
|
||
host->sd_write_retry = LL_SDHC_RETRY_ERR;
|
||
/* disable retry */
|
||
// host->sd_write_retry_flag = 1;
|
||
SDHC_ERR_PRINTF("sd err: sel all wr point!\r\n");
|
||
} else {
|
||
SDHC_WARN_PRINTF("sd sel wr point : %d\r\n", host->sd_write_sample);
|
||
}
|
||
}
|
||
|
||
if (host->sd_write_retry != LL_SDHC_RETRY_ERR) {
|
||
retry_cnt++;
|
||
/* retry 3 times @ every sample point */
|
||
if (0 == (retry_cnt % 3)) {
|
||
host->sd_write_retry = (host->sd_write_retry == LL_SDHC_RETRY_DEFAULT) ? LL_SDHC_RETRY_SELECT_POINT : LL_SDHC_RETRY_DEFAULT;
|
||
}
|
||
|
||
curr_lba = host->new_lba - host->data.blks;
|
||
block_num = host->data.blks;
|
||
kick_buf = kick_buf + (block_num - host->data.blks) * SECTOR_SIZE;
|
||
goto __retry;
|
||
}
|
||
}
|
||
|
||
if (ret == MMCSD_NO_ERR) {
|
||
host->sd_write_retry = LL_SDHC_RETRY_DEFAULT;
|
||
}
|
||
#endif
|
||
}
|
||
|
||
if (ret) {
|
||
sd_tran_stop(host);
|
||
}
|
||
__err:
|
||
os_mutex_unlock(&host->lock);
|
||
return ret;
|
||
}
|
||
|
||
int sd_multiple_read(struct sdh_device * host,uint32 lba, uint32 len, uint8* buf)
|
||
{
|
||
struct rt_mmcsd_cmd cmd;
|
||
int ret = 0;
|
||
int send_cmd = 1;
|
||
uint32 curr_lba = lba;
|
||
uint32 backup_lba = host->new_lba;
|
||
uint32 block_num = len/SECTOR_SIZE;
|
||
uint8 retry_cnt = 0;
|
||
uint8 curr_index = 0;
|
||
uint8 retry_sample_cnt = 0;
|
||
uint8 sample_point_bak = 0;
|
||
uint8 *kick_buf = buf;
|
||
// uint8 data_rev = 0;
|
||
// uint8 *s = NULL;
|
||
|
||
os_mutex_lock(&host->lock,osWaitForever);
|
||
|
||
__retry:
|
||
if(((curr_lba != host->new_lba)||(host->sd_opt != SD_M_R)) && host->sd_stop)
|
||
{
|
||
ret = sd_tran_stop(host);
|
||
if (ret) goto __err;
|
||
host->new_lba = curr_lba;
|
||
send_cmd = 1;
|
||
} else if ((host->sd_opt == SD_IDLE) || (!host->sd_stop)){
|
||
send_cmd = 1;
|
||
if (curr_lba != host->new_lba) host->new_lba = curr_lba;
|
||
} else {
|
||
send_cmd = 0;
|
||
}
|
||
|
||
if ((host->new_lba + block_num) > host->card_max_blk_num)
|
||
{
|
||
SDHC_ERR_PRINTF(KERN_ERR"%s operation lba %d size %d max : %d err\r\n", __func__, host->new_lba, block_num, host->card_max_blk_num);
|
||
host->new_lba = backup_lba;
|
||
ret = RET_ERR;
|
||
goto __err;
|
||
}
|
||
|
||
if (send_cmd) host->sd_stop = (host->single_support) ? (block_num > 1) : (1);
|
||
host->new_lba = host->new_lba + block_num;
|
||
host->sd_opt = SD_M_R;
|
||
|
||
///////////////////////////////////////////////////////
|
||
host->data.blksize = SECTOR_SIZE;
|
||
host->data.blks = block_num;
|
||
host->data.err = 0;
|
||
|
||
#if defined(TXW82X) || defined(TXW81X)
|
||
if (host->io_cfg.self_adaption_flag != MMCSD_SMP_DIS)
|
||
{
|
||
sd_delay_config(host, LL_SDHC_DLY_CHAIN, host->sd_read_dly_chain);
|
||
sd_set_sample(host, LL_SDHC_DAT_SMP_CFG_EN, 0, host->sd_read_sample);
|
||
}
|
||
#endif
|
||
|
||
if(!retry_cnt && ((uint32)kick_buf >= PSRAM_BASE) ) {
|
||
sys_dcache_invalid_range_unaligned((void *)kick_buf, len);
|
||
}
|
||
|
||
|
||
if(((const struct sdhc_hal_ops *)host->dev.ops)->read != NULL){
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->read(host,kick_buf);
|
||
}
|
||
|
||
///////////////////////////////////////////////////////
|
||
memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
|
||
cmd.cmd_code = (host->single_support) ? ((block_num > 1) ? (READ_MULTIPLE_BLOCK) : (READ_SINGLE_BLOCK)) : (READ_MULTIPLE_BLOCK);
|
||
cmd.arg = curr_lba;
|
||
if (!(host->cardflags & CARD_FLAG_SDHC))
|
||
{
|
||
cmd.arg <<= 9;
|
||
}
|
||
cmd.flags = RESP_SPI_R1 | RESP_R1 | CMD_ADTC;
|
||
if((((const struct sdhc_hal_ops *)host->dev.ops)) && send_cmd){
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->cmd(host,&cmd);
|
||
if(ret){
|
||
sd_tran_stop(host);
|
||
ret = MMCSD_CMD_ERR;
|
||
goto __err;
|
||
}
|
||
}
|
||
|
||
if (((const struct sdhc_hal_ops *)host->dev.ops)->complete != NULL){
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->complete(host);
|
||
#if defined(TXW82X)
|
||
if ((host->sd_read_retry_flag == 0) && (ret == MMCSD_CMP_DATERR) && (host->io_cfg.self_adaption_flag != MMCSD_SMP_EN))
|
||
{
|
||
if (host->sd_read_retry == LL_SDHC_RETRY_SELECT_POINT) {
|
||
/* find current pos & change sample point to next */
|
||
for (curr_index = 0; curr_index < host->sd_read_sample_num; curr_index++) {
|
||
if ((host->sd_read_sample_value[curr_index] == host->sd_read_sample)) {
|
||
if (!retry_sample_cnt) {
|
||
sample_point_bak = host->sd_read_sample;
|
||
}
|
||
curr_index++;
|
||
if (curr_index < host->sd_read_sample_num) {
|
||
host->sd_read_sample = host->sd_read_sample_value[curr_index];
|
||
} else {
|
||
host->sd_read_sample = host->sd_read_sample_value[0];
|
||
}
|
||
retry_sample_cnt++;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (retry_sample_cnt >= host->sd_read_sample_num) {
|
||
host->sd_read_sample = sample_point_bak;
|
||
host->sd_write_retry = LL_SDHC_RETRY_ERR;
|
||
/* disable retry */
|
||
// host->sd_write_retry_flag = 1;
|
||
SDHC_ERR_PRINTF("sd err: sel all rd point!\r\n");
|
||
} else {
|
||
SDHC_WARN_PRINTF("sd sel rd point : %d\r\n", host->sd_read_sample);
|
||
}
|
||
}
|
||
|
||
if (host->sd_read_retry != LL_SDHC_RETRY_ERR) {
|
||
retry_cnt++;
|
||
/* retry 3 times @ every sample point */
|
||
if (0 == (retry_cnt % 3)) {
|
||
host->sd_read_retry = (host->sd_read_retry == LL_SDHC_RETRY_DEFAULT) ? LL_SDHC_RETRY_SELECT_POINT : LL_SDHC_RETRY_DEFAULT;
|
||
}
|
||
|
||
curr_lba = host->new_lba - host->data.blks;
|
||
block_num = host->data.blks;
|
||
kick_buf = kick_buf + (block_num - host->data.blks) * SECTOR_SIZE;
|
||
goto __retry;
|
||
}
|
||
}
|
||
|
||
if((ret == MMCSD_NO_ERR)) {
|
||
host->sd_read_retry = LL_SDHC_RETRY_DEFAULT;
|
||
}
|
||
#endif
|
||
// SDHC_WARN_PRINTF("%s %d status : %d flag : %d\r\n", __func__, __LINE__, host->sd_read_retry, host->sd_read_retry_flag);
|
||
}
|
||
|
||
if (ret) {
|
||
sd_tran_stop(host);
|
||
}
|
||
|
||
__err:
|
||
os_mutex_unlock(&host->lock);
|
||
return ret;
|
||
}
|
||
|
||
|
||
uint32 send_app_op_cond(struct sdh_device *host,
|
||
uint32 ocr,
|
||
uint32 *rocr)
|
||
{
|
||
struct rt_mmcsd_cmd cmd;
|
||
uint32 i;
|
||
int ret;
|
||
memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd));
|
||
cmd.cmd_code = SD_APP_OP_COND;
|
||
cmd.arg = ocr;
|
||
cmd.flags = RESP_SPI_R1 | RESP_R3 | CMD_BCR;
|
||
|
||
for(i = 100;i;i--){
|
||
ret = send_app_cmd(host,0);
|
||
if(ret){
|
||
SDHC_ERR_PRINTF("cmd err\r\n");
|
||
break;
|
||
}
|
||
|
||
// memset(cmd->resp, 0, sizeof(cmd->resp));
|
||
ret = ((const struct sdhc_hal_ops *)host->dev.ops)->cmd(host,&cmd);
|
||
if(ret){
|
||
SDHC_ERR_PRINTF("cmd2 err\r\n");
|
||
break;
|
||
}
|
||
// SDHC_WARN_PRINTF("cmd resp:%x\r\n",cmd.resp[0]);
|
||
if (cmd.resp[0] & CARD_BUSY){
|
||
SDHC_WARN_PRINTF("card busy ok\r\n");
|
||
break;
|
||
}
|
||
os_sleep_ms(10);
|
||
}
|
||
|
||
if(rocr)
|
||
*rocr = cmd.resp[0];
|
||
|
||
if(!(cmd.resp[0] & CARD_BUSY))
|
||
{
|
||
SDHC_ERR_PRINTF("card no busy\r\n");
|
||
return RET_ERR;
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
|
||
void stop_card(){
|
||
sd_tran_stop(sdh_test);
|
||
}
|
||
|
||
uint8 get_sd_status(void) {
|
||
//SDHC_WARN_PRINTF("%s:%d\r\n",__FUNCTION__,sdh_test->sd_opt);
|
||
return sdh_test->sd_opt;
|
||
}
|
||
uint8 get_sd_status2(void) {
|
||
return sdh_test->sd_opt == SD_OFF;
|
||
}
|
||
|
||
int sd_scsi_read2(uint32 lba,uint8* buf) {
|
||
return sd_multiple_read(sdh_test,lba,SECTOR_SIZE ,buf);
|
||
}
|
||
|
||
int sd_scsi_write2(uint32 lba,uint8* buf) {
|
||
return sd_multiple_write(sdh_test,lba,SECTOR_SIZE ,buf);
|
||
}
|
||
|
||
int usb_sd_scsi_read(uint32 lba, uint32 count, uint8* buf) {
|
||
return sd_multiple_read(sdh_test,lba,SECTOR_SIZE*count,buf);
|
||
}
|
||
|
||
int usb_sd_scsi_write(uint32 lba, uint32 count, uint8* buf) {
|
||
return sd_multiple_write(sdh_test,lba,SECTOR_SIZE*count,buf);
|
||
}
|
||
|
||
|
||
//返回sd卡的扇区大小,现在是固定的
|
||
uint32_t get_sd_sector_size()
|
||
{
|
||
return 512;
|
||
}
|
||
|
||
uint32 get_sd_cap()
|
||
{
|
||
return sd_dwCap * 2;//Blocks
|
||
}
|
||
|
||
#if (defined (TXW81X) || defined (TXW82X))
|
||
uint16 sd_spi_mode_baud_cfg(uint32 clk)
|
||
{
|
||
return (((peripheral_clock_get(HG_APB0_PT_SPI0) / 2 + clk - 1) / clk) - 1);
|
||
}
|
||
void sd_sample_print(uint8 *buf, uint8 cnt, char *str, uint8 print_en)
|
||
{
|
||
if (print_en)
|
||
{
|
||
SDHC_WARN_PRINTF("%s\r\n", str);
|
||
for (int z = 0; z < cnt; z++)
|
||
{
|
||
_os_printf("%d, ", buf[z]);
|
||
}
|
||
_os_printf("\r\n");
|
||
}
|
||
}
|
||
|
||
uint32 sd_cmd_sample_retry(struct sdh_device *host, uint8 sample_max)
|
||
{
|
||
uint32 result = RET_OK;
|
||
uint8 buf_index = 0;
|
||
uint32 ret = 0;
|
||
uint32 last_ret = MMCSD_INT_VLE;
|
||
for (int i = 0; i < sample_max; i++)
|
||
{
|
||
(host->sd_mode_type) ? (host->spi_delay_cycle = i) : (sd_set_sample(host, LL_SDHC_CMD_SMP_CFG_EN, i, 0));//
|
||
ret = send_card_status(host);
|
||
if (!ret)
|
||
{
|
||
host->sd_cmd_sample_value[buf_index++] = i;
|
||
} else if (!last_ret && (last_ret != ret) && buf_index) {
|
||
break;
|
||
}
|
||
last_ret = ret;
|
||
}
|
||
|
||
if (buf_index)
|
||
{
|
||
sd_sample_print(host->sd_cmd_sample_value, buf_index, "cmd", SD_SAMPLE_VALUE_PRINT);
|
||
host->sd_cmd_sample_num = buf_index;
|
||
host->sd_cmd_sample = host->sd_cmd_sample_value[(buf_index)>>1];
|
||
SDHC_WARN_PRINTF("%s %d sd_cmd_sample : %d\r\n", __func__, __LINE__, host->sd_cmd_sample);
|
||
(host->sd_mode_type) ? (host->spi_delay_cycle = host->sd_cmd_sample) : (sd_set_sample(host, LL_SDHC_CMD_SMP_CFG_EN, host->sd_cmd_sample, 0));
|
||
} else {
|
||
SDHC_ERR_PRINTF("sd sample point num : %d err\r\n", buf_index);
|
||
result = RET_ERR;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
uint32 sd_read_dat_sample_retry(struct sdh_device *host, uint8 sample_max, uint8 *p_read, uint8 *p_write)
|
||
{
|
||
uint32 result = RET_OK;
|
||
uint8 buf_index = 0;
|
||
uint8 sel_index = 0;
|
||
uint32 ret = 0;
|
||
uint32 last_ret = MMCSD_INT_VLE;
|
||
uint32 write_block = 0;
|
||
|
||
for (int i = 0; i < sample_max; i++)
|
||
{
|
||
host->sd_read_sample = (i + sample_max - 2) % sample_max;
|
||
ret = sd_multiple_read(host, 0, SECTOR_SIZE, p_read);
|
||
if (ret == MMCSD_NO_ERR)
|
||
{
|
||
host->sd_read_sample_value[buf_index++] = host->sd_read_sample;
|
||
} else if (ret == MMCSD_CMD_ERR) {
|
||
buf_index = 0;
|
||
result = RET_ERR;
|
||
break;
|
||
} else if (!last_ret && (last_ret != ret) && buf_index) {
|
||
break;
|
||
}
|
||
last_ret = ret;
|
||
}
|
||
|
||
if (buf_index)
|
||
{
|
||
write_block = host->card_max_blk_num - sample_max - 1;
|
||
host->sd_read_sample_num = buf_index;
|
||
sel_index = (buf_index - 1) >> 1;
|
||
host->sd_read_sample = (host->sd_read_sample_value[sel_index] == 0) ? (host->sd_read_sample_value[(sel_index + buf_index - 1) % buf_index]) : (host->sd_read_sample_value[sel_index]);
|
||
ret = sd_multiple_read(host, write_block, SECTOR_SIZE*sample_max, (void *)p_write);
|
||
if (!ret)
|
||
{
|
||
sd_sample_print(host->sd_read_sample_value, buf_index, "read", SD_SAMPLE_VALUE_PRINT);
|
||
SDHC_WARN_PRINTF("%s %d sd_read_sample : %d\r\n", __func__, __LINE__, host->sd_read_sample);
|
||
} else {
|
||
result = RET_ERR;
|
||
}
|
||
} else {
|
||
result = RET_ERR;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
uint32 sd_write_dat_sample_retry(struct sdh_device *host, uint8 sample_max, uint8 *p_write)
|
||
{
|
||
uint32 result = RET_OK;
|
||
uint8 buf_index = 0;
|
||
uint32 ret = 0;
|
||
uint32 last_ret = MMCSD_INT_VLE;
|
||
uint32 write_block = host->card_max_blk_num - sample_max - 1;
|
||
|
||
for (int i = 0; i < sample_max; i++)
|
||
{
|
||
host->sd_write_sample = i;
|
||
ret = sd_multiple_write(host, write_block+i, SECTOR_SIZE, (void *)&p_write[SECTOR_SIZE*i]);
|
||
if (!ret)
|
||
{
|
||
host->sd_write_sample_value[buf_index++] = i;
|
||
} else if (ret == MMCSD_CMD_ERR) {
|
||
buf_index = 0;
|
||
break;
|
||
} else if (!last_ret && (last_ret != ret) && buf_index) {
|
||
break;
|
||
}
|
||
last_ret = ret;
|
||
}
|
||
|
||
if (buf_index)
|
||
{
|
||
sd_sample_print(host->sd_write_sample_value, buf_index, "write\r\n", SD_SAMPLE_VALUE_PRINT);
|
||
host->sd_write_sample = host->sd_write_sample_value[(buf_index - 1)>>1];
|
||
host->sd_write_sample_num = buf_index;
|
||
} else {
|
||
result = RET_ERR;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
uint32 sd_sample_point_cfg(struct sdh_device *host, uint32 clk)
|
||
{
|
||
uint32 ret_val = RET_OK;
|
||
uint32 ret = 0;
|
||
uint8 flag = 0;
|
||
uint8 sample_max = 0;//host->io_cfg.crc_sample_max;
|
||
uint8 *test_data = NULL;//os_malloc(SECTOR_SIZE);
|
||
uint8 *write_data = NULL;//os_malloc(SECTOR_SIZE * sample_max);
|
||
uint32 src_clk = host->io_cfg.clock;
|
||
|
||
if ((host->card_type != CARD_TYPE_SD))
|
||
{
|
||
ret_val = RET_ERR;
|
||
goto __err;
|
||
}
|
||
|
||
sd_set_clk(host, clk);
|
||
sample_max = host->io_cfg.crc_sample_max;
|
||
#if defined(TXW82X)
|
||
host->spi_mode_baud = sd_spi_mode_baud_cfg(clk);
|
||
if(!host->sd_read_sample_value ) host->sd_read_sample_value = SDHC_HEAP_MALLOC(sample_max);
|
||
if(!host->sd_write_sample_value) host->sd_write_sample_value = SDHC_HEAP_MALLOC(sample_max);
|
||
if(!host->sd_cmd_sample_value ) host->sd_cmd_sample_value = SDHC_HEAP_MALLOC(sample_max);
|
||
os_printf("read : %08x write : %08x cmd : %08x\r\n", (uint32)host->sd_read_sample_value , (uint32)host->sd_write_sample_value, (uint32)host->sd_cmd_sample_value );
|
||
#endif
|
||
test_data = os_malloc(SECTOR_SIZE);
|
||
write_data = os_malloc(SECTOR_SIZE * sample_max);
|
||
|
||
if ((test_data == NULL) || (write_data == NULL)|| (!host->sd_read_sample_value) || (!host->sd_write_sample_value) || (!host->sd_cmd_sample_value))
|
||
{
|
||
os_printf("test_data : %08x write_data : %08x num : %d read : %08x write : %08x cmd : %08x err\r\n", (uint32)test_data, (uint32)write_data, sample_max, (uint32)host->sd_read_sample_value, (uint32)host->sd_write_sample_value, (uint32)host->sd_cmd_sample_value);
|
||
ret_val = RET_ERR;
|
||
sd_set_clk(host, src_clk);
|
||
#if defined(TXW82X)
|
||
host->spi_mode_baud = sd_spi_mode_baud_cfg(src_clk);
|
||
#endif
|
||
goto __err;
|
||
}
|
||
host->sd_write_dly_chain = 0x3;
|
||
host->sd_read_dly_chain = 0x0;
|
||
host->io_cfg.self_adaption_flag = MMCSD_SMP_EN;
|
||
sd_set_sample(host, LL_SDHC_ALL_SMP_CFG_DIS, 0, 0);
|
||
|
||
os_memset(host->sd_read_sample_value , 0xff, sample_max);
|
||
os_memset(host->sd_write_sample_value, 0xff, sample_max);
|
||
os_memset(host->sd_cmd_sample_value , 0xff, sample_max);
|
||
|
||
ret = sd_cmd_sample_retry(host, sample_max);
|
||
if (ret)
|
||
{
|
||
goto __adjust;
|
||
} else {
|
||
flag |= SDHC_SMP_CMD_SUCC;
|
||
}
|
||
|
||
|
||
while (1)
|
||
{
|
||
ret = sd_read_dat_sample_retry(host, sample_max, test_data, write_data);
|
||
if (ret)
|
||
{
|
||
host->sd_read_dly_chain += 2;
|
||
if (host->sd_read_dly_chain > 7) goto __adjust;
|
||
} else {
|
||
flag |= SDHC_SMP_DAT_SUCC;
|
||
break;
|
||
}
|
||
}
|
||
|
||
while(1)
|
||
{
|
||
ret = sd_write_dat_sample_retry(host, sample_max, write_data);
|
||
if (ret)
|
||
{
|
||
host->sd_write_dly_chain += 2;
|
||
if (host->sd_write_dly_chain > 7) goto __adjust;
|
||
} else {
|
||
flag |= SDHC_SMP_WRITE_CRC_SUCC;
|
||
break;
|
||
}
|
||
}
|
||
|
||
__adjust:
|
||
if(flag != SDHC_SMP_ALL_SUCC)
|
||
{
|
||
sd_set_sample(host, LL_SDHC_ALL_SMP_CFG_DIS, 0, 0);
|
||
SDHC_WARN_PRINTF("******** write : %d read : %d cmd : %d read_chain : %d write_chain : %d***********\r\n", host->sd_write_sample, host->sd_read_sample, host->sd_cmd_sample, host->sd_read_dly_chain, host->sd_write_dly_chain);
|
||
ret_val = RET_ERR;
|
||
#if defined(TXW82X)
|
||
if(host->sd_read_sample_value ) SDHC_HEAP_FREE(host->sd_read_sample_value );
|
||
if(host->sd_write_sample_value) SDHC_HEAP_FREE(host->sd_write_sample_value);
|
||
if(host->sd_cmd_sample_value ) SDHC_HEAP_FREE(host->sd_cmd_sample_value );
|
||
#endif
|
||
} else {
|
||
SDHC_WARN_PRINTF("******** write : %d read : %d cmd : %d read_chain : %d write_chain : %d***********\r\n", host->sd_write_sample, host->sd_read_sample, host->sd_cmd_sample, host->sd_read_dly_chain, host->sd_write_dly_chain);
|
||
}
|
||
|
||
__err:
|
||
// sd_tran_stop(host);
|
||
if (test_data ) os_free(test_data );
|
||
if (write_data) os_free(write_data);
|
||
return ret_val;
|
||
}
|
||
#endif
|
||
|
||
/* flags : TYPE_SDHC_INIT_FLAGS */
|
||
uint32 sd_init(struct sdh_device * host, uint32 clk, uint32 flags)
|
||
{
|
||
uint32 ret;
|
||
uint32 resp[4];
|
||
uint32 ocr;
|
||
uint8 bw = 1;
|
||
SDHC_WARN_PRINTF("open_width:%d\r\n",bw);
|
||
|
||
|
||
if(((const struct sdhc_hal_ops *)host->dev.ops)->open)
|
||
((const struct sdhc_hal_ops *)host->dev.ops)->open(host,bw, SD_MODE_TYPE);
|
||
|
||
#if defined (TXW82X)
|
||
host->sd_clk_io = MACRO_PIN(PIN_SDH_CLK);
|
||
#endif
|
||
host->opt_timeout = 2;
|
||
host->cmd12_timeout = 5;
|
||
host->single_support = flags & SDHC_INIT_FLAGS_SINGLE_BLK_RW_EN;
|
||
host->busy_filter_cnt = (flags & SDHC_INIT_FLAGS_BUSY_FILTER_EN) ? 2 : 0;
|
||
|
||
sdhost_io_func_init(host->flags&MMCSD_BUSWIDTH_4);
|
||
SDHC_WARN_PRINTF("host->flags:%x\r\n",host->flags);
|
||
if(bw == 4)
|
||
sd_power_up(host,MMCSD_BUSWIDTH_4);
|
||
else
|
||
sd_power_up(host,0);
|
||
|
||
void __delay_asm(uint32 n);
|
||
ret = send_idle(host);
|
||
if(ret)
|
||
{
|
||
SDHC_ERR_PRINTF("idle cmd err\r\n");
|
||
return RET_ERR;
|
||
}
|
||
delay_us(100);
|
||
ret = send_if_cond(host,host->valid_ocr);
|
||
|
||
ret = send_app_op_cond(host,0x40ff8000,&ocr);
|
||
if(ret){
|
||
SDHC_ERR_PRINTF("init card err\r\n");
|
||
return RET_ERR;
|
||
}
|
||
SDHC_WARN_PRINTF("ocr:%x\r\n",ocr);
|
||
ocr = select_voltage(host,ocr);
|
||
SDHC_WARN_PRINTF("cur_ocr:%x\r\n",ocr);
|
||
|
||
if (!ocr)
|
||
{
|
||
SDHC_ERR_PRINTF("cal ocr error\r\n");
|
||
return RET_ERR;
|
||
}
|
||
|
||
send_idle(host);
|
||
delay_us(100);
|
||
ret = send_if_cond(host,ocr);
|
||
if(ret==0)
|
||
ocr |= 1 << 30;
|
||
|
||
ret = send_app_op_cond(host,ocr,NULL);
|
||
if(ret){
|
||
SDHC_ERR_PRINTF("init card app_op_cond err\r\n");
|
||
return RET_ERR;
|
||
}
|
||
|
||
send_all_get_cid(host,resp);
|
||
host->card_type = CARD_TYPE_SD;
|
||
memcpy(host->resp_cid,resp,sizeof(host->resp_cid));
|
||
send_get_card_addr(host,&host->rca);
|
||
send_get_csd(host,host->resp_csd);
|
||
sd_parse_csd(host);
|
||
send_select_card(host);
|
||
ret = send_get_scr(host,host->resp_scr);
|
||
if (ret == 0)
|
||
{
|
||
SDHC_ERR_PRINTF("get src err\r\n");
|
||
return RET_ERR;
|
||
}
|
||
|
||
sd_parse_scr(host);
|
||
|
||
/*switch bus width*/
|
||
if ((host->flags & MMCSD_BUSWIDTH_4) &&
|
||
(host->scr.sd_bus_widths & SD_SCR_BUS_WIDTH_4))
|
||
{
|
||
ret = sd_app_set_bus_width(host, MMCSD_BUS_WIDTH_4);
|
||
if (ret){
|
||
SDHC_ERR_PRINTF("set bus width 4 err\r\n");
|
||
return RET_ERR;
|
||
}
|
||
sd_set_bus_width(host, MMCSD_BUS_WIDTH_4);
|
||
}
|
||
host->sd_opt = SD_IDLE;
|
||
#if (defined (TXW81X) || defined (TXW82X))
|
||
if ((host->flags & MMCSD_SUP_HIGHSPEED) &&
|
||
(!host->io_cfg.self_adaption_flag) &&
|
||
(host->scr.sd_version) &&
|
||
(clk > 25*1000*1000))
|
||
{
|
||
ret = sd_switch(host);
|
||
if (ret)
|
||
{
|
||
sd_set_clk(host, 24*1000*1000);
|
||
}else{
|
||
SDHC_WARN_PRINTF("********** test SD start ********\r\n");
|
||
ret = sd_sample_point_cfg(host, clk);
|
||
SDHC_WARN_PRINTF("********** test SD finish ********\r\n");
|
||
if (ret)
|
||
{
|
||
SDHC_ERR_PRINTF("set highspeed sampling point err\r\n");
|
||
host->io_cfg.self_adaption_flag = MMCSD_SMP_DIS;
|
||
sd_set_clk(host, 24*1000*1000);
|
||
}
|
||
host->io_cfg.self_adaption_flag = MMCSD_SMP_SUCC;
|
||
}
|
||
}else{
|
||
sd_set_clk(host, 24*1000*1000);
|
||
}
|
||
#else
|
||
sd_set_clk(host, clk);
|
||
#endif
|
||
((struct hgsdh *)host)->opened = 1;
|
||
#if defined(TXW82X)
|
||
host->spi_mode_baud =sd_spi_mode_baud_cfg(host->io_cfg.clock);
|
||
#endif
|
||
return RET_OK;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
extern bool fatfs_register();
|
||
extern void fatfs_unregister();
|
||
void sd_open()
|
||
{
|
||
sdh_test = (struct sdh_device *)dev_get(HG_SDIOHOST_DEVID);
|
||
#if SDH_I2C2_REUSE
|
||
os_sema_init(&sem,1);
|
||
#endif
|
||
}
|
||
|
||
void sdhost_test()
|
||
{
|
||
SDHC_WARN_PRINTF("enter sdhost test\r\n");
|
||
sdh_test = (struct sdh_device *)dev_get(HG_SDIOHOST_DEVID);
|
||
//sdhost_io_func_init();f
|
||
|
||
sd_init(sdh_test, 24*1000*1000, 0);
|
||
|
||
}
|
||
|
||
struct sdhost_hdl
|
||
{
|
||
struct os_work wk;
|
||
struct sdh_device *host;
|
||
uint32_t lba;
|
||
uint8_t opt:3,isregister:1,count:2;
|
||
};
|
||
|
||
static struct sdhost_hdl sdhost_wk = {
|
||
.wk.running=0
|
||
};
|
||
|
||
|
||
|
||
int32 sdh_loop(struct os_work *work)
|
||
{
|
||
struct sdhost_hdl *hdl = (struct sdhost_hdl*)work;
|
||
struct sdh_device *host = hdl->host;
|
||
uint32 sleep_time = 500;
|
||
uint32 ret;
|
||
if(SD_OFF == host->sd_opt || !hdl->isregister)
|
||
{
|
||
SDHC_ERR_PRINTF("sdh no online2\r\n");
|
||
if(get_fat_isready())
|
||
{
|
||
fatfs_unregister();
|
||
hdl->isregister = 0;
|
||
}
|
||
|
||
//判断状态,是否重新挂在文件系统
|
||
fatfs_register();
|
||
if(get_fat_isready())
|
||
{
|
||
hdl->isregister = 1;
|
||
}
|
||
} else {
|
||
ret = os_mutex_lock(&host->lock,0);
|
||
if(ret)
|
||
{
|
||
sleep_time = 1;
|
||
//获取锁失败
|
||
goto sdh_loop_end;
|
||
}
|
||
|
||
if (host->sd_stop && (SD_IDLE != host->sd_opt))
|
||
{
|
||
if((hdl->opt != host->sd_opt)||(hdl->lba != host->new_lba))
|
||
{
|
||
hdl->opt = host->sd_opt;
|
||
hdl->lba = host->new_lba;
|
||
hdl->count = 0;
|
||
} else {
|
||
hdl->count++;
|
||
}
|
||
} else {
|
||
ret = send_card_status(host);
|
||
if(ret != 0)
|
||
{
|
||
host->sd_opt = SD_OFF;
|
||
hdl->count = 0;
|
||
}
|
||
}
|
||
|
||
if(hdl->count >= 2)
|
||
{
|
||
sd_tran_stop(host);
|
||
}
|
||
|
||
os_mutex_unlock(&host->lock);
|
||
}
|
||
sdh_loop_end:
|
||
os_run_work_delay(work, sleep_time);
|
||
return 0;
|
||
}
|
||
|
||
uint32 sdhost_reinit_for_wakeup()
|
||
{
|
||
if(sdhost_wk.wk.init == 0 && sdhost_wk.wk.running == 0)
|
||
{
|
||
sdhost_wk.isregister = 1;
|
||
OS_WORK_INIT(&sdhost_wk.wk, sdh_loop, 0);
|
||
os_run_work_delay(&sdhost_wk.wk, 500);
|
||
}
|
||
}
|
||
|
||
|
||
uint32 sdhost_deinit_for_sleep()
|
||
{
|
||
uint32 err = 0;
|
||
struct sdh_device *sdh = NULL;
|
||
sdh = (struct sdh_device *)dev_get(HG_SDIOHOST_DEVID);
|
||
os_work_cancle2(&sdhost_wk.wk,1);
|
||
return err;
|
||
}
|
||
|
||
|
||
uint32 sdhost_init(uint32 clk, uint32 flags)
|
||
{
|
||
uint32 err = 1;
|
||
struct sdh_device *sdh = NULL;
|
||
sdh = (struct sdh_device *)dev_get(HG_SDIOHOST_DEVID);
|
||
|
||
#if SDH_I2C2_REUSE
|
||
os_sema_down(&sem,osWaitForever);
|
||
#endif
|
||
|
||
if(sdh)
|
||
{
|
||
err = sd_init(sdh, clk, flags);
|
||
if(err)
|
||
sdh->sd_opt = SD_OFF;
|
||
|
||
if(sdhost_wk.wk.init == 0 && sdhost_wk.wk.running == 0)
|
||
{
|
||
sdhost_wk.host = sdh;
|
||
sdhost_wk.isregister = 1;
|
||
OS_WORK_INIT(&sdhost_wk.wk, sdh_loop, 0);
|
||
os_run_work_delay(&sdhost_wk.wk, 500);
|
||
}
|
||
}
|
||
|
||
#if SDH_I2C2_REUSE
|
||
os_sema_up(&sem);
|
||
#endif
|
||
|
||
return err;
|
||
}
|
||
|
||
|
||
#if SDH_I2C2_REUSE
|
||
/**
|
||
* @brief 该函数用于SDH和I2C2端口复用的切换
|
||
*
|
||
* @param sdh_stop_en 停止SDH、使用I2C2，则置1，否则置0
|
||
* @return uint32
|
||
*/
|
||
uint32 sdhost_i2c2_exchange(int sdh_stop_en)
|
||
{
|
||
if(sdh_stop_en) {
|
||
os_sema_down(&sem,osWaitForever);
|
||
os_work_cancle2(&sdhost_wk.wk,1);
|
||
pin_func(HG_I2C2_DEVID,1);
|
||
} else {
|
||
os_sema_up(&sem);
|
||
OS_WORK_INIT(&sdhost_wk.wk, sdh_loop, 0);
|
||
os_run_work_delay(&sdhost_wk.wk, 500);
|
||
}
|
||
}
|
||
|
||
#endif
|
||
|
||
uint32 get_sdhost_status(struct sdh_device *host)
|
||
{
|
||
if(host->sd_opt == SD_OFF)
|
||
{
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
|