blob: 219bf4b1d97e9a06b18592f3f2ff55596efc7525 [file] [log] [blame]
Pierre Ossman4101c162007-05-19 13:39:01 +02001/*
2 * linux/drivers/mmc/core/bus.c
3 *
4 * Copyright (C) 2003 Russell King, All Rights Reserved.
5 * Copyright (C) 2007 Pierre Ossman
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 *
11 * MMC card bus driver model
12 */
13
Paul Gortmaker3ef77af2011-07-10 12:42:00 -040014#include <linux/export.h>
Pierre Ossman4101c162007-05-19 13:39:01 +020015#include <linux/device.h>
16#include <linux/err.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090017#include <linux/slab.h>
Paul Gortmaker0205a902011-07-15 12:01:27 -040018#include <linux/stat.h>
Ohad Ben-Cohen516d5cc2010-10-02 13:54:08 +020019#include <linux/pm_runtime.h>
Pierre Ossman4101c162007-05-19 13:39:01 +020020
21#include <linux/mmc/card.h>
22#include <linux/mmc/host.h>
23
Pierre Ossman4101c162007-05-19 13:39:01 +020024#include "core.h"
Pierre Ossman1a632f82007-07-30 15:15:30 +020025#include "sdio_cis.h"
Pierre Ossman4101c162007-05-19 13:39:01 +020026#include "bus.h"
27
Pierre Ossman4101c162007-05-19 13:39:01 +020028#define to_mmc_driver(d) container_of(d, struct mmc_driver, drv)
29
30static ssize_t mmc_type_show(struct device *dev,
31 struct device_attribute *attr, char *buf)
32{
Andy Shevchenko265cdc92010-09-17 20:32:25 -040033 struct mmc_card *card = mmc_dev_to_card(dev);
Pierre Ossman4101c162007-05-19 13:39:01 +020034
35 switch (card->type) {
36 case MMC_TYPE_MMC:
37 return sprintf(buf, "MMC\n");
38 case MMC_TYPE_SD:
39 return sprintf(buf, "SD\n");
Pierre Ossman5c4e6f12007-05-21 20:23:20 +020040 case MMC_TYPE_SDIO:
41 return sprintf(buf, "SDIO\n");
Michal Miroslaw7310ece82010-08-10 18:01:40 -070042 case MMC_TYPE_SD_COMBO:
43 return sprintf(buf, "SDcombo\n");
Pierre Ossman4101c162007-05-19 13:39:01 +020044 default:
45 return -EFAULT;
46 }
47}
48
49static struct device_attribute mmc_dev_attrs[] = {
Pierre Ossman51ec92e2008-03-21 23:54:50 +010050 __ATTR(type, S_IRUGO, mmc_type_show, NULL),
Pierre Ossman4101c162007-05-19 13:39:01 +020051 __ATTR_NULL,
52};
53
54/*
55 * This currently matches any MMC driver to any MMC card - drivers
56 * themselves make the decision whether to drive this card in their
57 * probe method.
58 */
59static int mmc_bus_match(struct device *dev, struct device_driver *drv)
60{
61 return 1;
62}
63
64static int
Kay Sievers7eff2e72007-08-14 15:15:12 +020065mmc_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
Pierre Ossman4101c162007-05-19 13:39:01 +020066{
Andy Shevchenko265cdc92010-09-17 20:32:25 -040067 struct mmc_card *card = mmc_dev_to_card(dev);
Pierre Ossman9eb3a942007-06-17 11:18:46 +020068 const char *type;
Kay Sievers7eff2e72007-08-14 15:15:12 +020069 int retval = 0;
Pierre Ossman4101c162007-05-19 13:39:01 +020070
71 switch (card->type) {
72 case MMC_TYPE_MMC:
Pierre Ossman9eb3a942007-06-17 11:18:46 +020073 type = "MMC";
Pierre Ossman4101c162007-05-19 13:39:01 +020074 break;
75 case MMC_TYPE_SD:
Pierre Ossman9eb3a942007-06-17 11:18:46 +020076 type = "SD";
Pierre Ossman4101c162007-05-19 13:39:01 +020077 break;
Pierre Ossman5c4e6f12007-05-21 20:23:20 +020078 case MMC_TYPE_SDIO:
Pierre Ossman9eb3a942007-06-17 11:18:46 +020079 type = "SDIO";
Pierre Ossman5c4e6f12007-05-21 20:23:20 +020080 break;
Michal Miroslaw7310ece82010-08-10 18:01:40 -070081 case MMC_TYPE_SD_COMBO:
82 type = "SDcombo";
83 break;
Pierre Ossman9eb3a942007-06-17 11:18:46 +020084 default:
85 type = NULL;
Pierre Ossman4101c162007-05-19 13:39:01 +020086 }
87
Pierre Ossman9eb3a942007-06-17 11:18:46 +020088 if (type) {
Kay Sievers7eff2e72007-08-14 15:15:12 +020089 retval = add_uevent_var(env, "MMC_TYPE=%s", type);
90 if (retval)
91 return retval;
Pierre Ossman9eb3a942007-06-17 11:18:46 +020092 }
Pierre Ossman4101c162007-05-19 13:39:01 +020093
Kay Sievers7eff2e72007-08-14 15:15:12 +020094 retval = add_uevent_var(env, "MMC_NAME=%s", mmc_card_name(card));
Andy Whitcroft6b0b6282009-02-23 12:38:41 +000095 if (retval)
96 return retval;
97
98 /*
99 * Request the mmc_block device. Note: that this is a direct request
100 * for the module it carries no information as to what is inserted.
101 */
102 retval = add_uevent_var(env, "MODALIAS=mmc:block");
Pierre Ossman4101c162007-05-19 13:39:01 +0200103
Kay Sievers7eff2e72007-08-14 15:15:12 +0200104 return retval;
Pierre Ossman4101c162007-05-19 13:39:01 +0200105}
106
107static int mmc_bus_probe(struct device *dev)
108{
109 struct mmc_driver *drv = to_mmc_driver(dev->driver);
Andy Shevchenko265cdc92010-09-17 20:32:25 -0400110 struct mmc_card *card = mmc_dev_to_card(dev);
Pierre Ossman4101c162007-05-19 13:39:01 +0200111
112 return drv->probe(card);
113}
114
115static int mmc_bus_remove(struct device *dev)
116{
117 struct mmc_driver *drv = to_mmc_driver(dev->driver);
Andy Shevchenko265cdc92010-09-17 20:32:25 -0400118 struct mmc_card *card = mmc_dev_to_card(dev);
Pierre Ossman4101c162007-05-19 13:39:01 +0200119
120 drv->remove(card);
121
122 return 0;
123}
124
Ulf Hansson76287742013-06-10 17:03:40 +0200125static void mmc_bus_shutdown(struct device *dev)
126{
127 struct mmc_driver *drv = to_mmc_driver(dev->driver);
128 struct mmc_card *card = mmc_dev_to_card(dev);
129
130 drv->shutdown(card);
131}
132
Chuanxiao Dong0dd1bfe2012-04-23 15:18:02 +0800133#ifdef CONFIG_PM_SLEEP
Chuanxiao Dong32d317c2012-04-11 19:54:38 +0800134static int mmc_bus_suspend(struct device *dev)
Pierre Ossman4101c162007-05-19 13:39:01 +0200135{
136 struct mmc_driver *drv = to_mmc_driver(dev->driver);
Andy Shevchenko265cdc92010-09-17 20:32:25 -0400137 struct mmc_card *card = mmc_dev_to_card(dev);
Ulf Hansson986892c2013-06-10 17:03:39 +0200138 struct mmc_host *host = card->host;
139 int ret;
Pierre Ossman4101c162007-05-19 13:39:01 +0200140
Ulf Hansson986892c2013-06-10 17:03:39 +0200141 if (dev->driver && drv->suspend) {
Chuanxiao Dong32d317c2012-04-11 19:54:38 +0800142 ret = drv->suspend(card);
Ulf Hansson986892c2013-06-10 17:03:39 +0200143 if (ret)
144 return ret;
145 }
146
147 ret = host->bus_ops->suspend(host);
Pierre Ossman4101c162007-05-19 13:39:01 +0200148 return ret;
149}
150
151static int mmc_bus_resume(struct device *dev)
152{
153 struct mmc_driver *drv = to_mmc_driver(dev->driver);
Andy Shevchenko265cdc92010-09-17 20:32:25 -0400154 struct mmc_card *card = mmc_dev_to_card(dev);
Ulf Hansson986892c2013-06-10 17:03:39 +0200155 struct mmc_host *host = card->host;
156 int ret;
157
158 ret = host->bus_ops->resume(host);
159 if (ret)
160 pr_warn("%s: error %d during resume (card was removed?)\n",
161 mmc_hostname(host), ret);
Pierre Ossman4101c162007-05-19 13:39:01 +0200162
163 if (dev->driver && drv->resume)
164 ret = drv->resume(card);
Ulf Hansson986892c2013-06-10 17:03:39 +0200165
Pierre Ossman4101c162007-05-19 13:39:01 +0200166 return ret;
167}
Chuanxiao Dong0dd1bfe2012-04-23 15:18:02 +0800168#endif
Pierre Ossman4101c162007-05-19 13:39:01 +0200169
Ohad Ben-Cohen516d5cc2010-10-02 13:54:08 +0200170#ifdef CONFIG_PM_RUNTIME
171
172static int mmc_runtime_suspend(struct device *dev)
173{
174 struct mmc_card *card = mmc_dev_to_card(dev);
Ulf Hansson12d01d02013-05-02 14:02:37 +0200175 struct mmc_host *host = card->host;
176 int ret = 0;
Ohad Ben-Cohen516d5cc2010-10-02 13:54:08 +0200177
Ulf Hansson12d01d02013-05-02 14:02:37 +0200178 if (host->bus_ops->runtime_suspend)
179 ret = host->bus_ops->runtime_suspend(host);
180
181 return ret;
Ohad Ben-Cohen516d5cc2010-10-02 13:54:08 +0200182}
183
184static int mmc_runtime_resume(struct device *dev)
185{
186 struct mmc_card *card = mmc_dev_to_card(dev);
Ulf Hansson12d01d02013-05-02 14:02:37 +0200187 struct mmc_host *host = card->host;
188 int ret = 0;
Ohad Ben-Cohen516d5cc2010-10-02 13:54:08 +0200189
Ulf Hansson12d01d02013-05-02 14:02:37 +0200190 if (host->bus_ops->runtime_resume)
191 ret = host->bus_ops->runtime_resume(host);
192
193 return ret;
Ohad Ben-Cohen516d5cc2010-10-02 13:54:08 +0200194}
195
196static int mmc_runtime_idle(struct device *dev)
197{
198 return pm_runtime_suspend(dev);
199}
200
Ohad Ben-Cohen516d5cc2010-10-02 13:54:08 +0200201#endif /* !CONFIG_PM_RUNTIME */
202
Chuanxiao Dong32d317c2012-04-11 19:54:38 +0800203static const struct dev_pm_ops mmc_bus_pm_ops = {
204 SET_RUNTIME_PM_OPS(mmc_runtime_suspend, mmc_runtime_resume,
205 mmc_runtime_idle)
206 SET_SYSTEM_SLEEP_PM_OPS(mmc_bus_suspend, mmc_bus_resume)
207};
208
Pierre Ossman4101c162007-05-19 13:39:01 +0200209static struct bus_type mmc_bus_type = {
210 .name = "mmc",
211 .dev_attrs = mmc_dev_attrs,
212 .match = mmc_bus_match,
213 .uevent = mmc_bus_uevent,
214 .probe = mmc_bus_probe,
215 .remove = mmc_bus_remove,
Ulf Hansson76287742013-06-10 17:03:40 +0200216 .shutdown = mmc_bus_shutdown,
Chuanxiao Dong32d317c2012-04-11 19:54:38 +0800217 .pm = &mmc_bus_pm_ops,
Pierre Ossman4101c162007-05-19 13:39:01 +0200218};
219
220int mmc_register_bus(void)
221{
222 return bus_register(&mmc_bus_type);
223}
224
225void mmc_unregister_bus(void)
226{
227 bus_unregister(&mmc_bus_type);
228}
229
230/**
231 * mmc_register_driver - register a media driver
232 * @drv: MMC media driver
233 */
234int mmc_register_driver(struct mmc_driver *drv)
235{
236 drv->drv.bus = &mmc_bus_type;
237 return driver_register(&drv->drv);
238}
239
240EXPORT_SYMBOL(mmc_register_driver);
241
242/**
243 * mmc_unregister_driver - unregister a media driver
244 * @drv: MMC media driver
245 */
246void mmc_unregister_driver(struct mmc_driver *drv)
247{
248 drv->drv.bus = &mmc_bus_type;
249 driver_unregister(&drv->drv);
250}
251
252EXPORT_SYMBOL(mmc_unregister_driver);
253
254static void mmc_release_card(struct device *dev)
255{
Andy Shevchenko265cdc92010-09-17 20:32:25 -0400256 struct mmc_card *card = mmc_dev_to_card(dev);
Pierre Ossman4101c162007-05-19 13:39:01 +0200257
Pierre Ossman1a632f82007-07-30 15:15:30 +0200258 sdio_free_common_cis(card);
259
Sachin Kamat8db580c2012-11-20 14:43:17 +0530260 kfree(card->info);
Pierre Ossman759bdc72007-09-19 18:42:16 +0200261
Pierre Ossman4101c162007-05-19 13:39:01 +0200262 kfree(card);
263}
264
265/*
266 * Allocate and initialise a new MMC card structure.
267 */
Pierre Ossman51ec92e2008-03-21 23:54:50 +0100268struct mmc_card *mmc_alloc_card(struct mmc_host *host, struct device_type *type)
Pierre Ossman4101c162007-05-19 13:39:01 +0200269{
270 struct mmc_card *card;
271
Mariusz Kozlowski733cb1e2007-08-10 14:00:47 -0700272 card = kzalloc(sizeof(struct mmc_card), GFP_KERNEL);
Pierre Ossman4101c162007-05-19 13:39:01 +0200273 if (!card)
274 return ERR_PTR(-ENOMEM);
275
Pierre Ossman4101c162007-05-19 13:39:01 +0200276 card->host = host;
277
278 device_initialize(&card->dev);
279
280 card->dev.parent = mmc_classdev(host);
281 card->dev.bus = &mmc_bus_type;
282 card->dev.release = mmc_release_card;
Pierre Ossman51ec92e2008-03-21 23:54:50 +0100283 card->dev.type = type;
Pierre Ossman4101c162007-05-19 13:39:01 +0200284
285 return card;
286}
287
288/*
289 * Register a new MMC card with the driver model.
290 */
291int mmc_add_card(struct mmc_card *card)
292{
293 int ret;
Pierre Ossman109b5be2007-07-23 00:12:10 +0200294 const char *type;
Subhash Jadavani6500c8e2012-03-30 12:10:18 +0530295 const char *uhs_bus_speed_mode = "";
296 static const char *const uhs_speeds[] = {
297 [UHS_SDR12_BUS_SPEED] = "SDR12 ",
298 [UHS_SDR25_BUS_SPEED] = "SDR25 ",
299 [UHS_SDR50_BUS_SPEED] = "SDR50 ",
300 [UHS_SDR104_BUS_SPEED] = "SDR104 ",
301 [UHS_DDR50_BUS_SPEED] = "DDR50 ",
302 };
303
Pierre Ossman4101c162007-05-19 13:39:01 +0200304
Kay Sieversd1b26862008-11-08 21:37:46 +0100305 dev_set_name(&card->dev, "%s:%04x", mmc_hostname(card->host), card->rca);
Pierre Ossman4101c162007-05-19 13:39:01 +0200306
Pierre Ossman109b5be2007-07-23 00:12:10 +0200307 switch (card->type) {
308 case MMC_TYPE_MMC:
309 type = "MMC";
310 break;
311 case MMC_TYPE_SD:
312 type = "SD";
Arindam Nath3a303512011-05-05 12:19:03 +0530313 if (mmc_card_blockaddr(card)) {
314 if (mmc_card_ext_capacity(card))
315 type = "SDXC";
316 else
317 type = "SDHC";
318 }
Pierre Ossman109b5be2007-07-23 00:12:10 +0200319 break;
Pierre Ossman5c4e6f12007-05-21 20:23:20 +0200320 case MMC_TYPE_SDIO:
321 type = "SDIO";
322 break;
Michal Miroslaw7310ece82010-08-10 18:01:40 -0700323 case MMC_TYPE_SD_COMBO:
324 type = "SD-combo";
325 if (mmc_card_blockaddr(card))
326 type = "SDHC-combo";
Michał Mirosław9bc218482011-04-09 08:16:47 +0200327 break;
Pierre Ossman109b5be2007-07-23 00:12:10 +0200328 default:
329 type = "?";
330 break;
331 }
332
Subhash Jadavani6500c8e2012-03-30 12:10:18 +0530333 if (mmc_sd_card_uhs(card) &&
334 (card->sd_bus_speed < ARRAY_SIZE(uhs_speeds)))
335 uhs_bus_speed_mode = uhs_speeds[card->sd_bus_speed];
336
David Brownellaf517152007-08-08 09:11:32 -0700337 if (mmc_host_is_spi(card->host)) {
Girish K Sa3c76eb2011-10-11 11:44:09 +0530338 pr_info("%s: new %s%s%s card on SPI\n",
David Brownellaf517152007-08-08 09:11:32 -0700339 mmc_hostname(card->host),
340 mmc_card_highspeed(card) ? "high speed " : "",
Adrian Hunter0f8d8ea2010-08-24 13:20:26 +0300341 mmc_card_ddr_mode(card) ? "DDR " : "",
David Brownellaf517152007-08-08 09:11:32 -0700342 type);
343 } else {
Subhash Jadavani6500c8e2012-03-30 12:10:18 +0530344 pr_info("%s: new %s%s%s%s%s card at address %04x\n",
David Brownellaf517152007-08-08 09:11:32 -0700345 mmc_hostname(card->host),
Philip Rakitya303c532011-11-14 19:14:38 -0800346 mmc_card_uhs(card) ? "ultra high speed " :
Arindam Nath3a303512011-05-05 12:19:03 +0530347 (mmc_card_highspeed(card) ? "high speed " : ""),
Girish K Sa4924c72012-01-11 14:04:52 -0500348 (mmc_card_hs200(card) ? "HS200 " : ""),
Adrian Hunter0f8d8ea2010-08-24 13:20:26 +0300349 mmc_card_ddr_mode(card) ? "DDR " : "",
Subhash Jadavani6500c8e2012-03-30 12:10:18 +0530350 uhs_bus_speed_mode, type, card->rca);
David Brownellaf517152007-08-08 09:11:32 -0700351 }
Pierre Ossman109b5be2007-07-23 00:12:10 +0200352
Haavard Skinnemoenf4b7f922008-07-24 14:18:58 +0200353#ifdef CONFIG_DEBUG_FS
354 mmc_add_card_debugfs(card);
355#endif
Konstantin Dorfman2220eed2013-01-14 14:28:17 -0500356 mmc_init_context_info(card->host);
Haavard Skinnemoenf4b7f922008-07-24 14:18:58 +0200357
Viresh Kumar1a2727e2011-01-04 12:55:14 -0500358 ret = device_add(&card->dev);
359 if (ret)
360 return ret;
361
Pierre Ossman4101c162007-05-19 13:39:01 +0200362 mmc_card_set_present(card);
363
364 return 0;
365}
366
367/*
368 * Unregister a new MMC card with the driver model, and
369 * (eventually) free it.
370 */
371void mmc_remove_card(struct mmc_card *card)
372{
Haavard Skinnemoenf4b7f922008-07-24 14:18:58 +0200373#ifdef CONFIG_DEBUG_FS
374 mmc_remove_card_debugfs(card);
375#endif
376
Pierre Ossman4101c162007-05-19 13:39:01 +0200377 if (mmc_card_present(card)) {
David Brownellaf517152007-08-08 09:11:32 -0700378 if (mmc_host_is_spi(card->host)) {
Girish K Sa3c76eb2011-10-11 11:44:09 +0530379 pr_info("%s: SPI card removed\n",
David Brownellaf517152007-08-08 09:11:32 -0700380 mmc_hostname(card->host));
381 } else {
Girish K Sa3c76eb2011-10-11 11:44:09 +0530382 pr_info("%s: card %04x removed\n",
David Brownellaf517152007-08-08 09:11:32 -0700383 mmc_hostname(card->host), card->rca);
384 }
Pierre Ossman4101c162007-05-19 13:39:01 +0200385 device_del(&card->dev);
386 }
387
388 put_device(&card->dev);
389}
390