393d817ed04076dca934511f4522b698776073ae
[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_suspend(struct device *dev, pm_message_t state)
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
129         if (dev->driver && drv->suspend)
130                 ret = drv->suspend(card, state);
131         return ret;
132 }
133
134 static int mmc_bus_resume(struct device *dev)
135 {
136         struct mmc_driver *drv = to_mmc_driver(dev->driver);
137         struct mmc_card *card = mmc_dev_to_card(dev);
138         int ret = 0;
139
140         if (dev->driver && drv->resume)
141                 ret = drv->resume(card);
142         return ret;
143 }
144
145 #ifdef CONFIG_PM_RUNTIME
146
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
166 static const struct dev_pm_ops mmc_bus_pm_ops = {
167         .runtime_suspend        = mmc_runtime_suspend,
168         .runtime_resume         = mmc_runtime_resume,
169         .runtime_idle           = mmc_runtime_idle,
170 };
171
172 #define MMC_PM_OPS_PTR  (&mmc_bus_pm_ops)
173
174 #else /* !CONFIG_PM_RUNTIME */
175
176 #define MMC_PM_OPS_PTR  NULL
177
178 #endif /* !CONFIG_PM_RUNTIME */
179
180 static struct bus_type mmc_bus_type = {
181         .name           = "mmc",
182         .dev_attrs      = mmc_dev_attrs,
183         .match          = mmc_bus_match,
184         .uevent         = mmc_bus_uevent,
185         .probe          = mmc_bus_probe,
186         .remove         = mmc_bus_remove,
187         .suspend        = mmc_bus_suspend,
188         .resume         = mmc_bus_resume,
189         .pm             = MMC_PM_OPS_PTR,
190 };
191
192 int mmc_register_bus(void)
193 {
194         return bus_register(&mmc_bus_type);
195 }
196
197 void mmc_unregister_bus(void)
198 {
199         bus_unregister(&mmc_bus_type);
200 }
201
202 /**
203  *      mmc_register_driver - register a media driver
204  *      @drv: MMC media driver
205  */
206 int mmc_register_driver(struct mmc_driver *drv)
207 {
208         drv->drv.bus = &mmc_bus_type;
209         return driver_register(&drv->drv);
210 }
211
212 EXPORT_SYMBOL(mmc_register_driver);
213
214 /**
215  *      mmc_unregister_driver - unregister a media driver
216  *      @drv: MMC media driver
217  */
218 void mmc_unregister_driver(struct mmc_driver *drv)
219 {
220         drv->drv.bus = &mmc_bus_type;
221         driver_unregister(&drv->drv);
222 }
223
224 EXPORT_SYMBOL(mmc_unregister_driver);
225
226 static void mmc_release_card(struct device *dev)
227 {
228         struct mmc_card *card = mmc_dev_to_card(dev);
229
230         sdio_free_common_cis(card);
231
232         if (card->info)
233                 kfree(card->info);
234
235         kfree(card);
236 }
237
238 /*
239  * Allocate and initialise a new MMC card structure.
240  */
241 struct mmc_card *mmc_alloc_card(struct mmc_host *host, struct device_type *type)
242 {
243         struct mmc_card *card;
244
245         card = kzalloc(sizeof(struct mmc_card), GFP_KERNEL);
246         if (!card)
247                 return ERR_PTR(-ENOMEM);
248
249         card->host = host;
250
251         device_initialize(&card->dev);
252
253         card->dev.parent = mmc_classdev(host);
254         card->dev.bus = &mmc_bus_type;
255         card->dev.release = mmc_release_card;
256         card->dev.type = type;
257
258         return card;
259 }
260
261 /*
262  * Register a new MMC card with the driver model.
263  */
264 int mmc_add_card(struct mmc_card *card)
265 {
266         int ret;
267         const char *type;
268
269         dev_set_name(&card->dev, "%s:%04x", mmc_hostname(card->host), card->rca);
270
271         switch (card->type) {
272         case MMC_TYPE_MMC:
273                 type = "MMC";
274                 break;
275         case MMC_TYPE_SD:
276                 type = "SD";
277                 if (mmc_card_blockaddr(card)) {
278                         if (mmc_card_ext_capacity(card))
279                                 type = "SDXC";
280                         else
281                                 type = "SDHC";
282                 }
283                 break;
284         case MMC_TYPE_SDIO:
285                 type = "SDIO";
286                 break;
287         case MMC_TYPE_SD_COMBO:
288                 type = "SD-combo";
289                 if (mmc_card_blockaddr(card))
290                         type = "SDHC-combo";
291                 break;
292         default:
293                 type = "?";
294                 break;
295         }
296
297         if (mmc_host_is_spi(card->host)) {
298                 printk(KERN_INFO "%s: new %s%s%s card on SPI\n",
299                         mmc_hostname(card->host),
300                         mmc_card_highspeed(card) ? "high speed " : "",
301                         mmc_card_ddr_mode(card) ? "DDR " : "",
302                         type);
303         } else {
304                 printk(KERN_INFO "%s: new %s%s%s card at address %04x\n",
305                         mmc_hostname(card->host),
306                         mmc_sd_card_uhs(card) ? "ultra high speed " :
307                         (mmc_card_highspeed(card) ? "high speed " : ""),
308                         mmc_card_ddr_mode(card) ? "DDR " : "",
309                         type, card->rca);
310         }
311
312 #ifdef CONFIG_DEBUG_FS
313         mmc_add_card_debugfs(card);
314 #endif
315
316         ret = device_add(&card->dev);
317         if (ret)
318                 return ret;
319
320         mmc_card_set_present(card);
321
322         return 0;
323 }
324
325 /*
326  * Unregister a new MMC card with the driver model, and
327  * (eventually) free it.
328  */
329 void mmc_remove_card(struct mmc_card *card)
330 {
331 #ifdef CONFIG_DEBUG_FS
332         mmc_remove_card_debugfs(card);
333 #endif
334
335         if (mmc_card_present(card)) {
336                 if (mmc_host_is_spi(card->host)) {
337                         printk(KERN_INFO "%s: SPI card removed\n",
338                                 mmc_hostname(card->host));
339                 } else {
340                         printk(KERN_INFO "%s: card %04x removed\n",
341                                 mmc_hostname(card->host), card->rca);
342                 }
343                 device_del(&card->dev);
344         }
345
346         put_device(&card->dev);
347 }
348