/*
* NOTE: void *buf, caller for the buf is required to use DMA-capable
* buffer or on-stack buffer (with some overhead in callee).
*/
static int
mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host,
u32 opcode, void *buf, unsigned len)
{
struct mmc_request mrq = {NULL};
struct mmc_command cmd = {0};
struct mmc_data data = {0};
struct scatterlist sg;
void *data_buf;
int is_on_stack;
is_on_stack = object_is_on_stack(buf);
if (is_on_stack) {
/*
* dma onto stack is unsafe/nonportable, but callers to this
* routine normally provide temporary on-stack buffers ...
*/
data_buf = kmalloc(len, GFP_KERNEL);
if (!data_buf)
return -ENOMEM;
} else
data_buf = buf;
mrq.cmd = &cmd;
mrq.data = &data;
cmd.opcode = opcode;
cmd.arg = 0;
/* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we
* rely on callers to never use this with "native" calls for reading
* CSD or CID. Native versions of those commands use the R2 type,
* not R1 plus a data block.
*/
cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
data.blksz = len;
data.blocks = 1;
data.flags = MMC_DATA_READ;
data.sg = &sg;
data.sg_len = 1;
sg_init_one(&sg, data_buf, len);
if (opcode == MMC_SEND_CSD || opcode == MMC_SEND_CID) {
/*
* The spec states that CSR and CID accesses have a timeout
* of 64 clock cycles.
*/
data.timeout_ns = 0;
data.timeout_clks = 64;
} else
mmc_set_data_timeout(&data, card);
mmc_wait_for_req(host, &mrq);
if (is_on_stack) {
memcpy(buf, data_buf, len);
kfree(data_buf);
}
#ifdef CONFIG_HUAWEI_EMMC_DSM
if(cmd.error || data.error)
if(!strcmp(mmc_hostname(host), "mmc0")){
DSM_EMMC_LOG(card, DSM_EMMC_SEND_CXD_ERR,
"opcode:%d failed, cmd.error:%d, data.error:%d\n",
opcode, cmd.error, data.error);
}
#endif
if (cmd.error)
return cmd.error;
if (data.error)
return data.error;
return 0;
}
/* By tuning, find the best timing condition
* 1 -- tuning is not finished. And this function should be called again
* 0 -- Tuning successfully.
* If this function be called again, another round of tuning would be start
* -1 -- Tuning failed. Maybe slow down the clock and call this function again
*/
static int dw_mci_hs_tuning_find_condition(struct dw_mci *host, int timing)
{
struct dw_mci_hs_priv_data *priv = host->priv;
int id = priv->id;
int sample_min, sample_max;
int i, j;
int ret = 0;
int mask, mask_lenth;
int d_value = 0;
if (host->hw_mmc_id == DWMMC_SD_ID) {
d_value = host->current_div - hs_timing_config[id][timing][1];
if (timing == MMC_TIMING_SD_HS) {
sample_max = hs_timing_config[id][timing][4] + d_value;
sample_min = hs_timing_config[id][timing][5] + d_value;
} else if ((timing == MMC_TIMING_UHS_SDR50) ||
(timing == MMC_TIMING_UHS_SDR104)) {
sample_max =
hs_timing_config[id][timing][4] + 2 * d_value;
sample_min = hs_timing_config[id][timing][5];
} else {
sample_max = hs_timing_config[id][timing][4];
sample_min = hs_timing_config[id][timing][5];
}
} else {
sample_max = hs_timing_config[id][timing][4];
sample_min = hs_timing_config[id][timing][5];
}
if (sample_max == sample_min) {
host->tuning_init_sample = (sample_max + sample_min) / 2;
dw_mci_hs_set_timing(host, id, timing, host->tuning_init_sample,
host->current_div);
dev_info(host->dev,
"no need tuning: timing is %d, tuning sample = %d",
timing, host->tuning_init_sample);
return 0;
}
if (-1 == host->tuning_current_sample) {
dw_mci_hs_tuning_clear_flags(host);
/* set the first sam del as the min_sam_del */
host->tuning_current_sample = sample_min;
/* a trick for next "++" */
host->tuning_current_sample--;
}
if (host->tuning_current_sample >= sample_max) {
/* tuning finish, select the best sam_del */
/* set sam del to -1, for next tuning */
host->tuning_current_sample = -1;
host->tuning_init_sample = -1;
for (mask_lenth = (((sample_max - sample_min) >> 1) << 1) + 1;
mask_lenth >= 1; mask_lenth -= 2) {
mask = (1 << mask_lenth) - 1;
for (i = (sample_min + sample_max - mask_lenth + 1) / 2,
j = 1;
(i <= sample_max - mask_lenth + 1) &&
(i >= sample_min);
i = ((sample_min + sample_max - mask_lenth + 1) /
2) +
((j % 2) ? -1 : 1) * (j / 2)) {
if ((host->tuning_sample_flag & (mask << i)) ==
(mask << i)) {
host->tuning_init_sample =
i + mask_lenth / 2;
break;
}
j++;
}
if (host->tuning_init_sample != -1) {
if ((host->hw_mmc_id == DWMMC_SD_ID) &&
(mask_lenth < 3)) {
dev_info(host->dev,
"sd card tuning need slow "
"down clk, timing is %d, "
"tuning_flag = 0x%x \n",
timing,
host->tuning_sample_flag);
return -1;
} else {
dev_info(
host->dev, "tuning OK: timing is "
"%d, tuning sample = "
"%d, tuning_flag = 0x%x",
timing, host->tuning_init_sample,
host->tuning_sample_flag);
ret = 0;
break;
}
}
}
if (-1 == host->tuning_init_sample) {
host->tuning_init_sample =
(sample_min + sample_max) / 2;
dev_info(host->dev, "tuning err: no good sam_del, "
"timing is %d, tuning_flag = 0x%x",
timing, host->tuning_sample_flag);
#ifdef CONFIG_HUAWEI_EMMC_DSM
if (host->hw_mmc_id == DWMMC_EMMC_ID) {
DSM_EMMC_LOG(host->cur_slot->mmc, DSM_EMMC_TUNING_ERROR,
"%s:eMMC tuning error: timing is %d, tuning_flag = 0x%x\n", __FUNCTION__, timing, host->tuning_sample_flag);
}
#endif
ret = -1;
}
dw_mci_hs_set_timing(host, id, timing, host->tuning_init_sample,
host->current_div);
return ret;
} else {