core.c revision 7f7e4129c23f0419257184dff6fec89d2d5a8964
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> 25e594573d790bd7e269f05955d316b88f7be0c14aOhad Ben-Cohen#include <linux/pm_runtime.h> 2635eb6db11ed9cbf9702ec90a28779a51fe4a21a9Amerigo Wang#include <linux/suspend.h> 271b676f70c108cda90cf9d114d16c677584400efcPer Forlin#include <linux/fault-inject.h> 281b676f70c108cda90cf9d114d16c677584400efcPer Forlin#include <linux/random.h> 291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/mmc/card.h> 311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#include <linux/mmc/host.h> 32da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossman#include <linux/mmc/mmc.h> 33da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossman#include <linux/mmc/sd.h> 341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 35aaac1b470bd0dccb30912356617069dc6199cc80Pierre Ossman#include "core.h" 36ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman#include "bus.h" 37ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman#include "host.h" 38e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman#include "sdio_bus.h" 39da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossman 40da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossman#include "mmc_ops.h" 41da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossman#include "sd_ops.h" 425c4e6f1301649d5b29dd0f70e6da83e728ab5ca5Pierre Ossman#include "sdio_ops.h" 431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 44ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossmanstatic struct workqueue_struct *workqueue; 45ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 46ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman/* 47af51715079e7fb6b290e1881d63d815dc4de5011David Brownell * Enabling software CRCs on the data blocks can be a significant (30%) 48af51715079e7fb6b290e1881d63d815dc4de5011David Brownell * performance cost, and for other reasons may not always be desired. 49af51715079e7fb6b290e1881d63d815dc4de5011David Brownell * So we allow it it to be disabled. 50af51715079e7fb6b290e1881d63d815dc4de5011David Brownell */ 51af51715079e7fb6b290e1881d63d815dc4de5011David Brownellint use_spi_crc = 1; 52af51715079e7fb6b290e1881d63d815dc4de5011David Brownellmodule_param(use_spi_crc, bool, 0); 53af51715079e7fb6b290e1881d63d815dc4de5011David Brownell 54af51715079e7fb6b290e1881d63d815dc4de5011David Brownell/* 55bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings * We normally treat cards as removed during suspend if they are not 56bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings * known to be on a non-removable bus, to avoid the risk of writing 57bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings * back data to a different card after resume. Allow this to be 58bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings * overridden if necessary. 59bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings */ 60bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings#ifdef CONFIG_MMC_UNSAFE_RESUME 61bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchingsint mmc_assume_removable; 62bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings#else 63bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchingsint mmc_assume_removable = 1; 64bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings#endif 6571d7d3d190fe77588269a8febf93cd739bd91eb3Matt FlemingEXPORT_SYMBOL(mmc_assume_removable); 66bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchingsmodule_param_named(removable, mmc_assume_removable, bool, 0644); 67bd68e0838fe85794b06892054772fa013a8d1986Ben HutchingsMODULE_PARM_DESC( 68bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings removable, 69bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings "MMC/SD cards are removable and may be removed during suspend"); 70bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings 71bd68e0838fe85794b06892054772fa013a8d1986Ben Hutchings/* 72ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman * Internal function. Schedule delayed work in the MMC work queue. 73ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman */ 74ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossmanstatic int mmc_schedule_delayed_work(struct delayed_work *work, 75ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman unsigned long delay) 76ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman{ 77ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman return queue_delayed_work(workqueue, work, delay); 78ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman} 79ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 80ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman/* 81ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman * Internal function. Flush all scheduled work from the MMC work queue. 82ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman */ 83ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossmanstatic void mmc_flush_scheduled_work(void) 84ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman{ 85ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman flush_workqueue(workqueue); 86ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman} 87ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 881b676f70c108cda90cf9d114d16c677584400efcPer Forlin#ifdef CONFIG_FAIL_MMC_REQUEST 891b676f70c108cda90cf9d114d16c677584400efcPer Forlin 901b676f70c108cda90cf9d114d16c677584400efcPer Forlin/* 911b676f70c108cda90cf9d114d16c677584400efcPer Forlin * Internal function. Inject random data errors. 921b676f70c108cda90cf9d114d16c677584400efcPer Forlin * If mmc_data is NULL no errors are injected. 931b676f70c108cda90cf9d114d16c677584400efcPer Forlin */ 941b676f70c108cda90cf9d114d16c677584400efcPer Forlinstatic void mmc_should_fail_request(struct mmc_host *host, 951b676f70c108cda90cf9d114d16c677584400efcPer Forlin struct mmc_request *mrq) 961b676f70c108cda90cf9d114d16c677584400efcPer Forlin{ 971b676f70c108cda90cf9d114d16c677584400efcPer Forlin struct mmc_command *cmd = mrq->cmd; 981b676f70c108cda90cf9d114d16c677584400efcPer Forlin struct mmc_data *data = mrq->data; 991b676f70c108cda90cf9d114d16c677584400efcPer Forlin static const int data_errors[] = { 1001b676f70c108cda90cf9d114d16c677584400efcPer Forlin -ETIMEDOUT, 1011b676f70c108cda90cf9d114d16c677584400efcPer Forlin -EILSEQ, 1021b676f70c108cda90cf9d114d16c677584400efcPer Forlin -EIO, 1031b676f70c108cda90cf9d114d16c677584400efcPer Forlin }; 1041b676f70c108cda90cf9d114d16c677584400efcPer Forlin 1051b676f70c108cda90cf9d114d16c677584400efcPer Forlin if (!data) 1061b676f70c108cda90cf9d114d16c677584400efcPer Forlin return; 1071b676f70c108cda90cf9d114d16c677584400efcPer Forlin 1081b676f70c108cda90cf9d114d16c677584400efcPer Forlin if (cmd->error || data->error || 1091b676f70c108cda90cf9d114d16c677584400efcPer Forlin !should_fail(&host->fail_mmc_request, data->blksz * data->blocks)) 1101b676f70c108cda90cf9d114d16c677584400efcPer Forlin return; 1111b676f70c108cda90cf9d114d16c677584400efcPer Forlin 1121b676f70c108cda90cf9d114d16c677584400efcPer Forlin data->error = data_errors[random32() % ARRAY_SIZE(data_errors)]; 1131b676f70c108cda90cf9d114d16c677584400efcPer Forlin data->bytes_xfered = (random32() % (data->bytes_xfered >> 9)) << 9; 1141b676f70c108cda90cf9d114d16c677584400efcPer Forlin} 1151b676f70c108cda90cf9d114d16c677584400efcPer Forlin 1161b676f70c108cda90cf9d114d16c677584400efcPer Forlin#else /* CONFIG_FAIL_MMC_REQUEST */ 1171b676f70c108cda90cf9d114d16c677584400efcPer Forlin 1181b676f70c108cda90cf9d114d16c677584400efcPer Forlinstatic inline void mmc_should_fail_request(struct mmc_host *host, 1191b676f70c108cda90cf9d114d16c677584400efcPer Forlin struct mmc_request *mrq) 1201b676f70c108cda90cf9d114d16c677584400efcPer Forlin{ 1211b676f70c108cda90cf9d114d16c677584400efcPer Forlin} 1221b676f70c108cda90cf9d114d16c677584400efcPer Forlin 1231b676f70c108cda90cf9d114d16c677584400efcPer Forlin#endif /* CONFIG_FAIL_MMC_REQUEST */ 1241b676f70c108cda90cf9d114d16c677584400efcPer Forlin 1251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 126fe10c6abea8bc83291a13e0580b3e4c355710b09Russell King * mmc_request_done - finish processing an MMC request 127fe10c6abea8bc83291a13e0580b3e4c355710b09Russell King * @host: MMC host which completed request 128fe10c6abea8bc83291a13e0580b3e4c355710b09Russell King * @mrq: MMC request which request 1291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 1301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * MMC drivers should call this function when they have completed 131fe10c6abea8bc83291a13e0580b3e4c355710b09Russell King * their processing of a request. 1321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 1331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsvoid mmc_request_done(struct mmc_host *host, struct mmc_request *mrq) 1341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds struct mmc_command *cmd = mrq->cmd; 136920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King int err = cmd->error; 137920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King 138af51715079e7fb6b290e1881d63d815dc4de5011David Brownell if (err && cmd->retries && mmc_host_is_spi(host)) { 139af51715079e7fb6b290e1881d63d815dc4de5011David Brownell if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND) 140af51715079e7fb6b290e1881d63d815dc4de5011David Brownell cmd->retries = 0; 141af51715079e7fb6b290e1881d63d815dc4de5011David Brownell } 142af51715079e7fb6b290e1881d63d815dc4de5011David Brownell 1431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (err && cmd->retries) { 144e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman pr_debug("%s: req failed (CMD%u): %d, retrying...\n", 145e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mmc_hostname(host), cmd->opcode, err); 146e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman 1471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cmd->retries--; 1481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cmd->error = 0; 1491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ops->request(host, mrq); 150e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman } else { 1511b676f70c108cda90cf9d114d16c677584400efcPer Forlin mmc_should_fail_request(host, mrq); 1521b676f70c108cda90cf9d114d16c677584400efcPer Forlin 153af8350c756cb48a738474738f7bf8c0e572fa057Pierre Ossman led_trigger_event(host->led, LED_OFF); 154af8350c756cb48a738474738f7bf8c0e572fa057Pierre Ossman 155e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman pr_debug("%s: req done (CMD%u): %d: %08x %08x %08x %08x\n", 156e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mmc_hostname(host), cmd->opcode, err, 157e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman cmd->resp[0], cmd->resp[1], 158e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman cmd->resp[2], cmd->resp[3]); 159e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman 160e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman if (mrq->data) { 161e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman pr_debug("%s: %d bytes transferred: %d\n", 162e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mmc_hostname(host), 163e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->data->bytes_xfered, mrq->data->error); 164e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman } 165e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman 166e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman if (mrq->stop) { 167e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman pr_debug("%s: (CMD%u): %d: %08x %08x %08x %08x\n", 168e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mmc_hostname(host), mrq->stop->opcode, 169e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->stop->error, 170e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->stop->resp[0], mrq->stop->resp[1], 171e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->stop->resp[2], mrq->stop->resp[3]); 172e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman } 173e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman 174e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman if (mrq->done) 175e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->done(mrq); 17604566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij 17708c14071fda4e69abb9d5b1566651cd092b158d3Mika Westerberg mmc_host_clk_release(host); 1781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 1791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 1801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_request_done); 1821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 183393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunkstatic void 1841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsmmc_start_request(struct mmc_host *host, struct mmc_request *mrq) 1851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 186976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman#ifdef CONFIG_MMC_DEBUG 187976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman unsigned int i, sz; 188a84756c5735f28bf000617f18734a9e94426386aPierre Ossman struct scatterlist *sg; 189976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman#endif 190976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman 191920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King pr_debug("%s: starting CMD%u arg %08x flags %08x\n", 192920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mmc_hostname(host), mrq->cmd->opcode, 193920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mrq->cmd->arg, mrq->cmd->flags); 1941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 195e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman if (mrq->data) { 196e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman pr_debug("%s: blksz %d blocks %d flags %08x " 197e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman "tsac %d ms nsac %d\n", 198e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mmc_hostname(host), mrq->data->blksz, 199e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->data->blocks, mrq->data->flags, 200ce252edd869ba1fee6a9a6f83e20f349d4c4d669Pierre Ossman mrq->data->timeout_ns / 1000000, 201e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->data->timeout_clks); 202e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman } 203e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman 204e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman if (mrq->stop) { 205e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman pr_debug("%s: CMD%u arg %08x flags %08x\n", 206e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mmc_hostname(host), mrq->stop->opcode, 207e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman mrq->stop->arg, mrq->stop->flags); 208e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman } 209e4d217087458914a6d5d9fd034d7237e6530c619Pierre Ossman 210f22ee4edf63e7480511112d9965c71e07be3f8b7Pierre Ossman WARN_ON(!host->claimed); 2111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->cmd->error = 0; 2131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->cmd->mrq = mrq; 2141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mrq->data) { 215fe4a3c7a20f14d86022a8132adbf6ddb98e7197cPierre Ossman BUG_ON(mrq->data->blksz > host->max_blk_size); 21655db890a838c7b37256241b1fc53d6344aa79cc0Pierre Ossman BUG_ON(mrq->data->blocks > host->max_blk_count); 21755db890a838c7b37256241b1fc53d6344aa79cc0Pierre Ossman BUG_ON(mrq->data->blocks * mrq->data->blksz > 21855db890a838c7b37256241b1fc53d6344aa79cc0Pierre Ossman host->max_req_size); 219fe4a3c7a20f14d86022a8132adbf6ddb98e7197cPierre Ossman 220976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman#ifdef CONFIG_MMC_DEBUG 221976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman sz = 0; 222a84756c5735f28bf000617f18734a9e94426386aPierre Ossman for_each_sg(mrq->data->sg, sg, mrq->data->sg_len, i) 223a84756c5735f28bf000617f18734a9e94426386aPierre Ossman sz += sg->length; 224976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman BUG_ON(sz != mrq->data->blocks * mrq->data->blksz); 225976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman#endif 226976d9276c826d6b35e4a2478fd4978dbd63bdd6fPierre Ossman 2271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->cmd->data = mrq->data; 2281da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->data->error = 0; 2291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->data->mrq = mrq; 2301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (mrq->stop) { 2311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->data->stop = mrq->stop; 2321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->stop->error = 0; 2331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq->stop->mrq = mrq; 2341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 2351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 23608c14071fda4e69abb9d5b1566651cd092b158d3Mika Westerberg mmc_host_clk_hold(host); 23766c036e0142fed2484d58a2d3c7a4d21ba32b6a6Pierre Tardy led_trigger_event(host->led, LED_FULL); 2381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ops->request(host, mrq); 2391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 2401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void mmc_wait_done(struct mmc_request *mrq) 2421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 243aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin complete(&mrq->completion); 244aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin} 245aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin 246aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlinstatic void __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq) 247aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin{ 248aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin init_completion(&mrq->completion); 249aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin mrq->done = mmc_wait_done; 250aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin mmc_start_request(host, mrq); 251aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin} 252aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin 253aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlinstatic void mmc_wait_for_req_done(struct mmc_host *host, 254aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin struct mmc_request *mrq) 255aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin{ 256aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin wait_for_completion(&mrq->completion); 257aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin} 258aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin 259aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin/** 260aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * mmc_pre_req - Prepare for a new request 261aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * @host: MMC host to prepare command 262aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * @mrq: MMC request to prepare for 263aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * @is_first_req: true if there is no previous started request 264aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * that may run in parellel to this call, otherwise false 265aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * 266aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * mmc_pre_req() is called in prior to mmc_start_req() to let 267aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * host prepare for the new request. Preparation of a request may be 268aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * performed while another request is running on the host. 269aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin */ 270aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlinstatic void mmc_pre_req(struct mmc_host *host, struct mmc_request *mrq, 271aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin bool is_first_req) 272aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin{ 273aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin if (host->ops->pre_req) 274aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin host->ops->pre_req(host, mrq, is_first_req); 275aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin} 276aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin 277aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin/** 278aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * mmc_post_req - Post process a completed request 279aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * @host: MMC host to post process command 280aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * @mrq: MMC request to post process for 281aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * @err: Error, if non zero, clean up any resources made in pre_req 282aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * 283aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * Let the host post process a completed request. Post processing of 284aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * a request may be performed while another reuqest is running. 285aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin */ 286aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlinstatic void mmc_post_req(struct mmc_host *host, struct mmc_request *mrq, 287aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin int err) 288aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin{ 289aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin if (host->ops->post_req) 290aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin host->ops->post_req(host, mrq, err); 2911da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 2921da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 29367a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman/** 294aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * mmc_start_req - start a non-blocking request 295aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * @host: MMC host to start command 296aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * @areq: async request to start 297aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * @error: out parameter returns 0 for success, otherwise non zero 298aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * 299aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * Start a new MMC custom command request for a host. 300aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * If there is on ongoing async request wait for completion 301aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * of that request and start the new one and return. 302aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * Does not wait for the new request to complete. 303aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * 304aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * Returns the completed request, NULL in case of none completed. 305aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * Wait for the an ongoing request (previoulsy started) to complete and 306aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * return the completed request. If there is no ongoing request, NULL 307aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin * is returned without waiting. NULL is not an error condition. 308aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin */ 309aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlinstruct mmc_async_req *mmc_start_req(struct mmc_host *host, 310aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin struct mmc_async_req *areq, int *error) 311aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin{ 312aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin int err = 0; 313aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin struct mmc_async_req *data = host->areq; 314aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin 315aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin /* Prepare a new request */ 316aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin if (areq) 317aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin mmc_pre_req(host, areq->mrq, !host->areq); 318aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin 319aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin if (host->areq) { 320aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin mmc_wait_for_req_done(host, host->areq->mrq); 321aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin err = host->areq->err_check(host->card, host->areq); 322aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin if (err) { 323aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin mmc_post_req(host, host->areq->mrq, 0); 324aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin if (areq) 325aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin mmc_post_req(host, areq->mrq, -EINVAL); 326aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin 327aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin host->areq = NULL; 328aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin goto out; 329aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin } 330aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin } 331aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin 332aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin if (areq) 333aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin __mmc_start_req(host, areq->mrq); 334aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin 335aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin if (host->areq) 336aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin mmc_post_req(host, host->areq->mrq, 0); 337aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin 338aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin host->areq = areq; 339aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin out: 340aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin if (error) 341aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin *error = err; 342aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin return data; 343aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin} 344aa8b683a7d392271ed349c6ab9f36b8c313794b7Per ForlinEXPORT_SYMBOL(mmc_start_req); 345aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin 346aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin/** 34767a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * mmc_wait_for_req - start a request and wait for completion 34867a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * @host: MMC host to start command 34967a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * @mrq: MMC request to start 35067a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * 35167a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * Start a new MMC custom command request for a host, and wait 35267a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * for the command to complete. Does not attempt to parse the 35367a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * response. 35467a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman */ 35567a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossmanvoid mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq) 3561da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 357aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin __mmc_start_req(host, mrq); 358aa8b683a7d392271ed349c6ab9f36b8c313794b7Per Forlin mmc_wait_for_req_done(host, mrq); 3591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 3601da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_wait_for_req); 3611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 3631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * mmc_wait_for_cmd - start a command and wait for completion 3641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @host: MMC host to start command 3651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @cmd: MMC command to start 3661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @retries: maximum number of retries 3671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 3681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Start a new MMC command for a host, and wait for the command 3691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * to complete. Return any error that occurred while the command 3701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * was executing. Do not attempt to parse the response. 3711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 3721da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries) 3731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 374ad5fd97288655b5628052c1fa906419417c86100Venkatraman S struct mmc_request mrq = {NULL}; 3751da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 376d84075c8aed771d47d7ac6e96b098559da361c25Pierre Ossman WARN_ON(!host->claimed); 3771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds memset(cmd->resp, 0, sizeof(cmd->resp)); 3791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cmd->retries = retries; 3801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mrq.cmd = cmd; 3821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds cmd->data = NULL; 3831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mmc_wait_for_req(host, &mrq); 3851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3861da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return cmd->error; 3871da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 3881da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 3891da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_wait_for_cmd); 3901da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 391335eadf2ef6a1122a720aea98e758e5d431da87dPierre Ossman/** 392d773d7255199a6c8934e197756f54a1115dd127bRussell King * mmc_set_data_timeout - set the timeout for a data command 393d773d7255199a6c8934e197756f54a1115dd127bRussell King * @data: data phase for command 394d773d7255199a6c8934e197756f54a1115dd127bRussell King * @card: the MMC card associated with the data transfer 39567a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * 39667a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * Computes the data timeout parameters according to the 39767a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * correct algorithm given the card type. 398d773d7255199a6c8934e197756f54a1115dd127bRussell King */ 399b146d26a61e0feab2f12a98ae83fd352830899c0Pierre Ossmanvoid mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card) 400d773d7255199a6c8934e197756f54a1115dd127bRussell King{ 401d773d7255199a6c8934e197756f54a1115dd127bRussell King unsigned int mult; 402d773d7255199a6c8934e197756f54a1115dd127bRussell King 403d773d7255199a6c8934e197756f54a1115dd127bRussell King /* 404e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman * SDIO cards only define an upper 1 s limit on access. 405e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman */ 406e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman if (mmc_card_sdio(card)) { 407e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman data->timeout_ns = 1000000000; 408e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman data->timeout_clks = 0; 409e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman return; 410e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman } 411e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman 412e6f918bf39773d712ab5b457bff54ade3bda0cb1Pierre Ossman /* 413d773d7255199a6c8934e197756f54a1115dd127bRussell King * SD cards use a 100 multiplier rather than 10 414d773d7255199a6c8934e197756f54a1115dd127bRussell King */ 415d773d7255199a6c8934e197756f54a1115dd127bRussell King mult = mmc_card_sd(card) ? 100 : 10; 416d773d7255199a6c8934e197756f54a1115dd127bRussell King 417d773d7255199a6c8934e197756f54a1115dd127bRussell King /* 418d773d7255199a6c8934e197756f54a1115dd127bRussell King * Scale up the multiplier (and therefore the timeout) by 419d773d7255199a6c8934e197756f54a1115dd127bRussell King * the r2w factor for writes. 420d773d7255199a6c8934e197756f54a1115dd127bRussell King */ 421b146d26a61e0feab2f12a98ae83fd352830899c0Pierre Ossman if (data->flags & MMC_DATA_WRITE) 422d773d7255199a6c8934e197756f54a1115dd127bRussell King mult <<= card->csd.r2w_factor; 423d773d7255199a6c8934e197756f54a1115dd127bRussell King 424d773d7255199a6c8934e197756f54a1115dd127bRussell King data->timeout_ns = card->csd.tacc_ns * mult; 425d773d7255199a6c8934e197756f54a1115dd127bRussell King data->timeout_clks = card->csd.tacc_clks * mult; 426d773d7255199a6c8934e197756f54a1115dd127bRussell King 427d773d7255199a6c8934e197756f54a1115dd127bRussell King /* 428d773d7255199a6c8934e197756f54a1115dd127bRussell King * SD cards also have an upper limit on the timeout. 429d773d7255199a6c8934e197756f54a1115dd127bRussell King */ 430d773d7255199a6c8934e197756f54a1115dd127bRussell King if (mmc_card_sd(card)) { 431d773d7255199a6c8934e197756f54a1115dd127bRussell King unsigned int timeout_us, limit_us; 432d773d7255199a6c8934e197756f54a1115dd127bRussell King 433d773d7255199a6c8934e197756f54a1115dd127bRussell King timeout_us = data->timeout_ns / 1000; 434e9b86841b372de01ae865080118e29159d8b7c39Linus Walleij if (mmc_host_clk_rate(card->host)) 435e9b86841b372de01ae865080118e29159d8b7c39Linus Walleij timeout_us += data->timeout_clks * 1000 / 436e9b86841b372de01ae865080118e29159d8b7c39Linus Walleij (mmc_host_clk_rate(card->host) / 1000); 437d773d7255199a6c8934e197756f54a1115dd127bRussell King 438b146d26a61e0feab2f12a98ae83fd352830899c0Pierre Ossman if (data->flags & MMC_DATA_WRITE) 439493890e75d98810a3470b4aae23be628ee5e9667Pierre Ossman /* 440493890e75d98810a3470b4aae23be628ee5e9667Pierre Ossman * The limit is really 250 ms, but that is 441493890e75d98810a3470b4aae23be628ee5e9667Pierre Ossman * insufficient for some crappy cards. 442493890e75d98810a3470b4aae23be628ee5e9667Pierre Ossman */ 443493890e75d98810a3470b4aae23be628ee5e9667Pierre Ossman limit_us = 300000; 444d773d7255199a6c8934e197756f54a1115dd127bRussell King else 445d773d7255199a6c8934e197756f54a1115dd127bRussell King limit_us = 100000; 446d773d7255199a6c8934e197756f54a1115dd127bRussell King 447fba68bd2dab1ac99af3c5a963ec9581cfa9f1725Philip Langdale /* 448fba68bd2dab1ac99af3c5a963ec9581cfa9f1725Philip Langdale * SDHC cards always use these fixed values. 449fba68bd2dab1ac99af3c5a963ec9581cfa9f1725Philip Langdale */ 450fba68bd2dab1ac99af3c5a963ec9581cfa9f1725Philip Langdale if (timeout_us > limit_us || mmc_card_blockaddr(card)) { 451d773d7255199a6c8934e197756f54a1115dd127bRussell King data->timeout_ns = limit_us * 1000; 452d773d7255199a6c8934e197756f54a1115dd127bRussell King data->timeout_clks = 0; 453d773d7255199a6c8934e197756f54a1115dd127bRussell King } 454d773d7255199a6c8934e197756f54a1115dd127bRussell King } 455c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees /* 456c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees * Some cards need very high timeouts if driven in SPI mode. 457c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees * The worst observed timeout was 900ms after writing a 458c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees * continuous stream of data until the internal logic 459c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees * overflowed. 460c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees */ 461c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees if (mmc_host_is_spi(card->host)) { 462c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees if (data->flags & MMC_DATA_WRITE) { 463c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees if (data->timeout_ns < 1000000000) 464c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees data->timeout_ns = 1000000000; /* 1s */ 465c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees } else { 466c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees if (data->timeout_ns < 100000000) 467c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees data->timeout_ns = 100000000; /* 100ms */ 468c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees } 469c0c88871574ccb4ee53dde1bbb678931b38ed47bWolfgang Muees } 470d773d7255199a6c8934e197756f54a1115dd127bRussell King} 471d773d7255199a6c8934e197756f54a1115dd127bRussell KingEXPORT_SYMBOL(mmc_set_data_timeout); 472d773d7255199a6c8934e197756f54a1115dd127bRussell King 4731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 474ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * mmc_align_data_size - pads a transfer size to a more optimal value 475ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * @card: the MMC card associated with the data transfer 476ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * @sz: original transfer size 477ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * 478ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * Pads the original data size with a number of extra bytes in 479ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * order to avoid controller bugs and/or performance hits 480ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * (e.g. some controllers revert to PIO for certain sizes). 481ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * 482ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * Returns the improved size, which might be unmodified. 483ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * 484ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * Note that this function is only relevant when issuing a 485ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * single scatter gather entry. 486ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman */ 487ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossmanunsigned int mmc_align_data_size(struct mmc_card *card, unsigned int sz) 488ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman{ 489ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman /* 490ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * FIXME: We don't have a system for the controller to tell 491ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * the core about its problems yet, so for now we just 32-bit 492ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman * align the size. 493ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman */ 494ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman sz = ((sz + 3) / 4) * 4; 495ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman 496ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman return sz; 497ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman} 498ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre OssmanEXPORT_SYMBOL(mmc_align_data_size); 499ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman 500ad3868b2ec96ec14a1549c9e33f5f9a2a3c6ab15Pierre Ossman/** 5018ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * mmc_host_enable - enable a host. 5028ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * @host: mmc host to enable 5038ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * 5048ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * Hosts that support power saving can use the 'enable' and 'disable' 5058ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * methods to exit and enter power saving states. For more information 5068ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * see comments for struct mmc_host_ops. 5078ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter */ 5088ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunterint mmc_host_enable(struct mmc_host *host) 5098ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 5108ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!(host->caps & MMC_CAP_DISABLE)) 5118ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5128ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5138ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->en_dis_recurs) 5148ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5158ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5168ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->nesting_cnt++) 5178ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5188ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5198ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter cancel_delayed_work_sync(&host->disable); 5208ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5218ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->enabled) 5228ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5238ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5248ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->ops->enable) { 5258ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter int err; 5268ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5278ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->en_dis_recurs = 1; 5288ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter err = host->ops->enable(host); 5298ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->en_dis_recurs = 0; 5308ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5318ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (err) { 5328ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter pr_debug("%s: enable error %d\n", 5338ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_hostname(host), err); 5348ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return err; 5358ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } 5368ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } 5378ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->enabled = 1; 5388ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5398ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 5408ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian HunterEXPORT_SYMBOL(mmc_host_enable); 5418ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5428ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunterstatic int mmc_host_do_disable(struct mmc_host *host, int lazy) 5438ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 5448ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->ops->disable) { 5458ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter int err; 5468ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5478ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->en_dis_recurs = 1; 5488ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter err = host->ops->disable(host, lazy); 5498ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->en_dis_recurs = 0; 5508ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5518ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (err < 0) { 5528ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter pr_debug("%s: disable error %d\n", 5538ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_hostname(host), err); 5548ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return err; 5558ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } 5568ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (err > 0) { 5578ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter unsigned long delay = msecs_to_jiffies(err); 5588ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5598ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_schedule_delayed_work(&host->disable, delay); 5608ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } 5618ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } 5628ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->enabled = 0; 5638ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5648ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 5658ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5668ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter/** 5678ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * mmc_host_disable - disable a host. 5688ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * @host: mmc host to disable 5698ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * 5708ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * Hosts that support power saving can use the 'enable' and 'disable' 5718ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * methods to exit and enter power saving states. For more information 5728ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * see comments for struct mmc_host_ops. 5738ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter */ 5748ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunterint mmc_host_disable(struct mmc_host *host) 5758ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 5768ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter int err; 5778ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5788ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!(host->caps & MMC_CAP_DISABLE)) 5798ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5808ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5818ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->en_dis_recurs) 5828ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5838ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5848ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (--host->nesting_cnt) 5858ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5868ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5878ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!host->enabled) 5888ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 5898ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5908ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter err = mmc_host_do_disable(host, 0); 5918ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return err; 5928ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 5938ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian HunterEXPORT_SYMBOL(mmc_host_disable); 5948ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 5958ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter/** 5962342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre * __mmc_claim_host - exclusively claim a host 5971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @host: mmc host to claim 5982342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre * @abort: whether or not the operation should be aborted 5991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 6002342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre * Claim a host for a set of operations. If @abort is non null and 6012342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre * dereference a non-zero value then this will return prematurely with 6022342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre * that non-zero value without acquiring the lock. Returns zero 6032342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre * with the lock held otherwise. 6041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 6052342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitreint __mmc_claim_host(struct mmc_host *host, atomic_t *abort) 6061da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 6071da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds DECLARE_WAITQUEUE(wait, current); 6081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds unsigned long flags; 6092342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre int stop; 6101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 611cf795bfb3ad4e2f8f6bb346aa8edb8272d4c70a2Pierre Ossman might_sleep(); 612cf795bfb3ad4e2f8f6bb346aa8edb8272d4c70a2Pierre Ossman 6131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds add_wait_queue(&host->wq, &wait); 6141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irqsave(&host->lock, flags); 6151da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds while (1) { 6161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_current_state(TASK_UNINTERRUPTIBLE); 6172342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre stop = abort ? atomic_read(abort) : 0; 618319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter if (stop || !host->claimed || host->claimer == current) 6191da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds break; 6201da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irqrestore(&host->lock, flags); 6211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds schedule(); 6221da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_lock_irqsave(&host->lock, flags); 6231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 6241da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds set_current_state(TASK_RUNNING); 625319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter if (!stop) { 6262342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre host->claimed = 1; 627319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter host->claimer = current; 628319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter host->claim_cnt += 1; 629319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter } else 6302342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre wake_up(&host->wq); 6311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds spin_unlock_irqrestore(&host->lock, flags); 6321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds remove_wait_queue(&host->wq, &wait); 6338ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!stop) 6348ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_host_enable(host); 6352342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas Pitre return stop; 6361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 6371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 6382342f3323c9a76367a1d7f9a35525ee3cb3911dfNicolas PitreEXPORT_SYMBOL(__mmc_claim_host); 6391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 640319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter/** 641319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter * mmc_try_claim_host - try exclusively to claim a host 642319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter * @host: mmc host to claim 643319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter * 644319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter * Returns %1 if the host is claimed, %0 otherwise. 645319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter */ 646319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunterint mmc_try_claim_host(struct mmc_host *host) 6478ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 6488ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter int claimed_host = 0; 6498ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter unsigned long flags; 6508ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 6518ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter spin_lock_irqsave(&host->lock, flags); 652319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter if (!host->claimed || host->claimer == current) { 6538ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter host->claimed = 1; 654319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter host->claimer = current; 655319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter host->claim_cnt += 1; 6568ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter claimed_host = 1; 6578ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } 6588ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter spin_unlock_irqrestore(&host->lock, flags); 6598ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return claimed_host; 6608ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 661319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian HunterEXPORT_SYMBOL(mmc_try_claim_host); 6628ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 663ab1efd271704416c9e6e9cb4e5f58e7e4c4260e6Ulf Hansson/** 664ab1efd271704416c9e6e9cb4e5f58e7e4c4260e6Ulf Hansson * mmc_do_release_host - release a claimed host 665ab1efd271704416c9e6e9cb4e5f58e7e4c4260e6Ulf Hansson * @host: mmc host to release 666ab1efd271704416c9e6e9cb4e5f58e7e4c4260e6Ulf Hansson * 667ab1efd271704416c9e6e9cb4e5f58e7e4c4260e6Ulf Hansson * If you successfully claimed a host, this function will 668ab1efd271704416c9e6e9cb4e5f58e7e4c4260e6Ulf Hansson * release it again. 669ab1efd271704416c9e6e9cb4e5f58e7e4c4260e6Ulf Hansson */ 670ab1efd271704416c9e6e9cb4e5f58e7e4c4260e6Ulf Hanssonvoid mmc_do_release_host(struct mmc_host *host) 6718ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 6728ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter unsigned long flags; 6738ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 6748ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter spin_lock_irqsave(&host->lock, flags); 675319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter if (--host->claim_cnt) { 676319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter /* Release for nested claim */ 677319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter spin_unlock_irqrestore(&host->lock, flags); 678319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter } else { 679319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter host->claimed = 0; 680319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter host->claimer = NULL; 681319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter spin_unlock_irqrestore(&host->lock, flags); 682319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter wake_up(&host->wq); 683319a3f1429c91147058ac26c5f5bac8ec1730bc6Adrian Hunter } 6848ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 685ab1efd271704416c9e6e9cb4e5f58e7e4c4260e6Ulf HanssonEXPORT_SYMBOL(mmc_do_release_host); 6868ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 6878ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Huntervoid mmc_host_deeper_disable(struct work_struct *work) 6888ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 6898ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter struct mmc_host *host = 6908ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter container_of(work, struct mmc_host, disable.work); 6918ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 6928ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter /* If the host is claimed then we do not want to disable it anymore */ 6938ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!mmc_try_claim_host(host)) 6948ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return; 6958ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_host_do_disable(host, 1); 6968ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_do_release_host(host); 6978ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 6988ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 6998ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter/** 7008ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * mmc_host_lazy_disable - lazily disable a host. 7018ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * @host: mmc host to disable 7028ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * 7038ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * Hosts that support power saving can use the 'enable' and 'disable' 7048ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * methods to exit and enter power saving states. For more information 7058ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter * see comments for struct mmc_host_ops. 7068ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter */ 7078ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunterint mmc_host_lazy_disable(struct mmc_host *host) 7088ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter{ 7098ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!(host->caps & MMC_CAP_DISABLE)) 7108ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 7118ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 7128ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->en_dis_recurs) 7138ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 7148ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 7158ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (--host->nesting_cnt) 7168ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 7178ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 7188ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (!host->enabled) 7198ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 7208ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 7218ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->disable_delay) { 7228ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_schedule_delayed_work(&host->disable, 7238ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter msecs_to_jiffies(host->disable_delay)); 7248ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return 0; 7258ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter } else 7268ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter return mmc_host_do_disable(host, 1); 7278ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter} 7288ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian HunterEXPORT_SYMBOL(mmc_host_lazy_disable); 7298ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter 7301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 7311da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * mmc_release_host - release a host 7321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @host: mmc host to release 7331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 7341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Release a MMC host, allowing others to claim the host 7351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * for their operations. 7361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 7371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsvoid mmc_release_host(struct mmc_host *host) 7381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 739d84075c8aed771d47d7ac6e96b098559da361c25Pierre Ossman WARN_ON(!host->claimed); 7401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7418ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_host_lazy_disable(host); 7421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7438ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter mmc_do_release_host(host); 7441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7461da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_release_host); 7471da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7487ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman/* 7497ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Internal function that does the actual ios call to the host driver, 7507ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * optionally printing some debug output. 7517ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman */ 752920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell Kingstatic inline void mmc_set_ios(struct mmc_host *host) 753920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King{ 754920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King struct mmc_ios *ios = &host->ios; 755920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King 756cd9277c011a99769fa371521b460ed57f6d280b1Pierre Ossman pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u " 757cd9277c011a99769fa371521b460ed57f6d280b1Pierre Ossman "width %u timing %u\n", 758920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mmc_hostname(host), ios->clock, ios->bus_mode, 759920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King ios->power_mode, ios->chip_select, ios->vdd, 760cd9277c011a99769fa371521b460ed57f6d280b1Pierre Ossman ios->bus_width, ios->timing); 761fba68bd2dab1ac99af3c5a963ec9581cfa9f1725Philip Langdale 76204566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij if (ios->clock > 0) 76304566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij mmc_set_ungated(host); 764920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King host->ops->set_ios(host, ios); 765920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King} 766920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King 7677ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman/* 7687ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Control chip select pin on a host. 7697ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman */ 770da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossmanvoid mmc_set_chip_select(struct mmc_host *host, int mode) 7711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 772778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg mmc_host_clk_hold(host); 773da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossman host->ios.chip_select = mode; 774da7fbe58d2d347e95af699ddf04d885be6362bbePierre Ossman mmc_set_ios(host); 775778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg mmc_host_clk_release(host); 7761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 7771da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 7781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 7797ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Sets the host clock to the highest possible frequency that 7807ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * is below "hz". 7817ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman */ 782778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerbergstatic void __mmc_set_clock(struct mmc_host *host, unsigned int hz) 7837ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman{ 7847ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman WARN_ON(hz < host->f_min); 7857ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 7867ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman if (hz > host->f_max) 7877ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman hz = host->f_max; 7887ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 7897ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->ios.clock = hz; 7907ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_set_ios(host); 7917ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman} 7927ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 793778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerbergvoid mmc_set_clock(struct mmc_host *host, unsigned int hz) 794778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg{ 795778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg mmc_host_clk_hold(host); 796778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg __mmc_set_clock(host, hz); 797778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg mmc_host_clk_release(host); 798778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg} 799778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg 80004566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij#ifdef CONFIG_MMC_CLKGATE 80104566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij/* 80204566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij * This gates the clock by setting it to 0 Hz. 80304566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij */ 80404566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleijvoid mmc_gate_clock(struct mmc_host *host) 80504566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij{ 80604566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij unsigned long flags; 80704566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij 80804566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij spin_lock_irqsave(&host->clk_lock, flags); 80904566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij host->clk_old = host->ios.clock; 81004566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij host->ios.clock = 0; 81104566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij host->clk_gated = true; 81204566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij spin_unlock_irqrestore(&host->clk_lock, flags); 81304566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij mmc_set_ios(host); 81404566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij} 81504566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij 81604566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij/* 81704566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij * This restores the clock from gating by using the cached 81804566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij * clock value. 81904566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij */ 82004566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleijvoid mmc_ungate_clock(struct mmc_host *host) 82104566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij{ 82204566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij /* 82304566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij * We should previously have gated the clock, so the clock shall 82404566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij * be 0 here! The clock may however be 0 during initialization, 82504566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij * when some request operations are performed before setting 82604566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij * the frequency. When ungate is requested in that situation 82704566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij * we just ignore the call. 82804566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij */ 82904566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij if (host->clk_old) { 83004566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij BUG_ON(host->ios.clock); 83104566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij /* This call will also set host->clk_gated to false */ 832778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg __mmc_set_clock(host, host->clk_old); 83304566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij } 83404566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij} 83504566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij 83604566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleijvoid mmc_set_ungated(struct mmc_host *host) 83704566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij{ 83804566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij unsigned long flags; 83904566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij 84004566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij /* 84104566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij * We've been given a new frequency while the clock is gated, 84204566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij * so make sure we regard this as ungating it. 84304566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij */ 84404566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij spin_lock_irqsave(&host->clk_lock, flags); 84504566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij host->clk_gated = false; 84604566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij spin_unlock_irqrestore(&host->clk_lock, flags); 84704566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij} 84804566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij 84904566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij#else 85004566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleijvoid mmc_set_ungated(struct mmc_host *host) 85104566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij{ 85204566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij} 85304566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij#endif 85404566831a703ae3ef4b49a2deae261c9ed26e020Linus Walleij 8557ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman/* 8567ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Change the bus mode (open drain/push-pull) of a host. 8577ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman */ 8587ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossmanvoid mmc_set_bus_mode(struct mmc_host *host, unsigned int mode) 8597ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman{ 860778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg mmc_host_clk_hold(host); 8617ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->ios.bus_mode = mode; 8627ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_set_ios(host); 863778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg mmc_host_clk_release(host); 8647ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman} 8657ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 8667ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman/* 8670f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter * Change data bus width of a host. 8680f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter */ 8690f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Huntervoid mmc_set_bus_width(struct mmc_host *host, unsigned int width) 8700f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter{ 871778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg mmc_host_clk_hold(host); 8724c4cb171054230c2e58ed6574d7faa1871c75bbePhilip Rakity host->ios.bus_width = width; 8734c4cb171054230c2e58ed6574d7faa1871c75bbePhilip Rakity mmc_set_ios(host); 874778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg mmc_host_clk_release(host); 8750f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter} 8760f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter 87786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov/** 87886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * mmc_vdd_to_ocrbitnum - Convert a voltage to the OCR bit number 87986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * @vdd: voltage (mV) 88086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * @low_bits: prefer low bits in boundary cases 88186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * 88286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * This function returns the OCR bit number according to the provided @vdd 88386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * value. If conversion is not possible a negative errno value returned. 88486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * 88586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * Depending on the @low_bits flag the function prefers low or high OCR bits 88686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * on boundary voltages. For example, 88786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * with @low_bits = true, 3300 mV translates to ilog2(MMC_VDD_32_33); 88886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * with @low_bits = false, 3300 mV translates to ilog2(MMC_VDD_33_34); 88986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * 89086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * Any value in the [1951:1999] range translates to the ilog2(MMC_VDD_20_21). 89186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov */ 89286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsovstatic int mmc_vdd_to_ocrbitnum(int vdd, bool low_bits) 89386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov{ 89486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov const int max_bit = ilog2(MMC_VDD_35_36); 89586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov int bit; 89686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 89786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (vdd < 1650 || vdd > 3600) 89886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return -EINVAL; 89986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 90086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (vdd >= 1650 && vdd <= 1950) 90186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return ilog2(MMC_VDD_165_195); 90286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 90386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (low_bits) 90486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov vdd -= 1; 90586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 90686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov /* Base 2000 mV, step 100 mV, bit's base 8. */ 90786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov bit = (vdd - 2000) / 100 + 8; 90886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (bit > max_bit) 90986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return max_bit; 91086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return bit; 91186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov} 91286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 91386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov/** 91486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * mmc_vddrange_to_ocrmask - Convert a voltage range to the OCR mask 91586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * @vdd_min: minimum voltage value (mV) 91686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * @vdd_max: maximum voltage value (mV) 91786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * 91886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * This function returns the OCR mask bits according to the provided @vdd_min 91986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * and @vdd_max values. If conversion is not possible the function returns 0. 92086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * 92186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * Notes wrt boundary cases: 92286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * This function sets the OCR bits for all boundary voltages, for example 92386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * [3300:3400] range is translated to MMC_VDD_32_33 | MMC_VDD_33_34 | 92486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov * MMC_VDD_34_35 mask. 92586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov */ 92686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsovu32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max) 92786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov{ 92886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov u32 mask = 0; 92986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 93086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (vdd_max < vdd_min) 93186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return 0; 93286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 93386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov /* Prefer high bits for the boundary vdd_max values. */ 93486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov vdd_max = mmc_vdd_to_ocrbitnum(vdd_max, false); 93586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (vdd_max < 0) 93686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return 0; 93786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 93886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov /* Prefer low bits for the boundary vdd_min values. */ 93986e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov vdd_min = mmc_vdd_to_ocrbitnum(vdd_min, true); 94086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov if (vdd_min < 0) 94186e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return 0; 94286e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 94386e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov /* Fill the mask, from max bit to min bit. */ 94486e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov while (vdd_max >= vdd_min) 94586e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov mask |= 1 << vdd_max--; 94686e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 94786e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov return mask; 94886e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov} 94986e8286a0e48663e1e86a5884b30a6d05de2993aAnton VorontsovEXPORT_SYMBOL(mmc_vddrange_to_ocrmask); 95086e8286a0e48663e1e86a5884b30a6d05de2993aAnton Vorontsov 9515c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell#ifdef CONFIG_REGULATOR 9525c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 9535c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell/** 9545c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * mmc_regulator_get_ocrmask - return mask of supported voltages 9555c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * @supply: regulator to use 9565c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * 9575c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * This returns either a negative errno, or a mask of voltages that 9585c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * can be provided to MMC/SD/SDIO devices using the specified voltage 9595c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * regulator. This would normally be called before registering the 9605c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * MMC host adapter. 9615c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell */ 9625c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownellint mmc_regulator_get_ocrmask(struct regulator *supply) 9635c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell{ 9645c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int result = 0; 9655c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int count; 9665c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int i; 9675c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 9685c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell count = regulator_count_voltages(supply); 9695c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell if (count < 0) 9705c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell return count; 9715c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 9725c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell for (i = 0; i < count; i++) { 9735c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int vdd_uV; 9745c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int vdd_mV; 9755c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 9765c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell vdd_uV = regulator_list_voltage(supply, i); 9775c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell if (vdd_uV <= 0) 9785c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell continue; 9795c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 9805c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell vdd_mV = vdd_uV / 1000; 9815c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell result |= mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV); 9825c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell } 9835c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 9845c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell return result; 9855c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell} 9865c13941acc513669c7d07b28789c3f9ba66ddddfDavid BrownellEXPORT_SYMBOL(mmc_regulator_get_ocrmask); 9875c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 9885c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell/** 9895c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * mmc_regulator_set_ocr - set regulator to match host->ios voltage 99099fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij * @mmc: the host to regulate 9915c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * @supply: regulator to use 99299fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij * @vdd_bit: zero for power off, else a bit number (host->ios.vdd) 9935c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * 9945c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * Returns zero on success, else negative errno. 9955c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * 9965c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * MMC host drivers may use this to enable or disable a regulator using 9975c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * a particular supply voltage. This would normally be called from the 9985c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * set_ios() method. 9995c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell */ 100099fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleijint mmc_regulator_set_ocr(struct mmc_host *mmc, 100199fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij struct regulator *supply, 100299fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij unsigned short vdd_bit) 10035c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell{ 10045c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int result = 0; 10055c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int min_uV, max_uV; 10065c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 10075c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell if (vdd_bit) { 10085c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int tmp; 10095c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell int voltage; 10105c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 10115c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell /* REVISIT mmc_vddrange_to_ocrmask() may have set some 10125c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * bits this regulator doesn't quite support ... don't 10135c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * be too picky, most cards and regulators are OK with 10145c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * a 0.1V range goof (it's a small error percentage). 10155c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell */ 10165c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell tmp = vdd_bit - ilog2(MMC_VDD_165_195); 10175c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell if (tmp == 0) { 10185c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell min_uV = 1650 * 1000; 10195c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell max_uV = 1950 * 1000; 10205c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell } else { 10215c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell min_uV = 1900 * 1000 + tmp * 100 * 1000; 10225c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell max_uV = min_uV + 100 * 1000; 10235c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell } 10245c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 10255c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell /* avoid needless changes to this voltage; the regulator 10265c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell * might not allow this operation 10275c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell */ 10285c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell voltage = regulator_get_voltage(supply); 10295c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell if (voltage < 0) 10305c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell result = voltage; 10315c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell else if (voltage < min_uV || voltage > max_uV) 10325c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell result = regulator_set_voltage(supply, min_uV, max_uV); 10335c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell else 10345c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell result = 0; 10355c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 103699fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij if (result == 0 && !mmc->regulator_enabled) { 10375c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell result = regulator_enable(supply); 103899fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij if (!result) 103999fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij mmc->regulator_enabled = true; 104099fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij } 104199fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij } else if (mmc->regulator_enabled) { 10425c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell result = regulator_disable(supply); 104399fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij if (result == 0) 104499fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij mmc->regulator_enabled = false; 10455c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell } 10465c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 104799fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij if (result) 104899fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij dev_err(mmc_dev(mmc), 104999fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij "could not set regulator OCR (%d)\n", result); 10505c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell return result; 10515c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell} 10525c13941acc513669c7d07b28789c3f9ba66ddddfDavid BrownellEXPORT_SYMBOL(mmc_regulator_set_ocr); 10535c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 105499fc5131018cbdc3cf42ce09fb394a4e8b053c74Linus Walleij#endif /* CONFIG_REGULATOR */ 10555c13941acc513669c7d07b28789c3f9ba66ddddfDavid Brownell 10567ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman/* 10571da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * Mask off any voltages we don't support and select 10581da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * the lowest voltage 10591da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 10607ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossmanu32 mmc_select_voltage(struct mmc_host *host, u32 ocr) 10611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 10621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds int bit; 10631da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ocr &= host->ocr_avail; 10651da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10661da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bit = ffs(ocr); 10671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds if (bit) { 10681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds bit -= 1; 10691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 107063ef731aa6a81e286de78dcc92241d123424ed39Timo Teras ocr &= 3 << bit; 10711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1072778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg mmc_host_clk_hold(host); 10731da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.vdd = bit; 1074920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mmc_set_ios(host); 1075778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg mmc_host_clk_release(host); 10761da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } else { 1077f6e10b865c3ea56bdaa8c6ecfee313b997900dbbDavid Brownell pr_warning("%s: host doesn't support card's voltages\n", 1078f6e10b865c3ea56bdaa8c6ecfee313b997900dbbDavid Brownell mmc_hostname(host)); 10791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds ocr = 0; 10801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 10811da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 10821da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds return ocr; 10831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 10841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1085261bbd463a091b939770255d559bbc89b1bad568Philip Rakityint mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage, bool cmd11) 1086f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath{ 1087f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath struct mmc_command cmd = {0}; 1088f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath int err = 0; 1089f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath 1090f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath BUG_ON(!host); 1091f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath 1092f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath /* 1093f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath * Send CMD11 only if the request is to switch the card to 1094f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath * 1.8V signalling. 1095f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath */ 1096261bbd463a091b939770255d559bbc89b1bad568Philip Rakity if ((signal_voltage != MMC_SIGNAL_VOLTAGE_330) && cmd11) { 1097f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath cmd.opcode = SD_SWITCH_VOLTAGE; 1098f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath cmd.arg = 0; 1099f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 1100f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath 1101f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath err = mmc_wait_for_cmd(host, &cmd, 0); 1102f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath if (err) 1103f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath return err; 1104f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath 1105f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath if (!mmc_host_is_spi(host) && (cmd.resp[0] & R1_ERROR)) 1106f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath return -EIO; 1107f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath } 1108f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath 1109f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath host->ios.signal_voltage = signal_voltage; 1110f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath 1111f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath if (host->ops->start_signal_voltage_switch) 1112f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath err = host->ops->start_signal_voltage_switch(host, &host->ios); 1113f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath 1114f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath return err; 1115f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath} 1116f2119df6b764609af4baceb68caf1e848c1c8aa7Arindam Nath 11171da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 11187ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Select timing parameters for host. 1119b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman */ 11207ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossmanvoid mmc_set_timing(struct mmc_host *host, unsigned int timing) 1121b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman{ 1122778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg mmc_host_clk_hold(host); 11237ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->ios.timing = timing; 11247ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_set_ios(host); 1125778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg mmc_host_clk_release(host); 1126b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman} 1127b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman 1128b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman/* 1129d6d50a15a2897d4133d536dd4343b5cf21163db3Arindam Nath * Select appropriate driver type for host. 1130d6d50a15a2897d4133d536dd4343b5cf21163db3Arindam Nath */ 1131d6d50a15a2897d4133d536dd4343b5cf21163db3Arindam Nathvoid mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type) 1132d6d50a15a2897d4133d536dd4343b5cf21163db3Arindam Nath{ 1133778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg mmc_host_clk_hold(host); 1134d6d50a15a2897d4133d536dd4343b5cf21163db3Arindam Nath host->ios.drv_type = drv_type; 1135d6d50a15a2897d4133d536dd4343b5cf21163db3Arindam Nath mmc_set_ios(host); 1136778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg mmc_host_clk_release(host); 1137d6d50a15a2897d4133d536dd4343b5cf21163db3Arindam Nath} 1138d6d50a15a2897d4133d536dd4343b5cf21163db3Arindam Nath 1139d6d50a15a2897d4133d536dd4343b5cf21163db3Arindam Nath/* 114045f8245b972e360c19aec9032e2a2033b8ac3719Russell King * Apply power to the MMC stack. This is a two-stage process. 114145f8245b972e360c19aec9032e2a2033b8ac3719Russell King * First, we enable power to the card without the clock running. 114245f8245b972e360c19aec9032e2a2033b8ac3719Russell King * We then wait a bit for the power to stabilise. Finally, 114345f8245b972e360c19aec9032e2a2033b8ac3719Russell King * enable the bus drivers and clock to the card. 114445f8245b972e360c19aec9032e2a2033b8ac3719Russell King * 114545f8245b972e360c19aec9032e2a2033b8ac3719Russell King * We must _NOT_ enable the clock prior to power stablising. 114645f8245b972e360c19aec9032e2a2033b8ac3719Russell King * 114745f8245b972e360c19aec9032e2a2033b8ac3719Russell King * If a host does all the power sequencing itself, ignore the 114845f8245b972e360c19aec9032e2a2033b8ac3719Russell King * initial MMC_POWER_UP stage. 11491da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 11501da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsstatic void mmc_power_up(struct mmc_host *host) 11511da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1152500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao int bit; 1153500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao 1154778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg mmc_host_clk_hold(host); 1155778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg 1156500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao /* If ocr is set, we use it */ 1157500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao if (host->ocr) 1158500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao bit = ffs(host->ocr) - 1; 1159500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao else 1160500f35648e5ebd04be00f974738a9db959a892b8Balaji Rao bit = fls(host->ocr_avail) - 1; 11611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.vdd = bit; 1163af51715079e7fb6b290e1881d63d815dc4de5011David Brownell if (mmc_host_is_spi(host)) { 1164af51715079e7fb6b290e1881d63d815dc4de5011David Brownell host->ios.chip_select = MMC_CS_HIGH; 1165af51715079e7fb6b290e1881d63d815dc4de5011David Brownell host->ios.bus_mode = MMC_BUSMODE_PUSHPULL; 1166af51715079e7fb6b290e1881d63d815dc4de5011David Brownell } else { 1167af51715079e7fb6b290e1881d63d815dc4de5011David Brownell host->ios.chip_select = MMC_CS_DONTCARE; 1168af51715079e7fb6b290e1881d63d815dc4de5011David Brownell host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN; 1169af51715079e7fb6b290e1881d63d815dc4de5011David Brownell } 11701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.power_mode = MMC_POWER_UP; 1171f218278a456b3c272b480443c89004c3d2a49f18Pierre Ossman host->ios.bus_width = MMC_BUS_WIDTH_1; 1172cd9277c011a99769fa371521b460ed57f6d280b1Pierre Ossman host->ios.timing = MMC_TIMING_LEGACY; 1173920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mmc_set_ios(host); 11741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1175f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman /* 1176f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman * This delay should be sufficient to allow the power supply 1177f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman * to reach the minimum voltage. 1178f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman */ 117979bccc5aefb4e64e651abe04f78c3e6bf8acd6f0José M. Fernández mmc_delay(10); 11801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 118188ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch host->ios.clock = host->f_init; 11828dfd0374be84793360db7fff2e635d2cd3bbcb21Sascha Hauer 11831da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.power_mode = MMC_POWER_ON; 1184920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mmc_set_ios(host); 11851da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1186f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman /* 1187f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman * This delay must be at least 74 clock sizes, or 1 ms, or the 1188f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman * time required to reach a stable voltage. 1189f9996aee36921e8f1d499de1b2ea380855cf6d97Pierre Ossman */ 119079bccc5aefb4e64e651abe04f78c3e6bf8acd6f0José M. Fernández mmc_delay(10); 1191778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg 1192778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg mmc_host_clk_release(host); 11931da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 11941da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 11957f7e4129c23f0419257184dff6fec89d2d5a8964Ulf Hanssonvoid mmc_power_off(struct mmc_host *host) 11961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1197778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg mmc_host_clk_hold(host); 1198778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg 11991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.clock = 0; 12001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.vdd = 0; 1201b33d46c398fd071dccd0815f33620924684860cdUlf Hansson 1202b33d46c398fd071dccd0815f33620924684860cdUlf Hansson /* 1203b33d46c398fd071dccd0815f33620924684860cdUlf Hansson * Reset ocr mask to be the highest possible voltage supported for 1204b33d46c398fd071dccd0815f33620924684860cdUlf Hansson * this mmc host. This value will be used at next power up. 1205b33d46c398fd071dccd0815f33620924684860cdUlf Hansson */ 1206b33d46c398fd071dccd0815f33620924684860cdUlf Hansson host->ocr = 1 << (fls(host->ocr_avail) - 1); 1207b33d46c398fd071dccd0815f33620924684860cdUlf Hansson 1208af51715079e7fb6b290e1881d63d815dc4de5011David Brownell if (!mmc_host_is_spi(host)) { 1209af51715079e7fb6b290e1881d63d815dc4de5011David Brownell host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN; 1210af51715079e7fb6b290e1881d63d815dc4de5011David Brownell host->ios.chip_select = MMC_CS_DONTCARE; 1211af51715079e7fb6b290e1881d63d815dc4de5011David Brownell } 12121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds host->ios.power_mode = MMC_POWER_OFF; 1213f218278a456b3c272b480443c89004c3d2a49f18Pierre Ossman host->ios.bus_width = MMC_BUS_WIDTH_1; 1214cd9277c011a99769fa371521b460ed57f6d280b1Pierre Ossman host->ios.timing = MMC_TIMING_LEGACY; 1215920e70c5c603ada05dd480ca0ccc0ae12a5fdc39Russell King mmc_set_ios(host); 1216778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg 1217041beb1d531f538bf62377e2ca2b4ecbaa479d75Daniel Drake /* 1218041beb1d531f538bf62377e2ca2b4ecbaa479d75Daniel Drake * Some configurations, such as the 802.11 SDIO card in the OLPC 1219041beb1d531f538bf62377e2ca2b4ecbaa479d75Daniel Drake * XO-1.5, require a short delay after poweroff before the card 1220041beb1d531f538bf62377e2ca2b4ecbaa479d75Daniel Drake * can be successfully turned on again. 1221041beb1d531f538bf62377e2ca2b4ecbaa479d75Daniel Drake */ 1222041beb1d531f538bf62377e2ca2b4ecbaa479d75Daniel Drake mmc_delay(1); 1223041beb1d531f538bf62377e2ca2b4ecbaa479d75Daniel Drake 1224778e277cb82411c9002ca28ccbd216c4d9eb9158Mika Westerberg mmc_host_clk_release(host); 12251da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 12261da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 12271da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/* 1228393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk * Cleanup when the last reference to the bus operator is dropped. 1229393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk */ 1230261172fd1b23769bc7632047e2cb826c9b8b1a50Adrian Bunkstatic void __mmc_release_bus(struct mmc_host *host) 1231393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk{ 1232393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk BUG_ON(!host); 1233393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk BUG_ON(host->bus_refs); 1234393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk BUG_ON(!host->bus_dead); 1235393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk 1236393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk host->bus_ops = NULL; 1237393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk} 1238393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk 1239393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk/* 1240393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk * Increase reference count of bus operator 1241393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk */ 1242393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunkstatic inline void mmc_bus_get(struct mmc_host *host) 1243393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk{ 1244393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk unsigned long flags; 1245393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk 1246393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk spin_lock_irqsave(&host->lock, flags); 1247393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk host->bus_refs++; 1248393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk spin_unlock_irqrestore(&host->lock, flags); 1249393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk} 1250393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk 1251393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk/* 1252393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk * Decrease reference count of bus operator and free it if 1253393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk * it is the last reference. 1254393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk */ 1255393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunkstatic inline void mmc_bus_put(struct mmc_host *host) 1256393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk{ 1257393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk unsigned long flags; 1258393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk 1259393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk spin_lock_irqsave(&host->lock, flags); 1260393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk host->bus_refs--; 1261393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk if ((host->bus_refs == 0) && host->bus_ops) 1262393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk __mmc_release_bus(host); 1263393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk spin_unlock_irqrestore(&host->lock, flags); 1264393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk} 1265393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk 1266393618510d5349e07d71dc28fb6fc49baf0d96a0Adrian Bunk/* 12677ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * Assign a mmc bus handler to a host. Only one bus handler may control a 12687ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman * host at any given time. 12691da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 12707ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossmanvoid mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops) 12711da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 12727ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman unsigned long flags; 1273e45a1bd20fa5b920901879e85cdf5eda21f78d7cPhilip Langdale 12747ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman BUG_ON(!host); 12757ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman BUG_ON(!ops); 1276b855885e3b60cf6f9452848712a62517b94583ebPierre Ossman 1277d84075c8aed771d47d7ac6e96b098559da361c25Pierre Ossman WARN_ON(!host->claimed); 1278bce40a36de574376f41f1ff3c4d212a7da2a3c90Philip Langdale 12797ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman spin_lock_irqsave(&host->lock, flags); 1280bce40a36de574376f41f1ff3c4d212a7da2a3c90Philip Langdale 12817ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman BUG_ON(host->bus_ops); 12827ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman BUG_ON(host->bus_refs); 1283b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman 12847ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->bus_ops = ops; 12857ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->bus_refs = 1; 12867ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->bus_dead = 0; 1287b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman 12887ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman spin_unlock_irqrestore(&host->lock, flags); 1289b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman} 1290b57c43ad81602589afca3948a5a7121e40026e17Pierre Ossman 12917ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman/* 12927f7e4129c23f0419257184dff6fec89d2d5a8964Ulf Hansson * Remove the current bus handler from a host. 12937ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman */ 12947ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossmanvoid mmc_detach_bus(struct mmc_host *host) 12957ccd266e676a3f0c6f8f897f58b684cac3dd1650Pierre Ossman{ 12967ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman unsigned long flags; 12977ccd266e676a3f0c6f8f897f58b684cac3dd1650Pierre Ossman 12987ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman BUG_ON(!host); 12997ccd266e676a3f0c6f8f897f58b684cac3dd1650Pierre Ossman 1300d84075c8aed771d47d7ac6e96b098559da361c25Pierre Ossman WARN_ON(!host->claimed); 1301d84075c8aed771d47d7ac6e96b098559da361c25Pierre Ossman WARN_ON(!host->bus_ops); 1302cd9277c011a99769fa371521b460ed57f6d280b1Pierre Ossman 13037ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman spin_lock_irqsave(&host->lock, flags); 13047ccd266e676a3f0c6f8f897f58b684cac3dd1650Pierre Ossman 13057ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->bus_dead = 1; 13067ccd266e676a3f0c6f8f897f58b684cac3dd1650Pierre Ossman 13077ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman spin_unlock_irqrestore(&host->lock, flags); 13081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13097ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_put(host); 13101da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13111da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13121da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 13131da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * mmc_detect_change - process change of state on a MMC socket 13141da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @host: host which changed state. 13158dc003359cc3996abad9e53a7b2280b272610283Richard Purdie * @delay: optional delay to wait before detection (jiffies) 13161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * 131767a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * MMC drivers should call this when they detect a card has been 131867a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * inserted or removed. The MMC layer will confirm that any 131967a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * present card is still functional, and initialize any newly 132067a61c484735de9bf4f099830ecb4ef2eca95c38Pierre Ossman * inserted. 13211da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 13228dc003359cc3996abad9e53a7b2280b272610283Richard Purdievoid mmc_detect_change(struct mmc_host *host, unsigned long delay) 13231da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 13243b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman#ifdef CONFIG_MMC_DEBUG 13251efd48b3ae8f89a1d04f1e36be96764d7bf43ae9Pierre Ossman unsigned long flags; 132601f41ec7b36e14da18a4e162ef697ae358f36e37Andrew Morton spin_lock_irqsave(&host->lock, flags); 1327d84075c8aed771d47d7ac6e96b098559da361c25Pierre Ossman WARN_ON(host->removed); 132801f41ec7b36e14da18a4e162ef697ae358f36e37Andrew Morton spin_unlock_irqrestore(&host->lock, flags); 13293b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman#endif 13303b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman 1331c4028958b6ecad064b1a6303a6a5906d4fe48d73David Howells mmc_schedule_delayed_work(&host->detect, delay); 13321da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 13331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 13341da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_detect_change); 13351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1336dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Huntervoid mmc_init_erase(struct mmc_card *card) 1337dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1338dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int sz; 1339dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1340dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (is_power_of_2(card->erase_size)) 1341dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->erase_shift = ffs(card->erase_size) - 1; 1342dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1343dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->erase_shift = 0; 1344dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1345dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* 1346dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * It is possible to erase an arbitrarily large area of an SD or MMC 1347dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * card. That is not desirable because it can take a long time 1348dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * (minutes) potentially delaying more important I/O, and also the 1349dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * timeout calculations become increasingly hugely over-estimated. 1350dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * Consequently, 'pref_erase' is defined as a guide to limit erases 1351dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * to that size and alignment. 1352dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * 1353dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * For SD cards that define Allocation Unit size, limit erases to one 1354dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * Allocation Unit at a time. For MMC cards that define High Capacity 1355dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * Erase Size, whether it is switched on or not, limit to that size. 1356dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * Otherwise just have a stab at a good value. For modern cards it 1357dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * will end up being 4MiB. Note that if the value is too small, it 1358dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * can end up taking longer to erase. 1359dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter */ 1360dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (mmc_card_sd(card) && card->ssr.au) { 1361dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->pref_erase = card->ssr.au; 1362dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->erase_shift = ffs(card->ssr.au) - 1; 1363dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } else if (card->ext_csd.hc_erase_size) { 1364dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->pref_erase = card->ext_csd.hc_erase_size; 1365dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } else { 1366dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter sz = (card->csd.capacity << (card->csd.read_blkbits - 9)) >> 11; 1367dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (sz < 128) 1368dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->pref_erase = 512 * 1024 / 512; 1369dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else if (sz < 512) 1370dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->pref_erase = 1024 * 1024 / 512; 1371dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else if (sz < 1024) 1372dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->pref_erase = 2 * 1024 * 1024 / 512; 1373dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1374dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->pref_erase = 4 * 1024 * 1024 / 512; 1375dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (card->pref_erase < card->erase_size) 1376dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->pref_erase = card->erase_size; 1377dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else { 1378dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter sz = card->pref_erase % card->erase_size; 1379dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (sz) 1380dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter card->pref_erase += card->erase_size - sz; 1381dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1382dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1383dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1384dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1385eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentinstatic unsigned int mmc_mmc_erase_timeout(struct mmc_card *card, 1386eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentin unsigned int arg, unsigned int qty) 1387dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1388dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int erase_timeout; 1389dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1390dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (card->ext_csd.erase_group_def & 1) { 1391dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* High Capacity Erase Group Size uses HC timeouts */ 1392dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (arg == MMC_TRIM_ARG) 1393dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter erase_timeout = card->ext_csd.trim_timeout; 1394dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1395dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter erase_timeout = card->ext_csd.hc_erase_timeout; 1396dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } else { 1397dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* CSD Erase Group Size uses write timeout */ 1398dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int mult = (10 << card->csd.r2w_factor); 1399dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int timeout_clks = card->csd.tacc_clks * mult; 1400dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int timeout_us; 1401dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1402dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* Avoid overflow: e.g. tacc_ns=80000000 mult=1280 */ 1403dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (card->csd.tacc_ns < 1000000) 1404dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter timeout_us = (card->csd.tacc_ns * mult) / 1000; 1405dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1406dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter timeout_us = (card->csd.tacc_ns / 1000) * mult; 1407dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1408dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* 1409dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * ios.clock is only a target. The real clock rate might be 1410dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * less but not that much less, so fudge it by multiplying by 2. 1411dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter */ 1412dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter timeout_clks <<= 1; 1413dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter timeout_us += (timeout_clks * 1000) / 14144cf8c6dd2e261da94b87c4deadcc136ab022b6acAdrian Hunter (mmc_host_clk_rate(card->host) / 1000); 1415dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1416dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter erase_timeout = timeout_us / 1000; 1417dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1418dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* 1419dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * Theoretically, the calculation could underflow so round up 1420dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * to 1ms in that case. 1421dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter */ 1422dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (!erase_timeout) 1423dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter erase_timeout = 1; 1424dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1425dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1426dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* Multiplier for secure operations */ 1427dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (arg & MMC_SECURE_ARGS) { 1428dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (arg == MMC_SECURE_ERASE_ARG) 1429dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter erase_timeout *= card->ext_csd.sec_erase_mult; 1430dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1431dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter erase_timeout *= card->ext_csd.sec_trim_mult; 1432dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1433dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1434dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter erase_timeout *= qty; 1435dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1436dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* 1437dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * Ensure at least a 1 second timeout for SPI as per 1438dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * 'mmc_set_data_timeout()' 1439dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter */ 1440dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (mmc_host_is_spi(card->host) && erase_timeout < 1000) 1441dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter erase_timeout = 1000; 1442dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1443eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentin return erase_timeout; 1444dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1445dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1446eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentinstatic unsigned int mmc_sd_erase_timeout(struct mmc_card *card, 1447eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentin unsigned int arg, 1448eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentin unsigned int qty) 1449dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1450eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentin unsigned int erase_timeout; 1451eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentin 1452dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (card->ssr.erase_timeout) { 1453dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* Erase timeout specified in SD Status Register (SSR) */ 1454eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentin erase_timeout = card->ssr.erase_timeout * qty + 1455eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentin card->ssr.erase_offset; 1456dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } else { 1457dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* 1458dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * Erase timeout not specified in SD Status Register (SSR) so 1459dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * use 250ms per write block. 1460dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter */ 1461eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentin erase_timeout = 250 * qty; 1462dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1463dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1464dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* Must not be less than 1 second */ 1465eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentin if (erase_timeout < 1000) 1466eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentin erase_timeout = 1000; 1467eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentin 1468eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentin return erase_timeout; 1469dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1470dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1471eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentinstatic unsigned int mmc_erase_timeout(struct mmc_card *card, 1472eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentin unsigned int arg, 1473eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentin unsigned int qty) 1474dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1475dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (mmc_card_sd(card)) 1476eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentin return mmc_sd_erase_timeout(card, arg, qty); 1477dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1478eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentin return mmc_mmc_erase_timeout(card, arg, qty); 1479dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1480dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1481dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunterstatic int mmc_do_erase(struct mmc_card *card, unsigned int from, 1482dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int to, unsigned int arg) 1483dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 14841278dba167f01bb3c6626d16450d31129d041087Chris Ball struct mmc_command cmd = {0}; 1485dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int qty = 0; 1486dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter int err; 1487dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1488dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* 1489dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * qty is used to calculate the erase timeout which depends on how many 1490dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * erase groups (or allocation units in SD terminology) are affected. 1491dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * We count erasing part of an erase group as one erase group. 1492dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * For SD, the allocation units are always a power of 2. For MMC, the 1493dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * erase group size is almost certainly also power of 2, but it does not 1494dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * seem to insist on that in the JEDEC standard, so we fall back to 1495dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * division in that case. SD may not specify an allocation unit size, 1496dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * in which case the timeout is based on the number of write blocks. 1497dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * 1498dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * Note that the timeout for secure trim 2 will only be correct if the 1499dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * number of erase groups specified is the same as the total of all 1500dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * preceding secure trim 1 commands. Since the power may have been 1501dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * lost since the secure trim 1 commands occurred, it is generally 1502dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * impossible to calculate the secure trim 2 timeout correctly. 1503dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter */ 1504dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (card->erase_shift) 1505dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter qty += ((to >> card->erase_shift) - 1506dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter (from >> card->erase_shift)) + 1; 1507dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else if (mmc_card_sd(card)) 1508dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter qty += to - from + 1; 1509dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1510dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter qty += ((to / card->erase_size) - 1511dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter (from / card->erase_size)) + 1; 1512dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1513dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (!mmc_card_blockaddr(card)) { 1514dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter from <<= 9; 1515dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter to <<= 9; 1516dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1517dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1518dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (mmc_card_sd(card)) 1519dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.opcode = SD_ERASE_WR_BLK_START; 1520dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1521dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.opcode = MMC_ERASE_GROUP_START; 1522dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.arg = from; 1523dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 1524dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err = mmc_wait_for_cmd(card->host, &cmd, 0); 1525dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (err) { 1526dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter printk(KERN_ERR "mmc_erase: group start error %d, " 1527dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter "status %#x\n", err, cmd.resp[0]); 1528dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err = -EINVAL; 1529dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter goto out; 1530dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1531dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1532dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter memset(&cmd, 0, sizeof(struct mmc_command)); 1533dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (mmc_card_sd(card)) 1534dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.opcode = SD_ERASE_WR_BLK_END; 1535dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1536dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.opcode = MMC_ERASE_GROUP_END; 1537dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.arg = to; 1538dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 1539dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err = mmc_wait_for_cmd(card->host, &cmd, 0); 1540dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (err) { 1541dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter printk(KERN_ERR "mmc_erase: group end error %d, status %#x\n", 1542dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err, cmd.resp[0]); 1543dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err = -EINVAL; 1544dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter goto out; 1545dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1546dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1547dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter memset(&cmd, 0, sizeof(struct mmc_command)); 1548dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.opcode = MMC_ERASE; 1549dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.arg = arg; 1550dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC; 1551eaa02f751ff4f8abfc2e55a15c20a5a274244418Andrei Warkentin cmd.cmd_timeout_ms = mmc_erase_timeout(card, arg, qty); 1552dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err = mmc_wait_for_cmd(card->host, &cmd, 0); 1553dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (err) { 1554dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter printk(KERN_ERR "mmc_erase: erase error %d, status %#x\n", 1555dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err, cmd.resp[0]); 1556dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err = -EIO; 1557dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter goto out; 1558dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1559dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1560dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (mmc_host_is_spi(card->host)) 1561dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter goto out; 1562dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1563dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter do { 1564dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter memset(&cmd, 0, sizeof(struct mmc_command)); 1565dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.opcode = MMC_SEND_STATUS; 1566dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.arg = card->rca << 16; 1567dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 1568dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* Do not retry else we can't see errors */ 1569dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err = mmc_wait_for_cmd(card->host, &cmd, 0); 1570dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (err || (cmd.resp[0] & 0xFDF92000)) { 1571dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter printk(KERN_ERR "error %d requesting status %#x\n", 1572dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err, cmd.resp[0]); 1573dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter err = -EIO; 1574dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter goto out; 1575dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1576dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } while (!(cmd.resp[0] & R1_READY_FOR_DATA) || 15777435bb7950ba8a3cbfa6d0c01e92588562533a3fJaehoon Chung R1_CURRENT_STATE(cmd.resp[0]) == R1_STATE_PRG); 1578dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunterout: 1579dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return err; 1580dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1581dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1582dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter/** 1583dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * mmc_erase - erase sectors. 1584dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * @card: card to erase 1585dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * @from: first sector to erase 1586dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * @nr: number of sectors to erase 1587dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * @arg: erase command argument (SD supports only %MMC_ERASE_ARG) 1588dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * 1589dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter * Caller must claim host before calling this function. 1590dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter */ 1591dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunterint mmc_erase(struct mmc_card *card, unsigned int from, unsigned int nr, 1592dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int arg) 1593dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1594dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int rem, to = from + nr; 1595dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1596dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (!(card->host->caps & MMC_CAP_ERASE) || 1597dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter !(card->csd.cmdclass & CCC_ERASE)) 1598dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return -EOPNOTSUPP; 1599dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1600dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (!card->erase_size) 1601dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return -EOPNOTSUPP; 1602dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1603dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (mmc_card_sd(card) && arg != MMC_ERASE_ARG) 1604dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return -EOPNOTSUPP; 1605dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1606dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if ((arg & MMC_SECURE_ARGS) && 1607dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN)) 1608dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return -EOPNOTSUPP; 1609dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1610dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if ((arg & MMC_TRIM_ARGS) && 1611dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN)) 1612dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return -EOPNOTSUPP; 1613dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1614dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (arg == MMC_SECURE_ERASE_ARG) { 1615dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (from % card->erase_size || nr % card->erase_size) 1616dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return -EINVAL; 1617dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1618dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1619dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (arg == MMC_ERASE_ARG) { 1620dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter rem = from % card->erase_size; 1621dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (rem) { 1622dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter rem = card->erase_size - rem; 1623dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter from += rem; 1624dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (nr > rem) 1625dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter nr -= rem; 1626dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter else 1627dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 0; 1628dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1629dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter rem = nr % card->erase_size; 1630dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (rem) 1631dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter nr -= rem; 1632dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter } 1633dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1634dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (nr == 0) 1635dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 0; 1636dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1637dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter to = from + nr; 1638dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1639dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (to <= from) 1640dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return -EINVAL; 1641dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1642dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter /* 'from' and 'to' are inclusive */ 1643dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter to -= 1; 1644dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1645dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return mmc_do_erase(card, from, to, arg); 1646dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1647dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian HunterEXPORT_SYMBOL(mmc_erase); 1648dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1649dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunterint mmc_can_erase(struct mmc_card *card) 1650dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1651dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if ((card->host->caps & MMC_CAP_ERASE) && 1652dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter (card->csd.cmdclass & CCC_ERASE) && card->erase_size) 1653dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 1; 1654dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 0; 1655dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1656dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian HunterEXPORT_SYMBOL(mmc_can_erase); 1657dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1658dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunterint mmc_can_trim(struct mmc_card *card) 1659dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1660dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN) 1661dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 1; 1662dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 0; 1663dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1664dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian HunterEXPORT_SYMBOL(mmc_can_trim); 1665dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1666dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunterint mmc_can_secure_erase_trim(struct mmc_card *card) 1667dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1668dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN) 1669dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 1; 1670dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 0; 1671dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1672dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian HunterEXPORT_SYMBOL(mmc_can_secure_erase_trim); 1673dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter 1674dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunterint mmc_erase_group_aligned(struct mmc_card *card, unsigned int from, 1675dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter unsigned int nr) 1676dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter{ 1677dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (!card->erase_size) 1678dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 0; 1679dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter if (from % card->erase_size || nr % card->erase_size) 1680dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 0; 1681dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter return 1; 1682dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian Hunter} 1683dfe86cba7676d58db8de7e623f5e72f1b0d3ca35Adrian HunterEXPORT_SYMBOL(mmc_erase_group_aligned); 16841da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1685e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunterstatic unsigned int mmc_do_calc_max_discard(struct mmc_card *card, 1686e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter unsigned int arg) 1687e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter{ 1688e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter struct mmc_host *host = card->host; 1689e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter unsigned int max_discard, x, y, qty = 0, max_qty, timeout; 1690e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter unsigned int last_timeout = 0; 1691e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter 1692e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter if (card->erase_shift) 1693e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter max_qty = UINT_MAX >> card->erase_shift; 1694e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter else if (mmc_card_sd(card)) 1695e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter max_qty = UINT_MAX; 1696e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter else 1697e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter max_qty = UINT_MAX / card->erase_size; 1698e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter 1699e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter /* Find the largest qty with an OK timeout */ 1700e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter do { 1701e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter y = 0; 1702e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter for (x = 1; x && x <= max_qty && max_qty - x >= qty; x <<= 1) { 1703e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter timeout = mmc_erase_timeout(card, arg, qty + x); 1704e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter if (timeout > host->max_discard_to) 1705e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter break; 1706e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter if (timeout < last_timeout) 1707e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter break; 1708e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter last_timeout = timeout; 1709e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter y = x; 1710e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter } 1711e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter qty += y; 1712e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter } while (y); 1713e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter 1714e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter if (!qty) 1715e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter return 0; 1716e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter 1717e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter if (qty == 1) 1718e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter return 1; 1719e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter 1720e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter /* Convert qty to sectors */ 1721e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter if (card->erase_shift) 1722e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter max_discard = --qty << card->erase_shift; 1723e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter else if (mmc_card_sd(card)) 1724e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter max_discard = qty; 1725e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter else 1726e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter max_discard = --qty * card->erase_size; 1727e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter 1728e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter return max_discard; 1729e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter} 1730e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter 1731e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunterunsigned int mmc_calc_max_discard(struct mmc_card *card) 1732e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter{ 1733e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter struct mmc_host *host = card->host; 1734e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter unsigned int max_discard, max_trim; 1735e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter 1736e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter if (!host->max_discard_to) 1737e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter return UINT_MAX; 1738e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter 1739e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter /* 1740e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter * Without erase_group_def set, MMC erase timeout depends on clock 1741e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter * frequence which can change. In that case, the best choice is 1742e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter * just the preferred erase size. 1743e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter */ 1744e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter if (mmc_card_mmc(card) && !(card->ext_csd.erase_group_def & 1)) 1745e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter return card->pref_erase; 1746e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter 1747e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter max_discard = mmc_do_calc_max_discard(card, MMC_ERASE_ARG); 1748e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter if (mmc_can_trim(card)) { 1749e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter max_trim = mmc_do_calc_max_discard(card, MMC_TRIM_ARG); 1750e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter if (max_trim < max_discard) 1751e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter max_discard = max_trim; 1752e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter } else if (max_discard < card->erase_size) { 1753e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter max_discard = 0; 1754e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter } 1755e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter pr_debug("%s: calculated max. discard sectors %u for timeout %u ms\n", 1756e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter mmc_hostname(host), max_discard, host->max_discard_to); 1757e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter return max_discard; 1758e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter} 1759e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian HunterEXPORT_SYMBOL(mmc_calc_max_discard); 1760e056a1b5b67b4e4bfad00bf143ab14f634777705Adrian Hunter 17610f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunterint mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen) 17620f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter{ 17631278dba167f01bb3c6626d16450d31129d041087Chris Ball struct mmc_command cmd = {0}; 17640f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter 17650f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter if (mmc_card_blockaddr(card) || mmc_card_ddr_mode(card)) 17660f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter return 0; 17670f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter 17680f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter cmd.opcode = MMC_SET_BLOCKLEN; 17690f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter cmd.arg = blocklen; 17700f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 17710f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter return mmc_wait_for_cmd(card->host, &cmd, 5); 17720f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter} 17730f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian HunterEXPORT_SYMBOL(mmc_set_blocklen); 17740f8d8ea64ec7c77ca5beb59534d386fe0235961aAdrian Hunter 1775807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Rossstatic int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq) 1776807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross{ 1777807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross host->f_init = freq; 1778807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross 1779807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross#ifdef CONFIG_MMC_DEBUG 1780807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross pr_info("%s: %s: trying to init card at %u Hz\n", 1781807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross mmc_hostname(host), __func__, host->f_init); 1782807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross#endif 1783807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross mmc_power_up(host); 17842f94e55ae5ddad83e661002985d2ea11b6d51d3dPhilip Rakity 17852f94e55ae5ddad83e661002985d2ea11b6d51d3dPhilip Rakity /* 17862f94e55ae5ddad83e661002985d2ea11b6d51d3dPhilip Rakity * sdio_reset sends CMD52 to reset card. Since we do not know 17872f94e55ae5ddad83e661002985d2ea11b6d51d3dPhilip Rakity * if the card is being re-initialized, just send it. CMD52 17882f94e55ae5ddad83e661002985d2ea11b6d51d3dPhilip Rakity * should be ignored by SD/eMMC cards. 17892f94e55ae5ddad83e661002985d2ea11b6d51d3dPhilip Rakity */ 1790807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross sdio_reset(host); 1791807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross mmc_go_idle(host); 1792807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross 1793807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross mmc_send_if_cond(host, host->ocr_avail); 1794807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross 1795807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross /* Order's important: probe SDIO, then SD, then MMC */ 1796807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross if (!mmc_attach_sdio(host)) 1797807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross return 0; 1798807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross if (!mmc_attach_sd(host)) 1799807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross return 0; 1800807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross if (!mmc_attach_mmc(host)) 1801807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross return 0; 1802807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross 1803807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross mmc_power_off(host); 1804807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross return -EIO; 1805807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross} 1806807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross 1807b93931a61a119575f84c33af2438b9384fde9eb7Pierre Ossmanvoid mmc_rescan(struct work_struct *work) 18081da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1809807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross static const unsigned freqs[] = { 400000, 300000, 200000, 100000 }; 1810c4028958b6ecad064b1a6303a6a5906d4fe48d73David Howells struct mmc_host *host = 1811c4028958b6ecad064b1a6303a6a5906d4fe48d73David Howells container_of(work, struct mmc_host, detect.work); 181288ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch int i; 18134c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 1814807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross if (host->rescan_disable) 18154c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky return; 18161da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 18177ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_get(host); 1818b855885e3b60cf6f9452848712a62517b94583ebPierre Ossman 181930201e7f3ac639fe98fcd25d40346b65dde9ecbaOhad Ben-Cohen /* 182030201e7f3ac639fe98fcd25d40346b65dde9ecbaOhad Ben-Cohen * if there is a _removable_ card registered, check whether it is 182130201e7f3ac639fe98fcd25d40346b65dde9ecbaOhad Ben-Cohen * still present 182230201e7f3ac639fe98fcd25d40346b65dde9ecbaOhad Ben-Cohen */ 182330201e7f3ac639fe98fcd25d40346b65dde9ecbaOhad Ben-Cohen if (host->bus_ops && host->bus_ops->detect && !host->bus_dead 1824bad3babace2ee4d1763b4016a662a5c660ab92e9Ohad Ben-Cohen && !(host->caps & MMC_CAP_NONREMOVABLE)) 182594d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer host->bus_ops->detect(host); 182694d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer 1827c584179828b268152f5ff82dab529a2c095b09acChris Ball /* 1828c584179828b268152f5ff82dab529a2c095b09acChris Ball * Let mmc_bus_put() free the bus/bus_ops if we've found that 1829c584179828b268152f5ff82dab529a2c095b09acChris Ball * the card is no longer present. 1830c584179828b268152f5ff82dab529a2c095b09acChris Ball */ 183194d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer mmc_bus_put(host); 183294d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer mmc_bus_get(host); 183394d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer 183494d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer /* if there still is a card present, stop here */ 183594d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer if (host->bus_ops != NULL) { 18367ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_put(host); 183794d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer goto out; 183894d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer } 18391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 184094d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer /* 184194d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer * Only we can add a new handler, so it's safe to 184294d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer * release the lock here. 184394d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer */ 184494d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer mmc_bus_put(host); 18451da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 184694d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer if (host->ops->get_cd && host->ops->get_cd(host) == 0) 184794d89efb2c347a82a08a61dbac8565b1087c3259Jorg Schummer goto out; 18481da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1849807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross mmc_claim_host(host); 185088ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch for (i = 0; i < ARRAY_SIZE(freqs); i++) { 1851807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross if (!mmc_rescan_try_freq(host, max(freqs[i], host->f_min))) 1852807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross break; 185306b2233a20bf25c8ee57b7c6e13f528309ac6edcJaehoon Chung if (freqs[i] <= host->f_min) 1854807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross break; 185588ae8b866488031b0e2fc05a27440fefec5e6927Hein Tibosch } 1856807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross mmc_release_host(host); 1857807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross 1858807e8e40673d9628fa7dcdd14423424b4ee5f43bAndy Ross out: 185928f52482b41edc88cdf575aa6ed414c6e116ce10Anton Vorontsov if (host->caps & MMC_CAP_NEEDS_POLL) 186028f52482b41edc88cdf575aa6ed414c6e116ce10Anton Vorontsov mmc_schedule_delayed_work(&host->detect, HZ); 18611da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 18621da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1863b93931a61a119575f84c33af2438b9384fde9eb7Pierre Ossmanvoid mmc_start_host(struct mmc_host *host) 18641da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 1865b93931a61a119575f84c33af2438b9384fde9eb7Pierre Ossman mmc_power_off(host); 1866b93931a61a119575f84c33af2438b9384fde9eb7Pierre Ossman mmc_detect_change(host, 0); 18671da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 18681da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 1869b93931a61a119575f84c33af2438b9384fde9eb7Pierre Ossmanvoid mmc_stop_host(struct mmc_host *host) 18701da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 18713b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman#ifdef CONFIG_MMC_DEBUG 18721efd48b3ae8f89a1d04f1e36be96764d7bf43ae9Pierre Ossman unsigned long flags; 18731efd48b3ae8f89a1d04f1e36be96764d7bf43ae9Pierre Ossman spin_lock_irqsave(&host->lock, flags); 18743b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman host->removed = 1; 18751efd48b3ae8f89a1d04f1e36be96764d7bf43ae9Pierre Ossman spin_unlock_irqrestore(&host->lock, flags); 18763b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman#endif 18773b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman 18788ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->caps & MMC_CAP_DISABLE) 18798ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter cancel_delayed_work(&host->disable); 1880d9bcbf343ec63e1104b5276195888ee06b4d086fGuennadi Liakhovetski cancel_delayed_work_sync(&host->detect); 18813b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman mmc_flush_scheduled_work(); 18823b91e5507cddaca53bccf1524ff11a0ac5c85531Pierre Ossman 1883da68c4eb258cd9f3f0b8aeb7e46b8118bb6358b6Nicolas Pitre /* clear pm flags now and let card drivers set them as needed */ 1884da68c4eb258cd9f3f0b8aeb7e46b8118bb6358b6Nicolas Pitre host->pm_flags = 0; 1885da68c4eb258cd9f3f0b8aeb7e46b8118bb6358b6Nicolas Pitre 18867ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_get(host); 18877ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman if (host->bus_ops && !host->bus_dead) { 18887ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman if (host->bus_ops->remove) 18897ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman host->bus_ops->remove(host); 18907ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 18917ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_claim_host(host); 18927ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_detach_bus(host); 18937f7e4129c23f0419257184dff6fec89d2d5a8964Ulf Hansson mmc_power_off(host); 18947ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_release_host(host); 189553509f0fe28e049e772897aa8fa1f5183b6823a2Denis Karpov mmc_bus_put(host); 189653509f0fe28e049e772897aa8fa1f5183b6823a2Denis Karpov return; 18971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds } 18987ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_put(host); 18997ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 19007ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman BUG_ON(host->card); 19011da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds mmc_power_off(host); 19031da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 19041da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 190512ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohenint mmc_power_save_host(struct mmc_host *host) 1906eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter{ 190712ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen int ret = 0; 190812ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen 1909bb9cab941c7139304899fa7922f3069bb2097f4eDaniel Drake#ifdef CONFIG_MMC_DEBUG 1910bb9cab941c7139304899fa7922f3069bb2097f4eDaniel Drake pr_info("%s: %s: powering down\n", mmc_hostname(host), __func__); 1911bb9cab941c7139304899fa7922f3069bb2097f4eDaniel Drake#endif 1912bb9cab941c7139304899fa7922f3069bb2097f4eDaniel Drake 1913eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_bus_get(host); 1914eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1915eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) { 1916eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_bus_put(host); 191712ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen return -EINVAL; 1918eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter } 1919eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1920eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter if (host->bus_ops->power_save) 192112ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen ret = host->bus_ops->power_save(host); 1922eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1923eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_bus_put(host); 1924eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1925eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_power_off(host); 192612ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen 192712ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen return ret; 1928eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter} 1929eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian HunterEXPORT_SYMBOL(mmc_power_save_host); 1930eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 193112ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohenint mmc_power_restore_host(struct mmc_host *host) 1932eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter{ 193312ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen int ret; 193412ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen 1935bb9cab941c7139304899fa7922f3069bb2097f4eDaniel Drake#ifdef CONFIG_MMC_DEBUG 1936bb9cab941c7139304899fa7922f3069bb2097f4eDaniel Drake pr_info("%s: %s: powering up\n", mmc_hostname(host), __func__); 1937bb9cab941c7139304899fa7922f3069bb2097f4eDaniel Drake#endif 1938bb9cab941c7139304899fa7922f3069bb2097f4eDaniel Drake 1939eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_bus_get(host); 1940eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1941eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter if (!host->bus_ops || host->bus_dead || !host->bus_ops->power_restore) { 1942eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_bus_put(host); 194312ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen return -EINVAL; 1944eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter } 1945eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1946eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_power_up(host); 194712ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen ret = host->bus_ops->power_restore(host); 1948eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1949eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter mmc_bus_put(host); 195012ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen 195112ae637f081a7a05144af65802a7b492b9162660Ohad Ben-Cohen return ret; 1952eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter} 1953eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian HunterEXPORT_SYMBOL(mmc_power_restore_host); 1954eae1aeeed852aae37621b82a9e7f6c05096a18fdAdrian Hunter 1955b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinenint mmc_card_awake(struct mmc_host *host) 1956b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen{ 1957b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen int err = -ENOSYS; 1958b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1959b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen mmc_bus_get(host); 1960b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1961b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen if (host->bus_ops && !host->bus_dead && host->bus_ops->awake) 1962b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen err = host->bus_ops->awake(host); 1963b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1964b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen mmc_bus_put(host); 1965b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1966b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen return err; 1967b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen} 1968b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko LavinenEXPORT_SYMBOL(mmc_card_awake); 1969b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1970b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinenint mmc_card_sleep(struct mmc_host *host) 1971b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen{ 1972b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen int err = -ENOSYS; 1973b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1974b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen mmc_bus_get(host); 1975b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1976b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen if (host->bus_ops && !host->bus_dead && host->bus_ops->awake) 1977b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen err = host->bus_ops->sleep(host); 1978b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1979b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen mmc_bus_put(host); 1980b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1981b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen return err; 1982b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen} 1983b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko LavinenEXPORT_SYMBOL(mmc_card_sleep); 1984b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1985b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinenint mmc_card_can_sleep(struct mmc_host *host) 1986b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen{ 1987b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen struct mmc_card *card = host->card; 1988b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 1989b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen if (card && mmc_card_mmc(card) && card->ext_csd.rev >= 3) 1990b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen return 1; 1991b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen return 0; 1992b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen} 1993b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko LavinenEXPORT_SYMBOL(mmc_card_can_sleep); 1994b1ebe38456f7fe61a88af2844361e763ac6ea5aeJarkko Lavinen 19951da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#ifdef CONFIG_PM 19961da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 19971da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 19981da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * mmc_suspend_host - suspend a host 19991da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @host: mmc host 20001da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 20011a13f8fa76c880be41d6b1e6a2b44404bcbfdf9eMatt Flemingint mmc_suspend_host(struct mmc_host *host) 20021da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 200395cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre int err = 0; 200495cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre 20058ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter if (host->caps & MMC_CAP_DISABLE) 20068ea926b22e2d13238e4d65d8f61c48fe424e6f4fAdrian Hunter cancel_delayed_work(&host->disable); 20077de427d088a967d2173739e21e744921d5496a8bJorg Schummer cancel_delayed_work(&host->detect); 2008b5af25bee2de2f6cd1ac74ba737cbc4f3d303e5dPierre Ossman mmc_flush_scheduled_work(); 2009b5af25bee2de2f6cd1ac74ba737cbc4f3d303e5dPierre Ossman 20107ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_get(host); 20117ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman if (host->bus_ops && !host->bus_dead) { 20126abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman if (host->bus_ops->suspend) 201395cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre err = host->bus_ops->suspend(host); 20141c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen if (err == -ENOSYS || !host->bus_ops->resume) { 20151c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen /* 20161c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen * We simply "remove" the card in this case. 20171c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen * It will be redetected on resume. 20181c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen */ 20191c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen if (host->bus_ops->remove) 20201c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen host->bus_ops->remove(host); 20211c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen mmc_claim_host(host); 20221c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen mmc_detach_bus(host); 20237f7e4129c23f0419257184dff6fec89d2d5a8964Ulf Hansson mmc_power_off(host); 20241c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen mmc_release_host(host); 20251c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen host->pm_flags = 0; 20261c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen err = 0; 20271c8cf9c997a4a6b36e907c7ede5f048aeaab1644Ohad Ben-Cohen } 2028b5af25bee2de2f6cd1ac74ba737cbc4f3d303e5dPierre Ossman } 20297ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman mmc_bus_put(host); 20307ea239d9e6d6993469a6a8ca83ff23834dfc3fcePierre Ossman 2031a5e9425d2010978c5f85986cc70a9fa0c0d5b912Ohad Ben-Cohen if (!err && !mmc_card_keep_power(host)) 203295cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre mmc_power_off(host); 20331da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 203495cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre return err; 20351da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 20361da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20371da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_suspend_host); 20381da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20391da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds/** 20401da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * mmc_resume_host - resume a previously suspended host 20411da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds * @host: mmc host 20421da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds */ 20431da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvaldsint mmc_resume_host(struct mmc_host *host) 20441da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds{ 204595cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre int err = 0; 204695cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre 20476abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman mmc_bus_get(host); 20486abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman if (host->bus_ops && !host->bus_dead) { 2049a5e9425d2010978c5f85986cc70a9fa0c0d5b912Ohad Ben-Cohen if (!mmc_card_keep_power(host)) { 2050da68c4eb258cd9f3f0b8aeb7e46b8118bb6358b6Nicolas Pitre mmc_power_up(host); 2051da68c4eb258cd9f3f0b8aeb7e46b8118bb6358b6Nicolas Pitre mmc_select_voltage(host, host->ocr); 2052e594573d790bd7e269f05955d316b88f7be0c14aOhad Ben-Cohen /* 2053e594573d790bd7e269f05955d316b88f7be0c14aOhad Ben-Cohen * Tell runtime PM core we just powered up the card, 2054e594573d790bd7e269f05955d316b88f7be0c14aOhad Ben-Cohen * since it still believes the card is powered off. 2055e594573d790bd7e269f05955d316b88f7be0c14aOhad Ben-Cohen * Note that currently runtime PM is only enabled 2056e594573d790bd7e269f05955d316b88f7be0c14aOhad Ben-Cohen * for SDIO cards that are MMC_CAP_POWER_OFF_CARD 2057e594573d790bd7e269f05955d316b88f7be0c14aOhad Ben-Cohen */ 2058e594573d790bd7e269f05955d316b88f7be0c14aOhad Ben-Cohen if (mmc_card_sdio(host->card) && 2059e594573d790bd7e269f05955d316b88f7be0c14aOhad Ben-Cohen (host->caps & MMC_CAP_POWER_OFF_CARD)) { 2060e594573d790bd7e269f05955d316b88f7be0c14aOhad Ben-Cohen pm_runtime_disable(&host->card->dev); 2061e594573d790bd7e269f05955d316b88f7be0c14aOhad Ben-Cohen pm_runtime_set_active(&host->card->dev); 2062e594573d790bd7e269f05955d316b88f7be0c14aOhad Ben-Cohen pm_runtime_enable(&host->card->dev); 2063e594573d790bd7e269f05955d316b88f7be0c14aOhad Ben-Cohen } 2064da68c4eb258cd9f3f0b8aeb7e46b8118bb6358b6Nicolas Pitre } 20656abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman BUG_ON(!host->bus_ops->resume); 206695cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre err = host->bus_ops->resume(host); 206795cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre if (err) { 206895cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre printk(KERN_WARNING "%s: error %d during resume " 206995cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre "(card was removed?)\n", 207095cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre mmc_hostname(host), err); 207195cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre err = 0; 207295cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre } 20736abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman } 2074a8e6df7343cf67c9104955da0de70075a6ee1dfdEliad Peller host->pm_flags &= ~MMC_PM_KEEP_POWER; 20756abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman mmc_bus_put(host); 20766abaa0c9fec563538f2a28a682af8c89bb9b125cPierre Ossman 207795cdfb72b9bc568803f395c266152c71b034b461Nicolas Pitre return err; 20781da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds} 20791da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsEXPORT_SYMBOL(mmc_resume_host); 20801da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 20814c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky/* Do the card removal on suspend if card is assumed removeable 20824c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky * Do that in pm notifier while userspace isn't yet frozen, so we will be able 20834c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky to sync the card. 20844c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky*/ 20854c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitskyint mmc_pm_notify(struct notifier_block *notify_block, 20864c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky unsigned long mode, void *unused) 20874c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky{ 20884c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky struct mmc_host *host = container_of( 20894c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky notify_block, struct mmc_host, pm_notify); 20904c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky unsigned long flags; 20914c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 20924c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 20934c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky switch (mode) { 20944c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky case PM_HIBERNATION_PREPARE: 20954c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky case PM_SUSPEND_PREPARE: 20964c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 20974c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky spin_lock_irqsave(&host->lock, flags); 20984c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky host->rescan_disable = 1; 20994c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky spin_unlock_irqrestore(&host->lock, flags); 21004c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky cancel_delayed_work_sync(&host->detect); 21014c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 21024c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky if (!host->bus_ops || host->bus_ops->suspend) 21034c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky break; 21044c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 21054c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky mmc_claim_host(host); 21064c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 21074c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky if (host->bus_ops->remove) 21084c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky host->bus_ops->remove(host); 21094c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 21104c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky mmc_detach_bus(host); 21117f7e4129c23f0419257184dff6fec89d2d5a8964Ulf Hansson mmc_power_off(host); 21124c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky mmc_release_host(host); 21134c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky host->pm_flags = 0; 21144c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky break; 21154c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 21164c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky case PM_POST_SUSPEND: 21174c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky case PM_POST_HIBERNATION: 2118274476f8fe0b6ac9bac542cc39de12c3dd0f43f6Takashi Iwai case PM_POST_RESTORE: 21194c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 21204c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky spin_lock_irqsave(&host->lock, flags); 21214c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky host->rescan_disable = 0; 21224c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky spin_unlock_irqrestore(&host->lock, flags); 21234c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky mmc_detect_change(host, 0); 21244c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 21254c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky } 21264c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky 21274c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky return 0; 21284c2ef25fe0b847d2ae818f74758ddb0be1c27d8eMaxim Levitsky} 21291da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds#endif 21301da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus Torvalds 2131ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossmanstatic int __init mmc_init(void) 2132ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman{ 2133ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman int ret; 2134ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 21350d9ee5b2e9aac981fa063339daf04320eac610d1Tejun Heo workqueue = alloc_ordered_workqueue("kmmcd", 0); 2136ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman if (!workqueue) 2137ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman return -ENOMEM; 2138ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 2139ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman ret = mmc_register_bus(); 2140e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman if (ret) 2141e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman goto destroy_workqueue; 2142e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman 2143e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman ret = mmc_register_host_class(); 2144e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman if (ret) 2145e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman goto unregister_bus; 2146e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman 2147e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman ret = sdio_register_bus(); 2148e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman if (ret) 2149e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman goto unregister_host_class; 2150e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman 2151e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman return 0; 2152e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman 2153e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossmanunregister_host_class: 2154e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman mmc_unregister_host_class(); 2155e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossmanunregister_bus: 2156e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman mmc_unregister_bus(); 2157e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossmandestroy_workqueue: 2158e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman destroy_workqueue(workqueue); 2159e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman 2160ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman return ret; 2161ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman} 2162ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 2163ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossmanstatic void __exit mmc_exit(void) 2164ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman{ 2165e29a7d73f4277eb92aa64e17017dea33460828efPierre Ossman sdio_unregister_bus(); 2166ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman mmc_unregister_host_class(); 2167ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman mmc_unregister_bus(); 2168ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman destroy_workqueue(workqueue); 2169ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman} 2170ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 217126074962e8f547b96614dbe248748ba2a1996ca3Nicolas Pitresubsys_initcall(mmc_init); 2172ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossmanmodule_exit(mmc_exit); 2173ffce2e7e7060c949ccd703dacc9b3dd81b377373Pierre Ossman 21741da177e4c3f41524e886b7f1b8a0c1fc7321cacLinus TorvaldsMODULE_LICENSE("GPL"); 2175