xref: /openbmc/linux/drivers/mmc/core/host.c (revision a36954f5)
1 /*
2  *  linux/drivers/mmc/core/host.c
3  *
4  *  Copyright (C) 2003 Russell King, All Rights Reserved.
5  *  Copyright (C) 2007-2008 Pierre Ossman
6  *  Copyright (C) 2010 Linus Walleij
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>
18 #include <linux/of.h>
19 #include <linux/of_gpio.h>
20 #include <linux/pagemap.h>
21 #include <linux/export.h>
22 #include <linux/leds.h>
23 #include <linux/slab.h>
24 
25 #include <linux/mmc/host.h>
26 #include <linux/mmc/card.h>
27 #include <linux/mmc/slot-gpio.h>
28 
29 #include "core.h"
30 #include "host.h"
31 #include "slot-gpio.h"
32 #include "pwrseq.h"
33 
34 #define cls_dev_to_mmc_host(d)	container_of(d, struct mmc_host, class_dev)
35 
36 static DEFINE_IDA(mmc_host_ida);
37 
38 static void mmc_host_classdev_release(struct device *dev)
39 {
40 	struct mmc_host *host = cls_dev_to_mmc_host(dev);
41 	ida_simple_remove(&mmc_host_ida, host->index);
42 	kfree(host);
43 }
44 
45 static struct class mmc_host_class = {
46 	.name		= "mmc_host",
47 	.dev_release	= mmc_host_classdev_release,
48 };
49 
50 int mmc_register_host_class(void)
51 {
52 	return class_register(&mmc_host_class);
53 }
54 
55 void mmc_unregister_host_class(void)
56 {
57 	class_unregister(&mmc_host_class);
58 }
59 
60 void mmc_retune_enable(struct mmc_host *host)
61 {
62 	host->can_retune = 1;
63 	if (host->retune_period)
64 		mod_timer(&host->retune_timer,
65 			  jiffies + host->retune_period * HZ);
66 }
67 
68 /*
69  * Pause re-tuning for a small set of operations.  The pause begins after the
70  * next command and after first doing re-tuning.
71  */
72 void mmc_retune_pause(struct mmc_host *host)
73 {
74 	if (!host->retune_paused) {
75 		host->retune_paused = 1;
76 		mmc_retune_needed(host);
77 		mmc_retune_hold(host);
78 	}
79 }
80 EXPORT_SYMBOL(mmc_retune_pause);
81 
82 void mmc_retune_unpause(struct mmc_host *host)
83 {
84 	if (host->retune_paused) {
85 		host->retune_paused = 0;
86 		mmc_retune_release(host);
87 	}
88 }
89 EXPORT_SYMBOL(mmc_retune_unpause);
90 
91 void mmc_retune_disable(struct mmc_host *host)
92 {
93 	mmc_retune_unpause(host);
94 	host->can_retune = 0;
95 	del_timer_sync(&host->retune_timer);
96 	host->retune_now = 0;
97 	host->need_retune = 0;
98 }
99 
100 void mmc_retune_timer_stop(struct mmc_host *host)
101 {
102 	del_timer_sync(&host->retune_timer);
103 }
104 EXPORT_SYMBOL(mmc_retune_timer_stop);
105 
106 void mmc_retune_hold(struct mmc_host *host)
107 {
108 	if (!host->hold_retune)
109 		host->retune_now = 1;
110 	host->hold_retune += 1;
111 }
112 
113 void mmc_retune_release(struct mmc_host *host)
114 {
115 	if (host->hold_retune)
116 		host->hold_retune -= 1;
117 	else
118 		WARN_ON(1);
119 }
120 
121 int mmc_retune(struct mmc_host *host)
122 {
123 	bool return_to_hs400 = false;
124 	int err;
125 
126 	if (host->retune_now)
127 		host->retune_now = 0;
128 	else
129 		return 0;
130 
131 	if (!host->need_retune || host->doing_retune || !host->card)
132 		return 0;
133 
134 	host->need_retune = 0;
135 
136 	host->doing_retune = 1;
137 
138 	if (host->ios.timing == MMC_TIMING_MMC_HS400) {
139 		err = mmc_hs400_to_hs200(host->card);
140 		if (err)
141 			goto out;
142 
143 		return_to_hs400 = true;
144 
145 		if (host->ops->prepare_hs400_tuning)
146 			host->ops->prepare_hs400_tuning(host, &host->ios);
147 	}
148 
149 	err = mmc_execute_tuning(host->card);
150 	if (err)
151 		goto out;
152 
153 	if (return_to_hs400)
154 		err = mmc_hs200_to_hs400(host->card);
155 out:
156 	host->doing_retune = 0;
157 
158 	return err;
159 }
160 
161 static void mmc_retune_timer(unsigned long data)
162 {
163 	struct mmc_host *host = (struct mmc_host *)data;
164 
165 	mmc_retune_needed(host);
166 }
167 
168 /**
169  *	mmc_of_parse() - parse host's device-tree node
170  *	@host: host whose node should be parsed.
171  *
172  * To keep the rest of the MMC subsystem unaware of whether DT has been
173  * used to to instantiate and configure this host instance or not, we
174  * parse the properties and set respective generic mmc-host flags and
175  * parameters.
176  */
177 int mmc_of_parse(struct mmc_host *host)
178 {
179 	struct device_node *np;
180 	u32 bus_width;
181 	int ret;
182 	bool cd_cap_invert, cd_gpio_invert = false;
183 	bool ro_cap_invert, ro_gpio_invert = false;
184 
185 	if (!host->parent || !host->parent->of_node)
186 		return 0;
187 
188 	np = host->parent->of_node;
189 
190 	/* "bus-width" is translated to MMC_CAP_*_BIT_DATA flags */
191 	if (of_property_read_u32(np, "bus-width", &bus_width) < 0) {
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,
208 			"Invalid \"bus-width\" value %u!\n", bus_width);
209 		return -EINVAL;
210 	}
211 
212 	/* f_max is obtained from the optional "max-frequency" property */
213 	of_property_read_u32(np, "max-frequency", &host->f_max);
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 */
228 	if (of_property_read_bool(np, "non-removable")) {
229 		host->caps |= MMC_CAP_NONREMOVABLE;
230 	} else {
231 		cd_cap_invert = of_property_read_bool(np, "cd-inverted");
232 
233 		if (of_property_read_bool(np, "broken-cd"))
234 			host->caps |= MMC_CAP_NEEDS_POLL;
235 
236 		ret = mmc_gpiod_request_cd(host, "cd", 0, true,
237 					   0, &cd_gpio_invert);
238 		if (!ret)
239 			dev_info(host->parent, "Got CD GPIO\n");
240 		else if (ret != -ENOENT && ret != -ENOSYS)
241 			return ret;
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 		 */
254 		if (cd_cap_invert ^ cd_gpio_invert)
255 			host->caps2 |= MMC_CAP2_CD_ACTIVE_HIGH;
256 	}
257 
258 	/* Parse Write Protection */
259 	ro_cap_invert = of_property_read_bool(np, "wp-inverted");
260 
261 	ret = mmc_gpiod_request_ro(host, "wp", 0, false, 0, &ro_gpio_invert);
262 	if (!ret)
263 		dev_info(host->parent, "Got WP GPIO\n");
264 	else if (ret != -ENOENT && ret != -ENOSYS)
265 		return ret;
266 
267 	if (of_property_read_bool(np, "disable-wp"))
268 		host->caps2 |= MMC_CAP2_NO_WRITE_PROTECT;
269 
270 	/* See the comment on CD inversion above */
271 	if (ro_cap_invert ^ ro_gpio_invert)
272 		host->caps2 |= MMC_CAP2_RO_ACTIVE_HIGH;
273 
274 	if (of_property_read_bool(np, "cap-sd-highspeed"))
275 		host->caps |= MMC_CAP_SD_HIGHSPEED;
276 	if (of_property_read_bool(np, "cap-mmc-highspeed"))
277 		host->caps |= MMC_CAP_MMC_HIGHSPEED;
278 	if (of_property_read_bool(np, "sd-uhs-sdr12"))
279 		host->caps |= MMC_CAP_UHS_SDR12;
280 	if (of_property_read_bool(np, "sd-uhs-sdr25"))
281 		host->caps |= MMC_CAP_UHS_SDR25;
282 	if (of_property_read_bool(np, "sd-uhs-sdr50"))
283 		host->caps |= MMC_CAP_UHS_SDR50;
284 	if (of_property_read_bool(np, "sd-uhs-sdr104"))
285 		host->caps |= MMC_CAP_UHS_SDR104;
286 	if (of_property_read_bool(np, "sd-uhs-ddr50"))
287 		host->caps |= MMC_CAP_UHS_DDR50;
288 	if (of_property_read_bool(np, "cap-power-off-card"))
289 		host->caps |= MMC_CAP_POWER_OFF_CARD;
290 	if (of_property_read_bool(np, "cap-mmc-hw-reset"))
291 		host->caps |= MMC_CAP_HW_RESET;
292 	if (of_property_read_bool(np, "cap-sdio-irq"))
293 		host->caps |= MMC_CAP_SDIO_IRQ;
294 	if (of_property_read_bool(np, "full-pwr-cycle"))
295 		host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE;
296 	if (of_property_read_bool(np, "keep-power-in-suspend"))
297 		host->pm_caps |= MMC_PM_KEEP_POWER;
298 	if (of_property_read_bool(np, "wakeup-source") ||
299 	    of_property_read_bool(np, "enable-sdio-wakeup")) /* legacy */
300 		host->pm_caps |= MMC_PM_WAKE_SDIO_IRQ;
301 	if (of_property_read_bool(np, "mmc-ddr-3_3v"))
302 		host->caps |= MMC_CAP_3_3V_DDR;
303 	if (of_property_read_bool(np, "mmc-ddr-1_8v"))
304 		host->caps |= MMC_CAP_1_8V_DDR;
305 	if (of_property_read_bool(np, "mmc-ddr-1_2v"))
306 		host->caps |= MMC_CAP_1_2V_DDR;
307 	if (of_property_read_bool(np, "mmc-hs200-1_8v"))
308 		host->caps2 |= MMC_CAP2_HS200_1_8V_SDR;
309 	if (of_property_read_bool(np, "mmc-hs200-1_2v"))
310 		host->caps2 |= MMC_CAP2_HS200_1_2V_SDR;
311 	if (of_property_read_bool(np, "mmc-hs400-1_8v"))
312 		host->caps2 |= MMC_CAP2_HS400_1_8V | MMC_CAP2_HS200_1_8V_SDR;
313 	if (of_property_read_bool(np, "mmc-hs400-1_2v"))
314 		host->caps2 |= MMC_CAP2_HS400_1_2V | MMC_CAP2_HS200_1_2V_SDR;
315 	if (of_property_read_bool(np, "mmc-hs400-enhanced-strobe"))
316 		host->caps2 |= MMC_CAP2_HS400_ES;
317 	if (of_property_read_bool(np, "no-sdio"))
318 		host->caps2 |= MMC_CAP2_NO_SDIO;
319 	if (of_property_read_bool(np, "no-sd"))
320 		host->caps2 |= MMC_CAP2_NO_SD;
321 	if (of_property_read_bool(np, "no-mmc"))
322 		host->caps2 |= MMC_CAP2_NO_MMC;
323 
324 	host->dsr_req = !of_property_read_u32(np, "dsr", &host->dsr);
325 	if (host->dsr_req && (host->dsr & ~0xffff)) {
326 		dev_err(host->parent,
327 			"device tree specified broken value for DSR: 0x%x, ignoring\n",
328 			host->dsr);
329 		host->dsr_req = 0;
330 	}
331 
332 	return mmc_pwrseq_alloc(host);
333 }
334 
335 EXPORT_SYMBOL(mmc_of_parse);
336 
337 /**
338  *	mmc_alloc_host - initialise the per-host structure.
339  *	@extra: sizeof private data structure
340  *	@dev: pointer to host device model structure
341  *
342  *	Initialise the per-host structure.
343  */
344 struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
345 {
346 	int err;
347 	struct mmc_host *host;
348 
349 	host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL);
350 	if (!host)
351 		return NULL;
352 
353 	/* scanning will be enabled when we're ready */
354 	host->rescan_disable = 1;
355 
356 	err = ida_simple_get(&mmc_host_ida, 0, 0, GFP_KERNEL);
357 	if (err < 0) {
358 		kfree(host);
359 		return NULL;
360 	}
361 
362 	host->index = err;
363 
364 	dev_set_name(&host->class_dev, "mmc%d", host->index);
365 
366 	host->parent = dev;
367 	host->class_dev.parent = dev;
368 	host->class_dev.class = &mmc_host_class;
369 	device_initialize(&host->class_dev);
370 	device_enable_async_suspend(&host->class_dev);
371 
372 	if (mmc_gpio_alloc(host)) {
373 		put_device(&host->class_dev);
374 		ida_simple_remove(&mmc_host_ida, host->index);
375 		kfree(host);
376 		return NULL;
377 	}
378 
379 	spin_lock_init(&host->lock);
380 	init_waitqueue_head(&host->wq);
381 	INIT_DELAYED_WORK(&host->detect, mmc_rescan);
382 	setup_timer(&host->retune_timer, mmc_retune_timer, (unsigned long)host);
383 
384 	/*
385 	 * By default, hosts do not support SGIO or large requests.
386 	 * They have to set these according to their abilities.
387 	 */
388 	host->max_segs = 1;
389 	host->max_seg_size = PAGE_SIZE;
390 
391 	host->max_req_size = PAGE_SIZE;
392 	host->max_blk_size = 512;
393 	host->max_blk_count = PAGE_SIZE / 512;
394 
395 	return host;
396 }
397 
398 EXPORT_SYMBOL(mmc_alloc_host);
399 
400 /**
401  *	mmc_add_host - initialise host hardware
402  *	@host: mmc host
403  *
404  *	Register the host with the driver model. The host must be
405  *	prepared to start servicing requests before this function
406  *	completes.
407  */
408 int mmc_add_host(struct mmc_host *host)
409 {
410 	int err;
411 
412 	WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) &&
413 		!host->ops->enable_sdio_irq);
414 
415 	err = device_add(&host->class_dev);
416 	if (err)
417 		return err;
418 
419 	led_trigger_register_simple(dev_name(&host->class_dev), &host->led);
420 
421 #ifdef CONFIG_DEBUG_FS
422 	mmc_add_host_debugfs(host);
423 #endif
424 
425 	mmc_start_host(host);
426 	mmc_register_pm_notifier(host);
427 
428 	return 0;
429 }
430 
431 EXPORT_SYMBOL(mmc_add_host);
432 
433 /**
434  *	mmc_remove_host - remove host hardware
435  *	@host: mmc host
436  *
437  *	Unregister and remove all cards associated with this host,
438  *	and power down the MMC bus. No new requests will be issued
439  *	after this function has returned.
440  */
441 void mmc_remove_host(struct mmc_host *host)
442 {
443 	mmc_unregister_pm_notifier(host);
444 	mmc_stop_host(host);
445 
446 #ifdef CONFIG_DEBUG_FS
447 	mmc_remove_host_debugfs(host);
448 #endif
449 
450 	device_del(&host->class_dev);
451 
452 	led_trigger_unregister_simple(host->led);
453 }
454 
455 EXPORT_SYMBOL(mmc_remove_host);
456 
457 /**
458  *	mmc_free_host - free the host structure
459  *	@host: mmc host
460  *
461  *	Free the host once all references to it have been dropped.
462  */
463 void mmc_free_host(struct mmc_host *host)
464 {
465 	mmc_pwrseq_free(host);
466 	put_device(&host->class_dev);
467 }
468 
469 EXPORT_SYMBOL(mmc_free_host);
470