_sdcardio.SDIOSDCard: implement for STM32F405 Feather

This is hard coded to the bus specs of the Feather.

Author: jepler

ports/atmel-samd/common-hal/_sdcardio/SDIOSDCard.c

@@ -1,5 +1,17 @@
+#include "py/objtuple.h"
 #include "shared-bindings/board/__init__.h"
 
+STATIC const mp_rom_obj_tuple_t sdio_data_tuple = {
+    {&mp_type_tuple},
+    4,
+    {
+        MP_ROM_PTR(&pin_PC08),
+        MP_ROM_PTR(&pin_PC09),
+        MP_ROM_PTR(&pin_PC10),
+        MP_ROM_PTR(&pin_PC11),
+    }
+};
+
 STATIC const mp_rom_map_elem_t board_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_A0), MP_ROM_PTR(&pin_PA04) },
     { MP_ROM_QSTR(MP_QSTR_A1), MP_ROM_PTR(&pin_PA05) },
@@ -31,5 +43,9 @@ STATIC const mp_rom_map_elem_t board_module_globals_table[] = {
     { MP_ROM_QSTR(MP_QSTR_I2C), MP_ROM_PTR(&board_i2c_obj) },
     { MP_ROM_QSTR(MP_QSTR_SPI), MP_ROM_PTR(&board_spi_obj) },
     { MP_ROM_QSTR(MP_QSTR_UART), MP_ROM_PTR(&board_uart_obj) },
+
+    { MP_ROM_QSTR(MP_QSTR_SDIO_CLOCK), MP_ROM_PTR(&pin_PC11) },
+    { MP_ROM_QSTR(MP_QSTR_SDIO_COMMAND), MP_ROM_PTR(&pin_PD02) },
+    { MP_ROM_QSTR(MP_QSTR_SDIO_DATA), MP_ROM_PTR(&sdio_data_tuple) },
 };
 MP_DEFINE_CONST_DICT(board_module_globals, board_module_globals_table);

ports/atmel-samd/common-hal/_sdcardio/SDIOSDCard.h

@@ -0,0 +1,203 @@
+/*
+ * 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 "shared-bindings/_sdcardio/SDIOSDCard.h"
+#include "py/mperrno.h"
+#include "py/runtime.h"
+
+#include "shared-bindings/microcontroller/__init__.h"
+#include "boards/board.h"
+#include "supervisor/shared/translate.h"
+#include "common-hal/microcontroller/Pin.h"
+
+#ifndef DEBUG_SDIO
+#define DEBUG_SDIO (0)
+#endif
+
+#if DEBUG_SDIO
+#define DEBUG_PRINT(...) ((void)mp_printf(&mp_plat_print, __VA_ARGS__))
+#else
+#define DEBUG_PRINT(...) ((void)0)
+#endif
+
+void common_hal_sdcardio_sdio_construct(sdcardio_sdiosdcard_obj_t *self,
+        const mcu_pin_obj_t * clock, const mcu_pin_obj_t * command,
+        uint8_t num_data, mcu_pin_obj_t ** data, uint32_t frequency) {
+    // constructor arguments are ignored, and the hard-wired SD slot on the board is used.
+
+    GPIO_InitTypeDef  GPIO_InitStruct;
+
+    // /* GPIOC and GPIOD Periph clock enable */
+    // RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD | SD_DETECT_GPIO_CLK, ENABLE);
+
+    /* Configure PC.08, PC.09, PC.10, PC.11 pins: D0, D1, D2, D3 pins */
+    GPIO_InitStruct.Pin = GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11;
+    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_PULLUP;
+    GPIO_InitStruct.Alternate = 12; // is there an identifier for this?
+    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
+
+    /* Configure PD.02 CMD line */
+    GPIO_InitStruct.Pin = GPIO_PIN_2;
+    HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
+
+    /* Configure PC.12 pin: CLK pin */
+    GPIO_InitStruct.Pin = GPIO_PIN_12;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
+
+#define SD_DETECT_PIN GPIO_PIN_12
+#define SD_DETECT_GPIO_PORT GPIOB
+
+    /*!< Configure SD_SPI_DETECT_PIN pin: SD Card detect pin */
+    GPIO_InitStruct.Pin = SD_DETECT_PIN;
+    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
+    GPIO_InitStruct.Pull = GPIO_PULLUP;
+    HAL_GPIO_Init(SD_DETECT_GPIO_PORT, &GPIO_InitStruct);
+
+    __HAL_RCC_SDIO_CLK_ENABLE();
+
+    self->handle.Init.ClockDiv = SDIO_TRANSFER_CLK_DIV;
+    self->handle.Init.ClockEdge = SDIO_CLOCK_EDGE_RISING;
+    self->handle.Init.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
+    self->handle.Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
+    self->handle.Init.BusWide = SDIO_BUS_WIDE_1B;
+    self->handle.Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
+    self->handle.Instance = SDIO;
+
+    HAL_StatusTypeDef r = HAL_SD_Init(&self->handle);
+    if (r != HAL_OK) {
+        mp_raise_ValueError_varg(translate("SDIO Init Error %d"), (int)r);
+    }
+
+    HAL_SD_CardInfoTypeDef info;
+    r = HAL_SD_GetCardInfo(&self->handle, &info);
+    if (r != HAL_OK) {
+        mp_raise_ValueError_varg(translate("SDIO GetCardInfo Error %d"), (int)r);
+    }
+
+    if ((r = HAL_SD_ConfigWideBusOperation(&self->handle, SDIO_BUS_WIDE_4B)) == HAL_SD_ERROR_NONE) {
+        DEBUG_PRINT("Switched bus to 4B mode\n");
+        self->handle.Init.BusWide = SDIO_BUS_WIDE_4B;
+        self->width = 4;
+    } else {
+        DEBUG_PRINT("WideBus_Enable returned %r, leaving at 1B mode\n", (int)r);
+        self->width = 1;
+    }
+
+    self->capacity = info.BlockNbr * (info.BlockSize / 512);
+    self->frequency = 25000000;
+
+    return;
+}
+
+uint32_t common_hal_sdcardio_sdio_get_count(sdcardio_sdiosdcard_obj_t *self) {
+    return self->capacity;
+}
+
+uint32_t common_hal_sdcardio_sdio_get_frequency(sdcardio_sdiosdcard_obj_t *self) {
+    return self->frequency; // self->frequency;
+}
+
+uint8_t common_hal_sdcardio_sdio_get_width(sdcardio_sdiosdcard_obj_t *self) {
+    return self->width; // self->width;
+}
+
+STATIC void check_for_deinit(sdcardio_sdiosdcard_obj_t *self) {
+}
+
+STATIC void check_whole_block(mp_buffer_info_t *bufinfo) {
+    if (bufinfo->len % 512) {
+        mp_raise_ValueError(translate("Buffer must be a multiple of 512 bytes"));
+    }
+}
+
+STATIC void wait_write_complete(sdcardio_sdiosdcard_obj_t *self) {
+    if (self->state_programming) {
+        HAL_SD_CardStateTypedef st = HAL_SD_CARD_PROGRAMMING;
+        for (int i=0; i < 50000 && st == HAL_SD_CARD_PROGRAMMING; i++) {
+            st = HAL_SD_GetCardState(&self->handle);
+            HAL_Delay(10);
+        };
+        self->state_programming = false;
+    }
+}
+
+STATIC void debug_print_state(sdcardio_sdiosdcard_obj_t *self, const char *what) {
+#if DEBUG_SDIO
+    HAL_SD_CardStateTypedef st = HAL_SD_GetCardState(&self->handle);
+    DEBUG_PRINT("%s, st=0x%x State=0x%x ErrorCode=0x%x\n", what, (int)st, self->handle.State, self->handle.ErrorCode);
+#endif
+}
+
+int common_hal_sdcardio_sdio_writeblocks(sdcardio_sdiosdcard_obj_t *self, uint32_t start_block, mp_buffer_info_t *bufinfo) {
+    check_for_deinit(self);
+    check_whole_block(bufinfo);
+    wait_write_complete(self);
+    self->state_programming = true;
+    common_hal_mcu_disable_interrupts();
+    HAL_StatusTypeDef r = HAL_SD_WriteBlocks(&self->handle, bufinfo->buf, start_block, bufinfo->len / 512, 1000);
+    common_hal_mcu_enable_interrupts();
+    if (r != HAL_OK) {
+        debug_print_state(self, "after writeblocks error");
+        return -EIO;
+    }
+    // debug_print_state(self, "after writeblocks OK");
+    // debug_print_state(self, "after writeblocks complete");
+    return 0;
+}
+
+int common_hal_sdcardio_sdio_readblocks(sdcardio_sdiosdcard_obj_t *self, uint32_t start_block, mp_buffer_info_t *bufinfo) {
+    check_for_deinit(self);
+    check_whole_block(bufinfo);
+    wait_write_complete(self);
+    common_hal_mcu_disable_interrupts();
+    HAL_StatusTypeDef r = HAL_SD_ReadBlocks(&self->handle, bufinfo->buf, start_block, bufinfo->len / 512, 1000);
+    common_hal_mcu_enable_interrupts();
+    if (r != HAL_OK) {
+        debug_print_state(self, "after readblocks error");
+        return -EIO;
+    }
+    return 0;
+}
+
+bool common_hal_sdcardio_sdio_configure(sdcardio_sdiosdcard_obj_t *self, uint32_t frequency, uint8_t bits) {
+    check_for_deinit(self);
+    return true;
+}
+
+bool common_hal_sdcardio_sdio_deinited(sdcardio_sdiosdcard_obj_t *self) {
+    return false;
+}
+
+void common_hal_sdcardio_sdio_deinit(sdcardio_sdiosdcard_obj_t *self) {
+}
+
+void common_hal_sdcardio_sdio_never_reset(sdcardio_sdiosdcard_obj_t *self) {
+}
+

ports/cxd56/common-hal/_sdcardio/SDIOSDCard.c

@@ -0,0 +1,52 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 Scott Shawcroft
+ * Copyright (c) 2019 Lucian Copeland 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.
+ */
+
+#ifndef MICROPY_INCLUDED_STM32_COMMON_HAL_BUSIO_SDIO_H
+#define MICROPY_INCLUDED_STM32_COMMON_HAL_BUSIO_SDIO_H
+
+#include "common-hal/microcontroller/Pin.h"
+
+#include "peripherals/periph.h"
+
+#include "py/obj.h"
+
+typedef struct {
+    mp_obj_base_t base;
+    SD_HandleTypeDef handle;
+    bool has_lock;
+    const mcu_periph_obj_t *cmd;
+    const mcu_periph_obj_t *clock;
+    const mcu_periph_obj_t *data[8];
+    uint32_t frequency;
+    uint8_t num_data:3, width:3, state_programming:1;
+    uint32_t capacity;
+} sdcardio_sdiosdcard_obj_t;
+
+void sdio_reset(void);
+
+#endif // MICROPY_INCLUDED_STM32_COMMON_HAL_BUSIO_SDIO_H
+

ports/cxd56/common-hal/_sdcardio/SDIOSDCard.h

@@ -6,6 +6,8 @@ USB_SERIAL_NUMBER_LENGTH = 24
 ifeq ($(MCU_VARIANT),STM32F405xx)
 	CIRCUITPY_FRAMEBUFFERIO = 1
 	CIRCUITPY_RGBMATRIX = 1
+	CIRCUITPY_SDCARDIO = 1
+	CIRCUITPY_SDCARDIO_SDIO = 1
 endif
 
 ifeq ($(MCU_SERIES),F4)

ports/esp32s2/common-hal/_sdcardio/SDIOSDCard.c

@@ -454,3 +454,18 @@ void _init(void)
 
 }
 
+void HAL_Delay(uint32_t delay) {
+    if (delay > 1000) {
+        mp_hal_delay_ms(delay / 1000);
+        delay %= 1000;
+    }
+    mp_hal_delay_us(delay);
+}
+
+#if 0
+uint32_t HAL_GetTick() {
+    uint8_t subticks;
+    uint32_t result = (uint32_t)port_get_raw_ticks(&subticks);
+    return (result * 1000) + (subticks * 1000 / 32);
+}
+#endif

ports/esp32s2/common-hal/_sdcardio/SDIOSDCard.h

@@ -302,6 +302,7 @@ SRC_COMMON_HAL_ALL = \
 	rotaryio/__init__.c \
 	rtc/RTC.c \
 	rtc/__init__.c \
+	_sdcardio/SDIOSDCard.c \
 	supervisor/Runtime.c \
 	supervisor/__init__.c
 

ports/litex/common-hal/_sdcardio/SDIOSDCard.c

@@ -85,6 +85,9 @@ CFLAGS += -DCIRCUITPY_BOARD=$(CIRCUITPY_BOARD)
 CIRCUITPY_BUSIO ?= 1
 CFLAGS += -DCIRCUITPY_BUSIO=$(CIRCUITPY_BUSIO)
 
+CIRCUITPY_BUSIO_SDIO ?= 0
+CFLAGS += -DCIRCUITPY_BUSIO_SDIO=$(CIRCUITPY_BUSIO_SDIO)
+
 CIRCUITPY_DIGITALIO ?= 1
 CFLAGS += -DCIRCUITPY_DIGITALIO=$(CIRCUITPY_DIGITALIO)
 
@@ -166,6 +169,9 @@ CFLAGS += -DCIRCUITPY_SAMD=$(CIRCUITPY_SAMD)
 CIRCUITPY_SDCARDIO ?= $(CIRCUITPY_FULL_BUILD)
 CFLAGS += -DCIRCUITPY_SDCARDIO=$(CIRCUITPY_SDCARDIO)
 
+CIRCUITPY_SDCARDIO_SDIO ?= 0
+CFLAGS += -DCIRCUITPY_SDCARDIO_SDIO=$(CIRCUITPY_SDCARDIO_SDIO)
+
 # Currently always off.
 CIRCUITPY_STAGE ?= 0
 CFLAGS += -DCIRCUITPY_STAGE=$(CIRCUITPY_STAGE)