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
mmc_type_show(struct device * dev,struct device_attribute * attr,char * buf)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 */
mmc_bus_match(struct device * dev,struct device_driver * drv)57 static int mmc_bus_match(struct device *dev, struct device_driver *drv)
58 {
59 return 1;
60 }
61
62 static int
mmc_bus_uevent(struct device * dev,struct kobj_uevent_env * env)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
mmc_bus_probe(struct device * dev)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
mmc_bus_remove(struct device * dev)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
mmc_bus_suspend(struct device * dev,pm_message_t state)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
mmc_bus_resume(struct device * dev)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
mmc_runtime_suspend(struct device * dev)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
mmc_runtime_resume(struct device * dev)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
mmc_runtime_idle(struct device * dev)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
mmc_register_bus(void)192 int mmc_register_bus(void)
193 {
194 return bus_register(&mmc_bus_type);
195 }
196
mmc_unregister_bus(void)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 */
mmc_register_driver(struct mmc_driver * drv)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 */
mmc_unregister_driver(struct mmc_driver * drv)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
mmc_release_card(struct device * dev)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 */
mmc_alloc_card(struct mmc_host * host,struct device_type * type)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 */
mmc_add_card(struct mmc_card * card)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 type = "SDHC";
279 break;
280 case MMC_TYPE_SDIO:
281 type = "SDIO";
282 break;
283 case MMC_TYPE_SD_COMBO:
284 type = "SD-combo";
285 if (mmc_card_blockaddr(card))
286 type = "SDHC-combo";
287 break;
288 default:
289 type = "?";
290 break;
291 }
292
293 if (mmc_host_is_spi(card->host)) {
294 printk(KERN_INFO "%s: new %s%s%s card on SPI\n",
295 mmc_hostname(card->host),
296 mmc_card_highspeed(card) ? "high speed " : "",
297 mmc_card_ddr_mode(card) ? "DDR " : "",
298 type);
299 } else {
300 printk(KERN_INFO "%s: new %s%s%s card at address %04x\n",
301 mmc_hostname(card->host),
302 mmc_card_highspeed(card) ? "high speed " : "",
303 mmc_card_ddr_mode(card) ? "DDR " : "",
304 type, card->rca);
305 }
306
307 #ifdef CONFIG_DEBUG_FS
308 mmc_add_card_debugfs(card);
309 #endif
310
311 ret = device_add(&card->dev);
312 if (ret)
313 return ret;
314
315 mmc_card_set_present(card);
316
317 return 0;
318 }
319
320 /*
321 * Unregister a new MMC card with the driver model, and
322 * (eventually) free it.
323 */
mmc_remove_card(struct mmc_card * card)324 void mmc_remove_card(struct mmc_card *card)
325 {
326 #ifdef CONFIG_DEBUG_FS
327 mmc_remove_card_debugfs(card);
328 #endif
329
330 if (mmc_card_present(card)) {
331 if (mmc_host_is_spi(card->host)) {
332 printk(KERN_INFO "%s: SPI card removed\n",
333 mmc_hostname(card->host));
334 } else {
335 printk(KERN_INFO "%s: card %04x removed\n",
336 mmc_hostname(card->host), card->rca);
337 }
338 device_del(&card->dev);
339 }
340
341 put_device(&card->dev);
342 }
343
344