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