一、工作流程

mmc驅動主要檔案包括

drivers/mmc/card/block.c
drivers/mmc/card/queue.c
drivers/mmc/core/core.c
drivers/mmc/core/host.c
drivers/mmc/core/

核心啟動時，首先執行core/core.c的mmc_init，註冊mmc、sd匯流排，以及一個host class裝置。接著執行card/block.c中，申請一個塊裝置。

二、資料結構：

這裡涉及三種匯流排

1. platform bus //MMC host controller 作為一種 platform device, 它是需要註冊到 platform bus上 的  
driver/base/platform.c  
struct bus_type platform_bus_type = {  
    .name        = "platform",  
    .dev_attrs    = platform_dev_attrs,  
    .match        = platform_match,  
    .uevent        = platform_uevent,  
    .pm        = &platform_dev_pm_ops,  
};  
  
2. mmc bus type  //在mmc_init()中被建立的.通過呼叫 mmc_register_bus() 來註冊 MMC 匯流排  
drivers\mmc\core\bus.c  
static struct bus_type mmc_bus_type = {  
    .name        = "mmc",  
    .dev_attrs    = mmc_dev_attrs,  
    .match        = mmc_bus_match,  
    .uevent        = mmc_bus_uevent,  
    .probe        = mmc_bus_probe,  
    .remove        = mmc_bus_remove,  
    .shutdown        = mmc_bus_shutdown,  
    .pm        = &mmc_bus_pm_ops,  
};  
  
3. sdio bus type    //在mmc_init()中被建立的.通過呼叫sdio_register_bus() 來註冊 SDIO 匯流排  
drivers\mmc\core\sdio_bus.c  
static struct bus_type sdio_bus_type = {  
    .name        = "sdio",  
    .dev_attrs    = sdio_dev_attrs,  
    .match        = sdio_bus_match,  
    .uevent        = sdio_bus_uevent,  
    .probe        = sdio_bus_probe,  
    .remove        = sdio_bus_remove,  
    .pm        = SDIO_PM_OPS_PTR,  
};  
 

//匯流排操作結構
struct mmc_bus_ops {
    void (*remove)(struct mmc_host *);
    void (*detect)(struct mmc_host *);
    int (*sysfs_add)(struct mmc_host *, struct mmc_card *card);
    void (*sysfs_remove)(struct mmc_host *, struct mmc_card *card);
    void (*suspend)(struct mmc_host *);
    void (*resume)(struct mmc_host *);
};
//  mmc卡的匯流排操作 core/mmc.c
static const struct mmc_bus_ops mmc_ops = {
    .remove = mmc_remove,
    .detect = mmc_detect,
    .sysfs_add = mmc_sysfs_add,
    .sysfs_remove = mmc_sysfs_remove,
    .suspend = mmc_suspend,
    .resume = mmc_resume,
};
// sd卡的匯流排操作 core/sd.c
static const struct mmc_bus_ops mmc_sd_ops = {
    .remove = mmc_sd_remove,
    .detect = mmc_sd_detect,
    .sysfs_add = mmc_sd_sysfs_add,
    .sysfs_remove = mmc_sd_sysfs_remove,
    .suspend = mmc_sd_suspend,
    .resume = mmc_sd_resume,
};
// sdio的匯流排操作 core/sdio.c
static const struct mmc_bus_ops mmc_sdio_ops = {
    .remove = mmc_sdio_remove,
    .detect = mmc_sdio_detect,
};
 

關於匯流排操作的函式：

.detect，驅動程式經常需要呼叫此函式去檢測mmc卡的狀態，具體實現是傳送CMD13命令，並讀迴響應，如果響應錯誤，則依次呼叫.remove、detach_bus來移除卡及釋放匯流排。

三、總體架構

1、kernel啟動時，先後執行mmc_init()及mmc_blk_init()，以對mmc裝置及mmc塊模組進行初始化

mmc/core/core.c  
static int __init mmc_init(void)  
    workqueue = alloc_ordered_workqueue("kmmcd", 0);//建立了一個工作佇列workqueue，這個工作佇列的作用主要是用來支援熱插拔  
    ret = mmc_register_bus();//註冊一個mmc匯流排  
    ret = mmc_register_host_class();//註冊了一個 mmc_host 類  
    ret = sdio_register_bus();//註冊了一個 sdio_bus_type  
      
*******   
mmc/card/block.c  
static int __init mmc_blk_init(void)  
    res = register_blkdev(MMC_BLOCK_MAJOR, "mmc");//註冊一個塊裝置  
    res = mmc_register_driver(&mmc_driver);//註冊一個mmc裝置驅動  
  
static struct mmc_driver mmc_driver =  
    .probe      = mmc_blk_probe,  
      
static int mmc_blk_probe(struct mmc_card *card)  
    mmc_set_bus_resume_policy(card->host, 1);//*host 該指標指向一個mmc主機例項，塊裝置中的讀寫操作就是呼叫這個mmc主機的操作函式host->ops->request來實現對實際硬體的操作。  
 

2、core部分會做兩件事

a -- 取得匯流排

b -- 檢查匯流排操作結構指標bus_ops，如果為空，則重新利用各匯流排對埠進行掃描，檢測順序依次為：SDIO、Normal SD、MMC。當檢測到相應的卡型別後，就使用mmc_attach_bus()把相對應的匯流排操作與host連線起來

void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
{
    ...
    host->bus_ops = ops;
    ...
}

3、然後在掛載mmc裝置驅動時，執行驅動程式中的xx_mmc_probe()，檢測host裝置中掛載的sd裝置

kernel\arch\arm\configs\msm9625_defconfig  
CONFIG_MMC_MSM=y  
  
kernel\drivers\mmc\host\Makefile  
obj-$(CONFIG_MMC_MSM)        += msm_sdcc.o      
  
msm_sdcc.c (drivers\mmc\host)  
//系統初始化時掃描 platform 總線上是否有名為該SD主控制器名字"msm_sdcc"的裝置，如果有， 驅動程式將主控制器掛載到 platform 總線上，並註冊該驅動程式  
static int __init msmsdcc_init(void)  
    platform_driver_register(&msmsdcc_driver);    //註冊 platform driver  
      
static struct platform_driver msmsdcc_driver = {  
    .probe        = msmsdcc_probe,  
    .remove        = msmsdcc_remove,  
    .driver        = {  
        .name    = "msm_sdcc",  
        .pm    = &msmsdcc_dev_pm_ops,  
        .of_match_table = msmsdcc_dt_match,  
    },  
};      
      
//整個裝置驅動的 probe()函式，其本質就是是為裝置建立起資料結構並對其賦初值  
//msmsdcc_probe 所有賦值中，我們重點關注從 platform_device *pdev裡得到的資料，即裝置樹裡的資料  
//platform_device *pdev是在系統初始化的時候掃描 platform 匯流排發現SD主控制器後所得到的資料  
static int msmsdcc_probe(struct platform_device *pdev)      
{      
    //初始化裝置的資料結構  
    if (pdev->dev.of_node) {  
    plat = msmsdcc_populate_pdata(&pdev->dev);        //獲取裝置樹資訊  
    of_property_read_u32((&pdev->dev)->of_node,"cell-index", &pdev->id);  
    } else {  
        plat = pdev->dev.platform_data;  
    }  
    //為主裝置控制器建立資料結構，建立kobject，並初始化等待佇列，工作佇列，以及一些控制器的配置  
    mmc = mmc_alloc_host(sizeof(struct msmsdcc_host), &pdev->dev);            ---- 1  
    //實現裝置驅動的功能函式，如mmc->ops = &pxamci_ops;  
    mmc->ops = &msmsdcc_ops;  
    //申請中斷函式 request_irq()  
    ret = request_irq(core_irqres->start, msmsdcc_irq, IRQF_SHARED,DRIVER_NAME " (cmd)", host);  
    //註冊裝置，即註冊kobject，建立sys檔案，傳送uevent等  
    mmc_add_host(mmc);                                                        ---- 2  
    //其他需求，如在/proc/driver下建立使用者互動檔案等  
    ret = device_create_file(&pdev->dev, &host->auto_cmd21_attr);  
}      

4、此時probe函式會建立一個host裝置，然後開啟一個延時任務mmc_rescan()。

1：    
core/host.c   
//重要函式mmc_alloc_host , 用於分配mmc_host結構體指標的記憶體空間大小  
struct mmc_host *mmc_alloc_host(int extra, struct device *dev)----建立一個 mmc_host 和 mmc_spi_host ，且mmc_host的最後一個成員指標private指向mmc_spi_host  
    //建立資料結構  
    struct mmc_host *host;    
    host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL);  
    //建立kobject  
    host->parent = dev;  
    host->class_dev.parent = dev;  
    host->class_dev.class = &mmc_host_class;  
    device_initialize(&host->class_dev);  
    //初始化等待佇列，工作佇列  
    init_waitqueue_head(&host->wq);  
    INIT_DELAYED_WORK(&host->detect, mmc_rescan);    //建立了一個工作佇列任務 structdelayed_work detect。工作佇列任務執行的函式為mmc_rescan  
    //配置控制器  
    host->max_segs = 1;  
    host->max_seg_size = PAGE_CACHE_SIZE;  
    return host;  

5、驅動掛載成功後，mmc_rescan()函式被執行，然後對卡進行初始化（步驟後面詳細講述）

core/core.c  
//mmc_rescan 函式是需要重點關注的,因為SD卡協議中的檢測，以及卡識別等都是在此函式中實現  
void mmc_rescan(struct work_struct *work)  
    if (host->bus_ops && host->bus_ops->detect && !host->bus_dead && !(host->caps & MMC_CAP_NONREMOVABLE))    //存在熱插拔卡，不包括emmc，呼叫探測函式  
    host->bus_ops->detect(host);  
    mmc_bus_put(host);    //減少引用技術，就釋放  
    mmc_bus_get(host);    //增加bus引用計數  
    if (host->bus_ops != NULL) {  
        mmc_bus_put(host);    //如果卡仍然存在，減少引用計數，不必探測了  
        goto out;  
    }  
    if (host->ops->get_cd && host->ops->get_cd(host) == 0)  //有卡，退出  
    goto out;  
    mmc_claim_host(host);                   //用於檢測host是否被佔用，佔用則退出，否則標記成佔用  
      
    if (!mmc_rescan_try_freq(host, host->f_min))  

a、傳送CMD0使卡進入IDLE狀態
b、傳送CMD8，檢查卡是否SD2.0。SD1.1是不支援CMD8的，因此在SD2.0 Spec中提出了先發送CMD8，如響應為無效命令，則卡為SD1.1，否則就是SD2.0（請參考SD2.0 Spec）。
c、傳送CMD5讀取OCR暫存器。
d、傳送ACMD55、CMD41，使卡進入工作狀態。MMC卡並不支援ACMD55、CMD41，如果這步通過了，則證明這張卡是SD卡。
e、如果d步驟錯誤，則傳送CMD1判斷卡是否為MMC。SD卡不支援CMD1，而MMC卡支援，這就是SD和MMC型別的判斷依據。
f、如果ACMD41和CMD1都不能通過，那這張卡恐怕就是無效卡了，初始化失敗。

      假如掃描到總線上掛有有效的裝置，就呼叫相對應的函式把裝置裝到系統中，mmc_attach_sdio()、mmc_attach_sd()、mmc_attach_mmc()這三個函式分別是裝載sdio裝置，sd卡和mmc卡的。

     在 sd卡中，驅動迴圈傳送ACMD41、CMD55給卡，讀取OCR暫存器，成功後，依次傳送CMD2(讀CID)、CMD3(得到RCA)、CMD9(讀 CSD)、CMD7(選擇卡)。後面還有幾個命令分別是ACMD41&CMD51，使用CMD6切換一些功能，如切換到高速模式。

     經過上述步驟，已經確定當前插入的卡是一張有效、可識別的儲存卡。然後呼叫mmc_add_card()把儲存卡加到系統中。正式與系統驅動連線在一起。

static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)  
    host->f_init = freq;                 //設定某一個時鐘頻率  
    mmc_power_up(host);                     //與 mmc_power_off 類似，不過設定了啟動時需要的 ios  
    mmc_go_idle(host);          ----1a      //CMD0 ,SD卡從 inactive 到 idle          
    mmc_send_if_cond(host, host->ocr_avail);//檢測SD卡是否支援SD2.0       
    if (!mmc_attach_sd(host))   ----1b      //然後對mmc或者sd傳送一些命令進行探測,這裡以 sd 為例  
  
1a:  
int mmc_go_idle(struct mmc_host *host)    
    struct mmc_command cmd = {0};  
    cmd.opcode = MMC_GO_IDLE_STATE; //即CMD0  
    cmd.arg = 0;                    //此命令無引數  
    err = mmc_wait_for_cmd(host, &cmd, 0)  
      
int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)  
    memset(cmd->resp, 0, sizeof(cmd->resp));  //呼叫了 mmc_start_request,   
    cmd->retries = retries;  
    mrq.cmd = cmd;                                
    mmc_wait_for_req(host, &mrq);  
      
void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq)   ----重要函式  
    __mmc_start_req(host, mrq);  
  
static int __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)  
    mmc_start_request(host, mrq);  
          
static void mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)  
    host->ops->request(host, mrq);    //即 msmsdcc_request， MMC 核心與核HOST 層握手了  
  
      
1b:   
core/mmc.c  
int mmc_attach_sd(struct mmc_host *host)                    //完成匹配，和初始化卡的功能  
    err = mmc_send_app_op_cond(host, 0, &ocr);      ----1b1 //檢測是否是支援SD卡  
    host->ocr = mmc_select_voltage(host, ocr);               //設定MMC電壓  
    err = mmc_init_card(host, host->ocr, NULL);              //對mmc卡進行初始化，主要是讀取mmc卡里的一些暫存器資訊，且對這些暫存器的值進行設定  
    err = mmc_sd_init_card(host, host->ocr, NULL);   ----1b2  
    err = mmc_add_card(host->card);                  ----1b3 //呼叫 mmc_add_card 來把 mmc_card 掛載到 mmc_bus_type 匯流排去  
      
      
1b1:  
int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)  
    cmd.opcode = SD_APP_OP_COND;    //ACMD41,獲取 SDcard 的允許電壓範圍值,儲存在 ocr 中. 所有傳送它之前需要傳送 CMD_55 命令。執行完後 card 狀態變為 READY  
  
      
      
1b2:  
static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,struct mmc_card *oldcard)  
    err = mmc_sd_get_cid(host, ocr, cid, &rocr);        //傳送 CMD2 ，獲取卡的身份資訊，進入到身份狀態  
    card = mmc_alloc_card(host, &sd_type);              //分配一張 SD 型別的 card 結構  
    err = mmc_send_relative_addr(host, &card->rca);      //獲取卡的相對地址，注意一前卡和主機通訊都採用預設地址，現在有了自己的地址了，進入到 stand_by 狀態  
    err = mmc_sd_get_csd(host, card); ----mmc_send_csd(card, card->raw_csd);//CMD9, 獲取 CSD 暫存器的資訊，包括 block 長度，卡容量等資訊  
    err = mmc_select_card(card);                        //傳送 CMD7, 選中目前 RADD 地址上的卡，任何時候總線上只有一張卡被選中，進入了傳輸狀態   
    err = mmc_sd_setup_card(host, card, oldcard != NULL);     
  
int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card,bool reinit)  
    mmc_app_send_scr(card, card->raw_scr);   //傳送命令 ACMD51 獲取 SRC 暫存器的內容，進入到 SENDING-DATA 狀態  
    if (host->ops->get_ro(host) > 0 )      // get_ro(host) 即是 msmsdcc_get_ro   
        mmc_card_set_readonly(card);        //是否防寫，如果是的，將 card 狀態設定為只讀狀態  
      
1b3:  
core/bus.c  
int mmc_add_card(struct mmc_card *card)     //  /sys/devices/msm_sdcc.2/mmc_host/mmc0  
    ret = device_add(&card->dev);  
  
drivers/base/core.c  
int device_add(struct device *dev)  
    dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id); //  
    bus_probe_device(dev);  
  
void bus_probe_device(struct device *dev)  
        if (bus->p->drivers_autoprobe)   
        ret = device_attach(dev);           //這樣，在匯流排 mmc_bus_type 中就有了 mmc 裝置 mmc_card 了      
      
      
***********   
2:  
//完成kobject的註冊，並呼叫 mmc_rescan，目的在於在系統初始化的時候就掃描SD匯流排檢視是否存在SD卡  
int mmc_add_host(struct mmc_host *host)  
    err = device_add(&host->class_dev);//將設備註冊進linux裝置模型，最終的結果就是在 sys/bus/platform/devices 目錄下能見到 mmc 裝置節點  
    mmc_start_host(host);  
      
      
void mmc_start_host(struct mmc_host *host)    
    mmc_power_off(host);                ----2a  
    mmc_detect_change(host, 0);         ----2b  
  
2a:  
void mmc_power_off(struct mmc_host *host)     
    host->ios.power_mode = MMC_POWER_OFF;    //對 ios 進行了設定  
    ...  
    mmc_set_ios(host);  
  
void mmc_set_ios(struct mmc_host *host)  
    host->ops->set_ios(host, ios);            // set_ios 實際上就是 mmc_host_ops 的 .set_ios  = msmsdcc_set_ios,  
  
2b:  
void mmc_detect_change(struct mmc_host *host, unsigned long delay)  
        mmc_schedule_delayed_work(&host->detect, delay); //實際上就是呼叫我們前面說的延時函式 mmc_rescan  

6、卡裝置加到系統中後，通知mmc塊裝置驅動。塊裝置驅動此時呼叫probe函式，即mmc_blk_probe()函式，mmc_blk_probe()首 先分配一個新的mmc_blk_data結構變數，然後呼叫mmc_init_queue，初始化blk佇列。然後建立一個執行緒 mmc_queue_thread()。

7、然後就可以進行傳輸命令和資料了

struct mmc_host_ops {         
    //用於SD卡命令的傳輸，比如傳送和接收命令，CMD0,CMD8,ACMD41諸如此類的都是在這個函式去實現  
    void    (*request)(struct mmc_host *host, struct mmc_request *req);  
  
}  
  
static const struct mmc_host_ops msmsdcc_ops = {  
    .enable     = msmsdcc_enable,  
    .disable    = msmsdcc_disable,  
    .pre_req        = msmsdcc_pre_req,  
    .post_req       = msmsdcc_post_req,  
    .request    = msmsdcc_request,  
    .set_ios    = msmsdcc_set_ios,  
    .get_ro     = msmsdcc_get_ro,  
    .enable_sdio_irq = msmsdcc_enable_sdio_irq,  
    .start_signal_voltage_switch = msmsdcc_switch_io_voltage,  
    .execute_tuning = msmsdcc_execute_tuning,  
    .hw_reset = msmsdcc_hw_reset,  
    .stop_request = msmsdcc_stop_request,  
    .get_xfer_remain = msmsdcc_get_xfer_remain,  
    .notify_load = msmsdcc_notify_load,  
};  
  
/*這個函式實現了命令和資料的傳送和接收， 
當 CORE 部分需要傳送命令或者傳輸資料時，都會呼叫這個函式，並傳遞 mrq 請求*/  
static void msmsdcc_request(struct mmc_host *mmc, struct mmc_request *mrq)  
    mmc_request_done(mmc, mrq);             // 如果卡不存在，就終止請求  
    msmsdcc_request_start(host, mrq);         
  
static void msmsdcc_request_start (struct msmsdcc_host *host, struct mmc_request *mrq)  
    if ((mrq->data->flags & MMC_DATA_READ) ||host->curr.use_wr_data_pend)      //判斷髮送資料還是命令  
        msmsdcc_start_data(host, mrq->data,mrq->sbc ? mrq->sbc : mrq->cmd,0);   //傳送資料  
    else  
        msmsdcc_start_command(host,mrq->sbc ? mrq->sbc : mrq->cmd,0);          //傳送命令  
  
  
static void msmsdcc_start_data(struct msmsdcc_host *host, struct mmc_data *data,struct mmc_command *cmd, u32 c)  
    //對某些 暫存器進行設定, 使能某些中斷， 如 pio_irqmask  
    ...  
    if (is_dma_mode(host) && (datactrl & MCI_DPSM_DMAENABLE))   //採用 DMA 進行資料傳輸還是採用 FIFO 進行資料傳輸  
        msmsdcc_start_command_deferred(host, cmd, &c);          //啟動了資料傳輸模式  
    else      
        msmsdcc_start_command(host, cmd, c)  
  
static void msmsdcc_start_command(struct msmsdcc_host *host, struct mmc_command *cmd, u32 c)  
{  
    msmsdcc_start_command_deferred(host, cmd, &c);  
    msmsdcc_start_command_exec(host, cmd->arg, c);  
}  
  
static void msmsdcc_start_command_deferred(struct msmsdcc_host *host,struct mmc_command *cmd, u32 *c)  
    cmd->opcode ----對應SD卡命令 ，如 CMD0:復位SD 卡