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