pwrseq_simple.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 *  Copyright (C) 2014 Linaro Ltd
  4 *
  5 * Author: Ulf Hansson <ulf.hansson@linaro.org>
  6 *
  7 *  Simple MMC power sequence management
  8 */
  9#include <linux/clk.h>
 10#include <linux/init.h>
 11#include <linux/kernel.h>
 12#include <linux/platform_device.h>
 13#include <linux/module.h>
 14#include <linux/slab.h>
 15#include <linux/device.h>
 16#include <linux/err.h>
 17#include <linux/gpio/consumer.h>
 18#include <linux/delay.h>
 19#include <linux/property.h>
 20#include <linux/of.h>
 21#include <linux/reset.h>
 22
 23#include <linux/mmc/host.h>
 24
 25#include "pwrseq.h"
 26
 27struct mmc_pwrseq_simple {
 28	struct mmc_pwrseq pwrseq;
 29	bool clk_enabled;
 30	u32 post_power_on_delay_ms;
 31	u32 power_off_delay_us;
 32	struct clk *ext_clk;
 33	struct gpio_descs *reset_gpios;
 34	struct reset_control *reset_ctrl;
 35};
 36
 37#define to_pwrseq_simple(p) container_of(p, struct mmc_pwrseq_simple, pwrseq)
 38
 39static void mmc_pwrseq_simple_set_gpios_value(struct mmc_pwrseq_simple *pwrseq,
 40					      int value)
 41{
 42	struct gpio_descs *reset_gpios = pwrseq->reset_gpios;
 43
 44	if (!IS_ERR(reset_gpios)) {
 45		unsigned long *values;
 46		int nvalues = reset_gpios->ndescs;
 47
 48		values = bitmap_alloc(nvalues, GFP_KERNEL);
 49		if (!values)
 50			return;
 51
 52		if (value)
 53			bitmap_fill(values, nvalues);
 54		else
 55			bitmap_zero(values, nvalues);
 56
 57		gpiod_multi_set_value_cansleep(reset_gpios, values);
 58
 59		bitmap_free(values);
 60	}
 61}
 62
 63static void mmc_pwrseq_simple_pre_power_on(struct mmc_host *host)
 64{
 65	struct mmc_pwrseq_simple *pwrseq = to_pwrseq_simple(host->pwrseq);
 66
 67	if (!IS_ERR(pwrseq->ext_clk) && !pwrseq->clk_enabled) {
 68		clk_prepare_enable(pwrseq->ext_clk);
 69		pwrseq->clk_enabled = true;
 70	}
 71
 72	if (pwrseq->reset_ctrl) {
 73		reset_control_deassert(pwrseq->reset_ctrl);
 74		reset_control_assert(pwrseq->reset_ctrl);
 75	} else
 76		mmc_pwrseq_simple_set_gpios_value(pwrseq, 1);
 77}
 78
 79static void mmc_pwrseq_simple_post_power_on(struct mmc_host *host)
 80{
 81	struct mmc_pwrseq_simple *pwrseq = to_pwrseq_simple(host->pwrseq);
 82
 83	if (pwrseq->reset_ctrl)
 84		reset_control_deassert(pwrseq->reset_ctrl);
 85	else
 86		mmc_pwrseq_simple_set_gpios_value(pwrseq, 0);
 87
 88	if (pwrseq->post_power_on_delay_ms)
 89		msleep(pwrseq->post_power_on_delay_ms);
 90}
 91
 92static void mmc_pwrseq_simple_power_off(struct mmc_host *host)
 93{
 94	struct mmc_pwrseq_simple *pwrseq = to_pwrseq_simple(host->pwrseq);
 95
 96	if (pwrseq->reset_ctrl)
 97		reset_control_assert(pwrseq->reset_ctrl);
 98	else
 99		mmc_pwrseq_simple_set_gpios_value(pwrseq, 1);
100
101	if (pwrseq->power_off_delay_us)
102		usleep_range(pwrseq->power_off_delay_us,
103			2 * pwrseq->power_off_delay_us);
104
105	if (!IS_ERR(pwrseq->ext_clk) && pwrseq->clk_enabled) {
106		clk_disable_unprepare(pwrseq->ext_clk);
107		pwrseq->clk_enabled = false;
108	}
109}
110
111static const struct mmc_pwrseq_ops mmc_pwrseq_simple_ops = {
112	.pre_power_on = mmc_pwrseq_simple_pre_power_on,
113	.post_power_on = mmc_pwrseq_simple_post_power_on,
114	.power_off = mmc_pwrseq_simple_power_off,
115};
116
117static const struct of_device_id mmc_pwrseq_simple_of_match[] = {
118	{ .compatible = "mmc-pwrseq-simple",},
119	{/* sentinel */},
120};
121MODULE_DEVICE_TABLE(of, mmc_pwrseq_simple_of_match);
122
123static int mmc_pwrseq_simple_probe(struct platform_device *pdev)
124{
125	struct mmc_pwrseq_simple *pwrseq;
126	struct device *dev = &pdev->dev;
127	int ngpio;
128
129	pwrseq = devm_kzalloc(dev, sizeof(*pwrseq), GFP_KERNEL);
130	if (!pwrseq)
131		return -ENOMEM;
132
133	pwrseq->ext_clk = devm_clk_get(dev, "ext_clock");
134	if (IS_ERR(pwrseq->ext_clk) && PTR_ERR(pwrseq->ext_clk) != -ENOENT)
135		return dev_err_probe(dev, PTR_ERR(pwrseq->ext_clk), "external clock not ready\n");
136
137	ngpio = of_count_phandle_with_args(dev->of_node, "reset-gpios", "#gpio-cells");
138	if (ngpio == 1) {
139		pwrseq->reset_ctrl = devm_reset_control_get_optional_shared(dev, NULL);
140		if (IS_ERR(pwrseq->reset_ctrl))
141			return dev_err_probe(dev, PTR_ERR(pwrseq->reset_ctrl),
142					     "reset control not ready\n");
143	}
144
145	/*
146	 * Fallback to GPIO based reset control in case of multiple reset lines
147	 * are specified or the platform doesn't have support for RESET at all.
148	 */
149	if (!pwrseq->reset_ctrl) {
150		pwrseq->reset_gpios = devm_gpiod_get_array(dev, "reset", GPIOD_OUT_HIGH);
151		if (IS_ERR(pwrseq->reset_gpios) &&
152		    PTR_ERR(pwrseq->reset_gpios) != -ENOENT &&
153		    PTR_ERR(pwrseq->reset_gpios) != -ENOSYS) {
154			return dev_err_probe(dev, PTR_ERR(pwrseq->reset_gpios),
155					     "reset GPIOs not ready\n");
156		}
157	}
158
159	device_property_read_u32(dev, "post-power-on-delay-ms",
160				 &pwrseq->post_power_on_delay_ms);
161	device_property_read_u32(dev, "power-off-delay-us",
162				 &pwrseq->power_off_delay_us);
163
164	pwrseq->pwrseq.dev = dev;
165	pwrseq->pwrseq.ops = &mmc_pwrseq_simple_ops;
166	pwrseq->pwrseq.owner = THIS_MODULE;
167	platform_set_drvdata(pdev, pwrseq);
168
169	return mmc_pwrseq_register(&pwrseq->pwrseq);
170}
171
172static void mmc_pwrseq_simple_remove(struct platform_device *pdev)
173{
174	struct mmc_pwrseq_simple *pwrseq = platform_get_drvdata(pdev);
175
176	mmc_pwrseq_unregister(&pwrseq->pwrseq);
177}
178
179static struct platform_driver mmc_pwrseq_simple_driver = {
180	.probe = mmc_pwrseq_simple_probe,
181	.remove = mmc_pwrseq_simple_remove,
182	.driver = {
183		.name = "pwrseq_simple",
184		.of_match_table = mmc_pwrseq_simple_of_match,
185	},
186};
187
188module_platform_driver(mmc_pwrseq_simple_driver);
189MODULE_DESCRIPTION("Simple power sequence management for MMC");
190MODULE_LICENSE("GPL v2");