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
 28static 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
 47static 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 */
 57static int mmc_bus_match(struct device *dev, struct device_driver *drv)
 58{
 59	return 1;
 60}
 61
 62static int
 63mmc_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
105static 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
113static 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
123static 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
134static 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
147static 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
154static 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
161static int mmc_runtime_idle(struct device *dev)
162{
163	return pm_runtime_suspend(dev);
164}
165
 
 
166static 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
180static 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
192int mmc_register_bus(void)
193{
194	return bus_register(&mmc_bus_type);
195}
196
197void 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 */
206int mmc_register_driver(struct mmc_driver *drv)
207{
208	drv->drv.bus = &mmc_bus_type;
209	return driver_register(&drv->drv);
210}
211
212EXPORT_SYMBOL(mmc_register_driver);
213
214/**
215 *	mmc_unregister_driver - unregister a media driver
216 *	@drv: MMC media driver
217 */
218void mmc_unregister_driver(struct mmc_driver *drv)
219{
220	drv->drv.bus = &mmc_bus_type;
221	driver_unregister(&drv->drv);
222}
223
224EXPORT_SYMBOL(mmc_unregister_driver);
225
226static 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 */
241struct 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 */
264int 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 */
329void 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

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