[deliverable/linux.git] / drivers / mmc / core / bus.c

/*
 *  linux/drivers/mmc/core/bus.c
 *
 *  Copyright (C) 2003 Russell King, All Rights Reserved.
 *  Copyright (C) 2007 Pierre Ossman
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 *  MMC card bus driver model
 */

#include <linux/export.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/stat.h>
#include <linux/of.h>
#include <linux/pm_runtime.h>

#include <linux/mmc/card.h>
#include <linux/mmc/host.h>

#include "core.h"
#include "sdio_cis.h"
#include "bus.h"

#define to_mmc_driver(d)	container_of(d, struct mmc_driver, drv)

static ssize_t type_show(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct mmc_card *card = mmc_dev_to_card(dev);

	switch (card->type) {
	case MMC_TYPE_MMC:
		return sprintf(buf, "MMC\n");
	case MMC_TYPE_SD:
		return sprintf(buf, "SD\n");
	case MMC_TYPE_SDIO:
		return sprintf(buf, "SDIO\n");
	case MMC_TYPE_SD_COMBO:
		return sprintf(buf, "SDcombo\n");
	default:
		return -EFAULT;
	}
}
static DEVICE_ATTR_RO(type);

static struct attribute *mmc_dev_attrs[] = {
	&dev_attr_type.attr,
	NULL,
};
ATTRIBUTE_GROUPS(mmc_dev);

/*
 * This currently matches any MMC driver to any MMC card - drivers
 * themselves make the decision whether to drive this card in their
 * probe method.
 */
static int mmc_bus_match(struct device *dev, struct device_driver *drv)
{
	return 1;
}

static int
mmc_bus_uevent(struct device *dev, struct kobj_uevent_env *env)
{
	struct mmc_card *card = mmc_dev_to_card(dev);
	const char *type;
	int retval = 0;

	switch (card->type) {
	case MMC_TYPE_MMC:
		type = "MMC";
		break;
	case MMC_TYPE_SD:
		type = "SD";
		break;
	case MMC_TYPE_SDIO:
		type = "SDIO";
		break;
	case MMC_TYPE_SD_COMBO:
		type = "SDcombo";
		break;
	default:
		type = NULL;
	}

	if (type) {
		retval = add_uevent_var(env, "MMC_TYPE=%s", type);
		if (retval)
			return retval;
	}

	retval = add_uevent_var(env, "MMC_NAME=%s", mmc_card_name(card));
	if (retval)
		return retval;

	/*
	 * Request the mmc_block device.  Note: that this is a direct request
	 * for the module it carries no information as to what is inserted.
	 */
	retval = add_uevent_var(env, "MODALIAS=mmc:block");

	return retval;
}

static int mmc_bus_probe(struct device *dev)
{
	struct mmc_driver *drv = to_mmc_driver(dev->driver);
	struct mmc_card *card = mmc_dev_to_card(dev);

	return drv->probe(card);
}

static int mmc_bus_remove(struct device *dev)
{
	struct mmc_driver *drv = to_mmc_driver(dev->driver);
	struct mmc_card *card = mmc_dev_to_card(dev);

	drv->remove(card);

	return 0;
}

static void mmc_bus_shutdown(struct device *dev)
{
	struct mmc_driver *drv = to_mmc_driver(dev->driver);
	struct mmc_card *card = mmc_dev_to_card(dev);
	struct mmc_host *host = card->host;
	int ret;

	if (dev->driver && drv->shutdown)
		drv->shutdown(card);

	if (host->bus_ops->shutdown) {
		ret = host->bus_ops->shutdown(host);
		if (ret)
			pr_warn("%s: error %d during shutdown\n",
				mmc_hostname(host), ret);
	}
}

#ifdef CONFIG_PM_SLEEP
static int mmc_bus_suspend(struct device *dev)
{
	struct mmc_card *card = mmc_dev_to_card(dev);
	struct mmc_host *host = card->host;
	int ret;

	ret = pm_generic_suspend(dev);
	if (ret)
		return ret;

	ret = host->bus_ops->suspend(host);
	return ret;
}

static int mmc_bus_resume(struct device *dev)
{
	struct mmc_card *card = mmc_dev_to_card(dev);
	struct mmc_host *host = card->host;
	int ret;

	ret = host->bus_ops->resume(host);
	if (ret)
		pr_warn("%s: error %d during resume (card was removed?)\n",
			mmc_hostname(host), ret);

	ret = pm_generic_resume(dev);
	return ret;
}
#endif

#ifdef CONFIG_PM
static int mmc_runtime_suspend(struct device *dev)
{
	struct mmc_card *card = mmc_dev_to_card(dev);
	struct mmc_host *host = card->host;

	return host->bus_ops->runtime_suspend(host);
}

static int mmc_runtime_resume(struct device *dev)
{
	struct mmc_card *card = mmc_dev_to_card(dev);
	struct mmc_host *host = card->host;

	return host->bus_ops->runtime_resume(host);
}
#endif /* !CONFIG_PM */

static const struct dev_pm_ops mmc_bus_pm_ops = {
	SET_RUNTIME_PM_OPS(mmc_runtime_suspend, mmc_runtime_resume, NULL)
	SET_SYSTEM_SLEEP_PM_OPS(mmc_bus_suspend, mmc_bus_resume)
};

static struct bus_type mmc_bus_type = {
	.name		= "mmc",
	.dev_groups	= mmc_dev_groups,
	.match		= mmc_bus_match,
	.uevent		= mmc_bus_uevent,
	.probe		= mmc_bus_probe,
	.remove		= mmc_bus_remove,
	.shutdown	= mmc_bus_shutdown,
	.pm		= &mmc_bus_pm_ops,
};

int mmc_register_bus(void)
{
	return bus_register(&mmc_bus_type);
}

void mmc_unregister_bus(void)
{
	bus_unregister(&mmc_bus_type);
}

/**
 *	mmc_register_driver - register a media driver
 *	@drv: MMC media driver
 */
int mmc_register_driver(struct mmc_driver *drv)
{
	drv->drv.bus = &mmc_bus_type;
	return driver_register(&drv->drv);
}

EXPORT_SYMBOL(mmc_register_driver);

/**
 *	mmc_unregister_driver - unregister a media driver
 *	@drv: MMC media driver
 */
void mmc_unregister_driver(struct mmc_driver *drv)
{
	drv->drv.bus = &mmc_bus_type;
	driver_unregister(&drv->drv);
}

EXPORT_SYMBOL(mmc_unregister_driver);

static void mmc_release_card(struct device *dev)
{
	struct mmc_card *card = mmc_dev_to_card(dev);

	sdio_free_common_cis(card);

	kfree(card->info);

	kfree(card);
}

/*
 * Allocate and initialise a new MMC card structure.
 */
struct mmc_card *mmc_alloc_card(struct mmc_host *host, struct device_type *type)
{
	struct mmc_card *card;

	card = kzalloc(sizeof(struct mmc_card), GFP_KERNEL);
	if (!card)
		return ERR_PTR(-ENOMEM);

	card->host = host;

	device_initialize(&card->dev);

	card->dev.parent = mmc_classdev(host);
	card->dev.bus = &mmc_bus_type;
	card->dev.release = mmc_release_card;
	card->dev.type = type;

	return card;
}

/*
 * Register a new MMC card with the driver model.
 */
int mmc_add_card(struct mmc_card *card)
{
	int ret;
	const char *type;
	const char *uhs_bus_speed_mode = "";
	static const char *const uhs_speeds[] = {
		[UHS_SDR12_BUS_SPEED] = "SDR12 ",
		[UHS_SDR25_BUS_SPEED] = "SDR25 ",
		[UHS_SDR50_BUS_SPEED] = "SDR50 ",
		[UHS_SDR104_BUS_SPEED] = "SDR104 ",
		[UHS_DDR50_BUS_SPEED] = "DDR50 ",
	};


	dev_set_name(&card->dev, "%s:%04x", mmc_hostname(card->host), card->rca);

	switch (card->type) {
	case MMC_TYPE_MMC:
		type = "MMC";
		break;
	case MMC_TYPE_SD:
		type = "SD";
		if (mmc_card_blockaddr(card)) {
			if (mmc_card_ext_capacity(card))
				type = "SDXC";
			else
				type = "SDHC";
		}
		break;
	case MMC_TYPE_SDIO:
		type = "SDIO";
		break;
	case MMC_TYPE_SD_COMBO:
		type = "SD-combo";
		if (mmc_card_blockaddr(card))
			type = "SDHC-combo";
		break;
	default:
		type = "?";
		break;
	}

	if (mmc_card_uhs(card) &&
		(card->sd_bus_speed < ARRAY_SIZE(uhs_speeds)))
		uhs_bus_speed_mode = uhs_speeds[card->sd_bus_speed];

	if (mmc_host_is_spi(card->host)) {
		pr_info("%s: new %s%s%s card on SPI\n",
			mmc_hostname(card->host),
			mmc_card_hs(card) ? "high speed " : "",
			mmc_card_ddr52(card) ? "DDR " : "",
			type);
	} else {
		pr_info("%s: new %s%s%s%s%s%s card at address %04x\n",
			mmc_hostname(card->host),
			mmc_card_uhs(card) ? "ultra high speed " :
			(mmc_card_hs(card) ? "high speed " : ""),
			mmc_card_hs400(card) ? "HS400 " :
			(mmc_card_hs200(card) ? "HS200 " : ""),
			mmc_card_hs400es(card) ? "Enhanced strobe " : "",
			mmc_card_ddr52(card) ? "DDR " : "",
			uhs_bus_speed_mode, type, card->rca);
	}

#ifdef CONFIG_DEBUG_FS
	mmc_add_card_debugfs(card);
#endif
	mmc_init_context_info(card->host);

	card->dev.of_node = mmc_of_find_child_device(card->host, 0);

	device_enable_async_suspend(&card->dev);

	ret = device_add(&card->dev);
	if (ret)
		return ret;

	mmc_card_set_present(card);

	return 0;
}

/*
 * Unregister a new MMC card with the driver model, and
 * (eventually) free it.
 */
void mmc_remove_card(struct mmc_card *card)
{
#ifdef CONFIG_DEBUG_FS
	mmc_remove_card_debugfs(card);
#endif

	if (mmc_card_present(card)) {
		if (mmc_host_is_spi(card->host)) {
			pr_info("%s: SPI card removed\n",
				mmc_hostname(card->host));
		} else {
			pr_info("%s: card %04x removed\n",
				mmc_hostname(card->host), card->rca);
		}
		device_del(&card->dev);
		of_node_put(card->dev.of_node);
	}

	put_device(&card->dev);
}
Commit	Line	Data
4101c16a PO	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
3ef77af1	14	#include <linux/export.h>
4101c16a PO	15	#include <linux/device.h>
4101c16a PO	16	#include <linux/err.h>
5a0e3ad6	17	#include <linux/slab.h>
0205a904	18	#include <linux/stat.h>
25185f3f	19	#include <linux/of.h>
516d5ccd	20	#include <linux/pm_runtime.h>
4101c16a PO	21
	22	#include <linux/mmc/card.h>
	23	#include <linux/mmc/host.h>
	24
4101c16a	25	#include "core.h"
1a632f8c	26	#include "sdio_cis.h"
4101c16a PO	27	#include "bus.h"
4101c16a PO	28
96541bac UH	29	#define to_mmc_driver(d) container_of(d, struct mmc_driver, drv)
96541bac UH	30
f24fc57b	31	static ssize_t type_show(struct device *dev,
4101c16a PO	32	struct device_attribute attr, char buf)
4101c16a PO	33	{
265cdc90	34	struct mmc_card *card = mmc_dev_to_card(dev);
4101c16a PO	35
	36	switch (card->type) {
	37	case MMC_TYPE_MMC:
	38	return sprintf(buf, "MMC\n");
	39	case MMC_TYPE_SD:
	40	return sprintf(buf, "SD\n");
5c4e6f13 PO	41	case MMC_TYPE_SDIO:
5c4e6f13 PO	42	return sprintf(buf, "SDIO\n");
7310ece8 MM	43	case MMC_TYPE_SD_COMBO:
7310ece8 MM	44	return sprintf(buf, "SDcombo\n");
4101c16a PO	45	default:
	46	return -EFAULT;
	47	}
	48	}
f24fc57b	49	static DEVICE_ATTR_RO(type);
4101c16a	50
f24fc57b GKH	51	static struct attribute *mmc_dev_attrs[] = {
	52	&dev_attr_type.attr,
	53	NULL,
4101c16a	54	};
f24fc57b	55	ATTRIBUTE_GROUPS(mmc_dev);
4101c16a PO	56
	57	/*
	58	* This currently matches any MMC driver to any MMC card - drivers
	59	* themselves make the decision whether to drive this card in their
	60	* probe method.
	61	*/
	62	static int mmc_bus_match(struct device dev, struct device_driver drv)
	63	{
	64	return 1;
	65	}
	66
	67	static int
7eff2e7a	68	mmc_bus_uevent(struct device dev, struct kobj_uevent_env env)
4101c16a	69	{
265cdc90	70	struct mmc_card *card = mmc_dev_to_card(dev);
9eb3a94d	71	const char *type;
7eff2e7a	72	int retval = 0;
4101c16a PO	73
	74	switch (card->type) {
	75	case MMC_TYPE_MMC:
9eb3a94d	76	type = "MMC";
4101c16a PO	77	break;
4101c16a PO	78	case MMC_TYPE_SD:
9eb3a94d	79	type = "SD";
4101c16a	80	break;
5c4e6f13	81	case MMC_TYPE_SDIO:
9eb3a94d	82	type = "SDIO";
5c4e6f13	83	break;
7310ece8 MM	84	case MMC_TYPE_SD_COMBO:
	85	type = "SDcombo";
	86	break;
9eb3a94d PO	87	default:
9eb3a94d PO	88	type = NULL;
4101c16a PO	89	}
4101c16a PO	90
9eb3a94d	91	if (type) {
7eff2e7a KS	92	retval = add_uevent_var(env, "MMC_TYPE=%s", type);
	93	if (retval)
	94	return retval;
9eb3a94d	95	}
4101c16a	96
7eff2e7a	97	retval = add_uevent_var(env, "MMC_NAME=%s", mmc_card_name(card));
6b0b6285 AW	98	if (retval)
	99	return retval;
	100
	101	/*
	102	* Request the mmc_block device. Note: that this is a direct request
	103	* for the module it carries no information as to what is inserted.
	104	*/
	105	retval = add_uevent_var(env, "MODALIAS=mmc:block");
4101c16a	106
7eff2e7a	107	return retval;
4101c16a PO	108	}
4101c16a PO	109
96541bac UH	110	static int mmc_bus_probe(struct device *dev)
	111	{
	112	struct mmc_driver *drv = to_mmc_driver(dev->driver);
	113	struct mmc_card *card = mmc_dev_to_card(dev);
	114
	115	return drv->probe(card);
	116	}
	117
	118	static int mmc_bus_remove(struct device *dev)
	119	{
	120	struct mmc_driver *drv = to_mmc_driver(dev->driver);
	121	struct mmc_card *card = mmc_dev_to_card(dev);
	122
	123	drv->remove(card);
	124
	125	return 0;
	126	}
	127
76287748 UH	128	static void mmc_bus_shutdown(struct device *dev)
76287748 UH	129	{
96541bac	130	struct mmc_driver *drv = to_mmc_driver(dev->driver);
76287748	131	struct mmc_card *card = mmc_dev_to_card(dev);
6b086bde UH	132	struct mmc_host *host = card->host;
6b086bde UH	133	int ret;
76287748	134
96541bac UH	135	if (dev->driver && drv->shutdown)
96541bac UH	136	drv->shutdown(card);
6b086bde UH	137
	138	if (host->bus_ops->shutdown) {
	139	ret = host->bus_ops->shutdown(host);
	140	if (ret)
	141	pr_warn("%s: error %d during shutdown\n",
	142	mmc_hostname(host), ret);
	143	}
76287748 UH	144	}
76287748 UH	145
0dd1bfeb	146	#ifdef CONFIG_PM_SLEEP
32d317c6	147	static int mmc_bus_suspend(struct device *dev)
4101c16a	148	{
265cdc90	149	struct mmc_card *card = mmc_dev_to_card(dev);
986892ca UH	150	struct mmc_host *host = card->host;
986892ca UH	151	int ret;
4101c16a	152
0967edc6 UH	153	ret = pm_generic_suspend(dev);
	154	if (ret)
	155	return ret;
986892ca UH	156
986892ca UH	157	ret = host->bus_ops->suspend(host);
4101c16a PO	158	return ret;
	159	}
	160
	161	static int mmc_bus_resume(struct device *dev)
	162	{
265cdc90	163	struct mmc_card *card = mmc_dev_to_card(dev);
986892ca UH	164	struct mmc_host *host = card->host;
	165	int ret;
	166
	167	ret = host->bus_ops->resume(host);
	168	if (ret)
	169	pr_warn("%s: error %d during resume (card was removed?)\n",
	170	mmc_hostname(host), ret);
4101c16a	171
0967edc6	172	ret = pm_generic_resume(dev);
4101c16a PO	173	return ret;
4101c16a PO	174	}
0dd1bfeb	175	#endif
4101c16a	176
162d6f98	177	#ifdef CONFIG_PM
516d5ccd OBC	178	static int mmc_runtime_suspend(struct device *dev)
	179	{
	180	struct mmc_card *card = mmc_dev_to_card(dev);
12d01d0b	181	struct mmc_host *host = card->host;
516d5ccd	182
5601aaf7	183	return host->bus_ops->runtime_suspend(host);
516d5ccd OBC	184	}
	185
	186	static int mmc_runtime_resume(struct device *dev)
	187	{
	188	struct mmc_card *card = mmc_dev_to_card(dev);
12d01d0b	189	struct mmc_host *host = card->host;
516d5ccd	190
5601aaf7	191	return host->bus_ops->runtime_resume(host);
516d5ccd	192	}
162d6f98	193	#endif /* !CONFIG_PM */
32d317c6	194
516d5ccd	195	static const struct dev_pm_ops mmc_bus_pm_ops = {
2e42da59	196	SET_RUNTIME_PM_OPS(mmc_runtime_suspend, mmc_runtime_resume, NULL)
32d317c6	197	SET_SYSTEM_SLEEP_PM_OPS(mmc_bus_suspend, mmc_bus_resume)
516d5ccd OBC	198	};
516d5ccd OBC	199
4101c16a PO	200	static struct bus_type mmc_bus_type = {
4101c16a PO	201	.name = "mmc",
f24fc57b	202	.dev_groups = mmc_dev_groups,
4101c16a PO	203	.match = mmc_bus_match,
4101c16a PO	204	.uevent = mmc_bus_uevent,
96541bac UH	205	.probe = mmc_bus_probe,
96541bac UH	206	.remove = mmc_bus_remove,
76287748	207	.shutdown = mmc_bus_shutdown,
32d317c6	208	.pm = &mmc_bus_pm_ops,
4101c16a PO	209	};
	210
	211	int mmc_register_bus(void)
	212	{
	213	return bus_register(&mmc_bus_type);
	214	}
	215
	216	void mmc_unregister_bus(void)
	217	{
	218	bus_unregister(&mmc_bus_type);
	219	}
	220
	221	/**
	222	* mmc_register_driver - register a media driver
	223	* @drv: MMC media driver
	224	*/
96541bac	225	int mmc_register_driver(struct mmc_driver *drv)
4101c16a	226	{
96541bac UH	227	drv->drv.bus = &mmc_bus_type;
96541bac UH	228	return driver_register(&drv->drv);
4101c16a	229	}
96541bac	230
4101c16a PO	231	EXPORT_SYMBOL(mmc_register_driver);
	232
	233	/**
	234	* mmc_unregister_driver - unregister a media driver
	235	* @drv: MMC media driver
	236	*/
96541bac	237	void mmc_unregister_driver(struct mmc_driver *drv)
4101c16a	238	{
96541bac UH	239	drv->drv.bus = &mmc_bus_type;
96541bac UH	240	driver_unregister(&drv->drv);
4101c16a	241	}
96541bac	242
4101c16a PO	243	EXPORT_SYMBOL(mmc_unregister_driver);
	244
	245	static void mmc_release_card(struct device *dev)
	246	{
265cdc90	247	struct mmc_card *card = mmc_dev_to_card(dev);
4101c16a	248
1a632f8c PO	249	sdio_free_common_cis(card);
1a632f8c PO	250
8db580cc	251	kfree(card->info);
759bdc7a	252
4101c16a PO	253	kfree(card);
	254	}
	255
	256	/*
	257	* Allocate and initialise a new MMC card structure.
	258	*/
51ec92e2	259	struct mmc_card mmc_alloc_card(struct mmc_host host, struct device_type *type)
4101c16a PO	260	{
	261	struct mmc_card *card;
	262
733cb1e4	263	card = kzalloc(sizeof(struct mmc_card), GFP_KERNEL);
4101c16a PO	264	if (!card)
	265	return ERR_PTR(-ENOMEM);
	266
4101c16a PO	267	card->host = host;
	268
	269	device_initialize(&card->dev);
	270
	271	card->dev.parent = mmc_classdev(host);
	272	card->dev.bus = &mmc_bus_type;
	273	card->dev.release = mmc_release_card;
51ec92e2	274	card->dev.type = type;
4101c16a PO	275
	276	return card;
	277	}
	278
	279	/*
	280	* Register a new MMC card with the driver model.
	281	*/
	282	int mmc_add_card(struct mmc_card *card)
	283	{
	284	int ret;
109b5bed	285	const char *type;
6500c8ed SJ	286	const char *uhs_bus_speed_mode = "";
	287	static const char *const uhs_speeds[] = {
	288	[UHS_SDR12_BUS_SPEED] = "SDR12 ",
	289	[UHS_SDR25_BUS_SPEED] = "SDR25 ",
	290	[UHS_SDR50_BUS_SPEED] = "SDR50 ",
	291	[UHS_SDR104_BUS_SPEED] = "SDR104 ",
	292	[UHS_DDR50_BUS_SPEED] = "DDR50 ",
	293	};
	294
4101c16a	295
d1b26863	296	dev_set_name(&card->dev, "%s:%04x", mmc_hostname(card->host), card->rca);
4101c16a	297
109b5bed PO	298	switch (card->type) {
	299	case MMC_TYPE_MMC:
	300	type = "MMC";
	301	break;
	302	case MMC_TYPE_SD:
	303	type = "SD";
3a303511 AN	304	if (mmc_card_blockaddr(card)) {
	305	if (mmc_card_ext_capacity(card))
	306	type = "SDXC";
	307	else
	308	type = "SDHC";
	309	}
109b5bed	310	break;
5c4e6f13 PO	311	case MMC_TYPE_SDIO:
	312	type = "SDIO";
	313	break;
7310ece8 MM	314	case MMC_TYPE_SD_COMBO:
	315	type = "SD-combo";
	316	if (mmc_card_blockaddr(card))
	317	type = "SDHC-combo";
9bc21848	318	break;
109b5bed PO	319	default:
	320	type = "?";
	321	break;
	322	}
	323
71ef1ea4	324	if (mmc_card_uhs(card) &&
6500c8ed SJ	325	(card->sd_bus_speed < ARRAY_SIZE(uhs_speeds)))
	326	uhs_bus_speed_mode = uhs_speeds[card->sd_bus_speed];
	327
af517150	328	if (mmc_host_is_spi(card->host)) {
a3c76eb9	329	pr_info("%s: new %s%s%s card on SPI\n",
af517150	330	mmc_hostname(card->host),
cdc99179 SJ	331	mmc_card_hs(card) ? "high speed " : "",
cdc99179 SJ	332	mmc_card_ddr52(card) ? "DDR " : "",
af517150 DB	333	type);
af517150 DB	334	} else {
81ac2af6	335	pr_info("%s: new %s%s%s%s%s%s card at address %04x\n",
af517150	336	mmc_hostname(card->host),
a303c531	337	mmc_card_uhs(card) ? "ultra high speed " :
cdc99179	338	(mmc_card_hs(card) ? "high speed " : ""),
0a5b6438	339	mmc_card_hs400(card) ? "HS400 " :
a4924c71	340	(mmc_card_hs200(card) ? "HS200 " : ""),
81ac2af6	341	mmc_card_hs400es(card) ? "Enhanced strobe " : "",
cdc99179	342	mmc_card_ddr52(card) ? "DDR " : "",
6500c8ed	343	uhs_bus_speed_mode, type, card->rca);
af517150	344	}
109b5bed	345
f4b7f927 HS	346	#ifdef CONFIG_DEBUG_FS
	347	mmc_add_card_debugfs(card);
	348	#endif
2220eedf	349	mmc_init_context_info(card->host);
f4b7f927	350
25185f3f SH	351	card->dev.of_node = mmc_of_find_child_device(card->host, 0);
25185f3f SH	352
ec076cd2 FZ	353	device_enable_async_suspend(&card->dev);
ec076cd2 FZ	354
1a2727e9 VK	355	ret = device_add(&card->dev);
	356	if (ret)
	357	return ret;
	358
4101c16a PO	359	mmc_card_set_present(card);
	360
	361	return 0;
	362	}
	363
	364	/*
	365	* Unregister a new MMC card with the driver model, and
	366	* (eventually) free it.
	367	*/
	368	void mmc_remove_card(struct mmc_card *card)
	369	{
f4b7f927 HS	370	#ifdef CONFIG_DEBUG_FS
	371	mmc_remove_card_debugfs(card);
	372	#endif
	373
4101c16a	374	if (mmc_card_present(card)) {
af517150	375	if (mmc_host_is_spi(card->host)) {
a3c76eb9	376	pr_info("%s: SPI card removed\n",
af517150 DB	377	mmc_hostname(card->host));
af517150 DB	378	} else {
a3c76eb9	379	pr_info("%s: card %04x removed\n",
af517150 DB	380	mmc_hostname(card->host), card->rca);
af517150 DB	381	}
4101c16a	382	device_del(&card->dev);
25185f3f	383	of_node_put(card->dev.of_node);
4101c16a PO	384	}
	385
	386	put_device(&card->dev);
	387	}
	388