ARM嵌入式Linux系统开发技术详解对应资源源代码

/* * linux/drivers/mmc/mmc.c * * Copyright (C) 2003-2004 Russell King, All Rights Reserved. * * SD-Card support: * Copyright (C) 2004 Thomas Kleffel, All Rights Reserved * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. 2005.07.10 ghcstop(godori) from www.aesop-embedded.org porting sdi interface(IRQ mode) to S3C2440A ==> dma mode?: s3c2410mci.c.dma IRQ mode transfer rate: slow than DMA mode ==> Low system load with media player: */ #include <linux/config.h> #include <linux/module.h> #include <linux/init.h> #include <linux/interrupt.h> #include <linux/completion.h> #include <linux/device.h> #include <linux/delay.h> #include <linux/pagemap.h> #include <linux/kernel.h> #include <asm/bitops.h> #include <linux/bitops.h> #include <linux/mmc/card.h> #include <linux/mmc/host.h> #include <linux/mmc/protocol.h> #include "mmc.h" #ifdef CONFIG_MMC_DEBUG #define DBG(x...) printk(KERN_DEBUG x) #else #define DBG(x...) do { } while (0) #endif #define CMD_RETRIES 3 /* * OCR Bit positions to 10s of Vdd mV. */ static const unsigned short mmc_ocr_bit_to_vdd[] = { 150, 155, 160, 165, 170, 180, 190, 200, 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 310, 320, 330, 340, 350, 360 }; static const unsigned int tran_exp[] = { 10000, 100000, 1000000, 10000000, 0, 0, 0, 0 }; static const unsigned char tran_mant[] = { 0, 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80, }; static const unsigned int tacc_exp[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, }; static const unsigned int tacc_mant[] = { 0, 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80, }; /** * mmc_request_done - finish processing an MMC command * @host: MMC host which completed command * @mrq: MMC request which completed * * MMC drivers should call this function when they have completed * their processing of a command. This should be called before the * data part of the command has completed. */ void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq) { struct mmc_command *cmd = mrq->cmd; int err = mrq->cmd->error; DBG("MMC: req done (%02x): %d: %08x %08x %08x %08x\n", cmd->opcode, err, cmd->resp[0], cmd->resp[1], cmd->resp[2], cmd->resp[3]); if (err && cmd->retries) { cmd->retries--; cmd->error = 0; host->ops->request(host, mrq); } else if (mrq->done) { mrq->done(mrq); } } EXPORT_SYMBOL(mmc_request_done); /** * mmc_start_request - start a command on a host * @host: MMC host to start command on * @mrq: MMC request to start * * Queue a command on the specified host. We expect the * caller to be holding the host lock with interrupts disabled. */ void mmc_start_request(struct mmc_host *host, struct mmc_request *mrq) { WARN_ON(host->card_busy == NULL); mrq->cmd->error = 0; mrq->cmd->mrq = mrq; if (mrq->data) { mrq->cmd->data = mrq->data; mrq->data->error = 0; mrq->data->mrq = mrq; if (mrq->stop) { mrq->data->stop = mrq->stop; mrq->stop->error = 0; mrq->stop->mrq = mrq; } } host->ops->request(host, mrq); } EXPORT_SYMBOL(mmc_start_request); static void mmc_wait_done(struct mmc_request *mrq) { complete(mrq->done_data); } int mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq) { DECLARE_COMPLETION(complete); mrq->done_data = &complete; mrq->done = mmc_wait_done; mmc_start_request(host, mrq); wait_for_completion(&complete); return 0; } EXPORT_SYMBOL(mmc_wait_for_req); /** * mmc_wait_for_cmd - start a command and wait for completion * @host: MMC host to start command * @cmd: MMC command to start * @retries: maximum number of retries * * Start a new MMC command for a host, and wait for the command * to complete. Return any error that occurred while the command * was executing. Do not attempt to parse the response. */ int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries) { struct mmc_request mrq; BUG_ON(host->card_busy == NULL); memset(&mrq, 0, sizeof(struct mmc_request)); memset(cmd->resp, 0, sizeof(cmd->resp)); cmd->retries = retries; mrq.cmd = cmd; cmd->data = NULL; mmc_wait_for_req(host, &mrq); return cmd->error; } EXPORT_SYMBOL(mmc_wait_for_cmd); static int mmc_send_app_cmd(struct mmc_host *host, u16 rca) { struct mmc_command cmd; cmd.opcode = MMC_APP_CMD; cmd.arg =((u32)rca)<<16; cmd.flags = MMC_RSP_R1; return mmc_wait_for_cmd(host, &cmd, 0); } int mmc_wait_for_acmd(struct mmc_host *host, u16 rca, struct mmc_command *cmd, int retries) { int err; do { err = mmc_send_app_cmd(host, rca); if(err != MMC_ERR_NONE) continue; err = mmc_wait_for_cmd(host, cmd, 0); if(err == MMC_ERR_NONE) break; } while (retries--); return err; } /** * __mmc_claim_host - exclusively claim a host * @host: mmc host to claim * @card: mmc card to claim host for * * Claim a host for a set of operations. If a valid card * is passed and this wasn't the last card selected, select * the card before returning. * * Note: you should use mmc_card_claim_host or mmc_claim_host. */ int __mmc_claim_host(struct mmc_host *host, struct mmc_card *card) { DECLARE_WAITQUEUE(wait, current); unsigned long flags; int err = 0; add_wait_queue(&host->wq, &wait); spin_lock_irqsave(&host->lock, flags); while (1) { set_current_state(TASK_UNINTERRUPTIBLE); if (host->card_busy == NULL) break; spin_unlock_irqrestore(&host->lock, flags); schedule(); spin_lock_irqsave(&host->lock, flags); } set_current_state(TASK_RUNNING); host->card_busy = card; spin_unlock_irqrestore(&host->lock, flags); remove_wait_queue(&host->wq, &wait); if (card != (void *)-1 && host->card_selected != card) { struct mmc_command cmd; host->card_selected = card; cmd.opcode = MMC_SELECT_CARD; cmd.arg = card->rca << 16; cmd.flags = MMC_RSP_R1; err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES); } return err; } EXPORT_SYMBOL(__mmc_claim_host); /** * mmc_release_host - release a host * @host: mmc host to release * * Release a MMC host, allowing others to claim the host * for their operations. */ void mmc_release_host(struct mmc_host *host) { unsigned long flags; BUG_ON(host->card_busy == NULL); spin_lock_irqsave(&host->lock, flags); host->card_busy = NULL; spin_unlock_irqrestore(&host->lock, flags); wake_up(&host->wq); } EXPORT_SYMBOL(mmc_release_host); /* * Ensure that no card is selected. */ static void mmc_deselect_cards(struct mmc_host *host) { struct mmc_command cmd; if (host->card_selected) { host->card_selected = NULL; cmd.opcode = MMC_SELECT_CARD; cmd.arg = 0; cmd.flags = MMC_RSP_NONE; mmc_wait_for_cmd(host, &cmd, 0); } } static inline void mmc_delay(unsigned int ms) { #if 0 if (ms < HZ / 1000) { yield(); mdelay(ms); } else { msleep_interruptible (ms); } #else yield(); mdelay(ms); #endif } #if 0 /* UNUSED */ /* * Mask off any voltages we don't support and select * the lowest voltage */ static u32 mmc_select_voltage(struct mmc_host *host, u32 ocr) { int bit; ocr &= host->ocr_avail; bit = ffs(ocr); if (bit) { bit -= 1; ocr = 3 << bit; host->ios.vdd = bit; host->ops->set_ios(host, &host->ios); } else { ocr = 0; } return ocr; } #endif #define UNSTUFF_BITS(resp,start,size) \ ({ \ const int __size = size; \ const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \ const int __off = 3 - ((start) / 32); \ const int __shft = (start) & 31; \ u32 __res; \ \ __res = resp[__off] >> __shft; \ if (__size + __shft > 32) \ __res |= resp[__off-1] << ((32 - __shft) % 32); \ __res & __mask; \ }) /* * Given the decoded CSD structure, decode the raw CID to our CID structure. */ static void mmc_decode_cid(struct mmc_card *card) { u32 *resp = card->raw_cid; memset(&card-