| /* SPDX-License-Identifier: GPL-2.0-or-later */ |
| /* |
| * Secure Digital (SD) card specific support code |
| * This code is controller independent |
| */ |
| |
| #include <commonlib/sd_mmc_ctrlr.h> |
| #include <commonlib/storage.h> |
| #include <delay.h> |
| #include <endian.h> |
| |
| #include "sd_mmc.h" |
| #include "storage.h" |
| |
| int sd_send_if_cond(struct storage_media *media) |
| { |
| struct mmc_command cmd; |
| struct sd_mmc_ctrlr *ctrlr = media->ctrlr; |
| |
| cmd.cmdidx = SD_CMD_SEND_IF_COND; |
| /* Set if controller supports voltages between 2.7 and 3.6 V. */ |
| cmd.cmdarg = ((ctrlr->voltages & 0xff8000) != 0) << 8 | 0xaa; |
| cmd.resp_type = CARD_RSP_R7; |
| cmd.flags = 0; |
| int err = ctrlr->send_cmd(ctrlr, &cmd, NULL); |
| if (err) |
| return err; |
| |
| if ((cmd.response[0] & 0xff) != 0xaa) |
| return CARD_UNUSABLE_ERR; |
| media->version = SD_VERSION_2; |
| return 0; |
| } |
| |
| int sd_send_op_cond(struct storage_media *media) |
| { |
| int err; |
| struct mmc_command cmd; |
| struct sd_mmc_ctrlr *ctrlr = media->ctrlr; |
| |
| int tries = SD_MMC_IO_RETRIES; |
| while (tries--) { |
| cmd.cmdidx = MMC_CMD_APP_CMD; |
| cmd.resp_type = CARD_RSP_R1; |
| cmd.cmdarg = 0; |
| cmd.flags = 0; |
| |
| err = ctrlr->send_cmd(ctrlr, &cmd, NULL); |
| if (err) |
| return err; |
| |
| cmd.cmdidx = SD_CMD_APP_SEND_OP_COND; |
| cmd.resp_type = CARD_RSP_R3; |
| |
| /* |
| * Most cards do not answer if some reserved bits |
| * in the ocr are set. However, Some controller |
| * can set bit 7 (reserved for low voltages), but |
| * how to manage low voltages SD card is not yet |
| * specified. |
| */ |
| cmd.cmdarg = (ctrlr->voltages & 0xff8000); |
| |
| if (media->version == SD_VERSION_2) |
| cmd.cmdarg |= OCR_HCS; |
| |
| err = ctrlr->send_cmd(ctrlr, &cmd, NULL); |
| if (err) |
| return err; |
| |
| // OCR_BUSY means "initialization complete". |
| if (cmd.response[0] & OCR_BUSY) |
| break; |
| |
| udelay(100); |
| } |
| if (tries < 0) |
| return CARD_UNUSABLE_ERR; |
| |
| if (media->version != SD_VERSION_2) |
| media->version = SD_VERSION_1_0; |
| |
| media->ocr = cmd.response[0]; |
| media->high_capacity = ((media->ocr & OCR_HCS) == OCR_HCS); |
| media->rca = 0; |
| return 0; |
| } |
| |
| static int sd_switch(struct sd_mmc_ctrlr *ctrlr, int mode, int group, |
| uint8_t value, uint8_t *resp) |
| { |
| /* Switch the frequency */ |
| struct mmc_command cmd; |
| cmd.cmdidx = SD_CMD_SWITCH_FUNC; |
| cmd.resp_type = CARD_RSP_R1; |
| cmd.cmdarg = (mode << 31) | (0xffffff & ~(0xf << (group * 4))) | |
| (value << (group * 4)); |
| cmd.flags = 0; |
| |
| struct mmc_data data; |
| data.dest = (char *)resp; |
| data.blocksize = 64; |
| data.blocks = 1; |
| data.flags = DATA_FLAG_READ; |
| |
| return ctrlr->send_cmd(ctrlr, &cmd, &data); |
| } |
| |
| static void sd_recalculate_clock(struct storage_media *media) |
| { |
| uint32_t clock = 1; |
| |
| if (media->caps & DRVR_CAP_HS) |
| clock = CLOCK_50MHZ; |
| else |
| clock = CLOCK_25MHZ; |
| SET_CLOCK(media->ctrlr, clock); |
| } |
| |
| int sd_change_freq(struct storage_media *media) |
| { |
| int delay; |
| int err, timeout; |
| struct mmc_command cmd; |
| struct sd_mmc_ctrlr *ctrlr = media->ctrlr; |
| struct mmc_data data; |
| ALLOC_CACHE_ALIGN_BUFFER(uint32_t, scr, 2); |
| ALLOC_CACHE_ALIGN_BUFFER(uint32_t, switch_status, 16); |
| |
| media->caps = 0; |
| |
| /* Read the SCR to find out if this card supports higher speeds */ |
| cmd.cmdidx = MMC_CMD_APP_CMD; |
| cmd.resp_type = CARD_RSP_R1; |
| cmd.cmdarg = media->rca << 16; |
| cmd.flags = 0; |
| |
| err = ctrlr->send_cmd(ctrlr, &cmd, NULL); |
| if (err) |
| return err; |
| |
| cmd.cmdidx = SD_CMD_APP_SEND_SCR; |
| cmd.resp_type = CARD_RSP_R1; |
| cmd.cmdarg = 0; |
| cmd.flags = 0; |
| |
| timeout = 3; |
| while (timeout--) { |
| data.dest = (char *)scr; |
| data.blocksize = 8; |
| data.blocks = 1; |
| data.flags = DATA_FLAG_READ; |
| err = ctrlr->send_cmd(ctrlr, &cmd, &data); |
| if (!err) |
| break; |
| } |
| if (err) { |
| sd_mmc_error("%s returning %d\n", __func__, err); |
| return err; |
| } |
| |
| media->scr[0] = be32toh(scr[0]); |
| media->scr[1] = be32toh(scr[1]); |
| |
| switch ((media->scr[0] >> 24) & 0xf) { |
| case 0: |
| media->version = SD_VERSION_1_0; |
| break; |
| case 1: |
| media->version = SD_VERSION_1_10; |
| break; |
| case 2: |
| media->version = SD_VERSION_2; |
| break; |
| default: |
| media->version = SD_VERSION_1_0; |
| break; |
| } |
| |
| if (media->scr[0] & SD_DATA_4BIT) |
| media->caps |= DRVR_CAP_4BIT; |
| |
| /* Version 1.0 doesn't support switching */ |
| if (media->version == SD_VERSION_1_0) |
| goto out; |
| |
| timeout = 4; |
| while (timeout--) { |
| err = sd_switch(ctrlr, SD_SWITCH_CHECK, 0, 1, |
| (uint8_t *)switch_status); |
| if (err) |
| return err; |
| |
| /* The high-speed function is busy. Try again */ |
| if (!(ntohl(switch_status[7]) & SD_HIGHSPEED_BUSY)) |
| break; |
| } |
| |
| /* If high-speed isn't supported, we return */ |
| if (!(ntohl(switch_status[3]) & SD_HIGHSPEED_SUPPORTED)) |
| goto out; |
| |
| /* |
| * If the controller doesn't support SD_HIGHSPEED, do not switch the |
| * card to HIGHSPEED mode even if the card support SD_HIGHSPPED. |
| * This can avoid a further problem when the card runs in different |
| * mode than the controller. |
| */ |
| if (!((ctrlr->caps & DRVR_CAP_HS52) && (ctrlr->caps & DRVR_CAP_HS))) |
| goto out; |
| |
| /* Give the card time to recover after the switch operation. Wait for |
| * 9 (>= 8) clock cycles receiving the switch status. |
| */ |
| delay = (9000000 + ctrlr->bus_hz - 1) / ctrlr->bus_hz; |
| udelay(delay); |
| |
| /* Switch to high speed */ |
| err = sd_switch(ctrlr, SD_SWITCH_SWITCH, 0, 1, |
| (uint8_t *)switch_status); |
| if (err) |
| return err; |
| |
| /* Give the card time to perform the switch operation. Wait for 9 |
| * (>= 8) clock cycles receiving the switch status. |
| */ |
| udelay(delay); |
| |
| if ((ntohl(switch_status[4]) & 0x0f000000) == 0x01000000) { |
| media->caps |= DRVR_CAP_HS; |
| SET_TIMING(ctrlr, BUS_TIMING_SD_HS); |
| } |
| |
| out: |
| sd_recalculate_clock(media); |
| return 0; |
| } |
| |
| int sd_set_bus_width(struct storage_media *media) |
| { |
| int err; |
| struct mmc_command cmd; |
| struct sd_mmc_ctrlr *ctrlr = media->ctrlr; |
| |
| if (media->caps & DRVR_CAP_4BIT) { |
| cmd.cmdidx = MMC_CMD_APP_CMD; |
| cmd.resp_type = CARD_RSP_R1; |
| cmd.cmdarg = media->rca << 16; |
| cmd.flags = 0; |
| |
| err = ctrlr->send_cmd(ctrlr, &cmd, NULL); |
| if (err) |
| return err; |
| |
| cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH; |
| cmd.resp_type = CARD_RSP_R1; |
| cmd.cmdarg = 2; |
| cmd.flags = 0; |
| err = ctrlr->send_cmd(ctrlr, &cmd, NULL); |
| if (err) |
| return err; |
| |
| SET_BUS_WIDTH(ctrlr, 4); |
| } |
| return 0; |
| } |
| |
| int sd_set_partition(struct storage_media *media, |
| unsigned int partition_number) |
| { |
| /* Validate the partition number */ |
| if (partition_number) |
| return -1; |
| |
| /* Update the partition number */ |
| media->partition_config = partition_number; |
| return 0; |
| } |
| |
| const char *sd_partition_name(struct storage_media *media, |
| unsigned int partition_number) |
| { |
| return ""; |
| } |