mmc: remove MMC bus legacy suspend/resume method
[linux-2.6.git] / drivers / mmc / core / bus.c
1 /*
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
14 #include <linux/export.h>
15 #include <linux/device.h>
16 #include <linux/err.h>
17 #include <linux/slab.h>
18 #include <linux/stat.h>
19 #include <linux/pm_runtime.h>
20
21 #include <linux/mmc/card.h>
22 #include <linux/mmc/host.h>
23
24 #include "core.h"
25 #include "sdio_cis.h"
26 #include "bus.h"
27
28 #define to_mmc_driver(d)        container_of(d, struct mmc_driver, drv)
29
30 static ssize_t mmc_type_show(struct device *dev,
31         struct device_attribute *attr, char *buf)
32 {
33         struct mmc_card *card = mmc_dev_to_card(dev);
34
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");
40         case MMC_TYPE_SDIO:
41                 return sprintf(buf, "SDIO\n");
42         case MMC_TYPE_SD_COMBO:
43                 return sprintf(buf, "SDcombo\n");
44         default:
45                 return -EFAULT;
46         }
47 }
48
49 static struct device_attribute mmc_dev_attrs[] = {
50         __ATTR(type, S_IRUGO, mmc_type_show, NULL),
51         __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  */
59 static int mmc_bus_match(struct device *dev, struct device_driver *drv)
60 {
61         return 1;
62 }
63
64 static int
65 mmc_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
66 {
67         struct mmc_card *card = mmc_dev_to_card(dev);
68         const char *type;
69         int retval = 0;
70
71         switch (card->type) {
72         case MMC_TYPE_MMC:
73                 type = "MMC";
74                 break;
75         case MMC_TYPE_SD:
76                 type = "SD";
77                 break;
78         case MMC_TYPE_SDIO:
79                 type = "SDIO";
80                 break;
81         case MMC_TYPE_SD_COMBO:
82                 type = "SDcombo";
83                 break;
84         default:
85                 type = NULL;
86         }
87
88         if (type) {
89                 retval = add_uevent_var(env, "MMC_TYPE=%s", type);
90                 if (retval)
91                         return retval;
92         }
93
94         retval = add_uevent_var(env, "MMC_NAME=%s", mmc_card_name(card));
95         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");
103
104         return retval;
105 }
106
107 static int mmc_bus_probe(struct device *dev)
108 {
109         struct mmc_driver *drv = to_mmc_driver(dev->driver);
110         struct mmc_card *card = mmc_dev_to_card(dev);
111
112         return drv->probe(card);
113 }
114
115 static int mmc_bus_remove(struct device *dev)
116 {
117         struct mmc_driver *drv = to_mmc_driver(dev->driver);
118         struct mmc_card *card = mmc_dev_to_card(dev);
119
120         drv->remove(card);
121
122         return 0;
123 }
124
125 static int mmc_bus_suspend(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         int ret = 0;
130
131         if (dev->driver && drv->suspend)
132                 ret = drv->suspend(card);
133         return ret;
134 }
135
136 static int mmc_bus_resume(struct device *dev)
137 {
138         struct mmc_driver *drv = to_mmc_driver(dev->driver);
139         struct mmc_card *card = mmc_dev_to_card(dev);
140         int ret = 0;
141
142         if (dev->driver && drv->resume)
143                 ret = drv->resume(card);
144         return ret;
145 }
146
147 #ifdef CONFIG_PM_RUNTIME
148
149 static int mmc_runtime_suspend(struct device *dev)
150 {
151         struct mmc_card *card = mmc_dev_to_card(dev);
152
153         return mmc_power_save_host(card->host);
154 }
155
156 static int mmc_runtime_resume(struct device *dev)
157 {
158         struct mmc_card *card = mmc_dev_to_card(dev);
159
160         return mmc_power_restore_host(card->host);
161 }
162
163 static int mmc_runtime_idle(struct device *dev)
164 {
165         return pm_runtime_suspend(dev);
166 }
167
168 #endif /* !CONFIG_PM_RUNTIME */
169
170 static const struct dev_pm_ops mmc_bus_pm_ops = {
171         SET_RUNTIME_PM_OPS(mmc_runtime_suspend, mmc_runtime_resume,
172                         mmc_runtime_idle)
173         SET_SYSTEM_SLEEP_PM_OPS(mmc_bus_suspend, mmc_bus_resume)
174 };
175
176 static struct bus_type mmc_bus_type = {
177         .name           = "mmc",
178         .dev_attrs      = mmc_dev_attrs,
179         .match          = mmc_bus_match,
180         .uevent         = mmc_bus_uevent,
181         .probe          = mmc_bus_probe,
182         .remove         = mmc_bus_remove,
183         .pm             = &mmc_bus_pm_ops,
184 };
185
186 int mmc_register_bus(void)
187 {
188         return bus_register(&mmc_bus_type);
189 }
190
191 void mmc_unregister_bus(void)
192 {
193         bus_unregister(&mmc_bus_type);
194 }
195
196 /**
197  *      mmc_register_driver - register a media driver
198  *      @drv: MMC media driver
199  */
200 int mmc_register_driver(struct mmc_driver *drv)
201 {
202         drv->drv.bus = &mmc_bus_type;
203         return driver_register(&drv->drv);
204 }
205
206 EXPORT_SYMBOL(mmc_register_driver);
207
208 /**
209  *      mmc_unregister_driver - unregister a media driver
210  *      @drv: MMC media driver
211  */
212 void mmc_unregister_driver(struct mmc_driver *drv)
213 {
214         drv->drv.bus = &mmc_bus_type;
215         driver_unregister(&drv->drv);
216 }
217
218 EXPORT_SYMBOL(mmc_unregister_driver);
219
220 static void mmc_release_card(struct device *dev)
221 {
222         struct mmc_card *card = mmc_dev_to_card(dev);
223
224         sdio_free_common_cis(card);
225
226         if (card->info)
227                 kfree(card->info);
228
229         kfree(card);
230 }
231
232 /*
233  * Allocate and initialise a new MMC card structure.
234  */
235 struct mmc_card *mmc_alloc_card(struct mmc_host *host, struct device_type *type)
236 {
237         struct mmc_card *card;
238
239         card = kzalloc(sizeof(struct mmc_card), GFP_KERNEL);
240         if (!card)
241                 return ERR_PTR(-ENOMEM);
242
243         card->host = host;
244
245         device_initialize(&card->dev);
246
247         card->dev.parent = mmc_classdev(host);
248         card->dev.bus = &mmc_bus_type;
249         card->dev.release = mmc_release_card;
250         card->dev.type = type;
251
252         return card;
253 }
254
255 /*
256  * Register a new MMC card with the driver model.
257  */
258 int mmc_add_card(struct mmc_card *card)
259 {
260         int ret;
261         const char *type;
262         const char *uhs_bus_speed_mode = "";
263         static const char *const uhs_speeds[] = {
264                 [UHS_SDR12_BUS_SPEED] = "SDR12 ",
265                 [UHS_SDR25_BUS_SPEED] = "SDR25 ",
266                 [UHS_SDR50_BUS_SPEED] = "SDR50 ",
267                 [UHS_SDR104_BUS_SPEED] = "SDR104 ",
268                 [UHS_DDR50_BUS_SPEED] = "DDR50 ",
269         };
270
271
272         dev_set_name(&card->dev, "%s:%04x", mmc_hostname(card->host), card->rca);
273
274         switch (card->type) {
275         case MMC_TYPE_MMC:
276                 type = "MMC";
277                 break;
278         case MMC_TYPE_SD:
279                 type = "SD";
280                 if (mmc_card_blockaddr(card)) {
281                         if (mmc_card_ext_capacity(card))
282                                 type = "SDXC";
283                         else
284                                 type = "SDHC";
285                 }
286                 break;
287         case MMC_TYPE_SDIO:
288                 type = "SDIO";
289                 break;
290         case MMC_TYPE_SD_COMBO:
291                 type = "SD-combo";
292                 if (mmc_card_blockaddr(card))
293                         type = "SDHC-combo";
294                 break;
295         default:
296                 type = "?";
297                 break;
298         }
299
300         if (mmc_sd_card_uhs(card) &&
301                 (card->sd_bus_speed < ARRAY_SIZE(uhs_speeds)))
302                 uhs_bus_speed_mode = uhs_speeds[card->sd_bus_speed];
303
304         if (mmc_host_is_spi(card->host)) {
305                 pr_info("%s: new %s%s%s card on SPI\n",
306                         mmc_hostname(card->host),
307                         mmc_card_highspeed(card) ? "high speed " : "",
308                         mmc_card_ddr_mode(card) ? "DDR " : "",
309                         type);
310         } else {
311                 pr_info("%s: new %s%s%s%s%s card at address %04x\n",
312                         mmc_hostname(card->host),
313                         mmc_card_uhs(card) ? "ultra high speed " :
314                         (mmc_card_highspeed(card) ? "high speed " : ""),
315                         (mmc_card_hs200(card) ? "HS200 " : ""),
316                         mmc_card_ddr_mode(card) ? "DDR " : "",
317                         uhs_bus_speed_mode, type, card->rca);
318         }
319
320 #ifdef CONFIG_DEBUG_FS
321         mmc_add_card_debugfs(card);
322 #endif
323
324         ret = device_add(&card->dev);
325         if (ret)
326                 return ret;
327
328         mmc_card_set_present(card);
329
330         return 0;
331 }
332
333 /*
334  * Unregister a new MMC card with the driver model, and
335  * (eventually) free it.
336  */
337 void mmc_remove_card(struct mmc_card *card)
338 {
339 #ifdef CONFIG_DEBUG_FS
340         mmc_remove_card_debugfs(card);
341 #endif
342
343         if (mmc_card_present(card)) {
344                 if (mmc_host_is_spi(card->host)) {
345                         pr_info("%s: SPI card removed\n",
346                                 mmc_hostname(card->host));
347                 } else {
348                         pr_info("%s: card %04x removed\n",
349                                 mmc_hostname(card->host), card->rca);
350                 }
351                 device_del(&card->dev);
352         }
353
354         put_device(&card->dev);
355 }
356