sdhc.h

Go to the documentation of this file.

/*
 * Copyright 2022, 2025 NXP
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_SDHC_H_
#define ZEPHYR_INCLUDE_DRIVERS_SDHC_H_
 
#include <errno.h>
#include <zephyr/device.h>
#include <zephyr/net_buf.h>
#include <zephyr/sd/sd_spec.h>

 
#ifdef __cplusplus
extern "C" {
#endif
 

#define SDHC_TIMEOUT_FOREVER (-1)

struct sdhc_command {
        uint32_t opcode; 
        uint32_t arg; 
        uint32_t response[4]; 
        uint32_t response_type; 
        unsigned int retries; 
        int timeout_ms; 
};
 
#define SDHC_NATIVE_RESPONSE_MASK 0xF
#define SDHC_SPI_RESPONSE_TYPE_MASK 0xF0

struct sdhc_data {
        unsigned int block_addr; 
        unsigned int block_size; 
        unsigned int blocks; 
        unsigned int bytes_xfered; 
#if defined(CONFIG_SDHC_SCATTER_GATHER_TRANSFER) || defined(__DOXYGEN__)
        bool is_sg_data; 
#endif
        void *data; 
        int timeout_ms; 
};

enum sdhc_bus_mode {
        SDHC_BUSMODE_OPENDRAIN = 1,
        SDHC_BUSMODE_PUSHPULL = 2,
};

enum sdhc_power {
        SDHC_POWER_OFF = 1,
        SDHC_POWER_ON = 2,
};

enum sdhc_bus_width {
        SDHC_BUS_WIDTH1BIT = 1U,
        SDHC_BUS_WIDTH4BIT = 4U,
        SDHC_BUS_WIDTH8BIT = 8U,
};

enum sdhc_timing_mode {
        SDHC_TIMING_LEGACY = 1U,
        SDHC_TIMING_HS = 2U,
        SDHC_TIMING_SDR12 = 3U,
        SDHC_TIMING_SDR25 = 4U,
        SDHC_TIMING_SDR50 = 5U,
        SDHC_TIMING_SDR104 = 6U,
        SDHC_TIMING_DDR50 = 7U,
        SDHC_TIMING_DDR52 = 8U,
        SDHC_TIMING_HS200 = 9U,
        SDHC_TIMING_HS400 = 10U,
};

enum sd_voltage {
        SD_VOL_3_3_V = 1U,
        SD_VOL_3_0_V = 2U,
        SD_VOL_1_8_V = 3U,
        SD_VOL_1_2_V = 4U,
};

struct sdhc_host_caps {
        unsigned int timeout_clk_freq: 6;               
        unsigned int _rsvd_6: 1;                        
        unsigned int timeout_clk_unit: 1;               
        unsigned int sd_base_clk: 8;                    
        unsigned int max_blk_len: 2;                    
        unsigned int bus_8_bit_support: 1;              
        unsigned int adma_2_support: 1;                 
        unsigned int _rsvd_20: 1;                       
        unsigned int high_spd_support: 1;               
        unsigned int sdma_support: 1;                   
        unsigned int suspend_res_support: 1;            
        unsigned int vol_330_support: 1;                
        unsigned int vol_300_support: 1;                
        unsigned int vol_180_support: 1;                
        unsigned int address_64_bit_support_v4: 1;      
        unsigned int address_64_bit_support_v3: 1;      
        unsigned int sdio_async_interrupt_support: 1;   
        unsigned int slot_type: 2;                      
        unsigned int sdr50_support: 1;                  
        unsigned int sdr104_support: 1;                 
        unsigned int ddr50_support: 1;                  
        unsigned int uhs_2_support: 1;                  
        unsigned int drv_type_a_support: 1;             
        unsigned int drv_type_c_support: 1;             
        unsigned int drv_type_d_support: 1;             
        unsigned int _rsvd_39: 1;                       
        unsigned int retune_timer_count: 4;             
        unsigned int _rsvd_44: 1;                       
        unsigned int sdr50_needs_tuning: 1;             
        unsigned int retuning_mode: 2;                  
        unsigned int clk_multiplier: 8;                 
        unsigned int _rsvd_56: 3;                       
        unsigned int adma3_support: 1;                  
        unsigned int vdd2_180_support: 1;               
        unsigned int _rsvd_61: 3;                       
};

struct sdhc_io {
        enum sdhc_clock_speed clock; 
        enum sdhc_bus_mode bus_mode; 
        enum sdhc_power power_mode; 
        enum sdhc_bus_width bus_width; 
        enum sdhc_timing_mode timing; 
        bool enhanced_strobe;         
        enum sd_driver_type driver_type; 
        enum sd_voltage signal_voltage; 
};

struct sdhc_host_props {
        unsigned int f_max; 
        unsigned int f_min; 
        unsigned int power_delay; 
        struct sdhc_host_caps host_caps; 
        uint32_t max_current_330; 
        uint32_t max_current_300; 
        uint32_t max_current_180; 
        bool bus_4_bit_support; 
        bool hs200_support; 
        bool hs400_support; 
        bool hs400_enhanced_strobe_support; 
        bool is_spi; 
};

enum sdhc_interrupt_source {
        SDHC_INT_SDIO = BIT(0), 
        SDHC_INT_INSERTED = BIT(1), 
        SDHC_INT_REMOVED = BIT(2), 
};

typedef void (*sdhc_interrupt_cb_t)(const struct device *dev, int reason,
                                    const void *user_data);


__subsystem struct sdhc_driver_api {
        int (*reset)(const struct device *dev);
        int (*request)(const struct device *dev,
                       struct sdhc_command *cmd,
                       struct sdhc_data *data);
        int (*set_io)(const struct device *dev, struct sdhc_io *ios);
        int (*get_card_present)(const struct device *dev);
        int (*execute_tuning)(const struct device *dev);
        int (*card_busy)(const struct device *dev);
        int (*get_host_props)(const struct device *dev,
                              struct sdhc_host_props *props);
        int (*enable_interrupt)(const struct device *dev,
                                sdhc_interrupt_cb_t callback,
                                int sources, void *user_data);
        int (*disable_interrupt)(const struct device *dev, int sources);
};


__syscall int sdhc_hw_reset(const struct device *dev);
 
static inline int z_impl_sdhc_hw_reset(const struct device *dev)
{
        const struct sdhc_driver_api *api = DEVICE_API_GET(sdhc, dev);
 
        if (!api->reset) {
                return -ENOSYS;
        }
 
        return api->reset(dev);
}
 

__syscall int sdhc_request(const struct device *dev, struct sdhc_command *cmd,
                           struct sdhc_data *data);
 
static inline int z_impl_sdhc_request(const struct device *dev,
                                      struct sdhc_command *cmd,
                                      struct sdhc_data *data)
{
        const struct sdhc_driver_api *api = DEVICE_API_GET(sdhc, dev);
 
        return api->request(dev, cmd, data);
}

__syscall int sdhc_set_io(const struct device *dev, struct sdhc_io *io);
 
static inline int z_impl_sdhc_set_io(const struct device *dev,
                                     struct sdhc_io *io)
{
        const struct sdhc_driver_api *api = DEVICE_API_GET(sdhc, dev);
 
        return api->set_io(dev, io);
}

__syscall int sdhc_card_present(const struct device *dev);
 
static inline int z_impl_sdhc_card_present(const struct device *dev)
{
        const struct sdhc_driver_api *api = DEVICE_API_GET(sdhc, dev);
 
        return api->get_card_present(dev);
}
 

__syscall int sdhc_execute_tuning(const struct device *dev);
 
static inline int z_impl_sdhc_execute_tuning(const struct device *dev)
{
        const struct sdhc_driver_api *api = DEVICE_API_GET(sdhc, dev);
 
        if (!api->execute_tuning) {
                return -ENOSYS;
        }
 
        return api->execute_tuning(dev);
}

__syscall int sdhc_card_busy(const struct device *dev);
 
static inline int z_impl_sdhc_card_busy(const struct device *dev)
{
        const struct sdhc_driver_api *api = DEVICE_API_GET(sdhc, dev);
 
        return api->card_busy(dev);
}
 

__syscall int sdhc_get_host_props(const struct device *dev,
                                  struct sdhc_host_props *props);
 
static inline int z_impl_sdhc_get_host_props(const struct device *dev,
                                             struct sdhc_host_props *props)
{
        const struct sdhc_driver_api *api = DEVICE_API_GET(sdhc, dev);
 
        return api->get_host_props(dev, props);
}

__syscall int sdhc_enable_interrupt(const struct device *dev,
                                    sdhc_interrupt_cb_t callback,
                                    int sources, void *user_data);
 
static inline int z_impl_sdhc_enable_interrupt(const struct device *dev,
                                               sdhc_interrupt_cb_t callback,
                                               int sources, void *user_data)
{
        const struct sdhc_driver_api *api = DEVICE_API_GET(sdhc, dev);
 
        if (!api->enable_interrupt) {
                return -ENOSYS;
        }
 
        return api->enable_interrupt(dev, callback, sources, user_data);
}

__syscall int sdhc_disable_interrupt(const struct device *dev, int sources);
 
static inline int z_impl_sdhc_disable_interrupt(const struct device *dev,
                                                int sources)
{
        const struct sdhc_driver_api *api = DEVICE_API_GET(sdhc, dev);
 
        if (!api->disable_interrupt) {
                return -ENOSYS;
        }
 
        return api->disable_interrupt(dev, sources);
}

 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/sdhc.h>
#endif /* ZEPHYR_INCLUDE_DRIVERS_SDHC_H_ */