Revert "mmc: core: Remove MMC_CLKGATE" (dff31263) · Commits · e / devices / android_kernel_fairphone_FP3

Documentation/mmc/mmc-dev-attrs.txt

+10 −0

Original line number	Original line	Diff line number	Diff line
	@@ -74,3 +74,13 @@ Note on raw_rpmb_size_mult:
	"raw_rpmb_size_mult" is a mutliple of 128kB block.		"raw_rpmb_size_mult" is a mutliple of 128kB block.
	RPMB size in byte is calculated by using the following equation:		RPMB size in byte is calculated by using the following equation:
	RPMB partition size = 128kB x raw_rpmb_size_mult		RPMB partition size = 128kB x raw_rpmb_size_mult

			SD/MMC/SDIO Clock Gating Attribute
			==================================

			Read and write access is provided to following attribute.
			This attribute appears only if CONFIG_MMC_CLKGATE is enabled.

			clkgate_delay Tune the clock gating delay with desired value in milliseconds.

			echo <desired delay> > /sys/class/mmc_host/mmcX/clkgate_delay

drivers/mmc/core/Kconfig

+10 −0

Original line number	Original line	Diff line number	Diff line
	@@ -37,3 +37,13 @@ config MMC_PARANOID_SD_INIT
	about re-trying SD init requests. This can be a useful		about re-trying SD init requests. This can be a useful
	work-around for buggy controllers and hardware. Enable		work-around for buggy controllers and hardware. Enable
	if you are experiencing issues with SD detection.		if you are experiencing issues with SD detection.

			config MMC_CLKGATE
			bool "MMC host clock gating"
			help
			This will attempt to aggressively gate the clock to the MMC card.
			This is done to save power due to gating off the logic and bus
			noise when the MMC card is not in use. Your host driver has to
			support handling this in order for it to be of any use.

			If unsure, say N.

drivers/mmc/core/core.c

+124 −15

Original line number	Original line	Diff line number	Diff line
	@@ -226,6 +226,8 @@ void mmc_request_done(struct mmc_host host, struct mmc_request mrq)

	if (mrq->done)		if (mrq->done)
	mrq->done(mrq);		mrq->done(mrq);

			mmc_host_clk_release(host);
	}		}
	}		}

	@@ -340,6 +342,7 @@ static int mmc_start_request(struct mmc_host host, struct mmc_request mrq)
	mrq->stop->mrq = mrq;		mrq->stop->mrq = mrq;
	}		}
	}		}
			mmc_host_clk_hold(host);
	led_trigger_event(host->led, LED_FULL);		led_trigger_event(host->led, LED_FULL);
	__mmc_start_request(host, mrq);		__mmc_start_request(host, mrq);

	@@ -634,8 +637,11 @@ EXPORT_SYMBOL(mmc_is_req_done);
	static void mmc_pre_req(struct mmc_host host, struct mmc_request mrq,		static void mmc_pre_req(struct mmc_host host, struct mmc_request mrq,
	bool is_first_req)		bool is_first_req)
	{		{
	if (host->ops->pre_req)		if (host->ops->pre_req) {
			mmc_host_clk_hold(host);
	host->ops->pre_req(host, mrq, is_first_req);		host->ops->pre_req(host, mrq, is_first_req);
			mmc_host_clk_release(host);
			}
	}		}

	/**		/**
	@@ -650,8 +656,11 @@ static void mmc_pre_req(struct mmc_host host, struct mmc_request mrq,
	static void mmc_post_req(struct mmc_host host, struct mmc_request mrq,		static void mmc_post_req(struct mmc_host host, struct mmc_request mrq,
	int err)		int err)
	{		{
	if (host->ops->post_req)		if (host->ops->post_req) {
			mmc_host_clk_hold(host);
	host->ops->post_req(host, mrq, err);		host->ops->post_req(host, mrq, err);
			mmc_host_clk_release(host);
			}
	}		}

	/**		/**
	@@ -949,9 +958,9 @@ void mmc_set_data_timeout(struct mmc_data data, const struct mmc_card card)
	unsigned int timeout_us, limit_us;		unsigned int timeout_us, limit_us;

	timeout_us = data->timeout_ns / 1000;		timeout_us = data->timeout_ns / 1000;
	if (card->host->ios.clock)		if (mmc_host_clk_rate(card->host))
	timeout_us += data->timeout_clks * 1000 /		timeout_us += data->timeout_clks * 1000 /
	(card->host->ios.clock / 1000);		(mmc_host_clk_rate(card->host) / 1000);

	if (data->flags & MMC_DATA_WRITE)		if (data->flags & MMC_DATA_WRITE)
	/*		/*
	@@ -1149,6 +1158,8 @@ static inline void mmc_set_ios(struct mmc_host *host)
	ios->power_mode, ios->chip_select, ios->vdd,		ios->power_mode, ios->chip_select, ios->vdd,
	1 << ios->bus_width, ios->timing);		1 << ios->bus_width, ios->timing);

			if (ios->clock > 0)
			mmc_set_ungated(host);
	host->ops->set_ios(host, ios);		host->ops->set_ios(host, ios);
	}		}

	@@ -1157,15 +1168,17 @@ static inline void mmc_set_ios(struct mmc_host *host)
	*/		*/
	void mmc_set_chip_select(struct mmc_host *host, int mode)		void mmc_set_chip_select(struct mmc_host *host, int mode)
	{		{
			mmc_host_clk_hold(host);
	host->ios.chip_select = mode;		host->ios.chip_select = mode;
	mmc_set_ios(host);		mmc_set_ios(host);
			mmc_host_clk_release(host);
	}		}

	/*		/*
	* Sets the host clock to the highest possible frequency that		* Sets the host clock to the highest possible frequency that
	* is below "hz".		* is below "hz".
	*/		*/
	void mmc_set_clock(struct mmc_host *host, unsigned int hz)		static void __mmc_set_clock(struct mmc_host *host, unsigned int hz)
	{		{
	WARN_ON(hz && hz < host->f_min);		WARN_ON(hz && hz < host->f_min);

	@@ -1176,6 +1189,68 @@ void mmc_set_clock(struct mmc_host *host, unsigned int hz)
	mmc_set_ios(host);		mmc_set_ios(host);
	}		}

			void mmc_set_clock(struct mmc_host *host, unsigned int hz)
			{
			mmc_host_clk_hold(host);
			__mmc_set_clock(host, hz);
			mmc_host_clk_release(host);
			}

			#ifdef CONFIG_MMC_CLKGATE
			/*
			* This gates the clock by setting it to 0 Hz.
			*/
			void mmc_gate_clock(struct mmc_host *host)
			{
			unsigned long flags;

			spin_lock_irqsave(&host->clk_lock, flags);
			host->clk_old = host->ios.clock;
			host->ios.clock = 0;
			host->clk_gated = true;
			spin_unlock_irqrestore(&host->clk_lock, flags);
			mmc_set_ios(host);
			}

			/*
			* This restores the clock from gating by using the cached
			* clock value.
			*/
			void mmc_ungate_clock(struct mmc_host *host)
			{
			/*
			* We should previously have gated the clock, so the clock shall
			* be 0 here! The clock may however be 0 during initialization,
			* when some request operations are performed before setting
			* the frequency. When ungate is requested in that situation
			* we just ignore the call.
			*/
			if (host->clk_old) {
			BUG_ON(host->ios.clock);
			/* This call will also set host->clk_gated to false */
			__mmc_set_clock(host, host->clk_old);
			}
			}

			void mmc_set_ungated(struct mmc_host *host)
			{
			unsigned long flags;

			/*
			* We've been given a new frequency while the clock is gated,
			* so make sure we regard this as ungating it.
			*/
			spin_lock_irqsave(&host->clk_lock, flags);
			host->clk_gated = false;
			spin_unlock_irqrestore(&host->clk_lock, flags);
			}

			#else
			void mmc_set_ungated(struct mmc_host *host)
			{
			}
			#endif

	int mmc_execute_tuning(struct mmc_card *card)		int mmc_execute_tuning(struct mmc_card *card)
	{		{
	struct mmc_host *host = card->host;		struct mmc_host *host = card->host;
	@@ -1190,7 +1265,9 @@ int mmc_execute_tuning(struct mmc_card *card)
	else		else
	opcode = MMC_SEND_TUNING_BLOCK;		opcode = MMC_SEND_TUNING_BLOCK;

			mmc_host_clk_hold(host);
	err = host->ops->execute_tuning(host, opcode);		err = host->ops->execute_tuning(host, opcode);
			mmc_host_clk_release(host);

	if (err)		if (err)
	pr_err("%s: tuning execution failed: %d\n",		pr_err("%s: tuning execution failed: %d\n",
	@@ -1206,8 +1283,10 @@ int mmc_execute_tuning(struct mmc_card *card)
	*/		*/
	void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)		void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
	{		{
			mmc_host_clk_hold(host);
	host->ios.bus_mode = mode;		host->ios.bus_mode = mode;
	mmc_set_ios(host);		mmc_set_ios(host);
			mmc_host_clk_release(host);
	}		}

	/*		/*
	@@ -1215,8 +1294,10 @@ void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
	*/		*/
	void mmc_set_bus_width(struct mmc_host *host, unsigned int width)		void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
	{		{
			mmc_host_clk_hold(host);
	host->ios.bus_width = width;		host->ios.bus_width = width;
	mmc_set_ios(host);		mmc_set_ios(host);
			mmc_host_clk_release(host);
	}		}

	/*		/*
	@@ -1671,8 +1752,11 @@ int __mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage)
	int old_signal_voltage = host->ios.signal_voltage;		int old_signal_voltage = host->ios.signal_voltage;

	host->ios.signal_voltage = signal_voltage;		host->ios.signal_voltage = signal_voltage;
	if (host->ops->start_signal_voltage_switch)		if (host->ops->start_signal_voltage_switch) {
			mmc_host_clk_hold(host);
	err = host->ops->start_signal_voltage_switch(host, &host->ios);		err = host->ops->start_signal_voltage_switch(host, &host->ios);
			mmc_host_clk_release(host);
			}

	if (err)		if (err)
	host->ios.signal_voltage = old_signal_voltage;		host->ios.signal_voltage = old_signal_voltage;
	@@ -1706,17 +1790,20 @@ int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage, u32 ocr)
	pr_warn("%s: cannot verify signal voltage switch\n",		pr_warn("%s: cannot verify signal voltage switch\n",
	mmc_hostname(host));		mmc_hostname(host));

			mmc_host_clk_hold(host);

	cmd.opcode = SD_SWITCH_VOLTAGE;		cmd.opcode = SD_SWITCH_VOLTAGE;
	cmd.arg = 0;		cmd.arg = 0;
	cmd.flags = MMC_RSP_R1 \| MMC_CMD_AC;		cmd.flags = MMC_RSP_R1 \| MMC_CMD_AC;

	err = mmc_wait_for_cmd(host, &cmd, 0);		err = mmc_wait_for_cmd(host, &cmd, 0);
	if (err)		if (err)
	return err;		goto err_command;

	if (!mmc_host_is_spi(host) && (cmd.resp[0] & R1_ERROR))
	return -EIO;

			if (!mmc_host_is_spi(host) && (cmd.resp[0] & R1_ERROR)) {
			err = -EIO;
			goto err_command;
			}
	/*		/*
	* The card should drive cmd and dat[0:3] low immediately		* The card should drive cmd and dat[0:3] low immediately
	* after the response of cmd11, but wait 1 ms to be sure		* after the response of cmd11, but wait 1 ms to be sure
	@@ -1765,6 +1852,9 @@ int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage, u32 ocr)
	mmc_power_cycle(host, ocr);		mmc_power_cycle(host, ocr);
	}		}

			err_command:
			mmc_host_clk_release(host);

	return err;		return err;
	}		}

	@@ -1773,8 +1863,10 @@ int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage, u32 ocr)
	*/		*/
	void mmc_set_timing(struct mmc_host *host, unsigned int timing)		void mmc_set_timing(struct mmc_host *host, unsigned int timing)
	{		{
			mmc_host_clk_hold(host);
	host->ios.timing = timing;		host->ios.timing = timing;
	mmc_set_ios(host);		mmc_set_ios(host);
			mmc_host_clk_release(host);
	}		}

	/*		/*
	@@ -1782,8 +1874,10 @@ void mmc_set_timing(struct mmc_host *host, unsigned int timing)
	*/		*/
	void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type)		void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type)
	{		{
			mmc_host_clk_hold(host);
	host->ios.drv_type = drv_type;		host->ios.drv_type = drv_type;
	mmc_set_ios(host);		mmc_set_ios(host);
			mmc_host_clk_release(host);
	}		}

	int mmc_select_drive_strength(struct mmc_card *card, unsigned int max_dtr,		int mmc_select_drive_strength(struct mmc_card *card, unsigned int max_dtr,
	@@ -1791,6 +1885,7 @@ int mmc_select_drive_strength(struct mmc_card *card, unsigned int max_dtr,
	{		{
	struct mmc_host *host = card->host;		struct mmc_host *host = card->host;
	int host_drv_type = SD_DRIVER_TYPE_B;		int host_drv_type = SD_DRIVER_TYPE_B;
			int drive_strength;

	*drv_type = 0;		*drv_type = 0;

	@@ -1813,10 +1908,14 @@ int mmc_select_drive_strength(struct mmc_card *card, unsigned int max_dtr,
	* information and let the hardware specific code		* information and let the hardware specific code
	* return what is possible given the options		* return what is possible given the options
	*/		*/
	return host->ops->select_drive_strength(card, max_dtr,		mmc_host_clk_hold(host);
			drive_strength = host->ops->select_drive_strength(card, max_dtr,
	host_drv_type,		host_drv_type,
	card_drv_type,		card_drv_type,
	drv_type);		drv_type);
			mmc_host_clk_release(host);

			return drive_strength;
	}		}

	/*		/*
	@@ -1835,6 +1934,8 @@ void mmc_power_up(struct mmc_host *host, u32 ocr)
	if (host->ios.power_mode == MMC_POWER_ON)		if (host->ios.power_mode == MMC_POWER_ON)
	return;		return;

			mmc_host_clk_hold(host);

	mmc_pwrseq_pre_power_on(host);		mmc_pwrseq_pre_power_on(host);

	host->ios.vdd = fls(ocr) - 1;		host->ios.vdd = fls(ocr) - 1;
	@@ -1868,6 +1969,8 @@ void mmc_power_up(struct mmc_host *host, u32 ocr)
	* time required to reach a stable voltage.		* time required to reach a stable voltage.
	*/		*/
	mmc_delay(10);		mmc_delay(10);

			mmc_host_clk_release(host);
	}		}

	void mmc_power_off(struct mmc_host *host)		void mmc_power_off(struct mmc_host *host)
	@@ -1875,6 +1978,8 @@ void mmc_power_off(struct mmc_host *host)
	if (host->ios.power_mode == MMC_POWER_OFF)		if (host->ios.power_mode == MMC_POWER_OFF)
	return;		return;

			mmc_host_clk_hold(host);

	mmc_pwrseq_power_off(host);		mmc_pwrseq_power_off(host);

	host->ios.clock = 0;		host->ios.clock = 0;
	@@ -1890,6 +1995,8 @@ void mmc_power_off(struct mmc_host *host)
	* can be successfully turned on again.		* can be successfully turned on again.
	*/		*/
	mmc_delay(1);		mmc_delay(1);

			mmc_host_clk_release(host);
	}		}

	void mmc_power_cycle(struct mmc_host *host, u32 ocr)		void mmc_power_cycle(struct mmc_host *host, u32 ocr)
	@@ -2103,7 +2210,7 @@ static unsigned int mmc_mmc_erase_timeout(struct mmc_card *card,
	*/		*/
	timeout_clks <<= 1;		timeout_clks <<= 1;
	timeout_us += (timeout_clks * 1000) /		timeout_us += (timeout_clks * 1000) /
	(card->host->ios.clock / 1000);		(mmc_host_clk_rate(card->host) / 1000);

	erase_timeout = timeout_us / 1000;		erase_timeout = timeout_us / 1000;

	@@ -2626,7 +2733,9 @@ static void mmc_hw_reset_for_init(struct mmc_host *host)
	{		{
	if (!(host->caps & MMC_CAP_HW_RESET) \|\| !host->ops->hw_reset)		if (!(host->caps & MMC_CAP_HW_RESET) \|\| !host->ops->hw_reset)
	return;		return;
			mmc_host_clk_hold(host);
	host->ops->hw_reset(host);		host->ops->hw_reset(host);
			mmc_host_clk_release(host);
	}		}

	int mmc_hw_reset(struct mmc_host *host)		int mmc_hw_reset(struct mmc_host *host)

drivers/mmc/core/core.h

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -40,6 +40,9 @@ void mmc_init_erase(struct mmc_card *card);

	void mmc_set_chip_select(struct mmc_host *host, int mode);		void mmc_set_chip_select(struct mmc_host *host, int mode);
	void mmc_set_clock(struct mmc_host *host, unsigned int hz);		void mmc_set_clock(struct mmc_host *host, unsigned int hz);
			void mmc_gate_clock(struct mmc_host *host);
			void mmc_ungate_clock(struct mmc_host *host);
			void mmc_set_ungated(struct mmc_host *host);
	void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode);		void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode);
	void mmc_set_bus_width(struct mmc_host *host, unsigned int width);		void mmc_set_bus_width(struct mmc_host *host, unsigned int width);
	u32 mmc_select_voltage(struct mmc_host *host, u32 ocr);		u32 mmc_select_voltage(struct mmc_host *host, u32 ocr);

drivers/mmc/core/debugfs.c

+5 −0

Original line number	Original line	Diff line number	Diff line
	@@ -256,6 +256,11 @@ void mmc_add_host_debugfs(struct mmc_host *host)
	&mmc_clock_fops))		&mmc_clock_fops))
	goto err_node;		goto err_node;

			#ifdef CONFIG_MMC_CLKGATE
			if (!debugfs_create_u32("clk_delay", (S_IRUSR \| S_IWUSR),
			root, &host->clk_delay))
			goto err_node;
			#endif
	#ifdef CONFIG_FAIL_MMC_REQUEST		#ifdef CONFIG_FAIL_MMC_REQUEST
	if (fail_request)		if (fail_request)
	setup_fault_attr(&fail_default_attr, fail_request);		setup_fault_attr(&fail_default_attr, fail_request);