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