1. 總論

2. 主控制器

3. 協議層

4. 塊裝置

1. 總論

 1.1 概念

• MMC - MultiMedia Card
• SD    - Secure Digital Card

1.2 分類

• 按儲存大小，普通SD卡（<=2GB，支援FAT12/FAT16），HCSD卡(>2GB,<=32GB，支援FAT32)
• 按體積大小，普通SD卡，mini-SD卡，micro-SD卡（TF卡）

1.3 速度

• 預設模式: 12.5MB/s
• 高速模式: 25MB/s

1.4 子系統程式碼結構

     

     Linux原始碼裡/drivers/mmc下有三個資料夾，分別存放了SD塊裝置，核心層和SD主控制器的相關程式碼，可以通過Kconfig和Makefile獲取更多資訊。

2. 主控制器

    SD卡的控制器晶片，可以看成CPU的代言人，它為CPU分擔了完成與SD卡資料通訊的任務。

2.1 資料結構

     以PXA晶片的SD控制器驅動為例，

struct pxamci_host {  struct mmc_host  *mmc;

 struct mmc_request *mrq;  struct mmc_command *cmd;  struct mmc_data  *data;

 ... ... };

2.1.1 struct mmc_host

     結構體mmc_host定義於/include/linux/mmc/host.c，可以認為是linux為SD卡控制器專門準備的一個類，該類裡面的成員是所有SD卡控制器都需要的，放之四海而皆準的資料結構，而在PXA晶片控制器的驅動程式pxamci.c中，則為該類具體化了一個物件struct mmc_host *mmc，此mmc指標即指代著該PXA晶片SD卡控制器的一個具體化物件。

struct mmc_host {  const struct mmc_host_ops *ops;     // SD卡主控制器的操作函式，即該控制器所具備的驅動能力

 const struct mmc_bus_ops *bus_ops; // SD匯流排驅動的操作函式，即SD匯流排所具備的驅動能力

 struct mmc_ios  ios;  // 配置時鐘、匯流排、電源、片選、時序等

 struct mmc_card  *card;  // 連線到此主控制器的SD卡裝置     ... ... };

struct mmc_host_ops {  void (*request)(struct mmc_host *host, struct mmc_request *req);  // 核心函式，完成主控制器與SD卡裝置之間的資料通訊  void (*set_ios

)(struct mmc_host *host, struct mmc_ios *ios);  // 配置時鐘、匯流排、電源、片選、時序等  int (*get_ro)(struct mmc_host *host);  void (*enable_sdio_irq)(struct mmc_host *host, int enable); };

struct mmc_bus_ops {  void (*remove)(struct mmc_host *);    // 拔出SD卡的回撥函式  void (*detect)(struct mmc_host *);      // 探測SD卡是否還在SD總線上的回撥函式  void (*suspend)(struct mmc_host *);  void (*resume)(struct mmc_host *); };

struct mmc_card {  struct mmc_host  *host;  /* the host this device belongs to */  struct device  dev;  /* the device */  unsigned int  rca;  /* relative card address of device */  unsigned int  type;  /* card type */  unsigned int  state;  /* (our) card state */  unsigned int  quirks;  /* card quirks */

 u32   raw_cid[4]; /* raw card CID */  u32   raw_csd[4]; /* raw card CSD */  u32   raw_scr[2]; /* raw card SCR */  struct mmc_cid  cid;  /* card identification */  struct mmc_csd  csd;  /* card specific */  struct mmc_ext_csd ext_csd; /* mmc v4 extended card specific */  struct sd_scr  scr;  /* extra SD information */  struct sd_switch_caps sw_caps; /* switch (CMD6) caps */

 unsigned int  sdio_funcs; /* number of SDIO functions */  struct sdio_cccr cccr;  /* common card info */  struct sdio_cis  cis;  /* common tuple info */    ... ... }; mmc_card結構體內的資料結構主要存放SD卡的資訊，其中RCA, CID, CSD, SCR為SD卡內部的32位暫存器。

 2.1.2 struct mmc_request

      結構體mmc_request定義於/include/linux/mmc/core.h，它主要存放兩大資料結構的指標，分別是cmd和data，顧名思意，一個為指令，一個為資料，也就是說，mmc_request結構體存放了進行主控制器與sd卡間通訊所需要的指令和資料，struct mmc_request, struct mmc_command *cmd, struct mmc_data *data三者之間的關係如下所示， 

struct mmc_request {  struct mmc_command *cmd;  struct mmc_data  *data;  struct mmc_command *stop;

 void   *done_data; /* completion data */  void   (*done)(struct mmc_request *);/* completion function */ };

   說到結構體mmc_command和mmc_data，就必須說說SD卡的協議了。

   1) 物理結構

     SD卡有9個pin腳（micro-SD為8個，少一個接地pin腳），如圖所示，

   SD的資料傳輸方式有兩種，普通SD模式和SPI模式，以SD模式為例，9個pin腳分別是VDD,VSS,CLK，以及我們需要關注的一根指令線CMD，4根資料線DAT0~DAT3。

   2) 傳輸模式

   首先由主機向SD卡傳送命令command，等待SD卡的回覆response，如果成功收到回覆，則進行資料傳輸。其中，指令線和資料線上傳輸的指令和資料都要遵循相應的協議格式。

 

   3) 指令格式

  

   一條指令command共48位，其中command index指代這條具體的指令名稱，argument為該指令的引數。

   一條回覆response根據不同的指令有幾種不同型別。

struct mmc_command {  u32   opcode;            // 對應command index  u32   arg;                  // 對應argument  u32   resp[4];           // 對應response  unsigned int  flags;  /* expected response type */

 ... ...

 unsigned int  retries; /* max number of retries */  unsigned int  error;  /* command error */

 struct mmc_data  *data;  /* data segment associated with cmd */  struct mmc_request *mrq;  /* associated request */ }; 

   4) 資料格式

   資料傳輸按資料線可分為一線傳輸和四線傳輸，按資料大小可分為位元組傳輸和塊傳輸（512位元組）。

struct mmc_data {  unsigned int  timeout_ns; /* data timeout (in ns, max 80ms) */  unsigned int  timeout_clks; /* data timeout (in clocks) */  unsigned int  blksz;  /* data block size */  unsigned int  blocks;  /* number of blocks */  unsigned int  error;  /* data error */  unsigned int  flags;

#define MMC_DATA_WRITE (1 << 8) #define MMC_DATA_READ (1 << 9) #define MMC_DATA_STREAM (1 << 10)

 unsigned int  bytes_xfered;

 struct mmc_command *stop;  /* stop command */  struct mmc_request *mrq;  /* associated request */

 unsigned int  sg_len;  /* size of scatter list */  struct scatterlist *sg;  /* I/O scatter list */ };

2.2 驅動程式

   系統初始化時掃描platform總線上是否有名為該SD主控制器名字"pxa2xx-mci"的裝置，如果有， 驅動程式將主控制器掛載到platform總線上，並註冊該驅動程式。

 static int __init pxamci_init(void) {

  return platform_driver_register(&pxamci_driver); }

static struct platform_driver pxamci_driver = {  .probe  = pxamci_probe,  .remove  = pxamci_remove,  .suspend = pxamci_suspend,  .resume  = pxamci_resume,  .driver  = {   .name = “pxa2xx-mci”,   .owner = THIS_MODULE,  }, }; 

其中，remove為probe的反操作，suspend和resume涉及電源管理的內容，本文重點討論probe。

SD主控制器驅動程式的初始化函式probe(struct platform_device *pdev)，概括地講，主要完成五大任務，

• 初始化裝置的資料結構，並將資料掛載到pdev->dev.driver_data下

• 實現裝置驅動的功能函式，如mmc->ops = &pxamci_ops;

• 申請中斷函式request_irq()

• 註冊裝置，即註冊kobject，建立sys檔案，傳送uevent等

• 其他需求，如在/proc/driver下建立使用者互動檔案等

2.2.1 註冊裝置

    對於裝置的註冊，所有裝置驅動的相關程式碼都類似。

static int pxamci_probe(struct platform_device *pdev)

{

  mmc = mmc_alloc_host(sizeof(struct pxamci_host), &pdev->dev);

  mmc_add_host(mmc);

  ... ...

}

這兩個函式都由/drivers/mmc/core核心層下的host.c負責具體實現，

1) mmc_alloc_host

為主裝置控制器建立資料結構，建立kobject，並初始化等待佇列，工作佇列，以及一些控制器的配置。其中，INIT_DELAYED_WORK(&host->detect, mmc_rescan);將探測SD卡的函式mmc_rescan與工作佇列host->detect關聯，mmc_rescan是整個SD子系統的核心函式，本文第三部分協議層將對它作重點討論。

struct mmc_host *mmc_alloc_host(int extra, struct device *dev) {

/* 建立資料結構 */

 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);

/* 配置控制器 */

 host->max_hw_segs = 1;  host->max_phys_segs = 1;

 ... ...  return host; }

2) mmc_add_host

完成kobject的註冊，並呼叫mmc_rescan，目的在於在系統初始化的時候就掃描SD匯流排檢視是否存在SD卡。注意到這裡的工作佇列的延時時間delay為0，因為系統啟動的時候不考慮插拔SD卡，關於這個delay將在下文討論。

int mmc_add_host(struct mmc_host *host) {   device_add(&host->class_dev);   mmc_start_host(host);

  ... ...

}

void mmc_start_host(struct mmc_host *host) {  mmc_power_off(host);  mmc_detect_change(host, 0); }

 void mmc_detect_change(struct mmc_host *host, unsigned long delay) {  mmc_schedule_delayed_work(&host->detect, delay); }

 static int mmc_schedule_delayed_work(struct delayed_work *work, unsigned long delay) {  wake_lock_timeout(&mmc_delayed_work_wake_lock, HZ * 2);  return queue_delayed_work(workqueue, work, delay); }

2.2.2 為裝置賦初值

   其實，整個裝置驅動的probe()函式，其本質就是是為裝置建立起資料結構並對其賦初值。pxamci_probe(struct platform_device *pdev)主要為SD主控制器完成時鐘、儲存等方面的初始化配置，

static int pxamci_probe(struct platform_device *pdev) {

 struct mmc_host *mmc;  struct pxamci_host *host = NULL;

 mmc->ops = &pxamci_ops;

 mmc->max_phys_segs = NR_SG;  mmc->max_hw_segs = NR_SG;

 mmc->max_seg_size = PAGE_SIZE;

 host = mmc_priv(mmc);  host->mmc = mmc;  host->dma = -1;  host->pdata = pdev->dev.platform_data;  host->clkrt = CLKRT_OFF;

 host->clk = clk_get(&pdev->dev, "MMCCLK");  host->clkrate = clk_get_rate(host->clk);

 mmc->caps |= MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED;

 host->sg_cpu = dma_alloc_coherent(&pdev->dev, PAGE_SIZE, &host->sg_dma, GFP_KERNEL);

 host->dma = pxa_request_dma(DRIVER_NAME, DMA_PRIO_LOW, pxamci_dma_irq, host);

 ... ...

}

完成所有賦值後，通過platform_set_drvdata(pdev, mmc);將資料掛載到pdev->dev.driver_data。

所有賦值中，我們重點關注從platform_device *pdev裡得到的資料。platform_device *pdev是在系統初始化的時候掃描platform匯流排發現SD主控制器後所得到的資料。

1) 得到platform_data資料

先看看platform_device的結構，

struct platform_device {  const char * name;  int  id;  struct device dev;  u32  num_resources;  struct resource * resource; };

系統初始化的時候，已經為該SD主控制器的name, resources等賦上了初值，具體內容如下，

struct platform_device pxa_device_mci = {  .name  = "pxa2xx-mci",  .id  = 0,  .dev  = {   .dma_mask = &pxamci_dmamask,   .coherent_dma_mask = 0xffffffff,  },  .num_resources = ARRAY_SIZE(pxamci_resources),  .resource = pxamci_resources, };

static struct resource pxamci_resources[] = {  [0] = {   .start = 0x41100000,   .end = 0x41100fff,   .flags = IORESOURCE_MEM,  // SD主控制器晶片的起始地址  },  [1] = {   .start = IRQ_MMC,          /* #define IRQ_MMC  23 */

  .end = IRQ_MMC,   .flags = IORESOURCE_IRQ,  // 申請的中斷號  },  ... ...

};

  需要注意的是，platform_device資料結構裡的name, id, resource等是所有裝置都用的到的資料型別，那麼裝置自身獨有的特性如何表現出來呢？事實上，結構體device專門準備了一個成員platform_data，就是為了掛載裝置的一些特有的資料。(注意與driver_data相區別)

struct device {   void  *platform_data; /* Platform specific data, device core doesn't touch it */

  void  *driver_data; /* data private to the driver */

  ... ...

}

  看看SD主控制器為什麼會有這些特有資料，

 static struct pxamci_platform_data saar_mci_platform_data = {  .detect_delay = 50,  .ocr_mask = MMC_VDD_32_33|MMC_VDD_33_34,  .init   = saar_mci_init,  .exit  = saar_mci_exit, };

-> detect_delay

   就是剛才提到的工作佇列的延時時間，設定為50ms，由於各種SD主控制器晶片的效能不同，這個值可能會變化。那麼為什麼要為工作佇列加一個延遲呢？首先，當插入SD卡之後，SD主控制器上的探測引腳會產生一箇中斷，之後呼叫中斷函式裡的工作佇列，然後執行工作佇列裡的mmc_rescan去掃描SD卡，為SD卡上電，傳送地址，註冊驅動等。考慮到插入SD卡需要一個短時間的過程(有個彈簧卡槽固定住SD卡)，如果沒有延遲，那麼插入SD卡的一瞬間，SD卡還沒有完全固定到主機板上，系統就開始執行mmc_rescan，那麼就很有可能在為SD卡上電、傳送地址的過程中出現錯誤(拔出SD卡同理)，因此，必須要有detect_delay這個值。

-> saar_mci_init

這個函式為SD主控制器的探測pin腳申請中斷，具體內容將在下文中斷的一節中討論。

static int saar_mci_init(struct device *dev, irq_handler_t saar_detect_int, void *data) {  struct platform_device *pdev = to_platform_device(dev);  int cd_irq, gpio_cd;  // cd - card detect

 saar_mmc_slot[0].gpio_cd  = mfp_to_gpio(MFP_PIN_GPIO61);  // 將GPIO61設為普通GPIO口

 cd_irq = gpio_to_irq(saar_mmc_slot[pdev->id].gpio_cd);   // 將GPIO61轉換為中斷號

 gpio_request(gpio_cd, "mmc card detect");  // 申請GPIO61  gpio_direction_input(gpio_cd);  // 將GPIO61設為輸入型別

 request_irq(cd_irq, saar_detect_int, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "MMC card detect", data);  ... ...

} 得到SD主控制器特有資料後，將其掛載到dev.platform_data下，並最終完成對platform_device *dev的註冊。

void __init pxa_register_device(struct platform_device *dev, void *data) {  dev->dev.platform_data = data;

 platform_device_register(dev); }

2) 使用platform_data資料

  下面就看看SD主控制器是如何使用這些在系統初始化的時候就已經得到的platform_device的資料的，

static int pxamci_probe(struct platform_device *pdev) {  struct mmc_host *mmc;  struct pxamci_host *host = NULL;  struct resource *r;  int ret, irq;

 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);    // 得到控制器晶片的起始地址  r = request_mem_region(r->start, SZ_4K, DRIVER_NAME); // 為晶片申請4k的記憶體空間

 irq = platform_get_irq(pdev, 0);  // 得到晶片的中斷號  host->res = r;  host->irq = irq;

 host->base = ioremap(r->start, SZ_4K); // 將晶片的實體地址對映為虛擬地址

 ... ...

}

2.2.3 裝置驅動的功能函式

   一般情況下，裝置驅動裡都有一個行為函式結構體，比如字元裝置驅動裡的struct file_operations *fops，該結構描述了裝置所具備的工作能力，比如open, read, write等，

struct file_operations {  struct module *owner;  ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);  ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);  int (*open) (struct inode *, struct file *);

 ... ... };

  同理，SD主控制器驅動程式裡也有一個類似的結構struct mmc_host_ops *ops，它描述了該控制器所具備驅動的能力。

static int pxamci_probe(struct platform_device *pdev) {

  mmc->ops = &pxamci_ops;

  ... ...

}

static const struct mmc_host_ops pxamci_ops = {  .request  = pxamci_request,  .get_ro   = pxamci_get_ro,  .set_ios  = pxamci_set_ios,  .enable_sdio_irq = pxamci_enable_sdio_irq, };

其中，(*set_ios)為主控制器設定匯流排和時鐘等配置，(*get_ro)得到只讀屬性，(*enable_sdio_irq)開啟sdio中斷，本文重點討論(*request)這個回撥函式，它是整個SD主控制器驅動的核心，實現了SD主控制器能與SD卡進行通訊的能力。

static void pxamci_request(struct mmc_host *mmc, struct mmc_request *mrq) {  struct pxamci_host *host = mmc_priv(mmc); unsigned int cmdat;

 set_mmc_cken(host, 1);

 host->mrq = mrq;

 cmdat = host->cmdat;  host->cmdat &= ~CMDAT_INIT;

 if (mrq->data) {   pxamci_setup_data(host, mrq->data);

  cmdat &= ~CMDAT_BUSY;   cmdat |= CMDAT_DATAEN | CMDAT_DMAEN;   if (mrq->data->flags & MMC_DATA_WRITE)    cmdat |= CMDAT_WRITE;

  if (mrq->data->flags & MMC_DATA_STREAM)    cmdat |= CMDAT_STREAM;  }

 pxamci_start_cmd(host, mrq->cmd, cmdat); }

其中， pxamci_setup_data()實現資料傳輸，pxamci_start_cmd()實現指令傳輸。

至此，我們必須去接觸SD主控制器的晶片手冊了。

首先，SD主控制器由一系列32位暫存器組成。通過軟體的方式，即對暫存器賦值，來控制SD主控制器，進而扮演SD主控制器的角色與SD卡取得通訊。

1) cmdat

  根據主控制器的晶片手冊，暫存器MMC_CMDAT控制命令和資料的傳輸，具體內容如下，

結合對暫存器MMC_CMDAT的描述，分析程式碼，

 host->cmdat &= ~CMDAT_INIT;               // 非初始化狀態

 if (mrq->data) {                                       // 如果存在資料需要傳輸   pxamci_setup_data(host, mrq->data);  // 實現主控制器與SD卡之間資料的傳輸

  cmdat &= ~CMDAT_BUSY;                      // 沒有忙碌busy訊號   cmdat |= CMDAT_DATAEN | CMDAT_DMAEN;   // 有資料傳輸，使用DMA   if (mrq->data->flags & MMC_DATA_WRITE)    

   cmdat |= CMDAT_WRITE;                               // 設定為寫資料

  if (mrq->data->flags & MMC_DATA_STREAM)    cmdat |= CMDAT_STREAM;                             // 設定為資料流stream模式

}

2) pxamci_setup_data  通過DMA實現主控制器與SD卡之間資料的傳輸

static void pxamci_setup_data(struct pxamci_host *host, struct mmc_data *data) {  host->data = data;

 writel(data->blocks, host->base + MMC_NOB);     // 設定塊的數量  writel(data->blksz, host->base + MMC_BLKLEN);  // 設定一個塊的大小(一般為512byte)

  if (data->flags & MMC_DATA_READ) {   host->dma_dir = DMA_FROM_DEVICE;   dcmd = DCMD_INCTRGADDR | DCMD_FLOWTRG;   DRCMR(host->dma_drcmrtx) = 0;   DRCMR(host->dma_drcmrrx) = host->dma | DRCMR_MAPVLD;  } else {   host->dma_dir = DMA_TO_DEVICE;   dcmd = DCMD_INCSRCADDR | DCMD_FLOWSRC;   DRCMR(host->dma_drcmrrx) = 0;   DRCMR(host->dma_drcmrtx) = host->dma | DRCMR_MAPVLD;  }

 dcmd |= DCMD_BURST32 | DCMD_WIDTH1;

 host->dma_len = dma_map_sg(mmc_dev(host->mmc), data->sg, data->sg_len, host->dma_dir);

 for (i = 0; i < host->dma_len; i++) {   unsigned int length = sg_dma_len(&data->sg[i]);   host->sg_cpu[i].dcmd = dcmd | length;   if (length & 31)    host->sg_cpu[i].dcmd |= DCMD_ENDIRQEN;   if (data->flags & MMC_DATA_READ) {    host->sg_cpu[i].dsadr = host->res->start + MMC_RXFIFO;    host->sg_cpu[i].dtadr = sg_dma_address(&data->sg[i]);   } else {    host->sg_cpu[i].dsadr = sg_dma_address(&data->sg[i]);    host->sg_cpu[i].dtadr = host->res->start + MMC_TXFIFO;   }   host->sg_cpu[i].ddadr = host->sg_dma + (i + 1) *      sizeof(struct pxa_dma_desc);  }  host->sg_cpu[host->dma_len - 1].ddadr = DDADR_STOP;  wmb();

 DDADR(host->dma) = host->sg_dma;  DCSR(host->dma) = DCSR_RUN; }

 for()迴圈裡的內容是整個SD卡主控制器裝置驅動的實質，通過DMA的方式實現主控制器與SD卡之間資料的讀寫操作。

3) pxamci_start_cmd  實現主控制器與SD卡之間指令的傳輸

static void pxamci_start_cmd(struct pxamci_host *host, struct mmc_command *cmd, unsigned int cmdat) {  host->cmd = cmd;

 if (cmd->flags & MMC_RSP_BUSY)   cmdat |= CMDAT_BUSY;

#define RSP_TYPE(x) ((x) & ~(MMC_RSP_BUSY|MMC_RSP_OPCODE))  switch (RSP_TYPE(mmc_resp_type(cmd))) {  case RSP_TYPE(MMC_RSP_R1): /* r1, r1b, r6, r7 */   cmdat |= CMDAT_RESP_SHORT;   break;  case RSP_TYPE(MMC_RSP_R3):   cmdat |= CMDAT_RESP_R3;   break;  case RSP_TYPE(MMC_RSP_R2):   cmdat |= CMDAT_RESP_R2;   break;  default:   break;  }

 writel(cmd->opcode, host->base + MMC_CMD);  writel(cmd->arg >> 16, host->base + MMC_ARGH);  writel(cmd->arg & 0xffff, host->base + MMC_ARGL);  writel(cmdat, host->base + MMC_CMDAT);

 pxamci_start_clock(host);

 pxamci_enable_irq(host, END_CMD_RES); }

-> response型別

  根據SD卡的協議，當SD卡收到從控制器發來的cmd指令後，SD卡會發出response相應，而response的型別分為R1,R1b,R2,R3,R6,R7，這些型別分別對應不同的指令，各自的資料包結構也不同(具體內容參考SD卡協議)。這裡，通過RSP_TYPE對指令cmd的opcode的解析得到相對應的reponse型別，再通過swich賦給暫存器MMC_CMDAT對應的[1:0]位。

-> 將指令和引數寫入暫存器

  4行writel()是整個SD卡主控制器裝置驅動的實質，通過對主控制器晶片暫存器MMC_CMD,MMC_ARGH,MMC_ARGL,MMC_CMDAT的設定，實現主控制器傳送指令到SD卡的功能。

4) 呼叫(*request)

 以上通過pxamci_request()實現了主控制器的通訊功能，之後只須通過host->ops->request(host, mrq);回撥函式即可。

協議層裡，每條指令都會通過mmc_wait_for_req(host, &mrq)呼叫到host->ops->request(host, mrq)來發送指令和資料。

/* core/core.c */

void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq) {  DECLARE_COMPLETION_ONSTACK(complete);

 mrq->done_data = &complete;  mrq->done = mmc_wait_done;

 mmc_start_request(host, mrq);

 wait_for_completion(&complete); }

mmc_start_request(struct mmc_host *host, struct mmc_request *mrq) {  ... ...

 host->ops->request(host, mrq); }

2.2.4 申請中斷

  pxamci_probe(struct platform_device *pdev)中有兩個中斷，一個為SD主控制器晶片內電路固有的內部中斷，另一個為探測引腳的探測到外部有SD卡插拔引起的中斷。 1) 由主控晶片內部電路引起的中斷

 request_irq(host->irq, pxamci_irq, 0, "pxa2xx-mci", host);

回顧一下，host->irq就是剛才從platform_device裡得到的中斷號，

 irq = platform_get_irq(pdev, 0);

 host->irq = irq;

接下來，pxamci_irq便是為該中斷host->irq申請的中斷函式，

static irqreturn_t pxamci_irq(int irq, void *devid) {  struct pxamci_host *host = devid;   // 得到主控制器的資料  unsigned int ireg; int handled = 0;  ireg = readl(host->base + MMC_I_REG) & ~readl(host->base + MMC_I_MASK);  // 讀取中斷暫存器的值

 if (ireg) {   unsigned stat = readl(host->base + MMC_STAT);  // 讀取狀態暫存器的值

  if (ireg & END_CMD_RES)    handled |= pxamci_cmd_done(host, stat);   if (ireg & DATA_TRAN_DONE)    handled |= pxamci_data_done(host, stat);   if (ireg & SDIO_INT) {    mmc_signal_sdio_irq(host->mmc);   }  }

 return IRQ_RETVAL(handled);

}

當呼叫(*request)，即host->ops->request(host, mrq)，即上文中的pxamci_request()後，控制器與SD卡之間開始進行一次指令或資料傳輸，通訊完畢後，主控晶片將產生一個內部中斷，以告知此次指令或資料傳輸完畢。這個中斷的具體值將儲存在一個名為MMC_I_REG的中斷暫存器中以供讀取，中斷暫存器MMC_I_REG中相關描述如下，

如果中斷暫存器MMC_I_REG中的第0位有值，則意味著資料傳輸完成，執行pxamci_cmd_done(host, stat);

如果中斷暫存器MMC_I_REG中的第2位有值，則意味著指令傳輸完成，執行pxamci_data_done(host, stat);

其中stat是從狀態暫存器MMC_STAT中讀取的值，在程式碼裡主要起到處理錯誤狀態的作用。 -> pxamci_cmd_done 收到結束指令的內部中斷訊號，主控制器從SD卡那裡得到response，結束這次指令傳輸 這裡需要注意，暫存器MMC_RES裡已經存放了來自SD卡傳送過來的response，以供讀取。

static int pxamci_cmd_done(struct pxamci_host *host, unsigned int stat) {  struct mmc_command *cmd = host->cmd;

 cmd->resp[i] = readl(host->base + MMC_RES) & 0xffff; 

 if (stat & STAT_TIME_OUT_RESPONSE) {   cmd->error = -ETIMEDOUT;  } else if (stat & STAT_RES_CRC_ERR && cmd->flags & MMC_RSP_CRC) {

   cmd->error = -EILSEQ;

}

 pxamci_disable_irq(host, END_CMD_RES);  if (host->data && !cmd->error) {   pxamci_enable_irq(host, DATA_TRAN_DONE);  } else {   pxamci_finish_request(host, host->mrq); // 結束一次傳輸，清空主控制器中的指令和資料  }

 return 1; }

-> pxamci_data_done  收到結束資料的內部中斷訊號，得到傳輸資料的大小，結束這次資料傳輸

 static int pxamci_data_done(struct pxamci_host *host, unsigned int stat) {  struct mmc_data *data = host->data;

 DCSR(host->dma) = 0;  dma_unmap_sg(mmc_dev(host->mmc), data->sg, host->dma_len, host->dma_dir);

 if (stat & STAT_READ_TIME_OUT)   data->error = -ETIMEDOUT;  else if (stat & (STAT_CRC_READ_ERROR|STAT_CRC_WRITE_ERROR))   data->error = -EILSEQ;

 if (!data->error)   data->bytes_xfered = data->blocks * data->blksz;  // 資料傳輸量=塊的數量*每個塊的大小(一般為512位元組)  else   data->bytes_xfered = 0;

 pxamci_disable_irq(host, DATA_TRAN_DONE);

 host->data = NULL;  pxamci_finish_request(host, host->mrq);  ... ...

} static void pxamci_finish_request(struct pxamci_host *host, struct mmc_request *mrq) {  host->mrq = NULL;  host->cmd = NULL;  host->data = NULL;  mmc_request_done(host->mmc, mrq);  set_mmc_cken(host, 0);  unset_dvfm_constraint(); }

/* drivers/mmc/core/core.c */ void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq) {

   ... ...    if (mrq->done)    mrq->done(mrq); } 

這裡用到了完成量completion，LDD3上是這樣說的，完成量是一個任務的輕量級機制，允許一個執行緒告知另一個執行緒工作已經完成。這裡的一個執行緒就是內部中斷處理函式，它是結束主控制器與SD卡間通訊的執行緒，通過mrq->done(mrq); 即complete(mrq->done_data);告知另一個執行緒-回撥(*request)實現主控制器與SD卡進行通訊的執行緒，通訊已經完畢。

void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq) {  DECLARE_COMPLETION_ONSTACK(complete);

 mrq->done_data = &complete;  mrq->done = mmc_wait_done;

 mmc_start_request(host, mrq);

 wait_for_completion(&complete); }

static void mmc_wait_done(struct mmc_request *mrq) {  complete(mrq->done_data); }

2) 探測引腳引起的中斷

  if (host->pdata && host->pdata->init)    host->pdata->init(&pdev->dev, pxamci_detect_irq, mmc);

 該init()回撥函式就是剛才提到的系統初始化時通過saar_mci_init()實現的， 

static int saar_mci_init(struct device *dev, irq_handler_t saar_detect_int, void *data) {

 request_irq(cd_irq, saar_detect_int, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "MMC card detect", data);  ... ...

}

其中，cd_irq是通過GPIO轉換得到的中斷號，pxamci_detect_irq便是該中斷實現的函式，之前已經提到過mmc_detect_change，它將最終呼叫queue_delayed_work執行工作佇列裡的mmc_rescan函式。 static irqreturn_t pxamci_detect_irq(int irq, void *devid) {  struct pxamci_host *host = mmc_priv(devid);

 mmc_detect_change(devid, host->pdata->detect_delay);  return IRQ_HANDLED; }

當有SD卡插入或拔出時，硬體主控制器晶片的探測pin腳產生外部中斷，進入中斷處理函式，執行工作佇列裡的mmc_rescan，掃描SD匯流排，對插入或拔出SD卡作相應的處理。下文協議層將討論mmc_rescan()。

  3. 協議層

   Linux在核心原始碼的drivers/mmc/core資料夾下為我們的提供了一系列SD卡的介面服務函式。可以檢視Makefile如下，

可見，core資料夾下有針對匯流排的服務bus.c，針對主控制器的服務host.c，針對SD卡的服務sd.c, sd_ops.c等等。

其中，最為核心的一個函式便是之前提到的位於core.c的mmc_rescan，概括來講，主要完成兩項任務，即

• 掃描SD匯流排，插入SD卡
• 掃描SD匯流排，拔出SD卡

3.1 插入SD卡

插入SD卡，主控制器產生中斷，進入中斷處理函式，處理工作佇列，執行mmc_rescan。

void mmc_rescan(struct work_struct *work) {  struct mmc_host *host = container_of(work, struct mmc_host, detect.work); // 得到mmc_host的資料  /*   * First we search for SDIO...   */  err = mmc_send_io_op_cond(host, 0, &ocr);  if (!err) {   if (mmc_attach_sdio(host, ocr))    mmc_power_off(host);   goto out;  }

 /*   * ...then normal SD...   */  err = mmc_send_app_op_cond(host, 0, &ocr);  if (!err) {   if (mmc_attach_sd(host, ocr))    mmc_power_off(host);   goto out;  }

 /*   * ...and finally MMC.   */  err = mmc_send_op_cond(host, 0, &ocr);  if (!err) {   if (mmc_attach_mmc(host, ocr))    mmc_power_off(host);   goto out;  }

  ... ...

}

插入SD卡，mmc_rescan掃描SD總線上是否存在SD卡，具體的實現方法就是通過向SD卡上電，看是否能成功，以普通SD卡為例，為普通SD卡上電的函式mmc_send_app_op_cond(host, 0, &ocr);如果上電成功，則返回0，即執行if()裡的mmc_attach_sd()進行匯流排與SD卡的繫結。如果上電失敗，則返回非0值，跳過if()，嘗試其他上電的方法。那麼，上電方法究竟有何不同呢？具體看看mmc_send_app_op_cond()的實現過程，

int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr) {  struct mmc_command cmd;  cmd.opcode = SD_APP_OP_COND;    /* #define SD_APP_OP_COND   41   */  mmc_wait_for_app_cmd(host, NULL, &cmd, MMC_CMD_RETRIES);

 ... ...

} int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card, struct mmc_command *cmd, int retries) {

  mmc_app_cmd(host, card);   /* #define MMC_APP_CMD   55   */   mrq.cmd = cmd;   cmd->data = NULL;

  mmc_wait_for_req(host, &mrq);

  ... ...

}

這裡的指令SD_APP_OP_COND只有SD2.0的協議支援，也就是說，只有普通SD卡支援，所以也只有普通SD卡能夠成功上電。 

        

如果上電成功，就開始進行匯流排與SD卡的繫結，通過mmc_attach_sd()，繫結過程可分為四步，

• 註冊SD總線上的操作函式 - struct mmc_bus_ops mmc_sd_ops
• 設定主控制器的時鐘和匯流排方式 - 通過回撥函式host->ops->set_ios();
• 啟動SD卡 - 根據協議，完成SD卡啟動的各個步驟
• 註冊SD卡裝置驅動

3.1.1 註冊總線上的操作函式

 int mmc_attach_sd(struct mmc_host *host, u32 ocr) {  mmc_sd_attach_bus_ops(host);

 ... ...

}

static void mmc_sd_attach_bus_ops(struct mmc_host *host) {  const struct mmc_bus_ops *bus_ops;

 bus_ops = &mmc_sd_ops;  mmc_attach_bus(host, bus_ops); }

void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops) {  host->bus_ops = ops;  host->bus_refs = 1;  host->bus_dead = 0;

}

static const struct mmc_bus_ops mmc_sd_ops = {  .remove = mmc_sd_remove,  // 拔出SD卡的操作函式  .detect = mmc_sd_detect,      // 探測SD卡的操作函式  .suspend = NULL,  .resume = NULL,  .power_restore = mmc_sd_power_restore,  // 重新啟動SD卡的操作函式 }; 這裡的mmc_sd_detect和mmc_sd_remove就是拔出SD卡所需要用到的函式，下文將詳細討論。這裡需要注意的是，插入SD卡的時候，並不執行mmc_sd_detect和mmc_sd_remove這兩個函式，但是會註冊它們，也就是說，這兩個函式的功能已經實現，將來可以使用。

3.1.2 設定時鐘和匯流排

 int mmc_attach_sd(struct mmc_host *host, u32 ocr) {   host->ocr = mmc_select_voltage(host, ocr);

  ... ...

}

u32 mmc_select_voltage(struct mmc_host *host, u32 ocr) {   mmc_set_ios(host);

  ... ... } static inline void mmc_set_ios(struct mmc_host *host) {  struct mmc_ios *ios = &host->ios;

 host->ops->set_ios(host, ios);  // 設定主控制器時鐘和匯流排的回撥函式，具體實現由主控制器驅動完成 } 從這裡可以體會到回撥函式的精髓：協議層裡利用回撥函式為所有滿足該協議的裝置提供統一的介面，而具體實現由底層不同的裝置驅動各自完成。注意到，之所以要定義一些放之四海而皆準的公用的類，比如struct mmc_host，就是需要通過struct mmc_host *host指標作為形參傳到協議層所提供的介面函式中，從而得以呼叫。

3.1.3 啟動SD卡

 int mmc_attach_sd(struct mmc_host *host, u32 ocr) {

  mmc_sd_init_card(host, host->ocr, NULL);

  ... ...

}

  mmc_sd_init_card主要完成以下任務，

• SD卡的啟動過程
• 得到暫存器CID, CSD, SCR, RCA的資料
• 其他操作比如切換到高速模式，初始化card

static int mmc_sd_init_card(struct mmc_host *host, u32 ocr, struct mmc_card *oldcard) {

  /* SD卡的啟動過程 */

  mmc_go_idle(host);

  mmc_send_if_cond(host, ocr);

  mmc_send_app_op_cond(host, ocr, NULL);

  mmc_all_send_cid(host, cid);

  mmc_send_relative_addr(host, &card->rca);

  /* 得到暫存器CID, CSD, SCR的資料 */

  mmc_send_csd(card, card->raw_csd);

  mmc_decode_csd(card);

  mmc_decode_cid(card);

  mmc_app_send_scr(card, card->raw_scr);

  mmc_decode_scr(card);

  /* 其它操作 */

  mmc_alloc_card(host, &sd_type);

  mmc_select_card(card); 

  mmc_read_switch(card);

  mmc_switch_hs(card);

  ... ...

}

1) SD卡的啟動過程

  根據SD2.0協議，SD卡的狀態可分為兩種模式：卡識別模式(card-identification mode)和資料傳輸模式(data-transfer mode)。這裡，我們關注啟動SD卡的卡識別模式。

結合程式碼，

  mmc_go_idle(host);                     CMD0

  Idle State

  mmc_send_if_cond(host, ocr);     CMD8

  mmc_send_app_op_cond(host, ocr, NULL);       ACMD41

  Ready State

  mmc_all_send_cid(host, cid);       CMD2

Identification State

  mmc_send_relative_addr(host, &card->rca);     CMD3

  Stand-by State

2) 暫存器CID, CSD, SCR, RCA

-> 傳送指令並得到暫存器的值

  當主控制器向SD卡傳送cmd指令，比如mmc_send_cid(card, card->raw_cid)，請求得到SD卡CID暫存器的值，當主控制器傳送cmd完成後，晶片產生一個內部中斷，處理結束cmd的中斷函式，之後得到來自SD卡的response，即CID暫存器的值，存放於host->cmd->resp[i]中。關於內部中斷處理，參看上文的中斷一節裡的 mmc_wait_for_cmd()。

mmc_send_cid(card, card->raw_cid);這個函式傳送了接收CSD暫存器的請求，並且得到了來自SD卡的CSD暫存器的值。

int mmc_send_cid(struct mmc_card *card, u32 *cid) {    return mmc_send_cxd_native(card->host, card->rca << 16, cid, MMC_SEND_CID);

}

static int mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode) {  cmd.opcode = opcode;  cmd.arg = arg;  cmd.flags = MMC_RSP_R2 | MMC_CMD_AC;

 mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);

 memcpy(cxd, cmd.resp, sizeof(u32) * 4);  // 得到response賦給cxd，即card->raw_cid

 ... ... }

-> 解析暫存器的值

為什麼要解析？先來看看暫存器CID在SD卡協議裡的定義，它是一個128位的暫存器，存放了關於這塊SD卡的基本資訊，就像自己的身份證。通過mmc_send_cid()將這個暫存器的數值賦給了card->raw_cid (定義 u32 raw_cid[4];) ，為了方便得到具體某一個資訊，協議層為我們解析了暫存器裡的域，並賦給card->cid，比如廠商名稱，就可以通過card->cid.manfid直接讀取到。

static int mmc_decode_cid(struct mmc_card *card) {   u32 *resp = card->raw_cid;

  card->cid.manfid = UNSTUFF_BITS(resp, 120, 8);   card->cid.oemid  = UNSTUFF_BITS(resp, 104, 16);   card->cid.prod_name[0] = UNSTUFF_BITS(resp, 96, 8);   card->cid.prod_name[1] = UNSTUFF_BITS(resp, 88, 8);   card->cid.prod_name[2] = UNSTUFF_BITS(resp, 80, 8);   card->cid.prod_name[3] = UNSTUFF_BITS(resp, 72, 8);   card->cid.prod_name[4] = UNSTUFF_BITS(resp, 64, 8);   card->cid.prod_name[5] = UNSTUFF_BITS(resp, 56, 8);   card->cid.serial = UNSTUFF_BITS(resp, 16, 32);   card->cid.month  = UNSTUFF_BITS(resp, 12, 4);   card->cid.year  = UNSTUFF_BITS(resp, 8, 4) + 1997;   return 0; }

3.1.4 註冊SD卡裝置驅動

 int mmc_attach_sd(struct mmc_host *host, u32 ocr) {

  /* mmc_alloc_card(host, &sd_type); 在mmc_sd_init_card()已完成 */

  mmc_add_card(host->card);

  ... ...

}

上文已經提到，裝置驅動程式都會通過alloc_xxx()和add_xxx()兩步來註冊驅動，其實質是呼叫/drivers/base/core.c裡的device_initialize()和device_add()，device_add()完成建立kobject，sys檔案，傳送uevent，等工作。

3.2 拔出SD卡

 void mmc_rescan(struct work_struct *work) {  struct mmc_host *host = container_of(work, struct mmc_host, detect.work);  mmc_bus_get(host);

 /* if there is a card registered, check whether it is still present */  if ((host->bus_ops != NULL) && host->bus_ops->detect && !host->bus_dead)   host->bus_ops->detect(host);

 mmc_bus_put(host);

 ... ...

}

這裡的mmc_bus_get/put()，為SD匯流排加上一個自旋鎖，規定同時只能有一個執行緒在SD總線上操作。

3.2.1 bus_ops->detect()

mmc_rescan()掃描SD匯流排，如果發現host->ops上賦了值，即之前已有SD卡註冊過，就執行bus_ops->detect()操作去探測SD總線上是否還存在SD卡，如果不存在了，就執行bus_ops->remove()拔出SD卡。之前已經提到，這個bus_ops->detect()已在mmc_attach_sd()註冊完成了。

 static void mmc_sd_detect(struct mmc_host *host) {  mmc_claim_host(host);

 /*   * Just check if our card has been removed.   */  err = mmc_send_status(host->card, NULL);

 mmc_release_host(host);

 if (err) {   mmc_sd_remove(host);

  mmc_claim_host(host);   mmc_detach_bus(host);   mmc_release_host(host);  } } 這裡的mmc_claim_host(host)通過set_current_state(TASK_RUNNING);將當前程序設定為正在執行程序。

mmc_send_status()傳送得到SD卡狀態的請求，如果未能得到狀態資料，則執行mmc_sd_remove(host)拔出SD卡。

int mmc_send_status(struct mmc_card *card, u32 *status) {  struct mmc_command cmd;

 cmd.opcode = MMC_SEND_STATUS;    /* #define MMC_SEND_STATUS   13 */  cmd.arg = card->rca << 16;  cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;

 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES);

 if (err)                  return err;           // 接收來自SD卡的response失敗，即沒有發現SD卡  if (status)   *status = cmd.resp[0];

 return 0;

} 主控制器傳送命令CMD13，要求得到SD卡的狀態暫存器CSR和SSR。

SD協議規定，狀態暫存器CSR是必須的，這個32位暫存器作為R1的一個域返回給主控制器，

狀態暫存器SSR作為擴充功能，具體參考SD2.0協議。

3.2.2 bus_ops->remove()

拔出SD卡，其實就是註冊SD卡驅動的反操作，實質就是執行device_del()和device_put()。

static void mmc_sd_remove(struct mmc_host *host) {  mmc_remove_card(host->card);  host->card = NULL; } void mmc_remove_card(struct mmc_card *card) {  if (mmc_card_present(card))   device_del(&card->dev);

 put_device(&card->dev); }

4. 塊裝置

首先，必須知道為什麼要用到塊裝置。在linux下，SD卡通過block塊的方式(以512位元組為最小單位)進行資料傳輸，它必須遵從塊裝置架構。在linux塊裝置層，I/O排程者通過請求佇列機制負責對塊資料的處理。

SD卡子系統分為三層，主裝置層，協議層和塊裝置層。塊裝置驅動位於/drivers/mmc/card/block.c，主要完成兩個任務，

• 建立裝置節點

• 通過請求佇列機制進行資料傳輸

插入SD卡，註冊驅動成功，那麼在開發板的目錄/dev/block下會出現SD卡的裝置節點。 

179為主裝置號，定義於include/linux/major.h  #define MMC_BLOCK_MAJOR  179

179:0代表這塊SD卡的裝置節點mmcblk0，179:1代表這塊SD卡的第一個分割槽mmcblk0p1，即主分割槽，如果有第二個分割槽，那就是179:2，最多可以有7個分割槽，即179:1~179:7(定義於block.c  alloc_disk(1 << 3);)。不過，SD卡一般只有一個分割槽。如果有第二塊SD卡插入，將會建立裝置節點mmcblk1(179:8)和mmcblk1p1(179:9)。 

下面通過對塊裝置驅動block.c的分析，看看SD卡是如何在塊裝置層建立節點和傳輸資料的。

4.1 資料結構

每個驅動都會有一個數據結構。幸運的是，我們SD卡塊裝置驅動的資料結構相對簡單，在mmc_blk_data裡，主要有兩個成員，struct gendisk *disk和struct mmc_queue queue。

1) struct gendisk 是general disk的縮寫，代表個通用的塊裝置，其中包括塊裝置的主分割槽結構struct hd_struct part0， 塊裝置的行為函式struct block_device_operations *fops，以及請求佇列struct request_queue *queue等。

2) struct request_queue 存放所有I/O排程的演算法。

3) struct request 請求是I/O排程者排程的物件，其中的結構struct bio是整個請求佇列的核心，具體內容請參看LDD3。

4.2 塊裝置驅動

首先瀏覽一下原始碼，

static int __init mmc_blk_init(void) {  register_blkdev(MMC_BLOCK_MAJOR, "mmc");    // 註冊主裝置號(若註冊成功，/proc/devices的塊裝置下會出現mmc)  mmc_register_driver(&mmc_driver);  return 0; }

static struct mmc_driver mmc_driver = {  .drv  = {   .name = "mmcblk",  },  .probe  = mmc_blk_probe,  .remove  = mmc_blk_remove,  .suspend = mmc_blk_suspend,  .resume  = mmc_blk_resume, };

static int mmc_blk_probe(struct mmc_card *card) {  struct mmc_blk_data *md;  md = mmc_blk_alloc(card);  mmc_blk_set_blksize(md, card);

 mmc_set_drvdata(card, md);  add_disk(md->disk);  return 0;

 ... ...

}

4.2.1 裝置驅動的初始化函式

  仍然可以將驅動程式的初始化mmc_blk_probe(struct mmc_card *card)歸納為以下內容，

• 初始化裝置驅動的資料結構mmc_blk_data，並掛載到card->dev.driver_data

• 實現塊備驅動的功能函式struct block_device_operations *fops

• 註冊裝置，即註冊kobject，建立sys檔案，傳送uevent等

• 其他需求，如mmc_blk_set_blksize(md, card);

1) 初始化mmc_blk_data

static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card) {  struct mmc_blk_data *md;  md = kzalloc(sizeof(struct mmc_blk_data), GFP_KERNEL);  md->read_only = mmc_blk_readonly(card);

 md->disk = alloc_disk(1 << 3);   // 分配了8個可用裝置

 spin_lock_init(&md->lock);  md->usage = 1;  ret = mmc_init_queue(&md->queue, card, &md->lock);

 md->queue.issue_fn = mmc_blk_issue_rq;  md->queue.data = md;

 md->disk->major = MMC_BLOCK_MAJOR;  md->disk->first_minor = devidx << MMC_SHIFT;  md->disk->fops = &mmc_bdops;  md->disk->private_data = md;  md->disk->queue = md->queue.queue;  md->disk->driverfs_dev = &card->dev;

 blk_queue_logical_block_size(md->queue.queue, 512);

 ... ...

 return md;

}

完成初始化後，通過mmc_set_drvdata(card, md);將資料掛載到card->dev.driver_data下。

2) 功能函式

static const struct block_device_operations mmc_bdops = {  .open   = mmc_blk_open,  .release  = mmc_blk_release,  .getgeo   = mmc_blk_getgeo,  .owner   = THIS_MODULE, };

static int mmc_blk_open(struct block_device *bdev, fmode_t mode) {  struct mmc_blk_data *md = mmc_blk_get(bdev->bd_disk);

 ... ... } struct block_device {  dev_t   bd_dev;  /* it's a search key */  struct inode *  bd_inode; /* will die */  struct super_block * bd_super;

 ... ... };

與字元驅動類似，通過dev_t和inode找到裝置。

3) 註冊驅動

void add_disk(struct gendisk *disk) {  blk_register_region(disk_devt(disk), disk->minors, NULL, exact_match, exact_lock, disk);  register_disk(disk);  blk_register_queue(disk);

 ... ...

}

blk_register_region()在linux中實現了一種利用雜湊表管理裝置號的機制。

register_disk()對應alloc_disk()，完成對塊裝置的註冊，其實質是通過register_disk()->blkdev_get()->__blkdev_get()->rescan_partitions()->add_partitions()新增分割槽，建立裝置節點。

blk_register_queue()對應blk_init_queue()完成對請求佇列的註冊，其實質是通過elv_register_queue()註冊請求佇列的演算法。

關於塊裝置更為具體的程式碼分析可參看linux那些事。

4.2.2 請求佇列

mmc_init_queue申請並初始化一個請求佇列，開啟負責處理這個請求佇列的守護程序。

int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, spinlock_t *lock) {  struct mmc_host *host = card->host;  mq->card = card;  mq->queue = blk_init_queue(mmc_request, lock);

 mq->queue->queuedata = mq;  mq->req = NULL;

 blk_queue_prep_rq(mq->queue, mmc_prep_request);  // 註冊mmc_prep_request演算法  blk_queue_ordered(mq->queue, QUEUE_ORDERED_DRAIN, NULL);  //註冊ordered演算法  mq->thread = kthread_run(mmc_queue_thread, mq, "mmcqd");

   ... ... }

1) mmc_request

它是處理SD卡通用的申請請求的回撥函式，或者說是SD卡申請請求的演算法。當CPU處於not busy狀態，會尋找一個請求，並試圖執行它。

/* /drivers/mmc/card/queue.c  */

/*  * Generic MMC request handler.  This is called for any queue on a  * particular host.  When the host is not busy, we look for a request  * on any queue on this host, and attempt to issue it.  This may  * not be the queue we were asked to process.  */ static void mmc_request(struct request_queue *q) {  struct mmc_queue *mq = q->queuedata;  struct request *req;

 if (!mq) {   while ((req = blk_fetch_request(q)) != NULL) { // 尋找來自請求佇列的一個請求req    req->cmd_flags |= REQ_QUIET;    __blk_end_request_all(req, -EIO);   }   return;  }

 if (!mq->req)   wake_up_process(mq->thread);    //  如果佇列裡沒有請求req，喚醒守護程序 }

這裡我們需要關注這個處理該SD卡請求佇列的演算法是何時申請的，也就是何時會去申請請求，何時會去喚醒核心執行緒。

用到回撥函式q->request_fn有三處

• 塊裝置驅動註冊請求佇列blk_register_queue()

• 驅動程式出錯，清空請求佇列mmc_cleanup_queue()

• 實現請求佇列機制的blk_fetch_request內部本身

blk_fetch_request()->blk_peek_request()->__elv_next_request()->blk_do_ordered()->...->q->request_fn

我們不必深究所謂的電梯演算法，只要知道，它是使資料得以高效通訊的一種演算法，演算法自身決定何時去喚醒守護程序處理請求。

2) blk_init_queue()

如果一個塊裝置希望使用一個標準的請求處理步驟，那就必須使用blk_init_queue()。這個函式註冊了q->request_fn(這裡就是mmc_request)，並初始化請求佇列的資料結構struct request_queue。

/*

 *    call blk_init_queue().  The function @rfn will be called when there  *    are requests on the queue that need to be processed.  If the device  *    supports plugging, then @rfn may not be called immediately when requests  *    are available on the queue, but may be called at some time later instead.

 */ 

 struct request_queue *blk_init_queue(request_fn_proc *rfn, spinlock_t *lock) {  return blk_init_queue_node(rfn, lock, -1); }

其中的rfn就是請求佇列的一個演算法，即這裡的mmc_request。

struct request_queue *blk_init_queue_node(request_fn_proc *rfn, spinlock_t *lock, int node_id) {  struct request_queue *q = blk_alloc_queue_node(GFP_KERNEL, node_id);

 q->request_fn  = rfn;  q->prep_rq_fn  = NULL;  q->unplug_fn  = generic_unplug_device;  q->queue_flags  = QUEUE_FLAG_DEFAULT;  q->queue_lock  = lock;

 blk_queue_make_request(q, __make_request);

 if (!elevator_init(q, NULL)) {   blk_queue_congestion_threshold(q);   return q;  }

  ... ...

}

3) kthead_run()

注意到mmc_init_queue這個函式的最後，建立並執行一個名為mmcqd的執行緒，顧名思意，mmc queue deamon它是一個SD卡的處理請求佇列的守護程序，或者說核心執行緒，當系統註冊SD卡塊裝置驅動時，就通過mmc_init_queue()開啟了這個核心執行緒。

4) mmc_queue_thread 

看看這個核心執行緒做了些什麼，

static int mmc_queue_thread(void *d) {  struct mmc_queue *mq = d;  struct request_queue *q = mq->queue;

 current->flags |= PF_MEMALLOC;

 down(&mq->thread_sem);

 do {   struct request *req = NULL;

  spin_lock_irq(q->queue_lock);   set_current_state(TASK_INTERRUPTIBLE);   if (!blk_queue_plugged(q))    req = blk_fetch_request(q);   mq->req = req;   spin_unlock_irq(q->queue_lock);

  if (!req) {

   if (kthread_should_stop()) {     set_current_state(TASK_RUNNING);     break;    }    up(&mq->thread_sem);    schedule();    down(&mq->thread_sem);    continue;   }   set_current_state(TASK_RUNNING);

  mq->issue_fn(mq, req);  } while (1);

 up(&mq->thread_sem);

 return 0; }

首先，這個守護程序是一個while(1)死迴圈，如果沒有特殊要求，即kthread_should_stop()指定要把這個核心執行緒終止掉，那麼它將從系統啟動開始一直負責處理SD卡的請求佇列。

在迴圈內部，核心執行緒首先通過set_current_state(TASK_INTERRUPTIBLE);設定當前執行緒為可打斷的等待執行緒，進入睡眠狀態，等待其他執行緒喚醒它，這裡喚醒它的就是處理SD卡請求的mmc_request，當mq->req為空，即當前沒有請求正在處理，則通過 wake_up_process(mq->thread);喚醒核心執行緒，接著該執行緒嘗試從請求佇列裡得到一個請求req，

-> 如果沒有請求，則呼叫schedule()交出cpu的使用權讓其自由排程，等到系統空閒時，再次得到cpu控制權，並且執行continue;退出當前迴圈，重新開始新的迴圈。

-> 如果得到了一個請求，則通過set_current_state(TASK_RUNNING);將該核心執行緒設定為當前正在執行的程序，並呼叫issue_fn()，即mmc_blk_issue_rq，處理這個請求，實現主控制器與SD卡的資料傳輸。

5) issue_fn

驅動初始化函式probe()裡的mmc_blk_alloc()裡註冊了這個回撥函式，md->queue.issue_fn =mmc_blk_issue_rq;

這個函式將req裡的成員解析成為mmc_blk_request裡的指令和資料，即mmc_command和mmc_data，然後通過mmc_wait_for_req()最終實現主控制器與SD卡間的通訊。

struct mmc_blk_request {  struct mmc_request mrq;  struct mmc_command cmd;  struct mmc_command stop;  struct mmc_data  data; }; static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req) {  struct mmc_blk_data *md = mq->data;  struct mmc_card *card = md->queue.card;  struct mmc_blk_request brq;

 mmc_claim_host(card->host);

 do {

  brq.mrq.cmd = &brq.cmd;   brq.mrq.data = &brq.data;

  brq.cmd.arg = blk_rq_pos(req);             // 解析指令的引數   if (!mmc_card_blockaddr(card))    brq.cmd.arg <<= 9;   brq.cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;   brq.data.blksz = 512;   brq.stop.opcode = MMC_STOP_TRANSMISSION;   brq.stop.arg = 0;   brq.stop.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;   brq.data.blocks = blk_rq_sectors(req);  // 解析資料塊大小

  if (rq_data_dir(req) == READ) {              // 解析傳輸資料方向    brq.cmd.opcode = MMC_READ_MULTIPLE_BLOCK;    brq.data.flags |= MMC_DATA_READ;   } else {    brq.cmd.opcode = MMC_WRITE_MULTIPLE_BLOCK;    brq.data.flags |= MMC_DATA_WRITE;   }

   mmc_wait_for_req(card->host, &brq.mrq);   // 呼叫core協議層提供的介面函式，實現資料間通訊

   ... ...

  }

  mmc_release_host(card->host);

}

--------------------- 本文來自 evilcode 的CSDN 部落格 ，全文地址請點選：https://blog.csdn.net/evilcode/article/details/7418323?utm_source=copy