core.c revision bd68e0838fe85794b06892054772fa013a8d1986
11da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 2aaac1b470bd0dccb30912356617069dc6199cc80Pierre Ossman * linux/drivers/mmc/core/core.c 31da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 41da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Copyright (C) 2003-2004 Russell King, All Rights Reserved. 55b4fd9aef778e223968dfab1b90f905b3f2bd23dPierre Ossman * SD support Copyright (C) 2004 Ian Molton, All Rights Reserved. 6ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved. 7bce40a36de574376f41f1ff3c4d212a7da2a3c90Philip Langdale * MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved. 81da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 91da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * This program is free software; you can redistribute it and/or modify 101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * it under the terms of the GNU General Public License version 2 as 111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * published by the Free Software Foundation. 121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/module.h> 141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/init.h> 151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/interrupt.h> 161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/completion.h> 171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/device.h> 181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/delay.h> 191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/pagemap.h> 201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/err.h> 21af8350c756cb48a738474738f7bf8c0e572fa057Pierre Ossman#include <linux/leds.h> 22b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman#include <linux/scatterlist.h> 2386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov#include <linux/log2.h> 245c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell#include <linux/regulator/consumer.h> 251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/mmc/card.h> 271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/mmc/host.h> 28da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossman#include <linux/mmc/mmc.h> 29da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossman#include <linux/mmc/sd.h> 301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 31aaac1b470bd0dccb30912356617069dc6199cc80Pierre Ossman#include "core.h" 32ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman#include "bus.h" 33ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman#include "host.h" 34e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman#include "sdio_bus.h" 35da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossman 36da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossman#include "mmc_ops.h" 37da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossman#include "sd_ops.h" 385c4e6f1301649d5b29dd0f70e6da83e728ab5ca5Pierre Ossman#include "sdio_ops.h" 391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 40ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossmanstatic struct workqueue_struct *workqueue; 41ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 42ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman/* 43af51715079e7fb6b290e1881d63d815dc4de5011David Brownell * Enabling software CRCs on the data blocks can be a significant (30%) 44af51715079e7fb6b290e1881d63d815dc4de5011David Brownell * performance cost, and for other reasons may not always be desired. 45af51715079e7fb6b290e1881d63d815dc4de5011David Brownell * So we allow it it to be disabled. 46af51715079e7fb6b290e1881d63d815dc4de5011David Brownell */ 47af51715079e7fb6b290e1881d63d815dc4de5011David Brownellint use_spi_crc = 1; 48af51715079e7fb6b290e1881d63d815dc4de5011David Brownellmodule_param(use_spi_crc, bool, 0); 49af51715079e7fb6b290e1881d63d815dc4de5011David Brownell 50af51715079e7fb6b290e1881d63d815dc4de5011David Brownell/* 51bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings * We normally treat cards as removed during suspend if they are not 52bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings * known to be on a non-removable bus, to avoid the risk of writing 53bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings * back data to a different card after resume. Allow this to be 54bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings * overridden if necessary. 55bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings */ 56bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings#ifdef CONFIG_MMC_UNSAFE_RESUME 57bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchingsint mmc_assume_removable; 58bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings#else 59bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchingsint mmc_assume_removable = 1; 60bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings#endif 61bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchingsmodule_param_named(removable, mmc_assume_removable, bool, 0644); 62bd68e0838fe85794b06892054772fa013a8d1986Ben HutchingsMODULE_PARM_DESC( 63bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings removable, 64bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings "MMC/SD cards are removable and may be removed during suspend"); 65bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings 66bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings/* 67ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman * Internal function. Schedule delayed work in the MMC work queue. 68ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman */ 69ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossmanstatic int mmc_schedule_delayed_work(struct delayed_work *work, 70ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman unsigned long delay) 71ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman{ 72ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman return queue_delayed_work(workqueue, work, delay); 73ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman} 74ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 75ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman/* 76ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman * Internal function. Flush all scheduled work from the MMC work queue. 77ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman */ 78ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossmanstatic void mmc_flush_scheduled_work(void) 79ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman{ 80ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman flush_workqueue(workqueue); 81ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman} 82ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 84fe10c6abea8bc83291a13e0580b3e4c355710b09Russell King * mmc_request_done - finish processing an MMC request 85fe10c6abea8bc83291a13e0580b3e4c355710b09Russell King * @host: MMC host which completed request 86fe10c6abea8bc83291a13e0580b3e4c355710b09Russell King * @mrq: MMC request which request 871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * MMC drivers should call this function when they have completed 89fe10c6abea8bc83291a13e0580b3e4c355710b09Russell King * their processing of a request. 901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsvoid mmc_request_done(struct mmc_host *host, struct mmc_request *mrq) 921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mmc_command *cmd = mrq->cmd; 94920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King int err = cmd->error; 95920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King 96af51715079e7fb6b290e1881d63d815dc4de5011David Brownell if (err && cmd->retries && mmc_host_is_spi(host)) { 97af51715079e7fb6b290e1881d63d815dc4de5011David Brownell if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND) 98af51715079e7fb6b290e1881d63d815dc4de5011David Brownell cmd->retries = 0; 99af51715079e7fb6b290e1881d63d815dc4de5011David Brownell } 100af51715079e7fb6b290e1881d63d815dc4de5011David Brownell 1011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (err && cmd->retries) { 102e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman pr_debug("%s: req failed (CMD%u): %d, retrying...\n", 103e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mmc_hostname(host), cmd->opcode, err); 104e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman 1051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cmd->retries--; 1061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cmd->error = 0; 1071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ops->request(host, mrq); 108e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman } else { 109af8350c756cb48a738474738f7bf8c0e572fa057Pierre Ossman led_trigger_event(host->led, LED_OFF); 110af8350c756cb48a738474738f7bf8c0e572fa057Pierre Ossman 111e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman pr_debug("%s: req done (CMD%u): %d: %08x %08x %08x %08x\n", 112e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mmc_hostname(host), cmd->opcode, err, 113e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman cmd->resp[0], cmd->resp[1], 114e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman cmd->resp[2], cmd->resp[3]); 115e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman 116e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman if (mrq->data) { 117e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman pr_debug("%s: %d bytes transferred: %d\n", 118e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mmc_hostname(host), 119e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->data->bytes_xfered, mrq->data->error); 120e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman } 121e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman 122e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman if (mrq->stop) { 123e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman pr_debug("%s: (CMD%u): %d: %08x %08x %08x %08x\n", 124e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mmc_hostname(host), mrq->stop->opcode, 125e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->stop->error, 126e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->stop->resp[0], mrq->stop->resp[1], 127e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->stop->resp[2], mrq->stop->resp[3]); 128e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman } 129e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman 130e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman if (mrq->done) 131e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->done(mrq); 1321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 1331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 1341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_request_done); 1361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 137393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunkstatic void 1381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmmc_start_request(struct mmc_host *host, struct mmc_request *mrq) 1391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 140976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman#ifdef CONFIG_MMC_DEBUG 141976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman unsigned int i, sz; 142a84756c5735f28bf000617f18734a9e94426386aPierre Ossman struct scatterlist *sg; 143976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman#endif 144976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman 145920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King pr_debug("%s: starting CMD%u arg %08x flags %08x\n", 146920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mmc_hostname(host), mrq->cmd->opcode, 147920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mrq->cmd->arg, mrq->cmd->flags); 1481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 149e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman if (mrq->data) { 150e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman pr_debug("%s: blksz %d blocks %d flags %08x " 151e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman "tsac %d ms nsac %d\n", 152e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mmc_hostname(host), mrq->data->blksz, 153e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->data->blocks, mrq->data->flags, 154ce252edd869ba1fee6a9a6f83e20f349d4c4d669Pierre Ossman mrq->data->timeout_ns / 1000000, 155e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->data->timeout_clks); 156e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman } 157e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman 158e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman if (mrq->stop) { 159e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman pr_debug("%s: CMD%u arg %08x flags %08x\n", 160e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mmc_hostname(host), mrq->stop->opcode, 161e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->stop->arg, mrq->stop->flags); 162e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman } 163e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman 164f22ee4edf63e7480511112d9965c71e07be3f8b7Pierre Ossman WARN_ON(!host->claimed); 1651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 166af8350c756cb48a738474738f7bf8c0e572fa057Pierre Ossman led_trigger_event(host->led, LED_FULL); 167af8350c756cb48a738474738f7bf8c0e572fa057Pierre Ossman 1681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->cmd->error = 0; 1691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->cmd->mrq = mrq; 1701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mrq->data) { 171fe4a3c7a20f14d86022a8132adbf6ddb98e7197cPierre Ossman BUG_ON(mrq->data->blksz > host->max_blk_size); 17255db890a838c7b37256241b1fc53d6344aa79cc0Pierre Ossman BUG_ON(mrq->data->blocks > host->max_blk_count); 17355db890a838c7b37256241b1fc53d6344aa79cc0Pierre Ossman BUG_ON(mrq->data->blocks * mrq->data->blksz > 17455db890a838c7b37256241b1fc53d6344aa79cc0Pierre Ossman host->max_req_size); 175fe4a3c7a20f14d86022a8132adbf6ddb98e7197cPierre Ossman 176976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman#ifdef CONFIG_MMC_DEBUG 177976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman sz = 0; 178a84756c5735f28bf000617f18734a9e94426386aPierre Ossman for_each_sg(mrq->data->sg, sg, mrq->data->sg_len, i) 179a84756c5735f28bf000617f18734a9e94426386aPierre Ossman sz += sg->length; 180976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman BUG_ON(sz != mrq->data->blocks * mrq->data->blksz); 181976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman#endif 182976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman 1831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->cmd->data = mrq->data; 1841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->data->error = 0; 1851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->data->mrq = mrq; 1861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mrq->stop) { 1871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->data->stop = mrq->stop; 1881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->stop->error = 0; 1891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->stop->mrq = mrq; 1901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 1911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 1921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ops->request(host, mrq); 1931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 1941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void mmc_wait_done(struct mmc_request *mrq) 1961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds complete(mrq->done_data); 1981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 1991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20067a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman/** 20167a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * mmc_wait_for_req - start a request and wait for completion 20267a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * @host: MMC host to start command 20367a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * @mrq: MMC request to start 20467a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * 20567a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * Start a new MMC custom command request for a host, and wait 20667a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * for the command to complete. Does not attempt to parse the 20767a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * response. 20867a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman */ 20967a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossmanvoid mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq) 2101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 2110afffc723c8041a005134099847ac2a2fd0316a0Ingo Molnar DECLARE_COMPLETION_ONSTACK(complete); 2121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->done_data = &complete; 2141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->done = mmc_wait_done; 2151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mmc_start_request(host, mrq); 2171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_completion(&complete); 2191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 2201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_wait_for_req); 2221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 2241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * mmc_wait_for_cmd - start a command and wait for completion 2251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @host: MMC host to start command 2261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @cmd: MMC command to start 2271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @retries: maximum number of retries 2281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Start a new MMC command for a host, and wait for the command 2301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * to complete. Return any error that occurred while the command 2311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * was executing. Do not attempt to parse the response. 2321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 2331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries) 2341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 2351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mmc_request mrq; 2361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 237d84075c8aed771d47d7ac6e96b098559da361c25Pierre Ossman WARN_ON(!host->claimed); 2381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memset(&mrq, 0, sizeof(struct mmc_request)); 2401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memset(cmd->resp, 0, sizeof(cmd->resp)); 2421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cmd->retries = retries; 2431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq.cmd = cmd; 2451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cmd->data = NULL; 2461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mmc_wait_for_req(host, &mrq); 2481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return cmd->error; 2501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 2511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_wait_for_cmd); 2531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 254335eadf2ef6a1122a720aea98e758e5d431da87dPierre Ossman/** 255d773d7255199a6c8934e197756f54a1115dd127bRussell King * mmc_set_data_timeout - set the timeout for a data command 256d773d7255199a6c8934e197756f54a1115dd127bRussell King * @data: data phase for command 257d773d7255199a6c8934e197756f54a1115dd127bRussell King * @card: the MMC card associated with the data transfer 25867a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * 25967a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * Computes the data timeout parameters according to the 26067a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * correct algorithm given the card type. 261d773d7255199a6c8934e197756f54a1115dd127bRussell King */ 262b146d26a61e0feab2f12a98ae83fd352830899c0Pierre Ossmanvoid mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card) 263d773d7255199a6c8934e197756f54a1115dd127bRussell King{ 264d773d7255199a6c8934e197756f54a1115dd127bRussell King unsigned int mult; 265d773d7255199a6c8934e197756f54a1115dd127bRussell King 266d773d7255199a6c8934e197756f54a1115dd127bRussell King /* 267e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman * SDIO cards only define an upper 1 s limit on access. 268e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman */ 269e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman if (mmc_card_sdio(card)) { 270e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman data->timeout_ns = 1000000000; 271e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman data->timeout_clks = 0; 272e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman return; 273e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman } 274e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman 275e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman /* 276d773d7255199a6c8934e197756f54a1115dd127bRussell King * SD cards use a 100 multiplier rather than 10 277d773d7255199a6c8934e197756f54a1115dd127bRussell King */ 278d773d7255199a6c8934e197756f54a1115dd127bRussell King mult = mmc_card_sd(card) ? 100 : 10; 279d773d7255199a6c8934e197756f54a1115dd127bRussell King 280d773d7255199a6c8934e197756f54a1115dd127bRussell King /* 281d773d7255199a6c8934e197756f54a1115dd127bRussell King * Scale up the multiplier (and therefore the timeout) by 282d773d7255199a6c8934e197756f54a1115dd127bRussell King * the r2w factor for writes. 283d773d7255199a6c8934e197756f54a1115dd127bRussell King */ 284b146d26a61e0feab2f12a98ae83fd352830899c0Pierre Ossman if (data->flags & MMC_DATA_WRITE) 285d773d7255199a6c8934e197756f54a1115dd127bRussell King mult <<= card->csd.r2w_factor; 286d773d7255199a6c8934e197756f54a1115dd127bRussell King 287d773d7255199a6c8934e197756f54a1115dd127bRussell King data->timeout_ns = card->csd.tacc_ns * mult; 288d773d7255199a6c8934e197756f54a1115dd127bRussell King data->timeout_clks = card->csd.tacc_clks * mult; 289d773d7255199a6c8934e197756f54a1115dd127bRussell King 290d773d7255199a6c8934e197756f54a1115dd127bRussell King /* 291d773d7255199a6c8934e197756f54a1115dd127bRussell King * SD cards also have an upper limit on the timeout. 292d773d7255199a6c8934e197756f54a1115dd127bRussell King */ 293d773d7255199a6c8934e197756f54a1115dd127bRussell King if (mmc_card_sd(card)) { 294d773d7255199a6c8934e197756f54a1115dd127bRussell King unsigned int timeout_us, limit_us; 295d773d7255199a6c8934e197756f54a1115dd127bRussell King 296d773d7255199a6c8934e197756f54a1115dd127bRussell King timeout_us = data->timeout_ns / 1000; 297d773d7255199a6c8934e197756f54a1115dd127bRussell King timeout_us += data->timeout_clks * 1000 / 298d773d7255199a6c8934e197756f54a1115dd127bRussell King (card->host->ios.clock / 1000); 299d773d7255199a6c8934e197756f54a1115dd127bRussell King 300b146d26a61e0feab2f12a98ae83fd352830899c0Pierre Ossman if (data->flags & MMC_DATA_WRITE) 301493890e75d98810a3470b4aae23be628ee5e9667Pierre Ossman /* 302493890e75d98810a3470b4aae23be628ee5e9667Pierre Ossman * The limit is really 250 ms, but that is 303493890e75d98810a3470b4aae23be628ee5e9667Pierre Ossman * insufficient for some crappy cards. 304493890e75d98810a3470b4aae23be628ee5e9667Pierre Ossman */ 305493890e75d98810a3470b4aae23be628ee5e9667Pierre Ossman limit_us = 300000; 306d773d7255199a6c8934e197756f54a1115dd127bRussell King else 307d773d7255199a6c8934e197756f54a1115dd127bRussell King limit_us = 100000; 308d773d7255199a6c8934e197756f54a1115dd127bRussell King 309fba68bd2dab1ac99af3c5a963ec9581cfa9f1725Philip Langdale /* 310fba68bd2dab1ac99af3c5a963ec9581cfa9f1725Philip Langdale * SDHC cards always use these fixed values. 311fba68bd2dab1ac99af3c5a963ec9581cfa9f1725Philip Langdale */ 312fba68bd2dab1ac99af3c5a963ec9581cfa9f1725Philip Langdale if (timeout_us > limit_us || mmc_card_blockaddr(card)) { 313d773d7255199a6c8934e197756f54a1115dd127bRussell King data->timeout_ns = limit_us * 1000; 314d773d7255199a6c8934e197756f54a1115dd127bRussell King data->timeout_clks = 0; 315d773d7255199a6c8934e197756f54a1115dd127bRussell King } 316d773d7255199a6c8934e197756f54a1115dd127bRussell King } 317c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees /* 318c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees * Some cards need very high timeouts if driven in SPI mode. 319c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees * The worst observed timeout was 900ms after writing a 320c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees * continuous stream of data until the internal logic 321c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees * overflowed. 322c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees */ 323c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees if (mmc_host_is_spi(card->host)) { 324c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees if (data->flags & MMC_DATA_WRITE) { 325c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees if (data->timeout_ns < 1000000000) 326c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees data->timeout_ns = 1000000000; /* 1s */ 327c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees } else { 328c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees if (data->timeout_ns < 100000000) 329c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees data->timeout_ns = 100000000; /* 100ms */ 330c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees } 331c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees } 332d773d7255199a6c8934e197756f54a1115dd127bRussell King} 333d773d7255199a6c8934e197756f54a1115dd127bRussell KingEXPORT_SYMBOL(mmc_set_data_timeout); 334d773d7255199a6c8934e197756f54a1115dd127bRussell King 3351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 336ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * mmc_align_data_size - pads a transfer size to a more optimal value 337ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * @card: the MMC card associated with the data transfer 338ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * @sz: original transfer size 339ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * 340ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * Pads the original data size with a number of extra bytes in 341ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * order to avoid controller bugs and/or performance hits 342ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * (e.g. some controllers revert to PIO for certain sizes). 343ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * 344ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * Returns the improved size, which might be unmodified. 345ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * 346ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * Note that this function is only relevant when issuing a 347ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * single scatter gather entry. 348ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman */ 349ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossmanunsigned int mmc_align_data_size(struct mmc_card *card, unsigned int sz) 350ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman{ 351ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman /* 352ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * FIXME: We don't have a system for the controller to tell 353ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * the core about its problems yet, so for now we just 32-bit 354ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * align the size. 355ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman */ 356ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman sz = ((sz + 3) / 4) * 4; 357ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman 358ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman return sz; 359ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman} 360ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre OssmanEXPORT_SYMBOL(mmc_align_data_size); 361ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman 362ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman/** 3638ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * mmc_host_enable - enable a host. 3648ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * @host: mmc host to enable 3658ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * 3668ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * Hosts that support power saving can use the 'enable' and 'disable' 3678ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * methods to exit and enter power saving states. For more information 3688ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * see comments for struct mmc_host_ops. 3698ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter */ 3708ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunterint mmc_host_enable(struct mmc_host *host) 3718ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 3728ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!(host->caps & MMC_CAP_DISABLE)) 3738ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 3748ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 3758ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->en_dis_recurs) 3768ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 3778ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 3788ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->nesting_cnt++) 3798ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 3808ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 3818ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter cancel_delayed_work_sync(&host->disable); 3828ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 3838ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->enabled) 3848ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 3858ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 3868ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->ops->enable) { 3878ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter int err; 3888ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 3898ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->en_dis_recurs = 1; 3908ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter err = host->ops->enable(host); 3918ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->en_dis_recurs = 0; 3928ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 3938ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (err) { 3948ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter pr_debug("%s: enable error %d\n", 3958ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_hostname(host), err); 3968ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return err; 3978ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } 3988ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } 3998ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->enabled = 1; 4008ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 4018ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 4028ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian HunterEXPORT_SYMBOL(mmc_host_enable); 4038ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4048ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunterstatic int mmc_host_do_disable(struct mmc_host *host, int lazy) 4058ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 4068ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->ops->disable) { 4078ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter int err; 4088ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4098ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->en_dis_recurs = 1; 4108ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter err = host->ops->disable(host, lazy); 4118ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->en_dis_recurs = 0; 4128ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4138ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (err < 0) { 4148ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter pr_debug("%s: disable error %d\n", 4158ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_hostname(host), err); 4168ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return err; 4178ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } 4188ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (err > 0) { 4198ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter unsigned long delay = msecs_to_jiffies(err); 4208ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4218ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_schedule_delayed_work(&host->disable, delay); 4228ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } 4238ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } 4248ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->enabled = 0; 4258ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 4268ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 4278ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4288ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter/** 4298ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * mmc_host_disable - disable a host. 4308ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * @host: mmc host to disable 4318ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * 4328ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * Hosts that support power saving can use the 'enable' and 'disable' 4338ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * methods to exit and enter power saving states. For more information 4348ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * see comments for struct mmc_host_ops. 4358ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter */ 4368ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunterint mmc_host_disable(struct mmc_host *host) 4378ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 4388ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter int err; 4398ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4408ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!(host->caps & MMC_CAP_DISABLE)) 4418ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 4428ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4438ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->en_dis_recurs) 4448ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 4458ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4468ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (--host->nesting_cnt) 4478ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 4488ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4498ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!host->enabled) 4508ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 4518ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4528ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter err = mmc_host_do_disable(host, 0); 4538ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return err; 4548ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 4558ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian HunterEXPORT_SYMBOL(mmc_host_disable); 4568ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4578ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter/** 4582342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre * __mmc_claim_host - exclusively claim a host 4591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @host: mmc host to claim 4602342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre * @abort: whether or not the operation should be aborted 4611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 4622342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre * Claim a host for a set of operations. If @abort is non null and 4632342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre * dereference a non-zero value then this will return prematurely with 4642342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre * that non-zero value without acquiring the lock. Returns zero 4652342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre * with the lock held otherwise. 4661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 4672342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitreint __mmc_claim_host(struct mmc_host *host, atomic_t *abort) 4681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 4691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DECLARE_WAITQUEUE(wait, current); 4701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long flags; 4712342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre int stop; 4721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 473cf795bfb3ad4e2f8f6bb346aa8edb8272d4c70a2Pierre Ossman might_sleep(); 474cf795bfb3ad4e2f8f6bb346aa8edb8272d4c70a2Pierre Ossman 4751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds add_wait_queue(&host->wq, &wait); 4761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irqsave(&host->lock, flags); 4771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (1) { 4781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_current_state(TASK_UNINTERRUPTIBLE); 4792342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre stop = abort ? atomic_read(abort) : 0; 480319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter if (stop || !host->claimed || host->claimer == current) 4811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 4821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irqrestore(&host->lock, flags); 4831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds schedule(); 4841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irqsave(&host->lock, flags); 4851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 4861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_current_state(TASK_RUNNING); 487319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter if (!stop) { 4882342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre host->claimed = 1; 489319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter host->claimer = current; 490319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter host->claim_cnt += 1; 491319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter } else 4922342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre wake_up(&host->wq); 4931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irqrestore(&host->lock, flags); 4941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds remove_wait_queue(&host->wq, &wait); 4958ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!stop) 4968ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_host_enable(host); 4972342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre return stop; 4981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 4991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5002342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas PitreEXPORT_SYMBOL(__mmc_claim_host); 5011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 502319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter/** 503319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter * mmc_try_claim_host - try exclusively to claim a host 504319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter * @host: mmc host to claim 505319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter * 506319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter * Returns %1 if the host is claimed, %0 otherwise. 507319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter */ 508319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunterint mmc_try_claim_host(struct mmc_host *host) 5098ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 5108ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter int claimed_host = 0; 5118ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter unsigned long flags; 5128ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5138ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter spin_lock_irqsave(&host->lock, flags); 514319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter if (!host->claimed || host->claimer == current) { 5158ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->claimed = 1; 516319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter host->claimer = current; 517319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter host->claim_cnt += 1; 5188ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter claimed_host = 1; 5198ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } 5208ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter spin_unlock_irqrestore(&host->lock, flags); 5218ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return claimed_host; 5228ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 523319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian HunterEXPORT_SYMBOL(mmc_try_claim_host); 5248ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5258ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunterstatic void mmc_do_release_host(struct mmc_host *host) 5268ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 5278ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter unsigned long flags; 5288ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5298ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter spin_lock_irqsave(&host->lock, flags); 530319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter if (--host->claim_cnt) { 531319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter /* Release for nested claim */ 532319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter spin_unlock_irqrestore(&host->lock, flags); 533319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter } else { 534319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter host->claimed = 0; 535319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter host->claimer = NULL; 536319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter spin_unlock_irqrestore(&host->lock, flags); 537319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter wake_up(&host->wq); 538319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter } 5398ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 5408ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5418ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Huntervoid mmc_host_deeper_disable(struct work_struct *work) 5428ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 5438ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter struct mmc_host *host = 5448ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter container_of(work, struct mmc_host, disable.work); 5458ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5468ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter /* If the host is claimed then we do not want to disable it anymore */ 5478ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!mmc_try_claim_host(host)) 5488ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return; 5498ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_host_do_disable(host, 1); 5508ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_do_release_host(host); 5518ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 5528ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5538ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter/** 5548ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * mmc_host_lazy_disable - lazily disable a host. 5558ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * @host: mmc host to disable 5568ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * 5578ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * Hosts that support power saving can use the 'enable' and 'disable' 5588ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * methods to exit and enter power saving states. For more information 5598ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * see comments for struct mmc_host_ops. 5608ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter */ 5618ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunterint mmc_host_lazy_disable(struct mmc_host *host) 5628ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 5638ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!(host->caps & MMC_CAP_DISABLE)) 5648ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5658ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5668ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->en_dis_recurs) 5678ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5688ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5698ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (--host->nesting_cnt) 5708ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5718ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5728ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!host->enabled) 5738ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5748ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5758ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->disable_delay) { 5768ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_schedule_delayed_work(&host->disable, 5778ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter msecs_to_jiffies(host->disable_delay)); 5788ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5798ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } else 5808ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return mmc_host_do_disable(host, 1); 5818ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 5828ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian HunterEXPORT_SYMBOL(mmc_host_lazy_disable); 5838ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 5851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * mmc_release_host - release a host 5861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @host: mmc host to release 5871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 5881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Release a MMC host, allowing others to claim the host 5891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * for their operations. 5901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 5911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsvoid mmc_release_host(struct mmc_host *host) 5921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 593d84075c8aed771d47d7ac6e96b098559da361c25Pierre Ossman WARN_ON(!host->claimed); 5941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5958ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_host_lazy_disable(host); 5961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5978ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_do_release_host(host); 5981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 5991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_release_host); 6011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6027ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman/* 6037ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Internal function that does the actual ios call to the host driver, 6047ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * optionally printing some debug output. 6057ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman */ 606920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell Kingstatic inline void mmc_set_ios(struct mmc_host *host) 607920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King{ 608920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King struct mmc_ios *ios = &host->ios; 609920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King 610cd9277c011a99769fa371521b460ed57f6d280b1Pierre Ossman pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u " 611cd9277c011a99769fa371521b460ed57f6d280b1Pierre Ossman "width %u timing %u\n", 612920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mmc_hostname(host), ios->clock, ios->bus_mode, 613920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King ios->power_mode, ios->chip_select, ios->vdd, 614cd9277c011a99769fa371521b460ed57f6d280b1Pierre Ossman ios->bus_width, ios->timing); 615fba68bd2dab1ac99af3c5a963ec9581cfa9f1725Philip Langdale 616920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King host->ops->set_ios(host, ios); 617920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King} 618920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King 6197ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman/* 6207ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Control chip select pin on a host. 6217ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman */ 622da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossmanvoid mmc_set_chip_select(struct mmc_host *host, int mode) 6231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 624da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossman host->ios.chip_select = mode; 625da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossman mmc_set_ios(host); 6261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 6271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 6297ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Sets the host clock to the highest possible frequency that 6307ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * is below "hz". 6317ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman */ 6327ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossmanvoid mmc_set_clock(struct mmc_host *host, unsigned int hz) 6337ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman{ 6347ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman WARN_ON(hz < host->f_min); 6357ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 6367ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman if (hz > host->f_max) 6377ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman hz = host->f_max; 6387ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 6397ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->ios.clock = hz; 6407ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_set_ios(host); 6417ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman} 6427ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 6437ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman/* 6447ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Change the bus mode (open drain/push-pull) of a host. 6457ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman */ 6467ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossmanvoid mmc_set_bus_mode(struct mmc_host *host, unsigned int mode) 6477ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman{ 6487ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->ios.bus_mode = mode; 6497ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_set_ios(host); 6507ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman} 6517ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 6527ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman/* 6537ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Change data bus width of a host. 6547ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman */ 6557ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossmanvoid mmc_set_bus_width(struct mmc_host *host, unsigned int width) 6567ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman{ 6577ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->ios.bus_width = width; 6587ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_set_ios(host); 6597ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman} 6607ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 66186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov/** 66286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * mmc_vdd_to_ocrbitnum - Convert a voltage to the OCR bit number 66386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * @vdd: voltage (mV) 66486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * @low_bits: prefer low bits in boundary cases 66586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * 66686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * This function returns the OCR bit number according to the provided @vdd 66786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * value. If conversion is not possible a negative errno value returned. 66886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * 66986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * Depending on the @low_bits flag the function prefers low or high OCR bits 67086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * on boundary voltages. For example, 67186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * with @low_bits = true, 3300 mV translates to ilog2(MMC_VDD_32_33); 67286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * with @low_bits = false, 3300 mV translates to ilog2(MMC_VDD_33_34); 67386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * 67486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * Any value in the [1951:1999] range translates to the ilog2(MMC_VDD_20_21). 67586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov */ 67686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsovstatic int mmc_vdd_to_ocrbitnum(int vdd, bool low_bits) 67786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov{ 67886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov const int max_bit = ilog2(MMC_VDD_35_36); 67986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov int bit; 68086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 68186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (vdd < 1650 || vdd > 3600) 68286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return -EINVAL; 68386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 68486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (vdd >= 1650 && vdd <= 1950) 68586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return ilog2(MMC_VDD_165_195); 68686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 68786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (low_bits) 68886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov vdd -= 1; 68986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 69086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov /* Base 2000 mV, step 100 mV, bit's base 8. */ 69186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov bit = (vdd - 2000) / 100 + 8; 69286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (bit > max_bit) 69386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return max_bit; 69486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return bit; 69586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov} 69686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 69786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov/** 69886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * mmc_vddrange_to_ocrmask - Convert a voltage range to the OCR mask 69986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * @vdd_min: minimum voltage value (mV) 70086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * @vdd_max: maximum voltage value (mV) 70186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * 70286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * This function returns the OCR mask bits according to the provided @vdd_min 70386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * and @vdd_max values. If conversion is not possible the function returns 0. 70486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * 70586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * Notes wrt boundary cases: 70686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * This function sets the OCR bits for all boundary voltages, for example 70786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * [3300:3400] range is translated to MMC_VDD_32_33 | MMC_VDD_33_34 | 70886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * MMC_VDD_34_35 mask. 70986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov */ 71086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsovu32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max) 71186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov{ 71286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov u32 mask = 0; 71386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 71486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (vdd_max < vdd_min) 71586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return 0; 71686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 71786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov /* Prefer high bits for the boundary vdd_max values. */ 71886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov vdd_max = mmc_vdd_to_ocrbitnum(vdd_max, false); 71986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (vdd_max < 0) 72086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return 0; 72186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 72286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov /* Prefer low bits for the boundary vdd_min values. */ 72386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov vdd_min = mmc_vdd_to_ocrbitnum(vdd_min, true); 72486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (vdd_min < 0) 72586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return 0; 72686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 72786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov /* Fill the mask, from max bit to min bit. */ 72886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov while (vdd_max >= vdd_min) 72986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov mask |= 1 << vdd_max--; 73086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 73186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return mask; 73286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov} 73386e8286a0e48663e1e86a5884b30a6d05de2993aAnton VorontsovEXPORT_SYMBOL(mmc_vddrange_to_ocrmask); 73486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 7355c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell#ifdef CONFIG_REGULATOR 7365c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 7375c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell/** 7385c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * mmc_regulator_get_ocrmask - return mask of supported voltages 7395c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * @supply: regulator to use 7405c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * 7415c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * This returns either a negative errno, or a mask of voltages that 7425c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * can be provided to MMC/SD/SDIO devices using the specified voltage 7435c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * regulator. This would normally be called before registering the 7445c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * MMC host adapter. 7455c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell */ 7465c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownellint mmc_regulator_get_ocrmask(struct regulator *supply) 7475c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell{ 7485c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int result = 0; 7495c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int count; 7505c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int i; 7515c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 7525c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell count = regulator_count_voltages(supply); 7535c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell if (count < 0) 7545c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell return count; 7555c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 7565c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell for (i = 0; i < count; i++) { 7575c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int vdd_uV; 7585c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int vdd_mV; 7595c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 7605c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell vdd_uV = regulator_list_voltage(supply, i); 7615c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell if (vdd_uV <= 0) 7625c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell continue; 7635c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 7645c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell vdd_mV = vdd_uV / 1000; 7655c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell result |= mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV); 7665c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell } 7675c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 7685c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell return result; 7695c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell} 7705c13941acc513669c7d07b28789c3f9ba66ddddfDavid BrownellEXPORT_SYMBOL(mmc_regulator_get_ocrmask); 7715c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 7725c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell/** 7735c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * mmc_regulator_set_ocr - set regulator to match host->ios voltage 7745c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * @vdd_bit: zero for power off, else a bit number (host->ios.vdd) 7755c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * @supply: regulator to use 7765c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * 7775c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * Returns zero on success, else negative errno. 7785c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * 7795c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * MMC host drivers may use this to enable or disable a regulator using 7805c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * a particular supply voltage. This would normally be called from the 7815c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * set_ios() method. 7825c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell */ 7835c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownellint mmc_regulator_set_ocr(struct regulator *supply, unsigned short vdd_bit) 7845c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell{ 7855c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int result = 0; 7865c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int min_uV, max_uV; 7875c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int enabled; 7885c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 7895c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell enabled = regulator_is_enabled(supply); 7905c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell if (enabled < 0) 7915c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell return enabled; 7925c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 7935c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell if (vdd_bit) { 7945c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int tmp; 7955c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int voltage; 7965c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 7975c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell /* REVISIT mmc_vddrange_to_ocrmask() may have set some 7985c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * bits this regulator doesn't quite support ... don't 7995c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * be too picky, most cards and regulators are OK with 8005c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * a 0.1V range goof (it's a small error percentage). 8015c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell */ 8025c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell tmp = vdd_bit - ilog2(MMC_VDD_165_195); 8035c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell if (tmp == 0) { 8045c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell min_uV = 1650 * 1000; 8055c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell max_uV = 1950 * 1000; 8065c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell } else { 8075c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell min_uV = 1900 * 1000 + tmp * 100 * 1000; 8085c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell max_uV = min_uV + 100 * 1000; 8095c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell } 8105c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 8115c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell /* avoid needless changes to this voltage; the regulator 8125c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * might not allow this operation 8135c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell */ 8145c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell voltage = regulator_get_voltage(supply); 8155c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell if (voltage < 0) 8165c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell result = voltage; 8175c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell else if (voltage < min_uV || voltage > max_uV) 8185c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell result = regulator_set_voltage(supply, min_uV, max_uV); 8195c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell else 8205c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell result = 0; 8215c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 8225c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell if (result == 0 && !enabled) 8235c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell result = regulator_enable(supply); 8245c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell } else if (enabled) { 8255c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell result = regulator_disable(supply); 8265c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell } 8275c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 8285c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell return result; 8295c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell} 8305c13941acc513669c7d07b28789c3f9ba66ddddfDavid BrownellEXPORT_SYMBOL(mmc_regulator_set_ocr); 8315c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 8325c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell#endif 8335c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 8347ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman/* 8351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Mask off any voltages we don't support and select 8361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the lowest voltage 8371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 8387ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossmanu32 mmc_select_voltage(struct mmc_host *host, u32 ocr) 8391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 8401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int bit; 8411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ocr &= host->ocr_avail; 8431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bit = ffs(ocr); 8451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (bit) { 8461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bit -= 1; 8471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 84863ef731aa6a81e286de78dcc92241d123424ed39Timo Teras ocr &= 3 << bit; 8491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.vdd = bit; 851920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mmc_set_ios(host); 8521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 853f6e10b865c3ea56bdaa8c6ecfee313b997900dbbDavid Brownell pr_warning("%s: host doesn't support card's voltages\n", 854f6e10b865c3ea56bdaa8c6ecfee313b997900dbbDavid Brownell mmc_hostname(host)); 8551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ocr = 0; 8561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return ocr; 8591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 8601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 8627ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Select timing parameters for host. 863b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman */ 8647ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossmanvoid mmc_set_timing(struct mmc_host *host, unsigned int timing) 865b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman{ 8667ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->ios.timing = timing; 8677ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_set_ios(host); 868b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman} 869b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman 870b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman/* 87145f8245b972e360c19aec9032e2a2033b8ac3719Russell King * Apply power to the MMC stack. This is a two-stage process. 87245f8245b972e360c19aec9032e2a2033b8ac3719Russell King * First, we enable power to the card without the clock running. 87345f8245b972e360c19aec9032e2a2033b8ac3719Russell King * We then wait a bit for the power to stabilise. Finally, 87445f8245b972e360c19aec9032e2a2033b8ac3719Russell King * enable the bus drivers and clock to the card. 87545f8245b972e360c19aec9032e2a2033b8ac3719Russell King * 87645f8245b972e360c19aec9032e2a2033b8ac3719Russell King * We must _NOT_ enable the clock prior to power stablising. 87745f8245b972e360c19aec9032e2a2033b8ac3719Russell King * 87845f8245b972e360c19aec9032e2a2033b8ac3719Russell King * If a host does all the power sequencing itself, ignore the 87945f8245b972e360c19aec9032e2a2033b8ac3719Russell King * initial MMC_POWER_UP stage. 8801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 8811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void mmc_power_up(struct mmc_host *host) 8821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 883500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao int bit; 884500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao 885500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao /* If ocr is set, we use it */ 886500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao if (host->ocr) 887500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao bit = ffs(host->ocr) - 1; 888500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao else 889500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao bit = fls(host->ocr_avail) - 1; 8901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.vdd = bit; 892af51715079e7fb6b290e1881d63d815dc4de5011David Brownell if (mmc_host_is_spi(host)) { 893af51715079e7fb6b290e1881d63d815dc4de5011David Brownell host->ios.chip_select = MMC_CS_HIGH; 894af51715079e7fb6b290e1881d63d815dc4de5011David Brownell host->ios.bus_mode = MMC_BUSMODE_PUSHPULL; 895af51715079e7fb6b290e1881d63d815dc4de5011David Brownell } else { 896af51715079e7fb6b290e1881d63d815dc4de5011David Brownell host->ios.chip_select = MMC_CS_DONTCARE; 897af51715079e7fb6b290e1881d63d815dc4de5011David Brownell host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN; 898af51715079e7fb6b290e1881d63d815dc4de5011David Brownell } 8991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.power_mode = MMC_POWER_UP; 900f218278a456b3c272b480443c89004c3d2a49f18Pierre Ossman host->ios.bus_width = MMC_BUS_WIDTH_1; 901cd9277c011a99769fa371521b460ed57f6d280b1Pierre Ossman host->ios.timing = MMC_TIMING_LEGACY; 902920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mmc_set_ios(host); 9031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 904f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman /* 905f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman * This delay should be sufficient to allow the power supply 906f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman * to reach the minimum voltage. 907f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman */ 90879bccc5aefb4e64e651abe04f78c3e6bf8acd6f0José M. Fernández mmc_delay(10); 9091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9108dfd0374be84793360db7fff2e635d2cd3bbcb21Sascha Hauer if (host->f_min > 400000) { 9118dfd0374be84793360db7fff2e635d2cd3bbcb21Sascha Hauer pr_warning("%s: Minimum clock frequency too high for " 9128dfd0374be84793360db7fff2e635d2cd3bbcb21Sascha Hauer "identification mode\n", mmc_hostname(host)); 9138dfd0374be84793360db7fff2e635d2cd3bbcb21Sascha Hauer host->ios.clock = host->f_min; 9148dfd0374be84793360db7fff2e635d2cd3bbcb21Sascha Hauer } else 9158dfd0374be84793360db7fff2e635d2cd3bbcb21Sascha Hauer host->ios.clock = 400000; 9168dfd0374be84793360db7fff2e635d2cd3bbcb21Sascha Hauer 9171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.power_mode = MMC_POWER_ON; 918920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mmc_set_ios(host); 9191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 920f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman /* 921f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman * This delay must be at least 74 clock sizes, or 1 ms, or the 922f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman * time required to reach a stable voltage. 923f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman */ 92479bccc5aefb4e64e651abe04f78c3e6bf8acd6f0José M. Fernández mmc_delay(10); 9251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 9261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void mmc_power_off(struct mmc_host *host) 9281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 9291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.clock = 0; 9301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.vdd = 0; 931af51715079e7fb6b290e1881d63d815dc4de5011David Brownell if (!mmc_host_is_spi(host)) { 932af51715079e7fb6b290e1881d63d815dc4de5011David Brownell host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN; 933af51715079e7fb6b290e1881d63d815dc4de5011David Brownell host->ios.chip_select = MMC_CS_DONTCARE; 934af51715079e7fb6b290e1881d63d815dc4de5011David Brownell } 9351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.power_mode = MMC_POWER_OFF; 936f218278a456b3c272b480443c89004c3d2a49f18Pierre Ossman host->ios.bus_width = MMC_BUS_WIDTH_1; 937cd9277c011a99769fa371521b460ed57f6d280b1Pierre Ossman host->ios.timing = MMC_TIMING_LEGACY; 938920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mmc_set_ios(host); 9391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 9401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 942393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk * Cleanup when the last reference to the bus operator is dropped. 943393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk */ 944261172fd1b23769bc7632047e2cb826c9b8b1a50Adrian Bunkstatic void __mmc_release_bus(struct mmc_host *host) 945393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk{ 946393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk BUG_ON(!host); 947393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk BUG_ON(host->bus_refs); 948393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk BUG_ON(!host->bus_dead); 949393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk 950393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk host->bus_ops = NULL; 951393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk} 952393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk 953393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk/* 954393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk * Increase reference count of bus operator 955393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk */ 956393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunkstatic inline void mmc_bus_get(struct mmc_host *host) 957393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk{ 958393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk unsigned long flags; 959393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk 960393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk spin_lock_irqsave(&host->lock, flags); 961393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk host->bus_refs++; 962393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk spin_unlock_irqrestore(&host->lock, flags); 963393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk} 964393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk 965393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk/* 966393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk * Decrease reference count of bus operator and free it if 967393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk * it is the last reference. 968393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk */ 969393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunkstatic inline void mmc_bus_put(struct mmc_host *host) 970393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk{ 971393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk unsigned long flags; 972393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk 973393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk spin_lock_irqsave(&host->lock, flags); 974393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk host->bus_refs--; 975393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk if ((host->bus_refs == 0) && host->bus_ops) 976393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk __mmc_release_bus(host); 977393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk spin_unlock_irqrestore(&host->lock, flags); 978393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk} 979393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk 980393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk/* 9817ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Assign a mmc bus handler to a host. Only one bus handler may control a 9827ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * host at any given time. 9831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 9847ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossmanvoid mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops) 9851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 9867ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman unsigned long flags; 987e45a1bd20fa5b920901879e85cdf5eda21f78d7cPhilip Langdale 9887ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman BUG_ON(!host); 9897ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman BUG_ON(!ops); 990b855885e3b60cf6f9452848712a62517b94583ebPierre Ossman 991d84075c8aed771d47d7ac6e96b098559da361c25Pierre Ossman WARN_ON(!host->claimed); 992bce40a36de574376f41f1ff3c4d212a7da2a3c90Philip Langdale 9937ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman spin_lock_irqsave(&host->lock, flags); 994bce40a36de574376f41f1ff3c4d212a7da2a3c90Philip Langdale 9957ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman BUG_ON(host->bus_ops); 9967ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman BUG_ON(host->bus_refs); 997b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman 9987ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->bus_ops = ops; 9997ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->bus_refs = 1; 10007ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->bus_dead = 0; 1001b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman 10027ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman spin_unlock_irqrestore(&host->lock, flags); 1003b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman} 1004b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman 10057ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman/* 10067ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Remove the current bus handler from a host. Assumes that there are 10077ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * no interesting cards left, so the bus is powered down. 10087ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman */ 10097ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossmanvoid mmc_detach_bus(struct mmc_host *host) 10107ccd266e676a3f0c6f8f897f58b684cac3dd1650Pierre Ossman{ 10117ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman unsigned long flags; 10127ccd266e676a3f0c6f8f897f58b684cac3dd1650Pierre Ossman 10137ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman BUG_ON(!host); 10147ccd266e676a3f0c6f8f897f58b684cac3dd1650Pierre Ossman 1015d84075c8aed771d47d7ac6e96b098559da361c25Pierre Ossman WARN_ON(!host->claimed); 1016d84075c8aed771d47d7ac6e96b098559da361c25Pierre Ossman WARN_ON(!host->bus_ops); 1017cd9277c011a99769fa371521b460ed57f6d280b1Pierre Ossman 10187ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman spin_lock_irqsave(&host->lock, flags); 10197ccd266e676a3f0c6f8f897f58b684cac3dd1650Pierre Ossman 10207ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->bus_dead = 1; 10217ccd266e676a3f0c6f8f897f58b684cac3dd1650Pierre Ossman 10227ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman spin_unlock_irqrestore(&host->lock, flags); 10231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10247ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_power_off(host); 10251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10267ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_put(host); 10271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 10281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 10301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * mmc_detect_change - process change of state on a MMC socket 10311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @host: host which changed state. 10328dc003359cc3996abad9e53a7b2280b272610283Richard Purdie * @delay: optional delay to wait before detection (jiffies) 10331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 103467a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * MMC drivers should call this when they detect a card has been 103567a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * inserted or removed. The MMC layer will confirm that any 103667a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * present card is still functional, and initialize any newly 103767a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * inserted. 10381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 10398dc003359cc3996abad9e53a7b2280b272610283Richard Purdievoid mmc_detect_change(struct mmc_host *host, unsigned long delay) 10401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 10413b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman#ifdef CONFIG_MMC_DEBUG 10421efd48b3ae8f89a1d04f1e36be96764d7bf43ae9Pierre Ossman unsigned long flags; 104301f41ec7b36e14da18a4e162ef697ae358f36e37Andrew Morton spin_lock_irqsave(&host->lock, flags); 1044d84075c8aed771d47d7ac6e96b098559da361c25Pierre Ossman WARN_ON(host->removed); 104501f41ec7b36e14da18a4e162ef697ae358f36e37Andrew Morton spin_unlock_irqrestore(&host->lock, flags); 10463b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman#endif 10473b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman 1048c4028958b6ecad064b1a6303a6a5906d4fe48d73David Howells mmc_schedule_delayed_work(&host->detect, delay); 10491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 10501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_detect_change); 10521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1054b93931a61a119575f84c33af2438b9384fde9eb7Pierre Ossmanvoid mmc_rescan(struct work_struct *work) 10551da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1056c4028958b6ecad064b1a6303a6a5906d4fe48d73David Howells struct mmc_host *host = 1057c4028958b6ecad064b1a6303a6a5906d4fe48d73David Howells container_of(work, struct mmc_host, detect.work); 10587ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman u32 ocr; 10597ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman int err; 10601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10617ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_get(host); 1062b855885e3b60cf6f9452848712a62517b94583ebPierre Ossman 106394d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer /* if there is a card registered, check whether it is still present */ 106494d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer if ((host->bus_ops != NULL) && host->bus_ops->detect && !host->bus_dead) 106594d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer host->bus_ops->detect(host); 106694d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer 106794d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer mmc_bus_put(host); 106894d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer 106994d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer 107094d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer mmc_bus_get(host); 107194d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer 107294d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer /* if there still is a card present, stop here */ 107394d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer if (host->bus_ops != NULL) { 10747ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_put(host); 107594d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer goto out; 107694d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer } 10771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 107894d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer /* detect a newly inserted card */ 107928f52482b41edc88cdf575aa6ed414c6e116ce10Anton Vorontsov 108094d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer /* 108194d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer * Only we can add a new handler, so it's safe to 108294d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer * release the lock here. 108394d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer */ 108494d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer mmc_bus_put(host); 10851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 108694d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer if (host->ops->get_cd && host->ops->get_cd(host) == 0) 108794d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer goto out; 10881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 108994d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer mmc_claim_host(host); 10901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 109194d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer mmc_power_up(host); 109294d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer mmc_go_idle(host); 10935c4e6f1301649d5b29dd0f70e6da83e728ab5ca5Pierre Ossman 109494d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer mmc_send_if_cond(host, host->ocr_avail); 10955c4e6f1301649d5b29dd0f70e6da83e728ab5ca5Pierre Ossman 109694d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer /* 109794d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer * First we search for SDIO... 109894d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer */ 109994d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer err = mmc_send_io_op_cond(host, 0, &ocr); 110094d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer if (!err) { 110194d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer if (mmc_attach_sdio(host, ocr)) 110294d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer mmc_power_off(host); 110394d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer goto out; 110494d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer } 11055c4e6f1301649d5b29dd0f70e6da83e728ab5ca5Pierre Ossman 110694d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer /* 110794d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer * ...then normal SD... 110894d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer */ 110994d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer err = mmc_send_app_op_cond(host, 0, &ocr); 111094d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer if (!err) { 111194d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer if (mmc_attach_sd(host, ocr)) 111294d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer mmc_power_off(host); 111394d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer goto out; 111494d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer } 11157ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 111694d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer /* 111794d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer * ...and finally MMC. 111894d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer */ 111994d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer err = mmc_send_op_cond(host, 0, &ocr); 112094d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer if (!err) { 112194d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer if (mmc_attach_mmc(host, ocr)) 112294d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer mmc_power_off(host); 112394d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer goto out; 11247ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman } 112594d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer 112694d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer mmc_release_host(host); 112794d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer mmc_power_off(host); 112894d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer 112928f52482b41edc88cdf575aa6ed414c6e116ce10Anton Vorontsovout: 113028f52482b41edc88cdf575aa6ed414c6e116ce10Anton Vorontsov if (host->caps & MMC_CAP_NEEDS_POLL) 113128f52482b41edc88cdf575aa6ed414c6e116ce10Anton Vorontsov mmc_schedule_delayed_work(&host->detect, HZ); 11321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1134b93931a61a119575f84c33af2438b9384fde9eb7Pierre Ossmanvoid mmc_start_host(struct mmc_host *host) 11351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1136b93931a61a119575f84c33af2438b9384fde9eb7Pierre Ossman mmc_power_off(host); 1137b93931a61a119575f84c33af2438b9384fde9eb7Pierre Ossman mmc_detect_change(host, 0); 11381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1140b93931a61a119575f84c33af2438b9384fde9eb7Pierre Ossmanvoid mmc_stop_host(struct mmc_host *host) 11411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 11423b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman#ifdef CONFIG_MMC_DEBUG 11431efd48b3ae8f89a1d04f1e36be96764d7bf43ae9Pierre Ossman unsigned long flags; 11441efd48b3ae8f89a1d04f1e36be96764d7bf43ae9Pierre Ossman spin_lock_irqsave(&host->lock, flags); 11453b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman host->removed = 1; 11461efd48b3ae8f89a1d04f1e36be96764d7bf43ae9Pierre Ossman spin_unlock_irqrestore(&host->lock, flags); 11473b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman#endif 11483b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman 11498ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->caps & MMC_CAP_DISABLE) 11508ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter cancel_delayed_work(&host->disable); 11517de427d088a967d2173739e21e744921d5496a8bJorg Schummer cancel_delayed_work(&host->detect); 11523b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman mmc_flush_scheduled_work(); 11533b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman 11547ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_get(host); 11557ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman if (host->bus_ops && !host->bus_dead) { 11567ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman if (host->bus_ops->remove) 11577ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->bus_ops->remove(host); 11587ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 11597ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_claim_host(host); 11607ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_detach_bus(host); 11617ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_release_host(host); 116253509f0fe28e049e772897aa8fa1f5183b6823a2Denis Karpov mmc_bus_put(host); 116353509f0fe28e049e772897aa8fa1f5183b6823a2Denis Karpov return; 11641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 11657ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_put(host); 11667ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 11677ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman BUG_ON(host->card); 11681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mmc_power_off(host); 11701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1172eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Huntervoid mmc_power_save_host(struct mmc_host *host) 1173eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter{ 1174eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_bus_get(host); 1175eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1176eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) { 1177eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_bus_put(host); 1178eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter return; 1179eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter } 1180eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1181eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter if (host->bus_ops->power_save) 1182eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter host->bus_ops->power_save(host); 1183eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1184eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_bus_put(host); 1185eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1186eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_power_off(host); 1187eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter} 1188eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian HunterEXPORT_SYMBOL(mmc_power_save_host); 1189eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1190eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Huntervoid mmc_power_restore_host(struct mmc_host *host) 1191eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter{ 1192eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_bus_get(host); 1193eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1194eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) { 1195eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_bus_put(host); 1196eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter return; 1197eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter } 1198eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1199eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_power_up(host); 1200eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter host->bus_ops->power_restore(host); 1201eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1202eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_bus_put(host); 1203eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter} 1204eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian HunterEXPORT_SYMBOL(mmc_power_restore_host); 1205eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1206b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinenint mmc_card_awake(struct mmc_host *host) 1207b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen{ 1208b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen int err = -ENOSYS; 1209b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1210b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen mmc_bus_get(host); 1211b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1212b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen if (host->bus_ops && !host->bus_dead && host->bus_ops->awake) 1213b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen err = host->bus_ops->awake(host); 1214b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1215b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen mmc_bus_put(host); 1216b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1217b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen return err; 1218b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen} 1219b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko LavinenEXPORT_SYMBOL(mmc_card_awake); 1220b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1221b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinenint mmc_card_sleep(struct mmc_host *host) 1222b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen{ 1223b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen int err = -ENOSYS; 1224b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1225b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen mmc_bus_get(host); 1226b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1227b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen if (host->bus_ops && !host->bus_dead && host->bus_ops->awake) 1228b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen err = host->bus_ops->sleep(host); 1229b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1230b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen mmc_bus_put(host); 1231b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1232b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen return err; 1233b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen} 1234b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko LavinenEXPORT_SYMBOL(mmc_card_sleep); 1235b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1236b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinenint mmc_card_can_sleep(struct mmc_host *host) 1237b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen{ 1238b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen struct mmc_card *card = host->card; 1239b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1240b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen if (card && mmc_card_mmc(card) && card->ext_csd.rev >= 3) 1241b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen return 1; 1242b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen return 0; 1243b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen} 1244b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko LavinenEXPORT_SYMBOL(mmc_card_can_sleep); 1245b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 12461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef CONFIG_PM 12471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 12491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * mmc_suspend_host - suspend a host 12501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @host: mmc host 12511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @state: suspend mode (PM_SUSPEND_xxx) 12521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 1253e5378ca8c0ab684bd9339dc6827dd5a042f9e6fcPavel Machekint mmc_suspend_host(struct mmc_host *host, pm_message_t state) 12541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 125595cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre int err = 0; 125695cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre 12578ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->caps & MMC_CAP_DISABLE) 12588ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter cancel_delayed_work(&host->disable); 12597de427d088a967d2173739e21e744921d5496a8bJorg Schummer cancel_delayed_work(&host->detect); 1260b5af25bee2de2f6cd1ac74ba737cbc4f3d303e5dPierre Ossman mmc_flush_scheduled_work(); 1261b5af25bee2de2f6cd1ac74ba737cbc4f3d303e5dPierre Ossman 12627ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_get(host); 12637ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman if (host->bus_ops && !host->bus_dead) { 12646abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman if (host->bus_ops->suspend) 126595cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre err = host->bus_ops->suspend(host); 126695cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre if (err == -ENOSYS || !host->bus_ops->resume) { 126795cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre /* 126895cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre * We simply "remove" the card in this case. 126995cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre * It will be redetected on resume. 127095cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre */ 12716abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman if (host->bus_ops->remove) 12726abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman host->bus_ops->remove(host); 12736abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman mmc_claim_host(host); 12746abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman mmc_detach_bus(host); 12756abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman mmc_release_host(host); 127695cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre err = 0; 12776abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman } 1278b5af25bee2de2f6cd1ac74ba737cbc4f3d303e5dPierre Ossman } 12797ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_put(host); 12807ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 128195cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre if (!err) 128295cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre mmc_power_off(host); 12831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 128495cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre return err; 12851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 12861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_suspend_host); 12881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 12901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * mmc_resume_host - resume a previously suspended host 12911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @host: mmc host 12921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 12931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint mmc_resume_host(struct mmc_host *host) 12941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 129595cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre int err = 0; 129695cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre 12976abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman mmc_bus_get(host); 12986abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman if (host->bus_ops && !host->bus_dead) { 12996abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman mmc_power_up(host); 1300d3096f88ac4596a509fc5fbe6fa7e7a5497eb399Balaji Rao mmc_select_voltage(host, host->ocr); 13016abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman BUG_ON(!host->bus_ops->resume); 130295cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre err = host->bus_ops->resume(host); 130395cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre if (err) { 130495cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre printk(KERN_WARNING "%s: error %d during resume " 130595cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre "(card was removed?)\n", 130695cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre mmc_hostname(host), err); 130795cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre if (host->bus_ops->remove) 130895cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre host->bus_ops->remove(host); 130995cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre mmc_claim_host(host); 131095cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre mmc_detach_bus(host); 131195cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre mmc_release_host(host); 131295cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre /* no need to bother upper layers */ 131395cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre err = 0; 131495cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre } 13156abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman } 13166abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman mmc_bus_put(host); 13176abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman 13186abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman /* 13196abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman * We add a slight delay here so that resume can progress 13206abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman * in parallel. 13216abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman */ 13226abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman mmc_detect_change(host, 1); 13231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 132495cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre return err; 13251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_resume_host); 13281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 13301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1331ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossmanstatic int __init mmc_init(void) 1332ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman{ 1333ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman int ret; 1334ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 1335ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman workqueue = create_singlethread_workqueue("kmmcd"); 1336ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman if (!workqueue) 1337ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman return -ENOMEM; 1338ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 1339ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman ret = mmc_register_bus(); 1340e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman if (ret) 1341e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman goto destroy_workqueue; 1342e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman 1343e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman ret = mmc_register_host_class(); 1344e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman if (ret) 1345e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman goto unregister_bus; 1346e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman 1347e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman ret = sdio_register_bus(); 1348e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman if (ret) 1349e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman goto unregister_host_class; 1350e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman 1351e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman return 0; 1352e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman 1353e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossmanunregister_host_class: 1354e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman mmc_unregister_host_class(); 1355e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossmanunregister_bus: 1356e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman mmc_unregister_bus(); 1357e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossmandestroy_workqueue: 1358e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman destroy_workqueue(workqueue); 1359e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman 1360ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman return ret; 1361ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman} 1362ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 1363ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossmanstatic void __exit mmc_exit(void) 1364ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman{ 1365e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman sdio_unregister_bus(); 1366ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman mmc_unregister_host_class(); 1367ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman mmc_unregister_bus(); 1368ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman destroy_workqueue(workqueue); 1369ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman} 1370ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 137126074962e8f547b96614dbe248748ba2a1996ca3Nicolas Pitresubsys_initcall(mmc_init); 1372ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossmanmodule_exit(mmc_exit); 1373ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 13741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_LICENSE("GPL"); 1375