xref: /linux/drivers/mmc/core/slot-gpio.c (revision 8b06f7538a1bb6ad15969114e31be7a99420125b)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Generic GPIO card-detect helper
4  *
5  * Copyright (C) 2011, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
6  */
7 
8 #include <linux/err.h>
9 #include <linux/gpio/consumer.h>
10 #include <linux/interrupt.h>
11 #include <linux/jiffies.h>
12 #include <linux/mmc/host.h>
13 #include <linux/mmc/slot-gpio.h>
14 #include <linux/module.h>
15 #include <linux/slab.h>
16 
17 #include "slot-gpio.h"
18 
19 struct mmc_gpio {
20 	struct gpio_desc *ro_gpio;
21 	struct gpio_desc *cd_gpio;
22 	irq_handler_t cd_gpio_isr;
23 	char *ro_label;
24 	char *cd_label;
25 	u32 cd_debounce_delay_ms;
26 	int cd_irq;
27 };
28 
mmc_gpio_cd_irqt(int irq,void * dev_id)29 static irqreturn_t mmc_gpio_cd_irqt(int irq, void *dev_id)
30 {
31 	/* Schedule a card detection after a debounce timeout */
32 	struct mmc_host *host = dev_id;
33 	struct mmc_gpio *ctx = host->slot.handler_priv;
34 
35 	host->trigger_card_event = true;
36 	mmc_detect_change(host, msecs_to_jiffies(ctx->cd_debounce_delay_ms));
37 
38 	return IRQ_HANDLED;
39 }
40 
mmc_gpio_alloc(struct mmc_host * host)41 int mmc_gpio_alloc(struct mmc_host *host)
42 {
43 	const char *devname = dev_name(host->parent);
44 	struct mmc_gpio *ctx;
45 
46 	ctx = devm_kzalloc(host->parent, sizeof(*ctx), GFP_KERNEL);
47 	if (!ctx)
48 		return -ENOMEM;
49 
50 	ctx->cd_debounce_delay_ms = 200;
51 	ctx->cd_label = devm_kasprintf(host->parent, GFP_KERNEL, "%s cd", devname);
52 	if (!ctx->cd_label)
53 		return -ENOMEM;
54 	ctx->ro_label = devm_kasprintf(host->parent, GFP_KERNEL, "%s ro", devname);
55 	if (!ctx->ro_label)
56 		return -ENOMEM;
57 	ctx->cd_irq = -EINVAL;
58 	host->slot.handler_priv = ctx;
59 	host->slot.cd_irq = -EINVAL;
60 
61 	return 0;
62 }
63 
mmc_gpio_set_cd_irq(struct mmc_host * host,int irq)64 void mmc_gpio_set_cd_irq(struct mmc_host *host, int irq)
65 {
66 	struct mmc_gpio *ctx = host->slot.handler_priv;
67 
68 	if (!ctx || irq < 0)
69 		return;
70 
71 	ctx->cd_irq = irq;
72 }
73 EXPORT_SYMBOL(mmc_gpio_set_cd_irq);
74 
mmc_gpio_get_ro(struct mmc_host * host)75 int mmc_gpio_get_ro(struct mmc_host *host)
76 {
77 	struct mmc_gpio *ctx = host->slot.handler_priv;
78 	int cansleep;
79 
80 	if (!ctx || !ctx->ro_gpio)
81 		return -ENOSYS;
82 
83 	cansleep = gpiod_cansleep(ctx->ro_gpio);
84 	return cansleep ?
85 		gpiod_get_value_cansleep(ctx->ro_gpio) :
86 		gpiod_get_value(ctx->ro_gpio);
87 }
88 EXPORT_SYMBOL(mmc_gpio_get_ro);
89 
mmc_gpio_get_cd(struct mmc_host * host)90 int mmc_gpio_get_cd(struct mmc_host *host)
91 {
92 	struct mmc_gpio *ctx = host->slot.handler_priv;
93 	int cansleep;
94 
95 	if (!ctx || !ctx->cd_gpio)
96 		return -ENOSYS;
97 
98 	cansleep = gpiod_cansleep(ctx->cd_gpio);
99 	return cansleep ?
100 		gpiod_get_value_cansleep(ctx->cd_gpio) :
101 		gpiod_get_value(ctx->cd_gpio);
102 }
103 EXPORT_SYMBOL(mmc_gpio_get_cd);
104 
mmc_gpiod_request_cd_irq(struct mmc_host * host)105 void mmc_gpiod_request_cd_irq(struct mmc_host *host)
106 {
107 	struct mmc_gpio *ctx = host->slot.handler_priv;
108 	int irq = -EINVAL;
109 	int ret;
110 
111 	if (host->slot.cd_irq >= 0 || !ctx || !ctx->cd_gpio)
112 		return;
113 
114 	/*
115 	 * Do not use IRQ if the platform prefers to poll, e.g., because that
116 	 * IRQ number is already used by another unit and cannot be shared.
117 	 */
118 	if (ctx->cd_irq >= 0)
119 		irq = ctx->cd_irq;
120 	else if (!(host->caps & MMC_CAP_NEEDS_POLL))
121 		irq = gpiod_to_irq(ctx->cd_gpio);
122 
123 	if (irq >= 0) {
124 		if (!ctx->cd_gpio_isr)
125 			ctx->cd_gpio_isr = mmc_gpio_cd_irqt;
126 		ret = devm_request_threaded_irq(host->parent, irq,
127 			NULL, ctx->cd_gpio_isr,
128 			IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
129 			ctx->cd_label, host);
130 		if (ret < 0)
131 			irq = ret;
132 	}
133 
134 	host->slot.cd_irq = irq;
135 
136 	if (irq < 0)
137 		host->caps |= MMC_CAP_NEEDS_POLL;
138 }
139 EXPORT_SYMBOL(mmc_gpiod_request_cd_irq);
140 
mmc_gpio_set_cd_wake(struct mmc_host * host,bool on)141 int mmc_gpio_set_cd_wake(struct mmc_host *host, bool on)
142 {
143 	int ret = 0;
144 
145 	if (!(host->caps & MMC_CAP_CD_WAKE) ||
146 	    host->slot.cd_irq < 0 ||
147 	    on == host->slot.cd_wake_enabled)
148 		return 0;
149 
150 	if (on) {
151 		ret = enable_irq_wake(host->slot.cd_irq);
152 		host->slot.cd_wake_enabled = !ret;
153 	} else {
154 		disable_irq_wake(host->slot.cd_irq);
155 		host->slot.cd_wake_enabled = false;
156 	}
157 
158 	return ret;
159 }
160 EXPORT_SYMBOL(mmc_gpio_set_cd_wake);
161 
162 /* Register an alternate interrupt service routine for
163  * the card-detect GPIO.
164  */
mmc_gpio_set_cd_isr(struct mmc_host * host,irq_handler_t isr)165 void mmc_gpio_set_cd_isr(struct mmc_host *host, irq_handler_t isr)
166 {
167 	struct mmc_gpio *ctx = host->slot.handler_priv;
168 
169 	WARN_ON(ctx->cd_gpio_isr);
170 	ctx->cd_gpio_isr = isr;
171 }
172 EXPORT_SYMBOL(mmc_gpio_set_cd_isr);
173 
174 /**
175  * mmc_gpiod_request_cd - request a gpio descriptor for card-detection
176  * @host: mmc host
177  * @con_id: function within the GPIO consumer
178  * @idx: index of the GPIO to obtain in the consumer
179  * @override_active_level: ignore %GPIO_ACTIVE_LOW flag
180  * @debounce: debounce time in microseconds
181  *
182  * Note that this must be called prior to mmc_add_host()
183  * otherwise the caller must also call mmc_gpiod_request_cd_irq().
184  *
185  * Returns zero on success, else an error.
186  */
mmc_gpiod_request_cd(struct mmc_host * host,const char * con_id,unsigned int idx,bool override_active_level,unsigned int debounce)187 int mmc_gpiod_request_cd(struct mmc_host *host, const char *con_id,
188 			 unsigned int idx, bool override_active_level,
189 			 unsigned int debounce)
190 {
191 	struct mmc_gpio *ctx = host->slot.handler_priv;
192 	struct gpio_desc *desc;
193 	int ret;
194 
195 	desc = devm_gpiod_get_index(host->parent, con_id, idx, GPIOD_IN);
196 	if (IS_ERR(desc))
197 		return PTR_ERR(desc);
198 
199 	/* Update default label if no con_id provided */
200 	if (!con_id)
201 		gpiod_set_consumer_name(desc, ctx->cd_label);
202 
203 	if (debounce) {
204 		ret = gpiod_set_debounce(desc, debounce);
205 		if (ret < 0)
206 			ctx->cd_debounce_delay_ms = debounce / 1000;
207 	}
208 
209 	/* override forces default (active-low) polarity ... */
210 	if (override_active_level && !gpiod_is_active_low(desc))
211 		gpiod_toggle_active_low(desc);
212 
213 	/* ... or active-high */
214 	if (host->caps2 & MMC_CAP2_CD_ACTIVE_HIGH)
215 		gpiod_toggle_active_low(desc);
216 
217 	ctx->cd_gpio = desc;
218 
219 	return 0;
220 }
221 EXPORT_SYMBOL(mmc_gpiod_request_cd);
222 
223 /**
224  * mmc_gpiod_set_cd_config - set config for card-detection GPIO
225  * @host: mmc host
226  * @config: Generic pinconf config (from pinconf_to_config_packed())
227  *
228  * This can be used by mmc host drivers to fixup a card-detection GPIO's config
229  * (e.g. set PIN_CONFIG_BIAS_PULL_UP) after acquiring the GPIO descriptor
230  * through mmc_gpiod_request_cd().
231  *
232  * Returns:
233  * 0 on success, or a negative errno value on error.
234  */
mmc_gpiod_set_cd_config(struct mmc_host * host,unsigned long config)235 int mmc_gpiod_set_cd_config(struct mmc_host *host, unsigned long config)
236 {
237 	struct mmc_gpio *ctx = host->slot.handler_priv;
238 
239 	return gpiod_set_config(ctx->cd_gpio, config);
240 }
241 EXPORT_SYMBOL(mmc_gpiod_set_cd_config);
242 
mmc_can_gpio_cd(struct mmc_host * host)243 bool mmc_can_gpio_cd(struct mmc_host *host)
244 {
245 	struct mmc_gpio *ctx = host->slot.handler_priv;
246 
247 	return ctx->cd_gpio ? true : false;
248 }
249 EXPORT_SYMBOL(mmc_can_gpio_cd);
250 
251 /**
252  * mmc_gpiod_request_ro - request a gpio descriptor for write protection
253  * @host: mmc host
254  * @con_id: function within the GPIO consumer
255  * @idx: index of the GPIO to obtain in the consumer
256  * @debounce: debounce time in microseconds
257  *
258  * Returns zero on success, else an error.
259  */
mmc_gpiod_request_ro(struct mmc_host * host,const char * con_id,unsigned int idx,unsigned int debounce)260 int mmc_gpiod_request_ro(struct mmc_host *host, const char *con_id,
261 			 unsigned int idx, unsigned int debounce)
262 {
263 	struct mmc_gpio *ctx = host->slot.handler_priv;
264 	struct gpio_desc *desc;
265 	int ret;
266 
267 	desc = devm_gpiod_get_index(host->parent, con_id, idx, GPIOD_IN);
268 	if (IS_ERR(desc))
269 		return PTR_ERR(desc);
270 
271 	/* Update default label if no con_id provided */
272 	if (!con_id)
273 		gpiod_set_consumer_name(desc, ctx->ro_label);
274 
275 	if (debounce) {
276 		ret = gpiod_set_debounce(desc, debounce);
277 		if (ret < 0)
278 			return ret;
279 	}
280 
281 	if (host->caps2 & MMC_CAP2_RO_ACTIVE_HIGH)
282 		gpiod_toggle_active_low(desc);
283 
284 	ctx->ro_gpio = desc;
285 
286 	return 0;
287 }
288 EXPORT_SYMBOL(mmc_gpiod_request_ro);
289 
mmc_can_gpio_ro(struct mmc_host * host)290 bool mmc_can_gpio_ro(struct mmc_host *host)
291 {
292 	struct mmc_gpio *ctx = host->slot.handler_priv;
293 
294 	return ctx->ro_gpio ? true : false;
295 }
296 EXPORT_SYMBOL(mmc_can_gpio_ro);
297