嵌入式linux sd卡读写,嵌入式Linux之我行——S3C2440上MMC/SD卡驱动实例开发讲解(二)...
嵌入式Linux之我行，主要講述和總結了本人在學習嵌入式linux中的每個步驟。一為總結經驗，二希望能給想入門嵌入式Linux的朋友提供方便。如有錯誤之處，謝請指正。
一、開發環境
主 ?機：VMWare--Fedora 9
開發板：Mini2440--64MB Nand, Kernel:2.6.30.4
編譯器：arm-linux-gcc-4.3.2
6. s3cmci_ops SDI主機控制器操作接口函數功能分析：
static struct mmc_host_ops s3cmci_ops =
{
.request?= s3cmci_request,//實現host的請求處理(即：命令和數據的發送和接收)
.set_ios?= s3cmci_set_ios,//通過核心層傳遞過來的ios，配置host寄存器(使能時鐘、總線帶寬等)
.get_ro??= s3cmci_get_ro,//通過讀取GPIO端口來判斷卡是否寫有保護
.get_cd??= s3cmci_card_present,//通過讀取GPIO端口來判斷卡是否存在
};mmc_host_ops結構體定義了對host主機進行操作的各種方法，其定義在Core核心層的host.h中，也就是Core核心層對Host主機層提供的接口函數。這里各種方法的函數原型如下：
void??(*request)(struct mmc_host *host, struct mmc_request *req);
void??(*set_ios)(struct mmc_host *host, struct mmc_ios *ios);
int???(*get_ro)(struct mmc_host *host);
int???(*get_cd)(struct mmc_host *host);
從各函數原型上看，他們都將mmc_host結構體作為參數，所以我在剛開始的時候就說過mmc_host結構體是MMC/SD卡驅動中比較重要的數據結構。 可以這樣說，他是Core層與Host層進行數據交換的載體。那么，這些接口函數何時會被調用呢？答案可以在Core層的core.c和sd.c中找到，我們可以看到如下部分代碼：
static void mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
{
......
host->ops->request(host, mrq);//導致s3cmci_request被調用
}
static inline void mmc_set_ios(struct mmc_host *host)
{
......
host->ops->set_ios(host, ios);//導致s3cmci_set_ios被調用
}
void mmc_rescan(struct work_struct *work)
{
......//導致s3cmci_card_present被調用
if (host->ops->get_cd && host->ops->get_cd(host) == 0)
goto out;
......
}
static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
struct mmc_card *oldcard)
{
......
/* Check if read-only switch is active.*/
if (!oldcard)
{?? //導致s3cmci_get_ro被調用
if (!host->ops->get_ro || host->ops->get_ro(host) < 0)
{
printk(KERN_WARNING "%s: host does not "
"support reading read-only "
"switch. assuming write-enable.\n",
mmc_hostname(host));
}
else
{
if (host->ops->get_ro(host) > 0)
mmc_card_set_readonly(card);
}
}
......
}
好了，我們開始分析每個接口函數的具體實現吧，從簡單的開始吧。 判斷卡是否存在，如下代碼：static int s3cmci_card_present(struct mmc_host *mmc)
{//從mmc_host的對象中獲取出s3cmci_host結構體的數據，在s3cmci_probe函數中進行關聯的
struct s3cmci_host *host = mmc_priv(mmc);
struct s3c24xx_mci_pdata *pdata = host->pdata;
int ret;//判斷有無設置卡檢測引腳端口，引腳在s3cmci_probe函數中已設置
if (pdata->gpio_detect == 0)
return -ENOSYS;//從設置的卡檢測引腳中讀出當前的電平值，來判斷卡是插入存在的還是被拔出不存在的
ret = s3c2410_gpio_getpin(pdata->gpio_detect) ? 0 : 1;
return ret ^ pdata->detect_invert;
}
獲取卡是否寫有保護，其實實現跟卡檢查類似，代碼如下：static int s3cmci_get_ro(struct mmc_host *mmc)
{
//從mmc_host的對象中獲取出s3cmci_host結構體的數據，在s3cmci_probe函數中進行關聯的
struct s3cmci_host *host = mmc_priv(mmc);
struct s3c24xx_mci_pdata *pdata = host->pdata;
int ret;
//判斷有無設置卡寫保護引腳端口，引腳在s3cmci_probe函數中已設置
if (pdata->gpio_wprotect == 0)
return 0;
//從設置的卡寫保護引腳中讀出當前的電平值，來判斷卡是否寫有保護
ret = s3c2410_gpio_getpin(pdata->gpio_wprotect);
if (pdata->wprotect_invert)
ret = !ret;
return ret;
}
配置host寄存器的時鐘和總線寬度，代碼如下：
static void s3cmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
{
//從mmc_host的對象中獲取出s3cmci_host結構體的數據，在s3cmci_probe函數中進行關聯的
struct s3cmci_host *host = mmc_priv(mmc);
u32 mci_con;
//讀取SDI控制寄存器的值
mci_con = readl(host->base + S3C2410_SDICON);
//ios結構體參數從Core層傳遞過來，根據不同的電源狀態來配置SDI各寄存器
switch (ios->power_mode)
{
case MMC_POWER_ON:
case MMC_POWER_UP:
//根據開發板引腳連接情況配置SDI控制器的各信號線，包括：時鐘線、命令線和四條數據線
s3c2410_gpio_cfgpin(S3C2410_GPE5, S3C2410_GPE5_SDCLK);
s3c2410_gpio_cfgpin(S3C2410_GPE6, S3C2410_GPE6_SDCMD);
s3c2410_gpio_cfgpin(S3C2410_GPE7, S3C2410_GPE7_SDDAT0);
s3c2410_gpio_cfgpin(S3C2410_GPE8, S3C2410_GPE8_SDDAT1);
s3c2410_gpio_cfgpin(S3C2410_GPE9, S3C2410_GPE9_SDDAT2);
s3c2410_gpio_cfgpin(S3C2410_GPE10, S3C2410_GPE10_SDDAT3);
if (host->pdata->set_power)
host->pdata->set_power(ios->power_mode, ios->vdd);
break;
case MMC_POWER_OFF:
default:
//如果電源狀態為關閉或者默認情況下，關閉SDI的時鐘信號
s3c2410_gpio_setpin(S3C2410_GPE5, 0);
s3c2410_gpio_cfgpin(S3C2410_GPE5, S3C2410_GPE5_OUTP);
//根據數據手冊的SDICON寄存器位的介紹，此處是將整個sdmmc時鐘復位
mci_con |= S3C2440_SDICON_SDRESET;
if (host->pdata->set_power)
host->pdata->set_power(ios->power_mode, ios->vdd);
break;
}
//設置SDI波特率預定標器寄存器以確定時鐘，看其定義部分
s3cmci_set_clk(host, ios);
//根據SDI當前的時鐘頻率來設置寄存器的使能時鐘位
if (ios->clock)
mci_con |= S3C2410_SDICON_CLOCKTYPE;
else
mci_con &= ~S3C2410_SDICON_CLOCKTYPE;
//將計算好的值寫回SDI控制寄存器
writel(mci_con, host->base + S3C2410_SDICON);
//下面只是一些調試信息，可以不要
if ((ios->power_mode == MMC_POWER_ON) || (ios->power_mode == MMC_POWER_UP))
{
dbg(host, dbg_conf, "running at %lukHz (requested: %ukHz).\n",
host->real_rate/1000, ios->clock/1000);
}
else
{
dbg(host, dbg_conf, "powered down.\n");
}
//設置總線寬度
host->bus_width = ios->bus_width;
}
//設置SDI波特率預定標器寄存器以確定時鐘
static void s3cmci_set_clk(struct s3cmci_host *host, struct mmc_ios *ios)
{
u32 mci_psc;
//根據SDI工作時鐘頻率范圍來確定時鐘預分頻器值
for (mci_psc = 0; mci_psc < 255; mci_psc++)
{
host->real_rate = host->clk_rate / (host->clk_div*(mci_psc+1));
if (host->real_rate <= ios->clock)
break;
}
//根據數據手冊描述，SDI波特率預定標器寄存器只有8個位，所以最大值為255
if (mci_psc > 255)
mci_psc = 255;
host->prescaler = mci_psc;//確定的預分頻器值
//將預分頻器值寫于SDI波特率預定標器寄存器中
writel(host->prescaler, host->base + S3C2410_SDIPRE);
if (ios->clock == 0)
host->real_rate = 0;
}
MMC/SD請求處理，這是Host驅動中比較重要的一部分。請求處理的整個流程請參考(一)中的流程圖，他很好的描述了一個請求是怎樣從Host層發出，通過Core層提交到Card層被塊設備處理的。下面看代碼：
static void s3cmci_request(struct mmc_host *mmc, struct mmc_request *mrq)
{
//從mmc_host的對象中獲取出s3cmci_host結構體的數據，在s3cmci_probe函數中進行關聯的
struct s3cmci_host *host = mmc_priv(mmc);
//s3cmci_host結構體定義的status主要是記錄請求過程所處的階段及狀態，方便調試時使用
host->status = "mmc request";
//請求處理主要包括MMC/SD命令和數據處理，所以定義cmd_is_stop來區分是哪種請求
host->cmd_is_stop = 0;
//將Core層的mmc_request對象保存到Host層中以備使用
host->mrq = mrq;
//在開始發出一個請求前先要檢測一下卡是否還存在，否則提交到了塊設備層而沒有請求處理的對象發生錯誤
if (s3cmci_card_present(mmc) == 0)
{
dbg(host, dbg_err, "%s: no medium present\n", __func__);
host->mrq->cmd->error = -ENOMEDIUM;
mmc_request_done(mmc, mrq);//如果卡不存在則馬上結束這次請求
}
else
{
s3cmci_send_request(mmc);//如果卡還存在則發出請求
}
}
//發送請求
static void s3cmci_send_request(struct mmc_host *mmc)
{
//從mmc_host的對象中獲取出s3cmci_host結構體的數據，在s3cmci_probe函數中進行關聯的
struct s3cmci_host *host = mmc_priv(mmc);
//取出在s3cmci_request函數中保存的mmc_request對象以使用
struct mmc_request *mrq = host->mrq;
//在s3cmci_request函數中設置的cmd_is_stop初始值為0，表示當前是命令請求
struct mmc_command *cmd = host->cmd_is_stop ? mrq->stop : mrq->cmd;
//清空SDI命令狀態寄存器、數據狀態寄存器和FIFO狀態寄存器
writel(0xFFFFFFFF, host->base + S3C2410_SDICMDSTAT);
writel(0xFFFFFFFF, host->base + S3C2410_SDIDSTA);
writel(0xFFFFFFFF, host->base + S3C2410_SDIFSTA);
//如果當前這次的請求是數據請求
if (cmd->data)
{
//進入數據請求處理設置，主要是數據控制寄存器的配置
int res = s3cmci_setup_data(host, cmd->data);
if (res)
{
//如果在數據請求設置中出現異常，則馬上結束這次請求
dbg(host, dbg_err, "setup data error %d\n", res);
cmd->error = res;
cmd->data->error = res;
mmc_request_done(mmc, mrq);
return;
}
//判斷數據處理的方式是DAM還是FIFO，在s3cmci_probe函數中初始的是0，所以沒有使用DMA的方式
if (host->dodma)
res = s3cmci_prepare_dma(host, cmd->data);
else
res = s3cmci_prepare_pio(host, cmd->data);
if (res)
{
//如果請求處理數據失敗則也要馬上結束這次請求
dbg(host, dbg_err, "data prepare error %d\n", res);
cmd->error = res;
cmd->data->error = res;
mmc_request_done(mmc, mrq);
return;
}
}
//否則這次請求是命令請求
s3cmci_send_command(host, cmd);
//還記得在s3cmci_probe中SDI未準備好是屏蔽了SD中斷，所以這里就使能中斷
enable_irq(host->irq);
}
//數據請求處理設置，主要是數據控制寄存器的配置
static int s3cmci_setup_data(struct s3cmci_host *host, struct mmc_data *data)
{
u32 dcon, imsk, stoptries = 3;
/*如果不是數據處理請求則清零SDI數據控制寄存器*/
if (!data)
{
writel(0, host->base + S3C2410_SDIDCON);
return 0;
}
//根據SDI模塊大小寄存器描述，如果在多模塊下BlkSize必須分配字大小即：BlkSize[1:0]=00
//所以這里與上3(即：二進制的11)來判斷的是單模塊
if ((data->blksz & 3) != 0)
{
//如果在單模塊處理的情況下，模塊數大于1了，就出現異常
if (data->blocks > 1)
{
pr_warning("%s: can't do non-word sized block transfers (blksz %d)\n", __func__, data->blksz);
return -EINVAL;
}
}
//循環判斷數據是否正在傳輸中(發送或者接收)
while (readl(host->base + S3C2410_SDIDSTA) & (S3C2410_SDIDSTA_TXDATAON | S3C2410_SDIDSTA_RXDATAON))
{
dbg(host, dbg_err, "mci_setup_data() transfer stillin progress.\n");
//如果正在傳輸中則立刻停止傳輸
writel(S3C2410_SDIDCON_STOP, host->base + S3C2410_SDIDCON);
//接著立刻復位整個MMC/SD時鐘
s3cmci_reset(host);
//這里應該是起到一個延遲的效果。因為硬件停止傳輸到復位MMC/SD需要一點時間，而循環判斷非常快。
//如果在這個時間內硬件還處在數據傳輸中而沒有復位好，則異常
if ((stoptries--) == 0)
{
return -EINVAL;
}
}
dcon = data->blocks & S3C2410_SDIDCON_BLKNUM_MASK;
//如果使用DMA傳輸，則使能SDI數據控制寄存器的DMA
if (host->dodma)
dcon |= S3C2410_SDIDCON_DMAEN;
//如果設置總線寬度為4線，則使能SDI數據控制寄存器的總線寬度模式為寬總線模式(即：4線模式)
if (host->bus_width == MMC_BUS_WIDTH_4)
dcon |= S3C2410_SDIDCON_WIDEBUS;
//配置SDI數據控制寄存器的數據傳輸模式為模塊數據傳輸
if (!(data->flags & MMC_DATA_STREAM))
dcon |= S3C2410_SDIDCON_BLOCKMODE;
if (data->flags & MMC_DATA_WRITE)
{
//數據發送命令響應收到后開始數據傳輸
dcon |= S3C2410_SDIDCON_TXAFTERRESP;
//數據發送模式
dcon |= S3C2410_SDIDCON_XFER_TXSTART;
}
if (data->flags & MMC_DATA_READ)
{
//數據發送命令響應收到后開始數據接收
dcon |= S3C2410_SDIDCON_RXAFTERCMD;
//數據接收模式
dcon |= S3C2410_SDIDCON_XFER_RXSTART;
}
//FIFO傳輸的大小使用字傳輸類型
dcon |= S3C2440_SDIDCON_DS_WORD;
//數據傳輸開始
dcon |= S3C2440_SDIDCON_DATSTART;
//將以上配置的值寫入SDI數據控制寄存器生效
writel(dcon, host->base + S3C2410_SDIDCON);
//配置模塊大小寄存器的塊大小值
writel(data->blksz, host->base + S3C2410_SDIBSIZE);
//出現FIFO失敗SDI中斷使能；數據接收CRC錯誤SDI中斷使能；數據接收超時SDI中斷使能；數據計時器為0SDI中斷使能
imsk = S3C2410_SDIIMSK_FIFOFAIL | S3C2410_SDIIMSK_DATACRC | S3C2410_SDIIMSK_DATATIMEOUT | S3C2410_SDIIMSK_DATAFINISH;
enable_imask(host, imsk);//使能中斷
//將配置的值寫入SDI中斷屏蔽寄存器，使之生效
writel(0x007FFFFF, host->base + S3C2410_SDITIMER);
return 0;
}
//復位整個MMC/SD時鐘
static void s3cmci_reset(struct s3cmci_host *host){??? u32 con = readl(host->base + S3C2410_SDICON);
con |= S3C2440_SDICON_SDRESET;
writel(con, host->base + S3C2410_SDICON);}
//使能中斷
static inline u32 enable_imask(struct s3cmci_host *host, u32 imask)
{
u32 newmask;
newmask = readl(host->base + host->sdiimsk);
newmask |= imask;
writel(newmask, host->base + host->sdiimsk);
return newmask;
}
//屏蔽中斷
static inline u32 disable_imask(struct s3cmci_host *host, u32 imask)
{
u32 newmask;
newmask = readl(host->base + host->sdiimsk);
newmask &= ~imask;
writel(newmask, host->base + host->sdiimsk);
return newmask;
}
//清空中斷屏蔽寄存器
static inline void clear_imask(struct s3cmci_host *host)
{
writel(0, host->base + host->sdiimsk);
}
//使用DMA傳輸數據方式，注意：這里就不講如何使用DMA的具體細節了，以后再講。
//對于驅動中相關DMA操作的方法都在plat-s3c24xx/dma.c中定義了。
static int s3cmci_prepare_dma(struct s3cmci_host *host, struct mmc_data *data)
{
int dma_len, i;
//判斷DMA傳輸的方向是讀還是寫
int rw = (data->flags & MMC_DATA_WRITE) ? 1 : 0;
//根據傳輸的方向來配置DMA相關寄存器
s3cmci_dma_setup(host, rw ? S3C2410_DMASRC_MEM : S3C2410_DMASRC_HW);
//s3c2410_dma_ctrl函數將根據標志flag來控制DMA傳輸的開始、停止等操作
s3c2410_dma_ctrl(host->dma, S3C2410_DMAOP_FLUSH);
//合并data->sg上相鄰的段，映射一個發散/匯聚DMA操作
//返回值是傳送的DMA緩沖區數，可能會小于sg_len，也就是說sg_len與dma_len可能是不同。
dma_len = dma_map_sg(mmc_dev(host->mmc), data->sg, data->sg_len,
(rw) ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
if (dma_len == 0)
return -ENOMEM;
host->dma_complete = 0;//初始DMA操作的狀態
host->dmatogo = dma_len;//保存合并后的段數
for (i = 0; i < dma_len; i++)
{
int res;
//分配一個數據段管理結構體，并將各數據段穿成單向鏈表，以及加載一個數據段到DMA通道
//sg_dma_address返回的是總線(DMA)的地址，sg_dma_len返回的是緩存區的長度
res = s3c2410_dma_enqueue(host->dma, (void *) host, sg_dma_address(&data->sg[i]), sg_dma_len(&data->sg[i]));
if (res)
{
s3c2410_dma_ctrl(host->dma, S3C2410_DMAOP_FLUSH);
return -EBUSY;
}
}
//開始DMA數據傳輸，數據傳輸會在接收到請求后真正開始
s3c2410_dma_ctrl(host->dma, S3C2410_DMAOP_START);
return 0;
}
//根據傳輸的方向來配置DMA相關寄存器，詳細描述請查看數據手冊DMA章節
static void s3cmci_dma_setup(struct s3cmci_host *host, enum s3c2410_dmasrc source)
{
static enum s3c2410_dmasrc last_source = -1;
static int setup_ok;
if (last_source == source)
return;
last_source = source;
//配置DMA源或者目標硬件類型和地址，這里DMA使用的是物理地址，不是虛擬地址。
s3c2410_dma_devconfig(host->dma, source, 3, host->mem->start + host->sdidata);
//這個判斷的作用是讓下面的代碼只執行一次，以后不在被執行
if (!setup_ok)
{
//配置DMA控制寄存器中的傳輸數據大小單位
s3c2410_dma_config(host->dma, 4, 0);
//設置DMA回調函數為s3cmci_dma_done_callback，當一段數據傳輸完后該函數被調用
s3c2410_dma_set_buffdone_fn(host->dma, s3cmci_dma_done_callback);
s3c2410_dma_setflags(host->dma, S3C2410_DMAF_AUTOSTART);
setup_ok = 1;
}
}
//DMA回調函數, 當一段數據傳輸完后該函數被調用
static void s3cmci_dma_done_callback(struct s3c2410_dma_chan *dma_ch, void *buf_id, int size,
enum s3c2410_dma_buffresult result)
{
struct s3cmci_host *host = buf_id;//這個s3cmci_host類型的參數是在s3c2410_dma_enqueue的時候傳遞進來的
unsigned long iflags;
u32 mci_csta, mci_dsta, mci_fsta, mci_dcnt;
mci_csta = readl(host->base + S3C2410_SDICMDSTAT);//命令狀態寄存器的值
mci_dsta = readl(host->base + S3C2410_SDIDSTA);//數據狀態寄存器的值
mci_fsta = readl(host->base + S3C2410_SDIFSTA);//FIFO狀態寄存器的值
mci_dcnt = readl(host->base + S3C2410_SDIDCNT);//數據保留計數器寄存器的值
spin_lock_irqsave(&host->complete_lock, iflags);
//如果DMA返回錯誤，則調到錯誤處理處進行錯誤處理
if (result != S3C2410_RES_OK)
{
goto fail_request;
}
host->dmatogo--;//合并data->sg上相鄰后的段數遞減
//如果合并的段數不為0，即所有的段還沒有處理完
if (host->dmatogo)
{
goto out;
}
//否則，標識這次DMA操作真正完成了
host->complete_what = COMPLETION_FINALIZE;
out:
//切換到中斷底半部執行
tasklet_schedule(&host->pio_tasklet);
spin_unlock_irqrestore(&host->complete_lock, iflags);
return;
fail_request:
host->mrq->data->error = -EINVAL;
host->complete_what = COMPLETION_FINALIZE;
//如果DMA請求失敗，則屏蔽SDI中斷
writel(0, host->base + host->sdiimsk);
goto out;
}
//使用FIFO傳輸數據方式。具體操作就是調用do_pio_write往FIFO中填充數據，當64字節的FIFO少于33字節時就會產生中斷；
//或者是從SD讀數據，則先使能中斷，當FIFO多于31字節時時，則會調用中斷服務程序，中斷服務程序中將會調用do_pio_read讀出FIFO的數據。
static int s3cmci_prepare_pio(struct s3cmci_host *host, struct mmc_data *data)
{
//跟DMA類似，這里同樣要判斷FIFO傳輸的方向是讀還是寫
int rw = (data->flags & MMC_DATA_WRITE) ? 1 : 0;
host->pio_sgptr = 0;
host->pio_bytes = 0;
host->pio_count = 0;
host->pio_active = rw ? XFER_WRITE : XFER_READ;//記錄FIFO操作狀態共三種:讀、寫和無操作，定義在驅動頭文件中
if (rw) //寫
{
//FIFO寫操作
do_pio_write(host);
//使能中斷。根據數據手冊SDI中斷屏蔽寄存器的描述，當發送FIFO半填滿就產生SDI中斷
enable_imask(host, S3C2410_SDIIMSK_TXFIFOHALF);
}
else //讀
{
//使能中斷。根據數據手冊SDI中斷屏蔽寄存器的描述，當接收FIFO半填滿或者接收FIFO有最后數據就產生SDI中斷
enable_imask(host, S3C2410_SDIIMSK_RXFIFOHALF | S3C2410_SDIIMSK_RXFIFOLAST);
}
return 0;
}
//FIFO寫操作(即填充FIFO)
static void do_pio_write(struct s3cmci_host *host)
{
void __iomem *to_ptr;
int res;
u32 fifo;
u32 *ptr;
//SDI數據寄存器的虛擬地址
to_ptr = host->base + host->sdidata;
//檢查FIFO中當前的剩余空間
while ((fifo = fifo_free(host)) > 3)
{
if (!host->pio_bytes)
{
//從分散聚集列表中獲取要寫的數據緩存，這里主要是獲取緩存的長度和開始地址
res = get_data_buffer(host, &host->pio_bytes, &host->pio_ptr);
if (res)
{
host->pio_active = XFER_NONE;
return;
}
}
//如果FIFO剩余空間比這一次要寫入的數據段長度要大
if (fifo >= host->pio_bytes)
fifo = host->pio_bytes;
else
fifo -= fifo & 3;
host->pio_bytes -= fifo;//更新還剩下沒寫完的緩存長度
host->pio_count += fifo;
fifo = (fifo + 3) >> 2;//將字節數轉化為字數
ptr = host->pio_ptr;
while (fifo--)//寫入FIFO
writel(*ptr++, to_ptr);
host->pio_ptr = ptr;//更新當前地址指針的位置
}
//FIFO半填滿時發生MMC/SD中斷
enable_imask(host, S3C2410_SDIIMSK_TXFIFOHALF);
}
//FIFO讀操作
static void do_pio_read(struct s3cmci_host *host)
{
int res;
u32 fifo;
u32 *ptr;
u32 fifo_words;
void __iomem *from_ptr;
//設置SDI波特率預定標器寄存器的值
writel(host->prescaler, host->base + S3C2410_SDIPRE);
//SDI數據寄存器的虛擬地址
from_ptr = host->base + host->sdidata;
//檢測FIFO中當前的數據個數
while ((fifo = fifo_count(host)))
{
if (!host->pio_bytes)
{
//從分散聚集列表中獲取要讀數據緩存，這里主要是獲取緩存的長度和開始地址的指針位置
res = get_data_buffer(host, &host->pio_bytes, &host->pio_ptr);
if (res)
{
host->pio_active = XFER_NONE;
host->complete_what = COMPLETION_FINALIZE;
return;
}
}
//如果FIFO中當前的數據個數比這一次要讀出的數據段長度要大
if (fifo >= host->pio_bytes)
fifo = host->pio_bytes;
else
fifo -= fifo & 3;
host->pio_bytes -= fifo;//更新還剩下沒讀完的緩存長度
host->pio_count += fifo;
fifo_words = fifo >> 2;//將字節數轉化為字數
ptr = host->pio_ptr;
while (fifo_words--)//從FIFO中讀出數據
*ptr++ = readl(from_ptr);
host->pio_ptr = ptr;//更新當前地址指針的位置
//如果fifo中的數據非字對齊則讀取非對齊部分
if (fifo & 3)
{
u32 n = fifo & 3;
u32 data = readl(from_ptr);
u8 *p = (u8 *)host->pio_ptr;
while (n--)
{
*p++ = data;
data >>= 8;
}
}
}
//請求的數據已讀完
if (!host->pio_bytes)
{
res = get_data_buffer(host, &host->pio_bytes, &host->pio_ptr);
if (res)
{
host->pio_active = XFER_NONE;
host->complete_what = COMPLETION_FINALIZE;
return;
}
}
//接收FIFO半滿或者接收FIFO有最后數據時發生MMC/SD中斷
enable_imask(host, S3C2410_SDIIMSK_RXFIFOHALF | S3C2410_SDIIMSK_RXFIFOLAST);
}
//檢測FIFO中當前的數據個數
static inline u32 fifo_count(struct s3cmci_host *host)
{
//讀取SDI FIFO狀態寄存器
u32 fifostat = readl(host->base + S3C2410_SDIFSTA);
//FIFO中的數據個數是保存在寄存器的0-6位，所以與上S3C2410_SDIFSTA_COUNTMASK得出數據個數值
//S3C2410_SDIFSTA_COUNTMASK定義在regs-sdi.h中為：0x7f，即：1111111
fifostat &= S3C2410_SDIFSTA_COUNTMASK;
return fifostat;
}
//檢查FIFO中當前的剩余空間
static inline u32 fifo_free(struct s3cmci_host *host)
{
//這里跟檢測FIFO中當前的數據個數是一樣的
u32 fifostat = readl(host->base + S3C2410_SDIFSTA);
fifostat &= S3C2410_SDIFSTA_COUNTMASK;
return 63 - fifostat;//用FIFO的總容量-FIFO中當前的數據個數=剩余空間
}
//MMC/SD核心為mrq->data成員分配了一個struct scatterlist的表，用來支持分散聚集，
//使用這種方法，使物理上不一致的內存頁，被組裝成一個連續的數組，避免了分配大的緩沖區的問題
static inline int get_data_buffer(struct s3cmci_host *host, u32 *bytes, u32 **pointer)
{
struct scatterlist *sg;
//FIFO當前的操作狀態驗證
if (host->pio_active == XFER_NONE)
return -EINVAL;
//MMC/SD請求及數據有效性驗證
if ((!host->mrq) || (!host->mrq->data))
return -EINVAL;
//數據緩存的入口有沒有超過分散列表的范圍
if (host->pio_sgptr >= host->mrq->data->sg_len)
return -EBUSY;
//從分散聚集列表中獲取一段數據緩存
sg = &host->mrq->data->sg[host->pio_sgptr];
*bytes = sg->length;//該段數據緩存的長度
*pointer = sg_virt(sg);//該段數據緩存的入口地址(為虛擬地址)，相當于一個游標的意思
host->pio_sgptr++;//準備下一段數據緩存的入口
return 0;
}
//以上三段代碼是對發送數據請求處理的，下面是發送命令請求
static void s3cmci_send_command(struct s3cmci_host *host, struct mmc_command *cmd)
{
u32 ccon, imsk;
//出現CRC狀態錯誤|命令響應超時|接收命令響應|命令發出|響應CRC校驗失敗時，將產生SDI中斷
imsk = S3C2410_SDIIMSK_CRCSTATUS | S3C2410_SDIIMSK_CMDTIMEOUT |
S3C2410_SDIIMSK_RESPONSEND | S3C2410_SDIIMSK_CMDSENT |
S3C2410_SDIIMSK_RESPONSECRC;
//將值寫入SDI中斷屏蔽寄存器中
enable_imask(host, imsk);
//判斷請求所處在何種狀態
if (cmd->data)
//如果有數據傳輸，則設當前任務為完成數據傳輸且接收命令響應狀態
host->complete_what = COMPLETION_XFERFINISH_RSPFIN;
else if (cmd->flags & MMC_RSP_PRESENT)
host->complete_what = COMPLETION_RSPFIN;
else
//命令發送狀態
host->complete_what = COMPLETION_CMDSENT;
//設置命令參數寄存器
writel(cmd->arg, host->base + S3C2410_SDICMDARG);
ccon = cmd->opcode & S3C2410_SDICMDCON_INDEX;
ccon |= S3C2410_SDICMDCON_SENDERHOST | S3C2410_SDICMDCON_CMDSTART;//命令操作開始
if (cmd->flags & MMC_RSP_PRESENT)
ccon |= S3C2410_SDICMDCON_WAITRSP;//主設備等待響應
if (cmd->flags & MMC_RSP_136)
ccon |= S3C2410_SDICMDCON_LONGRSP;//主設備接收一個136位長的響應
//設置命令控制寄存器，開始命令的傳輸
writel(ccon, host->base + S3C2410_SDICMDCON);
}
7. s3cmci_irq_cd SDI的卡檢測中斷服務功能
//當MMC/SD卡插入卡槽時引發的中斷
static irqreturn_t s3cmci_irq_cd(int irq, void *dev_id)
{
//這個dev_id參數是申請中斷時傳遞過來的
struct s3cmci_host *host = (struct s3cmci_host *)dev_id;
//調用核心層中的方法將將struct delayed_work detect加入共享工作隊列，
//其處理函數為核心層中的mmc_rescan方法，用于卡的識別并初始化。
mmc_detect_change(host->mmc, msecs_to_jiffies(500));
return IRQ_HANDLED;
}
8. s3cmci_irq SDI的中斷服務功能。我們從第6小節中對MMC/SD各種請求處理的代碼中和(一)中“命令、數據發送流程圖”中可以看出，在這個中斷服務中將要處理很多請求相關的事情。但對于中斷服務來說，這樣會嚴重影響系統的性能，所以這正是為什么要在驅動中實現中斷的底半部機制。下面看代碼進行分析。
//MMC/SD卡中斷服務程序
static irqreturn_t s3cmci_irq(int irq, void *dev_id)
{
//dev_id參數是申請中斷的時候傳遞過來的s3cmci_host結構體，void類型的指針可以存放任何的數據類型
struct s3cmci_host *host = dev_id;
struct mmc_command *cmd;
u32 mci_csta, mci_dsta, mci_fsta, mci_dcnt, mci_imsk;
u32 mci_cclear, mci_dclear;
unsigned long iflags;
//關中斷并保持狀態字
spin_lock_irqsave(&host->complete_lock, iflags);
//分別讀命令狀態、數據狀態、數據保留計數器、FIFO狀態、中斷屏蔽寄存器的值
mci_csta = readl(host->base + S3C2410_SDICMDSTAT);
mci_dsta = readl(host->base + S3C2410_SDIDSTA);
mci_dcnt = readl(host->base + S3C2410_SDIDCNT);
mci_fsta = readl(host->base + S3C2410_SDIFSTA);
mci_imsk = readl(host->base + host->sdiimsk);
mci_cclear = 0;
mci_dclear = 0;
//如果當前沒有請求狀態或者請求已經完成了，則恢復中斷什么都不做
if ((host->complete_what == COMPLETION_NONE) || (host->complete_what == COMPLETION_FINALIZE))
{
host->status = "nothing to complete";
clear_imask(host);
goto irq_out;
}
//如果核心層無MMC/SD請求，則恢復中斷什么都不做
if (!host->mrq)
{
host->status = "no active mrq";
clear_imask(host);
goto irq_out;
}
//獲取當前發送命令有無完成
cmd = host->cmd_is_stop ? host->mrq->stop : host->mrq->cmd;
//如果發送命令完成了，則恢復中斷什么都不做
if (!cmd)
{
host->status = "no active cmd";
clear_imask(host);
goto irq_out;
}
//判斷在數據傳輸狀態時使用的傳輸方式
if (!host->dodma)
{
//不是DMA傳輸。如果是FIFO寫，則切換到底半部去進行FIFO的寫操作
if ((host->pio_active == XFER_WRITE) && (mci_fsta & S3C2410_SDIFSTA_TFDET))
{
disable_imask(host, S3C2410_SDIIMSK_TXFIFOHALF);
tasklet_schedule(&host->pio_tasklet);
host->status = "pio tx";
}
//如果是FIFO讀，則切換到底半部去進行FIFO的讀操作
if ((host->pio_active == XFER_READ) && (mci_fsta & S3C2410_SDIFSTA_RFDET))
{
disable_imask(host, S3C2410_SDIIMSK_RXFIFOHALF | S3C2410_SDIIMSK_RXFIFOLAST);
tasklet_schedule(&host->pio_tasklet);
host->status = "pio rx";
}
}
//命令響應超時
if (mci_csta & S3C2410_SDICMDSTAT_CMDTIMEOUT)
{
dbg(host, dbg_err, "CMDSTAT: error CMDTIMEOUT\n");
cmd->error = -ETIMEDOUT;
host->status = "error: command timeout";
goto fail_transfer;
}
//命令發送結束
if (mci_csta & S3C2410_SDICMDSTAT_CMDSENT)
{
if (host->complete_what == COMPLETION_CMDSENT)
{
host->status = "ok: command sent";
goto close_transfer;
}
mci_cclear |= S3C2410_SDICMDSTAT_CMDSENT;
}
//收到命令響應，CRC校驗失敗
if (mci_csta & S3C2410_SDICMDSTAT_CRCFAIL)
{
if (cmd->flags & MMC_RSP_CRC)
{
if (host->mrq->cmd->flags & MMC_RSP_136)
{
dbg(host, dbg_irq, "fixup: ignore CRC fail with long rsp\n");
} else {/* note, we used to fail the transfer
* here, but it seems that this is just
* the hardware getting it wrong.
*
* cmd->error = -EILSEQ;
* host->status = "error: bad command crc";
* goto fail_transfer;
*/
}
}
mci_cclear |= S3C2410_SDICMDSTAT_CRCFAIL;
}
//收到命令響應，響應結束
if (mci_csta & S3C2410_SDICMDSTAT_RSPFIN)
{
//如果當前任務是完成，接收命令響應
if (host->complete_what == COMPLETION_RSPFIN)
{
host->status = "ok: command response received";
goto close_transfer;//停止傳輸
}
//當前任務是完成數據傳輸和接收命令響應
if (host->complete_what == COMPLETION_XFERFINISH_RSPFIN)
//標記當前任務為完成數據傳輸
host->complete_what = COMPLETION_XFERFINISH;
//清除收到命令響應標志
mci_cclear |= S3C2410_SDICMDSTAT_RSPFIN;
}
if (!cmd->data)
goto clear_status_bits;
//FIFO失敗
if (mci_fsta & S3C2440_SDIFSTA_FIFOFAIL)
{
dbg(host, dbg_err, "FIFO failure\n");
host->mrq->data->error = -EILSEQ;
host->status = "error: 2440 fifo failure";
goto fail_transfer;
}
//接收CRC錯誤
if (mci_dsta & S3C2410_SDIDSTA_RXCRCFAIL)
{
dbg(host, dbg_err, "bad data crc (outgoing)\n");
cmd->data->error = -EILSEQ;
host->status = "error: bad data crc (outgoing)";
goto fail_transfer;
}
//發送數據后，CRC狀態錯誤
if (mci_dsta & S3C2410_SDIDSTA_CRCFAIL)
{
dbg(host, dbg_err, "bad data crc (incoming)\n");
cmd->data->error = -EILSEQ;
host->status = "error: bad data crc (incoming)";
goto fail_transfer;
}
//數據/忙接收超時
if (mci_dsta & S3C2410_SDIDSTA_DATATIMEOUT)
{
dbg(host, dbg_err, "data timeout\n");
cmd->data->error = -ETIMEDOUT;
host->status = "error: data timeout";
goto fail_transfer;
}
//數據計數器為0，和本次請求的全部數據傳輸結束
if (mci_dsta & S3C2410_SDIDSTA_XFERFINISH)
{
//如果當前任務是完成數據傳輸則結束數據傳輸
if (host->complete_what == COMPLETION_XFERFINISH)
{
host->status = "ok: data transfer completed";
goto close_transfer;
}
//如果當前任務是完成數據傳輸和接收命令響應
if (host->complete_what == COMPLETION_XFERFINISH_RSPFIN)
//標記當前任務為完成 接收命令響應
host->complete_what = COMPLETION_RSPFIN;
//清除數據傳輸完標志
mci_dclear |= S3C2410_SDIDSTA_XFERFINISH;
}
//清除狀態字
clear_status_bits:
writel(mci_cclear, host->base + S3C2410_SDICMDSTAT);
writel(mci_dclear, host->base + S3C2410_SDIDSTA);
goto irq_out;
//傳輸失敗
fail_transfer:
host->pio_active = XFER_NONE;
//傳輸結束
close_transfer:
host->complete_what = COMPLETION_FINALIZE;
clear_imask(host);
tasklet_schedule(&host->pio_tasklet);
goto irq_out;
irq_out:
dbg(host, dbg_irq, "csta:0x%08x dsta:0x%08x fsta:0x%08x dcnt:0x%08x status:%s.\n",
mci_csta, mci_dsta, mci_fsta, mci_dcnt, host->status);
//開中斷并恢復狀態字
spin_unlock_irqrestore(&host->complete_lock, iflags);
return IRQ_HANDLED;
}
//MMC/SD卡中斷底半部程序
static void pio_tasklet(unsigned long data)
{
//data參數是在s3cmci_probe中的tasklet_init的時候傳遞過來的
struct s3cmci_host *host = (struct s3cmci_host *) data;
//在執行底半部程序的時候屏蔽中斷
disable_irq(host->irq);
//判斷如果當前存在FIFO的寫狀態，則進行FIFO的寫操作
if (host->pio_active == XFER_WRITE)
do_pio_write(host);
//判斷如果當前存在FIFO的讀狀態，則進行FIFO的讀操作
if (host->pio_active == XFER_READ)
do_pio_read(host);
//判斷如果當前的請求狀態為完成狀態，則準備進行完成請求處理
if (host->complete_what == COMPLETION_FINALIZE)
{
//清空中斷屏蔽寄存器
clear_imask(host);
//FIFO狀態驗證
if (host->pio_active != XFER_NONE)
{
if (host->mrq->data)
host->mrq->data->error = -EINVAL;
}
//完成請求處理
finalize_request(host);
}
else
//當前請求狀態為其他，則使能中斷繼續請求處理
enable_irq(host->irq);
}
//完成請求處理
static void finalize_request(struct s3cmci_host *host)
{
struct mmc_request *mrq = host->mrq;
struct mmc_command *cmd = host->cmd_is_stop ? mrq->stop : mrq->cmd;
int debug_as_failure = 0;
//如果當前請求狀態不為完成狀態，則為錯誤
if (host->complete_what != COMPLETION_FINALIZE)
return;
if (!mrq)
return;
if (cmd->data && (cmd->error == 0) && (cmd->data->error == 0))
{
if (host->dodma && (!host->dma_complete))
{
dbg(host, dbg_dma, "DMA Missing!\n");
return;
}
}
//讀響應寄存器
cmd->resp[0] = readl(host->base + S3C2410_SDIRSP0);
cmd->resp[1] = readl(host->base + S3C2410_SDIRSP1);
cmd->resp[2] = readl(host->base + S3C2410_SDIRSP2);
cmd->resp[3] = readl(host->base + S3C2410_SDIRSP3);
writel(host->prescaler, host->base + S3C2410_SDIPRE);
if (cmd->error)
debug_as_failure = 1;
if (cmd->data && cmd->data->error)
debug_as_failure = 1;
dbg_dumpcmd(host, cmd, debug_as_failure);
//清空命令參數、數據配置、命令配置、中斷屏蔽寄存器
writel(0, host->base + S3C2410_SDICMDARG);
writel(S3C2410_SDIDCON_STOP, host->base + S3C2410_SDIDCON);
writel(0, host->base + S3C2410_SDICMDCON);
writel(0, host->base + host->sdiimsk);
if (cmd->data && cmd->error)
cmd->data->error = cmd->error;
//有數據請求，有傳輸停止命令，數據傳輸命令已發送
if (cmd->data && cmd->data->stop && (!host->cmd_is_stop))
{
host->cmd_is_stop = 1;
s3cmci_send_request(host->mmc);//傳輸停止命令
return;
}
if (!mrq->data)
goto request_done;
//計算已傳輸的數據量
if (mrq->data->error == 0)
{
mrq->data->bytes_xfered = (mrq->data->blocks * mrq->data->blksz);
}
else
{
mrq->data->bytes_xfered = 0;
}
if (mrq->data->error != 0)
{
if (host->dodma)
s3c2410_dma_ctrl(host->dma, S3C2410_DMAOP_FLUSH);
//清除和復位FIFO狀態寄存器
writel(S3C2440_SDIFSTA_FIFORESET | S3C2440_SDIFSTA_FIFOFAIL, host->base + S3C2410_SDIFSTA);
}
//完成請求
request_done:
host->complete_what = COMPLETION_NONE;
host->mrq = NULL;
mmc_request_done(host->mmc, mrq);
}
新人創作打卡挑戰賽發博客就能抽獎！定制產品紅包拿不停！總結
以上是生活随笔為你收集整理的嵌入式linux sd卡读写,嵌入式Linux之我行——S3C2440上MMC/SD卡驱动实例开发讲解(二)...的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： ie8 ajax访问不了https,ie
- 下一篇： linux nohup 后台运行