Pull events into release branch
[linux-2.6] / 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
17 #include <linux/mmc/card.h>
18 #include <linux/mmc/host.h>
19
20 #include "sysfs.h"
21 #include "core.h"
22 #include "bus.h"
23
24 #define dev_to_mmc_card(d)      container_of(d, struct mmc_card, dev)
25 #define to_mmc_driver(d)        container_of(d, struct mmc_driver, drv)
26
27 static ssize_t mmc_type_show(struct device *dev,
28         struct device_attribute *attr, char *buf)
29 {
30         struct mmc_card *card = dev_to_mmc_card(dev);
31
32         switch (card->type) {
33         case MMC_TYPE_MMC:
34                 return sprintf(buf, "MMC\n");
35         case MMC_TYPE_SD:
36                 return sprintf(buf, "SD\n");
37         default:
38                 return -EFAULT;
39         }
40 }
41
42 static struct device_attribute mmc_dev_attrs[] = {
43         MMC_ATTR_RO(type),
44         __ATTR_NULL,
45 };
46
47 /*
48  * This currently matches any MMC driver to any MMC card - drivers
49  * themselves make the decision whether to drive this card in their
50  * probe method.
51  */
52 static int mmc_bus_match(struct device *dev, struct device_driver *drv)
53 {
54         return 1;
55 }
56
57 static int
58 mmc_bus_uevent(struct device *dev, char **envp, int num_envp, char *buf,
59                 int buf_size)
60 {
61         struct mmc_card *card = dev_to_mmc_card(dev);
62         int retval = 0, i = 0, length = 0;
63
64 #define add_env(fmt,val) do {                                   \
65         retval = add_uevent_var(envp, num_envp, &i,             \
66                                 buf, buf_size, &length,         \
67                                 fmt, val);                      \
68         if (retval)                                             \
69                 return retval;                                  \
70 } while (0);
71
72         switch (card->type) {
73         case MMC_TYPE_MMC:
74                 add_env("MMC_TYPE=%s", "MMC");
75                 break;
76         case MMC_TYPE_SD:
77                 add_env("MMC_TYPE=%s", "SD");
78                 break;
79         }
80
81         add_env("MMC_NAME=%s", mmc_card_name(card));
82
83 #undef add_env
84
85         envp[i] = NULL;
86
87         return 0;
88 }
89
90 static int mmc_bus_probe(struct device *dev)
91 {
92         struct mmc_driver *drv = to_mmc_driver(dev->driver);
93         struct mmc_card *card = dev_to_mmc_card(dev);
94
95         return drv->probe(card);
96 }
97
98 static int mmc_bus_remove(struct device *dev)
99 {
100         struct mmc_driver *drv = to_mmc_driver(dev->driver);
101         struct mmc_card *card = dev_to_mmc_card(dev);
102
103         drv->remove(card);
104
105         return 0;
106 }
107
108 static int mmc_bus_suspend(struct device *dev, pm_message_t state)
109 {
110         struct mmc_driver *drv = to_mmc_driver(dev->driver);
111         struct mmc_card *card = dev_to_mmc_card(dev);
112         int ret = 0;
113
114         if (dev->driver && drv->suspend)
115                 ret = drv->suspend(card, state);
116         return ret;
117 }
118
119 static int mmc_bus_resume(struct device *dev)
120 {
121         struct mmc_driver *drv = to_mmc_driver(dev->driver);
122         struct mmc_card *card = dev_to_mmc_card(dev);
123         int ret = 0;
124
125         if (dev->driver && drv->resume)
126                 ret = drv->resume(card);
127         return ret;
128 }
129
130 static struct bus_type mmc_bus_type = {
131         .name           = "mmc",
132         .dev_attrs      = mmc_dev_attrs,
133         .match          = mmc_bus_match,
134         .uevent         = mmc_bus_uevent,
135         .probe          = mmc_bus_probe,
136         .remove         = mmc_bus_remove,
137         .suspend        = mmc_bus_suspend,
138         .resume         = mmc_bus_resume,
139 };
140
141 int mmc_register_bus(void)
142 {
143         return bus_register(&mmc_bus_type);
144 }
145
146 void mmc_unregister_bus(void)
147 {
148         bus_unregister(&mmc_bus_type);
149 }
150
151 /**
152  *      mmc_register_driver - register a media driver
153  *      @drv: MMC media driver
154  */
155 int mmc_register_driver(struct mmc_driver *drv)
156 {
157         drv->drv.bus = &mmc_bus_type;
158         return driver_register(&drv->drv);
159 }
160
161 EXPORT_SYMBOL(mmc_register_driver);
162
163 /**
164  *      mmc_unregister_driver - unregister a media driver
165  *      @drv: MMC media driver
166  */
167 void mmc_unregister_driver(struct mmc_driver *drv)
168 {
169         drv->drv.bus = &mmc_bus_type;
170         driver_unregister(&drv->drv);
171 }
172
173 EXPORT_SYMBOL(mmc_unregister_driver);
174
175 static void mmc_release_card(struct device *dev)
176 {
177         struct mmc_card *card = dev_to_mmc_card(dev);
178
179         kfree(card);
180 }
181
182 /*
183  * Allocate and initialise a new MMC card structure.
184  */
185 struct mmc_card *mmc_alloc_card(struct mmc_host *host)
186 {
187         struct mmc_card *card;
188
189         card = kzalloc(sizeof(struct mmc_card), GFP_KERNEL);
190         if (!card)
191                 return ERR_PTR(-ENOMEM);
192
193         card->host = host;
194
195         device_initialize(&card->dev);
196
197         card->dev.parent = mmc_classdev(host);
198         card->dev.bus = &mmc_bus_type;
199         card->dev.release = mmc_release_card;
200
201         return card;
202 }
203
204 /*
205  * Register a new MMC card with the driver model.
206  */
207 int mmc_add_card(struct mmc_card *card)
208 {
209         int ret;
210         const char *type;
211
212         snprintf(card->dev.bus_id, sizeof(card->dev.bus_id),
213                  "%s:%04x", mmc_hostname(card->host), card->rca);
214
215         switch (card->type) {
216         case MMC_TYPE_MMC:
217                 type = "MMC";
218                 break;
219         case MMC_TYPE_SD:
220                 type = "SD";
221                 if (mmc_card_blockaddr(card))
222                         type = "SDHC";
223                 break;
224         default:
225                 type = "?";
226                 break;
227         }
228
229         printk(KERN_INFO "%s: new %s%s card at address %04x\n",
230                 mmc_hostname(card->host),
231                 mmc_card_highspeed(card) ? "high speed " : "",
232                 type, card->rca);
233
234         card->dev.uevent_suppress = 1;
235
236         ret = device_add(&card->dev);
237         if (ret)
238                 return ret;
239
240         if (card->host->bus_ops->sysfs_add) {
241                 ret = card->host->bus_ops->sysfs_add(card->host, card);
242                 if (ret) {
243                         device_del(&card->dev);
244                         return ret;
245                  }
246         }
247
248         card->dev.uevent_suppress = 0;
249
250         kobject_uevent(&card->dev.kobj, KOBJ_ADD);
251
252         mmc_card_set_present(card);
253
254         return 0;
255 }
256
257 /*
258  * Unregister a new MMC card with the driver model, and
259  * (eventually) free it.
260  */
261 void mmc_remove_card(struct mmc_card *card)
262 {
263         if (mmc_card_present(card)) {
264                 printk(KERN_INFO "%s: card %04x removed\n",
265                         mmc_hostname(card->host), card->rca);
266
267                 if (card->host->bus_ops->sysfs_remove)
268                         card->host->bus_ops->sysfs_remove(card->host, card);
269                 device_del(&card->dev);
270         }
271
272         put_device(&card->dev);
273 }
274