void mmc_auto_suspend_work(struct work_struct *work)
{
struct mmc_host *host =
container_of(work, struct mmc_host, auto_suspend.work);
/* Try suspending the host */
mmc_auto_suspend(host, 1);
}
void mmc_rescan(struct work_struct *work)
{
struct mmc_host *host =
container_of(work, struct mmc_host, detect.work);
u32 ocr;
int err;
int extend_wakelock = 0;
wake_lock(&mmc_delayed_work_wake_lock);
mmc_bus_get(host);
#ifdef CONFIG_MMC_AUTO_SUSPEND
if (!mmc_auto_suspend(host, 0)) { /* i.e resumed */
mmc_bus_put(host);
goto out;
}
#endif
/* 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);
/* If the card was removed the bus will be marked
* as dead - extend the wakelock so userspace
* can respond */
if (host->bus_dead)
extend_wakelock = 1;
}
mmc_bus_put(host);
mmc_bus_get(host);
/* if there still is a card present, stop here */
if (host->bus_ops != NULL) {
mmc_bus_put(host);
goto out;
}
/* detect a newly inserted card */
/*
* Only we can add a new handler, so it's safe to
* release the lock here.
*/
mmc_bus_put(host);
if (host->ops->get_cd && host->ops->get_cd(host) == 0)
goto out;
mmc_claim_host(host);
mmc_power_up(host);
mmc_go_idle(host);
mmc_send_if_cond(host, host->ocr_avail);
/*
* 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);
extend_wakelock = 1;
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);
extend_wakelock = 1;
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);
extend_wakelock = 1;
goto out;
}
mmc_release_host(host);
mmc_power_off(host);
out:
if (extend_wakelock)
wake_lock_timeout(&mmc_delayed_work_wake_lock, HZ / 2);
else
wake_unlock(&mmc_delayed_work_wake_lock);
if (host->caps & MMC_CAP_NEEDS_POLL)
mmc_schedule_delayed_work(&host->detect, HZ);
}
static int mmc_queue_thread(void *d)
{
struct mmc_queue *mq = d;
struct request_queue *q = mq->queue;
struct request *req;
//ruanmeisi_20100603
int issue_ret = 0;
#ifdef CONFIG_MMC_PERF_PROFILING
ktime_t start, diff;
struct mmc_host *host = mq->card->host;
unsigned long bytes_xfer;
#endif
current->flags |= PF_MEMALLOC;
down(&mq->thread_sem);
do {
req = NULL;
//ruanmeisi_20100603
if (kthread_should_stop()) {
remove_all_req(mq);
break;
}
//end
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);
#ifdef CONFIG_MMC_AUTO_SUSPEND
mmc_auto_suspend(mq->card->host, 0);
#endif
#ifdef CONFIG_MMC_BLOCK_PARANOID_RESUME
if (mq->check_status) {
struct mmc_command cmd;
int retries = 3;
do {
int err;
cmd.opcode = MMC_SEND_STATUS;
cmd.arg = mq->card->rca << 16;
cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
mmc_claim_host(mq->card->host);
err = mmc_wait_for_cmd(mq->card->host, &cmd, 5);
mmc_release_host(mq->card->host);
if (err) {
printk(KERN_ERR "%s: failed to get status (%d)\n",
__func__, err);
msleep(5);
retries--;
continue;
}
printk(KERN_DEBUG "%s: status 0x%.8x\n", __func__, cmd.resp[0]);
} while (retries &&
(!(cmd.resp[0] & R1_READY_FOR_DATA) ||
(R1_CURRENT_STATE(cmd.resp[0]) == 7)));
mq->check_status = 0;
}
#endif
//ruanmeisi_20100529
#ifdef CONFIG_MMC_PERF_PROFILING
bytes_xfer = blk_rq_bytes(req);
if (rq_data_dir(req) == READ) {
start = ktime_get();
issue_ret = mq->issue_fn(mq, req);
diff = ktime_sub(ktime_get(), start);
host->perf.rbytes_mmcq += bytes_xfer;
host->perf.rtime_mmcq =
ktime_add(host->perf.rtime_mmcq, diff);
} else {
start = ktime_get();
issue_ret = mq->issue_fn(mq, req);
diff = ktime_sub(ktime_get(), start);
host->perf.wbytes_mmcq += bytes_xfer;
host->perf.wtime_mmcq =
ktime_add(host->perf.wtime_mmcq, diff);
}
#else
issue_ret = mq->issue_fn(mq, req);
#endif
//ruanmeisi
if (0 == issue_ret) {
int err;
mmc_claim_host(mq->card->host);
err = mmc_send_status(mq->card, NULL);
mmc_release_host(mq->card->host);
if (err) {
printk(KERN_ERR "rms:%s: failed to get status (%d) maybe the card is removed\n",
__func__, err);
//sdcard is removed?
mmc_detect_change(mq->card->host, 0);
msleep(500);
//set_current_state(TASK_INTERRUPTIBLE);
//schedule_timeout(HZ / 2);
continue;
}
}
} while (1);
up(&mq->thread_sem);
return 0;
}
static int mmc_queue_thread(void *d)
{
struct mmc_queue *mq = d;
struct request_queue *q = mq->queue;
struct request *req;
current->flags |= PF_MEMALLOC;
down(&mq->thread_sem);
do {
req = NULL; /* Must be set to NULL at each iteration */
spin_lock_irq(q->queue_lock);
set_current_state(TASK_INTERRUPTIBLE);
if (!blk_queue_plugged(q))
req = elv_next_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);
#ifdef CONFIG_MMC_AUTO_SUSPEND
mmc_auto_suspend(mq->card->host, 0);
#endif
#ifdef CONFIG_MMC_BLOCK_PARANOID_RESUME
if (mq->check_status) {
struct mmc_command cmd;
int retries = 3;
do {
int err;
cmd.opcode = MMC_SEND_STATUS;
cmd.arg = mq->card->rca << 16;
cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
mmc_claim_host(mq->card->host);
err = mmc_wait_for_cmd(mq->card->host, &cmd, 5);
mmc_release_host(mq->card->host);
if (err) {
printk(KERN_ERR "%s: failed to get status (%d)\n",
__func__, err);
msleep(5);
retries--;
continue;
}
printk(KERN_DEBUG "%s: status 0x%.8x\n", __func__, cmd.resp[0]);
} while (retries &&
(!(cmd.resp[0] & R1_READY_FOR_DATA) ||
(R1_CURRENT_STATE(cmd.resp[0]) == 7)));
mq->check_status = 0;
}
#endif
mq->issue_fn(mq, req);
} while (1);
up(&mq->thread_sem);
return 0;
}
