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

/*
 *  linux/drivers/mmc/core/host.c
 *
 *  Copyright (C) 2003 Russell King, All Rights Reserved.
 *  Copyright (C) 2007-2008 Pierre Ossman
 *  Copyright (C) 2010 Linus Walleij
 *
 * 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 host class device management
 */

#include <linux/device.h>
#include <linux/err.h>
#include <linux/idr.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/pagemap.h>
#include <linux/export.h>
#include <linux/leds.h>
#include <linux/slab.h>
#include <linux/suspend.h>

#include <linux/mmc/host.h>
#include <linux/mmc/card.h>
#include <linux/mmc/slot-gpio.h>

#include "core.h"
#include "host.h"
#include "slot-gpio.h"
#include "pwrseq.h"

#define cls_dev_to_mmc_host(d)	container_of(d, struct mmc_host, class_dev)

static DEFINE_IDR(mmc_host_idr);
static DEFINE_SPINLOCK(mmc_host_lock);

static void mmc_host_classdev_release(struct device *dev)
{
	struct mmc_host *host = cls_dev_to_mmc_host(dev);
	spin_lock(&mmc_host_lock);
	idr_remove(&mmc_host_idr, host->index);
	spin_unlock(&mmc_host_lock);
	kfree(host);
}

static struct class mmc_host_class = {
	.name		= "mmc_host",
	.dev_release	= mmc_host_classdev_release,
};

int mmc_register_host_class(void)
{
	return class_register(&mmc_host_class);
}

void mmc_unregister_host_class(void)
{
	class_unregister(&mmc_host_class);
}

void mmc_retune_enable(struct mmc_host *host)
{
	host->can_retune = 1;
	if (host->retune_period)
		mod_timer(&host->retune_timer,
			  jiffies + host->retune_period * HZ);
}

void mmc_retune_disable(struct mmc_host *host)
{
	host->can_retune = 0;
	del_timer_sync(&host->retune_timer);
	host->retune_now = 0;
	host->need_retune = 0;
}

void mmc_retune_timer_stop(struct mmc_host *host)
{
	del_timer_sync(&host->retune_timer);
}
EXPORT_SYMBOL(mmc_retune_timer_stop);

void mmc_retune_hold(struct mmc_host *host)
{
	if (!host->hold_retune)
		host->retune_now = 1;
	host->hold_retune += 1;
}

void mmc_retune_release(struct mmc_host *host)
{
	if (host->hold_retune)
		host->hold_retune -= 1;
	else
		WARN_ON(1);
}

int mmc_retune(struct mmc_host *host)
{
	bool return_to_hs400 = false;
	int err;

	if (host->retune_now)
		host->retune_now = 0;
	else
		return 0;

	if (!host->need_retune || host->doing_retune || !host->card)
		return 0;

	host->need_retune = 0;

	host->doing_retune = 1;

	if (host->ios.timing == MMC_TIMING_MMC_HS400) {
		err = mmc_hs400_to_hs200(host->card);
		if (err)
			goto out;

		return_to_hs400 = true;

		if (host->ops->prepare_hs400_tuning)
			host->ops->prepare_hs400_tuning(host, &host->ios);
	}

	err = mmc_execute_tuning(host->card);
	if (err)
		goto out;

	if (return_to_hs400)
		err = mmc_hs200_to_hs400(host->card);
out:
	host->doing_retune = 0;

	return err;
}

static void mmc_retune_timer(unsigned long data)
{
	struct mmc_host *host = (struct mmc_host *)data;

	mmc_retune_needed(host);
}

/**
 *	mmc_of_parse() - parse host's device-tree node
 *	@host: host whose node should be parsed.
 *
 * To keep the rest of the MMC subsystem unaware of whether DT has been
 * used to to instantiate and configure this host instance or not, we
 * parse the properties and set respective generic mmc-host flags and
 * parameters.
 */
int mmc_of_parse(struct mmc_host *host)
{
	struct device_node *np;
	u32 bus_width;
	int ret;
	bool cd_cap_invert, cd_gpio_invert = false;
	bool ro_cap_invert, ro_gpio_invert = false;

	if (!host->parent || !host->parent->of_node)
		return 0;

	np = host->parent->of_node;

	/* "bus-width" is translated to MMC_CAP_*_BIT_DATA flags */
	if (of_property_read_u32(np, "bus-width", &bus_width) < 0) {
		dev_dbg(host->parent,
			"\"bus-width\" property is missing, assuming 1 bit.\n");
		bus_width = 1;
	}

	switch (bus_width) {
	case 8:
		host->caps |= MMC_CAP_8_BIT_DATA;
		/* Hosts capable of 8-bit transfers can also do 4 bits */
	case 4:
		host->caps |= MMC_CAP_4_BIT_DATA;
		break;
	case 1:
		break;
	default:
		dev_err(host->parent,
			"Invalid \"bus-width\" value %u!\n", bus_width);
		return -EINVAL;
	}

	/* f_max is obtained from the optional "max-frequency" property */
	of_property_read_u32(np, "max-frequency", &host->f_max);

	/*
	 * Configure CD and WP pins. They are both by default active low to
	 * match the SDHCI spec. If GPIOs are provided for CD and / or WP, the
	 * mmc-gpio helpers are used to attach, configure and use them. If
	 * polarity inversion is specified in DT, one of MMC_CAP2_CD_ACTIVE_HIGH
	 * and MMC_CAP2_RO_ACTIVE_HIGH capability-2 flags is set. If the
	 * "broken-cd" property is provided, the MMC_CAP_NEEDS_POLL capability
	 * is set. If the "non-removable" property is found, the
	 * MMC_CAP_NONREMOVABLE capability is set and no card-detection
	 * configuration is performed.
	 */

	/* Parse Card Detection */
	if (of_property_read_bool(np, "non-removable")) {
		host->caps |= MMC_CAP_NONREMOVABLE;
	} else {
		cd_cap_invert = of_property_read_bool(np, "cd-inverted");

		if (of_property_read_bool(np, "broken-cd"))
			host->caps |= MMC_CAP_NEEDS_POLL;

		ret = mmc_gpiod_request_cd(host, "cd", 0, true,
					   0, &cd_gpio_invert);
		if (!ret)
			dev_info(host->parent, "Got CD GPIO\n");
		else if (ret != -ENOENT && ret != -ENOSYS)
			return ret;

		/*
		 * There are two ways to flag that the CD line is inverted:
		 * through the cd-inverted flag and by the GPIO line itself
		 * being inverted from the GPIO subsystem. This is a leftover
		 * from the times when the GPIO subsystem did not make it
		 * possible to flag a line as inverted.
		 *
		 * If the capability on the host AND the GPIO line are
		 * both inverted, the end result is that the CD line is
		 * not inverted.
		 */
		if (cd_cap_invert ^ cd_gpio_invert)
			host->caps2 |= MMC_CAP2_CD_ACTIVE_HIGH;
	}

	/* Parse Write Protection */
	ro_cap_invert = of_property_read_bool(np, "wp-inverted");

	ret = mmc_gpiod_request_ro(host, "wp", 0, false, 0, &ro_gpio_invert);
	if (!ret)
		dev_info(host->parent, "Got WP GPIO\n");
	else if (ret != -ENOENT && ret != -ENOSYS)
		return ret;

	if (of_property_read_bool(np, "disable-wp"))
		host->caps2 |= MMC_CAP2_NO_WRITE_PROTECT;

	/* See the comment on CD inversion above */
	if (ro_cap_invert ^ ro_gpio_invert)
		host->caps2 |= MMC_CAP2_RO_ACTIVE_HIGH;

	if (of_property_read_bool(np, "cap-sd-highspeed"))
		host->caps |= MMC_CAP_SD_HIGHSPEED;
	if (of_property_read_bool(np, "cap-mmc-highspeed"))
		host->caps |= MMC_CAP_MMC_HIGHSPEED;
	if (of_property_read_bool(np, "sd-uhs-sdr12"))
		host->caps |= MMC_CAP_UHS_SDR12;
	if (of_property_read_bool(np, "sd-uhs-sdr25"))
		host->caps |= MMC_CAP_UHS_SDR25;
	if (of_property_read_bool(np, "sd-uhs-sdr50"))
		host->caps |= MMC_CAP_UHS_SDR50;
	if (of_property_read_bool(np, "sd-uhs-sdr104"))
		host->caps |= MMC_CAP_UHS_SDR104;
	if (of_property_read_bool(np, "sd-uhs-ddr50"))
		host->caps |= MMC_CAP_UHS_DDR50;
	if (of_property_read_bool(np, "cap-power-off-card"))
		host->caps |= MMC_CAP_POWER_OFF_CARD;
	if (of_property_read_bool(np, "cap-sdio-irq"))
		host->caps |= MMC_CAP_SDIO_IRQ;
	if (of_property_read_bool(np, "full-pwr-cycle"))
		host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE;
	if (of_property_read_bool(np, "keep-power-in-suspend"))
		host->pm_caps |= MMC_PM_KEEP_POWER;
	if (of_property_read_bool(np, "enable-sdio-wakeup"))
		host->pm_caps |= MMC_PM_WAKE_SDIO_IRQ;
	if (of_property_read_bool(np, "mmc-ddr-1_8v"))
		host->caps |= MMC_CAP_1_8V_DDR;
	if (of_property_read_bool(np, "mmc-ddr-1_2v"))
		host->caps |= MMC_CAP_1_2V_DDR;
	if (of_property_read_bool(np, "mmc-hs200-1_8v"))
		host->caps2 |= MMC_CAP2_HS200_1_8V_SDR;
	if (of_property_read_bool(np, "mmc-hs200-1_2v"))
		host->caps2 |= MMC_CAP2_HS200_1_2V_SDR;
	if (of_property_read_bool(np, "mmc-hs400-1_8v"))
		host->caps2 |= MMC_CAP2_HS400_1_8V | MMC_CAP2_HS200_1_8V_SDR;
	if (of_property_read_bool(np, "mmc-hs400-1_2v"))
		host->caps2 |= MMC_CAP2_HS400_1_2V | MMC_CAP2_HS200_1_2V_SDR;

	host->dsr_req = !of_property_read_u32(np, "dsr", &host->dsr);
	if (host->dsr_req && (host->dsr & ~0xffff)) {
		dev_err(host->parent,
			"device tree specified broken value for DSR: 0x%x, ignoring\n",
			host->dsr);
		host->dsr_req = 0;
	}

	return mmc_pwrseq_alloc(host);
}

EXPORT_SYMBOL(mmc_of_parse);

/**
 *	mmc_alloc_host - initialise the per-host structure.
 *	@extra: sizeof private data structure
 *	@dev: pointer to host device model structure
 *
 *	Initialise the per-host structure.
 */
struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
{
	int err;
	struct mmc_host *host;

	host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL);
	if (!host)
		return NULL;

	/* scanning will be enabled when we're ready */
	host->rescan_disable = 1;
	idr_preload(GFP_KERNEL);
	spin_lock(&mmc_host_lock);
	err = idr_alloc(&mmc_host_idr, host, 0, 0, GFP_NOWAIT);
	if (err >= 0)
		host->index = err;
	spin_unlock(&mmc_host_lock);
	idr_preload_end();
	if (err < 0) {
		kfree(host);
		return NULL;
	}

	dev_set_name(&host->class_dev, "mmc%d", host->index);

	host->parent = dev;
	host->class_dev.parent = dev;
	host->class_dev.class = &mmc_host_class;
	device_initialize(&host->class_dev);

	if (mmc_gpio_alloc(host)) {
		put_device(&host->class_dev);
		return NULL;
	}

	spin_lock_init(&host->lock);
	init_waitqueue_head(&host->wq);
	INIT_DELAYED_WORK(&host->detect, mmc_rescan);
#ifdef CONFIG_PM
	host->pm_notify.notifier_call = mmc_pm_notify;
#endif
	setup_timer(&host->retune_timer, mmc_retune_timer, (unsigned long)host);

	/*
	 * By default, hosts do not support SGIO or large requests.
	 * They have to set these according to their abilities.
	 */
	host->max_segs = 1;
	host->max_seg_size = PAGE_CACHE_SIZE;

	host->max_req_size = PAGE_CACHE_SIZE;
	host->max_blk_size = 512;
	host->max_blk_count = PAGE_CACHE_SIZE / 512;

	return host;
}

EXPORT_SYMBOL(mmc_alloc_host);

/**
 *	mmc_add_host - initialise host hardware
 *	@host: mmc host
 *
 *	Register the host with the driver model. The host must be
 *	prepared to start servicing requests before this function
 *	completes.
 */
int mmc_add_host(struct mmc_host *host)
{
	int err;

	WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) &&
		!host->ops->enable_sdio_irq);

	err = device_add(&host->class_dev);
	if (err)
		return err;

	led_trigger_register_simple(dev_name(&host->class_dev), &host->led);

#ifdef CONFIG_DEBUG_FS
	mmc_add_host_debugfs(host);
#endif

	mmc_start_host(host);
	register_pm_notifier(&host->pm_notify);

	return 0;
}

EXPORT_SYMBOL(mmc_add_host);

/**
 *	mmc_remove_host - remove host hardware
 *	@host: mmc host
 *
 *	Unregister and remove all cards associated with this host,
 *	and power down the MMC bus. No new requests will be issued
 *	after this function has returned.
 */
void mmc_remove_host(struct mmc_host *host)
{
	unregister_pm_notifier(&host->pm_notify);
	mmc_stop_host(host);

#ifdef CONFIG_DEBUG_FS
	mmc_remove_host_debugfs(host);
#endif

	device_del(&host->class_dev);

	led_trigger_unregister_simple(host->led);
}

EXPORT_SYMBOL(mmc_remove_host);

/**
 *	mmc_free_host - free the host structure
 *	@host: mmc host
 *
 *	Free the host once all references to it have been dropped.
 */
void mmc_free_host(struct mmc_host *host)
{
	mmc_pwrseq_free(host);
	put_device(&host->class_dev);
}

EXPORT_SYMBOL(mmc_free_host);
Commit	Line	Data
b93931a6 PO	1	/*
	2	* linux/drivers/mmc/core/host.c
	3	*
	4	* Copyright (C) 2003 Russell King, All Rights Reserved.
ff3112f5	5	* Copyright (C) 2007-2008 Pierre Ossman
04566831	6	* Copyright (C) 2010 Linus Walleij
b93931a6 PO	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*
	12	* MMC host class device management
	13	*/
	14
	15	#include <linux/device.h>
	16	#include <linux/err.h>
	17	#include <linux/idr.h>
6c56e7a0 GL	18	#include <linux/of.h>
6c56e7a0 GL	19	#include <linux/of_gpio.h>
b93931a6	20	#include <linux/pagemap.h>
3ef77af1	21	#include <linux/export.h>
af8350c7	22	#include <linux/leds.h>
5a0e3ad6	23	#include <linux/slab.h>
4c2ef25f	24	#include <linux/suspend.h>
b93931a6 PO	25
b93931a6 PO	26	#include <linux/mmc/host.h>
04566831	27	#include <linux/mmc/card.h>
6c56e7a0	28	#include <linux/mmc/slot-gpio.h>
b93931a6 PO	29
	30	#include "core.h"
	31	#include "host.h"
df8aca16	32	#include "slot-gpio.h"
3aa8793f	33	#include "pwrseq.h"
b93931a6 PO	34
	35	#define cls_dev_to_mmc_host(d) container_of(d, struct mmc_host, class_dev)
	36
e2d1926b UH	37	static DEFINE_IDR(mmc_host_idr);
	38	static DEFINE_SPINLOCK(mmc_host_lock);
	39
b93931a6 PO	40	static void mmc_host_classdev_release(struct device *dev)
	41	{
	42	struct mmc_host *host = cls_dev_to_mmc_host(dev);
e2d1926b UH	43	spin_lock(&mmc_host_lock);
	44	idr_remove(&mmc_host_idr, host->index);
	45	spin_unlock(&mmc_host_lock);
b93931a6 PO	46	kfree(host);
	47	}
	48
	49	static struct class mmc_host_class = {
	50	.name = "mmc_host",
	51	.dev_release = mmc_host_classdev_release,
	52	};
	53
	54	int mmc_register_host_class(void)
	55	{
	56	return class_register(&mmc_host_class);
	57	}
	58
	59	void mmc_unregister_host_class(void)
	60	{
	61	class_unregister(&mmc_host_class);
	62	}
	63
dfa13ebb AH	64	void mmc_retune_enable(struct mmc_host *host)
	65	{
	66	host->can_retune = 1;
	67	if (host->retune_period)
	68	mod_timer(&host->retune_timer,
	69	jiffies + host->retune_period * HZ);
	70	}
	71
	72	void mmc_retune_disable(struct mmc_host *host)
	73	{
	74	host->can_retune = 0;
	75	del_timer_sync(&host->retune_timer);
	76	host->retune_now = 0;
	77	host->need_retune = 0;
	78	}
	79
	80	void mmc_retune_timer_stop(struct mmc_host *host)
	81	{
	82	del_timer_sync(&host->retune_timer);
	83	}
	84	EXPORT_SYMBOL(mmc_retune_timer_stop);
	85
	86	void mmc_retune_hold(struct mmc_host *host)
	87	{
	88	if (!host->hold_retune)
	89	host->retune_now = 1;
	90	host->hold_retune += 1;
	91	}
	92
	93	void mmc_retune_release(struct mmc_host *host)
	94	{
	95	if (host->hold_retune)
	96	host->hold_retune -= 1;
	97	else
	98	WARN_ON(1);
	99	}
	100
	101	int mmc_retune(struct mmc_host *host)
	102	{
6376f69d	103	bool return_to_hs400 = false;
dfa13ebb AH	104	int err;
	105
	106	if (host->retune_now)
	107	host->retune_now = 0;
	108	else
	109	return 0;
	110
	111	if (!host->need_retune \|\| host->doing_retune \|\| !host->card)
	112	return 0;
	113
	114	host->need_retune = 0;
	115
	116	host->doing_retune = 1;
	117
6376f69d AH	118	if (host->ios.timing == MMC_TIMING_MMC_HS400) {
	119	err = mmc_hs400_to_hs200(host->card);
	120	if (err)
	121	goto out;
	122
	123	return_to_hs400 = true;
	124
	125	if (host->ops->prepare_hs400_tuning)
	126	host->ops->prepare_hs400_tuning(host, &host->ios);
	127	}
	128
dfa13ebb	129	err = mmc_execute_tuning(host->card);
6376f69d AH	130	if (err)
6376f69d AH	131	goto out;
dfa13ebb	132
6376f69d AH	133	if (return_to_hs400)
	134	err = mmc_hs200_to_hs400(host->card);
	135	out:
dfa13ebb AH	136	host->doing_retune = 0;
	137
	138	return err;
	139	}
	140
	141	static void mmc_retune_timer(unsigned long data)
	142	{
	143	struct mmc_host host = (struct mmc_host )data;
	144
	145	mmc_retune_needed(host);
	146	}
	147
6c56e7a0 GL	148	/**
	149	* mmc_of_parse() - parse host's device-tree node
	150	* @host: host whose node should be parsed.
	151	*
	152	* To keep the rest of the MMC subsystem unaware of whether DT has been
	153	* used to to instantiate and configure this host instance or not, we
	154	* parse the properties and set respective generic mmc-host flags and
	155	* parameters.
	156	*/
ec0a7517	157	int mmc_of_parse(struct mmc_host *host)
6c56e7a0 GL	158	{
	159	struct device_node *np;
	160	u32 bus_width;
90614cd9	161	int ret;
a31b0c6c KM	162	bool cd_cap_invert, cd_gpio_invert = false;
a31b0c6c KM	163	bool ro_cap_invert, ro_gpio_invert = false;
6c56e7a0 GL	164
6c56e7a0 GL	165	if (!host->parent \|\| !host->parent->of_node)
ec0a7517	166	return 0;
6c56e7a0 GL	167
	168	np = host->parent->of_node;
	169
	170	/* "bus-width" is translated to MMC_CAP__BIT_DATA flags /
	171	if (of_property_read_u32(np, "bus-width", &bus_width) < 0) {
	172	dev_dbg(host->parent,
	173	"\"bus-width\" property is missing, assuming 1 bit.\n");
	174	bus_width = 1;
	175	}
	176
	177	switch (bus_width) {
	178	case 8:
	179	host->caps \|= MMC_CAP_8_BIT_DATA;
	180	/* Hosts capable of 8-bit transfers can also do 4 bits */
	181	case 4:
	182	host->caps \|= MMC_CAP_4_BIT_DATA;
	183	break;
	184	case 1:
	185	break;
	186	default:
	187	dev_err(host->parent,
1c279f4f	188	"Invalid \"bus-width\" value %u!\n", bus_width);
ec0a7517	189	return -EINVAL;
6c56e7a0 GL	190	}
	191
	192	/* f_max is obtained from the optional "max-frequency" property */
	193	of_property_read_u32(np, "max-frequency", &host->f_max);
	194
	195	/*
	196	* Configure CD and WP pins. They are both by default active low to
	197	* match the SDHCI spec. If GPIOs are provided for CD and / or WP, the
	198	* mmc-gpio helpers are used to attach, configure and use them. If
	199	* polarity inversion is specified in DT, one of MMC_CAP2_CD_ACTIVE_HIGH
	200	* and MMC_CAP2_RO_ACTIVE_HIGH capability-2 flags is set. If the
	201	* "broken-cd" property is provided, the MMC_CAP_NEEDS_POLL capability
	202	* is set. If the "non-removable" property is found, the
	203	* MMC_CAP_NONREMOVABLE capability is set and no card-detection
	204	* configuration is performed.
	205	*/
	206
	207	/* Parse Card Detection */
90614cd9	208	if (of_property_read_bool(np, "non-removable")) {
6c56e7a0 GL	209	host->caps \|= MMC_CAP_NONREMOVABLE;
6c56e7a0 GL	210	} else {
a31b0c6c	211	cd_cap_invert = of_property_read_bool(np, "cd-inverted");
6c56e7a0	212
90614cd9	213	if (of_property_read_bool(np, "broken-cd"))
6c56e7a0 GL	214	host->caps \|= MMC_CAP_NEEDS_POLL;
6c56e7a0 GL	215
89168b48	216	ret = mmc_gpiod_request_cd(host, "cd", 0, true,
a31b0c6c	217	0, &cd_gpio_invert);
9116752f	218	if (!ret)
98e90de9	219	dev_info(host->parent, "Got CD GPIO\n");
43934ece	220	else if (ret != -ENOENT && ret != -ENOSYS)
9116752f	221	return ret;
89168b48 LW	222
	223	/*
	224	* There are two ways to flag that the CD line is inverted:
	225	* through the cd-inverted flag and by the GPIO line itself
	226	* being inverted from the GPIO subsystem. This is a leftover
	227	* from the times when the GPIO subsystem did not make it
	228	* possible to flag a line as inverted.
	229	*
	230	* If the capability on the host AND the GPIO line are
	231	* both inverted, the end result is that the CD line is
	232	* not inverted.
	233	*/
a31b0c6c	234	if (cd_cap_invert ^ cd_gpio_invert)
89168b48	235	host->caps2 \|= MMC_CAP2_CD_ACTIVE_HIGH;
6c56e7a0 GL	236	}
	237
	238	/* Parse Write Protection */
a31b0c6c	239	ro_cap_invert = of_property_read_bool(np, "wp-inverted");
6c56e7a0	240
a31b0c6c	241	ret = mmc_gpiod_request_ro(host, "wp", 0, false, 0, &ro_gpio_invert);
9116752f	242	if (!ret)
98e90de9	243	dev_info(host->parent, "Got WP GPIO\n");
43934ece	244	else if (ret != -ENOENT && ret != -ENOSYS)
9116752f	245	return ret;
2fdb6e2d	246
19f44246 LPC	247	if (of_property_read_bool(np, "disable-wp"))
	248	host->caps2 \|= MMC_CAP2_NO_WRITE_PROTECT;
	249
89168b48	250	/* See the comment on CD inversion above */
a31b0c6c	251	if (ro_cap_invert ^ ro_gpio_invert)
89168b48 LW	252	host->caps2 \|= MMC_CAP2_RO_ACTIVE_HIGH;
89168b48 LW	253
90614cd9	254	if (of_property_read_bool(np, "cap-sd-highspeed"))
2fdb6e2d	255	host->caps \|= MMC_CAP_SD_HIGHSPEED;
90614cd9	256	if (of_property_read_bool(np, "cap-mmc-highspeed"))
2fdb6e2d	257	host->caps \|= MMC_CAP_MMC_HIGHSPEED;
90614cd9	258	if (of_property_read_bool(np, "sd-uhs-sdr12"))
b66bd0e4	259	host->caps \|= MMC_CAP_UHS_SDR12;
90614cd9	260	if (of_property_read_bool(np, "sd-uhs-sdr25"))
b66bd0e4	261	host->caps \|= MMC_CAP_UHS_SDR25;
90614cd9	262	if (of_property_read_bool(np, "sd-uhs-sdr50"))
b66bd0e4	263	host->caps \|= MMC_CAP_UHS_SDR50;
90614cd9	264	if (of_property_read_bool(np, "sd-uhs-sdr104"))
b66bd0e4	265	host->caps \|= MMC_CAP_UHS_SDR104;
90614cd9	266	if (of_property_read_bool(np, "sd-uhs-ddr50"))
b66bd0e4	267	host->caps \|= MMC_CAP_UHS_DDR50;
90614cd9	268	if (of_property_read_bool(np, "cap-power-off-card"))
2fdb6e2d	269	host->caps \|= MMC_CAP_POWER_OFF_CARD;
90614cd9	270	if (of_property_read_bool(np, "cap-sdio-irq"))
2fdb6e2d	271	host->caps \|= MMC_CAP_SDIO_IRQ;
90614cd9	272	if (of_property_read_bool(np, "full-pwr-cycle"))
5a36d6bc	273	host->caps2 \|= MMC_CAP2_FULL_PWR_CYCLE;
90614cd9	274	if (of_property_read_bool(np, "keep-power-in-suspend"))
2fdb6e2d	275	host->pm_caps \|= MMC_PM_KEEP_POWER;
90614cd9	276	if (of_property_read_bool(np, "enable-sdio-wakeup"))
2fdb6e2d	277	host->pm_caps \|= MMC_PM_WAKE_SDIO_IRQ;
90614cd9	278	if (of_property_read_bool(np, "mmc-ddr-1_8v"))
c0baf848	279	host->caps \|= MMC_CAP_1_8V_DDR;
90614cd9	280	if (of_property_read_bool(np, "mmc-ddr-1_2v"))
c0baf848	281	host->caps \|= MMC_CAP_1_2V_DDR;
90614cd9	282	if (of_property_read_bool(np, "mmc-hs200-1_8v"))
321bd41d	283	host->caps2 \|= MMC_CAP2_HS200_1_8V_SDR;
90614cd9	284	if (of_property_read_bool(np, "mmc-hs200-1_2v"))
321bd41d	285	host->caps2 \|= MMC_CAP2_HS200_1_2V_SDR;
90614cd9	286	if (of_property_read_bool(np, "mmc-hs400-1_8v"))
c373eb48	287	host->caps2 \|= MMC_CAP2_HS400_1_8V \| MMC_CAP2_HS200_1_8V_SDR;
90614cd9	288	if (of_property_read_bool(np, "mmc-hs400-1_2v"))
c373eb48	289	host->caps2 \|= MMC_CAP2_HS400_1_2V \| MMC_CAP2_HS200_1_2V_SDR;
ec0a7517	290
3d705d14 SH	291	host->dsr_req = !of_property_read_u32(np, "dsr", &host->dsr);
	292	if (host->dsr_req && (host->dsr & ~0xffff)) {
	293	dev_err(host->parent,
	294	"device tree specified broken value for DSR: 0x%x, ignoring\n",
	295	host->dsr);
	296	host->dsr_req = 0;
	297	}
	298
3aa8793f	299	return mmc_pwrseq_alloc(host);
6c56e7a0 GL	300	}
	301
	302	EXPORT_SYMBOL(mmc_of_parse);
	303
b93931a6 PO	304	/**
	305	* mmc_alloc_host - initialise the per-host structure.
	306	* @extra: sizeof private data structure
	307	* @dev: pointer to host device model structure
	308	*
	309	* Initialise the per-host structure.
	310	*/
	311	struct mmc_host mmc_alloc_host(int extra, struct device dev)
	312	{
ff3112f5	313	int err;
b93931a6 PO	314	struct mmc_host *host;
b93931a6 PO	315
be760a9d	316	host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL);
b93931a6 PO	317	if (!host)
	318	return NULL;
	319
d9adcc12 GL	320	/* scanning will be enabled when we're ready */
d9adcc12 GL	321	host->rescan_disable = 1;
803d9e04	322	idr_preload(GFP_KERNEL);
ff3112f5	323	spin_lock(&mmc_host_lock);
803d9e04 TH	324	err = idr_alloc(&mmc_host_idr, host, 0, 0, GFP_NOWAIT);
	325	if (err >= 0)
	326	host->index = err;
ff3112f5	327	spin_unlock(&mmc_host_lock);
803d9e04	328	idr_preload_end();
df8aca16 UH	329	if (err < 0) {
	330	kfree(host);
	331	return NULL;
	332	}
ff3112f5	333
d1b26863	334	dev_set_name(&host->class_dev, "mmc%d", host->index);
ff3112f5	335
b93931a6 PO	336	host->parent = dev;
	337	host->class_dev.parent = dev;
	338	host->class_dev.class = &mmc_host_class;
	339	device_initialize(&host->class_dev);
	340
df8aca16 UH	341	if (mmc_gpio_alloc(host)) {
	342	put_device(&host->class_dev);
	343	return NULL;
	344	}
04566831	345
b93931a6 PO	346	spin_lock_init(&host->lock);
	347	init_waitqueue_head(&host->wq);
	348	INIT_DELAYED_WORK(&host->detect, mmc_rescan);
81ca03a0	349	#ifdef CONFIG_PM
4c2ef25f	350	host->pm_notify.notifier_call = mmc_pm_notify;
81ca03a0	351	#endif
dfa13ebb	352	setup_timer(&host->retune_timer, mmc_retune_timer, (unsigned long)host);
b93931a6 PO	353
	354	/*
	355	* By default, hosts do not support SGIO or large requests.
	356	* They have to set these according to their abilities.
	357	*/
a36274e0	358	host->max_segs = 1;
b93931a6 PO	359	host->max_seg_size = PAGE_CACHE_SIZE;
	360
	361	host->max_req_size = PAGE_CACHE_SIZE;
	362	host->max_blk_size = 512;
	363	host->max_blk_count = PAGE_CACHE_SIZE / 512;
	364
	365	return host;
	366	}
	367
	368	EXPORT_SYMBOL(mmc_alloc_host);
	369
	370	/**
	371	* mmc_add_host - initialise host hardware
	372	* @host: mmc host
67a61c48 PO	373	*
	374	* Register the host with the driver model. The host must be
	375	* prepared to start servicing requests before this function
	376	* completes.
b93931a6 PO	377	*/
	378	int mmc_add_host(struct mmc_host *host)
	379	{
	380	int err;
	381
17b759af NP	382	WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) &&
	383	!host->ops->enable_sdio_irq);
	384
b93931a6 PO	385	err = device_add(&host->class_dev);
	386	if (err)
	387	return err;
	388
f317dfeb WS	389	led_trigger_register_simple(dev_name(&host->class_dev), &host->led);
f317dfeb WS	390
6edd8ee6 HS	391	#ifdef CONFIG_DEBUG_FS
	392	mmc_add_host_debugfs(host);
	393	#endif
	394
b93931a6	395	mmc_start_host(host);
4c2ef25f	396	register_pm_notifier(&host->pm_notify);
b93931a6 PO	397
	398	return 0;
	399	}
	400
	401	EXPORT_SYMBOL(mmc_add_host);
	402
	403	/**
	404	* mmc_remove_host - remove host hardware
	405	* @host: mmc host
	406	*
	407	* Unregister and remove all cards associated with this host,
67a61c48 PO	408	* and power down the MMC bus. No new requests will be issued
67a61c48 PO	409	* after this function has returned.
b93931a6 PO	410	*/
	411	void mmc_remove_host(struct mmc_host *host)
	412	{
4c2ef25f	413	unregister_pm_notifier(&host->pm_notify);
b93931a6 PO	414	mmc_stop_host(host);
b93931a6 PO	415
6edd8ee6 HS	416	#ifdef CONFIG_DEBUG_FS
	417	mmc_remove_host_debugfs(host);
	418	#endif
	419
b93931a6 PO	420	device_del(&host->class_dev);
b93931a6 PO	421
77f1fd6e	422	led_trigger_unregister_simple(host->led);
b93931a6 PO	423	}
	424
	425	EXPORT_SYMBOL(mmc_remove_host);
	426
	427	/**
	428	* mmc_free_host - free the host structure
	429	* @host: mmc host
	430	*
	431	* Free the host once all references to it have been dropped.
	432	*/
	433	void mmc_free_host(struct mmc_host *host)
	434	{
3aa8793f	435	mmc_pwrseq_free(host);
b93931a6 PO	436	put_device(&host->class_dev);
	437	}
	438
	439	EXPORT_SYMBOL(mmc_free_host);