circuitpython/ports/broadcom/common-hal/sdioio/SDCard.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

402 lines
14 KiB
C
Raw Normal View History

/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2020 Jeff Epler for Adafruit Industries
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdbool.h>
#include "mphalport.h"
#include "py/mperrno.h"
#include "py/runtime.h"
#include "common-hal/microcontroller/Pin.h"
#include "shared-bindings/sdioio/SDCard.h"
#include "shared-bindings/microcontroller/Pin.h"
#include "shared-bindings/microcontroller/__init__.h"
#include "supervisor/port.h"
#include "supervisor/shared/translate.h"
2022-01-06 11:52:33 -05:00
#include "peripherals/broadcom/cpu.h"
#include "peripherals/broadcom/defines.h"
#include "peripherals/broadcom/gpio.h"
#include "lib/sdmmc/include/sdmmc_cmd.h"
void osal_task_delay(uint32_t msec) {
mp_hal_delay_ms(msec);
}
/*!< Host function to initialize the driver */
STATIC sdmmc_err_t _init(void) {
return SDMMC_OK;
}
/*!< host function to set bus width */
STATIC sdmmc_err_t _set_bus_width(int slot, size_t width) {
if (width == 4) {
EMMC->CONTROL0_b.HCTL_DWIDTH = true;
} else if (width == 8) {
EMMC->CONTROL0_b.HCTL_8BIT = true;
}
return SDMMC_OK;
}
/*!< host function to get the maximum bus width of a particular slot */
STATIC size_t _get_bus_width(int slot) {
return 4;
}
/*!< host function to set card clock frequency */
STATIC sdmmc_err_t _set_card_clk(int slot, uint32_t freq_khz) {
uint32_t base_clock = 125000000;
uint32_t frequency = freq_khz * 1000;
uint64_t start_ticks = port_get_raw_ticks(NULL);
while ((EMMC->STATUS_b.CMD_INHIBIT || EMMC->STATUS_b.DAT_INHIBIT) && (port_get_raw_ticks(NULL) - start_ticks) < 1024) {
}
if (EMMC->STATUS_b.CMD_INHIBIT || EMMC->STATUS_b.DAT_INHIBIT) {
return SDMMC_ERR_TIMEOUT;
}
EMMC->CONTROL1_b.CLK_EN = false;
uint32_t divisor = base_clock / frequency;
// + 1 to ensure we round the frequency down.
if (base_clock % frequency > 0) {
divisor += 1;
}
// Only even divisors are supported
uint32_t register_value = divisor / 2;
if (divisor % 2 == 1) {
register_value += 1;
}
// The divisor is stored with bits swapped.
EMMC->CONTROL1_b.CLK_FREQ8 = divisor & 0xff;
EMMC->CONTROL1_b.CLK_FREQ_MS2 = (divisor >> 8) & 0x3;
EMMC->CONTROL1_b.CLK_EN = true;
start_ticks = port_get_raw_ticks(NULL);
while (!EMMC->CONTROL1_b.CLK_STABLE && (port_get_raw_ticks(NULL) - start_ticks) < 1024) {
}
if (!EMMC->CONTROL1_b.CLK_STABLE) {
return SDMMC_ERR_TIMEOUT;
}
return SDMMC_OK;
}
/*!< host function to do a transaction */
STATIC sdmmc_err_t _do_transaction(int slot, sdmmc_command_t *cmdinfo) {
if (EMMC->STATUS_b.CMD_INHIBIT) {
return SDMMC_ERR_BUSY;
}
// Clear interrupts and then send the command
EMMC->INTERRUPT = 0xffffffff;
EMMC->ARG1 = cmdinfo->arg;
uint32_t cmd_flags = 0;
bool read = (cmdinfo->flags & SCF_CMD_READ) != 0;
if (SCF_CMD(cmdinfo->flags) == SCF_CMD_ADTC ||
SCF_CMD(cmdinfo->flags) == (SCF_CMD_ADTC | SCF_CMD_READ)) {
if (EMMC->STATUS_b.DAT_INHIBIT) {
return SDMMC_ERR_BUSY;
}
cmd_flags = EMMC_CMDTM_TM_BLKCNT_EN_Msk | EMMC_CMDTM_CMD_ISDATA_Msk;
if (cmdinfo->datalen > cmdinfo->blklen) {
cmd_flags |= EMMC_CMDTM_TM_MULTI_BLOCK_Msk;
if ((cmdinfo->flags & SCF_AUTO_STOP) != 0) {
cmd_flags |= 1 << EMMC_CMDTM_TM_AUTO_CMD_EN_Pos;
}
}
if (read) {
cmd_flags |= EMMC_CMDTM_TM_DAT_DIR_Msk;
}
EMMC->BLKSIZECNT = (cmdinfo->datalen / cmdinfo->blklen) << EMMC_BLKSIZECNT_BLKCNT_Pos |
cmdinfo->blklen << EMMC_BLKSIZECNT_BLKSIZE_Pos;
}
uint32_t response_type = EMMC_CMDTM_CMD_RSPNS_TYPE_RESPONSE_48BITS;
uint32_t crc = 0;
if ((cmdinfo->flags & SCF_RSP_CRC) != 0) {
crc |= EMMC_CMDTM_CMD_CRCCHK_EN_Msk;
}
if ((cmdinfo->flags & SCF_RSP_IDX) != 0) {
crc |= EMMC_CMDTM_CMD_IXCHK_EN_Msk;
}
if ((cmdinfo->flags & SCF_RSP_136) != 0) {
response_type = EMMC_CMDTM_CMD_RSPNS_TYPE_RESPONSE_136BITS;
} else if ((cmdinfo->flags & SCF_RSP_BSY) != 0) {
response_type = EMMC_CMDTM_CMD_RSPNS_TYPE_RESPONSE_48BITS_USING_BUSY;
} else if ((cmdinfo->flags & SCF_RSP_PRESENT) == 0) {
response_type = EMMC_CMDTM_CMD_RSPNS_TYPE_RESPONSE_NONE;
}
uint32_t full_cmd = cmd_flags | crc |
cmdinfo->opcode << EMMC_CMDTM_CMD_INDEX_Pos |
response_type << EMMC_CMDTM_CMD_RSPNS_TYPE_Pos;
EMMC->CMDTM = full_cmd;
// Wait for an interrupt to indicate completion of the command.
uint64_t start_ticks = port_get_raw_ticks(NULL);
while (EMMC->INTERRUPT == 0 && (port_get_raw_ticks(NULL) - start_ticks) < (size_t)cmdinfo->timeout_ms) {
}
if (!EMMC->INTERRUPT_b.CMD_DONE) {
cmdinfo->response[0] = 0;
// Reset the command circuit
EMMC->CONTROL1_b.SRST_CMD = true;
// Wait for the bit to clear
start_ticks = port_get_raw_ticks(NULL);
while (EMMC->CONTROL1_b.SRST_CMD && (port_get_raw_ticks(NULL) - start_ticks) < (size_t)cmdinfo->timeout_ms) {
}
return SDMMC_ERR_TIMEOUT;
} else {
EMMC->INTERRUPT = EMMC_INTERRUPT_CMD_DONE_Msk;
}
// Transfer the data.
// TODO: Use DMA
if (cmd_flags != 0) {
if (read) {
for (size_t i = 0; i < cmdinfo->datalen / sizeof(uint32_t); i++) {
start_ticks = port_get_raw_ticks(NULL);
while (!EMMC->INTERRUPT_b.READ_RDY && (port_get_raw_ticks(NULL) - start_ticks) < (size_t)cmdinfo->timeout_ms) {
}
if (!EMMC->INTERRUPT_b.READ_RDY) {
return SDMMC_ERR_TIMEOUT;
}
((uint32_t *)cmdinfo->data)[i] = EMMC->DATA;
}
} else {
for (size_t i = 0; i < cmdinfo->datalen / sizeof(uint32_t); i++) {
start_ticks = port_get_raw_ticks(NULL);
while (!EMMC->INTERRUPT_b.WRITE_RDY && (port_get_raw_ticks(NULL) - start_ticks) < (size_t)cmdinfo->timeout_ms) {
}
if (!EMMC->INTERRUPT_b.WRITE_RDY) {
return SDMMC_ERR_TIMEOUT;
}
EMMC->DATA = ((uint32_t *)cmdinfo->data)[i];
}
}
uint32_t data_done_mask = EMMC_INTERRUPT_ERR_Msk | EMMC_INTERRUPT_DATA_DONE_Msk;
start_ticks = port_get_raw_ticks(NULL);
while ((EMMC->INTERRUPT & data_done_mask) == 0 && (port_get_raw_ticks(NULL) - start_ticks) < (size_t)cmdinfo->timeout_ms) {
}
if (!EMMC->INTERRUPT_b.DATA_DONE) {
cmdinfo->response[0] = 0;
// Reset the command circuit
EMMC->CONTROL1_b.SRST_DATA = true;
// Wait for the bit to clear
start_ticks = port_get_raw_ticks(NULL);
while (EMMC->CONTROL1_b.SRST_DATA && (port_get_raw_ticks(NULL) - start_ticks) < (size_t)cmdinfo->timeout_ms) {
}
return SDMMC_ERR_TIMEOUT;
}
}
cmdinfo->response[0] = EMMC->RESP0;
if (response_type == EMMC_CMDTM_CMD_RSPNS_TYPE_RESPONSE_136BITS) {
// Rotate one more byte for some reason.
cmdinfo->response[3] = EMMC->RESP3 << 8 | ((EMMC->RESP2 >> 24) & 0xff);
cmdinfo->response[2] = EMMC->RESP2 << 8 | ((EMMC->RESP1 >> 24) & 0xff);
cmdinfo->response[1] = EMMC->RESP1 << 8 | ((EMMC->RESP0 >> 24) & 0xff);
cmdinfo->response[0] <<= 8;
}
return SDMMC_OK;
}
/*!< host function to deinitialize the driver, called with the `slot` */
STATIC sdmmc_err_t _deinit(int slot) {
return SDMMC_OK;
}
void common_hal_sdioio_sdcard_construct(sdioio_sdcard_obj_t *self,
const mcu_pin_obj_t *clock, const mcu_pin_obj_t *command,
uint8_t num_data, const mcu_pin_obj_t **data, uint32_t frequency) {
if (clock != NULL) {
gpio_set_function(clock->number, GPIO_GPFSEL4_FSEL48_SD1_CLK);
gpio_set_pull(clock->number, BP_PULL_NONE);
2022-01-04 22:08:14 -05:00
self->clock_pin = clock->number;
gpio_set_function(command->number, GPIO_GPFSEL4_FSEL49_SD1_CMD);
gpio_set_pull(command->number, BP_PULL_UP);
2022-01-04 22:08:14 -05:00
self->command_pin = command->number;
gpio_set_function(data[0]->number, GPIO_GPFSEL5_FSEL50_SD1_DAT0);
gpio_set_pull(data[0]->number, BP_PULL_UP);
2022-01-04 22:08:14 -05:00
self->data_pins[0] = data[0]->number;
gpio_set_function(data[1]->number, GPIO_GPFSEL5_FSEL51_SD1_DAT1);
gpio_set_pull(data[1]->number, BP_PULL_UP);
2022-01-04 22:08:14 -05:00
self->data_pins[1] = data[1]->number;
gpio_set_function(data[2]->number, GPIO_GPFSEL5_FSEL52_SD1_DAT2);
gpio_set_pull(data[2]->number, BP_PULL_UP);
2022-01-04 22:08:14 -05:00
self->data_pins[2] = data[2]->number;
gpio_set_function(data[3]->number, GPIO_GPFSEL5_FSEL53_SD1_DAT3);
gpio_set_pull(data[3]->number, BP_PULL_UP);
2022-01-04 22:08:14 -05:00
self->data_pins[3] = data[3]->number;
} else {
// Switch the sdcard to use the old arasan interface.
GPIO->EXTRA_MUX_b.SDIO = GPIO_EXTRA_MUX_SDIO_ARASAN;
}
2022-01-06 11:52:33 -05:00
COMPLETE_MEMORY_READS;
self->host_info = (sdmmc_host_t) {
.flags = SDMMC_HOST_FLAG_1BIT | SDMMC_HOST_FLAG_4BIT | SDMMC_HOST_FLAG_DEINIT_ARG,
.slot = 0,
.max_freq_khz = SDMMC_FREQ_HIGHSPEED,
.io_voltage = 3.3f,
.command_timeout_ms = 0,
.init = _init,
.set_bus_width = _set_bus_width,
.get_bus_width = _get_bus_width,
.set_bus_ddr_mode = NULL,
.set_card_clk = _set_card_clk,
.do_transaction = _do_transaction,
.deinit_p = _deinit,
};
// Reset the peripheral.
EMMC->CONTROL0 = 0;
EMMC->CONTROL1_b.SRST_HC = true;
// Wait for the bit to clear
while (EMMC->CONTROL1_b.SRST_HC) {
}
// Set max timeout
EMMC->CONTROL1 |= EMMC_CONTROL1_CLK_INTLEN_Msk | (0xe << EMMC_CONTROL1_DATA_TOUNIT_Pos);
EMMC->IRPT_MASK = 0xffffffff;
// Start clocking the card.
_set_card_clk(0, 400);
2022-01-04 22:08:14 -05:00
sdmmc_err_t err = SDMMC_ERR_INVALID_RESPONSE;
size_t tries = 3;
while (err == SDMMC_ERR_INVALID_RESPONSE && tries > 0) {
err = sdmmc_card_init(&self->host_info, &self->card_info);
if (err != SDMMC_OK) {
mp_printf(&mp_plat_print, "SD card init failed %d\n", err);
} else if (tries < 3) {
mp_printf(&mp_plat_print, "SD card init success\n");
}
tries--;
}
self->init = err == SDMMC_OK;
self->capacity = self->card_info.csd.capacity;
2022-01-06 11:52:33 -05:00
COMPLETE_MEMORY_READS;
}
uint32_t common_hal_sdioio_sdcard_get_count(sdioio_sdcard_obj_t *self) {
return self->capacity;
}
uint32_t common_hal_sdioio_sdcard_get_frequency(sdioio_sdcard_obj_t *self) {
return self->frequency;
}
uint8_t common_hal_sdioio_sdcard_get_width(sdioio_sdcard_obj_t *self) {
return self->num_data;
}
STATIC void check_whole_block(mp_buffer_info_t *bufinfo) {
if (bufinfo->len % 512) {
mp_raise_ValueError(translate("Buffer length must be a multiple of 512"));
}
}
int common_hal_sdioio_sdcard_writeblocks(sdioio_sdcard_obj_t *self, uint32_t start_block, mp_buffer_info_t *bufinfo) {
2022-01-04 22:08:14 -05:00
if (!self->init) {
return -EIO;
}
check_whole_block(bufinfo);
self->state_programming = true;
2022-01-06 11:52:33 -05:00
COMPLETE_MEMORY_READS;
sdmmc_err_t error = sdmmc_write_sectors(&self->card_info, bufinfo->buf,
start_block, bufinfo->len / 512);
2022-01-06 11:52:33 -05:00
COMPLETE_MEMORY_READS;
if (error != SDMMC_OK) {
mp_printf(&mp_plat_print, "write sectors result %d\n", error);
return -EIO;
}
return 0;
}
int common_hal_sdioio_sdcard_readblocks(sdioio_sdcard_obj_t *self, uint32_t start_block, mp_buffer_info_t *bufinfo) {
2022-01-04 22:08:14 -05:00
if (!self->init) {
return -EIO;
}
check_whole_block(bufinfo);
2022-01-06 11:52:33 -05:00
COMPLETE_MEMORY_READS;
sdmmc_err_t error = sdmmc_read_sectors(&self->card_info, bufinfo->buf,
start_block, bufinfo->len / 512);
2022-01-06 11:52:33 -05:00
COMPLETE_MEMORY_READS;
if (error != SDMMC_OK) {
mp_printf(&mp_plat_print, "read sectors result %d when reading block %d for %d\n", error, start_block, bufinfo->len / 512);
return -EIO;
}
return 0;
}
bool common_hal_sdioio_sdcard_configure(sdioio_sdcard_obj_t *self, uint32_t frequency, uint8_t bits) {
2022-01-04 22:08:14 -05:00
if (!self->init) {
return false;
}
return true;
}
bool common_hal_sdioio_sdcard_deinited(sdioio_sdcard_obj_t *self) {
return self->command_pin == COMMON_HAL_MCU_NO_PIN;
}
void common_hal_sdioio_sdcard_deinit(sdioio_sdcard_obj_t *self) {
reset_pin_number(self->command_pin);
reset_pin_number(self->clock_pin);
reset_pin_number(self->data_pins[0]);
reset_pin_number(self->data_pins[1]);
reset_pin_number(self->data_pins[2]);
reset_pin_number(self->data_pins[3]);
self->command_pin = COMMON_HAL_MCU_NO_PIN;
self->clock_pin = COMMON_HAL_MCU_NO_PIN;
self->data_pins[0] = COMMON_HAL_MCU_NO_PIN;
self->data_pins[1] = COMMON_HAL_MCU_NO_PIN;
self->data_pins[2] = COMMON_HAL_MCU_NO_PIN;
self->data_pins[3] = COMMON_HAL_MCU_NO_PIN;
2022-01-04 22:08:14 -05:00
self->init = false;
}
void common_hal_sdioio_sdcard_never_reset(sdioio_sdcard_obj_t *self) {
2022-01-04 22:08:14 -05:00
never_reset_pin_number(self->command_pin);
never_reset_pin_number(self->clock_pin);
never_reset_pin_number(self->data_pins[0]);
never_reset_pin_number(self->data_pins[1]);
never_reset_pin_number(self->data_pins[2]);
never_reset_pin_number(self->data_pins[3]);
}