libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/allwinner/libraries/sunxi-hal/hal/source/sdmmc/sd.c

1132 lines
31 KiB
C
Raw Blame History

/*
* Copyright (C) 2017 ALLWINNERTECH TECHNOLOGY CO., LTD. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
* 3. Neither the name of ALLWINNERTECH TECHNOLOGY CO., LTD. nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "sunxi_hal_common.h"
#include "hal_base.h"
#include "sys/endian.h"
#include "hal_sdhost.h"
#include "sdmmc.h"
#include "_sdhost.h"
#include "_core.h"
#ifdef CONFIG_USE_MMC
#include "_mmc.h"
#endif
#include "_sd.h"
#include "_sd_define.h"
#ifdef CONFIG_USE_SD
static const unsigned int tran_exp[] = { /* about KB/S */
10000, 100000, 1000000, 10000000,
0, 0, 0, 0
};
static const unsigned char tran_mant[] = { /* time value*10 */
0, 10, 12, 13, 15, 20, 25, 30,
35, 40, 45, 50, 55, 60, 70, 80,
};
/*
static const unsigned int tacc_exp[] = {
1, 10, 100, 1000, 10000, 100000, 1000000, 10000000,
};
static const unsigned int tacc_mant[] = {
0, 10, 12, 13, 15, 20, 25, 30,
35, 40, 45, 50, 55, 60, 70, 80,
};
*/
static int32_t mmc_send_app_op_cond(struct mmc_host *host, uint32_t ocr, uint32_t *rocr)
{
struct mmc_command cmd = {0};
int32_t i, err;
if (!host) {
SDC_LOGE_RAW(ROM_ERR_MASK, "%s,%d err", __func__, __LINE__);
return -1;
}
cmd.opcode = SD_APP_OP_COND;
cmd.arg = ocr;
cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR;
for (i = 100; i; i--) {
err = mmc_wait_for_app_cmd(host, NULL, &cmd);
if (err) {
// printf("%s,%d\n",__FUNCTION__,__LINE__);
break;
}
/* otherwise wait until reset completes */
if (cmd.resp[0] & MMC_CARD_BUSY){
// printf("%s,%d\n",__FUNCTION__,__LINE__);
break;
}
if (host->ocr_avail & MMC_VDD_165_195)
cmd.arg = 0x41000000 | (cmd.resp[0] & 0xFF8000);
else
cmd.arg = 0x40000000 | (cmd.resp[0] & 0xFF8000);
err = -1;
mmc_mdelay(20);
// printf("%s,%d %d\n",__FUNCTION__,__LINE__,i);
}
if (rocr)
*rocr = cmd.resp[0];
if(err)
printf("%s,%d %ld\n",__FUNCTION__,__LINE__, HAL_PR_SZ_L(i));
return err;
}
int32_t mmc_app_sd_status(struct mmc_card *card, uint8_t *ssr)
{
struct mmc_request mrq;
struct mmc_command cmd = {0};
struct mmc_data data = {0};
struct scatterlist sg;
if (!ssr) {
SD_LOGE("%s,%d err", __func__, __LINE__);
return -1;
}
if (mmc_app_cmd(card->host, card)) {
return -1;
}
mrq.cmd = &cmd;
mrq.data = &data;
cmd.opcode = SD_APP_SD_STATUS;
cmd.arg = 0;
cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_ADTC;
data.blksz = 64;
data.blocks = 1;
data.flags = MMC_DATA_READ;
data.sg = &sg;
data.sg_len = 1;
sg.len = 64;
sg.buffer = ssr;
if (mmc_wait_for_req(card->host, &mrq)) {
return -1;
}
SD_LOGN("card raw SD status:\n");
sd_hex_dump_bytes((void *)ssr, 64);
return 0;
}
int32_t mmc_app_send_scr(struct mmc_card *card, uint32_t *raw_scr)
{
struct mmc_command cmd = {0};
struct mmc_data data = {0};
struct mmc_request mrq;
struct scatterlist sg;
if (mmc_app_cmd(card->host, card)) {
return -1;
}
mrq.cmd = &cmd;
mrq.data = &data;
cmd.opcode = SD_APP_SEND_SCR;
cmd.arg = 0;
cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
data.blksz = 8;
data.blocks = 1;
data.flags = MMC_DATA_READ;
data.sg = &sg;
data.sg_len = 1;
sg.len = 8;
sg.buffer = (void *)raw_scr;
/* get scr, 8 bytes */
if (mmc_wait_for_req(card->host, &mrq)) {
return -1;
}
raw_scr[0] = be32_to_cpu(raw_scr[0]);
raw_scr[1] = be32_to_cpu(raw_scr[1]);
return 0;
}
#ifdef SD_SUPPORT_VERSION3
int32_t mmc_switch_to_1v8(struct mmc_card *card)
{
struct mmc_command cmd = {0};
cmd.opcode = SD_SWITCH_VOLTAGE;
cmd.arg = 0;
cmd.vol_switch = 1;
cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
if (mmc_wait_for_cmd(card->host, &cmd)) {
SD_LOGW("sd switch 1v8 failed\n");
return -1;
}
return 0;
}
#endif
/*
* Given the decoded CSD structure, decode the raw CID to our CID structure.
*/
void mmc_decode_cid(struct mmc_card *card, uint32_t *resp)
{
SDC_Memset(&card->cid, 0, sizeof(struct mmc_cid));
/*
* SD doesn't currently have a version field so we will
* have to assume we can parse this.
*/
card->cid.manfid = UNSTUFF_BITS(resp, 120, 8);
card->cid.oemid = UNSTUFF_BITS(resp, 104, 8);
card->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8);
card->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8);
card->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8);
card->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8);
card->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8);
card->cid.hwrev = UNSTUFF_BITS(resp, 60, 4);
card->cid.fwrev = UNSTUFF_BITS(resp, 56, 4);
card->cid.serial = UNSTUFF_BITS(resp, 24, 32);
card->cid.year = UNSTUFF_BITS(resp, 12, 8);
card->cid.month = UNSTUFF_BITS(resp, 8, 4);
card->cid.year += 2000; /* SD cards year offset */
}
int32_t mmc_send_cid(struct mmc_card *card)
{
struct mmc_command cmd = {0};
uint32_t cid[4] = {0};
cmd.opcode = MMC_SEND_CID;
cmd.arg = card->rca << 16;
cmd.flags = MMC_RSP_R2 | MMC_CMD_AC;
if (mmc_wait_for_cmd(card->host, &cmd)) {
return -1;
}
HAL_Memcpy((void *)cid, (void *)cmd.resp, 16);
SD_LOGN("card raw cid:\n");
sd_hex_dump_bytes((void *)cid, 16);
mmc_decode_cid(card, cid);
return 0;
}
/*
* Given a 128-bit response, decode to our card CSD structure.
*/
static int32_t mmc_decode_csd(struct mmc_card *card, uint32_t *raw_csd)
{
int32_t e, m, csd_struct;
uint32_t *resp = raw_csd;
struct mmc_csd *csd = &card->csd;
csd_struct = UNSTUFF_BITS(resp, 126, 2);
card->csd.csd_ver = csd_struct;
switch (csd_struct) {
case 0:
//m = UNSTUFF_BITS(resp, 115, 4);
//e = UNSTUFF_BITS(resp, 112, 3);
//csd->tacc_ns = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
//csd->tacc_clks = UNSTUFF_BITS(resp, 104, 8) * 100;
m = UNSTUFF_BITS(resp, 99, 4);
e = UNSTUFF_BITS(resp, 96, 3);
csd->max_dtr = tran_exp[e] * tran_mant[m];
csd->cmdclass = UNSTUFF_BITS(resp, 84, 12);
m = UNSTUFF_BITS(resp, 80, 4);
csd->read_blk_len = 1 << m;
e = UNSTUFF_BITS(resp, 47, 3);
m = UNSTUFF_BITS(resp, 62, 12);
csd->capacity = (1 + m) * (1 << (e + 2)) * csd->read_blk_len;
csd->capacity >>= 10; /* unit:KB */
//csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
//csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
//csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
//csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
//csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
//csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
//csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
//if (UNSTUFF_BITS(resp, 46, 1)) {
// csd->erase_size = 1;
//} else if (csd->write_blkbits >= 9) {
// csd->erase_size = UNSTUFF_BITS(resp, 39, 7) + 1;
// csd->erase_size <<= csd->write_blkbits - 9;
//}
break;
case 1:
/*
* This is a block-addressed SDHC or SDXC card. Most
* interesting fields are unused and have fixed
* values. To avoid getting tripped by buggy cards,
* we assume those fixed values ourselves.
*/
mmc_card_set_blockaddr(card);
//csd->tacc_ns = 0; /* Unused */
//csd->tacc_clks = 0; /* Unused */
m = UNSTUFF_BITS(resp, 99, 4);
e = UNSTUFF_BITS(resp, 96, 3);
csd->max_dtr = tran_exp[e] * tran_mant[m];
csd->cmdclass = UNSTUFF_BITS(resp, 84, 12);
csd->read_blk_len = UNSTUFF_BITS(resp, 80, 4);
m = UNSTUFF_BITS(resp, 48, 22);
csd->capacity = (1 + m) << 9;
/* SDXC cards have a minimum C_SIZE of 0x00FFFF */
if (m >= 0xFFFF)
mmc_card_set_ext_capacity(card);
//csd->read_blkbits = 9;
//csd->read_partial = 0;
//csd->write_misalign = 0;
//csd->read_misalign = 0;
//csd->r2w_factor = 4; /* Unused */
//csd->write_blkbits = 9;
//csd->write_partial = 0;
//csd->erase_size = 1;
break;
default:
SD_LOGE("%s: unrecognised CSD structure version %d\n",
__func__, (unsigned int)csd_struct);
return -1;
}
//card->erase_size = csd->erase_size;
SD_LOGD("%s %d ca:%d\n", __func__, (unsigned int)csd_struct, (unsigned int)csd->capacity);
return 0;
}
#ifdef SD_SUPPORT_VERSION3
static void sd_update_bus_speed_mode(struct mmc_card *card)
{
/*
* If the host doesn't support any of the UHS-I modes, fallback on
* default speed.
*/
if (!(card->host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50))) {
card->sd_bus_speed = 0;
return;
}
if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
(card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
card->sd_bus_speed = UHS_SDR104_BUS_SPEED;
} else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
(card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
card->sd_bus_speed = UHS_DDR50_BUS_SPEED;
} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
SD_MODE_UHS_SDR50)) {
card->sd_bus_speed = UHS_SDR50_BUS_SPEED;
} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
(card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
card->sd_bus_speed = UHS_SDR25_BUS_SPEED;
} else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
SD_MODE_UHS_SDR12)) {
card->sd_bus_speed = UHS_SDR12_BUS_SPEED;
}
}
static int32_t sd_set_bus_speed_mode(struct mmc_card *card, int8_t *status)
{
int32_t err;
uint32_t timing = 0;
switch (card->sd_bus_speed) {
case UHS_SDR104_BUS_SPEED:
timing = MMC_TIMING_UHS_SDR104;
card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
break;
case UHS_DDR50_BUS_SPEED:
timing = MMC_TIMING_UHS_DDR50;
card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
break;
case UHS_SDR50_BUS_SPEED:
timing = MMC_TIMING_UHS_SDR50;
card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
break;
case UHS_SDR25_BUS_SPEED:
timing = MMC_TIMING_UHS_SDR25;
card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
break;
case UHS_SDR12_BUS_SPEED:
timing = MMC_TIMING_UHS_SDR12;
card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
break;
default:
return 0;
}
err = mmc_sd_switch(card, 1, 0, card->sd_bus_speed, status);
if (err)
return err;
if ((status[16] & 0xF) != card->sd_bus_speed)
SD_LOGW("%s: Problem setting bus speed mode!\n", __func__);
else {
mmc_set_timing(card->host, timing);
mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr);
}
return 0;
}
static int32_t sd_set_current_limit(struct mmc_card *card, int8_t *status)
{
int32_t current_limit = 0;
int32_t err;
/*
* Current limit switch is only defined for SDR50, SDR104, and DDR50
* bus speed modes. For other bus speed modes, we set the default
* current limit of 200mA.
*/
if ((card->sd_bus_speed == UHS_SDR50_BUS_SPEED) ||
(card->sd_bus_speed == UHS_SDR104_BUS_SPEED) ||
(card->sd_bus_speed == UHS_DDR50_BUS_SPEED)) {
if (card->host->caps & MMC_CAP_MAX_CURRENT_800) {
if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_800)
current_limit = SD_SET_CURRENT_LIMIT_800;
else if (card->sw_caps.sd3_curr_limit &
SD_MAX_CURRENT_600)
current_limit = SD_SET_CURRENT_LIMIT_600;
else if (card->sw_caps.sd3_curr_limit &
SD_MAX_CURRENT_400)
current_limit = SD_SET_CURRENT_LIMIT_400;
else if (card->sw_caps.sd3_curr_limit &
SD_MAX_CURRENT_200)
current_limit = SD_SET_CURRENT_LIMIT_200;
} else if (card->host->caps & MMC_CAP_MAX_CURRENT_600) {
if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_600)
current_limit = SD_SET_CURRENT_LIMIT_600;
else if (card->sw_caps.sd3_curr_limit &
SD_MAX_CURRENT_400)
current_limit = SD_SET_CURRENT_LIMIT_400;
else if (card->sw_caps.sd3_curr_limit &
SD_MAX_CURRENT_200)
current_limit = SD_SET_CURRENT_LIMIT_200;
} else if (card->host->caps & MMC_CAP_MAX_CURRENT_400) {
if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_400)
current_limit = SD_SET_CURRENT_LIMIT_400;
else if (card->sw_caps.sd3_curr_limit &
SD_MAX_CURRENT_200)
current_limit = SD_SET_CURRENT_LIMIT_200;
} else if (card->host->caps & MMC_CAP_MAX_CURRENT_200) {
if (card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_200)
current_limit = SD_SET_CURRENT_LIMIT_200;
}
} else
current_limit = SD_SET_CURRENT_LIMIT_200;
err = mmc_sd_switch(card, 1, 3, current_limit, status);
if (err)
return err;
if (((status[15] >> 4) & 0x0F) != current_limit)
SD_LOGW("%s: Problem setting current limit!\n", __func__);
return 0;
}
int32_t mmc_sd_init_uhs_card(struct mmc_card *card)
{
int32_t err;
struct mmc_command cmd = {0};
struct mmc_data data = {0};
struct mmc_request mrq;
struct scatterlist sg = {0};
uint32_t time = 0;
uint8_t pattern[] = {
0xff, 0x0f, 0xff, 0x00, 0xff, 0xcc, 0xc3, 0xcc, 0xc3, 0x3c, 0xcc, 0xff, 0xfe, 0xff, 0xfe, 0xef,
0xff, 0xdf, 0xff, 0xdd, 0xff, 0xfb, 0xff, 0xfb, 0xbf, 0xff, 0x7f, 0xff, 0x77, 0xf7, 0xbd, 0xef,
0xff, 0xf0, 0xff, 0xf0, 0x0f, 0xfc, 0xcc, 0x3c, 0xcc, 0x33, 0xcc, 0xcf, 0xff, 0xef, 0xff, 0xee,
0xff, 0xfd, 0xff, 0xfd, 0xdf, 0xff, 0xbf, 0xff, 0xbb, 0xff, 0xf7, 0xff, 0xf7, 0x7f, 0x7b, 0xde
};
uint32_t status[64/4] = {0};
if (!card->scr.sda_spec3)
return 0;
if (!(card->csd.cmdclass & CCC_SWITCH))
return 0;
/* Set 4-bit bus width */
if ((card->host->caps & MMC_CAP_4_BIT_DATA) &&
(card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
if (err)
goto out;
HAL_SDC_Set_BusWidth(card->host, MMC_BUS_WIDTH_4);
}
/*
* Select the bus speed mode depending on host
* and card capability.
*/
sd_update_bus_speed_mode(card);
/* Set the driver strength for the card */
err = sd_select_driver_type(card, status);
if (err)
goto out;
/* Set current limit for the card */
err = sd_set_current_limit(card, status);
if (err)
goto out;
/* Set bus speed mode of the card */
err = sd_set_bus_speed_mode(card, status);
if (err)
goto out;
/* SPI mode doesn't define CMD19 */
mmc_host_clk_hold(card->host);
sg.len = 512;
sg.buffer = status;
cmd.opcode = MMC_SEND_TUNING_PATTERN;
cmd.arg = 0;
cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
cmd.data = &data;
data.blksz = 64;
data.sg_len = 1;
data.sg = &sg;
data.flags = MMC_DATA_READ;
mrq.cmd = &cmd;
mrq.data = &data;
do {
if (mmc_wait_for_req(card->host, &mrq)) {
continue;
}
time++;
} while (time < 40);
if (HAL_Memcmp((void *)pattern, (void *)status, 64))
return -1;
mmc_host_clk_release(card->host);
out:
return 0;
}
#endif
/*
* Given a 64-bit response, decode to our card SCR structure.
*/
static int32_t mmc_decode_scr(struct mmc_card *card, uint32_t *raw_scr)
{
struct sd_scr *scr = &card->scr;
uint32_t scr_struct;
uint32_t resp[4];
resp[3] = raw_scr[1];
resp[2] = raw_scr[0];
scr_struct = UNSTUFF_BITS(resp, 60, 4);
if (scr_struct != 0) {
SD_LOGW("sdc unrecognised SCR structure version %u\n", (unsigned int)scr_struct);
return -1;
}
scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4);
scr->security_sup = UNSTUFF_BITS(resp, 52, 3);
scr->bus_widths = UNSTUFF_BITS(resp, 48, 4);
if (scr->sda_vsn == SCR_SPEC_VER_2)
/* Check if Physical Layer Spec v3.0 is supported */
scr->sda_spec3 = UNSTUFF_BITS(resp, 47, 1);
//if (UNSTUFF_BITS(resp, 55, 1))
// card->erased_byte = 0xFF;
//else
// card->erased_byte = 0x0;
if (scr->sda_spec3) {
scr->cmds = UNSTUFF_BITS(resp, 32, 2);
scr->sda_spec4 = UNSTUFF_BITS(resp, 42, 1);
scr->sda_spec5 = UNSTUFF_BITS(resp, 38, 4);
}
return 0;
}
/*
* Fetch and process SD Status register.
*/
static int32_t mmc_read_ssr(struct mmc_card *card)
{
int32_t err, i;
uint32_t ssr[64/4];
if (!(card->csd.cmdclass & CCC_APP_SPEC)) {
SD_LOGW("%s: card lacks mandatory SD Status function.\n", __func__);
return 0;
}
err = mmc_app_sd_status(card, (uint8_t *)ssr);
if (err) {
SD_LOGW("%s: problem reading SD Status register.\n", __func__);
err = 0;
goto out;
}
for (i = 0; i < 16; i++)
ssr[i] = be32_to_cpu(ssr[i]);
#ifdef SD_SUPPORT_ERASE
uint32_t au, es, et, eo;
/*
* UNSTUFF_BITS only works with four u32s so we have to offset the
* bitfield positions accordingly.
*/
au = UNSTUFF_BITS(ssr, 428 - 384, 4);
if (au > 0 && au <= 9) {
card->ssr.au = 1 << (au + 4);
es = UNSTUFF_BITS(ssr, 408 - 384, 16);
et = UNSTUFF_BITS(ssr, 402 - 384, 6);
eo = UNSTUFF_BITS(ssr, 400 - 384, 2);
if (es && et) {
card->ssr.erase_timeout = (et * 1000) / es;
card->ssr.erase_offset = eo * 1000;
}
} else {
SD_LOGW("%s: SD Status: Invalid Allocation Unit size.\n", __func__);
}
#endif
card->speed_class = UNSTUFF_BITS(ssr, 440 - 384, 8) * 2;
if (card->speed_class == 8)
card->speed_class = 10;
out:
return err;
}
/*
* Fetches and decodes switch information
*/
static int32_t mmc_read_switch(struct mmc_card *card)
{
int32_t err;
uint32_t status[64/sizeof(uint32_t)] = {0};
uint8_t *p_sta = (uint8_t *)status;
if (card->scr.sda_vsn < SCR_SPEC_VER_1) {
SD_LOGN("Card ver. does not support to read switch info!\n");
return 0;
}
if (!(card->csd.cmdclass & CCC_SWITCH)) {
SD_LOGW("card lacks mandatory switch function, performance might suffer.\n");
return 0;
}
/* Find out the supported Bus Speed Modes. */
err = mmc_sd_switch(card, SD_SWITCH_CHECK, SD_SWITCH_GRP_ACCESS_MODE,
SD_SWITCH_ACCESS_HS, p_sta);
if (err) {
SD_LOGW("%s: problem reading Bus Speed modes.\n", __func__);
goto out;
}
if (p_sta[13] & SD_MODE_HIGH_SPEED)
card->sw_caps.hs_max_dtr = HIGH_SPEED_MAX_DTR;
if (card->scr.sda_spec3) {
card->sw_caps.sd3_bus_mode = p_sta[13];
/* Find out Driver Strengths supported by the card */
err = mmc_sd_switch(card, SD_SWITCH_CHECK, SD_SWITCH_GRP_DRV_STRENGTH,
SD_SWITCH_ACCESS_HS, p_sta);
if (err) {
SD_LOGW("%s: problem reading Driver Strength.\n", __func__);
goto out;
}
card->sw_caps.sd3_drv_type = p_sta[9];
/* Find out Current Limits supported by the card */
err = mmc_sd_switch(card, SD_SWITCH_CHECK, SD_SWITCH_GRP_CUR_LIMIT,
SD_SWITCH_ACCESS_HS, p_sta);
if (err) {
SD_LOGW("%s: problem reading Current Limit.\n", __func__);
goto out;
}
card->sw_caps.sd3_curr_limit = p_sta[7];
}
out:
return err;
}
/*
* Test if the card supports high-speed mode and, if so, switch to it.
*/
int32_t mmc_sd_switch_hs(struct mmc_card *card)
{
int32_t err;
uint32_t status[64/sizeof(uint32_t)] = {0};
uint8_t *p_sta = (uint8_t *)status;
if (card->scr.sda_vsn < SCR_SPEC_VER_1) {
SD_LOGN("Card ver. does not support to switch to high speed!\n");
return 0;
}
if (!(card->csd.cmdclass & CCC_SWITCH)) {
SD_LOGN("Card cmdclass not support to switch to high speed!\n");
return 0;
}
if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
return 0;
if (card->sw_caps.hs_max_dtr == 0)
return 0;
/* Check function */
err = mmc_sd_switch(card, SD_SWITCH_CHECK, SD_SWITCH_GRP_ACCESS_MODE,
SD_SWITCH_ACCESS_HS, p_sta);
if (err)
return err;
if ((p_sta[16] & 0x0F) != 1) {
SD_LOGW("%s: Problem switching card into high-speed mode!\n", __func__);
err = 0;
} else {
err = 1;
}
return err;
}
static int32_t mmc_send_cxd_native(struct mmc_host *host, uint32_t arg, uint32_t *cxd, int32_t opcode)
{
int32_t err;
struct mmc_command cmd = {0};
if (!host || !cxd) {
SDC_LOGE_RAW(ROM_ERR_MASK, "%s,%d err", __func__, __LINE__);
return -1;
}
cmd.opcode = opcode;
cmd.arg = arg;
cmd.flags = MMC_RSP_R2 | MMC_CMD_AC;
err = mmc_wait_for_cmd(host, &cmd);
if (err)
return err;
HAL_Memcpy(cxd, cmd.resp, sizeof(uint32_t) * 4);
return 0;
}
int32_t mmc_send_csd(struct mmc_card *card, uint32_t *csd)
{
return mmc_send_cxd_native(card->host, card->rca << 16,
csd, MMC_SEND_CSD);
}
int32_t mmc_sd_get_csd(struct mmc_card *card)
{
int32_t err;
uint32_t csd[4] = {0};
/* Fetch CSD from card. */
err = mmc_send_csd(card, csd);
if (err)
return err;
SD_LOGN("card raw csd:\n");
sd_hex_dump_bytes((void *)csd, 16);
err = mmc_decode_csd(card, csd);
if (err)
return err;
return 0;
}
int32_t mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card)
{
int32_t err;
int32_t retries;
uint32_t raw_scr[2] = {0};
/* Fetch SCR from card. */
err = mmc_app_send_scr(card, raw_scr);
if (err)
return err;
SD_LOGN("card raw scr:\n");
sd_hex_dump_bytes((void *)raw_scr, 8);
err = mmc_decode_scr(card, raw_scr);
if (err)
return err;
/* Fetch and process SD Status register. */
err = mmc_read_ssr(card);
if (err)
return err;
#ifdef SD_SUPPORT_ERASE
/* Erase init depends on CSD and SSR */
mmc_init_erase(card);
#endif
/* Fetch switch information from card. */
for (retries = 1; retries <= 3; retries++) {
err = mmc_read_switch(card);
if (!err) {
if (retries > 1) {
SD_LOGW("%s: recovered\n", __func__);
}
break;
} else {
SD_LOGW("%s: read switch failed (attempt %d)\n",
__func__, (unsigned int)retries);
}
}
if (err)
return err;
#ifdef SD_SUPPORT_WRITEPROTECT
int32_t ro = -1;
/* Check if read-only switch is active. */
mmc_host_clk_hold(card->host);
ro = HAL_SDC_Get_ReadOnly(card->host);
mmc_host_clk_release(card->host);
if (ro < 0) {
SD_LOGW("%s: host does not support reading read-only switch."
" assuming write-enable.\n", __func__);
} else if (ro > 0) {
mmc_card_set_readonly(card);
}
#endif
return 0;
}
uint32_t mmc_sd_get_max_clock(struct mmc_card *card)
{
uint32_t max_dtr = (uint32_t)-1;
if (mmc_card_highspeed(card)) {
if (max_dtr > card->sw_caps.hs_max_dtr)
max_dtr = card->sw_caps.hs_max_dtr;
} else if (max_dtr > card->csd.max_dtr) {
max_dtr = card->csd.max_dtr;
}
return max_dtr;
}
/*
* Handle the detection and initialisation of a card.
*
* In the case of a resume, "oldcard" will contain the card
* we're trying to reinitialise.
*/
static int32_t mmc_sd_init_card(struct mmc_card *card, struct mmc_host *host)
{
int32_t err = 0;
/*
* I/O voltage should be 3.3 V here for the initialization needed.
*/
/* cmd2, send cid, check if card support 3.3V */
err = mmc_all_send_cid(host, card->cidno);
if (err) {
SD_LOGW("Cards all send CID number failed !!\n");
return -1;
} else
SD_LOGN("Card CID number:%x\n", (unsigned int)card->cidno[0]);
card->type = MMC_TYPE_SD;
/* cmd3, For native busses: get card RCA and quit open drain mode. */
err = mmc_send_relative_addr(card->host, &card->rca);
if (err) {
SD_LOGW("Card public new RCA failed !!\n");
return -1;
} else
SD_LOGD("Card public new RCA:%x\n", (unsigned int)card->rca);
/* cmd10, get CID register */
if (mmc_send_cid(card)) {
SD_LOGW("Card send CID reg failed !!\n");
return -1;
}
/* cmd9, get CSD register */
if (mmc_sd_get_csd(card)) {
SD_LOGW("Card send CSD reg failed !!\n");
return -1;
}
/* cmd7, Select card to standby state, as all following commands rely on that. */
if (mmc_select_card(card, 1)) {
SD_LOGW("mmc_select_card failed !!\n");
return -1;
}
err = mmc_sd_setup_card(host, card);
if (err)
goto free_card;
/* Initialization sequence for UHS-I cards */
#ifdef SD_SUPPORT_VERSION3
if (card->ocr.ocr & SD_ROCR_S18A) {
err = mmc_sd_init_uhs_card(card);
if (err)
goto free_card;
/* Card is an ultra-high-speed card */
mmc_card_set_uhs(card);
/*
* Since initialization is now complete, enable preset
* value registers for UHS-I cards.
*/
mmc_host_clk_hold(card->host);
HAL_SDC_Enable_Preset_Value(card->host, true);
mmc_host_clk_release(card->host);
} else
#endif
{
uint32_t clk;
uint32_t retries = 3;
while (retries) {
err = mmc_sd_switch_hs(card);
if (err < 0) {
SD_LOGE("%s: Re-switch hs, err %d (retries = %u)\n",
__func__, (unsigned int)err, (unsigned int)retries);
mmc_mdelay(5);
retries--;
continue;
}
break;
}
if (err <= 0) {
SD_LOGW("switch to high speed error, use DS: 25 MHz\n");
clk = 25000000;
err = HAL_SDC_Update_Clk(card->host, clk);
if (err)
return -1;
} else {
mmc_card_set_highspeed(card);
card->sd_bus_speed = HIGH_SPEED_BUS_SPEED;
clk = mmc_sd_get_max_clock(card);
err = HAL_SDC_Update_Clk(card->host, clk);
if (err)
return -1;
SD_LOGN("card is switched to high speed mode, clk:%u KHz\n", (unsigned int)clk/1000);
}
/* Switch to wider bus (if supported). */
if ((host->caps & MMC_CAP_4_BIT_DATA) &&
(card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
if (err) {
SD_LOGW("Set bus width error, use default 1 bit !!\n");
return -1;
}
/* config SDMMC controller bus width */
HAL_SDC_Set_BusWidth(card->host, MMC_BUS_WIDTH_4);
SD_LOGN("Set bus width type: %d\n", MMC_BUS_WIDTH_4);
}
}
mmc_add_card(card);
return 0;
free_card:
return err;
}
#ifdef CONFIG_SD_PM
static int32_t mmc_sd_suspend(struct mmc_host *host)
{
struct mmc_card *card = host->card;
if (card == NULL) {
SD_LOGE_RAW(ROM_ERR_MASK, "card open fail\n");
return -1;
}
mmc_card_open(card->id);
card->suspend = 1;
mmc_card_deinit(host->card);
SD_LOGD("%s ok\n", __func__);
mmc_card_close(card->id);
return 0;
}
static int32_t mmc_sd_resume(struct mmc_host *host)
{
struct mmc_card *card = host->card;
if (card == NULL) {
SD_LOGE_RAW(ROM_ERR_MASK, "card open fail\n");
return -1;
}
mmc_card_open(card->id);
mmc_rescan(card, host->sdc_id);
card->suspend = 0;
SD_LOGD("%s ok\n", __func__);
mmc_card_close(card->id);
return 0;
}
static const struct mmc_bus_ops sd_bus_ops = {
.suspend = mmc_sd_suspend,
.resume = mmc_sd_resume,
};
#endif
/*
* Starting point for SD card init.
*/
int32_t mmc_attach_sd(struct mmc_card *card, struct mmc_host *host)
{
int32_t err = 0;
uint32_t ocr = 0;
if (!host) {
SD_LOGE_RAW(ROM_ERR_MASK, "%s,%d err", __func__, __LINE__);
return -1;
}
//SD_LOGE("%s,%d\n",__FUNCTION__,__LINE__);
/* send cmd41/55 to check operation condition */
err = mmc_send_app_op_cond(host, 0, &ocr);
if (err) {
return err;
}
SD_LOGN("card ocr: %08x\n", (unsigned int)ocr);
/*
* Sanity check the voltages that the card claims to
* support.
*/
if (ocr & 0x7F) {
SD_LOGW("%s: card claims to support voltages below the defined range."
" These will be ignored.\n", __func__);
ocr &= ~0x7F;
}
card->ocr.ocr = 0x7fffffff & ocr; /* set card not in busy state */
err = mmc_sd_init_card(card, host);
if (err) {
goto out;
}
host->card = card;
#ifdef CONFIG_SD_PM
if (!card->suspend) {
mmc_attach_bus(host, &sd_bus_ops);
}
#endif
out:
return err;
}
void mmc_deattach_sd(struct mmc_card *card, struct mmc_host *host)
{
mmc_select_card(card, 0);
card->state &= ~MMC_STATE_HIGHSPEED;
#ifdef CONFIG_SD_PM
if (!card->suspend) {
mmc_detach_bus(host);
host->card = NULL;
}
#else
host->card = NULL;
#endif
}
#endif /* CONFIG_USE_SD */
View Git Blame Copy Permalink