#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" struct sdh_device *sdh_test; struct os_semaphore sem; #define be32_to_cpu(x) ((uint32_t)( \ (((uint32_t)(x) & (uint32_t)0x000000ffUL) << 24) | \ (((uint32_t)(x) & (uint32_t)0x0000ff00UL) << 8) | \ (((uint32_t)(x) & (uint32_t)0x00ff0000UL) >> 8) | \ (((uint32_t)(x) & (uint32_t)0xff000000UL) >> 24))) static uint32_t __rt_fls(uint32_t val) { uint32_t 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_t tran_unit[] = { 10000, 100000, 1000000, 10000000, 0, 0, 0, 0 }; static const uint8_t tran_value[] = { 0, 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80, }; static const uint32_t tacc_uint[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, }; static const uint8_t tacc_value[] = { 0, 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80, }; uint32_t GET_BITS(uint32_t *resp, uint32_t start, uint32_t size) { const int32_t __size = size; const uint32_t __mask = (__size < 32 ? 1 << __size : 0) - 1; const int32_t __off = 3 - ((start) / 32); const int32_t __shft = (start) & 31; uint32_t __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_t 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); os_printf("sd_version : %d \t %d\r\n", scr->sd_version, scr->sd_bus_widths); return 0; } #ifdef TXW81X static int32_t sd_switch(struct sdh_device *host) { int32_t ret; struct rt_mmcsd_cmd cmd; uint8_t *buf = os_malloc(64); if (!buf) { os_printf("mallo err!\r\n"); return 1; } host->data.blksize = 64; host->data.blks = 1; host->data.err = 0; if (host->read) { ret = host->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 (host->cmd) { ret = host->cmd(host, &cmd); if (ret) return 1; } if (host->complete) { ret = host->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) os_printf("\r\n"); os_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 (host->read) { ret = host->read(host, buf); if (ret) return 1; } cmd.cmd_code = SD_SWITCH; cmd.arg = 0x80FFFFF1; cmd.flags = RESP_R1 | CMD_ADTC; if (host->cmd) { ret = host->cmd(host, &cmd); if (ret) return 1; } if (host->complete) { ret = host->complete(host); if (ret) return 1; } #if 0 for(int itk = 0;itk <64;itk++){ if(itk%32 == 0) os_printf("\r\n"); os_printf("%02x ",buf[itk]); } os_printf("\r\n"); #endif if ((buf[16] & 0xF) != 1) { os_printf("switching card to high speed failed!"); return 1; } os_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_t *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: os_printf("unrecognised CSD structure version %d!", csd->csd_structure); return -EINVAL; } host->card_max_blk_num = host->card_capacity << 1; os_printf("SD card capacity %d KB.\r\n" , host->card_capacity); os_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_t ocr) { int bit; //extern int ffs32_lsb(uint32_t 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(host->iocfg) host->iocfg(host,&host->io_cfg); } else { os_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(host->iocfg) host->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(host->iocfg) host->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_t clk) { host->io_cfg.clock = clk; host->io_cfg.ioctl_type = LL_SDHC_IOCTRL_SET_CLOCK; host->iocfg(host,&host->io_cfg); } void sd_set_bus_width(struct sdh_device * host,uint32_t width) { host->io_cfg.bus_width = width; host->io_cfg.ioctl_type = LL_SDHC_IOCTRL_SET_BUS_WIDTH; host->iocfg(host,&host->io_cfg); } #ifdef TXW81X void sd_set_sample(struct sdh_device *host, TYPE_LL_SDHC_SMP_CFG type, uint8_t cmd_cmp, uint8_t 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; host->iocfg(host, &host->io_cfg); } void sd_delay_config(struct sdh_device *host, TYPE_LL_SDHC_DELAY_SYSCLK dly_cfg, uint8_t 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 = dly_cfg; host->io_cfg.delay_chain_cnt = chain; } host->io_cfg.ioctl_type = LL_SDHC_IOCTRL_SET_DELAY_TYPE; host->iocfg(host, &host->io_cfg); } void sd_dat_of_stop_clk_cfg(struct sdh_device *host, uint8_t flag) { host->io_cfg.dat_overflow_stop_flag = flag; host->io_cfg.ioctl_type = LL_SDHC_IOCTRL_SET_DAT_OF_STOP_CLK; host->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(host->cmd) ret = host->cmd(host,&cmd); else{ os_printf("no cmd action register\r\n"); return 0; } return ret; } uint32 send_all_get_cid(struct sdh_device * host,uint32_t *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 = host->cmd(host,&cmd); if(ret==0) memcpy(cid, cmd.resp, sizeof(uint32_t) * 4); return ret; } uint32 send_get_card_addr(struct sdh_device * host,uint32_t *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 = host->cmd(host,&cmd); *rca = cmd.resp[0] >> 16; return 0; } uint32 send_card_status(struct sdh_device * host){ struct rt_mmcsd_cmd cmd; int ret = 0; uint32 status = 0; 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(host->cmd) ret = host->cmd(host,&cmd); status = (cmd.resp[0] >> 9) & 0xf; if (status != MMCSD_CARD_STATUS_TRAN) { os_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(host->cmd) ret = host->cmd(host,&cmd); return ret; } uint32 send_if_cond(struct sdh_device * host,uint32_t ocr) { struct rt_mmcsd_cmd cmd; int ret = 0; uint8_t 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(host->cmd) ret = host->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_t *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 = host->cmd(host,&cmd); memcpy(csd, cmd.resp, sizeof(uint32_t) * 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(host->cmd) ret = host->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(host->cmd) ret = host->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(host->read) ret = host->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(host->cmd) ret = host->cmd(host,&cmd); if (host->complete) { ret = host->complete(host); if (ret) return 1; } if(host->data.err != 0) return 0; scr[0] = be32_to_cpu(scr[0]); scr[1] = be32_to_cpu(scr[1]); os_printf("scr:%x %x\r\n",scr[0],scr[1]); return 1; } uint32 sd_tran_stop(struct sdh_device * host) { int ret = 0; 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; host->sd_opt = SD_IDLE; if(host->cmd) ret = host->cmd(host,&cmd); host->sd_stop = 0; if(!ret) { for (int i = 0; i < 50; i++) { ret = send_card_status(host); if(!ret) break; } if(ret) { os_printf("%s status err!\r\n", __func__); ret = RET_ERR; } } return ret; } //给外部接口专门用的停止命令,现在暂时是给文件系统 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_t backup_lba = host->new_lba; struct rt_mmcsd_cmd cmd; os_mutex_lock(&host->lock,osWaitForever); if(((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 = lba; } else if(host->sd_opt == SD_IDLE) { send_cmd = 1; } else { send_cmd = 0; } if ((host->new_lba + len/SECTOR_SIZE) >= host->card_max_blk_num) { os_printf("%s operation lba %d size %d max : %d err\r\n", __func__, host->new_lba, len/SECTOR_SIZE, host->card_max_blk_num); host->new_lba = backup_lba; ret = RET_ERR; goto __err; } host->sd_stop = 1; host->new_lba = host->new_lba + len/SECTOR_SIZE; host->sd_opt = SD_M_W; /////////////////////////////////////////////////////// memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); cmd.cmd_code = WRITE_MULTIPLE_BLOCK; cmd.arg = lba; if (!(host->cardflags & CARD_FLAG_SDHC)) { cmd.arg <<= 9; } cmd.flags = RESP_SPI_R1 | RESP_R1 | CMD_ADTC; if((host->cmd) && send_cmd){ ret = host->cmd(host,&cmd); if(ret){ sd_tran_stop(host); ret = -1; goto __err; } } /////////////////////////////////////////////////////// host->data.blksize = SECTOR_SIZE; host->data.blks = len/SECTOR_SIZE; host->data.err = 0; if(host->write) ret = host->write(host,buf); if (host->complete) ret = host->complete(host); 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) { int ret = 0; int send_cmd = 1; uint32_t backup_lba = host->new_lba; struct rt_mmcsd_cmd cmd; os_mutex_lock(&host->lock,osWaitForever); if(((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 = lba; } else if(host->sd_opt == SD_IDLE) { send_cmd = 1; } else { send_cmd = 0; } if ((host->new_lba + len/SECTOR_SIZE) >= host->card_max_blk_num) { os_printf("%s operation lba %d size %d max : %d err\r\n", __func__, host->new_lba, len/SECTOR_SIZE, host->card_max_blk_num); host->new_lba = backup_lba; ret = RET_ERR; goto __err; } host->sd_stop = 1; host->new_lba = host->new_lba + len/SECTOR_SIZE; host->sd_opt = SD_M_R; /////////////////////////////////////////////////////// /////////////////////////////////////////////////////// host->data.blksize = SECTOR_SIZE; host->data.blks = len/SECTOR_SIZE; host->data.err = 0; if(host->read) ret = host->read(host,buf); memset(&cmd, 0, sizeof(struct rt_mmcsd_cmd)); cmd.cmd_code = READ_MULTIPLE_BLOCK; cmd.arg = lba; if (!(host->cardflags & CARD_FLAG_SDHC)) { cmd.arg <<= 9; } cmd.flags = RESP_SPI_R1 | RESP_R1 | CMD_ADTC; if((host->cmd) && send_cmd){ ret = host->cmd(host,&cmd); if(ret){ sd_tran_stop(host); ret = MMCSD_CMD_ERR; goto __err; } } if (host->complete) ret = host->complete(host); if (ret) { sd_tran_stop(host); ret = MMCSD_DAT_ERR; goto __err; } __err: os_mutex_unlock(&host->lock); return ret; } uint32 send_app_op_cond(struct sdh_device *host, uint32_t ocr, uint32_t *rocr) { struct rt_mmcsd_cmd cmd; uint32_t 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){ os_printf("cmd err\r\n"); break; } // memset(cmd->resp, 0, sizeof(cmd->resp)); ret = host->cmd(host,&cmd); if(ret){ os_printf("cmd2 err\r\n"); break; } os_printf("cmd resp:%x\r\n",cmd.resp[0]); if (cmd.resp[0] & CARD_BUSY){ os_printf("card busy ok\r\n"); break; } os_sleep_ms(10); } if(rocr) *rocr = cmd.resp[0]; if(!(cmd.resp[0] & CARD_BUSY)) return RET_ERR; return ret; } void stop_card(){ sd_tran_stop(sdh_test); } uint8_t get_sd_status(void) { //os_printf("%s:%d\r\n",__FUNCTION__,sdh_test->sd_opt); return sdh_test->sd_opt; } uint8_t get_sd_status2(void) { //os_printf("%s:%d\r\n",__FUNCTION__,sdh_test->sd_opt); 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 TXW81X uint32 sd_sample_point_cfg(struct sdh_device *host, uint32 clk) { uint32_t ret = 0; uint32_t last_ret = MMCSD_INT_VLE; uint8_t loop = MMCSD_SMP_DELAY_CHAIN; uint8_t index = 0; uint8_t buf_index = 0; uint8_t cmd_smp = 0; uint8_t dat_smp = 0; uint8_t smp[2][5] = {0}; uint8_t dly_chain = 0x7; uint8_t flag = 0; uint8_t *data = os_malloc(SECTOR_SIZE); if (host->card_type != CARD_TYPE_SD) { os_free(data); return RET_ERR; } sd_set_clk(host, clk); host->io_cfg.self_adaption_flag = MMCSD_SMP_EN; __switch_type: sd_delay_config(host, loop, dly_chain); sd_set_sample(host, LL_SDHC_ALL_SMP_CFG_EN, 0, 0); for (int i = 0; i < 2; i++) { do { ret = sd_multiple_read(host, 0, SECTOR_SIZE, data); switch (ret) { case MMCSD_NO_ERR: smp[i][buf_index++] = index; break; case MMCSD_CMD_ERR: if(i) flag |= MMCSD_SMP_ERR; break; case MMCSD_DAT_ERR: if(!i) smp[i][buf_index++] = index; break; default: break; } if((last_ret == MMCSD_NO_ERR) && (ret == BIT(i))) flag |= MMCSD_BUF_ERR; if((flag & (MMCSD_SMP_ERR | MMCSD_BUF_ERR)) || (buf_index > 5)) break; last_ret = ret; (i) ? (sd_set_sample(host, LL_SDHC_ALL_SMP_CFG_EN, cmd_smp, ++index)): (sd_set_sample(host, LL_SDHC_ALL_SMP_CFG_EN, ++index, dat_smp)); } while (index < host->io_cfg.crc_sample_max); if(!buf_index || (flag & MMCSD_SMP_ERR)) { os_printf("%s smp err!\r\n", (i) ? ("dat") : ("cmd")); break; }else{ flag |= BIT(i); } if(!i) cmd_smp = (((buf_index - 1)>>1) == 0) ? (0) : (((uint32)*(smp[i] + (buf_index - 1))>>1)); else dat_smp = (((buf_index - 1)>>1) == 0) ? (0) : (((uint32)*(smp[i] + (buf_index - 1))>>1)); sd_set_sample(host, LL_SDHC_ALL_SMP_CFG_EN, cmd_smp, dat_smp); index = 0;buf_index = 0; flag &= ~(MMCSD_BUF_ERR); } if(flag != 0x3) { os_printf("loop:%d\r\n", loop); flag = 0;cmd_smp = 0; dat_smp = 0;dly_chain += 8; if(!((loop == MMCSD_SMP_DELAY_CHAIN)&&(dly_chain < 0x20))) loop++; if(loop <= MMCSD_SMP_DELAY_ONE_CLOCK) goto __switch_type; os_free(data); sd_set_sample(host, LL_SDHC_ALL_SMP_CFG_EN, 0, 0); sd_tran_stop(host); return RET_ERR; } os_printf("********cmd_index: %d \t dat_index:%d \t dly_chain :%d***********\r\n", cmd_smp, dat_smp, dly_chain); os_free(data); sd_tran_stop(host); return RET_OK; } #endif uint32 sd_init(struct sdh_device * host, uint32 clk) { uint32 ret; uint32_t resp[4]; uint32_t ocr; uint8_t bw = 1; os_printf("open_width:%d\r\n",bw); if(host->open) host->open(host,bw); sdhost_io_func_init(host->flags&MMCSD_BUSWIDTH_4); os_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) { os_printf("idle cmd err\r\n"); return RET_ERR; } __delay_asm(100); ret = send_if_cond(host,host->valid_ocr); if(ret) { os_printf("SEND_IF_COND cmd err\r\n"); return RET_ERR; } ret = send_app_op_cond(host,0x40ff8000,&ocr); if(ret){ os_printf("init card err\r\n"); return RET_ERR; } os_printf("ocr:%x\r\n",ocr); ocr = select_voltage(host,ocr); os_printf("cur_ocr:%x\r\n",ocr); if (!ocr) { os_printf("cal ocr error\r\n"); return RET_ERR; } send_idle(host); __delay_asm(100); ret = send_if_cond(host,ocr); if(ret==0) ocr |= 1 << 30; ret = send_app_op_cond(host,ocr,NULL); if(ret){ os_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); send_get_scr(host,host->resp_scr); 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){ os_printf("set bus width 4 err\r\n"); return RET_ERR; } sd_set_bus_width(host, MMCSD_BUS_WIDTH_4); } #if defined (TXW81X) 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{ os_printf("********** test SD start ********\r\n"); ret = sd_sample_point_cfg(host, clk); os_printf("********** test SD finish ********\r\n"); if (ret) { os_printf("set highspeed sampling point err\r\n"); host->io_cfg.self_adaption_flag = MMCSD_SMP_DIS; sd_set_clk(host, 24*1000*1000); return RET_OK; } host->io_cfg.self_adaption_flag = MMCSD_SMP_SUCC; } }else{ sd_set_clk(host, clk); } #else sd_set_clk(host, clk); #endif ((struct hgsdh *)host)->opened = 1; return RET_OK; } extern bool fatfs_register(); extern void fatfs_unregister(); extern void fatfs_unregister_loop(); void hg_sdh_status(struct sdh_device *host){ uint8_t opt = SD_IDLE; uint32_t lba = 0; int flag = 0; uint32 ret; uint8_t count = 0; while(1){ os_sleep_ms(500); if(SD_OFF == host->sd_opt){ os_printf("sdh no online\r\n"); if(flag == 1) { flag = 0; os_mutex_del(&host->lock); fatfs_unregister(); } //判断状态,是否重新挂在文件系统 fatfs_register(); }else{ os_mutex_lock(&host->lock,osWaitForever); if(SD_IDLE != host->sd_opt){ if((opt != host->sd_opt)||(lba != host->new_lba)) { opt = host->sd_opt; lba = host->new_lba; count = 0; }else{ count++; } }else{ ret = send_card_status(host); if(ret != 0){ host->sd_opt = SD_OFF; count = 0; flag = 1; } } if(count >= 2){ count = 0; sd_tran_stop(host); } os_mutex_unlock(&host->lock); } } } 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() { os_printf("enter sdhost test\r\n"); sdh_test = (struct sdh_device *)dev_get(HG_SDIOHOST_DEVID); //sdhost_io_func_init(); sd_init(sdh_test, 48*1000*1000); } uint32 sdhost_suspend(struct sdh_device * host){ uint32 ret = -1; if(host->suspend){ ret = host->suspend(host); } return ret; } uint32 sdhost_resume(struct sdh_device * host){ uint32 ret = -1; if(host->resume){ ret = host->resume(host); } return ret; } static struct os_work sdhost_wk = { .running=0 }; int32 sdh_loop(struct os_work *work) { struct sdh_device *host = NULL; host = (struct sdh_device *)dev_get(HG_SDIOHOST_DEVID); static uint8_t opt = SD_IDLE; static uint32_t lba = 0; static uint8_t flag = 0; static uint8_t count = 0; uint32_t sleep_time = 500; uint32 ret; if(SD_OFF == host->sd_opt) { os_printf("sdh no online\r\n"); if(flag == 1) { flag = 0; fatfs_unregister_loop(); } //判断状态,是否重新挂在文件系统 fatfs_register(); } else { ret = os_mutex_lock(&host->lock,0); if(ret) { sleep_time = 1; //获取锁失败 goto sdh_loop_end; } if(SD_IDLE != host->sd_opt) { if((opt != host->sd_opt)||(lba != host->new_lba)) { opt = host->sd_opt; lba = host->new_lba; count = 0; } else { count++; } } else { ret = send_card_status(host); if(ret != 0) { host->sd_opt = SD_OFF; count = 0; flag = 1; } } if(count >= 2){ count = 0; sd_tran_stop(host); } os_mutex_unlock(&host->lock); } sdh_loop_end: os_run_work_delay(work, sleep_time); return 0; } 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,1); return err; } uint32 sdhost_init(uint32 clk) { 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); if(err) sdh->sd_opt = SD_OFF; if(sdhost_wk.init == 0 && sdhost_wk.running == 0) { OS_WORK_INIT(&sdhost_wk, sdh_loop, 0); os_run_work_delay(&sdhost_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,1); pin_func(HG_I2C2_DEVID,1); } else { os_sema_up(&sem); OS_WORK_INIT(&sdhost_wk, sdh_loop, 0); os_run_work_delay(&sdhost_wk, 500); } } #endif uint32 get_sdhost_status(struct sdh_device *host) { if(host->sd_opt == SD_OFF) { return 1; } return 0; }