8. [mmc subsystem] host（第二章）——sdhci

一、sdhci core说明

1、sdhci说明

具体参考《host（第一章）——概述》

SDHC：Secure Digital(SD) Host Controller，是指一套sd host控制器的设计标准，其寄存器偏移以及意义都有一定的规范，并且提供了对应的驱动程序，方便vendor进行host controller的开发。

vendor按照这套标准设计host controller之后，可以直接使用sdhci driver来实现host controller的使用，（qcom和samsung都使用了这套标准）。而vendor只需要实现平台相关的部分、如clock、pinctrl、power等等的部分即可。

关于这个标准，我们可以参考《SDHC_Ver3.00_Final_110225》。

注意，强调一下，这是一种mmc host controller的设计标准，其本质上还是属于mmc host。并且，其兼容mmc type card，而不是说只能使用于sd type card。

2、sdhci core

因为sdhci driver并不是某个特定host的driver，而是提供了一些接口和操作集方法给对应的host driver使用。

因此，我们将sdhci.c的代码部分称之为sdhci core用以和host driver区分。

其主要功能如下：

• 为host driver提供分配、释放sdhci_host的接口
• 为host driver提供注册、卸载sdhci_host的接口
• 实现sdhci_host和mmc_host的对接（也就是mmc core的对接）
• 实现host关于SDHCI标准的通用操作（sdhci_ops）
• 实现host的通用电源管理操作

注意，clock和pinctrl是由host driver自己管理，sdhci core并不参与。

3、代码位置

drivers/mmc/host/sdhci.c
drivers/mmc/host/sdhci.h

二、数据结构

1、struct sdhci_host

sdhci core将host抽象出struct sdhci_host来进行管理和维护。

数据结构如下：

struct sdhci_host {
    /* Data set by hardware interface driver */
    const char *hw_name;    /* Hardware bus name */      // 名称
    unsigned int quirks;    /* Deviations from spec. */         // 癖好，可以理解为硬件sdhci controller和标准sdhci规范不符合的地方。
    unsigned int quirks2;   /* More deviations from spec. */   // 癖好2，可以理解为硬件sdhci controller和标准sdhci规范不符合的地方。

    int irq;        /* Device IRQ */      // sdhci的中断
    void __iomem *ioaddr;   /* Mapped address */   // sdhci寄存器的基地址
    const struct sdhci_ops *ops;    /* Low level hw interface */      // 底层硬件的操作接口

    struct regulator *vmmc;     /* Power regulator (vmmc) */       // sdhci core的LDO
    struct regulator *vqmmc;    /* Signaling regulator (vccq) */      // 给sdhci io供电的LDO

    /* Internal data */
    struct mmc_host *mmc;   /* MMC structure */      // struct mmc_host，用于注册到mmc subsystem中
    u64 dma_mask;       /* custom DMA mask */

    spinlock_t lock;    /* Mutex */      // 自旋锁
    int flags;      /* Host attributes */   // sdhci的一些标识
    unsigned int version;   /* SDHCI spec. version */   // 当前sdhci的硬件版本
    unsigned int max_clk;   /* Max possible freq (MHz) */   // 该sdhci支持的最大电压
    unsigned int timeout_clk;   /* Timeout freq (KHz) */   // 超时频率
    unsigned int clk_mul;   /* Clock Muliplier value */   // 当前倍频值
    unsigned int clock; /* Current clock (MHz) */      // 当前工作频率
    u8 pwr;         /* Current voltage */   // 当前工作电压
    bool runtime_suspended; /* Host is runtime suspended */      // 是否处于runtime suspend状态
    struct mmc_request *mrq;    /* Current request */      // 当前正在处理的请求
    struct mmc_command *cmd;    /* Current command */   // 当前的命令请求
    struct mmc_data *data;  /* Current data request */      // 当前的数据请求
    unsigned int data_early:1;  /* Data finished before cmd */   // 表示在CMD处理完成前，data已经处理完成

    struct sg_mapping_iter sg_miter;    /* SG state for PIO */
    unsigned int blocks;    /* remaining PIO blocks */
    int sg_count;       /* Mapped sg entries */
    u8 *adma_desc;      /* ADMA descriptor table */
    u8 *align_buffer;   /* Bounce buffer */
    unsigned int adma_desc_sz; /* ADMA descriptor table size */
    unsigned int adma_desc_line_sz; /* ADMA descriptor line size */
    unsigned int align_buf_sz; /* Bounce buffer size */
    unsigned int align_bytes; /* Alignment bytes (4/8 for 32-bit/64-bit) */
    unsigned int adma_max_desc; /* Max ADMA descriptos (max sg segments) */
    dma_addr_t adma_addr;   /* Mapped ADMA descr. table */
    dma_addr_t align_addr;  /* Mapped bounce buffer */

    struct tasklet_struct card_tasklet; /* Tasklet structures */      // card tasklet，用于处理card的插入或者拔出事件
    struct tasklet_struct finish_tasklet;      // finsh tasklet，用来通知上层一个请求处理完成（包括出错的情况）

    struct timer_list timer;    /* Timer for timeouts */   // 超时定时器链表

    u32 caps;       /* Alternative CAPABILITY_0 */   // 表示该sdhci controller的属性
    u32 caps1;      /* Alternative CAPABILITY_1 */   // 表示该sdhci controller的属性

    unsigned int            ocr_avail_sdio; /* OCR bit masks */   // 在该sdhci controller上可用的sdio card的ocr值掩码（代表了其可用电压）
    unsigned int            ocr_avail_sd;   // 在该sdhci controller上可用的sd card的ocr值掩码（代表了其可用电压）
    unsigned int            ocr_avail_mmc;   /// 在该sdhci controller上可用的mmc card的ocr值掩码（代表了其可用电压） 

/* 以下和mmc的tuning相关 */
    wait_queue_head_t   buf_ready_int;  /* Waitqueue for Buffer Read Ready interrupt */
    unsigned int        tuning_done;    /* Condition flag set when CMD19 succeeds */
    unsigned int        tuning_count;   /* Timer count for re-tuning */
    unsigned int        tuning_mode;    /* Re-tuning mode supported by host */
#define SDHCI_TUNING_MODE_1 0
    struct timer_list   tuning_timer;   /* Timer for tuning */

/* 以下和sdhci的qos相关 */
    struct sdhci_host_qos host_qos[SDHCI_QOS_MAX_POLICY];
    enum sdhci_host_qos_policy last_qos_policy;
    bool host_use_default_qos;
    unsigned int pm_qos_timeout_us;         /* timeout for PM QoS request */
    struct device_attribute pm_qos_tout;
    struct delayed_work pm_qos_work;

    struct sdhci_next next_data;
    ktime_t data_start_time;
    struct mutex ios_mutex;
    enum sdhci_power_policy power_policy;

    bool irq_enabled; /* host irq status flag */      // 表示中断是否使能？
    bool async_int_supp;  /* async support to rxv int, when clks are off */
    bool disable_sdio_irq_deferred; /* status of disabling sdio irq */
    u32 auto_cmd_err_sts;
    struct ratelimit_state dbg_dump_rs;
    int reset_wa_applied; /* reset workaround status */
    ktime_t reset_wa_t; /* time when the reset workaround is applied */
    int reset_wa_cnt; /* total number of times workaround is used */

    unsigned long private[0] ____cacheline_aligned;      // 私有数据指针
};

• 癖好1（sdhci_host->quirks）各个位意义如下：

/* Controller doesn't honor resets unless we touch the clock register */
#define SDHCI_QUIRK_CLOCK_BEFORE_RESET            (1<<0)
/* Controller has bad caps bits, but really supports DMA */
#define SDHCI_QUIRK_FORCE_DMA                (1<<1)
/* Controller doesn't like to be reset when there is no card inserted. */
#define SDHCI_QUIRK_NO_CARD_NO_RESET            (1<<2)
/* Controller doesn't like clearing the power reg before a change */
#define SDHCI_QUIRK_SINGLE_POWER_WRITE            (1<<3)
/* Controller has flaky internal state so reset it on each ios change */
#define SDHCI_QUIRK_RESET_CMD_DATA_ON_IOS        (1<<4)
/* Controller has an unusable DMA engine */
#define SDHCI_QUIRK_BROKEN_DMA                (1<<5)
/* Controller has an unusable ADMA engine */
#define SDHCI_QUIRK_BROKEN_ADMA                (1<<6)
/* Controller can only DMA from 32-bit aligned addresses */
#define SDHCI_QUIRK_32BIT_DMA_ADDR            (1<<7)
/* Controller can only DMA chunk sizes that are a multiple of 32 bits */
#define SDHCI_QUIRK_32BIT_DMA_SIZE            (1<<8)
/* Controller can only ADMA chunks that are a multiple of 32 bits */
#define SDHCI_QUIRK_32BIT_ADMA_SIZE            (1<<9)
/* Controller needs to be reset after each request to stay stable */
#define SDHCI_QUIRK_RESET_AFTER_REQUEST            (1<<10)
/* Controller needs voltage and power writes to happen separately */
#define SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER        (1<<11)
/* Controller provides an incorrect timeout value for transfers */
#define SDHCI_QUIRK_BROKEN_TIMEOUT_VAL            (1<<12)
/* Controller has an issue with buffer bits for small transfers */
#define SDHCI_QUIRK_BROKEN_SMALL_PIO            (1<<13)
/* Controller does not provide transfer-complete interrupt when not busy */
#define SDHCI_QUIRK_NO_BUSY_IRQ                (1<<14)
/* Controller has unreliable card detection */
#define SDHCI_QUIRK_BROKEN_CARD_DETECTION        (1<<15)
/* Controller reports inverted write-protect state */
#define SDHCI_QUIRK_INVERTED_WRITE_PROTECT        (1<<16)
/* Controller has nonstandard clock management */
#define SDHCI_QUIRK_NONSTANDARD_CLOCK            (1<<17)
/* Controller does not like fast PIO transfers */
#define SDHCI_QUIRK_PIO_NEEDS_DELAY            (1<<18)
/* Controller losing signal/interrupt enable states after reset */
#define SDHCI_QUIRK_RESTORE_IRQS_AFTER_RESET        (1<<19)
/* Controller has to be forced to use block size of 2048 bytes */
#define SDHCI_QUIRK_FORCE_BLK_SZ_2048            (1<<20)
/* Controller cannot do multi-block transfers */
#define SDHCI_QUIRK_NO_MULTIBLOCK            (1<<21)
/* Controller can only handle 1-bit data transfers */
#define SDHCI_QUIRK_FORCE_1_BIT_DATA            (1<<22)
/* Controller needs 10ms delay between applying power and clock */
#define SDHCI_QUIRK_DELAY_AFTER_POWER            (1<<23)
/* Controller uses SDCLK instead of TMCLK for data timeouts */
#define SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK        (1<<24)
/* Controller reports wrong base clock capability */
#define SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN        (1<<25)
/* Controller cannot support End Attribute in NOP ADMA descriptor */
#define SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC        (1<<26)
/* Controller is missing device caps. Use caps provided by host */
#define SDHCI_QUIRK_MISSING_CAPS            (1<<27)
/* Controller uses Auto CMD12 command to stop the transfer */
#define SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12        (1<<28)
/* Controller doesn't have HISPD bit field in HI-SPEED SD card */
#define SDHCI_QUIRK_NO_HISPD_BIT            (1<<29)
/* Controller treats ADMA descriptors with length 0000h incorrectly */
#define SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC        (1<<30)
/* The read-only detection via SDHCI_PRESENT_STATE register is unstable */
#define SDHCI_QUIRK_UNSTABLE_RO_DETECT            (1<<31)

• 癖好2（sdhci_host->quirks2）各个位意义如下：

#define SDHCI_QUIRK2_HOST_OFF_CARD_ON           (1<<0)
#define SDHCI_QUIRK2_HOST_NO_CMD23          (1<<1)
/* The system physically doesn't support 1.8v, even if the host does */
#define SDHCI_QUIRK2_NO_1_8_V               (1<<2)
#define SDHCI_QUIRK2_PRESET_VALUE_BROKEN        (1<<3)
/*
 * Read Transfer Active/ Write Transfer Active may be not
 * de-asserted after end of transaction. Issue reset for DAT line.
 */
#define SDHCI_QUIRK2_RDWR_TX_ACTIVE_EOT         (1<<4)
/*
 * Slow interrupt clearance at 400KHz may cause
 * host controller driver interrupt handler to
 * be called twice.
 */
#define SDHCI_QUIRK2_SLOW_INT_CLR           (1<<5)
/*
 * If the base clock can be scalable, then there should be no further
 * clock dividing as the input clock itself will be scaled down to
 * required frequency.
 */
#define SDHCI_QUIRK2_ALWAYS_USE_BASE_CLOCK      (1<<6)
/*
 * Dont use the max_discard_to in sdhci driver so that the maximum discard
 * unit gets picked by the mmc queue. Otherwise, it takes a long time for
 * secure discard kind of operations to complete.
 */
#define SDHCI_QUIRK2_USE_MAX_DISCARD_SIZE       (1<<7)
/*
 * Ignore data timeout error for R1B commands as there will be no
 * data associated and the busy timeout value for these commands
 * could be lager than the maximum timeout value that controller
 * can handle.
 */
#define SDHCI_QUIRK2_IGNORE_DATATOUT_FOR_R1BCMD     (1<<8)
/*
 * The preset value registers are not properly initialized by
 * some hardware and hence preset value must not be enabled for
 * such controllers.
 */
#define SDHCI_QUIRK2_BROKEN_PRESET_VALUE        (1<<9)
/*
 * Some controllers define the usage of 0xF in data timeout counter
 * register (0x2E) which is actually a reserved bit as per
 * specification.
 */
#define SDHCI_QUIRK2_USE_RESERVED_MAX_TIMEOUT       (1<<10)
/*
 * This is applicable for controllers that advertize timeout clock
 * value in capabilities register (bit 5-0) as just 50MHz whereas the
 * base clock frequency is 200MHz. So, the controller internally
 * multiplies the value in timeout control register by 4 with the
 * assumption that driver always uses fixed timeout clock value from
 * capabilities register to calculate the timeout. But when the driver
 * uses SDHCI_QUIRK2_ALWAYS_USE_BASE_CLOCK base clock frequency is directly
 * controller by driver and it's rate varies upto max. 200MHz. This new quirk
 * will be used in such cases to avoid controller mulplication when timeout is
 * calculated based on the base clock.
 */
#define SDHCI_QUIRK2_DIVIDE_TOUT_BY_4 (1 << 11)
/*
 * Some SDHC controllers are unable to handle data-end bit error in
 * 1-bit mode of SDIO.
 */
#define SDHCI_QUIRK2_IGN_DATA_END_BIT_ERROR             (1<<12)

/*
 * Some SDHC controllers do not require data buffers alignment, skip
 * the bounce buffer logic when preparing data
 */
#define SDHCI_QUIRK2_ADMA_SKIP_DATA_ALIGNMENT             (1<<13)
/* Some controllers doesn't have have any LED control */
#define SDHCI_QUIRK2_BROKEN_LED_CONTROL (1 << 14)
/* Use reset workaround in case sdhci reset timeouts */
#define SDHCI_QUIRK2_USE_RESET_WORKAROUND (1 << 15)

• sdhci host的一些标识（sdhci_host->flags）如下：

#define SDHCI_USE_SDMA      (1<<0)  /* Host is SDMA capable */
#define SDHCI_USE_ADMA      (1<<1)  /* Host is ADMA capable */
#define SDHCI_REQ_USE_DMA   (1<<2)  /* Use DMA for this req. */
#define SDHCI_DEVICE_DEAD   (1<<3)  /* Device unresponsive */
#define SDHCI_SDR50_NEEDS_TUNING (1<<4) /* SDR50 needs tuning */
#define SDHCI_NEEDS_RETUNING    (1<<5)  /* Host needs retuning */
#define SDHCI_AUTO_CMD12    (1<<6)  /* Auto CMD12 support */
#define SDHCI_AUTO_CMD23    (1<<7)  /* Auto CMD23 support */
#define SDHCI_PV_ENABLED    (1<<8)  /* Preset value enabled */
#define SDHCI_SDIO_IRQ_ENABLED  (1<<9)  /* SDIO irq enabled */
#define SDHCI_HS200_NEEDS_TUNING (1<<10)    /* HS200 needs tuning */
#define SDHCI_USING_RETUNING_TIMER (1<<11)  /* Host is using a retuning timer for the card */
#define SDHCI_HS400_NEEDS_TUNING (1<<12)    /* HS400 needs tuning */
#define SDHCI_USE_ADMA_64BIT     (1<<13)/* Host is 64-bit ADMA capable */

2、struct sdhci_ops结构体

sdhci core只是提供了一些接口和符合mmc core的操作集方法给对应的host driver使用。由于各个host的硬件有所差异，所以实际和硬件交互的驱动部分还是在host driver中实现。

所以sdhci core要求host提供标准的访问硬件的一些方法。而这些方法就被定义在了struct sdhci_ops结构体内部。

结构体如下：

struct sdhci_ops {
#ifdef CONFIG_MMC_SDHCI_IO_ACCESSORS
   // 表示host另外提供了一套访问寄存器的方法，没有定义的话，则说明使用通用的读写寄存器的方法
    u32        (*read_l)(struct sdhci_host *host, int reg);
    u16        (*read_w)(struct sdhci_host *host, int reg);
    u8        (*read_b)(struct sdhci_host *host, int reg);
    void        (*write_l)(struct sdhci_host *host, u32 val, int reg);
    void        (*write_w)(struct sdhci_host *host, u16 val, int reg);
    void        (*write_b)(struct sdhci_host *host, u8 val, int reg);
#endif

    void    (*set_clock)(struct sdhci_host *host, unsigned int clock);    // 设置时钟频率

    int        (*enable_dma)(struct sdhci_host *host);    // 使能DMA
    unsigned int    (*get_max_clock)(struct sdhci_host *host);    // 获取支持的最大时钟频率
    unsigned int    (*get_min_clock)(struct sdhci_host *host);    // 获取支持的最小时钟频率
    unsigned int    (*get_timeout_clock)(struct sdhci_host *host);
    int        (*platform_bus_width)(struct sdhci_host *host, int width);
    void (*platform_send_init_74_clocks)(struct sdhci_host *host,
                         u8 power_mode);
    unsigned int    (*get_ro)(struct sdhci_host *host);    // 获取
    void    (*platform_reset_enter)(struct sdhci_host *host, u8 mask);    // 进入平台复位的方法
    void    (*platform_reset_exit)(struct sdhci_host *host, u8 mask);    // 退出平台复位的方法
    int    (*set_uhs_signaling)(struct sdhci_host *host, unsigned int uhs);    // 设置uhs方式
    void    (*hw_reset)(struct sdhci_host *host);    // 硬件复位的方法
    void    (*platform_suspend)(struct sdhci_host *host);    // 平台host的suspend方法
    void    (*platform_resume)(struct sdhci_host *host);    // 平台host的resume方法
    void    (*adma_workaround)(struct sdhci_host *host, u32 intmask);
    void    (*platform_init)(struct sdhci_host *host);    // 平台host的初始化方法
    void    (*check_power_status)(struct sdhci_host *host, u32 req_type);    // 检测总线的电源状态
#define REQ_BUS_OFF    (1 << 0)
#define REQ_BUS_ON    (1 << 1)
#define REQ_IO_LOW    (1 << 2)
#define REQ_IO_HIGH    (1 << 3)
    int    (*execute_tuning)(struct sdhci_host *host, u32 opcode);    // 执行tuning操作的的方法
    void    (*toggle_cdr)(struct sdhci_host *host, bool enable);
    unsigned int    (*get_max_segments)(void);
    void    (*platform_bus_voting)(struct sdhci_host *host, u32 enable);    // 平台总线投票的方法
    void    (*disable_data_xfer)(struct sdhci_host *host);
    void    (*dump_vendor_regs)(struct sdhci_host *host);
    int    (*config_auto_tuning_cmd)(struct sdhci_host *host,
                      bool enable,
                      u32 type);
    int    (*enable_controller_clock)(struct sdhci_host *host);
    void    (*reset_workaround)(struct sdhci_host *host, u32 enable);
};

这个结构体也就是host driver要实现的核心内容。

3、struct mmc_host_ops sdhci_ops

注意：这里的sdhci_ops是一个变量名，和上述的struct sdhci_ops不是同一个概念。搞不懂为什么这么命名，容易混淆。

sdhci core使用sdhci_ops作为sdhci host抽象出来的mmc host的操作集，所以其是一个struct mmc_host_ops结构体。

后续mmc core关于这个host的操作也都是基于这个操作集上实现的，包括使能host（enable方法）、禁用host（disable方法）、发送请求（request方法）。

具体参考《mmc core》系列。

具体实现如下，具体意义参考《mmc core（第二章）——数据结构和宏定义说明》：

static const struct mmc_host_ops sdhci_ops = {
        // post_req和pre_req是为了实现异步请求处理而设置的
        // 异步请求处理就是指，当另外一个异步请求还没有处理完成的时候，可以先准备另外一个异步请求而不必等待
        // 具体参考《mmc core主模块》
    .pre_req    = sdhci_pre_req,
    .post_req   = sdhci_post_req,
    .request    = sdhci_request,    // host处理mmc请求的方法，在mmc_start_request中会调用
    .set_ios    = sdhci_set_ios,   // 设置host的总线的io setting
    .get_cd     = sdhci_get_cd,   // 检测host的卡槽中card的插入状态
    .get_ro     = sdhci_get_ro,  // 获取host上的card的读写属性
    .hw_reset   = sdhci_hw_reset,  // 硬件复位
    .enable_sdio_irq = sdhci_enable_sdio_irq,
    .start_signal_voltage_switch    = sdhci_start_signal_voltage_switch,   // 切换信号电压的方法
    .execute_tuning         = sdhci_execute_tuning,   // 执行tuning操作，为card选择一个合适的采样点
    .card_event         = sdhci_card_event,
    .card_busy  = sdhci_card_busy,   // 用于检测card是否处于busy状态
    .enable     = sdhci_enable, // 使能host，当host被占用时（第一次调用mmc_claim_host）调用
    .disable    = sdhci_disable,    // 禁用host，当host被释放时（第一次调用mmc_release_host）调用
    .stop_request = sdhci_stop_request,   // 停止请求处理的方法
    .get_xfer_remain = sdhci_get_xfer_remain,
    .notify_load    = sdhci_notify_load,
};

三、API总览

1、sdhci_host分配和释放相关

• sdhci_alloc_host & sdhci_free_host

由底层host driver调用。

sdhci_alloc_host为host driver分配一个sdhci_host和mmc_host，并实现其初始化，以及sdhci_host和mmc_host的关联。

sdhci_free_host则是用来释放一个sdhci_host。

原型：struct sdhci_host *sdhci_alloc_host(struct device *dev, size_t priv_size)
    参数说明：struct device *dev——》对应host的device结构体
                    size_t priv_size——》要分配的sdhci_host的私有数据的长度，一般是平台自己定制的host的长度。

    原型：void sdhci_free_host(struct sdhci_host *host)

2、sdhci_host的注册和卸载相关

• sdhci_add_host & sdhci_remove_host

由底层host driver调用。

sdhci_add_host用于向sdhci core注册一个sdhci_host。会根据sdhci的寄存器以及部分标识设置其mmc_host，最终将mmc_host注册到mmc core中。

因此，在调用sdhci_add_host之前，必须准备好sdhci的所有硬件环境。

sdhci_free_host则用于从sdhci core中卸载一个sdhci_host，对应的mmc_host也会从mmc core中被卸载。

    原型：int sdhci_add_host(struct sdhci_host *host)；
    原型：void sdhci_remove_host(struct sdhci_host *host, int dead)；

四、接口代码说明

1、sdhci_alloc_host

struct sdhci_host *sdhci_alloc_host(struct device *dev,
    size_t priv_size)
{
    struct mmc_host *mmc;
    struct sdhci_host *host;

    WARN_ON(dev == NULL);

/* 实现mmc_host和sdhci_host的分配 */
    mmc = mmc_alloc_host(sizeof(struct sdhci_host) + priv_size, dev);   // 分配一个struct mmc_host
    // 分配mmc_host的同时也分配了sizeof(struct sdhci_host) + priv_size的私有数据空间，这部分就是作为sdhci_host及其私有数据使用的。
    // 具体参考《mmc core——host模块说明》
    if (!mmc)
        return ERR_PTR(-ENOMEM);

/* 实现mmc_host和sdhci_host的关联操作 */
    host = mmc_priv(mmc);   // 将sdhci_host作为mmc_host的私有数据，mmc_host->private = sdhci_host
    host->mmc = mmc;   // 关联sdhci_host和mmc_host，sdhci_host->mmc = mmc_host

/* sdhci_host的锁的初始化工作 */
    spin_lock_init(&host->lock);   // 初始化sdhci_host 的占有锁
    mutex_init(&host->ios_mutex);   // 初始化sdhci_host 设置io setting的互斥锁

    return host;   // 将struct sdhci_host 返回
}

综上，

mmc_host->private = sdhci_host
sdhci_host->mmc = mmc_host

2、sdhci_add_host

（0）底层传上来的sdhci_host中应该包含什么信息

• sdhci的寄存器的映射过后的基地址（sdhci_host->ioaddr）
• sdhci的癖好quirks、quirks2（sdhci_host->quirks，sdhci_host->quirks2）
• sdhci的中断号（sdhci_host->irq）
• host提供给sdhci core用来操作硬件的操作集（sdhci_host->ops）

（1）主要完成工作如下：

• sdhci host复位

调用sdhci_reset

• 读取该host的sdhci的信息（从sdhci相关寄存器中读取）并设置sdhci_host相关成员

  • 版本（sdhci_host->version） : 从SDHCI_HOST_VERSION寄存器中读取
  • 支持的属性 : 从SDHCI_CAPABILITIES、SDHCI_CAPABILITIES_1寄存器中读取
  • 标识（sdhci_host->version） : 根据sdhci_host->quirks和quirks2来设置
  • 支持的最大频率和倍频（sdhci_host->max_clk & sdhci_host->clk_mul）
    
    
    对应SDHCI_CAPABILITIES寄存器中的SDHCI_CLOCK_BASE_SHIFT位
    
    
    对应SDHCI_CAPABILITIES寄存器中的SDHCI_CLOCK_MUL_SHIFT位
  • sdhci使用的regulator（sdhci_host->vqmmc）
    
    
    从节点中的命名为”vmmc”的regulator属性中获取
  • card插入状态发生变化时调用的tasklet（sdhci_host->card_tasklet）
    
    
    设置为sdhci_tasklet_card
  • 请求处理完成时调用的tasklet（sdhci_host->finish_tasklet）
    
    
    设置为sdhci_tasklet_finish
  • 请求的处理超时定时器（sdhci_host->timer）
    
    
    设置为sdhci_timeout_timer
  • qos处理的工作（sdhci_host->pm_qos_work）
    
    
    设置为sdhci_pm_qos_remove_work

• 设置mmc_host的相关成员

  • 操作集（mmc_host->ops）
    
    
    设置为sdhci_ops，上面已经说明过了
  • 最大频率（mmc_host->f_max）
    
    
    用sdhci_host->max_clk的值来设置
  • host的属性（mmc_host->caps & mmc_host->caps2）
    
    
    通过sdhci_host->quirks和quirks2、以及SDHCI_CAPABILITIES、SDHCI_CAPABILITIES_1寄存器中的属性进行设置
  • 各个电压下的最大电流值（mmc_host->max_current_330 & mmc_host->max_current_300 & mmc_host->max_current_180）
    
    
    从SDHCI_MAX_CURRENT寄存器中读取
  • 可用电压（mmc->ocr_avail & mmc->ocr_avail_sdio & mmc->ocr_avail_sd & mmc->ocr_avail_mmc）
    
    
    从SDHCI_CAPABILITIES寄存器中的SDHCI_CAN_VDD_330、SDHCI_CAN_VDD_300、SDHCI_CAN_VDD_180位获取
  • 一些块和段size的设置

• 中断的注册
  
  
  将sdhci_host的中断处理函数注册为sdhci_irq

• sdhci host初始化
  
  
  调用sdhci_init

• 注册mmc_host到mmc core中
  
  
  调用mmc_add_host

• 使能card插入状态的检测
  
  
  调用sdhci_enable_card_detection

（2）代码如下：

int sdhci_add_host(struct sdhci_host *host)
{
// 以下变量要注意区分
// host是指要注册的sdhci host
// mmc是指要注册到mmc subsystem的host，封装在sdhci host中
    struct mmc_host *mmc;
    u32 caps[2] = {0, 0};
    u32 max_current_caps;
    unsigned int ocr_avail;
    int ret;

    WARN_ON(host == NULL);
    if (host == NULL)
        return -EINVAL;

    mmc = host->mmc;      // 获取struct mmc_host

/* 执行复位操作 */
    sdhci_reset(host, SDHCI_RESET_ALL);
        // 执行reset操作，会调用到sdhci_host->ops->platform_reset_enter，msm并没有实现这个方法

/********************************* 获取sdhci信息并设置sdhci_host的相应成员***********************/
/* 获取sdhci controller版本号 */
    host->version = sdhci_readw(host, SDHCI_HOST_VERSION);
    host->version = (host->version & SDHCI_SPEC_VER_MASK) >> SDHCI_SPEC_VER_SHIFT;
        // 获取sdhci host的硬件版本号

/* 获取sdhci controller支持的属性 */
    caps[0] = (host->quirks & SDHCI_QUIRK_MISSING_CAPS) ? host->caps : sdhci_readl(host, SDHCI_CAPABILITIES);
        // SDHCI_QUIRK_MISSING_CAPS：Controller is missing device caps. Use caps provided by host
        // sdhci控制器没有devices属性的话，由底层host提供，否则，从sdhci controller的SDHCI_CAPABILITIES读取属性

    if (host->version >= SDHCI_SPEC_300)
        caps[1] = (host->quirks & SDHCI_QUIRK_MISSING_CAPS) ?host->caps1 : sdhci_readl(host, SDHCI_CAPABILITIES_1);
        // 从sdhci controller的SDHCI_CAPABILITIES_1读取属性

/* 设置sdhci_host->flags中和DMA相关的flag */
    if (host->quirks & SDHCI_QUIRK_FORCE_DMA)
        host->flags |= SDHCI_USE_SDMA;
    else if (!(caps[0] & SDHCI_CAN_DO_SDMA))
        DBG("Controller doesn't have SDMA capability\n");
    else
        host->flags |= SDHCI_USE_SDMA;
        // SDHCI_QUIRK_FORCE_DMA : Controller has bad caps bits, but really supports DMA
        // 设置sdhci_host->flags中的SDHCI_USE_SDMA标识
        //............................
    if (host->flags & SDHCI_USE_ADMA) {
                // sdhci_host ->adma_max_desc
                // sdhci_host ->adma_desc_line_sz
                // sdhci_host ->align_bytes
                // sdhci_host ->adma_desc_sz
                // sdhci_host ->align_buf_sz
                // sdhci_host ->adma_desc
                // sdhci_host ->align_buffer
    }

    host->next_data.cookie = 1;

/* 获取sdhci controller支持的最大频率以及倍频 */
    if (host->version >= SDHCI_SPEC_300)
        host->max_clk = (caps[0] & SDHCI_CLOCK_V3_BASE_MASK)
            >> SDHCI_CLOCK_BASE_SHIFT;     // 从sdhci controller的SDHCI_CLOCK_V3_BASE_MASK读取最大clock（单位是MHZ）
    else
        host->max_clk = (caps[0] & SDHCI_CLOCK_BASE_MASK)
            >> SDHCI_CLOCK_BASE_SHIFT;

    host->max_clk *= 1000000;（转化为hz）
        // 设置sdhci_host->max_clk
    sdhci_update_power_policy(host, SDHCI_PERFORMANCE_MODE_INIT);
        // 设置sdhci_host->power_policy为SDHCI_PERFORMANCE_MODE_INIT
    if (host->max_clk == 0 || host->quirks & SDHCI_QUIRK_CAP_CLOCK_BASE_BROKEN) {
        host->max_clk = host->ops->get_max_clock(host);   // 调用sdhci_host->ops->get_max_clock获得最大时钟
    }

    host->clk_mul = (caps[1] & SDHCI_CLOCK_MUL_MASK) >> SDHCI_CLOCK_MUL_SHIFT;
    if (host->clk_mul)
        host->clk_mul += 1;
        // 设置sdhci_host->clk_mul，clock的倍频实行

/*************************** 以下对mmc_host和sdhci_host进行设置操作 ***************************/
/* 以下设置mmc_host，ops、f_max、f_min */
    mmc->ops = &sdhci_ops;   // 设置mmc_host的操作集为sdhci_ops
    mmc->f_max = host->max_clk;   // 设置最大时钟频率mmc_host->f_max
    if (host->ops->get_min_clock)
        mmc->f_min = host->ops->get_min_clock(host);   // 调用sdhci_host->ops->get_min_clock获得最小时钟频率mmc_host->f_min

    host->timeout_clk = (caps[0] & SDHCI_TIMEOUT_CLK_MASK) >> SDHCI_TIMEOUT_CLK_SHIFT;
        // 从sdhci controller的SDHCI_TIMEOUT_CLK_MASK读取最大timeout
        // 设置到sdhci_host->timeout_clk
    if (host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)
        host->timeout_clk = mmc->f_max / 1000;

    if (!(host->quirks2 & SDHCI_QUIRK2_USE_MAX_DISCARD_SIZE))
        mmc->max_discard_to = (1 << 27) / host->timeout_clk;
        // 设置mmc_host->max_discard_to

/* 设置mmc_host->caps，也就是属性 */
    mmc->caps |= MMC_CAP_SDIO_IRQ | MMC_CAP_ERASE | MMC_CAP_CMD23;
    if (!(host->quirks & SDHCI_QUIRK_FORCE_1_BIT_DATA))
        mmc->caps |= MMC_CAP_4_BIT_DATA;
    if (host->quirks2 & SDHCI_QUIRK2_HOST_NO_CMD23)
        mmc->caps &= ~MMC_CAP_CMD23;
    if (caps[0] & SDHCI_CAN_DO_HISPD)
        mmc->caps |= MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED;
    if ((host->quirks & SDHCI_QUIRK_BROKEN_CARD_DETECTION) &&
        !(host->mmc->caps & MMC_CAP_NONREMOVABLE) &&
        (mmc_gpio_get_cd(host->mmc) < 0) &&
        !(host->mmc->caps2 & MMC_CAP2_NONHOTPLUG))
        mmc->caps |= MMC_CAP_NEEDS_POLL;

/* 获取vqmmc regulater并使能 */
    /* If vqmmc regulator and no 1.8V signalling, then there's no UHS */
    host->vqmmc = regulator_get(mmc_dev(mmc), "vqmmc");
    if (IS_ERR_OR_NULL(host->vqmmc)) {
            ....
    } else {
        ret = regulator_enable(host->vqmmc);
        if (!regulator_is_supported_voltage(host->vqmmc, 1700000,1950000))
            caps[1] &= ~(SDHCI_SUPPORT_SDR104 | SDHCI_SUPPORT_SDR50 | SDHCI_SUPPORT_DDR50);
    }
    if (host->quirks2 & SDHCI_QUIRK2_NO_1_8_V)
        caps[1] &= ~(SDHCI_SUPPORT_SDR104 | SDHCI_SUPPORT_SDR50 | SDHCI_SUPPORT_DDR50);

/* 设置mmc_host->caps和传输模式相关的属性 */
    /* Any UHS-I mode in caps implies SDR12 and SDR25 support. */
    if (caps[1] & (SDHCI_SUPPORT_SDR104 | SDHCI_SUPPORT_SDR50 |
               SDHCI_SUPPORT_DDR50))
        mmc->caps |= MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25;

    /* SDR104 supports also implies SDR50 support */
    if (caps[1] & SDHCI_SUPPORT_SDR104)
        mmc->caps |= MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_SDR50;
    else if (caps[1] & SDHCI_SUPPORT_SDR50)
        mmc->caps |= MMC_CAP_UHS_SDR50;

    if (caps[1] & SDHCI_SUPPORT_DDR50)
        mmc->caps |= MMC_CAP_UHS_DDR50;

/* 设置sdhci_host->flags中和tuning相关的flag */
    /* Does the host need tuning for SDR50? */
    if (caps[1] & SDHCI_USE_SDR50_TUNING)
        host->flags |= SDHCI_SDR50_NEEDS_TUNING;
    /* Does the host need tuning for HS200? */
    if (mmc->caps2 & MMC_CAP2_HS200)
        host->flags |= SDHCI_HS200_NEEDS_TUNING;
    /* Does the host need tuning for HS400? */
    if (mmc->caps2 & MMC_CAP2_HS400)
        host->flags |= SDHCI_HS400_NEEDS_TUNING;

/* 设置mmc_host->caps和驱动类型相关的属性 */
    /* Driver Type(s) (A, C, D) supported by the host */
    if (caps[1] & SDHCI_DRIVER_TYPE_A)
        mmc->caps |= MMC_CAP_DRIVER_TYPE_A;
    if (caps[1] & SDHCI_DRIVER_TYPE_C)
        mmc->caps |= MMC_CAP_DRIVER_TYPE_C;
    if (caps[1] & SDHCI_DRIVER_TYPE_D)
        mmc->caps |= MMC_CAP_DRIVER_TYPE_D;

/* 获取sdhci controller的tuning计数（tuning_count 、tuning_mode ）*/
    host->tuning_count = (caps[1] & SDHCI_RETUNING_TIMER_COUNT_MASK) >>
                  SDHCI_RETUNING_TIMER_COUNT_SHIFT;
    if (host->tuning_count)
        host->tuning_count = 1 << (host->tuning_count - 1);

    host->tuning_mode = (caps[1] & SDHCI_RETUNING_MODE_MASK) >> SDHCI_RETUNING_MODE_SHIFT;

    ocr_avail = 0;

/* 获取vmmc regulater，设置caps[0]支持的电压值 */
    host->vmmc = regulator_get(mmc_dev(mmc), "vmmc");
#ifdef CONFIG_REGULATOR
    /*
     * Voltage range check makes sense only if regulator reports
     * any voltage value.
     */
    if (host->vmmc && regulator_get_voltage(host->vmmc) > 0) {
        ret = regulator_is_supported_voltage(host->vmmc, 2700000,
            3600000);
        if ((ret <= 0) || (!(caps[0] & SDHCI_CAN_VDD_330)))
            caps[0] &= ~SDHCI_CAN_VDD_330;
        if ((ret <= 0) || (!(caps[0] & SDHCI_CAN_VDD_300)))
            caps[0] &= ~SDHCI_CAN_VDD_300;
        ret = regulator_is_supported_voltage(host->vmmc, 1700000,
            1950000);
        if ((ret <= 0) || (!(caps[0] & SDHCI_CAN_VDD_180)))
            caps[0] &= ~SDHCI_CAN_VDD_180;
    }
#endif /* CONFIG_REGULATOR */

/* 设置各个电压下的最大电流值（max_current_330、max_current_330 、max_current_180 ）*/
/* 设置可用电压域 */
    max_current_caps = sdhci_readl(host, SDHCI_MAX_CURRENT);
    if (!max_current_caps && host->vmmc) {
        u32 curr = regulator_get_current_limit(host->vmmc);
                //....................
    }

    if (caps[0] & SDHCI_CAN_VDD_330) {
        ocr_avail |= MMC_VDD_32_33 | MMC_VDD_33_34;

        mmc->max_current_330 = ((max_current_caps &
                   SDHCI_MAX_CURRENT_330_MASK) >>
                   SDHCI_MAX_CURRENT_330_SHIFT) *
                   SDHCI_MAX_CURRENT_MULTIPLIER;
    }
        //.........
    mmc->ocr_avail = ocr_avail;
    mmc->ocr_avail_sdio = ocr_avail;
        // ......

/*********************************** sdhci的初始化工作**************************************/
/* 初始化sdhci工作过程中会使用到的tasklet */
    tasklet_init(&host->card_tasklet, sdhci_tasklet_card, (unsigned long)host);      // host上发生card插入或者拔出时调用
    tasklet_init(&host->finish_tasklet, sdhci_tasklet_finish, (unsigned long)host);   // 完成一个request时调用

    setup_timer(&host->timer, sdhci_timeout_timer, (unsigned long)host); // command的超时定时器

/* 初始化qos处理的工作 */
    INIT_DELAYED_WORK(&host->pm_qos_work, sdhci_pm_qos_remove_work);

/* 中断注册和使能 */
    ret = request_irq(host->irq, sdhci_irq, IRQF_SHARED,mmc_hostname(mmc), host);
    host->irq_enabled = true;

/* 对该sdhci controller进行初始化 */
    sdhci_init(host, 0);

    mmiowb();
/* sdhci关于qos的请求和操作的设置 */
    if (host->host_qos[SDHCI_QOS_READ_WRITE].cpu_dma_latency_us) {
            // .........
    }

/*********************************** 将mmc_host注册到mmc subsystem中 *******************************/
    mmc_add_host(mmc);

/*********************************** 开始使能sdhci和并且开始检测card状态******************************/
    sdhci_enable_card_detection(host);

    return 0;
}

重点关注如下几个部分：

（1）sdhci_reset(host, SDHCI_RESET_ALL);
（2）mmc->ops = &sdhci_ops;   // 设置mmc_host的操作集为sdhci_ops
（3）host->vmmc = regulator_get(mmc_dev(mmc), "vmmc");
（4）tasklet_init(&host->card_tasklet, sdhci_tasklet_card, (unsigned long)host); // host上发生card插入或者拔出时调用
（5）tasklet_init(&host->finish_tasklet, sdhci_tasklet_finish, (unsigned long)host); // 完成一个request时调用的tasklet
（6）ret = request_irq(host->irq, sdhci_irq, IRQF_SHARED,mmc_hostname(mmc), host);
（7）sdhci_init(host, 0);    // 软初始化host
（8）sdhci_enable_card_detection(host);    // 开始使能card插入状态的检测

五、sdhci core内部代码简单说明

1、sdhci_reset & sdhci_init & sdhci_enable_card_detection

• sdhci_reset
  
  
  由sdhci core内部调用，用于复位host。
• sdhci_init
  
  
  由sdhci core内部调用，用于初始化host
• sdhci_enable_card_detection
  
  
  由sdhci core内部调用，使能card插入状态的检测，主要是设置SDHCI_INT_ENABLE、SDHCI_SIGNAL_ENABLE寄存器

static irqreturn_t sdhci_irq(int irq, void *dev_id)
{
    irqreturn_t result;
    struct sdhci_host *host = dev_id;
    u32 intmask, unexpected = 0;
    int cardint = 0, max_loops = 16;

    spin_lock(&host->lock);

 /* 从SDHCI_INT_STATUS寄存器中读取中断状态 */
    intmask = sdhci_readl(host, SDHCI_INT_STATUS);    // 从SDHCI_INT_STATUS寄存器中读取中断状态

/* 确认是否有中断产生 */
    if (!intmask || intmask == 0xffffffff) {
        result = IRQ_NONE;
        goto out;
    }

again:
    DBG("*** %s got interrupt: 0x%08x\n",
        mmc_hostname(host->mmc), intmask);

 /* 以下是对card插入或者拔出的中断进行处理 */
    if (intmask & (SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE)) {
        u32 present = sdhci_readl(host, SDHCI_PRESENT_STATE) &
                  SDHCI_CARD_PRESENT;
        sdhci_mask_irqs(host, present ? SDHCI_INT_CARD_INSERT :
                        SDHCI_INT_CARD_REMOVE);
        sdhci_unmask_irqs(host, present ? SDHCI_INT_CARD_REMOVE :
                          SDHCI_INT_CARD_INSERT);

        sdhci_writel(host, intmask & (SDHCI_INT_CARD_INSERT |
                 SDHCI_INT_CARD_REMOVE), SDHCI_INT_STATUS);    // 重置这两个中断位
        intmask &= ~(SDHCI_INT_CARD_INSERT | SDHCI_INT_CARD_REMOVE);
        tasklet_schedule(&host->card_tasklet);    // 执行host->card_tasklet，也就是sdhci_tasklet_card进行处理，后面说明
    }

 /* 以下是sdhci处理命令产生的中断进行处理，不一定是出错 */
    if (intmask & SDHCI_INT_CMD_MASK) {
        if (intmask & SDHCI_INT_AUTO_CMD_ERR)
            host->auto_cmd_err_sts = sdhci_readw(host,
                    SDHCI_AUTO_CMD_ERR);
        sdhci_writel(host, intmask & SDHCI_INT_CMD_MASK,
            SDHCI_INT_STATUS);
        if ((host->quirks2 & SDHCI_QUIRK2_SLOW_INT_CLR) &&
            (host->clock <= 400000))
            udelay(40);
        sdhci_cmd_irq(host, intmask & SDHCI_INT_CMD_MASK);    // 在sdhci_cmd_irq中会执行host->finish_tasklet, 也就是sdhci_tasklet_finish来通知上层。后面说明。
    }

 /* 以下是sdhci处理数据产生的中断进行处理，不一定是出错 */
    if (intmask & SDHCI_INT_DATA_MASK) {
        sdhci_writel(host, intmask & SDHCI_INT_DATA_MASK,
            SDHCI_INT_STATUS);
        if ((host->quirks2 & SDHCI_QUIRK2_SLOW_INT_CLR) &&
            (host->clock <= 400000))
            udelay(40);
        sdhci_data_irq(host, intmask & SDHCI_INT_DATA_MASK); // 在sdhci_data_irq中会执行host->finish_tasklet, 也就是sdhci_tasklet_finish来通知上层。
    }

    intmask &= ~(SDHCI_INT_CMD_MASK | SDHCI_INT_DATA_MASK);

    intmask &= ~SDHCI_INT_ERROR;

 /* 以下是对总线电源状态发生变化的中断的处理 */
    if (intmask & SDHCI_INT_BUS_POWER) {
        pr_err("%s: Card is consuming too much power!\n",
            mmc_hostname(host->mmc));
        sdhci_writel(host, SDHCI_INT_BUS_POWER, SDHCI_INT_STATUS);
    }

    intmask &= ~SDHCI_INT_BUS_POWER;

    if (intmask & SDHCI_INT_CARD_INT)
        cardint = 1;

    intmask &= ~SDHCI_INT_CARD_INT;

    if (intmask) {
        unexpected |= intmask;
        sdhci_writel(host, intmask, SDHCI_INT_STATUS);
    }

    result = IRQ_HANDLED;

/* 可能不止有其他事件导致中断的产生，重复检测 */
    intmask = sdhci_readl(host, SDHCI_INT_STATUS);
    if (intmask && --max_loops)
        goto again;
out:
    spin_unlock(&host->lock);
    return result;
}

3、sdhci_tasklet_card

• 简单流程说明：
  • 当进行卡插入或者拔出的时候，sdhci controller（硬件）会检测到其状态发生变化
  • sdhci controller（硬件）会设置中断状态寄存器中SDHCI_INT_CARD_INSERT或者SDHCI_INT_CARD_REMOVE位
  • sdhci controller（硬件）触发中段
  • sdhci core中的中断处理函数sdhci_irq被调用（软件）
  • sdhci_irq（软件）去判断出中断状态寄存器中SDHCI_INT_CARD_INSERT或者SDHCI_INT_CARD_REMOVE位被设置
  • sdhci_irq执行host->card_tasklet，也就是我们这里的sdhci_tasklet_card进行相应处理。
• sdhci_tasklet_card实现如下：

static void sdhci_tasklet_card(unsigned long param)
{
    struct sdhci_host *host = (struct sdhci_host*)param;   // 提取sdhci_host结构体
    sdhci_card_event(host->mmc);   // 发送事件，如果此时有mmc_request正在处理，则会复位数据线和命令线，终止mmc_request处理
    mmc_detect_change(host->mmc, msecs_to_jiffies(200));
         // 调用mmc_detect_change通知mmc core卡槽状态发生了变化，剩下的就是mmc core的工作了
        // mmc_detect_change实现具体参考《mmc core主模块说明》
}

4、sdhci_tasklet_finish

static void sdhci_tasklet_finish(unsigned long param)
{
        //......过滤掉前面一些根据情况决定的复位操作
    mmc_request_done(host->mmc, mrq);
        // 调用mmc_request_done来通知mmc core 说mrq这个mmc request已经处理完成，至于处理完成的结果由上层自己解决
        // mmc_request_done实现具体参考《mmc core主模块说明》
    sdhci_runtime_pm_put(host);
}

5、struct mmc_host_ops sdhci_ops各个方法简单说明

static const struct mmc_host_ops sdhci_ops = {
        // post_req和pre_req是为了实现异步请求处理而设置的
        // 异步请求处理就是指，当另外一个异步请求还没有处理完成的时候，可以先准备另外一个异步请求而不必等待
        // 具体参考《mmc core主模块》
    .pre_req    = sdhci_pre_req,
    .post_req    = sdhci_post_req,
    .request    = sdhci_request,    // host处理mmc请求的方法，在mmc_start_request中会调用
    .set_ios    = sdhci_set_ios,   // 设置host的总线的io setting
    .get_cd        = sdhci_get_cd,   // 检测host的卡槽中card的插入状态
    .get_ro        = sdhci_get_ro,  // 获取host上的card的读写属性
    .hw_reset    = sdhci_hw_reset,  // 硬件复位
    .enable_sdio_irq = sdhci_enable_sdio_irq,
    .start_signal_voltage_switch    = sdhci_start_signal_voltage_switch,   // 切换信号电压的方法
    .execute_tuning            = sdhci_execute_tuning,   // 执行tuning操作，为card选择一个合适的采样点
    .card_event            = sdhci_card_event,
    .card_busy    = sdhci_card_busy,   // 用于检测card是否处于busy状态
    .enable        = sdhci_enable, // 使能host，当host被占用时（第一次调用mmc_claim_host）调用
    .disable    = sdhci_disable,    // 禁用host，当host被释放时（第一次调用mmc_release_host）调用
    .stop_request = sdhci_stop_request,   // 停止请求处理的方法
    .get_xfer_remain = sdhci_get_xfer_remain,
    .notify_load    = sdhci_notify_load,
};