include/sdmmc/sdmmc.h

Go to the documentation of this file.

#ifndef SDMMC_SDMMC_H_INCLUDED
#define SDMMC_SDMMC_H_INCLUDED

#include <types.h>
#include <bitops.h>
#include <slist.h>
#include <buffer.h>
#include <chip/portmux.h>
#include <dmac/dma_controller.h>

struct sdmmc_cid {
        uint8_t                 manufacturer_id;
        uint16_t                application_id;
        char                    name[6];
        uint8_t                 revision;
        uint32_t                serial;
        uint16_t                manu_year;
        uint8_t                 manu_month;
        uint8_t                 checksum;
};

struct sdmmc_csd {
        uint8_t         mmc_version;
        uint16_t        command_classes;
        uint16_t        read_access_time_clks;
        uint32_t        read_access_time_ns;
        uint32_t        write_speed_factor;
        uint32_t        max_transfer_rate;
        uint32_t        read_block_length;
        uint32_t        write_block_length;
        uint32_t        capacity;
        uint32_t        can_read_partial:1,
                                can_read_misaligned:1,
                                can_write_partial:1,
                                can_write_misaligned:1;
};

struct sdmmc_command {
        uint32_t                opcode;
        uint32_t                arg;
        uint32_t                resp[4];
        unsigned long           flags;
#define SDMMC_RSP_PRESENT       (1 << 0)        
#define SDMMC_RSP_136           (1 << 1)        
#define SDMMC_RSP_CRC           (1 << 2)        
#define SDMMC_RSP_BUSY          (1 << 3)        
#define SDMMC_RSP_MASK          (15)

/* Combinations of the above */
#define SDMMC_RSP_NONE  (0)
#define SDMMC_RSP_R1    (SDMMC_RSP_PRESENT | SDMMC_RSP_CRC)
#define SDMMC_RSP_R1B   (SDMMC_RSP_PRESENT | SDMMC_RSP_CRC | SDMMC_RSP_BUSY)
#define SDMMC_RSP_R2    (SDMMC_RSP_PRESENT | SDMMC_RSP_136 | SDMMC_RSP_CRC)
#define SDMMC_RSP_R3    (SDMMC_RSP_PRESENT)
#define SDMMC_RSP_R4    (SDMMC_RSP_PRESENT)
#define SDMMC_RSP_R5    (SDMMC_RSP_PRESENT | SDMMC_RSP_CRC)
#define SDMMC_RSP_R6    (SDMMC_RSP_PRESENT | SDMMC_RSP_CRC)
#define SDMMC_RSP_R7    (SDMMC_RSP_PRESENT | SDMMC_RSP_CRC)

#define SDMMC_CMD_OPD   (1 << 4)        /* open drain mode */

        int                     status;
};

enum sdmmc_req_flag {
        SDMMC_REQ_WRITE,        
        SDMMC_REQ_STOP,         
        SDMMC_REQ_INITSEQ,      
};

struct sdmmc_request {
        struct slist            buf_list;
        struct slist_node       node;
        struct sdmmc_command    cmd;
        struct sdmmc_slot       *slot;
        uint32_t                blocks;
        uint32_t                block_size;
        unsigned long           flags;
        void                    (*req_started)(struct sdmmc_request *req);
        void                    (*req_done)(struct sdmmc_request *req);
        void                    (*buf_list_done)(struct sdmmc_request *req,
                                        struct slist *buf_list);
        void                    *context;
        int                     status;
        size_t                  bytes_xfered;
};

enum sdmmc_card_type {
        SDMMC_CARD_TYPE_SD,
        SDMMC_CARD_TYPE_SDHC,
        SDMMC_CARD_TYPE_MMC,
        SDMMC_CARD_TYPE_SDIO
};

struct sdmmc_card {
        enum sdmmc_card_type    type;
        uint32_t                rca;
        struct sdmmc_cid        cid;
        struct sdmmc_csd        csd;
        uint32_t                block_size;
        /* Data read timeout (ns) */
        uint32_t                read_timeout_ns;
        /* Data read timeout (clks) */
        uint32_t                read_timeout_clks;
        /* Data write timeout (ns) */
        uint32_t                write_timeout_ns;
        /* Data write timeout (clks) */
        uint32_t                write_timeout_clks;
};

enum sdmmc_slot_flags {
        SDMMC_SLOT_CARD_DETECT,         
        SDMMC_SLOT_CARD_PRESENT,        
        SDMMC_SLOT_HCS,
        SDMMC_SLOT_HIGH_SPEED,          
        SDMMC_SLOT_PROBING,             
};

struct sdmmc_cd;

struct sdmmc_slot {
        int                     id;
        struct sdmmc_host       *host;
        unsigned long           flags;
        struct sdmmc_card       card;
        uint32_t                bcr;
        uint32_t                ocr;
        int                     bus_width;
        int                     bus_width_max;
        int32_t                 f_max;
        void                    (*notify_card_detect)(void *context);
        void                    *context;
        struct sdmmc_cd         *cd;
};

struct sdmmc_host {
        void                    (*enable)(struct sdmmc_host *host);
        void                    (*power_up)(struct sdmmc_host *host,
                                                struct sdmmc_slot *slot);
        void                    (*power_down)(struct sdmmc_host *host,
                                                struct sdmmc_slot *slot);
        void                    (*set_voltage)(struct sdmmc_host *host,
                                                uint32_t ocr);
        void                    (*set_bus_params)(struct sdmmc_host *host,
                                                struct sdmmc_slot *slot);
        int                     slot_count;
        struct sdmmc_slot       *(*get_slot)(struct sdmmc_host *host,
                                                int slot_id);
        bool                    (*wp_is_active)(struct sdmmc_host *host,
                                                struct sdmmc_slot *slot);
        void                    (*submit_req)(struct sdmmc_host *host,
                                                struct sdmmc_request *req);
        int                     (*submit_buf_list)(struct sdmmc_host *host,
                                                struct sdmmc_request *req,
                                                struct slist *buf_list);
        unsigned int            f_max;
        unsigned int            f_min;
        unsigned int            f_cur;
        uint32_t                ocr_avail;
};

static inline struct sdmmc_slot *sdmmc_card_get_slot(struct sdmmc_card *card)
{
        return container_of(card, struct sdmmc_slot, card);
}

extern void sdmmc_req_prep_transfer(struct sdmmc_slot *slot,
                struct sdmmc_request *req,
                uint32_t lba, uint32_t nr_blocks, bool write);

static inline void sdmmc_req_init(struct sdmmc_request *req)
{
        req->flags = 0;
        slist_init(&req->buf_list);
        req->blocks = 0;
        req->block_size = 0;
}

static inline void sdmmc_req_prep_cmd(struct sdmmc_request *req,
                uint32_t opcode, uint32_t arg, unsigned long flags)
{
        req->cmd.opcode = opcode;
        req->cmd.arg = arg;
        req->cmd.flags = flags;
}

static inline void sdmmc_req_prep_data(struct sdmmc_request *req,
                struct buffer *buf)
{
        slist_insert_tail(&req->buf_list, &buf->node);
        req->blocks = 1;
        req->block_size = buf->len;
}

static inline void sdmmc_req_prep_callback(struct sdmmc_request *req,
                void (*callback)(struct sdmmc_request *req),
                void *data)
{
        req->req_done = callback;
        req->context = data;
}

static inline void sdmmc_slot_update(struct sdmmc_slot *slot)
{
        struct sdmmc_host       *host = slot->host;

        host->set_bus_params(host, slot);
}

extern void sdmmc_decode_sd_cid(struct sdmmc_card *card, const be32_t *raw_cid);

extern int sdmmc_decode_mmc_cid(struct sdmmc_card *card, const be32_t *raw_cid);

extern int sdmmc_decode_sd_csd(struct sdmmc_card *card, const be32_t *raw_csd);

extern int sdmmc_decode_mmc_csd(struct sdmmc_card *card,
                const be32_t *raw_csd);

static inline void sdmmc_card_set_type(struct sdmmc_card *card,
                enum sdmmc_card_type type)
{
        card->type = type;
        sdmmc_slot_update(sdmmc_card_get_slot(card));
}

extern void sdmmc_card_update_timeouts(struct sdmmc_card *card,
                uint32_t mmc_hz);

static inline uint32_t sdmmc_card_get_rca(struct sdmmc_card *card)
{
        return card->rca >> 16;
}

static inline uint32_t sdmmc_card_block2addr(struct sdmmc_card *card,
                uint32_t lba)
{
        if (card->type == SDMMC_CARD_TYPE_SDHC)
                return lba;

        return lba * card->block_size;
}

extern void sdmmc_slot_submit_req(struct sdmmc_slot *slot,
                struct sdmmc_request *req);

static inline int sdmmc_req_submit_buf_list(struct sdmmc_host *host,
                struct sdmmc_request *req, struct slist *buf_list)
{
        assert(host && req && buf_list);

        return host->submit_buf_list(host, req, buf_list);
}

static inline bool sdmmc_slot_is_card_present(struct sdmmc_slot *slot)
{
        return test_bit(SDMMC_SLOT_CARD_PRESENT, &slot->flags);
}

static inline bool sdmmc_slot_is_card_write_protected(struct sdmmc_slot *slot)
{
        return slot->host->wp_is_active(slot->host, slot);
}

extern void sdmmc_slot_power_up(struct sdmmc_slot *slot);

extern void sdmmc_slot_power_down(struct sdmmc_slot *slot);

extern uint32_t sdmmc_slot_set_voltage(struct sdmmc_slot *slot, uint32_t ocr);

extern void sdmmc_slot_set_f_max(struct sdmmc_slot *slot, int32_t f_max);

extern void sdmmc_slot_set_bus_width(struct sdmmc_slot *slot,
                unsigned int bits);

extern void sdmmc_slot_notify_card_detect(struct sdmmc_slot *slot, int value);

extern void sdmmc_slot_init(struct sdmmc_slot *slot, struct sdmmc_host *host,
                int slot_id);

extern void sdmmc_probe_notify_card_detect(void *data);

extern void *sdmmc_probe_init(struct sdmmc_slot *slot,
                void (*event)(struct sdmmc_slot *slot, void *context),
                void *context);

extern struct sdmmc_cd *sdmmc_cd_init(struct sdmmc_slot *slot, gpio_pin_t pin);

extern void sdmmc_cd_enable(struct sdmmc_cd *cd);

static inline void sdmmc_host_enable(struct sdmmc_host *host)
{
        assert(host);
        assert(host->enable);

        host->enable(host);
}

#endif /* SDMMC_SDMMC_H_INCLUDED */

---