mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-09-08 13:53:21 +09:00
![Tushar Behera](/assets/img/avatar_default.png)
MMC host controller requires a delay between every sdhci_send_cmd() execution. In s5p_mmc driver (s5p_sdhci replaces this driver), a delay of 1000us was provided after every mmc_send_cmd() call. Adding a quirk in current sdhci driver to replicate the behaviour. Without this delay, MMC initialization on Origen board fails with following error messages. Timeout for status update! mmc fail to send stop cmd Signed-off-by: Tushar Behera <tushar.behera@linaro.org> Signed-off-by: Jaehoon Chung <jh80.chung@samsung.com> Signed-off-by: Andy Fleming <afleming@freescale.com>
493 lines
12 KiB
C
493 lines
12 KiB
C
/*
|
|
* Copyright 2011, Marvell Semiconductor Inc.
|
|
* Lei Wen <leiwen@marvell.com>
|
|
*
|
|
* See file CREDITS for list of people who contributed to this
|
|
* project.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of
|
|
* the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
* MA 02111-1307 USA
|
|
*
|
|
* Back ported to the 8xx platform (from the 8260 platform) by
|
|
* Murray.Jensen@cmst.csiro.au, 27-Jan-01.
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <malloc.h>
|
|
#include <mmc.h>
|
|
#include <sdhci.h>
|
|
|
|
void *aligned_buffer;
|
|
|
|
static void sdhci_reset(struct sdhci_host *host, u8 mask)
|
|
{
|
|
unsigned long timeout;
|
|
|
|
/* Wait max 100 ms */
|
|
timeout = 100;
|
|
sdhci_writeb(host, mask, SDHCI_SOFTWARE_RESET);
|
|
while (sdhci_readb(host, SDHCI_SOFTWARE_RESET) & mask) {
|
|
if (timeout == 0) {
|
|
printf("Reset 0x%x never completed.\n", (int)mask);
|
|
return;
|
|
}
|
|
timeout--;
|
|
udelay(1000);
|
|
}
|
|
}
|
|
|
|
static void sdhci_cmd_done(struct sdhci_host *host, struct mmc_cmd *cmd)
|
|
{
|
|
int i;
|
|
if (cmd->resp_type & MMC_RSP_136) {
|
|
/* CRC is stripped so we need to do some shifting. */
|
|
for (i = 0; i < 4; i++) {
|
|
cmd->response[i] = sdhci_readl(host,
|
|
SDHCI_RESPONSE + (3-i)*4) << 8;
|
|
if (i != 3)
|
|
cmd->response[i] |= sdhci_readb(host,
|
|
SDHCI_RESPONSE + (3-i)*4-1);
|
|
}
|
|
} else {
|
|
cmd->response[0] = sdhci_readl(host, SDHCI_RESPONSE);
|
|
}
|
|
}
|
|
|
|
static void sdhci_transfer_pio(struct sdhci_host *host, struct mmc_data *data)
|
|
{
|
|
int i;
|
|
char *offs;
|
|
for (i = 0; i < data->blocksize; i += 4) {
|
|
offs = data->dest + i;
|
|
if (data->flags == MMC_DATA_READ)
|
|
*(u32 *)offs = sdhci_readl(host, SDHCI_BUFFER);
|
|
else
|
|
sdhci_writel(host, *(u32 *)offs, SDHCI_BUFFER);
|
|
}
|
|
}
|
|
|
|
static int sdhci_transfer_data(struct sdhci_host *host, struct mmc_data *data,
|
|
unsigned int start_addr)
|
|
{
|
|
unsigned int stat, rdy, mask, timeout, block = 0;
|
|
#ifdef CONFIG_MMC_SDMA
|
|
unsigned char ctrl;
|
|
ctrl = sdhci_readl(host, SDHCI_HOST_CONTROL);
|
|
ctrl &= ~SDHCI_CTRL_DMA_MASK;
|
|
ctrl |= SDHCI_CTRL_SDMA;
|
|
sdhci_writel(host, ctrl, SDHCI_HOST_CONTROL);
|
|
#endif
|
|
|
|
timeout = 1000000;
|
|
rdy = SDHCI_INT_SPACE_AVAIL | SDHCI_INT_DATA_AVAIL;
|
|
mask = SDHCI_DATA_AVAILABLE | SDHCI_SPACE_AVAILABLE;
|
|
do {
|
|
stat = sdhci_readl(host, SDHCI_INT_STATUS);
|
|
if (stat & SDHCI_INT_ERROR) {
|
|
printf("Error detected in status(0x%X)!\n", stat);
|
|
return -1;
|
|
}
|
|
if (stat & rdy) {
|
|
if (!(sdhci_readl(host, SDHCI_PRESENT_STATE) & mask))
|
|
continue;
|
|
sdhci_writel(host, rdy, SDHCI_INT_STATUS);
|
|
sdhci_transfer_pio(host, data);
|
|
data->dest += data->blocksize;
|
|
if (++block >= data->blocks)
|
|
break;
|
|
}
|
|
#ifdef CONFIG_MMC_SDMA
|
|
if (stat & SDHCI_INT_DMA_END) {
|
|
sdhci_writel(host, SDHCI_INT_DMA_END, SDHCI_INT_STATUS);
|
|
start_addr &= ~(SDHCI_DEFAULT_BOUNDARY_SIZE - 1);
|
|
start_addr += SDHCI_DEFAULT_BOUNDARY_SIZE;
|
|
sdhci_writel(host, start_addr, SDHCI_DMA_ADDRESS);
|
|
}
|
|
#endif
|
|
if (timeout-- > 0)
|
|
udelay(10);
|
|
else {
|
|
printf("Transfer data timeout\n");
|
|
return -1;
|
|
}
|
|
} while (!(stat & SDHCI_INT_DATA_END));
|
|
return 0;
|
|
}
|
|
|
|
int sdhci_send_command(struct mmc *mmc, struct mmc_cmd *cmd,
|
|
struct mmc_data *data)
|
|
{
|
|
struct sdhci_host *host = (struct sdhci_host *)mmc->priv;
|
|
unsigned int stat = 0;
|
|
int ret = 0;
|
|
int trans_bytes = 0, is_aligned = 1;
|
|
u32 mask, flags, mode;
|
|
unsigned int timeout, start_addr = 0;
|
|
unsigned int retry = 10000;
|
|
|
|
/* Wait max 10 ms */
|
|
timeout = 10;
|
|
|
|
sdhci_writel(host, SDHCI_INT_ALL_MASK, SDHCI_INT_STATUS);
|
|
mask = SDHCI_CMD_INHIBIT | SDHCI_DATA_INHIBIT;
|
|
|
|
/* We shouldn't wait for data inihibit for stop commands, even
|
|
though they might use busy signaling */
|
|
if (cmd->cmdidx == MMC_CMD_STOP_TRANSMISSION)
|
|
mask &= ~SDHCI_DATA_INHIBIT;
|
|
|
|
while (sdhci_readl(host, SDHCI_PRESENT_STATE) & mask) {
|
|
if (timeout == 0) {
|
|
printf("Controller never released inhibit bit(s).\n");
|
|
return COMM_ERR;
|
|
}
|
|
timeout--;
|
|
udelay(1000);
|
|
}
|
|
|
|
mask = SDHCI_INT_RESPONSE;
|
|
if (!(cmd->resp_type & MMC_RSP_PRESENT))
|
|
flags = SDHCI_CMD_RESP_NONE;
|
|
else if (cmd->resp_type & MMC_RSP_136)
|
|
flags = SDHCI_CMD_RESP_LONG;
|
|
else if (cmd->resp_type & MMC_RSP_BUSY) {
|
|
flags = SDHCI_CMD_RESP_SHORT_BUSY;
|
|
mask |= SDHCI_INT_DATA_END;
|
|
} else
|
|
flags = SDHCI_CMD_RESP_SHORT;
|
|
|
|
if (cmd->resp_type & MMC_RSP_CRC)
|
|
flags |= SDHCI_CMD_CRC;
|
|
if (cmd->resp_type & MMC_RSP_OPCODE)
|
|
flags |= SDHCI_CMD_INDEX;
|
|
if (data)
|
|
flags |= SDHCI_CMD_DATA;
|
|
|
|
/*Set Transfer mode regarding to data flag*/
|
|
if (data != 0) {
|
|
sdhci_writeb(host, 0xe, SDHCI_TIMEOUT_CONTROL);
|
|
mode = SDHCI_TRNS_BLK_CNT_EN;
|
|
trans_bytes = data->blocks * data->blocksize;
|
|
if (data->blocks > 1)
|
|
mode |= SDHCI_TRNS_MULTI;
|
|
|
|
if (data->flags == MMC_DATA_READ)
|
|
mode |= SDHCI_TRNS_READ;
|
|
|
|
#ifdef CONFIG_MMC_SDMA
|
|
if (data->flags == MMC_DATA_READ)
|
|
start_addr = (unsigned int)data->dest;
|
|
else
|
|
start_addr = (unsigned int)data->src;
|
|
if ((host->quirks & SDHCI_QUIRK_32BIT_DMA_ADDR) &&
|
|
(start_addr & 0x7) != 0x0) {
|
|
is_aligned = 0;
|
|
start_addr = (unsigned int)aligned_buffer;
|
|
if (data->flags != MMC_DATA_READ)
|
|
memcpy(aligned_buffer, data->src, trans_bytes);
|
|
}
|
|
|
|
sdhci_writel(host, start_addr, SDHCI_DMA_ADDRESS);
|
|
mode |= SDHCI_TRNS_DMA;
|
|
#endif
|
|
sdhci_writew(host, SDHCI_MAKE_BLKSZ(SDHCI_DEFAULT_BOUNDARY_ARG,
|
|
data->blocksize),
|
|
SDHCI_BLOCK_SIZE);
|
|
sdhci_writew(host, data->blocks, SDHCI_BLOCK_COUNT);
|
|
sdhci_writew(host, mode, SDHCI_TRANSFER_MODE);
|
|
}
|
|
|
|
sdhci_writel(host, cmd->cmdarg, SDHCI_ARGUMENT);
|
|
#ifdef CONFIG_MMC_SDMA
|
|
flush_cache(start_addr, trans_bytes);
|
|
#endif
|
|
sdhci_writew(host, SDHCI_MAKE_CMD(cmd->cmdidx, flags), SDHCI_COMMAND);
|
|
do {
|
|
stat = sdhci_readl(host, SDHCI_INT_STATUS);
|
|
if (stat & SDHCI_INT_ERROR)
|
|
break;
|
|
if (--retry == 0)
|
|
break;
|
|
} while ((stat & mask) != mask);
|
|
|
|
if (retry == 0) {
|
|
if (host->quirks & SDHCI_QUIRK_BROKEN_R1B)
|
|
return 0;
|
|
else {
|
|
printf("Timeout for status update!\n");
|
|
return TIMEOUT;
|
|
}
|
|
}
|
|
|
|
if ((stat & (SDHCI_INT_ERROR | mask)) == mask) {
|
|
sdhci_cmd_done(host, cmd);
|
|
sdhci_writel(host, mask, SDHCI_INT_STATUS);
|
|
} else
|
|
ret = -1;
|
|
|
|
if (!ret && data)
|
|
ret = sdhci_transfer_data(host, data, start_addr);
|
|
|
|
if (host->quirks & SDHCI_QUIRK_WAIT_SEND_CMD)
|
|
udelay(1000);
|
|
|
|
stat = sdhci_readl(host, SDHCI_INT_STATUS);
|
|
sdhci_writel(host, SDHCI_INT_ALL_MASK, SDHCI_INT_STATUS);
|
|
if (!ret) {
|
|
if ((host->quirks & SDHCI_QUIRK_32BIT_DMA_ADDR) &&
|
|
!is_aligned && (data->flags == MMC_DATA_READ))
|
|
memcpy(data->dest, aligned_buffer, trans_bytes);
|
|
return 0;
|
|
}
|
|
|
|
sdhci_reset(host, SDHCI_RESET_CMD);
|
|
sdhci_reset(host, SDHCI_RESET_DATA);
|
|
if (stat & SDHCI_INT_TIMEOUT)
|
|
return TIMEOUT;
|
|
else
|
|
return COMM_ERR;
|
|
}
|
|
|
|
static int sdhci_set_clock(struct mmc *mmc, unsigned int clock)
|
|
{
|
|
struct sdhci_host *host = (struct sdhci_host *)mmc->priv;
|
|
unsigned int div, clk, timeout;
|
|
|
|
sdhci_writew(host, 0, SDHCI_CLOCK_CONTROL);
|
|
|
|
if (clock == 0)
|
|
return 0;
|
|
|
|
if ((host->version & SDHCI_SPEC_VER_MASK) >= SDHCI_SPEC_300) {
|
|
/* Version 3.00 divisors must be a multiple of 2. */
|
|
if (mmc->f_max <= clock)
|
|
div = 1;
|
|
else {
|
|
for (div = 2; div < SDHCI_MAX_DIV_SPEC_300; div += 2) {
|
|
if ((mmc->f_max / div) <= clock)
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
/* Version 2.00 divisors must be a power of 2. */
|
|
for (div = 1; div < SDHCI_MAX_DIV_SPEC_200; div *= 2) {
|
|
if ((mmc->f_max / div) <= clock)
|
|
break;
|
|
}
|
|
}
|
|
div >>= 1;
|
|
|
|
if (host->set_clock)
|
|
host->set_clock(host->index, div);
|
|
|
|
clk = (div & SDHCI_DIV_MASK) << SDHCI_DIVIDER_SHIFT;
|
|
clk |= ((div & SDHCI_DIV_HI_MASK) >> SDHCI_DIV_MASK_LEN)
|
|
<< SDHCI_DIVIDER_HI_SHIFT;
|
|
clk |= SDHCI_CLOCK_INT_EN;
|
|
sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
|
|
|
|
/* Wait max 20 ms */
|
|
timeout = 20;
|
|
while (!((clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL))
|
|
& SDHCI_CLOCK_INT_STABLE)) {
|
|
if (timeout == 0) {
|
|
printf("Internal clock never stabilised.\n");
|
|
return -1;
|
|
}
|
|
timeout--;
|
|
udelay(1000);
|
|
}
|
|
|
|
clk |= SDHCI_CLOCK_CARD_EN;
|
|
sdhci_writew(host, clk, SDHCI_CLOCK_CONTROL);
|
|
return 0;
|
|
}
|
|
|
|
static void sdhci_set_power(struct sdhci_host *host, unsigned short power)
|
|
{
|
|
u8 pwr = 0;
|
|
|
|
if (power != (unsigned short)-1) {
|
|
switch (1 << power) {
|
|
case MMC_VDD_165_195:
|
|
pwr = SDHCI_POWER_180;
|
|
break;
|
|
case MMC_VDD_29_30:
|
|
case MMC_VDD_30_31:
|
|
pwr = SDHCI_POWER_300;
|
|
break;
|
|
case MMC_VDD_32_33:
|
|
case MMC_VDD_33_34:
|
|
pwr = SDHCI_POWER_330;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (pwr == 0) {
|
|
sdhci_writeb(host, 0, SDHCI_POWER_CONTROL);
|
|
return;
|
|
}
|
|
|
|
pwr |= SDHCI_POWER_ON;
|
|
|
|
sdhci_writeb(host, pwr, SDHCI_POWER_CONTROL);
|
|
}
|
|
|
|
void sdhci_set_ios(struct mmc *mmc)
|
|
{
|
|
u32 ctrl;
|
|
struct sdhci_host *host = (struct sdhci_host *)mmc->priv;
|
|
|
|
if (host->set_control_reg)
|
|
host->set_control_reg(host);
|
|
|
|
if (mmc->clock != host->clock)
|
|
sdhci_set_clock(mmc, mmc->clock);
|
|
|
|
/* Set bus width */
|
|
ctrl = sdhci_readb(host, SDHCI_HOST_CONTROL);
|
|
if (mmc->bus_width == 8) {
|
|
ctrl &= ~SDHCI_CTRL_4BITBUS;
|
|
if ((host->version & SDHCI_SPEC_VER_MASK) >= SDHCI_SPEC_300)
|
|
ctrl |= SDHCI_CTRL_8BITBUS;
|
|
} else {
|
|
if ((host->version & SDHCI_SPEC_VER_MASK) >= SDHCI_SPEC_300)
|
|
ctrl &= ~SDHCI_CTRL_8BITBUS;
|
|
if (mmc->bus_width == 4)
|
|
ctrl |= SDHCI_CTRL_4BITBUS;
|
|
else
|
|
ctrl &= ~SDHCI_CTRL_4BITBUS;
|
|
}
|
|
|
|
if (mmc->clock > 26000000)
|
|
ctrl |= SDHCI_CTRL_HISPD;
|
|
else
|
|
ctrl &= ~SDHCI_CTRL_HISPD;
|
|
|
|
if (host->quirks & SDHCI_QUIRK_NO_HISPD_BIT)
|
|
ctrl &= ~SDHCI_CTRL_HISPD;
|
|
|
|
sdhci_writeb(host, ctrl, SDHCI_HOST_CONTROL);
|
|
}
|
|
|
|
int sdhci_init(struct mmc *mmc)
|
|
{
|
|
struct sdhci_host *host = (struct sdhci_host *)mmc->priv;
|
|
|
|
if ((host->quirks & SDHCI_QUIRK_32BIT_DMA_ADDR) && !aligned_buffer) {
|
|
aligned_buffer = memalign(8, 512*1024);
|
|
if (!aligned_buffer) {
|
|
printf("Aligned buffer alloc failed!!!");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
sdhci_set_power(host, fls(mmc->voltages) - 1);
|
|
|
|
if (host->quirks & SDHCI_QUIRK_NO_CD) {
|
|
unsigned int status;
|
|
|
|
sdhci_writel(host, SDHCI_CTRL_CD_TEST_INS | SDHCI_CTRL_CD_TEST,
|
|
SDHCI_HOST_CONTROL);
|
|
|
|
status = sdhci_readl(host, SDHCI_PRESENT_STATE);
|
|
while ((!(status & SDHCI_CARD_PRESENT)) ||
|
|
(!(status & SDHCI_CARD_STATE_STABLE)) ||
|
|
(!(status & SDHCI_CARD_DETECT_PIN_LEVEL)))
|
|
status = sdhci_readl(host, SDHCI_PRESENT_STATE);
|
|
}
|
|
|
|
/* Eable all state */
|
|
sdhci_writel(host, SDHCI_INT_ALL_MASK, SDHCI_INT_ENABLE);
|
|
sdhci_writel(host, SDHCI_INT_ALL_MASK, SDHCI_SIGNAL_ENABLE);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int add_sdhci(struct sdhci_host *host, u32 max_clk, u32 min_clk)
|
|
{
|
|
struct mmc *mmc;
|
|
unsigned int caps;
|
|
|
|
mmc = malloc(sizeof(struct mmc));
|
|
if (!mmc) {
|
|
printf("mmc malloc fail!\n");
|
|
return -1;
|
|
}
|
|
|
|
mmc->priv = host;
|
|
host->mmc = mmc;
|
|
|
|
sprintf(mmc->name, "%s", host->name);
|
|
mmc->send_cmd = sdhci_send_command;
|
|
mmc->set_ios = sdhci_set_ios;
|
|
mmc->init = sdhci_init;
|
|
mmc->getcd = NULL;
|
|
|
|
caps = sdhci_readl(host, SDHCI_CAPABILITIES);
|
|
#ifdef CONFIG_MMC_SDMA
|
|
if (!(caps & SDHCI_CAN_DO_SDMA)) {
|
|
printf("Your controller don't support sdma!!\n");
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
if (max_clk)
|
|
mmc->f_max = max_clk;
|
|
else {
|
|
if ((host->version & SDHCI_SPEC_VER_MASK) >= SDHCI_SPEC_300)
|
|
mmc->f_max = (caps & SDHCI_CLOCK_V3_BASE_MASK)
|
|
>> SDHCI_CLOCK_BASE_SHIFT;
|
|
else
|
|
mmc->f_max = (caps & SDHCI_CLOCK_BASE_MASK)
|
|
>> SDHCI_CLOCK_BASE_SHIFT;
|
|
mmc->f_max *= 1000000;
|
|
}
|
|
if (mmc->f_max == 0) {
|
|
printf("Hardware doesn't specify base clock frequency\n");
|
|
return -1;
|
|
}
|
|
if (min_clk)
|
|
mmc->f_min = min_clk;
|
|
else {
|
|
if ((host->version & SDHCI_SPEC_VER_MASK) >= SDHCI_SPEC_300)
|
|
mmc->f_min = mmc->f_max / SDHCI_MAX_DIV_SPEC_300;
|
|
else
|
|
mmc->f_min = mmc->f_max / SDHCI_MAX_DIV_SPEC_200;
|
|
}
|
|
|
|
mmc->voltages = 0;
|
|
if (caps & SDHCI_CAN_VDD_330)
|
|
mmc->voltages |= MMC_VDD_32_33 | MMC_VDD_33_34;
|
|
if (caps & SDHCI_CAN_VDD_300)
|
|
mmc->voltages |= MMC_VDD_29_30 | MMC_VDD_30_31;
|
|
if (caps & SDHCI_CAN_VDD_180)
|
|
mmc->voltages |= MMC_VDD_165_195;
|
|
|
|
if (host->quirks & SDHCI_QUIRK_BROKEN_VOLTAGE)
|
|
mmc->voltages |= host->voltages;
|
|
|
|
mmc->host_caps = MMC_MODE_HS | MMC_MODE_HS_52MHz | MMC_MODE_4BIT;
|
|
if (caps & SDHCI_CAN_DO_8BIT)
|
|
mmc->host_caps |= MMC_MODE_8BIT;
|
|
if (host->host_caps)
|
|
mmc->host_caps |= host->host_caps;
|
|
|
|
sdhci_reset(host, SDHCI_RESET_ALL);
|
|
mmc_register(mmc);
|
|
|
|
return 0;
|
|
}
|