|
@@ -24,7 +24,8 @@ static void sdhci_reset(struct sdhci_host *host, u8 mask)
|
|
sdhci_writeb(host, mask, SDHCI_SOFTWARE_RESET);
|
|
sdhci_writeb(host, mask, SDHCI_SOFTWARE_RESET);
|
|
while (sdhci_readb(host, SDHCI_SOFTWARE_RESET) & mask) {
|
|
while (sdhci_readb(host, SDHCI_SOFTWARE_RESET) & mask) {
|
|
if (timeout == 0) {
|
|
if (timeout == 0) {
|
|
- printf("Reset 0x%x never completed.\n", (int)mask);
|
|
|
|
|
|
+ printf("%s: Reset 0x%x never completed.\n",
|
|
|
|
+ __func__, (int)mask);
|
|
return;
|
|
return;
|
|
}
|
|
}
|
|
timeout--;
|
|
timeout--;
|
|
@@ -79,7 +80,8 @@ static int sdhci_transfer_data(struct sdhci_host *host, struct mmc_data *data,
|
|
do {
|
|
do {
|
|
stat = sdhci_readl(host, SDHCI_INT_STATUS);
|
|
stat = sdhci_readl(host, SDHCI_INT_STATUS);
|
|
if (stat & SDHCI_INT_ERROR) {
|
|
if (stat & SDHCI_INT_ERROR) {
|
|
- printf("Error detected in status(0x%X)!\n", stat);
|
|
|
|
|
|
+ printf("%s: Error detected in status(0x%X)!\n",
|
|
|
|
+ __func__, stat);
|
|
return -1;
|
|
return -1;
|
|
}
|
|
}
|
|
if (stat & rdy) {
|
|
if (stat & rdy) {
|
|
@@ -102,7 +104,7 @@ static int sdhci_transfer_data(struct sdhci_host *host, struct mmc_data *data,
|
|
if (timeout-- > 0)
|
|
if (timeout-- > 0)
|
|
udelay(10);
|
|
udelay(10);
|
|
else {
|
|
else {
|
|
- printf("Transfer data timeout\n");
|
|
|
|
|
|
+ printf("%s: Transfer data timeout\n", __func__);
|
|
return -1;
|
|
return -1;
|
|
}
|
|
}
|
|
} while (!(stat & SDHCI_INT_DATA_END));
|
|
} while (!(stat & SDHCI_INT_DATA_END));
|
|
@@ -147,7 +149,7 @@ int sdhci_send_command(struct mmc *mmc, struct mmc_cmd *cmd,
|
|
|
|
|
|
while (sdhci_readl(host, SDHCI_PRESENT_STATE) & mask) {
|
|
while (sdhci_readl(host, SDHCI_PRESENT_STATE) & mask) {
|
|
if (time >= cmd_timeout) {
|
|
if (time >= cmd_timeout) {
|
|
- printf("MMC: %d busy ", mmc_dev);
|
|
|
|
|
|
+ printf("%s: MMC: %d busy ", __func__, mmc_dev);
|
|
if (2 * cmd_timeout <= CONFIG_SDHCI_CMD_MAX_TIMEOUT) {
|
|
if (2 * cmd_timeout <= CONFIG_SDHCI_CMD_MAX_TIMEOUT) {
|
|
cmd_timeout += cmd_timeout;
|
|
cmd_timeout += cmd_timeout;
|
|
printf("timeout increasing to: %u ms.\n",
|
|
printf("timeout increasing to: %u ms.\n",
|
|
@@ -179,7 +181,7 @@ int sdhci_send_command(struct mmc *mmc, struct mmc_cmd *cmd,
|
|
if (data)
|
|
if (data)
|
|
flags |= SDHCI_CMD_DATA;
|
|
flags |= SDHCI_CMD_DATA;
|
|
|
|
|
|
- /*Set Transfer mode regarding to data flag*/
|
|
|
|
|
|
+ /* Set Transfer mode regarding to data flag */
|
|
if (data != 0) {
|
|
if (data != 0) {
|
|
sdhci_writeb(host, 0xe, SDHCI_TIMEOUT_CONTROL);
|
|
sdhci_writeb(host, 0xe, SDHCI_TIMEOUT_CONTROL);
|
|
mode = SDHCI_TRNS_BLK_CNT_EN;
|
|
mode = SDHCI_TRNS_BLK_CNT_EN;
|
|
@@ -230,7 +232,7 @@ int sdhci_send_command(struct mmc *mmc, struct mmc_cmd *cmd,
|
|
if (host->quirks & SDHCI_QUIRK_BROKEN_R1B)
|
|
if (host->quirks & SDHCI_QUIRK_BROKEN_R1B)
|
|
return 0;
|
|
return 0;
|
|
else {
|
|
else {
|
|
- printf("Timeout for status update!\n");
|
|
|
|
|
|
+ printf("%s: Timeout for status update!\n", __func__);
|
|
return TIMEOUT;
|
|
return TIMEOUT;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
@@ -307,7 +309,8 @@ static int sdhci_set_clock(struct mmc *mmc, unsigned int clock)
|
|
while (!((clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL))
|
|
while (!((clk = sdhci_readw(host, SDHCI_CLOCK_CONTROL))
|
|
& SDHCI_CLOCK_INT_STABLE)) {
|
|
& SDHCI_CLOCK_INT_STABLE)) {
|
|
if (timeout == 0) {
|
|
if (timeout == 0) {
|
|
- printf("Internal clock never stabilised.\n");
|
|
|
|
|
|
+ printf("%s: Internal clock never stabilised.\n",
|
|
|
|
+ __func__);
|
|
return -1;
|
|
return -1;
|
|
}
|
|
}
|
|
timeout--;
|
|
timeout--;
|
|
@@ -397,7 +400,8 @@ int sdhci_init(struct mmc *mmc)
|
|
if ((host->quirks & SDHCI_QUIRK_32BIT_DMA_ADDR) && !aligned_buffer) {
|
|
if ((host->quirks & SDHCI_QUIRK_32BIT_DMA_ADDR) && !aligned_buffer) {
|
|
aligned_buffer = memalign(8, 512*1024);
|
|
aligned_buffer = memalign(8, 512*1024);
|
|
if (!aligned_buffer) {
|
|
if (!aligned_buffer) {
|
|
- printf("Aligned buffer alloc failed!!!");
|
|
|
|
|
|
+ printf("%s: Aligned buffer alloc failed!!!\n",
|
|
|
|
+ __func__);
|
|
return -1;
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
@@ -418,8 +422,8 @@ int sdhci_init(struct mmc *mmc)
|
|
}
|
|
}
|
|
|
|
|
|
/* Enable only interrupts served by the SD controller */
|
|
/* Enable only interrupts served by the SD controller */
|
|
- sdhci_writel(host, SDHCI_INT_DATA_MASK | SDHCI_INT_CMD_MASK
|
|
|
|
- , SDHCI_INT_ENABLE);
|
|
|
|
|
|
+ sdhci_writel(host, SDHCI_INT_DATA_MASK | SDHCI_INT_CMD_MASK,
|
|
|
|
+ SDHCI_INT_ENABLE);
|
|
/* Mask all sdhci interrupt sources */
|
|
/* Mask all sdhci interrupt sources */
|
|
sdhci_writel(host, 0x0, SDHCI_SIGNAL_ENABLE);
|
|
sdhci_writel(host, 0x0, SDHCI_SIGNAL_ENABLE);
|
|
|
|
|
|
@@ -433,7 +437,7 @@ int add_sdhci(struct sdhci_host *host, u32 max_clk, u32 min_clk)
|
|
|
|
|
|
mmc = malloc(sizeof(struct mmc));
|
|
mmc = malloc(sizeof(struct mmc));
|
|
if (!mmc) {
|
|
if (!mmc) {
|
|
- printf("mmc malloc fail!\n");
|
|
|
|
|
|
+ printf("%s: mmc malloc fail!\n", __func__);
|
|
return -1;
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
|
|
@@ -450,7 +454,8 @@ int add_sdhci(struct sdhci_host *host, u32 max_clk, u32 min_clk)
|
|
caps = sdhci_readl(host, SDHCI_CAPABILITIES);
|
|
caps = sdhci_readl(host, SDHCI_CAPABILITIES);
|
|
#ifdef CONFIG_MMC_SDMA
|
|
#ifdef CONFIG_MMC_SDMA
|
|
if (!(caps & SDHCI_CAN_DO_SDMA)) {
|
|
if (!(caps & SDHCI_CAN_DO_SDMA)) {
|
|
- printf("Your controller don't support sdma!!\n");
|
|
|
|
|
|
+ printf("%s: Your controller doesn't support SDMA!!\n",
|
|
|
|
+ __func__);
|
|
return -1;
|
|
return -1;
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
@@ -467,7 +472,8 @@ int add_sdhci(struct sdhci_host *host, u32 max_clk, u32 min_clk)
|
|
mmc->f_max *= 1000000;
|
|
mmc->f_max *= 1000000;
|
|
}
|
|
}
|
|
if (mmc->f_max == 0) {
|
|
if (mmc->f_max == 0) {
|
|
- printf("Hardware doesn't specify base clock frequency\n");
|
|
|
|
|
|
+ printf("%s: Hardware doesn't specify base clock frequency\n",
|
|
|
|
+ __func__);
|
|
return -1;
|
|
return -1;
|
|
}
|
|
}
|
|
if (min_clk)
|
|
if (min_clk)
|