[mirror_ubuntu-bionic-kernel.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/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"
#include "sdio_ops.h"

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

static DEFINE_IDA(mmc_host_ida);

static void mmc_host_classdev_release(struct device *dev)
{
	struct mmc_host *host = cls_dev_to_mmc_host(dev);
	ida_simple_remove(&mmc_host_ida, host->index);
	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);
}

/*
 * Pause re-tuning for a small set of operations.  The pause begins after the
 * next command and after first doing re-tuning.
 */
void mmc_retune_pause(struct mmc_host *host)
{
	if (!host->retune_paused) {
		host->retune_paused = 1;
		mmc_retune_needed(host);
		mmc_retune_hold(host);
	}
}
EXPORT_SYMBOL(mmc_retune_pause);

void mmc_retune_unpause(struct mmc_host *host)
{
	if (host->retune_paused) {
		host->retune_paused = 0;
		mmc_retune_release(host);
	}
}
EXPORT_SYMBOL(mmc_retune_unpause);

void mmc_retune_disable(struct mmc_host *host)
{
	mmc_retune_unpause(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);
}
EXPORT_SYMBOL(mmc_retune_release);

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(struct timer_list *t)
{
	struct mmc_host *host = from_timer(host, t, retune_timer);

	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 *dev = host->parent;
	u32 bus_width, drv_type;
	int ret;
	bool cd_cap_invert, cd_gpio_invert = false;
	bool ro_cap_invert, ro_gpio_invert = false;

	if (!dev || !dev_fwnode(dev))
		return 0;

	/* "bus-width" is translated to MMC_CAP_*_BIT_DATA flags */
	if (device_property_read_u32(dev, "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 */
	device_property_read_u32(dev, "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 (device_property_read_bool(dev, "non-removable")) {
		host->caps |= MMC_CAP_NONREMOVABLE;
	} else {
		cd_cap_invert = device_property_read_bool(dev, "cd-inverted");

		if (device_property_read_bool(dev, "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 = device_property_read_bool(dev, "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 (device_property_read_bool(dev, "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 (device_property_read_bool(dev, "cap-sd-highspeed"))
		host->caps |= MMC_CAP_SD_HIGHSPEED;
	if (device_property_read_bool(dev, "cap-mmc-highspeed"))
		host->caps |= MMC_CAP_MMC_HIGHSPEED;
	if (device_property_read_bool(dev, "sd-uhs-sdr12"))
		host->caps |= MMC_CAP_UHS_SDR12;
	if (device_property_read_bool(dev, "sd-uhs-sdr25"))
		host->caps |= MMC_CAP_UHS_SDR25;
	if (device_property_read_bool(dev, "sd-uhs-sdr50"))
		host->caps |= MMC_CAP_UHS_SDR50;
	if (device_property_read_bool(dev, "sd-uhs-sdr104"))
		host->caps |= MMC_CAP_UHS_SDR104;
	if (device_property_read_bool(dev, "sd-uhs-ddr50"))
		host->caps |= MMC_CAP_UHS_DDR50;
	if (device_property_read_bool(dev, "cap-power-off-card"))
		host->caps |= MMC_CAP_POWER_OFF_CARD;
	if (device_property_read_bool(dev, "cap-mmc-hw-reset"))
		host->caps |= MMC_CAP_HW_RESET;
	if (device_property_read_bool(dev, "cap-sdio-irq"))
		host->caps |= MMC_CAP_SDIO_IRQ;
	if (device_property_read_bool(dev, "full-pwr-cycle"))
		host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE;
	if (device_property_read_bool(dev, "keep-power-in-suspend"))
		host->pm_caps |= MMC_PM_KEEP_POWER;
	if (device_property_read_bool(dev, "wakeup-source") ||
	    device_property_read_bool(dev, "enable-sdio-wakeup")) /* legacy */
		host->pm_caps |= MMC_PM_WAKE_SDIO_IRQ;
	if (device_property_read_bool(dev, "mmc-ddr-3_3v"))
		host->caps |= MMC_CAP_3_3V_DDR;
	if (device_property_read_bool(dev, "mmc-ddr-1_8v"))
		host->caps |= MMC_CAP_1_8V_DDR;
	if (device_property_read_bool(dev, "mmc-ddr-1_2v"))
		host->caps |= MMC_CAP_1_2V_DDR;
	if (device_property_read_bool(dev, "mmc-hs200-1_8v"))
		host->caps2 |= MMC_CAP2_HS200_1_8V_SDR;
	if (device_property_read_bool(dev, "mmc-hs200-1_2v"))
		host->caps2 |= MMC_CAP2_HS200_1_2V_SDR;
	if (device_property_read_bool(dev, "mmc-hs400-1_8v"))
		host->caps2 |= MMC_CAP2_HS400_1_8V | MMC_CAP2_HS200_1_8V_SDR;
	if (device_property_read_bool(dev, "mmc-hs400-1_2v"))
		host->caps2 |= MMC_CAP2_HS400_1_2V | MMC_CAP2_HS200_1_2V_SDR;
	if (device_property_read_bool(dev, "mmc-hs400-enhanced-strobe"))
		host->caps2 |= MMC_CAP2_HS400_ES;
	if (device_property_read_bool(dev, "no-sdio"))
		host->caps2 |= MMC_CAP2_NO_SDIO;
	if (device_property_read_bool(dev, "no-sd"))
		host->caps2 |= MMC_CAP2_NO_SD;
	if (device_property_read_bool(dev, "no-mmc"))
		host->caps2 |= MMC_CAP2_NO_MMC;

	/* Must be after "non-removable" check */
	if (device_property_read_u32(dev, "fixed-emmc-driver-type", &drv_type) == 0) {
		if (host->caps & MMC_CAP_NONREMOVABLE)
			host->fixed_drv_type = drv_type;
		else
			dev_err(host->parent,
				"can't use fixed driver type, media is removable\n");
	}

	host->dsr_req = !device_property_read_u32(dev, "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;

	err = ida_simple_get(&mmc_host_ida, 0, 0, GFP_KERNEL);
	if (err < 0) {
		kfree(host);
		return NULL;
	}

	host->index = err;

	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);
	device_enable_async_suspend(&host->class_dev);

	if (mmc_gpio_alloc(host)) {
		put_device(&host->class_dev);
		ida_simple_remove(&mmc_host_ida, host->index);
		kfree(host);
		return NULL;
	}

	spin_lock_init(&host->lock);
	init_waitqueue_head(&host->wq);
	INIT_DELAYED_WORK(&host->detect, mmc_rescan);
	INIT_DELAYED_WORK(&host->sdio_irq_work, sdio_irq_work);
	timer_setup(&host->retune_timer, mmc_retune_timer, 0);

	/*
	 * 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_SIZE;

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

	host->fixed_drv_type = -EINVAL;

	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);
	mmc_register_pm_notifier(host);

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