core.c revision 0d9ee5b2e9aac981fa063339daf04320eac610d1
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 6171d7d3d190fe77588269a8febf93cd739bd91eb3Matt FlemingEXPORT_SYMBOL(mmc_assume_removable); 62bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchingsmodule_param_named(removable, mmc_assume_removable, bool, 0644); 63bd68e0838fe85794b06892054772fa013a8d1986Ben HutchingsMODULE_PARM_DESC( 64bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings removable, 65bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings "MMC/SD cards are removable and may be removed during suspend"); 66bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings 67bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings/* 68ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman * Internal function. Schedule delayed work in the MMC work queue. 69ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman */ 70ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossmanstatic int mmc_schedule_delayed_work(struct delayed_work *work, 71ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman unsigned long delay) 72ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman{ 73ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman return queue_delayed_work(workqueue, work, delay); 74ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman} 75ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 76ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman/* 77ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman * Internal function. Flush all scheduled work from the MMC work queue. 78ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman */ 79ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossmanstatic void mmc_flush_scheduled_work(void) 80ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman{ 81ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman flush_workqueue(workqueue); 82ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman} 83ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 85fe10c6abea8bc83291a13e0580b3e4c355710b09Russell King * mmc_request_done - finish processing an MMC request 86fe10c6abea8bc83291a13e0580b3e4c355710b09Russell King * @host: MMC host which completed request 87fe10c6abea8bc83291a13e0580b3e4c355710b09Russell King * @mrq: MMC request which request 881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * MMC drivers should call this function when they have completed 90fe10c6abea8bc83291a13e0580b3e4c355710b09Russell King * their processing of a request. 911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsvoid mmc_request_done(struct mmc_host *host, struct mmc_request *mrq) 931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mmc_command *cmd = mrq->cmd; 95920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King int err = cmd->error; 96920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King 97af51715079e7fb6b290e1881d63d815dc4de5011David Brownell if (err && cmd->retries && mmc_host_is_spi(host)) { 98af51715079e7fb6b290e1881d63d815dc4de5011David Brownell if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND) 99af51715079e7fb6b290e1881d63d815dc4de5011David Brownell cmd->retries = 0; 100af51715079e7fb6b290e1881d63d815dc4de5011David Brownell } 101af51715079e7fb6b290e1881d63d815dc4de5011David Brownell 1021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (err && cmd->retries) { 103e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman pr_debug("%s: req failed (CMD%u): %d, retrying...\n", 104e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mmc_hostname(host), cmd->opcode, err); 105e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman 1061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cmd->retries--; 1071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cmd->error = 0; 1081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ops->request(host, mrq); 109e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman } else { 110af8350c756cb48a738474738f7bf8c0e572fa057Pierre Ossman led_trigger_event(host->led, LED_OFF); 111af8350c756cb48a738474738f7bf8c0e572fa057Pierre Ossman 112e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman pr_debug("%s: req done (CMD%u): %d: %08x %08x %08x %08x\n", 113e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mmc_hostname(host), cmd->opcode, err, 114e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman cmd->resp[0], cmd->resp[1], 115e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman cmd->resp[2], cmd->resp[3]); 116e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman 117e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman if (mrq->data) { 118e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman pr_debug("%s: %d bytes transferred: %d\n", 119e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mmc_hostname(host), 120e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->data->bytes_xfered, mrq->data->error); 121e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman } 122e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman 123e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman if (mrq->stop) { 124e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman pr_debug("%s: (CMD%u): %d: %08x %08x %08x %08x\n", 125e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mmc_hostname(host), mrq->stop->opcode, 126e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->stop->error, 127e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->stop->resp[0], mrq->stop->resp[1], 128e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->stop->resp[2], mrq->stop->resp[3]); 129e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman } 130e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman 131e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman if (mrq->done) 132e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->done(mrq); 1331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 1341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 1351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_request_done); 1371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 138393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunkstatic void 1391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmmc_start_request(struct mmc_host *host, struct mmc_request *mrq) 1401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 141976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman#ifdef CONFIG_MMC_DEBUG 142976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman unsigned int i, sz; 143a84756c5735f28bf000617f18734a9e94426386aPierre Ossman struct scatterlist *sg; 144976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman#endif 145976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman 146920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King pr_debug("%s: starting CMD%u arg %08x flags %08x\n", 147920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mmc_hostname(host), mrq->cmd->opcode, 148920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mrq->cmd->arg, mrq->cmd->flags); 1491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 150e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman if (mrq->data) { 151e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman pr_debug("%s: blksz %d blocks %d flags %08x " 152e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman "tsac %d ms nsac %d\n", 153e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mmc_hostname(host), mrq->data->blksz, 154e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->data->blocks, mrq->data->flags, 155ce252edd869ba1fee6a9a6f83e20f349d4c4d669Pierre Ossman mrq->data->timeout_ns / 1000000, 156e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->data->timeout_clks); 157e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman } 158e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman 159e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman if (mrq->stop) { 160e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman pr_debug("%s: CMD%u arg %08x flags %08x\n", 161e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mmc_hostname(host), mrq->stop->opcode, 162e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->stop->arg, mrq->stop->flags); 163e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman } 164e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman 165f22ee4edf63e7480511112d9965c71e07be3f8b7Pierre Ossman WARN_ON(!host->claimed); 1661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 167af8350c756cb48a738474738f7bf8c0e572fa057Pierre Ossman led_trigger_event(host->led, LED_FULL); 168af8350c756cb48a738474738f7bf8c0e572fa057Pierre Ossman 1691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->cmd->error = 0; 1701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->cmd->mrq = mrq; 1711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mrq->data) { 172fe4a3c7a20f14d86022a8132adbf6ddb98e7197cPierre Ossman BUG_ON(mrq->data->blksz > host->max_blk_size); 17355db890a838c7b37256241b1fc53d6344aa79cc0Pierre Ossman BUG_ON(mrq->data->blocks > host->max_blk_count); 17455db890a838c7b37256241b1fc53d6344aa79cc0Pierre Ossman BUG_ON(mrq->data->blocks * mrq->data->blksz > 17555db890a838c7b37256241b1fc53d6344aa79cc0Pierre Ossman host->max_req_size); 176fe4a3c7a20f14d86022a8132adbf6ddb98e7197cPierre Ossman 177976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman#ifdef CONFIG_MMC_DEBUG 178976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman sz = 0; 179a84756c5735f28bf000617f18734a9e94426386aPierre Ossman for_each_sg(mrq->data->sg, sg, mrq->data->sg_len, i) 180a84756c5735f28bf000617f18734a9e94426386aPierre Ossman sz += sg->length; 181976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman BUG_ON(sz != mrq->data->blocks * mrq->data->blksz); 182976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman#endif 183976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman 1841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->cmd->data = mrq->data; 1851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->data->error = 0; 1861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->data->mrq = mrq; 1871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mrq->stop) { 1881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->data->stop = mrq->stop; 1891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->stop->error = 0; 1901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->stop->mrq = mrq; 1911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 1921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 1931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ops->request(host, mrq); 1941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 1951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void mmc_wait_done(struct mmc_request *mrq) 1971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds complete(mrq->done_data); 1991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 2001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20167a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman/** 20267a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * mmc_wait_for_req - start a request and wait for completion 20367a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * @host: MMC host to start command 20467a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * @mrq: MMC request to start 20567a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * 20667a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * Start a new MMC custom command request for a host, and wait 20767a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * for the command to complete. Does not attempt to parse the 20867a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * response. 20967a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman */ 21067a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossmanvoid mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq) 2111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 2120afffc723c8041a005134099847ac2a2fd0316a0Ingo Molnar DECLARE_COMPLETION_ONSTACK(complete); 2131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->done_data = &complete; 2151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->done = mmc_wait_done; 2161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mmc_start_request(host, mrq); 2181da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds wait_for_completion(&complete); 2201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 2211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_wait_for_req); 2231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 2251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * mmc_wait_for_cmd - start a command and wait for completion 2261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @host: MMC host to start command 2271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @cmd: MMC command to start 2281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @retries: maximum number of retries 2291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 2301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Start a new MMC command for a host, and wait for the command 2311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * to complete. Return any error that occurred while the command 2321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * was executing. Do not attempt to parse the response. 2331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 2341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries) 2351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 2361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mmc_request mrq; 2371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 238d84075c8aed771d47d7ac6e96b098559da361c25Pierre Ossman WARN_ON(!host->claimed); 2391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memset(&mrq, 0, sizeof(struct mmc_request)); 2411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memset(cmd->resp, 0, sizeof(cmd->resp)); 2431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cmd->retries = retries; 2441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq.cmd = cmd; 2461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cmd->data = NULL; 2471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mmc_wait_for_req(host, &mrq); 2491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return cmd->error; 2511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 2521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_wait_for_cmd); 2541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 255335eadf2ef6a1122a720aea98e758e5d431da87dPierre Ossman/** 256d773d7255199a6c8934e197756f54a1115dd127bRussell King * mmc_set_data_timeout - set the timeout for a data command 257d773d7255199a6c8934e197756f54a1115dd127bRussell King * @data: data phase for command 258d773d7255199a6c8934e197756f54a1115dd127bRussell King * @card: the MMC card associated with the data transfer 25967a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * 26067a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * Computes the data timeout parameters according to the 26167a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * correct algorithm given the card type. 262d773d7255199a6c8934e197756f54a1115dd127bRussell King */ 263b146d26a61e0feab2f12a98ae83fd352830899c0Pierre Ossmanvoid mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card) 264d773d7255199a6c8934e197756f54a1115dd127bRussell King{ 265d773d7255199a6c8934e197756f54a1115dd127bRussell King unsigned int mult; 266d773d7255199a6c8934e197756f54a1115dd127bRussell King 267d773d7255199a6c8934e197756f54a1115dd127bRussell King /* 268e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman * SDIO cards only define an upper 1 s limit on access. 269e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman */ 270e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman if (mmc_card_sdio(card)) { 271e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman data->timeout_ns = 1000000000; 272e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman data->timeout_clks = 0; 273e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman return; 274e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman } 275e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman 276e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman /* 277d773d7255199a6c8934e197756f54a1115dd127bRussell King * SD cards use a 100 multiplier rather than 10 278d773d7255199a6c8934e197756f54a1115dd127bRussell King */ 279d773d7255199a6c8934e197756f54a1115dd127bRussell King mult = mmc_card_sd(card) ? 100 : 10; 280d773d7255199a6c8934e197756f54a1115dd127bRussell King 281d773d7255199a6c8934e197756f54a1115dd127bRussell King /* 282d773d7255199a6c8934e197756f54a1115dd127bRussell King * Scale up the multiplier (and therefore the timeout) by 283d773d7255199a6c8934e197756f54a1115dd127bRussell King * the r2w factor for writes. 284d773d7255199a6c8934e197756f54a1115dd127bRussell King */ 285b146d26a61e0feab2f12a98ae83fd352830899c0Pierre Ossman if (data->flags & MMC_DATA_WRITE) 286d773d7255199a6c8934e197756f54a1115dd127bRussell King mult <<= card->csd.r2w_factor; 287d773d7255199a6c8934e197756f54a1115dd127bRussell King 288d773d7255199a6c8934e197756f54a1115dd127bRussell King data->timeout_ns = card->csd.tacc_ns * mult; 289d773d7255199a6c8934e197756f54a1115dd127bRussell King data->timeout_clks = card->csd.tacc_clks * mult; 290d773d7255199a6c8934e197756f54a1115dd127bRussell King 291d773d7255199a6c8934e197756f54a1115dd127bRussell King /* 292d773d7255199a6c8934e197756f54a1115dd127bRussell King * SD cards also have an upper limit on the timeout. 293d773d7255199a6c8934e197756f54a1115dd127bRussell King */ 294d773d7255199a6c8934e197756f54a1115dd127bRussell King if (mmc_card_sd(card)) { 295d773d7255199a6c8934e197756f54a1115dd127bRussell King unsigned int timeout_us, limit_us; 296d773d7255199a6c8934e197756f54a1115dd127bRussell King 297d773d7255199a6c8934e197756f54a1115dd127bRussell King timeout_us = data->timeout_ns / 1000; 298d773d7255199a6c8934e197756f54a1115dd127bRussell King timeout_us += data->timeout_clks * 1000 / 299d773d7255199a6c8934e197756f54a1115dd127bRussell King (card->host->ios.clock / 1000); 300d773d7255199a6c8934e197756f54a1115dd127bRussell King 301b146d26a61e0feab2f12a98ae83fd352830899c0Pierre Ossman if (data->flags & MMC_DATA_WRITE) 302493890e75d98810a3470b4aae23be628ee5e9667Pierre Ossman /* 303493890e75d98810a3470b4aae23be628ee5e9667Pierre Ossman * The limit is really 250 ms, but that is 304493890e75d98810a3470b4aae23be628ee5e9667Pierre Ossman * insufficient for some crappy cards. 305493890e75d98810a3470b4aae23be628ee5e9667Pierre Ossman */ 306493890e75d98810a3470b4aae23be628ee5e9667Pierre Ossman limit_us = 300000; 307d773d7255199a6c8934e197756f54a1115dd127bRussell King else 308d773d7255199a6c8934e197756f54a1115dd127bRussell King limit_us = 100000; 309d773d7255199a6c8934e197756f54a1115dd127bRussell King 310fba68bd2dab1ac99af3c5a963ec9581cfa9f1725Philip Langdale /* 311fba68bd2dab1ac99af3c5a963ec9581cfa9f1725Philip Langdale * SDHC cards always use these fixed values. 312fba68bd2dab1ac99af3c5a963ec9581cfa9f1725Philip Langdale */ 313fba68bd2dab1ac99af3c5a963ec9581cfa9f1725Philip Langdale if (timeout_us > limit_us || mmc_card_blockaddr(card)) { 314d773d7255199a6c8934e197756f54a1115dd127bRussell King data->timeout_ns = limit_us * 1000; 315d773d7255199a6c8934e197756f54a1115dd127bRussell King data->timeout_clks = 0; 316d773d7255199a6c8934e197756f54a1115dd127bRussell King } 317d773d7255199a6c8934e197756f54a1115dd127bRussell King } 318c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees /* 319c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees * Some cards need very high timeouts if driven in SPI mode. 320c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees * The worst observed timeout was 900ms after writing a 321c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees * continuous stream of data until the internal logic 322c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees * overflowed. 323c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees */ 324c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees if (mmc_host_is_spi(card->host)) { 325c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees if (data->flags & MMC_DATA_WRITE) { 326c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees if (data->timeout_ns < 1000000000) 327c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees data->timeout_ns = 1000000000; /* 1s */ 328c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees } else { 329c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees if (data->timeout_ns < 100000000) 330c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees data->timeout_ns = 100000000; /* 100ms */ 331c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees } 332c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees } 333d773d7255199a6c8934e197756f54a1115dd127bRussell King} 334d773d7255199a6c8934e197756f54a1115dd127bRussell KingEXPORT_SYMBOL(mmc_set_data_timeout); 335d773d7255199a6c8934e197756f54a1115dd127bRussell King 3361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 337ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * mmc_align_data_size - pads a transfer size to a more optimal value 338ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * @card: the MMC card associated with the data transfer 339ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * @sz: original transfer size 340ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * 341ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * Pads the original data size with a number of extra bytes in 342ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * order to avoid controller bugs and/or performance hits 343ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * (e.g. some controllers revert to PIO for certain sizes). 344ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * 345ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * Returns the improved size, which might be unmodified. 346ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * 347ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * Note that this function is only relevant when issuing a 348ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * single scatter gather entry. 349ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman */ 350ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossmanunsigned int mmc_align_data_size(struct mmc_card *card, unsigned int sz) 351ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman{ 352ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman /* 353ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * FIXME: We don't have a system for the controller to tell 354ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * the core about its problems yet, so for now we just 32-bit 355ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * align the size. 356ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman */ 357ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman sz = ((sz + 3) / 4) * 4; 358ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman 359ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman return sz; 360ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman} 361ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre OssmanEXPORT_SYMBOL(mmc_align_data_size); 362ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman 363ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman/** 3648ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * mmc_host_enable - enable a host. 3658ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * @host: mmc host to enable 3668ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * 3678ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * Hosts that support power saving can use the 'enable' and 'disable' 3688ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * methods to exit and enter power saving states. For more information 3698ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * see comments for struct mmc_host_ops. 3708ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter */ 3718ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunterint mmc_host_enable(struct mmc_host *host) 3728ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 3738ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!(host->caps & MMC_CAP_DISABLE)) 3748ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 3758ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 3768ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->en_dis_recurs) 3778ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 3788ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 3798ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->nesting_cnt++) 3808ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 3818ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 3828ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter cancel_delayed_work_sync(&host->disable); 3838ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 3848ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->enabled) 3858ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 3868ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 3878ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->ops->enable) { 3888ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter int err; 3898ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 3908ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->en_dis_recurs = 1; 3918ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter err = host->ops->enable(host); 3928ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->en_dis_recurs = 0; 3938ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 3948ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (err) { 3958ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter pr_debug("%s: enable error %d\n", 3968ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_hostname(host), err); 3978ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return err; 3988ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } 3998ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } 4008ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->enabled = 1; 4018ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 4028ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 4038ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian HunterEXPORT_SYMBOL(mmc_host_enable); 4048ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4058ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunterstatic int mmc_host_do_disable(struct mmc_host *host, int lazy) 4068ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 4078ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->ops->disable) { 4088ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter int err; 4098ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4108ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->en_dis_recurs = 1; 4118ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter err = host->ops->disable(host, lazy); 4128ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->en_dis_recurs = 0; 4138ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4148ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (err < 0) { 4158ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter pr_debug("%s: disable error %d\n", 4168ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_hostname(host), err); 4178ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return err; 4188ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } 4198ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (err > 0) { 4208ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter unsigned long delay = msecs_to_jiffies(err); 4218ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4228ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_schedule_delayed_work(&host->disable, delay); 4238ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } 4248ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } 4258ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->enabled = 0; 4268ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 4278ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 4288ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4298ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter/** 4308ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * mmc_host_disable - disable a host. 4318ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * @host: mmc host to disable 4328ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * 4338ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * Hosts that support power saving can use the 'enable' and 'disable' 4348ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * methods to exit and enter power saving states. For more information 4358ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * see comments for struct mmc_host_ops. 4368ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter */ 4378ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunterint mmc_host_disable(struct mmc_host *host) 4388ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 4398ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter int err; 4408ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4418ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!(host->caps & MMC_CAP_DISABLE)) 4428ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 4438ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4448ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->en_dis_recurs) 4458ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 4468ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4478ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (--host->nesting_cnt) 4488ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 4498ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4508ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!host->enabled) 4518ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 4528ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4538ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter err = mmc_host_do_disable(host, 0); 4548ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return err; 4558ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 4568ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian HunterEXPORT_SYMBOL(mmc_host_disable); 4578ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 4588ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter/** 4592342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre * __mmc_claim_host - exclusively claim a host 4601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @host: mmc host to claim 4612342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre * @abort: whether or not the operation should be aborted 4621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 4632342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre * Claim a host for a set of operations. If @abort is non null and 4642342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre * dereference a non-zero value then this will return prematurely with 4652342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre * that non-zero value without acquiring the lock. Returns zero 4662342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre * with the lock held otherwise. 4671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 4682342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitreint __mmc_claim_host(struct mmc_host *host, atomic_t *abort) 4691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 4701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DECLARE_WAITQUEUE(wait, current); 4711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long flags; 4722342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre int stop; 4731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 474cf795bfb3ad4e2f8f6bb346aa8edb8272d4c70a2Pierre Ossman might_sleep(); 475cf795bfb3ad4e2f8f6bb346aa8edb8272d4c70a2Pierre Ossman 4761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds add_wait_queue(&host->wq, &wait); 4771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irqsave(&host->lock, flags); 4781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (1) { 4791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_current_state(TASK_UNINTERRUPTIBLE); 4802342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre stop = abort ? atomic_read(abort) : 0; 481319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter if (stop || !host->claimed || host->claimer == current) 4821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 4831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irqrestore(&host->lock, flags); 4841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds schedule(); 4851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irqsave(&host->lock, flags); 4861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 4871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_current_state(TASK_RUNNING); 488319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter if (!stop) { 4892342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre host->claimed = 1; 490319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter host->claimer = current; 491319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter host->claim_cnt += 1; 492319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter } else 4932342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre wake_up(&host->wq); 4941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irqrestore(&host->lock, flags); 4951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds remove_wait_queue(&host->wq, &wait); 4968ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!stop) 4978ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_host_enable(host); 4982342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre return stop; 4991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 5001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5012342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas PitreEXPORT_SYMBOL(__mmc_claim_host); 5021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 503319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter/** 504319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter * mmc_try_claim_host - try exclusively to claim a host 505319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter * @host: mmc host to claim 506319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter * 507319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter * Returns %1 if the host is claimed, %0 otherwise. 508319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter */ 509319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunterint mmc_try_claim_host(struct mmc_host *host) 5108ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 5118ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter int claimed_host = 0; 5128ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter unsigned long flags; 5138ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5148ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter spin_lock_irqsave(&host->lock, flags); 515319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter if (!host->claimed || host->claimer == current) { 5168ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->claimed = 1; 517319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter host->claimer = current; 518319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter host->claim_cnt += 1; 5198ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter claimed_host = 1; 5208ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } 5218ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter spin_unlock_irqrestore(&host->lock, flags); 5228ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return claimed_host; 5238ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 524319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian HunterEXPORT_SYMBOL(mmc_try_claim_host); 5258ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5268ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunterstatic void mmc_do_release_host(struct mmc_host *host) 5278ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 5288ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter unsigned long flags; 5298ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5308ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter spin_lock_irqsave(&host->lock, flags); 531319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter if (--host->claim_cnt) { 532319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter /* Release for nested claim */ 533319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter spin_unlock_irqrestore(&host->lock, flags); 534319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter } else { 535319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter host->claimed = 0; 536319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter host->claimer = NULL; 537319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter spin_unlock_irqrestore(&host->lock, flags); 538319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter wake_up(&host->wq); 539319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter } 5408ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 5418ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5428ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Huntervoid mmc_host_deeper_disable(struct work_struct *work) 5438ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 5448ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter struct mmc_host *host = 5458ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter container_of(work, struct mmc_host, disable.work); 5468ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5478ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter /* If the host is claimed then we do not want to disable it anymore */ 5488ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!mmc_try_claim_host(host)) 5498ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return; 5508ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_host_do_disable(host, 1); 5518ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_do_release_host(host); 5528ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 5538ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5548ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter/** 5558ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * mmc_host_lazy_disable - lazily disable a host. 5568ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * @host: mmc host to disable 5578ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * 5588ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * Hosts that support power saving can use the 'enable' and 'disable' 5598ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * methods to exit and enter power saving states. For more information 5608ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * see comments for struct mmc_host_ops. 5618ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter */ 5628ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunterint mmc_host_lazy_disable(struct mmc_host *host) 5638ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 5648ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!(host->caps & MMC_CAP_DISABLE)) 5658ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5668ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5678ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->en_dis_recurs) 5688ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5698ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5708ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (--host->nesting_cnt) 5718ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5728ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5738ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!host->enabled) 5748ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5758ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5768ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->disable_delay) { 5778ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_schedule_delayed_work(&host->disable, 5788ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter msecs_to_jiffies(host->disable_delay)); 5798ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5808ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } else 5818ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return mmc_host_do_disable(host, 1); 5828ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 5838ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian HunterEXPORT_SYMBOL(mmc_host_lazy_disable); 5848ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 5861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * mmc_release_host - release a host 5871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @host: mmc host to release 5881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 5891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Release a MMC host, allowing others to claim the host 5901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * for their operations. 5911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 5921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsvoid mmc_release_host(struct mmc_host *host) 5931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 594d84075c8aed771d47d7ac6e96b098559da361c25Pierre Ossman WARN_ON(!host->claimed); 5951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5968ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_host_lazy_disable(host); 5971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 5988ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_do_release_host(host); 5991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 6001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_release_host); 6021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6037ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman/* 6047ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Internal function that does the actual ios call to the host driver, 6057ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * optionally printing some debug output. 6067ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman */ 607920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell Kingstatic inline void mmc_set_ios(struct mmc_host *host) 608920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King{ 609920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King struct mmc_ios *ios = &host->ios; 610920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King 611cd9277c011a99769fa371521b460ed57f6d280b1Pierre Ossman pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u " 612cd9277c011a99769fa371521b460ed57f6d280b1Pierre Ossman "width %u timing %u\n", 613920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mmc_hostname(host), ios->clock, ios->bus_mode, 614920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King ios->power_mode, ios->chip_select, ios->vdd, 615cd9277c011a99769fa371521b460ed57f6d280b1Pierre Ossman ios->bus_width, ios->timing); 616fba68bd2dab1ac99af3c5a963ec9581cfa9f1725Philip Langdale 617920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King host->ops->set_ios(host, ios); 618920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King} 619920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King 6207ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman/* 6217ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Control chip select pin on a host. 6227ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman */ 623da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossmanvoid mmc_set_chip_select(struct mmc_host *host, int mode) 6241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 625da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossman host->ios.chip_select = mode; 626da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossman mmc_set_ios(host); 6271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 6281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 6307ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Sets the host clock to the highest possible frequency that 6317ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * is below "hz". 6327ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman */ 6337ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossmanvoid mmc_set_clock(struct mmc_host *host, unsigned int hz) 6347ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman{ 6357ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman WARN_ON(hz < host->f_min); 6367ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 6377ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman if (hz > host->f_max) 6387ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman hz = host->f_max; 6397ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 6407ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->ios.clock = hz; 6417ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_set_ios(host); 6427ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman} 6437ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 6447ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman/* 6457ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Change the bus mode (open drain/push-pull) of a host. 6467ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman */ 6477ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossmanvoid mmc_set_bus_mode(struct mmc_host *host, unsigned int mode) 6487ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman{ 6497ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->ios.bus_mode = mode; 6507ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_set_ios(host); 6517ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman} 6527ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 6537ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman/* 6540f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter * Change data bus width and DDR mode of a host. 6557ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman */ 65649e3b5a44f8abd33c8693edc575c6d06a210d778Adrian Huntervoid mmc_set_bus_width_ddr(struct mmc_host *host, unsigned int width, 65749e3b5a44f8abd33c8693edc575c6d06a210d778Adrian Hunter unsigned int ddr) 6587ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman{ 6597ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->ios.bus_width = width; 66049e3b5a44f8abd33c8693edc575c6d06a210d778Adrian Hunter host->ios.ddr = ddr; 6617ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_set_ios(host); 6627ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman} 6637ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 6640f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter/* 6650f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter * Change data bus width of a host. 6660f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter */ 6670f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Huntervoid mmc_set_bus_width(struct mmc_host *host, unsigned int width) 6680f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter{ 66949e3b5a44f8abd33c8693edc575c6d06a210d778Adrian Hunter mmc_set_bus_width_ddr(host, width, MMC_SDR_MODE); 6700f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter} 6710f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter 67286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov/** 67386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * mmc_vdd_to_ocrbitnum - Convert a voltage to the OCR bit number 67486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * @vdd: voltage (mV) 67586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * @low_bits: prefer low bits in boundary cases 67686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * 67786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * This function returns the OCR bit number according to the provided @vdd 67886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * value. If conversion is not possible a negative errno value returned. 67986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * 68086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * Depending on the @low_bits flag the function prefers low or high OCR bits 68186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * on boundary voltages. For example, 68286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * with @low_bits = true, 3300 mV translates to ilog2(MMC_VDD_32_33); 68386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * with @low_bits = false, 3300 mV translates to ilog2(MMC_VDD_33_34); 68486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * 68586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * Any value in the [1951:1999] range translates to the ilog2(MMC_VDD_20_21). 68686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov */ 68786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsovstatic int mmc_vdd_to_ocrbitnum(int vdd, bool low_bits) 68886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov{ 68986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov const int max_bit = ilog2(MMC_VDD_35_36); 69086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov int bit; 69186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 69286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (vdd < 1650 || vdd > 3600) 69386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return -EINVAL; 69486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 69586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (vdd >= 1650 && vdd <= 1950) 69686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return ilog2(MMC_VDD_165_195); 69786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 69886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (low_bits) 69986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov vdd -= 1; 70086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 70186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov /* Base 2000 mV, step 100 mV, bit's base 8. */ 70286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov bit = (vdd - 2000) / 100 + 8; 70386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (bit > max_bit) 70486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return max_bit; 70586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return bit; 70686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov} 70786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 70886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov/** 70986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * mmc_vddrange_to_ocrmask - Convert a voltage range to the OCR mask 71086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * @vdd_min: minimum voltage value (mV) 71186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * @vdd_max: maximum voltage value (mV) 71286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * 71386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * This function returns the OCR mask bits according to the provided @vdd_min 71486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * and @vdd_max values. If conversion is not possible the function returns 0. 71586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * 71686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * Notes wrt boundary cases: 71786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * This function sets the OCR bits for all boundary voltages, for example 71886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * [3300:3400] range is translated to MMC_VDD_32_33 | MMC_VDD_33_34 | 71986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * MMC_VDD_34_35 mask. 72086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov */ 72186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsovu32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max) 72286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov{ 72386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov u32 mask = 0; 72486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 72586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (vdd_max < vdd_min) 72686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return 0; 72786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 72886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov /* Prefer high bits for the boundary vdd_max values. */ 72986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov vdd_max = mmc_vdd_to_ocrbitnum(vdd_max, false); 73086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (vdd_max < 0) 73186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return 0; 73286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 73386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov /* Prefer low bits for the boundary vdd_min values. */ 73486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov vdd_min = mmc_vdd_to_ocrbitnum(vdd_min, true); 73586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (vdd_min < 0) 73686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return 0; 73786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 73886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov /* Fill the mask, from max bit to min bit. */ 73986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov while (vdd_max >= vdd_min) 74086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov mask |= 1 << vdd_max--; 74186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 74286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return mask; 74386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov} 74486e8286a0e48663e1e86a5884b30a6d05de2993aAnton VorontsovEXPORT_SYMBOL(mmc_vddrange_to_ocrmask); 74586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 7465c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell#ifdef CONFIG_REGULATOR 7475c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 7485c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell/** 7495c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * mmc_regulator_get_ocrmask - return mask of supported voltages 7505c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * @supply: regulator to use 7515c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * 7525c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * This returns either a negative errno, or a mask of voltages that 7535c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * can be provided to MMC/SD/SDIO devices using the specified voltage 7545c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * regulator. This would normally be called before registering the 7555c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * MMC host adapter. 7565c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell */ 7575c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownellint mmc_regulator_get_ocrmask(struct regulator *supply) 7585c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell{ 7595c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int result = 0; 7605c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int count; 7615c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int i; 7625c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 7635c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell count = regulator_count_voltages(supply); 7645c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell if (count < 0) 7655c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell return count; 7665c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 7675c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell for (i = 0; i < count; i++) { 7685c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int vdd_uV; 7695c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int vdd_mV; 7705c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 7715c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell vdd_uV = regulator_list_voltage(supply, i); 7725c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell if (vdd_uV <= 0) 7735c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell continue; 7745c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 7755c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell vdd_mV = vdd_uV / 1000; 7765c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell result |= mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV); 7775c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell } 7785c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 7795c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell return result; 7805c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell} 7815c13941acc513669c7d07b28789c3f9ba66ddddfDavid BrownellEXPORT_SYMBOL(mmc_regulator_get_ocrmask); 7825c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 7835c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell/** 7845c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * mmc_regulator_set_ocr - set regulator to match host->ios voltage 78599fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij * @mmc: the host to regulate 7865c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * @supply: regulator to use 78799fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij * @vdd_bit: zero for power off, else a bit number (host->ios.vdd) 7885c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * 7895c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * Returns zero on success, else negative errno. 7905c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * 7915c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * MMC host drivers may use this to enable or disable a regulator using 7925c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * a particular supply voltage. This would normally be called from the 7935c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * set_ios() method. 7945c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell */ 79599fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleijint mmc_regulator_set_ocr(struct mmc_host *mmc, 79699fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij struct regulator *supply, 79799fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij unsigned short vdd_bit) 7985c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell{ 7995c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int result = 0; 8005c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int min_uV, max_uV; 8015c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 8025c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell if (vdd_bit) { 8035c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int tmp; 8045c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int voltage; 8055c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 8065c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell /* REVISIT mmc_vddrange_to_ocrmask() may have set some 8075c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * bits this regulator doesn't quite support ... don't 8085c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * be too picky, most cards and regulators are OK with 8095c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * a 0.1V range goof (it's a small error percentage). 8105c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell */ 8115c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell tmp = vdd_bit - ilog2(MMC_VDD_165_195); 8125c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell if (tmp == 0) { 8135c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell min_uV = 1650 * 1000; 8145c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell max_uV = 1950 * 1000; 8155c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell } else { 8165c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell min_uV = 1900 * 1000 + tmp * 100 * 1000; 8175c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell max_uV = min_uV + 100 * 1000; 8185c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell } 8195c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 8205c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell /* avoid needless changes to this voltage; the regulator 8215c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * might not allow this operation 8225c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell */ 8235c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell voltage = regulator_get_voltage(supply); 8245c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell if (voltage < 0) 8255c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell result = voltage; 8265c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell else if (voltage < min_uV || voltage > max_uV) 8275c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell result = regulator_set_voltage(supply, min_uV, max_uV); 8285c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell else 8295c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell result = 0; 8305c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 83199fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij if (result == 0 && !mmc->regulator_enabled) { 8325c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell result = regulator_enable(supply); 83399fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij if (!result) 83499fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij mmc->regulator_enabled = true; 83599fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij } 83699fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij } else if (mmc->regulator_enabled) { 8375c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell result = regulator_disable(supply); 83899fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij if (result == 0) 83999fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij mmc->regulator_enabled = false; 8405c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell } 8415c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 84299fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij if (result) 84399fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij dev_err(mmc_dev(mmc), 84499fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij "could not set regulator OCR (%d)\n", result); 8455c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell return result; 8465c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell} 8475c13941acc513669c7d07b28789c3f9ba66ddddfDavid BrownellEXPORT_SYMBOL(mmc_regulator_set_ocr); 8485c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 84999fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij#endif /* CONFIG_REGULATOR */ 8505c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 8517ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman/* 8521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Mask off any voltages we don't support and select 8531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the lowest voltage 8541da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 8557ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossmanu32 mmc_select_voltage(struct mmc_host *host, u32 ocr) 8561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 8571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int bit; 8581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ocr &= host->ocr_avail; 8601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bit = ffs(ocr); 8621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (bit) { 8631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bit -= 1; 8641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 86563ef731aa6a81e286de78dcc92241d123424ed39Timo Teras ocr &= 3 << bit; 8661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.vdd = bit; 868920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mmc_set_ios(host); 8691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 870f6e10b865c3ea56bdaa8c6ecfee313b997900dbbDavid Brownell pr_warning("%s: host doesn't support card's voltages\n", 871f6e10b865c3ea56bdaa8c6ecfee313b997900dbbDavid Brownell mmc_hostname(host)); 8721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ocr = 0; 8731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 8741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return ocr; 8761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 8771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 8781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 8797ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Select timing parameters for host. 880b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman */ 8817ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossmanvoid mmc_set_timing(struct mmc_host *host, unsigned int timing) 882b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman{ 8837ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->ios.timing = timing; 8847ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_set_ios(host); 885b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman} 886b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman 887b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman/* 88845f8245b972e360c19aec9032e2a2033b8ac3719Russell King * Apply power to the MMC stack. This is a two-stage process. 88945f8245b972e360c19aec9032e2a2033b8ac3719Russell King * First, we enable power to the card without the clock running. 89045f8245b972e360c19aec9032e2a2033b8ac3719Russell King * We then wait a bit for the power to stabilise. Finally, 89145f8245b972e360c19aec9032e2a2033b8ac3719Russell King * enable the bus drivers and clock to the card. 89245f8245b972e360c19aec9032e2a2033b8ac3719Russell King * 89345f8245b972e360c19aec9032e2a2033b8ac3719Russell King * We must _NOT_ enable the clock prior to power stablising. 89445f8245b972e360c19aec9032e2a2033b8ac3719Russell King * 89545f8245b972e360c19aec9032e2a2033b8ac3719Russell King * If a host does all the power sequencing itself, ignore the 89645f8245b972e360c19aec9032e2a2033b8ac3719Russell King * initial MMC_POWER_UP stage. 8971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 8981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void mmc_power_up(struct mmc_host *host) 8991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 900500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao int bit; 901500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao 902500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao /* If ocr is set, we use it */ 903500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao if (host->ocr) 904500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao bit = ffs(host->ocr) - 1; 905500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao else 906500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao bit = fls(host->ocr_avail) - 1; 9071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.vdd = bit; 909af51715079e7fb6b290e1881d63d815dc4de5011David Brownell if (mmc_host_is_spi(host)) { 910af51715079e7fb6b290e1881d63d815dc4de5011David Brownell host->ios.chip_select = MMC_CS_HIGH; 911af51715079e7fb6b290e1881d63d815dc4de5011David Brownell host->ios.bus_mode = MMC_BUSMODE_PUSHPULL; 912af51715079e7fb6b290e1881d63d815dc4de5011David Brownell } else { 913af51715079e7fb6b290e1881d63d815dc4de5011David Brownell host->ios.chip_select = MMC_CS_DONTCARE; 914af51715079e7fb6b290e1881d63d815dc4de5011David Brownell host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN; 915af51715079e7fb6b290e1881d63d815dc4de5011David Brownell } 9161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.power_mode = MMC_POWER_UP; 917f218278a456b3c272b480443c89004c3d2a49f18Pierre Ossman host->ios.bus_width = MMC_BUS_WIDTH_1; 918cd9277c011a99769fa371521b460ed57f6d280b1Pierre Ossman host->ios.timing = MMC_TIMING_LEGACY; 919920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mmc_set_ios(host); 9201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 921f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman /* 922f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman * This delay should be sufficient to allow the power supply 923f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman * to reach the minimum voltage. 924f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman */ 92579bccc5aefb4e64e651abe04f78c3e6bf8acd6f0José M. Fernández mmc_delay(10); 9261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 92788ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch host->ios.clock = host->f_init; 9288dfd0374be84793360db7fff2e635d2cd3bbcb21Sascha Hauer 9291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.power_mode = MMC_POWER_ON; 930920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mmc_set_ios(host); 9311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 932f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman /* 933f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman * This delay must be at least 74 clock sizes, or 1 ms, or the 934f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman * time required to reach a stable voltage. 935f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman */ 93679bccc5aefb4e64e651abe04f78c3e6bf8acd6f0José M. Fernández mmc_delay(10); 9371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 9381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void mmc_power_off(struct mmc_host *host) 9401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 9411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.clock = 0; 9421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.vdd = 0; 943af51715079e7fb6b290e1881d63d815dc4de5011David Brownell if (!mmc_host_is_spi(host)) { 944af51715079e7fb6b290e1881d63d815dc4de5011David Brownell host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN; 945af51715079e7fb6b290e1881d63d815dc4de5011David Brownell host->ios.chip_select = MMC_CS_DONTCARE; 946af51715079e7fb6b290e1881d63d815dc4de5011David Brownell } 9471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.power_mode = MMC_POWER_OFF; 948f218278a456b3c272b480443c89004c3d2a49f18Pierre Ossman host->ios.bus_width = MMC_BUS_WIDTH_1; 949cd9277c011a99769fa371521b460ed57f6d280b1Pierre Ossman host->ios.timing = MMC_TIMING_LEGACY; 950920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mmc_set_ios(host); 9511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 9521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 9531da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 954393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk * Cleanup when the last reference to the bus operator is dropped. 955393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk */ 956261172fd1b23769bc7632047e2cb826c9b8b1a50Adrian Bunkstatic void __mmc_release_bus(struct mmc_host *host) 957393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk{ 958393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk BUG_ON(!host); 959393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk BUG_ON(host->bus_refs); 960393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk BUG_ON(!host->bus_dead); 961393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk 962393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk host->bus_ops = NULL; 963393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk} 964393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk 965393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk/* 966393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk * Increase reference count of bus operator 967393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk */ 968393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunkstatic inline void mmc_bus_get(struct mmc_host *host) 969393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk{ 970393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk unsigned long flags; 971393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk 972393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk spin_lock_irqsave(&host->lock, flags); 973393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk host->bus_refs++; 974393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk spin_unlock_irqrestore(&host->lock, flags); 975393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk} 976393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk 977393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk/* 978393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk * Decrease reference count of bus operator and free it if 979393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk * it is the last reference. 980393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk */ 981393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunkstatic inline void mmc_bus_put(struct mmc_host *host) 982393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk{ 983393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk unsigned long flags; 984393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk 985393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk spin_lock_irqsave(&host->lock, flags); 986393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk host->bus_refs--; 987393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk if ((host->bus_refs == 0) && host->bus_ops) 988393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk __mmc_release_bus(host); 989393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk spin_unlock_irqrestore(&host->lock, flags); 990393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk} 991393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk 992393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk/* 9937ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Assign a mmc bus handler to a host. Only one bus handler may control a 9947ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * host at any given time. 9951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 9967ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossmanvoid mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops) 9971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 9987ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman unsigned long flags; 999e45a1bd20fa5b920901879e85cdf5eda21f78d7cPhilip Langdale 10007ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman BUG_ON(!host); 10017ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman BUG_ON(!ops); 1002b855885e3b60cf6f9452848712a62517b94583ebPierre Ossman 1003d84075c8aed771d47d7ac6e96b098559da361c25Pierre Ossman WARN_ON(!host->claimed); 1004bce40a36de574376f41f1ff3c4d212a7da2a3c90Philip Langdale 10057ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman spin_lock_irqsave(&host->lock, flags); 1006bce40a36de574376f41f1ff3c4d212a7da2a3c90Philip Langdale 10077ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman BUG_ON(host->bus_ops); 10087ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman BUG_ON(host->bus_refs); 1009b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman 10107ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->bus_ops = ops; 10117ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->bus_refs = 1; 10127ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->bus_dead = 0; 1013b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman 10147ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman spin_unlock_irqrestore(&host->lock, flags); 1015b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman} 1016b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman 10177ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman/* 10187ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Remove the current bus handler from a host. Assumes that there are 10197ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * no interesting cards left, so the bus is powered down. 10207ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman */ 10217ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossmanvoid mmc_detach_bus(struct mmc_host *host) 10227ccd266e676a3f0c6f8f897f58b684cac3dd1650Pierre Ossman{ 10237ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman unsigned long flags; 10247ccd266e676a3f0c6f8f897f58b684cac3dd1650Pierre Ossman 10257ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman BUG_ON(!host); 10267ccd266e676a3f0c6f8f897f58b684cac3dd1650Pierre Ossman 1027d84075c8aed771d47d7ac6e96b098559da361c25Pierre Ossman WARN_ON(!host->claimed); 1028d84075c8aed771d47d7ac6e96b098559da361c25Pierre Ossman WARN_ON(!host->bus_ops); 1029cd9277c011a99769fa371521b460ed57f6d280b1Pierre Ossman 10307ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman spin_lock_irqsave(&host->lock, flags); 10317ccd266e676a3f0c6f8f897f58b684cac3dd1650Pierre Ossman 10327ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->bus_dead = 1; 10337ccd266e676a3f0c6f8f897f58b684cac3dd1650Pierre Ossman 10347ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman spin_unlock_irqrestore(&host->lock, flags); 10351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10367ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_power_off(host); 10371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10387ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_put(host); 10391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 10401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 10421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * mmc_detect_change - process change of state on a MMC socket 10431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @host: host which changed state. 10448dc003359cc3996abad9e53a7b2280b272610283Richard Purdie * @delay: optional delay to wait before detection (jiffies) 10451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 104667a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * MMC drivers should call this when they detect a card has been 104767a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * inserted or removed. The MMC layer will confirm that any 104867a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * present card is still functional, and initialize any newly 104967a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * inserted. 10501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 10518dc003359cc3996abad9e53a7b2280b272610283Richard Purdievoid mmc_detect_change(struct mmc_host *host, unsigned long delay) 10521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 10533b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman#ifdef CONFIG_MMC_DEBUG 10541efd48b3ae8f89a1d04f1e36be96764d7bf43ae9Pierre Ossman unsigned long flags; 105501f41ec7b36e14da18a4e162ef697ae358f36e37Andrew Morton spin_lock_irqsave(&host->lock, flags); 1056d84075c8aed771d47d7ac6e96b098559da361c25Pierre Ossman WARN_ON(host->removed); 105701f41ec7b36e14da18a4e162ef697ae358f36e37Andrew Morton spin_unlock_irqrestore(&host->lock, flags); 10583b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman#endif 10593b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman 1060c4028958b6ecad064b1a6303a6a5906d4fe48d73David Howells mmc_schedule_delayed_work(&host->detect, delay); 10611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 10621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_detect_change); 10641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1065dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Huntervoid mmc_init_erase(struct mmc_card *card) 1066dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1067dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int sz; 1068dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1069dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (is_power_of_2(card->erase_size)) 1070dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->erase_shift = ffs(card->erase_size) - 1; 1071dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1072dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->erase_shift = 0; 1073dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1074dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* 1075dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * It is possible to erase an arbitrarily large area of an SD or MMC 1076dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * card. That is not desirable because it can take a long time 1077dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * (minutes) potentially delaying more important I/O, and also the 1078dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * timeout calculations become increasingly hugely over-estimated. 1079dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * Consequently, 'pref_erase' is defined as a guide to limit erases 1080dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * to that size and alignment. 1081dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * 1082dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * For SD cards that define Allocation Unit size, limit erases to one 1083dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * Allocation Unit at a time. For MMC cards that define High Capacity 1084dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * Erase Size, whether it is switched on or not, limit to that size. 1085dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * Otherwise just have a stab at a good value. For modern cards it 1086dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * will end up being 4MiB. Note that if the value is too small, it 1087dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * can end up taking longer to erase. 1088dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter */ 1089dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (mmc_card_sd(card) && card->ssr.au) { 1090dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->pref_erase = card->ssr.au; 1091dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->erase_shift = ffs(card->ssr.au) - 1; 1092dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } else if (card->ext_csd.hc_erase_size) { 1093dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->pref_erase = card->ext_csd.hc_erase_size; 1094dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } else { 1095dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter sz = (card->csd.capacity << (card->csd.read_blkbits - 9)) >> 11; 1096dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (sz < 128) 1097dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->pref_erase = 512 * 1024 / 512; 1098dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else if (sz < 512) 1099dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->pref_erase = 1024 * 1024 / 512; 1100dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else if (sz < 1024) 1101dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->pref_erase = 2 * 1024 * 1024 / 512; 1102dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1103dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->pref_erase = 4 * 1024 * 1024 / 512; 1104dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (card->pref_erase < card->erase_size) 1105dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->pref_erase = card->erase_size; 1106dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else { 1107dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter sz = card->pref_erase % card->erase_size; 1108dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (sz) 1109dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->pref_erase += card->erase_size - sz; 1110dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1111dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1112dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1113dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1114dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunterstatic void mmc_set_mmc_erase_timeout(struct mmc_card *card, 1115dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter struct mmc_command *cmd, 1116dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int arg, unsigned int qty) 1117dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1118dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int erase_timeout; 1119dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1120dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (card->ext_csd.erase_group_def & 1) { 1121dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* High Capacity Erase Group Size uses HC timeouts */ 1122dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (arg == MMC_TRIM_ARG) 1123dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter erase_timeout = card->ext_csd.trim_timeout; 1124dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1125dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter erase_timeout = card->ext_csd.hc_erase_timeout; 1126dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } else { 1127dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* CSD Erase Group Size uses write timeout */ 1128dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int mult = (10 << card->csd.r2w_factor); 1129dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int timeout_clks = card->csd.tacc_clks * mult; 1130dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int timeout_us; 1131dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1132dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* Avoid overflow: e.g. tacc_ns=80000000 mult=1280 */ 1133dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (card->csd.tacc_ns < 1000000) 1134dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter timeout_us = (card->csd.tacc_ns * mult) / 1000; 1135dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1136dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter timeout_us = (card->csd.tacc_ns / 1000) * mult; 1137dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1138dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* 1139dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * ios.clock is only a target. The real clock rate might be 1140dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * less but not that much less, so fudge it by multiplying by 2. 1141dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter */ 1142dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter timeout_clks <<= 1; 1143dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter timeout_us += (timeout_clks * 1000) / 1144dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter (card->host->ios.clock / 1000); 1145dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1146dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter erase_timeout = timeout_us / 1000; 1147dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1148dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* 1149dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * Theoretically, the calculation could underflow so round up 1150dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * to 1ms in that case. 1151dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter */ 1152dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (!erase_timeout) 1153dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter erase_timeout = 1; 1154dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1155dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1156dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* Multiplier for secure operations */ 1157dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (arg & MMC_SECURE_ARGS) { 1158dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (arg == MMC_SECURE_ERASE_ARG) 1159dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter erase_timeout *= card->ext_csd.sec_erase_mult; 1160dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1161dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter erase_timeout *= card->ext_csd.sec_trim_mult; 1162dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1163dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1164dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter erase_timeout *= qty; 1165dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1166dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* 1167dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * Ensure at least a 1 second timeout for SPI as per 1168dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * 'mmc_set_data_timeout()' 1169dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter */ 1170dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (mmc_host_is_spi(card->host) && erase_timeout < 1000) 1171dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter erase_timeout = 1000; 1172dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1173dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd->erase_timeout = erase_timeout; 1174dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1175dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1176dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunterstatic void mmc_set_sd_erase_timeout(struct mmc_card *card, 1177dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter struct mmc_command *cmd, unsigned int arg, 1178dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int qty) 1179dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1180dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (card->ssr.erase_timeout) { 1181dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* Erase timeout specified in SD Status Register (SSR) */ 1182dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd->erase_timeout = card->ssr.erase_timeout * qty + 1183dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->ssr.erase_offset; 1184dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } else { 1185dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* 1186dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * Erase timeout not specified in SD Status Register (SSR) so 1187dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * use 250ms per write block. 1188dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter */ 1189dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd->erase_timeout = 250 * qty; 1190dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1191dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1192dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* Must not be less than 1 second */ 1193dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (cmd->erase_timeout < 1000) 1194dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd->erase_timeout = 1000; 1195dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1196dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1197dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunterstatic void mmc_set_erase_timeout(struct mmc_card *card, 1198dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter struct mmc_command *cmd, unsigned int arg, 1199dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int qty) 1200dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1201dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (mmc_card_sd(card)) 1202dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter mmc_set_sd_erase_timeout(card, cmd, arg, qty); 1203dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1204dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter mmc_set_mmc_erase_timeout(card, cmd, arg, qty); 1205dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1206dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1207dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunterstatic int mmc_do_erase(struct mmc_card *card, unsigned int from, 1208dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int to, unsigned int arg) 1209dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1210dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter struct mmc_command cmd; 1211dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int qty = 0; 1212dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter int err; 1213dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1214dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* 1215dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * qty is used to calculate the erase timeout which depends on how many 1216dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * erase groups (or allocation units in SD terminology) are affected. 1217dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * We count erasing part of an erase group as one erase group. 1218dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * For SD, the allocation units are always a power of 2. For MMC, the 1219dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * erase group size is almost certainly also power of 2, but it does not 1220dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * seem to insist on that in the JEDEC standard, so we fall back to 1221dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * division in that case. SD may not specify an allocation unit size, 1222dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * in which case the timeout is based on the number of write blocks. 1223dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * 1224dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * Note that the timeout for secure trim 2 will only be correct if the 1225dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * number of erase groups specified is the same as the total of all 1226dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * preceding secure trim 1 commands. Since the power may have been 1227dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * lost since the secure trim 1 commands occurred, it is generally 1228dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * impossible to calculate the secure trim 2 timeout correctly. 1229dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter */ 1230dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (card->erase_shift) 1231dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter qty += ((to >> card->erase_shift) - 1232dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter (from >> card->erase_shift)) + 1; 1233dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else if (mmc_card_sd(card)) 1234dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter qty += to - from + 1; 1235dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1236dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter qty += ((to / card->erase_size) - 1237dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter (from / card->erase_size)) + 1; 1238dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1239dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (!mmc_card_blockaddr(card)) { 1240dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter from <<= 9; 1241dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter to <<= 9; 1242dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1243dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1244dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter memset(&cmd, 0, sizeof(struct mmc_command)); 1245dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (mmc_card_sd(card)) 1246dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.opcode = SD_ERASE_WR_BLK_START; 1247dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1248dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.opcode = MMC_ERASE_GROUP_START; 1249dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.arg = from; 1250dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 1251dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err = mmc_wait_for_cmd(card->host, &cmd, 0); 1252dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (err) { 1253dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter printk(KERN_ERR "mmc_erase: group start error %d, " 1254dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter "status %#x\n", err, cmd.resp[0]); 1255dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err = -EINVAL; 1256dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter goto out; 1257dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1258dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1259dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter memset(&cmd, 0, sizeof(struct mmc_command)); 1260dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (mmc_card_sd(card)) 1261dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.opcode = SD_ERASE_WR_BLK_END; 1262dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1263dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.opcode = MMC_ERASE_GROUP_END; 1264dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.arg = to; 1265dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 1266dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err = mmc_wait_for_cmd(card->host, &cmd, 0); 1267dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (err) { 1268dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter printk(KERN_ERR "mmc_erase: group end error %d, status %#x\n", 1269dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err, cmd.resp[0]); 1270dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err = -EINVAL; 1271dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter goto out; 1272dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1273dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1274dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter memset(&cmd, 0, sizeof(struct mmc_command)); 1275dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.opcode = MMC_ERASE; 1276dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.arg = arg; 1277dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC; 1278dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter mmc_set_erase_timeout(card, &cmd, arg, qty); 1279dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err = mmc_wait_for_cmd(card->host, &cmd, 0); 1280dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (err) { 1281dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter printk(KERN_ERR "mmc_erase: erase error %d, status %#x\n", 1282dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err, cmd.resp[0]); 1283dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err = -EIO; 1284dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter goto out; 1285dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1286dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1287dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (mmc_host_is_spi(card->host)) 1288dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter goto out; 1289dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1290dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter do { 1291dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter memset(&cmd, 0, sizeof(struct mmc_command)); 1292dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.opcode = MMC_SEND_STATUS; 1293dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.arg = card->rca << 16; 1294dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 1295dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* Do not retry else we can't see errors */ 1296dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err = mmc_wait_for_cmd(card->host, &cmd, 0); 1297dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (err || (cmd.resp[0] & 0xFDF92000)) { 1298dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter printk(KERN_ERR "error %d requesting status %#x\n", 1299dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err, cmd.resp[0]); 1300dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err = -EIO; 1301dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter goto out; 1302dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1303dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } while (!(cmd.resp[0] & R1_READY_FOR_DATA) || 1304dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter R1_CURRENT_STATE(cmd.resp[0]) == 7); 1305dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunterout: 1306dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return err; 1307dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1308dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1309dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter/** 1310dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * mmc_erase - erase sectors. 1311dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * @card: card to erase 1312dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * @from: first sector to erase 1313dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * @nr: number of sectors to erase 1314dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * @arg: erase command argument (SD supports only %MMC_ERASE_ARG) 1315dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * 1316dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * Caller must claim host before calling this function. 1317dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter */ 1318dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunterint mmc_erase(struct mmc_card *card, unsigned int from, unsigned int nr, 1319dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int arg) 1320dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1321dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int rem, to = from + nr; 1322dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1323dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (!(card->host->caps & MMC_CAP_ERASE) || 1324dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter !(card->csd.cmdclass & CCC_ERASE)) 1325dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return -EOPNOTSUPP; 1326dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1327dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (!card->erase_size) 1328dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return -EOPNOTSUPP; 1329dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1330dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (mmc_card_sd(card) && arg != MMC_ERASE_ARG) 1331dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return -EOPNOTSUPP; 1332dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1333dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if ((arg & MMC_SECURE_ARGS) && 1334dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN)) 1335dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return -EOPNOTSUPP; 1336dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1337dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if ((arg & MMC_TRIM_ARGS) && 1338dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN)) 1339dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return -EOPNOTSUPP; 1340dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1341dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (arg == MMC_SECURE_ERASE_ARG) { 1342dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (from % card->erase_size || nr % card->erase_size) 1343dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return -EINVAL; 1344dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1345dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1346dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (arg == MMC_ERASE_ARG) { 1347dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter rem = from % card->erase_size; 1348dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (rem) { 1349dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter rem = card->erase_size - rem; 1350dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter from += rem; 1351dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (nr > rem) 1352dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter nr -= rem; 1353dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1354dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 0; 1355dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1356dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter rem = nr % card->erase_size; 1357dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (rem) 1358dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter nr -= rem; 1359dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1360dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1361dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (nr == 0) 1362dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 0; 1363dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1364dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter to = from + nr; 1365dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1366dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (to <= from) 1367dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return -EINVAL; 1368dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1369dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* 'from' and 'to' are inclusive */ 1370dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter to -= 1; 1371dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1372dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return mmc_do_erase(card, from, to, arg); 1373dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1374dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian HunterEXPORT_SYMBOL(mmc_erase); 1375dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1376dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunterint mmc_can_erase(struct mmc_card *card) 1377dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1378dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if ((card->host->caps & MMC_CAP_ERASE) && 1379dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter (card->csd.cmdclass & CCC_ERASE) && card->erase_size) 1380dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 1; 1381dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 0; 1382dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1383dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian HunterEXPORT_SYMBOL(mmc_can_erase); 1384dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1385dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunterint mmc_can_trim(struct mmc_card *card) 1386dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1387dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN) 1388dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 1; 1389dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 0; 1390dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1391dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian HunterEXPORT_SYMBOL(mmc_can_trim); 1392dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1393dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunterint mmc_can_secure_erase_trim(struct mmc_card *card) 1394dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1395dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN) 1396dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 1; 1397dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 0; 1398dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1399dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian HunterEXPORT_SYMBOL(mmc_can_secure_erase_trim); 1400dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1401dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunterint mmc_erase_group_aligned(struct mmc_card *card, unsigned int from, 1402dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int nr) 1403dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1404dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (!card->erase_size) 1405dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 0; 1406dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (from % card->erase_size || nr % card->erase_size) 1407dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 0; 1408dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 1; 1409dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1410dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian HunterEXPORT_SYMBOL(mmc_erase_group_aligned); 14111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14120f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunterint mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen) 14130f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter{ 14140f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter struct mmc_command cmd; 14150f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter 14160f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter if (mmc_card_blockaddr(card) || mmc_card_ddr_mode(card)) 14170f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter return 0; 14180f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter 14190f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter memset(&cmd, 0, sizeof(struct mmc_command)); 14200f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter cmd.opcode = MMC_SET_BLOCKLEN; 14210f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter cmd.arg = blocklen; 14220f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 14230f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter return mmc_wait_for_cmd(card->host, &cmd, 5); 14240f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter} 14250f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian HunterEXPORT_SYMBOL(mmc_set_blocklen); 14260f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter 1427b93931a61a119575f84c33af2438b9384fde9eb7Pierre Ossmanvoid mmc_rescan(struct work_struct *work) 14281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1429c4028958b6ecad064b1a6303a6a5906d4fe48d73David Howells struct mmc_host *host = 1430c4028958b6ecad064b1a6303a6a5906d4fe48d73David Howells container_of(work, struct mmc_host, detect.work); 14317ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman u32 ocr; 14327ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman int err; 14334c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky unsigned long flags; 143488ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch int i; 143588ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch const unsigned freqs[] = { 400000, 300000, 200000, 100000 }; 14364c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 14374c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky spin_lock_irqsave(&host->lock, flags); 14384c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 14394c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky if (host->rescan_disable) { 14404c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky spin_unlock_irqrestore(&host->lock, flags); 14414c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky return; 14424c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky } 14434c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 14444c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky spin_unlock_irqrestore(&host->lock, flags); 14454c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 14461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 14477ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_get(host); 1448b855885e3b60cf6f9452848712a62517b94583ebPierre Ossman 144994d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer /* if there is a card registered, check whether it is still present */ 145094d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer if ((host->bus_ops != NULL) && host->bus_ops->detect && !host->bus_dead) 145194d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer host->bus_ops->detect(host); 145294d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer 145394d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer mmc_bus_put(host); 145494d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer 145594d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer 145694d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer mmc_bus_get(host); 145794d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer 145894d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer /* if there still is a card present, stop here */ 145994d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer if (host->bus_ops != NULL) { 14607ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_put(host); 146194d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer goto out; 146294d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer } 14631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 146494d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer /* detect a newly inserted card */ 146528f52482b41edc88cdf575aa6ed414c6e116ce10Anton Vorontsov 146694d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer /* 146794d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer * Only we can add a new handler, so it's safe to 146894d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer * release the lock here. 146994d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer */ 147094d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer mmc_bus_put(host); 14711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 147294d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer if (host->ops->get_cd && host->ops->get_cd(host) == 0) 147394d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer goto out; 14741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 147588ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch for (i = 0; i < ARRAY_SIZE(freqs); i++) { 147688ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch mmc_claim_host(host); 14771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 147888ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch if (freqs[i] >= host->f_min) 147988ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch host->f_init = freqs[i]; 148088ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch else if (!i || freqs[i-1] > host->f_min) 148188ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch host->f_init = host->f_min; 148288ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch else { 148388ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch mmc_release_host(host); 148488ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch goto out; 148588ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch } 14864d0b8611cd4da64f075b8e07a126f0eb498fb153Eric Bénard#ifdef CONFIG_MMC_DEBUG 148788ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch pr_info("%s: %s: trying to init card at %u Hz\n", 148888ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch mmc_hostname(host), __func__, host->f_init); 14894d0b8611cd4da64f075b8e07a126f0eb498fb153Eric Bénard#endif 149088ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch mmc_power_up(host); 149188ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch sdio_reset(host); 149288ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch mmc_go_idle(host); 14935c4e6f1301649d5b29dd0f70e6da83e728ab5ca5Pierre Ossman 149488ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch mmc_send_if_cond(host, host->ocr_avail); 14957310ece86ad7da027f85a37a0638164118a5d12fMichal Miroslaw 149688ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch /* 149788ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch * First we search for SDIO... 149888ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch */ 149988ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch err = mmc_send_io_op_cond(host, 0, &ocr); 150088ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch if (!err) { 150188ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch if (mmc_attach_sdio(host, ocr)) { 150288ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch mmc_claim_host(host); 150388ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch /* 150488ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch * Try SDMEM (but not MMC) even if SDIO 150588ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch * is broken. 150688ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch */ 150788ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch if (mmc_send_app_op_cond(host, 0, &ocr)) 150888ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch goto out_fail; 150988ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch 151088ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch if (mmc_attach_sd(host, ocr)) 151188ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch mmc_power_off(host); 151288ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch } 151388ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch goto out; 151488ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch } 151588ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch 151688ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch /* 151788ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch * ...then normal SD... 151888ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch */ 151988ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch err = mmc_send_app_op_cond(host, 0, &ocr); 152088ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch if (!err) { 15217310ece86ad7da027f85a37a0638164118a5d12fMichal Miroslaw if (mmc_attach_sd(host, ocr)) 15227310ece86ad7da027f85a37a0638164118a5d12fMichal Miroslaw mmc_power_off(host); 152388ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch goto out; 15247310ece86ad7da027f85a37a0638164118a5d12fMichal Miroslaw } 15255c4e6f1301649d5b29dd0f70e6da83e728ab5ca5Pierre Ossman 152688ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch /* 152788ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch * ...and finally MMC. 152888ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch */ 152988ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch err = mmc_send_op_cond(host, 0, &ocr); 153088ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch if (!err) { 153188ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch if (mmc_attach_mmc(host, ocr)) 153288ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch mmc_power_off(host); 153388ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch goto out; 153488ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch } 153594d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer 15367310ece86ad7da027f85a37a0638164118a5d12fMichal Miroslawout_fail: 153788ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch mmc_release_host(host); 153888ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch mmc_power_off(host); 153988ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch } 154028f52482b41edc88cdf575aa6ed414c6e116ce10Anton Vorontsovout: 154128f52482b41edc88cdf575aa6ed414c6e116ce10Anton Vorontsov if (host->caps & MMC_CAP_NEEDS_POLL) 154228f52482b41edc88cdf575aa6ed414c6e116ce10Anton Vorontsov mmc_schedule_delayed_work(&host->detect, HZ); 15431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 15441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1545b93931a61a119575f84c33af2438b9384fde9eb7Pierre Ossmanvoid mmc_start_host(struct mmc_host *host) 15461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1547b93931a61a119575f84c33af2438b9384fde9eb7Pierre Ossman mmc_power_off(host); 1548b93931a61a119575f84c33af2438b9384fde9eb7Pierre Ossman mmc_detect_change(host, 0); 15491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 15501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1551b93931a61a119575f84c33af2438b9384fde9eb7Pierre Ossmanvoid mmc_stop_host(struct mmc_host *host) 15521da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 15533b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman#ifdef CONFIG_MMC_DEBUG 15541efd48b3ae8f89a1d04f1e36be96764d7bf43ae9Pierre Ossman unsigned long flags; 15551efd48b3ae8f89a1d04f1e36be96764d7bf43ae9Pierre Ossman spin_lock_irqsave(&host->lock, flags); 15563b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman host->removed = 1; 15571efd48b3ae8f89a1d04f1e36be96764d7bf43ae9Pierre Ossman spin_unlock_irqrestore(&host->lock, flags); 15583b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman#endif 15593b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman 15608ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->caps & MMC_CAP_DISABLE) 15618ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter cancel_delayed_work(&host->disable); 15627de427d088a967d2173739e21e744921d5496a8bJorg Schummer cancel_delayed_work(&host->detect); 15633b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman mmc_flush_scheduled_work(); 15643b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman 1565da68c4eb258cd9f3f0b8aeb7e46b8118bb6358b6Nicolas Pitre /* clear pm flags now and let card drivers set them as needed */ 1566da68c4eb258cd9f3f0b8aeb7e46b8118bb6358b6Nicolas Pitre host->pm_flags = 0; 1567da68c4eb258cd9f3f0b8aeb7e46b8118bb6358b6Nicolas Pitre 15687ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_get(host); 15697ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman if (host->bus_ops && !host->bus_dead) { 15707ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman if (host->bus_ops->remove) 15717ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->bus_ops->remove(host); 15727ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 15737ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_claim_host(host); 15747ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_detach_bus(host); 15757ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_release_host(host); 157653509f0fe28e049e772897aa8fa1f5183b6823a2Denis Karpov mmc_bus_put(host); 157753509f0fe28e049e772897aa8fa1f5183b6823a2Denis Karpov return; 15781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 15797ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_put(host); 15807ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 15817ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman BUG_ON(host->card); 15821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 15831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mmc_power_off(host); 15841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 15851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 158612ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohenint mmc_power_save_host(struct mmc_host *host) 1587eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter{ 158812ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen int ret = 0; 158912ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen 1590eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_bus_get(host); 1591eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1592eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) { 1593eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_bus_put(host); 159412ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen return -EINVAL; 1595eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter } 1596eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1597eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter if (host->bus_ops->power_save) 159812ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen ret = host->bus_ops->power_save(host); 1599eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1600eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_bus_put(host); 1601eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1602eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_power_off(host); 160312ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen 160412ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen return ret; 1605eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter} 1606eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian HunterEXPORT_SYMBOL(mmc_power_save_host); 1607eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 160812ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohenint mmc_power_restore_host(struct mmc_host *host) 1609eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter{ 161012ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen int ret; 161112ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen 1612eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_bus_get(host); 1613eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1614eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) { 1615eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_bus_put(host); 161612ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen return -EINVAL; 1617eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter } 1618eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1619eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_power_up(host); 162012ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen ret = host->bus_ops->power_restore(host); 1621eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1622eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_bus_put(host); 162312ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen 162412ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen return ret; 1625eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter} 1626eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian HunterEXPORT_SYMBOL(mmc_power_restore_host); 1627eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1628b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinenint mmc_card_awake(struct mmc_host *host) 1629b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen{ 1630b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen int err = -ENOSYS; 1631b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1632b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen mmc_bus_get(host); 1633b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1634b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen if (host->bus_ops && !host->bus_dead && host->bus_ops->awake) 1635b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen err = host->bus_ops->awake(host); 1636b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1637b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen mmc_bus_put(host); 1638b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1639b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen return err; 1640b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen} 1641b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko LavinenEXPORT_SYMBOL(mmc_card_awake); 1642b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1643b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinenint mmc_card_sleep(struct mmc_host *host) 1644b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen{ 1645b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen int err = -ENOSYS; 1646b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1647b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen mmc_bus_get(host); 1648b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1649b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen if (host->bus_ops && !host->bus_dead && host->bus_ops->awake) 1650b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen err = host->bus_ops->sleep(host); 1651b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1652b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen mmc_bus_put(host); 1653b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1654b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen return err; 1655b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen} 1656b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko LavinenEXPORT_SYMBOL(mmc_card_sleep); 1657b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1658b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinenint mmc_card_can_sleep(struct mmc_host *host) 1659b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen{ 1660b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen struct mmc_card *card = host->card; 1661b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1662b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen if (card && mmc_card_mmc(card) && card->ext_csd.rev >= 3) 1663b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen return 1; 1664b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen return 0; 1665b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen} 1666b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko LavinenEXPORT_SYMBOL(mmc_card_can_sleep); 1667b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 16681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef CONFIG_PM 16691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 16701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 16711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * mmc_suspend_host - suspend a host 16721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @host: mmc host 16731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 16741a13f8fa76c880be41d6b1e6a2b44404bcbfdf9eMatt Flemingint mmc_suspend_host(struct mmc_host *host) 16751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 167695cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre int err = 0; 167795cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre 16788ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->caps & MMC_CAP_DISABLE) 16798ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter cancel_delayed_work(&host->disable); 16807de427d088a967d2173739e21e744921d5496a8bJorg Schummer cancel_delayed_work(&host->detect); 1681b5af25bee2de2f6cd1ac74ba737cbc4f3d303e5dPierre Ossman mmc_flush_scheduled_work(); 1682b5af25bee2de2f6cd1ac74ba737cbc4f3d303e5dPierre Ossman 16837ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_get(host); 16847ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman if (host->bus_ops && !host->bus_dead) { 16856abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman if (host->bus_ops->suspend) 168695cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre err = host->bus_ops->suspend(host); 16871c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen if (err == -ENOSYS || !host->bus_ops->resume) { 16881c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen /* 16891c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen * We simply "remove" the card in this case. 16901c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen * It will be redetected on resume. 16911c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen */ 16921c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen if (host->bus_ops->remove) 16931c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen host->bus_ops->remove(host); 16941c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen mmc_claim_host(host); 16951c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen mmc_detach_bus(host); 16961c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen mmc_release_host(host); 16971c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen host->pm_flags = 0; 16981c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen err = 0; 16991c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen } 1700b5af25bee2de2f6cd1ac74ba737cbc4f3d303e5dPierre Ossman } 17017ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_put(host); 17027ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 1703da68c4eb258cd9f3f0b8aeb7e46b8118bb6358b6Nicolas Pitre if (!err && !(host->pm_flags & MMC_PM_KEEP_POWER)) 170495cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre mmc_power_off(host); 17051da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 170695cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre return err; 17071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17091da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_suspend_host); 17101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 17121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * mmc_resume_host - resume a previously suspended host 17131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @host: mmc host 17141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 17151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint mmc_resume_host(struct mmc_host *host) 17161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 171795cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre int err = 0; 171895cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre 17196abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman mmc_bus_get(host); 17206abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman if (host->bus_ops && !host->bus_dead) { 1721da68c4eb258cd9f3f0b8aeb7e46b8118bb6358b6Nicolas Pitre if (!(host->pm_flags & MMC_PM_KEEP_POWER)) { 1722da68c4eb258cd9f3f0b8aeb7e46b8118bb6358b6Nicolas Pitre mmc_power_up(host); 1723da68c4eb258cd9f3f0b8aeb7e46b8118bb6358b6Nicolas Pitre mmc_select_voltage(host, host->ocr); 1724da68c4eb258cd9f3f0b8aeb7e46b8118bb6358b6Nicolas Pitre } 17256abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman BUG_ON(!host->bus_ops->resume); 172695cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre err = host->bus_ops->resume(host); 172795cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre if (err) { 172895cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre printk(KERN_WARNING "%s: error %d during resume " 172995cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre "(card was removed?)\n", 173095cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre mmc_hostname(host), err); 173195cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre err = 0; 173295cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre } 17336abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman } 17346abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman mmc_bus_put(host); 17356abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman 173695cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre return err; 17371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 17381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_resume_host); 17391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 17404c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky/* Do the card removal on suspend if card is assumed removeable 17414c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky * Do that in pm notifier while userspace isn't yet frozen, so we will be able 17424c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky to sync the card. 17434c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky*/ 17444c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitskyint mmc_pm_notify(struct notifier_block *notify_block, 17454c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky unsigned long mode, void *unused) 17464c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky{ 17474c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky struct mmc_host *host = container_of( 17484c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky notify_block, struct mmc_host, pm_notify); 17494c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky unsigned long flags; 17504c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 17514c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 17524c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky switch (mode) { 17534c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky case PM_HIBERNATION_PREPARE: 17544c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky case PM_SUSPEND_PREPARE: 17554c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 17564c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky spin_lock_irqsave(&host->lock, flags); 17574c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky host->rescan_disable = 1; 17584c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky spin_unlock_irqrestore(&host->lock, flags); 17594c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky cancel_delayed_work_sync(&host->detect); 17604c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 17614c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky if (!host->bus_ops || host->bus_ops->suspend) 17624c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky break; 17634c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 17644c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky mmc_claim_host(host); 17654c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 17664c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky if (host->bus_ops->remove) 17674c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky host->bus_ops->remove(host); 17684c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 17694c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky mmc_detach_bus(host); 17704c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky mmc_release_host(host); 17714c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky host->pm_flags = 0; 17724c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky break; 17734c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 17744c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky case PM_POST_SUSPEND: 17754c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky case PM_POST_HIBERNATION: 17764c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 17774c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky spin_lock_irqsave(&host->lock, flags); 17784c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky host->rescan_disable = 0; 17794c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky spin_unlock_irqrestore(&host->lock, flags); 17804c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky mmc_detect_change(host, 0); 17814c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 17824c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky } 17834c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 17844c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky return 0; 17854c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky} 17861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 17871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1788ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossmanstatic int __init mmc_init(void) 1789ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman{ 1790ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman int ret; 1791ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 17920d9ee5b2e9aac981fa063339daf04320eac610d1Tejun Heo workqueue = alloc_ordered_workqueue("kmmcd", 0); 1793ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman if (!workqueue) 1794ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman return -ENOMEM; 1795ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 1796ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman ret = mmc_register_bus(); 1797e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman if (ret) 1798e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman goto destroy_workqueue; 1799e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman 1800e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman ret = mmc_register_host_class(); 1801e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman if (ret) 1802e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman goto unregister_bus; 1803e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman 1804e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman ret = sdio_register_bus(); 1805e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman if (ret) 1806e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman goto unregister_host_class; 1807e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman 1808e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman return 0; 1809e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman 1810e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossmanunregister_host_class: 1811e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman mmc_unregister_host_class(); 1812e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossmanunregister_bus: 1813e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman mmc_unregister_bus(); 1814e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossmandestroy_workqueue: 1815e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman destroy_workqueue(workqueue); 1816e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman 1817ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman return ret; 1818ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman} 1819ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 1820ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossmanstatic void __exit mmc_exit(void) 1821ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman{ 1822e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman sdio_unregister_bus(); 1823ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman mmc_unregister_host_class(); 1824ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman mmc_unregister_bus(); 1825ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman destroy_workqueue(workqueue); 1826ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman} 1827ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 182826074962e8f547b96614dbe248748ba2a1996ca3Nicolas Pitresubsys_initcall(mmc_init); 1829ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossmanmodule_exit(mmc_exit); 1830ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 18311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_LICENSE("GPL"); 1832