xref: /linux/drivers/mmc/core/host.c (revision 74ce1896c6c65b2f8cccbf59162d542988835835) 
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 #include "sdio_ops.h"
34 
35 #define cls_dev_to_mmc_host(d)	container_of(d, struct mmc_host, class_dev)
36 
37 static DEFINE_IDA(mmc_host_ida);
38 
39 static void mmc_host_classdev_release(struct device *dev)
40 {
41 	struct mmc_host *host = cls_dev_to_mmc_host(dev);
42 	ida_simple_remove(&mmc_host_ida, host->index);
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 
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 
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 
92 void mmc_retune_disable(struct mmc_host *host)
93 {
94 	mmc_retune_unpause(host);
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_hold_now(struct mmc_host *host)
115 {
116 	host->retune_now = 0;
117 	host->hold_retune += 1;
118 }
119 
120 void mmc_retune_release(struct mmc_host *host)
121 {
122 	if (host->hold_retune)
123 		host->hold_retune -= 1;
124 	else
125 		WARN_ON(1);
126 }
127 
128 int mmc_retune(struct mmc_host *host)
129 {
130 	bool return_to_hs400 = false;
131 	int err;
132 
133 	if (host->retune_now)
134 		host->retune_now = 0;
135 	else
136 		return 0;
137 
138 	if (!host->need_retune || host->doing_retune || !host->card)
139 		return 0;
140 
141 	host->need_retune = 0;
142 
143 	host->doing_retune = 1;
144 
145 	if (host->ios.timing == MMC_TIMING_MMC_HS400) {
146 		err = mmc_hs400_to_hs200(host->card);
147 		if (err)
148 			goto out;
149 
150 		return_to_hs400 = true;
151 
152 		if (host->ops->prepare_hs400_tuning)
153 			host->ops->prepare_hs400_tuning(host, &host->ios);
154 	}
155 
156 	err = mmc_execute_tuning(host->card);
157 	if (err)
158 		goto out;
159 
160 	if (return_to_hs400)
161 		err = mmc_hs200_to_hs400(host->card);
162 out:
163 	host->doing_retune = 0;
164 
165 	return err;
166 }
167 
168 static void mmc_retune_timer(unsigned long data)
169 {
170 	struct mmc_host *host = (struct mmc_host *)data;
171 
172 	mmc_retune_needed(host);
173 }
174 
175 /**
176  *	mmc_of_parse() - parse host's device-tree node
177  *	@host: host whose node should be parsed.
178  *
179  * To keep the rest of the MMC subsystem unaware of whether DT has been
180  * used to to instantiate and configure this host instance or not, we
181  * parse the properties and set respective generic mmc-host flags and
182  * parameters.
183  */
184 int mmc_of_parse(struct mmc_host *host)
185 {
186 	struct device *dev = host->parent;
187 	u32 bus_width;
188 	int ret;
189 	bool cd_cap_invert, cd_gpio_invert = false;
190 	bool ro_cap_invert, ro_gpio_invert = false;
191 
192 	if (!dev || !dev_fwnode(dev))
193 		return 0;
194 
195 	/* "bus-width" is translated to MMC_CAP_*_BIT_DATA flags */
196 	if (device_property_read_u32(dev, "bus-width", &bus_width) < 0) {
197 		dev_dbg(host->parent,
198 			"\"bus-width\" property is missing, assuming 1 bit.\n");
199 		bus_width = 1;
200 	}
201 
202 	switch (bus_width) {
203 	case 8:
204 		host->caps |= MMC_CAP_8_BIT_DATA;
205 		/* Hosts capable of 8-bit transfers can also do 4 bits */
206 	case 4:
207 		host->caps |= MMC_CAP_4_BIT_DATA;
208 		break;
209 	case 1:
210 		break;
211 	default:
212 		dev_err(host->parent,
213 			"Invalid \"bus-width\" value %u!\n", bus_width);
214 		return -EINVAL;
215 	}
216 
217 	/* f_max is obtained from the optional "max-frequency" property */
218 	device_property_read_u32(dev, "max-frequency", &host->f_max);
219 
220 	/*
221 	 * Configure CD and WP pins. They are both by default active low to
222 	 * match the SDHCI spec. If GPIOs are provided for CD and / or WP, the
223 	 * mmc-gpio helpers are used to attach, configure and use them. If
224 	 * polarity inversion is specified in DT, one of MMC_CAP2_CD_ACTIVE_HIGH
225 	 * and MMC_CAP2_RO_ACTIVE_HIGH capability-2 flags is set. If the
226 	 * "broken-cd" property is provided, the MMC_CAP_NEEDS_POLL capability
227 	 * is set. If the "non-removable" property is found, the
228 	 * MMC_CAP_NONREMOVABLE capability is set and no card-detection
229 	 * configuration is performed.
230 	 */
231 
232 	/* Parse Card Detection */
233 	if (device_property_read_bool(dev, "non-removable")) {
234 		host->caps |= MMC_CAP_NONREMOVABLE;
235 	} else {
236 		cd_cap_invert = device_property_read_bool(dev, "cd-inverted");
237 
238 		if (device_property_read_bool(dev, "broken-cd"))
239 			host->caps |= MMC_CAP_NEEDS_POLL;
240 
241 		ret = mmc_gpiod_request_cd(host, "cd", 0, true,
242 					   0, &cd_gpio_invert);
243 		if (!ret)
244 			dev_info(host->parent, "Got CD GPIO\n");
245 		else if (ret != -ENOENT && ret != -ENOSYS)
246 			return ret;
247 
248 		/*
249 		 * There are two ways to flag that the CD line is inverted:
250 		 * through the cd-inverted flag and by the GPIO line itself
251 		 * being inverted from the GPIO subsystem. This is a leftover
252 		 * from the times when the GPIO subsystem did not make it
253 		 * possible to flag a line as inverted.
254 		 *
255 		 * If the capability on the host AND the GPIO line are
256 		 * both inverted, the end result is that the CD line is
257 		 * not inverted.
258 		 */
259 		if (cd_cap_invert ^ cd_gpio_invert)
260 			host->caps2 |= MMC_CAP2_CD_ACTIVE_HIGH;
261 	}
262 
263 	/* Parse Write Protection */
264 	ro_cap_invert = device_property_read_bool(dev, "wp-inverted");
265 
266 	ret = mmc_gpiod_request_ro(host, "wp", 0, false, 0, &ro_gpio_invert);
267 	if (!ret)
268 		dev_info(host->parent, "Got WP GPIO\n");
269 	else if (ret != -ENOENT && ret != -ENOSYS)
270 		return ret;
271 
272 	if (device_property_read_bool(dev, "disable-wp"))
273 		host->caps2 |= MMC_CAP2_NO_WRITE_PROTECT;
274 
275 	/* See the comment on CD inversion above */
276 	if (ro_cap_invert ^ ro_gpio_invert)
277 		host->caps2 |= MMC_CAP2_RO_ACTIVE_HIGH;
278 
279 	if (device_property_read_bool(dev, "cap-sd-highspeed"))
280 		host->caps |= MMC_CAP_SD_HIGHSPEED;
281 	if (device_property_read_bool(dev, "cap-mmc-highspeed"))
282 		host->caps |= MMC_CAP_MMC_HIGHSPEED;
283 	if (device_property_read_bool(dev, "sd-uhs-sdr12"))
284 		host->caps |= MMC_CAP_UHS_SDR12;
285 	if (device_property_read_bool(dev, "sd-uhs-sdr25"))
286 		host->caps |= MMC_CAP_UHS_SDR25;
287 	if (device_property_read_bool(dev, "sd-uhs-sdr50"))
288 		host->caps |= MMC_CAP_UHS_SDR50;
289 	if (device_property_read_bool(dev, "sd-uhs-sdr104"))
290 		host->caps |= MMC_CAP_UHS_SDR104;
291 	if (device_property_read_bool(dev, "sd-uhs-ddr50"))
292 		host->caps |= MMC_CAP_UHS_DDR50;
293 	if (device_property_read_bool(dev, "cap-power-off-card"))
294 		host->caps |= MMC_CAP_POWER_OFF_CARD;
295 	if (device_property_read_bool(dev, "cap-mmc-hw-reset"))
296 		host->caps |= MMC_CAP_HW_RESET;
297 	if (device_property_read_bool(dev, "cap-sdio-irq"))
298 		host->caps |= MMC_CAP_SDIO_IRQ;
299 	if (device_property_read_bool(dev, "full-pwr-cycle"))
300 		host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE;
301 	if (device_property_read_bool(dev, "keep-power-in-suspend"))
302 		host->pm_caps |= MMC_PM_KEEP_POWER;
303 	if (device_property_read_bool(dev, "wakeup-source") ||
304 	    device_property_read_bool(dev, "enable-sdio-wakeup")) /* legacy */
305 		host->pm_caps |= MMC_PM_WAKE_SDIO_IRQ;
306 	if (device_property_read_bool(dev, "mmc-ddr-3_3v"))
307 		host->caps |= MMC_CAP_3_3V_DDR;
308 	if (device_property_read_bool(dev, "mmc-ddr-1_8v"))
309 		host->caps |= MMC_CAP_1_8V_DDR;
310 	if (device_property_read_bool(dev, "mmc-ddr-1_2v"))
311 		host->caps |= MMC_CAP_1_2V_DDR;
312 	if (device_property_read_bool(dev, "mmc-hs200-1_8v"))
313 		host->caps2 |= MMC_CAP2_HS200_1_8V_SDR;
314 	if (device_property_read_bool(dev, "mmc-hs200-1_2v"))
315 		host->caps2 |= MMC_CAP2_HS200_1_2V_SDR;
316 	if (device_property_read_bool(dev, "mmc-hs400-1_8v"))
317 		host->caps2 |= MMC_CAP2_HS400_1_8V | MMC_CAP2_HS200_1_8V_SDR;
318 	if (device_property_read_bool(dev, "mmc-hs400-1_2v"))
319 		host->caps2 |= MMC_CAP2_HS400_1_2V | MMC_CAP2_HS200_1_2V_SDR;
320 	if (device_property_read_bool(dev, "mmc-hs400-enhanced-strobe"))
321 		host->caps2 |= MMC_CAP2_HS400_ES;
322 	if (device_property_read_bool(dev, "no-sdio"))
323 		host->caps2 |= MMC_CAP2_NO_SDIO;
324 	if (device_property_read_bool(dev, "no-sd"))
325 		host->caps2 |= MMC_CAP2_NO_SD;
326 	if (device_property_read_bool(dev, "no-mmc"))
327 		host->caps2 |= MMC_CAP2_NO_MMC;
328 
329 	host->dsr_req = !device_property_read_u32(dev, "dsr", &host->dsr);
330 	if (host->dsr_req && (host->dsr & ~0xffff)) {
331 		dev_err(host->parent,
332 			"device tree specified broken value for DSR: 0x%x, ignoring\n",
333 			host->dsr);
334 		host->dsr_req = 0;
335 	}
336 
337 	return mmc_pwrseq_alloc(host);
338 }
339 
340 EXPORT_SYMBOL(mmc_of_parse);
341 
342 /**
343  *	mmc_alloc_host - initialise the per-host structure.
344  *	@extra: sizeof private data structure
345  *	@dev: pointer to host device model structure
346  *
347  *	Initialise the per-host structure.
348  */
349 struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
350 {
351 	int err;
352 	struct mmc_host *host;
353 
354 	host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL);
355 	if (!host)
356 		return NULL;
357 
358 	/* scanning will be enabled when we're ready */
359 	host->rescan_disable = 1;
360 
361 	err = ida_simple_get(&mmc_host_ida, 0, 0, GFP_KERNEL);
362 	if (err < 0) {
363 		kfree(host);
364 		return NULL;
365 	}
366 
367 	host->index = err;
368 
369 	dev_set_name(&host->class_dev, "mmc%d", host->index);
370 
371 	host->parent = dev;
372 	host->class_dev.parent = dev;
373 	host->class_dev.class = &mmc_host_class;
374 	device_initialize(&host->class_dev);
375 	device_enable_async_suspend(&host->class_dev);
376 
377 	if (mmc_gpio_alloc(host)) {
378 		put_device(&host->class_dev);
379 		ida_simple_remove(&mmc_host_ida, host->index);
380 		kfree(host);
381 		return NULL;
382 	}
383 
384 	spin_lock_init(&host->lock);
385 	init_waitqueue_head(&host->wq);
386 	INIT_DELAYED_WORK(&host->detect, mmc_rescan);
387 	INIT_DELAYED_WORK(&host->sdio_irq_work, sdio_irq_work);
388 	setup_timer(&host->retune_timer, mmc_retune_timer, (unsigned long)host);
389 
390 	/*
391 	 * By default, hosts do not support SGIO or large requests.
392 	 * They have to set these according to their abilities.
393 	 */
394 	host->max_segs = 1;
395 	host->max_seg_size = PAGE_SIZE;
396 
397 	host->max_req_size = PAGE_SIZE;
398 	host->max_blk_size = 512;
399 	host->max_blk_count = PAGE_SIZE / 512;
400 
401 	return host;
402 }
403 
404 EXPORT_SYMBOL(mmc_alloc_host);
405 
406 /**
407  *	mmc_add_host - initialise host hardware
408  *	@host: mmc host
409  *
410  *	Register the host with the driver model. The host must be
411  *	prepared to start servicing requests before this function
412  *	completes.
413  */
414 int mmc_add_host(struct mmc_host *host)
415 {
416 	int err;
417 
418 	WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) &&
419 		!host->ops->enable_sdio_irq);
420 
421 	err = device_add(&host->class_dev);
422 	if (err)
423 		return err;
424 
425 	led_trigger_register_simple(dev_name(&host->class_dev), &host->led);
426 
427 #ifdef CONFIG_DEBUG_FS
428 	mmc_add_host_debugfs(host);
429 #endif
430 
431 	mmc_start_host(host);
432 	mmc_register_pm_notifier(host);
433 
434 	return 0;
435 }
436 
437 EXPORT_SYMBOL(mmc_add_host);
438 
439 /**
440  *	mmc_remove_host - remove host hardware
441  *	@host: mmc host
442  *
443  *	Unregister and remove all cards associated with this host,
444  *	and power down the MMC bus. No new requests will be issued
445  *	after this function has returned.
446  */
447 void mmc_remove_host(struct mmc_host *host)
448 {
449 	mmc_unregister_pm_notifier(host);
450 	mmc_stop_host(host);
451 
452 #ifdef CONFIG_DEBUG_FS
453 	mmc_remove_host_debugfs(host);
454 #endif
455 
456 	device_del(&host->class_dev);
457 
458 	led_trigger_unregister_simple(host->led);
459 }
460 
461 EXPORT_SYMBOL(mmc_remove_host);
462 
463 /**
464  *	mmc_free_host - free the host structure
465  *	@host: mmc host
466  *
467  *	Free the host once all references to it have been dropped.
468  */
469 void mmc_free_host(struct mmc_host *host)
470 {
471 	mmc_pwrseq_free(host);
472 	put_device(&host->class_dev);
473 }
474 
475 EXPORT_SYMBOL(mmc_free_host);
476