From 27433715e3765e64a5de35a2ee6020da1848877c Mon Sep 17 00:00:00 2001 From: SamulKyull Date: Sun, 16 Jun 2024 19:30:00 +0800 Subject: [PATCH] [driver] fix tm4 timing data --- board/avaota-a1/board.c | 6 +- include/drivers/mmc/sys-mmc.h | 18 ++-- include/drivers/mmc/sys-sdcard.h | 31 ++++-- src/drivers/mmc/sys-mmc.c | 172 ++++++++++++++++--------------- src/drivers/mmc/sys-sdcard.c | 29 +++++- src/drivers/mmc/sys-sdhci.c | 131 ++++++++++++----------- 6 files changed, 217 insertions(+), 170 deletions(-) diff --git a/board/avaota-a1/board.c b/board/avaota-a1/board.c index be3a28de..4d00348e 100644 --- a/board/avaota-a1/board.c +++ b/board/avaota-a1/board.c @@ -58,8 +58,8 @@ sunxi_sdhci_t sdhci0 = { .clk_ctrl_base = CCU_BASE + CCU_SMHC_BGR_REG, .clk_base = CCU_BASE + CCU_SMHC0_CLK_REG, .sdhci_mmc_type = MMC_TYPE_SD, - .max_clk = 200 * 1000 * 1000, - .width = SMHC_WIDTH_4BIT, + .max_clk = MMC_CLK_50M, + .width = 50000000, .dma_des_addr = SDRAM_BASE + 0x30080000, .pinctrl = { .gpio_clk = {GPIO_PIN(GPIO_PORTF, 2), GPIO_PERIPH_MUX2}, @@ -80,7 +80,7 @@ sunxi_sdhci_t sdhci2 = { .clk_ctrl_base = CCU_BASE + CCU_SMHC_BGR_REG, .clk_base = CCU_BASE + CCU_SMHC2_CLK_REG, .sdhci_mmc_type = MMC_TYPE_EMMC, - .max_clk = 25 * 1000 * 1000, + .max_clk = 25000000, .width = SMHC_WIDTH_8BIT, .dma_des_addr = SDRAM_BASE + 0x30080000, .pinctrl = { diff --git a/include/drivers/mmc/sys-mmc.h b/include/drivers/mmc/sys-mmc.h index 70bf7dab..a4ba910f 100644 --- a/include/drivers/mmc/sys-mmc.h +++ b/include/drivers/mmc/sys-mmc.h @@ -378,20 +378,20 @@ typedef struct mmc { int sunxi_mmc_init(void *sdhci_hdl); /** - * @brief Reads blocks from the SD/MMC card. + * @brief Read blocks from the Sunxi MMC block device * - * This function reads blocks from the SD/MMC card starting from the specified block address. - * It supports reading multiple blocks and handles high capacity cards appropriately. + * This function reads a specified number of blocks from the Sunxi MMC block device + * and stores the data into the destination buffer. * - * @param sdhci Pointer to the SDHCI controller structure. - * @param dst Pointer to the destination buffer where the data will be stored. - * @param start Start block address from where to read the data. - * @param blkcnt Number of blocks to read. - * @return Number of blocks read on success, 0 otherwise. + * @param sdhci Pointer to the Sunxi SD Host Controller instance + * @param dst Pointer to the destination buffer where the read data will be stored + * @param start The starting block number to read from + * @param blkcnt The number of blocks to read + * + * @return Returns 0 on success, or an error code if the operation fails */ uint32_t sunxi_mmc_blk_read(void *sdhci, void *dst, uint32_t start, uint32_t blkcnt); - #ifdef __cplusplus } #endif// __cplusplus diff --git a/include/drivers/mmc/sys-sdcard.h b/include/drivers/mmc/sys-sdcard.h index 5e9a33d5..70e15084 100644 --- a/include/drivers/mmc/sys-sdcard.h +++ b/include/drivers/mmc/sys-sdcard.h @@ -28,22 +28,33 @@ typedef struct { extern sdmmc_pdata_t card0; /** - * Initialize the SDMMC controller with the specified platform data and SDHCI driver. + * @brief Initialize the SD/MMC interface * - * @param data Pointer to the SDMMC platform data structure. - * @param hci Pointer to the SDHCI driver instance. - * @return 0 if successful, or an error code if failed. + * Initializes the SD/MMC interface using the provided data structure and SD Host Controller instance. + * It sets the SD Host Controller instance and the online status in the data structure, and then initializes + * the MMC device. If the initialization is successful, it prints a message indicating the type of card detected + * and returns 0; otherwise, it returns -1. + * + * @param data Pointer to the SD/MMC platform data structure + * @param hci Pointer to the Sunxi SD Host Controller instance + * + * @return Returns 0 on success, or -1 if the initialization fails */ int sdmmc_init(sdmmc_pdata_t *data, sunxi_sdhci_t *hci); /** - * Read data from the SDMMC card into the provided buffer. + * @brief Read blocks from the SD/MMC device + * + * Reads a specified number of blocks from the SD/MMC device using the provided platform data structure, + * destination buffer, block number, and block count. It calls the underlying function for reading blocks + * from the Sunxi MMC block device and returns the result. + * + * @param data Pointer to the SD/MMC platform data structure + * @param buf Pointer to the destination buffer where the read data will be stored + * @param blkno The starting block number to read from + * @param blkcnt The number of blocks to read * - * @param data Pointer to the SDMMC platform data structure. - * @param buf Pointer to the destination buffer to store the read data. - * @param blkno The starting block number to read from. - * @param blkcnt The number of blocks to read. - * @return The total number of bytes read, or an error code if failed. + * @return Returns 0 on success, or an error code if the operation fails */ uint32_t sdmmc_blk_read(sdmmc_pdata_t *data, uint8_t *buf, uint32_t blkno, uint32_t blkcnt); diff --git a/src/drivers/mmc/sys-mmc.c b/src/drivers/mmc/sys-mmc.c index 8edf99a8..7b3cea0b 100644 --- a/src/drivers/mmc/sys-mmc.c +++ b/src/drivers/mmc/sys-mmc.c @@ -187,19 +187,19 @@ static int sunxi_mmc_send_status(sunxi_sdhci_t *sdhci, uint32_t timeout) { do { err = sunxi_sdhci_xfer(sdhci, &cmd, NULL); if (err) { - printk_error("SMHC%u: Send status failed\n", sdhci->id); + printk_warning("SMHC%u: Send status failed\n", sdhci->id); return err; } else if (cmd.response[0] & MMC_STATUS_RDY_FOR_DATA) break; mdelay(1); if (cmd.response[0] & MMC_STATUS_MASK) { - printk_error("SMHC%u: Status Error: 0x%08X\n", sdhci->id, cmd.response[0]); + printk_warning("SMHC%u: Status Error: 0x%08X\n", sdhci->id, cmd.response[0]); return COMM_ERR; } } while (timeout--); if (!timeout) { - printk_error("SMHC%u: Timeout waiting card ready\n", sdhci->id); + printk_warning("SMHC%u: Timeout waiting card ready\n", sdhci->id); return TIMEOUT; } @@ -269,7 +269,7 @@ static uint32_t sunxi_mmc_read_blocks(sunxi_sdhci_t *sdhci, void *dst, uint32_t data.flags = MMC_DATA_READ; if (sunxi_sdhci_xfer(sdhci, &cmd, &data)) { - printk_error("SMHC: read block failed\n"); + printk_warning("SMHC: read block failed\n"); return 0; } @@ -279,7 +279,7 @@ static uint32_t sunxi_mmc_read_blocks(sunxi_sdhci_t *sdhci, void *dst, uint32_t cmd.resp_type = MMC_RSP_R1b; cmd.flags = 0; if (sunxi_sdhci_xfer(sdhci, &cmd, NULL)) { - printk_error("SMHC: failed to send stop command\n"); + printk_warning("SMHC: failed to send stop command\n"); return 0; } @@ -312,7 +312,7 @@ static int sunxi_mmc_go_idle(sunxi_sdhci_t *sdhci) { err = sunxi_sdhci_xfer(sdhci, &cmd, NULL); if (err) { - printk_error("SMHC: idle failed\n"); + printk_warning("SMHC: idle failed\n"); return err; } mdelay(2); @@ -347,7 +347,7 @@ static int sunxi_mmc_sd_send_op_cond(sunxi_sdhci_t *sdhci) { err = sunxi_sdhci_xfer(sdhci, &cmd, NULL); if (err) { - printk_error("SMHC: send app cmd failed\n"); + printk_warning("SMHC: send app cmd failed\n"); return err; } @@ -365,7 +365,7 @@ static int sunxi_mmc_sd_send_op_cond(sunxi_sdhci_t *sdhci) { err = sunxi_sdhci_xfer(sdhci, &cmd, NULL); if (err) { - printk_error("SMHC: send cmd41 failed\n"); + printk_warning("SMHC: send cmd41 failed\n"); return err; } @@ -374,7 +374,7 @@ static int sunxi_mmc_sd_send_op_cond(sunxi_sdhci_t *sdhci) { } while ((!(cmd.response[0] & OCR_BUSY)) && timeout--);// Wait for card initialization and decrement timeout if (timeout <= 0) { - printk_error("SMHC: wait card init failed\n"); + printk_warning("SMHC: wait card init failed\n"); return UNUSABLE_ERR; } @@ -393,7 +393,7 @@ static int sunxi_mmc_sd_send_op_cond(sunxi_sdhci_t *sdhci) { err = sunxi_sdhci_xfer(sdhci, &cmd, NULL); if (err) { - printk_error("SMHC: spi read ocr failed\n"); + printk_warning("SMHC: spi read ocr failed\n"); return err; } } @@ -440,7 +440,7 @@ static int sunxi_mmc_mmc_send_op_cond(sunxi_sdhci_t *sdhci) { // Send command to check card capabilities err = sunxi_sdhci_xfer(sdhci, &cmd, NULL); if (err) { - printk_error("SMHC: send op cond failed\n"); + printk_warning("SMHC: send op cond failed\n"); return err; } @@ -460,7 +460,7 @@ static int sunxi_mmc_mmc_send_op_cond(sunxi_sdhci_t *sdhci) { // Send command to check card capabilities err = sunxi_sdhci_xfer(sdhci, &cmd, NULL); if (err) { - printk_error("SMHC: send op cond failed\n"); + printk_warning("SMHC: send op cond failed\n"); return err; } @@ -469,7 +469,7 @@ static int sunxi_mmc_mmc_send_op_cond(sunxi_sdhci_t *sdhci) { } while (!(cmd.response[0] & OCR_BUSY) && timeout--);// Wait for card initialization and decrement timeout if (timeout <= 0) { - printk_error("SMHC: wait for mmc init failed\n"); + printk_warning("SMHC: wait for mmc init failed\n"); return UNUSABLE_ERR;// Indicate failure to initialize the card within the timeout } @@ -532,7 +532,7 @@ static int sunxi_mmc_send_ext_csd(sunxi_sdhci_t *sdhci, char *ext_csd) { err = sunxi_sdhci_xfer(sdhci, &cmd, &data); if (err) - printk_error("SMHC: send ext csd failed\n"); + printk_warning("SMHC: send ext csd failed\n"); return err;// Return the error code (0 if successful) } @@ -569,14 +569,14 @@ static int sunxi_mmc_switch(sunxi_sdhci_t *sdhci, uint8_t set, uint8_t index, ui // Send the SWITCH command to the card ret = sunxi_sdhci_xfer(sdhci, &cmd, NULL); if (ret) { - printk_error("SMHC: switch failed\n"); + printk_warning("SMHC: switch failed\n"); } /* for re-update sample phase */ // Update clock phase after sending command 6 ret = sunxi_sdhci_update_phase(sdhci); if (ret) { - printk_error("SMHC: update clock failed after send cmd6\n"); + printk_warning("SMHC: update clock failed after send cmd6\n"); return ret; } @@ -624,7 +624,7 @@ static int sunxi_mmc_mmc_change_freq(sunxi_sdhci_t *sdhci) { // Get the extended CSD data from the card err = sunxi_mmc_send_ext_csd(sdhci, ext_csd); if (err) { - printk_error("SMHC: get ext csd failed\n"); + printk_warning("SMHC: get ext csd failed\n"); return err; } @@ -640,14 +640,14 @@ static int sunxi_mmc_mmc_change_freq(sunxi_sdhci_t *sdhci) { } while (retry--); if (err) { - printk_error("SMHC: change to hs failed\n"); + printk_warning("SMHC: change to hs failed\n"); return err; } // Check if the frequency change was successful err = sunxi_mmc_send_ext_csd(sdhci, ext_csd); if (err) { - printk_error("SMHC: send ext csd faild\n"); + printk_warning("SMHC: send ext csd faild\n"); return err; } @@ -751,7 +751,7 @@ static int sunxi_mmc_sd_change_freq(sunxi_sdhci_t *sdhci) { err = sunxi_sdhci_xfer(sdhci, &cmd, NULL); if (err) { - printk_error("SMHC: Send app cmd failed\n"); + printk_warning("SMHC: Send app cmd failed\n"); return err; } @@ -773,7 +773,7 @@ static int sunxi_mmc_sd_change_freq(sunxi_sdhci_t *sdhci) { if (err) { if (timeout--) goto retry_scr; - printk_error("SMHC: Send scr failed\n"); + printk_warning("SMHC: Send scr failed\n"); return err; } @@ -807,7 +807,7 @@ static int sunxi_mmc_sd_change_freq(sunxi_sdhci_t *sdhci) { err = sunxi_mmc_sd_switch(sdhci, SD_SWITCH_CHECK, 0, 1, (uint8_t *) &switch_status); if (err) { - printk_error("SMHC: Check high speed status faild\n"); + printk_warning("SMHC: Check high speed status faild\n"); return err; } @@ -823,13 +823,13 @@ static int sunxi_mmc_sd_change_freq(sunxi_sdhci_t *sdhci) { err = sunxi_mmc_sd_switch(sdhci, SD_SWITCH_SWITCH, 0, 1, (uint8_t *) &switch_status); if (err) { - printk_error("SMHC: switch to high speed failed\n"); + printk_warning("SMHC: switch to high speed failed\n"); return err; } err = sunxi_sdhci_update_phase(sdhci); if (err) { - printk_error("SMHC: update clock failed after send cmd6 to switch to sd high speed mode\n"); + printk_warning("SMHC: update clock failed after send cmd6 to switch to sd high speed mode\n"); return err; } @@ -939,7 +939,7 @@ static int sunxi_mmc_mmc_switch_ds(sunxi_sdhci_t *sdhci) { // Check if card supports DS mode if (!(mmc->card_caps && MMC_MODE_HS)) { - printk_error("SMHC: Card does not support DS mode\n"); + printk_warning("SMHC: Card does not support DS mode\n"); return -1; } @@ -947,7 +947,7 @@ static int sunxi_mmc_mmc_switch_ds(sunxi_sdhci_t *sdhci) { err = sunxi_mmc_switch(sdhci, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, EXT_CSD_TIMING_BC); if (err) { - printk_error("SMHC: Failed to change to DS mode\n"); + printk_warning("SMHC: Failed to change to DS mode\n"); return err; } @@ -976,7 +976,7 @@ static int sunxi_mmc_mmc_switch_hs(sunxi_sdhci_t *sdhci) { // Check if card supports HS mode if (!(mmc->card_caps && MMC_MODE_HS_52MHz)) { - printk_error("SMHC: Card does not support HS mode\n"); + printk_warning("SMHC: Card does not support HS mode\n"); return -1; } @@ -984,7 +984,7 @@ static int sunxi_mmc_mmc_switch_hs(sunxi_sdhci_t *sdhci) { err = sunxi_mmc_switch(sdhci, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS); if (err) { - printk_error("SMHC: Failed to change to HS mode\n"); + printk_warning("SMHC: Failed to change to HS mode\n"); return err; } @@ -1013,7 +1013,7 @@ static int sunxi_mmc_mmc_switch_hs200(sunxi_sdhci_t *sdhci) { // Check if card supports HS200 mode if (!(mmc->card_caps && MMC_MODE_HS200)) { - printk_error("SMHC: Card does not support HS200 mode\n"); + printk_warning("SMHC: Card does not support HS200 mode\n"); return -1; } @@ -1021,7 +1021,7 @@ static int sunxi_mmc_mmc_switch_hs200(sunxi_sdhci_t *sdhci) { err = sunxi_mmc_switch(sdhci, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS200); if (err) { - printk_error("SMHC: Failed to change to HS200 mode\n"); + printk_warning("SMHC: Failed to change to HS200 mode\n"); return err; } @@ -1050,7 +1050,7 @@ static int sunxi_mmc_mmc_switch_hs400(sunxi_sdhci_t *sdhci) { // Check if card supports HS400 mode if (!(mmc->card_caps && MMC_MODE_HS400)) { - printk_error("SMHC: Card does not support HS400 mode\n"); + printk_warning("SMHC: Card does not support HS400 mode\n"); return -1; } @@ -1058,7 +1058,7 @@ static int sunxi_mmc_mmc_switch_hs400(sunxi_sdhci_t *sdhci) { err = sunxi_mmc_switch(sdhci, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS400); if (err) { - printk_error("SMHC: Failed to change to HS400 mode\n"); + printk_warning("SMHC: Failed to change to HS400 mode\n"); return err; } @@ -1173,7 +1173,7 @@ static int sunxi_mmc_mmc_switch_bus_width(sunxi_sdhci_t *sdhci, uint32_t spd_mod err = sunxi_mmc_check_bus_width(sdhci, emmc_hs_ddr, width); if (err) { - printk_error("SMHC: bus witdh param error.\n"); + printk_warning("SMHC: bus witdh param error.\n"); return -1; } @@ -1194,7 +1194,7 @@ static int sunxi_mmc_mmc_switch_bus_width(sunxi_sdhci_t *sdhci, uint32_t spd_mod err = sunxi_mmc_switch(sdhci, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BUS_WIDTH, val); if (err) { - printk_error("SMHC: set bus witdh error.\n"); + printk_warning("SMHC: set bus witdh error.\n"); return -1; } if (spd_mode == MMC_HSDDR52_DDR50) { @@ -1235,14 +1235,14 @@ static int sunxi_mmc_mmc_switch_bus_mode(sunxi_sdhci_t *sdhci, uint32_t spd_mode err = sunxi_mmc_mmc_switch_speed_mode(sdhci, spd_mode); if (err) { - printk_error("SMHC: Switch speed mode failed\n"); + printk_warning("SMHC: Switch speed mode failed\n"); return err; } err = sunxi_mmc_mmc_switch_bus_width(sdhci, spd_mode, width); if (err) { - printk_error("SMHC: Switch bus width\n"); + printk_warning("SMHC: Switch bus width\n"); return err; } @@ -1261,7 +1261,7 @@ static int sunxi_mmc_mmc_switch_bus_mode(sunxi_sdhci_t *sdhci, uint32_t spd_mode * @param sdhci Pointer to the SD/MMC host controller structure. * @return Returns 0 upon success, an error code if an error occurs. */ -static int sunxi_mmc_send_if_cond(sunxi_sdhci_t *sdhci) { +static int sunxi_mmc_sd_send_if_cond(sunxi_sdhci_t *sdhci) { mmc_t *mmc = sdhci->mmc; mmc_cmd_t cmd; int err = 0; @@ -1275,7 +1275,7 @@ static int sunxi_mmc_send_if_cond(sunxi_sdhci_t *sdhci) { err = sunxi_sdhci_xfer(sdhci, &cmd, NULL); if (err) { - printk_error("SMHC: send if cond failed\n"); + printk_warning("SMHC: send if cond failed\n"); return err; } @@ -1325,7 +1325,7 @@ static int sunxi_mmc_probe(sunxi_sdhci_t *sdhci) { mmc_t *mmc = sdhci->mmc; int err = 0; int timeout = 1000; - uint32_t capacity, cmult, csize; + uint64_t capacity = 0, cmult = 0, csize = 0; const char *strver = "unknown"; mmc_cmd_t cmd; @@ -1340,7 +1340,7 @@ static int sunxi_mmc_probe(sunxi_sdhci_t *sdhci) { err = sunxi_sdhci_xfer(sdhci, &cmd, NULL); if (err) { - printk_error("SMHC: Put the Card in Identify Mode failed\n"); + printk_warning("SMHC: Put the Card in Identify Mode failed\n"); return -1; } @@ -1355,12 +1355,12 @@ static int sunxi_mmc_probe(sunxi_sdhci_t *sdhci) { cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR; cmd.cmdarg = mmc->rca << 16; cmd.resp_type = MMC_RSP_R6; - cmd.flags = MMC_DATA_READ; + cmd.flags = 0; err = sunxi_sdhci_xfer(sdhci, &cmd, NULL); if (err) { - printk_error("SMHC: send rca failed\n"); + printk_warning("SMHC: send rca failed\n"); return err; } @@ -1373,7 +1373,7 @@ static int sunxi_mmc_probe(sunxi_sdhci_t *sdhci) { cmd.cmdidx = MMC_CMD_SEND_CSD; cmd.resp_type = MMC_RSP_R2; cmd.cmdarg = mmc->rca << 16; - cmd.flags = MMC_DATA_READ; + cmd.flags = 0; err = sunxi_sdhci_xfer(sdhci, &cmd, NULL); @@ -1381,7 +1381,7 @@ static int sunxi_mmc_probe(sunxi_sdhci_t *sdhci) { sunxi_mmc_send_status(sdhci, timeout); if (err) { - printk_error("SMHC: MMC get csd failed\n"); + printk_warning("SMHC: MMC get csd failed\n"); return err; } @@ -1462,15 +1462,11 @@ static int sunxi_mmc_probe(sunxi_sdhci_t *sdhci) { err = sunxi_sdhci_xfer(sdhci, &cmd, NULL); if (err) { - printk_error("SMHC: Select the card failed\n"); + printk_warning("SMHC: Select the card failed\n"); return err; } } - if (!sunxi_mmc_device_is_sd(mmc)) { - /* TODO MMC Timing update */ - } - sunxi_mmc_set_clock(sdhci, 25000000); /* @@ -1518,14 +1514,16 @@ static int sunxi_mmc_probe(sunxi_sdhci_t *sdhci) { strver = "5.1"; break; } + } else { + printk_debug("SMHC: Read ext csd fail"); } if (!err & (ext_csd[EXT_CSD_REV] >= 2)) { - mmc->capacity = ext_csd[EXT_CSD_SEC_CNT] << 0 | - ext_csd[EXT_CSD_SEC_CNT + 1] << 8 | - ext_csd[EXT_CSD_SEC_CNT + 2] << 16 | - ext_csd[EXT_CSD_SEC_CNT + 3] << 24; - mmc->capacity *= 1 << UNSTUFF_BITS(mmc->csd, 80, 4); + capacity = ext_csd[EXT_CSD_SEC_CNT] << 0 | ext_csd[EXT_CSD_SEC_CNT + 1] << 8 | + ext_csd[EXT_CSD_SEC_CNT + 2] << 16 | ext_csd[EXT_CSD_SEC_CNT + 3] << 24; + capacity *= mmc->read_bl_len; + if ((capacity >> 20) > 2 * 1024) + mmc->capacity = capacity; } /* @@ -1533,7 +1531,7 @@ static int sunxi_mmc_probe(sunxi_sdhci_t *sdhci) { * group size from ext_csd directly, or calculate * the group size from the csd value. */ - if (ext_csd[175]) + if (ext_csd[EXT_CSD_ERASE_GROUP_DEF]) mmc->erase_grp_size = ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 512 * 1024; else { int erase_gsz, erase_gmul; @@ -1555,14 +1553,14 @@ static int sunxi_mmc_probe(sunxi_sdhci_t *sdhci) { } if (err) { - printk_error("SMHC: Change speed mode failed\n"); + printk_warning("SMHC: Change speed mode failed\n"); return err; } /* for re-update sample phase */ err = sunxi_sdhci_update_phase(sdhci); if (err) { - printk_error("SMHC: update clock failed\n"); + printk_warning("SMHC: update clock failed\n"); return err; } @@ -1612,12 +1610,13 @@ static int sunxi_mmc_probe(sunxi_sdhci_t *sdhci) { } else { /* EMMC */ if (mmc->card_caps & MMC_MODE_8BIT) { + printk_trace("SMHC: set mmc bus width 8: %s\n", (mmc->card_caps & MMC_MODE_DDR_52MHz) ? "DDR" : "SDR"); /* Set the card to use 8 bit */ if ((mmc->card_caps & MMC_MODE_DDR_52MHz)) { /* Set the card to use 8 bit ddr */ err = sunxi_mmc_switch(sdhci, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BUS_WIDTH, EXT_CSD_BUS_DDR_8); if (err) { - printk_error("SMHC: switch bus width failed\n"); + printk_warning("SMHC: switch bus width failed\n"); return err; } sunxi_mmc_set_bus_width(sdhci, SMHC_WIDTH_8BIT); @@ -1625,17 +1624,18 @@ static int sunxi_mmc_probe(sunxi_sdhci_t *sdhci) { /* Set the card to use 8 bit */ err = sunxi_mmc_switch(sdhci, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BUS_WIDTH, EXT_CSD_BUS_WIDTH_8); if (err) { - printk_error("SMHC: switch bus width failed\n"); + printk_warning("SMHC: switch bus width failed\n"); return err; } sunxi_mmc_set_bus_width(sdhci, SMHC_WIDTH_8BIT); } } else if (mmc->card_caps & MMC_MODE_4BIT) { + printk_trace("SMHC: set mmc bus width 4: %s\n", (mmc->card_caps & MMC_MODE_DDR_52MHz) ? "DDR" : "SDR"); if ((mmc->card_caps & MMC_MODE_DDR_52MHz)) { /* Set the card to use 4 bit ddr */ err = sunxi_mmc_switch(sdhci, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BUS_WIDTH, EXT_CSD_BUS_DDR_4); if (err) { - printk_error("SMHC: switch bus width failed\n"); + printk_warning("SMHC: switch bus width failed\n"); return err; } sunxi_mmc_set_bus_width(sdhci, SMHC_WIDTH_4BIT); @@ -1643,25 +1643,19 @@ static int sunxi_mmc_probe(sunxi_sdhci_t *sdhci) { /* Set the card to use 4 bit */ err = sunxi_mmc_switch(sdhci, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BUS_WIDTH, EXT_CSD_BUS_WIDTH_4); if (err) { - printk_error("SMHC: switch bus width failed\n"); + printk_warning("SMHC: switch bus width failed\n"); return err; } sunxi_mmc_set_bus_width(sdhci, SMHC_WIDTH_4BIT); } - } else { - /* Set the card to use 8 bit */ - err = sunxi_mmc_switch(sdhci, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BUS_WIDTH, EXT_CSD_BUS_WIDTH_8); - - if (err) { - printk_error("SMHC: witch bus width8 failed\n"); - return err; - } - sunxi_mmc_set_bus_width(sdhci, SMHC_WIDTH_8BIT); } if (mmc->card_caps & MMC_MODE_HS400) { + printk_trace("SMHC: speed set to max clk: %dHz\n", sdhci->max_clk); mmc->tran_speed = sdhci->max_clk; - } else if (mmc->card_caps & MMC_MODE_DDR_52MHz) { + } + + if (mmc->card_caps & MMC_MODE_DDR_52MHz) { mmc->tran_speed = 52000000; } else if (mmc->card_caps & MMC_MODE_HS) { if (mmc->card_caps & MMC_MODE_HS_52MHz) { @@ -1674,7 +1668,6 @@ static int sunxi_mmc_probe(sunxi_sdhci_t *sdhci) { } } - printk_trace("SMHC: set clock to %u\n", mmc->tran_speed); sunxi_mmc_set_clock(sdhci, mmc->tran_speed); @@ -1685,11 +1678,7 @@ static int sunxi_mmc_probe(sunxi_sdhci_t *sdhci) { printk_debug("SD/MMC card at the '%s' host controller:\r\n", sdhci->name); printk_debug(" Attached is a %s%s card\r\n", mmc->version & SD_VERSION_SD ? "SD" : "MMC", mmc->version & SD_VERSION_SD ? "" : strver); - if (mmc->capacity / (f64) 1000000000.0 < 4) - printk_info(" Capacity: %.1fMB\n", (f32) ((f64) mmc->capacity / (f64) 1000000.0)); - else - printk_info(" Capacity: %.1fGB\n", (f32) ((f64) mmc->capacity / (f64) 1000000000.0)); - + printk_info(" Capacity: %.2fGB\n", (f64) (mmc->lba >> 11) / (f64) 1024.f); sunxi_mmc_show_card_info(sdhci); return 0; @@ -1717,7 +1706,7 @@ int sunxi_mmc_init(void *sdhci_hdl) { err = sunxi_sdhci_core_init(sdhci); if (err) { - printk_error("SMHC: host init failed\n"); + printk_warning("SMHC: host init failed\n"); return err; } @@ -1727,7 +1716,7 @@ int sunxi_mmc_init(void *sdhci_hdl) { err = sunxi_mmc_go_idle(sdhci); if (err) { - printk_error("SMHC: Reset card fail\n"); + printk_warning("SMHC: Reset card fail\n"); return err; } @@ -1737,40 +1726,53 @@ int sunxi_mmc_init(void *sdhci_hdl) { /* if is SDHCI0 in PF port try SD Card CD pin */ if (sdhci->pinctrl.gpio_cd.pin != 0) { if (sdhci->id == 0 && sunxi_gpio_read(sdhci->pinctrl.gpio_cd.pin) != GPIO_LEVEL_LOW) { - printk_error("SMHC: SD Card Get CD error %d\n", sunxi_gpio_read(sdhci->pinctrl.gpio_cd.pin)); + printk_warning("SMHC: SD Card Get CD error %d\n", sunxi_gpio_read(sdhci->pinctrl.gpio_cd.pin)); err = -1; return err; } } printk_debug("SMHC: Try to init SD Card\n"); - err = sunxi_mmc_send_if_cond(sdhci); + err = sunxi_mmc_sd_send_if_cond(sdhci); if (err) { - printk_error("SMHC%d: SD Card did not respond to voltage select\n", sdhci->id); + printk_warning("SMHC%d: SD Card did not respond to voltage select\n", sdhci->id); return -1; } err = sunxi_mmc_sd_send_op_cond(sdhci); if (err) { - printk_error("SMHC%d: SD Card did not respond to voltage select\n", sdhci->id); + printk_warning("SMHC%d: SD Card did not respond to voltage select\n", sdhci->id); return -1; } } else if (sdhci->sdhci_mmc_type == MMC_TYPE_EMMC) { printk_debug("SMHC: Try to init eMMC Card\n"); err = sunxi_mmc_mmc_send_op_cond(sdhci); if (err) { - printk_error("SMHC%d: MMC did not respond to voltage select\n", sdhci->id); + printk_warning("SMHC%d: MMC did not respond to voltage select\n", sdhci->id); return -1; } } err = sunxi_mmc_probe(sdhci); if (err) { - printk_error("SMHC%d: SD/MMC Probe failed, err %d\n", sdhci->id, err); + printk_warning("SMHC%d: SD/MMC Probe failed, err %d\n", sdhci->id, err); } return err; } +/** + * @brief Read blocks from the Sunxi MMC block device + * + * This function reads a specified number of blocks from the Sunxi MMC block device + * and stores the data into the destination buffer. + * + * @param sdhci Pointer to the Sunxi SD Host Controller instance + * @param dst Pointer to the destination buffer where the read data will be stored + * @param start The starting block number to read from + * @param blkcnt The number of blocks to read + * + * @return Returns 0 on success, or an error code if the operation fails + */ uint32_t sunxi_mmc_blk_read(void *sdhci, void *dst, uint32_t start, uint32_t blkcnt) { return sunxi_mmc_read_blocks((sunxi_sdhci_t *) sdhci, dst, start, blkcnt); } \ No newline at end of file diff --git a/src/drivers/mmc/sys-sdcard.c b/src/drivers/mmc/sys-sdcard.c index 558abda1..7afc5538 100644 --- a/src/drivers/mmc/sys-sdcard.c +++ b/src/drivers/mmc/sys-sdcard.c @@ -18,6 +18,19 @@ sdmmc_pdata_t card0; +/** + * @brief Initialize the SD/MMC interface + * + * Initializes the SD/MMC interface using the provided data structure and SD Host Controller instance. + * It sets the SD Host Controller instance and the online status in the data structure, and then initializes + * the MMC device. If the initialization is successful, it prints a message indicating the type of card detected + * and returns 0; otherwise, it returns -1. + * + * @param data Pointer to the SD/MMC platform data structure + * @param hci Pointer to the Sunxi SD Host Controller instance + * + * @return Returns 0 on success, or -1 if the initialization fails + */ int sdmmc_init(sdmmc_pdata_t *data, sunxi_sdhci_t *hci) { data->hci = hci; data->online = false; @@ -30,6 +43,20 @@ int sdmmc_init(sdmmc_pdata_t *data, sunxi_sdhci_t *hci) { return -1; } +/** + * @brief Read blocks from the SD/MMC device + * + * Reads a specified number of blocks from the SD/MMC device using the provided platform data structure, + * destination buffer, block number, and block count. It calls the underlying function for reading blocks + * from the Sunxi MMC block device and returns the result. + * + * @param data Pointer to the SD/MMC platform data structure + * @param buf Pointer to the destination buffer where the read data will be stored + * @param blkno The starting block number to read from + * @param blkcnt The number of blocks to read + * + * @return Returns 0 on success, or an error code if the operation fails + */ uint32_t sdmmc_blk_read(sdmmc_pdata_t *data, uint8_t *buf, uint32_t blkno, uint32_t blkcnt) { return sunxi_mmc_blk_read(data->hci, buf, blkno, blkcnt); -} \ No newline at end of file +} diff --git a/src/drivers/mmc/sys-sdhci.c b/src/drivers/mmc/sys-sdhci.c index 380b188b..fdf1246f 100644 --- a/src/drivers/mmc/sys-sdhci.c +++ b/src/drivers/mmc/sys-sdhci.c @@ -36,11 +36,11 @@ static int sunxi_sdhci_clk_enable(sunxi_sdhci_t *sdhci) { uint32_t reg_val; /* Configure AHB clock */ reg_val = readl(mmc_host->hclkbase); - reg_val |= (1 << (sdhci->id)); + reg_val |= BIT(sdhci->id); writel(reg_val, mmc_host->hclkbase); reg_val = readl(mmc_host->hclkrst); - reg_val |= (1 << (16 + sdhci->id)); + reg_val |= BIT(16 + sdhci->id); writel(reg_val, mmc_host->hclkrst); /* Configure module clock */ @@ -74,7 +74,7 @@ static int sunxi_sdhci_update_clk(sunxi_sdhci_t *sdhci) { /* Check status */ if (mmc_host->reg->cmd & SMHC_CMD_START) { - printk_error("SMHC: mmc %d update clk failed\n", sdhci->id); + printk_debug("SMHC: mmc %d update clk failed\n", sdhci->id); return -1; } @@ -84,14 +84,15 @@ static int sunxi_sdhci_update_clk(sunxi_sdhci_t *sdhci) { } /** - * @brief Configure timing settings for timing mode 4 in the SDHC controller. - * - * This function configures timing settings for timing mode 4 in the SDHC controller. - * It calculates the delay based on the speed mode and frequency parameters and sets - * the appropriate values in the timing data structure. Additionally, it sets the - * output delay (`odly`) based on the speed mode and returns 0 on success or -1 on failure. - * - * @param sdhci Pointer to the SDHC structure. + * @brief Calculate the timing configuration for Sunxi SD Host Controller using timing mode 4. + * + * This function calculates the timing configuration for the Sunxi SD Host Controller when operating + * in timing mode 4 based on the speed mode and frequency. It updates the timing data with the calculated delay. + * + * @param sdhci A pointer to the Sunxi SD Host Controller structure. + * @param spd_md_id The speed mode ID. + * @param freq_id The frequency ID. + * * @return 0 on success, -1 on failure. */ static int sunxi_sdhci_get_timing_config_timing_4(sunxi_sdhci_t *sdhci, const uint32_t spd_md_id, const uint32_t freq_id) { @@ -103,7 +104,7 @@ static int sunxi_sdhci_get_timing_config_timing_4(sunxi_sdhci_t *sdhci, const ui /* Check if the controller ID is MMC_CONTROLLER_2 and if timing mode and frequency ID are valid */ if ((sdhci->id != MMC_CONTROLLER_2) || (spd_md_id > MMC_HS400) || (freq_id > MMC_MAX_SPD_MD_NUM)) { - printk_error("SMHC: timing 4 not supported for this configuration\n"); + printk_debug("SMHC: timing 4 not supported for this configuration\n"); return -1; } @@ -116,7 +117,7 @@ static int sunxi_sdhci_get_timing_config_timing_4(sunxi_sdhci_t *sdhci, const ui if (freq_id <= MMC_CLK_25M) { dly = 0; } else { - printk_error("SMHC: wrong frequency %d at speed mode %d\n", freq_id, spd_md_id); + printk_debug("SMHC: wrong frequency %d at speed mode %d\n", freq_id, spd_md_id); ret = -1; } } else if (spd_md_id == MMC_HSSDR52_SDR25) { @@ -125,18 +126,18 @@ static int sunxi_sdhci_get_timing_config_timing_4(sunxi_sdhci_t *sdhci, const ui } else if (freq_id == MMC_CLK_50M) { dly = 15; } else { - printk_error("SMHC: wrong frequency %d at speed mode %d\n", freq_id, spd_md_id); + printk_debug("SMHC: wrong frequency %d at speed mode %d\n", freq_id, spd_md_id); ret = -1; } } else if (spd_md_id == MMC_HSDDR52_DDR50) { if (freq_id <= MMC_CLK_25M) { dly = 0; } else { - printk_error("SMHC: wrong frequency %d at speed mode %d\n", freq_id, spd_md_id); + printk_debug("SMHC: wrong frequency %d at speed mode %d\n", freq_id, spd_md_id); ret = -1; } } else { - printk_error("SMHC: wrong speed mode %d\n", spd_md_id); + printk_debug("SMHC: wrong speed mode %d\n", spd_md_id); ret = -1; } } @@ -157,14 +158,16 @@ static int sunxi_sdhci_get_timing_config_timing_4(sunxi_sdhci_t *sdhci, const ui return ret; } - /** - * @brief Get timing configuration for the SDHC controller. - * - * This function retrieves the timing configuration for the specified SDHC controller. - * - * @param sdhci Pointer to the SDHC controller structure. - * @return Returns 0 on success, -1 on failure. + * @brief Get the timing configuration for the Sunxi SD Host Controller + * + * This function retrieves the timing configuration for the Sunxi SD Host Controller based on the provided parameters. + * + * @param sdhci Pointer to the Sunxi SD Host Controller instance + * @param spd_md_id Speed mode ID + * @param freq_id Frequency ID + * + * @return Returns 0 on success, or an error code if the operation fails */ static int sunxi_sdhci_get_timing_config(sunxi_sdhci_t *sdhci, uint32_t spd_md_id, uint32_t freq_id) { int ret = 0; @@ -174,30 +177,31 @@ static int sunxi_sdhci_get_timing_config(sunxi_sdhci_t *sdhci, uint32_t spd_md_i // Check for specific conditions based on the controller ID and timing mode if ((sdhci->id == 2) && mmc_host->timing_mode == SUNXI_MMC_TIMING_MODE_4) { - /* When using eMMC and SMHC2, config it as timing 4 */ + /* When using eMMC and SMHC2, configure it as timing 4 */ ret = sunxi_sdhci_get_timing_config_timing_4(sdhci, spd_md_id, freq_id); if (ret) { - printk_error("SMHC: Config timing TM4 fail\n"); + printk_debug("SMHC: Configuring timing TM4 failed\n"); } } else if ((sdhci->id == 0) && (mmc_host->timing_mode == SUNXI_MMC_TIMING_MODE_1)) { // Check timing data and adjust configuration if necessary if ((spd_md_id <= MMC_HSSDR52_SDR25) && (freq_id <= MMC_CLK_50M)) { - /* if timing less than SDR25, use default odly */ + /* If timing is less than SDR25, use default odly */ timing_data->odly = 0; timing_data->sdly = 0; ret = 0; } else { - printk_warning("SMHC: SMHC0 does not support input spd mode %d\n", spd_md_id); + printk_warning("SMHC: SMHC0 does not support input speed mode %d\n", spd_md_id); ret = -1; } } else { - printk_error("SMHC: timing setting failed, parameter error\n"); + printk_debug("SMHC: Timing setting failed due to parameter error\n"); ret = -1; } return ret; } + /** * @brief Set the SDHC controller's clock frequency. * @@ -244,7 +248,7 @@ static int sunxi_sdhci_set_mclk(sunxi_sdhci_t *sdhci, uint32_t clk_hz) { default: n = 0; m = 0; - printk_error("SMHC: requested frequency does not match: freq=%d\n", clk_hz); + printk_debug("SMHC: requested frequency does not match: freq=%d\n", clk_hz); break; } @@ -290,7 +294,7 @@ static uint32_t sunxi_sdhci_get_mclk(sunxi_sdhci_t *sdhci) { clk_hz = (sdhci->id == 2) ? 600000000 : 300000000; break; default: - printk_error("SMHC: wrong clock source %u\n", src); + printk_debug("SMHC: wrong clock source %u\n", src); break; } @@ -299,12 +303,15 @@ static uint32_t sunxi_sdhci_get_mclk(sunxi_sdhci_t *sdhci) { } /** - * @brief Configure the delay for the SDHC controller based on timing mode. - * - * This function configures the delay for the SDHC controller based on the timing mode. - * - * @param sdhci Pointer to the SDHC controller structure. - * @return 0 on success, -1 on failure. + * @brief Configure delay for the Sunxi SD Host Controller + * + * This function configures the delay settings for the Sunxi SD Host Controller based on the provided parameters. + * + * @param sdhci Pointer to the Sunxi SD Host Controller instance + * @param spd_md_id Speed mode ID + * @param freq_id Frequency ID + * + * @return Returns 0 on success, or an error code if the operation fails */ static int sunxi_sdhci_config_delay(sunxi_sdhci_t *sdhci, uint32_t spd_md_id, uint32_t freq_id) { int ret = 0; @@ -357,12 +364,12 @@ static int sunxi_sdhci_config_delay(sunxi_sdhci_t *sdhci, uint32_t spd_md_id, ui timing_data->sdly = 0xff; if ((ret = sunxi_sdhci_get_timing_config(sdhci, spd_md_id, freq_id)) != 0) { - printk_error("SMHC: getting timing param error %d\n", ret); + printk_debug("SMHC: getting timing param error %d\n", ret); return -1; } if ((timing_data->odly == 0xff) || (timing_data->sdly == 0xff)) { - printk_error("SMHC: getting timing config error\n"); + printk_debug("SMHC: getting timing config error\n"); return -1; } @@ -384,12 +391,12 @@ static int sunxi_sdhci_config_delay(sunxi_sdhci_t *sdhci, uint32_t spd_md_id, ui timing_data->odly = 0xff; timing_data->sdly = 0xff; if ((ret = sunxi_sdhci_get_timing_config(sdhci, spd_md_id, freq_id)) != 0) { - printk_error("SMHC: getting timing param error %d\n", ret); + printk_debug("SMHC: getting timing param error %d\n", ret); return -1; } if ((timing_data->odly == 0xff) || (timing_data->sdly == 0xff)) { - printk_error("SMHC: getting timing config error\n"); + printk_debug("SMHC: getting timing config error\n"); return -1; } @@ -544,7 +551,7 @@ static int sunxi_sdhci_config_clock(sunxi_sdhci_t *sdhci, uint32_t clk) { // Update clock settings if (sunxi_sdhci_update_clk(sdhci)) { - printk_error("SMHC: Failed to update clock settings\n"); + printk_debug("SMHC: Failed to update clock settings\n"); return -1; } @@ -552,11 +559,11 @@ static int sunxi_sdhci_config_clock(sunxi_sdhci_t *sdhci, uint32_t clk) { if (mmc_host->timing_mode == SUNXI_MMC_TIMING_MODE_1 || mmc_host->timing_mode == SUNXI_MMC_TIMING_MODE_3 || mmc_host->timing_mode == SUNXI_MMC_TIMING_MODE_4) { if (sunxi_sdhci_clock_mode(sdhci, clk)) { - printk_error("SMHC: Failed to configure clock mode\n"); + printk_debug("SMHC: Failed to configure clock mode\n"); return -1; } } else { - printk_error("SMHC: Timing mode not supported\n"); + printk_debug("SMHC: Timing mode not supported\n"); return -1; } @@ -565,7 +572,7 @@ static int sunxi_sdhci_config_clock(sunxi_sdhci_t *sdhci, uint32_t clk) { // Check if clock update after configuration fails if (sunxi_sdhci_update_clk(sdhci)) { - printk_error("SMHC: Failed to update clock settings after configuration\n"); + printk_debug("SMHC: Failed to update clock settings after configuration\n"); return -1; } @@ -733,7 +740,7 @@ static int sunxi_sunxi_sdhci_trans_data_cpu(sunxi_sdhci_t *sdhci, mmc_data_t *da } if (mmc_host->reg->status & SMHC_STATUS_FIFO_EMPTY) { if (time_us() >= timeout) { - printk_error("SMHC: read by CPU failed, timeout, index %u\n", i); + printk_debug("SMHC: read by CPU failed, timeout, index %u\n", i); } return -1; } @@ -835,13 +842,13 @@ static int sunxi_sunxi_sdhci_trans_data_dma(sunxi_sdhci_t *sdhci, mmc_data_t *da /* Enable DMA */ - mmc_host->reg->idst = 0x337; + // mmc_host->reg->idst = 0x337; mmc_host->reg->gctrl |= (SMHC_GCTRL_DMA_ENABLE | SMHC_GCTRL_DMA_RESET); timeout = time_us() + SMHC_TIMEOUT; while (mmc_host->reg->gctrl & SMHC_GCTRL_DMA_RESET) { if (time_us() > timeout) { - printk_error("SMHC: wait for dma rst timeout\n"); + printk_debug("SMHC: wait for dma rst timeout\n"); return -1; } } @@ -851,7 +858,7 @@ static int sunxi_sunxi_sdhci_trans_data_dma(sunxi_sdhci_t *sdhci, mmc_data_t *da timeout = time_us() + SMHC_TIMEOUT; while (mmc_host->reg->dmac & SMHC_IDMAC_SOFT_RESET) { if (time_us() > timeout) { - printk_error("SMHC: wait for dma soft rst timeout\n"); + printk_debug("SMHC: wait for dma soft rst timeout\n"); return -1; } } @@ -892,7 +899,7 @@ void sunxi_sdhci_set_ios(sunxi_sdhci_t *sdhci) { // Configure clock and handle errors if (mmc->clock && sunxi_sdhci_config_clock(sdhci, mmc->clock)) { - printk_error("SMHC: update clock failed\n"); + printk_debug("SMHC: update clock failed\n"); mmc_host->fatal_err = 1; return; } @@ -933,7 +940,7 @@ int sunxi_sdhci_core_init(sunxi_sdhci_t *sdhci) { mmc_host->reg->gctrl = 0x7; while (mmc_host->reg->gctrl & 0x7) { if (time_us() > timeout) { - printk_error("SMHC: controller reset timeout\n"); + printk_debug("SMHC: controller reset timeout\n"); return -1; } } @@ -989,7 +996,7 @@ int sunxi_sdhci_xfer(sunxi_sdhci_t *sdhci, mmc_cmd_t *cmd, mmc_data_t *data) { /* Check if have fatal error */ if (mmc_host->fatal_err) { - printk_error("SMHC: SMHC into error, cmd send failed\n"); + printk_debug("SMHC: SMHC into error, cmd send failed\n"); return -1; } @@ -1032,7 +1039,7 @@ int sunxi_sdhci_xfer(sunxi_sdhci_t *sdhci, mmc_cmd_t *cmd, mmc_data_t *data) { if (data) { /* Check data desc align */ if ((uint32_t) data->b.dest & 0x3) { - printk_error("SMHC: data dest is not 4 byte align\n"); + printk_debug("SMHC: data dest is not 4 byte align\n"); error_code = -1; goto out; } @@ -1082,7 +1089,7 @@ int sunxi_sdhci_xfer(sunxi_sdhci_t *sdhci, mmc_cmd_t *cmd, mmc_data_t *data) { if (ret) { error_code = mmc_host->reg->rint & SMHC_RINT_INTERRUPT_ERROR_BIT; - printk_warning("SMHC: error 0x%x status 0x%x\n", error_code & SMHC_RINT_INTERRUPT_ERROR_BIT, error_code & ~SMHC_RINT_INTERRUPT_ERROR_BIT); + printk_debug("SMHC: error 0x%x status 0x%x\n", error_code & SMHC_RINT_INTERRUPT_ERROR_BIT, error_code & ~SMHC_RINT_INTERRUPT_ERROR_BIT); if (!error_code) { error_code = 0xffffffff; } @@ -1099,9 +1106,9 @@ int sunxi_sdhci_xfer(sunxi_sdhci_t *sdhci, mmc_cmd_t *cmd, mmc_data_t *data) { error_code = 0xffffffff; } if (time_us() > timeout) - printk_error("SMHC: stage 1 data timeout, error %08x\n", error_code); + printk_debug("SMHC: stage 1 data timeout, error %08x\n", error_code); else - printk_error("SMHC: stage 1 status get interrupt, error 0x%08x\n", error_code); + printk_debug("SMHC: stage 1 status get interrupt, error 0x%08x\n", error_code); goto out; } } while (!(status & SMHC_RINT_COMMAND_DONE)); @@ -1117,9 +1124,9 @@ int sunxi_sdhci_xfer(sunxi_sdhci_t *sdhci, mmc_cmd_t *cmd, mmc_data_t *data) { error_code = 0xffffffff; } if (time_us() > timeout) - printk_error("SMHC: stage 2 data timeout, error %08x\n", error_code); + printk_debug("SMHC: stage 2 data timeout, error %08x\n", error_code); else - printk_error("SMHC: stage 2 status get interrupt, error 0x%08x\n", error_code); + printk_debug("SMHC: stage 2 status get interrupt, error 0x%08x\n", error_code); goto out; } @@ -1141,7 +1148,7 @@ int sunxi_sdhci_xfer(sunxi_sdhci_t *sdhci, mmc_cmd_t *cmd, mmc_data_t *data) { if (!error_code) { error_code = 0xffffffff; } - printk_error("SMHC: wait dma timeout, error %08x\n", error_code); + printk_debug("SMHC: wait dma timeout, error %08x\n", error_code); goto out; } done = status & BIT(1); @@ -1158,7 +1165,7 @@ int sunxi_sdhci_xfer(sunxi_sdhci_t *sdhci, mmc_cmd_t *cmd, mmc_data_t *data) { if (!error_code) { error_code = 0xffffffff; } - printk_error("SMHC: busy timeout, status %08x\n", status); + printk_debug("SMHC: busy timeout, status %08x\n", status); goto out; } } while (status & SMHC_STATUS_CARD_DATA_BUSY); @@ -1199,12 +1206,12 @@ int sunxi_sdhci_xfer(sunxi_sdhci_t *sdhci, mmc_cmd_t *cmd, mmc_data_t *data) { timeout = time_us() + SMHC_TIMEOUT; while (mmc_host->reg->gctrl & SMHC_GCTRL_HARDWARE_RESET) { if (time_us() > timeout) { - printk_error("SMHC: controller error reset timeout\n"); + printk_debug("SMHC: controller error reset timeout\n"); return -1; } } sunxi_sdhci_update_clk(sdhci); - printk_error("SMHC: CMD 0x%08x, error 0x%08x\n", cmd->cmdidx, error_code); + printk_debug("SMHC: CMD 0x%08x, error 0x%08x\n", cmd->cmdidx, error_code); } mmc_host->reg->rint = 0xffffffff; @@ -1252,7 +1259,7 @@ int sunxi_sdhci_update_phase(sunxi_sdhci_t *sdhci) { int sunxi_sdhci_init(sunxi_sdhci_t *sdhci) { /* Check if controller ID is correct */ if (sdhci->id > MMC_CONTROLLER_2) { - printk_error("SMHC: Unsupported MAX Controller reached\n"); + printk_debug("SMHC: Unsupported MAX Controller reached\n"); return -1; }