Commit | Line | Data |
---|---|---|
d2912cb1 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
b93931a6 PO |
2 | /* |
3 | * linux/drivers/mmc/core/host.c | |
4 | * | |
5 | * Copyright (C) 2003 Russell King, All Rights Reserved. | |
ff3112f5 | 6 | * Copyright (C) 2007-2008 Pierre Ossman |
04566831 | 7 | * Copyright (C) 2010 Linus Walleij |
b93931a6 | 8 | * |
b93931a6 PO |
9 | * MMC host class device management |
10 | */ | |
11 | ||
12 | #include <linux/device.h> | |
13 | #include <linux/err.h> | |
14 | #include <linux/idr.h> | |
6c56e7a0 GL |
15 | #include <linux/of.h> |
16 | #include <linux/of_gpio.h> | |
b93931a6 | 17 | #include <linux/pagemap.h> |
b52fb259 | 18 | #include <linux/pm_wakeup.h> |
3ef77af1 | 19 | #include <linux/export.h> |
af8350c7 | 20 | #include <linux/leds.h> |
5a0e3ad6 | 21 | #include <linux/slab.h> |
b93931a6 PO |
22 | |
23 | #include <linux/mmc/host.h> | |
04566831 | 24 | #include <linux/mmc/card.h> |
6c56e7a0 | 25 | #include <linux/mmc/slot-gpio.h> |
b93931a6 PO |
26 | |
27 | #include "core.h" | |
93f1c150 | 28 | #include "crypto.h" |
b93931a6 | 29 | #include "host.h" |
df8aca16 | 30 | #include "slot-gpio.h" |
3aa8793f | 31 | #include "pwrseq.h" |
68269660 | 32 | #include "sdio_ops.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 | 37 | |
17a17bf5 UH |
38 | #ifdef CONFIG_PM_SLEEP |
39 | static int mmc_host_class_prepare(struct device *dev) | |
40 | { | |
41 | struct mmc_host *host = cls_dev_to_mmc_host(dev); | |
42 | ||
43 | /* | |
44 | * It's safe to access the bus_ops pointer, as both userspace and the | |
45 | * workqueue for detecting cards are frozen at this point. | |
46 | */ | |
47 | if (!host->bus_ops) | |
48 | return 0; | |
49 | ||
50 | /* Validate conditions for system suspend. */ | |
51 | if (host->bus_ops->pre_suspend) | |
52 | return host->bus_ops->pre_suspend(host); | |
53 | ||
54 | return 0; | |
55 | } | |
56 | ||
57 | static void mmc_host_class_complete(struct device *dev) | |
58 | { | |
59 | struct mmc_host *host = cls_dev_to_mmc_host(dev); | |
60 | ||
61 | _mmc_detect_change(host, 0, false); | |
62 | } | |
63 | ||
64 | static const struct dev_pm_ops mmc_host_class_dev_pm_ops = { | |
65 | .prepare = mmc_host_class_prepare, | |
66 | .complete = mmc_host_class_complete, | |
67 | }; | |
68 | ||
69 | #define MMC_HOST_CLASS_DEV_PM_OPS (&mmc_host_class_dev_pm_ops) | |
70 | #else | |
71 | #define MMC_HOST_CLASS_DEV_PM_OPS NULL | |
72 | #endif | |
73 | ||
b93931a6 PO |
74 | static void mmc_host_classdev_release(struct device *dev) |
75 | { | |
76 | struct mmc_host *host = cls_dev_to_mmc_host(dev); | |
b52fb259 | 77 | wakeup_source_unregister(host->ws); |
10252bae SB |
78 | if (of_alias_get_id(host->parent->of_node, "mmc") < 0) |
79 | ida_simple_remove(&mmc_host_ida, host->index); | |
b93931a6 PO |
80 | kfree(host); |
81 | } | |
82 | ||
66c915d0 UH |
83 | static int mmc_host_classdev_shutdown(struct device *dev) |
84 | { | |
85 | struct mmc_host *host = cls_dev_to_mmc_host(dev); | |
86 | ||
87 | __mmc_stop_host(host); | |
88 | return 0; | |
89 | } | |
90 | ||
b93931a6 PO |
91 | static struct class mmc_host_class = { |
92 | .name = "mmc_host", | |
93 | .dev_release = mmc_host_classdev_release, | |
66c915d0 | 94 | .shutdown_pre = mmc_host_classdev_shutdown, |
17a17bf5 | 95 | .pm = MMC_HOST_CLASS_DEV_PM_OPS, |
b93931a6 PO |
96 | }; |
97 | ||
98 | int mmc_register_host_class(void) | |
99 | { | |
100 | return class_register(&mmc_host_class); | |
101 | } | |
102 | ||
103 | void mmc_unregister_host_class(void) | |
104 | { | |
105 | class_unregister(&mmc_host_class); | |
106 | } | |
107 | ||
68249abd WS |
108 | /** |
109 | * mmc_retune_enable() - enter a transfer mode that requires retuning | |
110 | * @host: host which should retune now | |
111 | */ | |
dfa13ebb AH |
112 | void mmc_retune_enable(struct mmc_host *host) |
113 | { | |
114 | host->can_retune = 1; | |
115 | if (host->retune_period) | |
116 | mod_timer(&host->retune_timer, | |
117 | jiffies + host->retune_period * HZ); | |
118 | } | |
119 | ||
7ff27609 AH |
120 | /* |
121 | * Pause re-tuning for a small set of operations. The pause begins after the | |
122 | * next command and after first doing re-tuning. | |
123 | */ | |
124 | void mmc_retune_pause(struct mmc_host *host) | |
125 | { | |
126 | if (!host->retune_paused) { | |
127 | host->retune_paused = 1; | |
128 | mmc_retune_needed(host); | |
129 | mmc_retune_hold(host); | |
130 | } | |
131 | } | |
132 | EXPORT_SYMBOL(mmc_retune_pause); | |
133 | ||
134 | void mmc_retune_unpause(struct mmc_host *host) | |
135 | { | |
136 | if (host->retune_paused) { | |
137 | host->retune_paused = 0; | |
138 | mmc_retune_release(host); | |
139 | } | |
140 | } | |
141 | EXPORT_SYMBOL(mmc_retune_unpause); | |
142 | ||
68249abd WS |
143 | /** |
144 | * mmc_retune_disable() - exit a transfer mode that requires retuning | |
145 | * @host: host which should not retune anymore | |
146 | * | |
147 | * It is not meant for temporarily preventing retuning! | |
148 | */ | |
dfa13ebb AH |
149 | void mmc_retune_disable(struct mmc_host *host) |
150 | { | |
7ff27609 | 151 | mmc_retune_unpause(host); |
dfa13ebb AH |
152 | host->can_retune = 0; |
153 | del_timer_sync(&host->retune_timer); | |
8ffb2611 | 154 | mmc_retune_clear(host); |
dfa13ebb AH |
155 | } |
156 | ||
157 | void mmc_retune_timer_stop(struct mmc_host *host) | |
158 | { | |
159 | del_timer_sync(&host->retune_timer); | |
160 | } | |
161 | EXPORT_SYMBOL(mmc_retune_timer_stop); | |
162 | ||
163 | void mmc_retune_hold(struct mmc_host *host) | |
164 | { | |
165 | if (!host->hold_retune) | |
166 | host->retune_now = 1; | |
167 | host->hold_retune += 1; | |
168 | } | |
169 | ||
170 | void mmc_retune_release(struct mmc_host *host) | |
171 | { | |
172 | if (host->hold_retune) | |
173 | host->hold_retune -= 1; | |
174 | else | |
175 | WARN_ON(1); | |
176 | } | |
cb39f61e | 177 | EXPORT_SYMBOL(mmc_retune_release); |
dfa13ebb AH |
178 | |
179 | int mmc_retune(struct mmc_host *host) | |
180 | { | |
6376f69d | 181 | bool return_to_hs400 = false; |
dfa13ebb AH |
182 | int err; |
183 | ||
184 | if (host->retune_now) | |
185 | host->retune_now = 0; | |
186 | else | |
187 | return 0; | |
188 | ||
189 | if (!host->need_retune || host->doing_retune || !host->card) | |
190 | return 0; | |
191 | ||
192 | host->need_retune = 0; | |
193 | ||
194 | host->doing_retune = 1; | |
195 | ||
6376f69d AH |
196 | if (host->ios.timing == MMC_TIMING_MMC_HS400) { |
197 | err = mmc_hs400_to_hs200(host->card); | |
198 | if (err) | |
199 | goto out; | |
200 | ||
201 | return_to_hs400 = true; | |
6376f69d AH |
202 | } |
203 | ||
dfa13ebb | 204 | err = mmc_execute_tuning(host->card); |
6376f69d AH |
205 | if (err) |
206 | goto out; | |
dfa13ebb | 207 | |
6376f69d AH |
208 | if (return_to_hs400) |
209 | err = mmc_hs200_to_hs400(host->card); | |
210 | out: | |
dfa13ebb AH |
211 | host->doing_retune = 0; |
212 | ||
213 | return err; | |
214 | } | |
215 | ||
e99e88a9 | 216 | static void mmc_retune_timer(struct timer_list *t) |
dfa13ebb | 217 | { |
e99e88a9 | 218 | struct mmc_host *host = from_timer(host, t, retune_timer); |
dfa13ebb AH |
219 | |
220 | mmc_retune_needed(host); | |
221 | } | |
222 | ||
3561afa0 AJ |
223 | static void mmc_of_parse_timing_phase(struct device *dev, const char *prop, |
224 | struct mmc_clk_phase *phase) | |
225 | { | |
226 | int degrees[2] = {0}; | |
227 | int rc; | |
228 | ||
229 | rc = device_property_read_u32_array(dev, prop, degrees, 2); | |
230 | phase->valid = !rc; | |
231 | if (phase->valid) { | |
232 | phase->in_deg = degrees[0]; | |
233 | phase->out_deg = degrees[1]; | |
234 | } | |
235 | } | |
236 | ||
237 | void | |
238 | mmc_of_parse_clk_phase(struct mmc_host *host, struct mmc_clk_phase_map *map) | |
239 | { | |
240 | struct device *dev = host->parent; | |
241 | ||
242 | mmc_of_parse_timing_phase(dev, "clk-phase-legacy", | |
243 | &map->phase[MMC_TIMING_LEGACY]); | |
244 | mmc_of_parse_timing_phase(dev, "clk-phase-mmc-hs", | |
245 | &map->phase[MMC_TIMING_MMC_HS]); | |
246 | mmc_of_parse_timing_phase(dev, "clk-phase-sd-hs", | |
247 | &map->phase[MMC_TIMING_SD_HS]); | |
248 | mmc_of_parse_timing_phase(dev, "clk-phase-uhs-sdr12", | |
249 | &map->phase[MMC_TIMING_UHS_SDR12]); | |
250 | mmc_of_parse_timing_phase(dev, "clk-phase-uhs-sdr25", | |
251 | &map->phase[MMC_TIMING_UHS_SDR25]); | |
252 | mmc_of_parse_timing_phase(dev, "clk-phase-uhs-sdr50", | |
253 | &map->phase[MMC_TIMING_UHS_SDR50]); | |
254 | mmc_of_parse_timing_phase(dev, "clk-phase-uhs-sdr104", | |
255 | &map->phase[MMC_TIMING_UHS_SDR104]); | |
256 | mmc_of_parse_timing_phase(dev, "clk-phase-uhs-ddr50", | |
257 | &map->phase[MMC_TIMING_UHS_DDR50]); | |
258 | mmc_of_parse_timing_phase(dev, "clk-phase-mmc-ddr52", | |
259 | &map->phase[MMC_TIMING_MMC_DDR52]); | |
260 | mmc_of_parse_timing_phase(dev, "clk-phase-mmc-hs200", | |
261 | &map->phase[MMC_TIMING_MMC_HS200]); | |
262 | mmc_of_parse_timing_phase(dev, "clk-phase-mmc-hs400", | |
263 | &map->phase[MMC_TIMING_MMC_HS400]); | |
264 | } | |
265 | EXPORT_SYMBOL(mmc_of_parse_clk_phase); | |
266 | ||
6c56e7a0 | 267 | /** |
0f2c771e AS |
268 | * mmc_of_parse() - parse host's device properties |
269 | * @host: host whose properties should be parsed. | |
6c56e7a0 GL |
270 | * |
271 | * To keep the rest of the MMC subsystem unaware of whether DT has been | |
ff50df9a | 272 | * used to instantiate and configure this host instance or not, we |
6c56e7a0 GL |
273 | * parse the properties and set respective generic mmc-host flags and |
274 | * parameters. | |
275 | */ | |
ec0a7517 | 276 | int mmc_of_parse(struct mmc_host *host) |
6c56e7a0 | 277 | { |
73a47a9b | 278 | struct device *dev = host->parent; |
bfd694d5 | 279 | u32 bus_width, drv_type, cd_debounce_delay_ms; |
90614cd9 | 280 | int ret; |
6c56e7a0 | 281 | |
73a47a9b | 282 | if (!dev || !dev_fwnode(dev)) |
ec0a7517 | 283 | return 0; |
6c56e7a0 | 284 | |
6c56e7a0 | 285 | /* "bus-width" is translated to MMC_CAP_*_BIT_DATA flags */ |
73a47a9b | 286 | if (device_property_read_u32(dev, "bus-width", &bus_width) < 0) { |
6c56e7a0 GL |
287 | dev_dbg(host->parent, |
288 | "\"bus-width\" property is missing, assuming 1 bit.\n"); | |
289 | bus_width = 1; | |
290 | } | |
291 | ||
292 | switch (bus_width) { | |
293 | case 8: | |
294 | host->caps |= MMC_CAP_8_BIT_DATA; | |
df561f66 | 295 | fallthrough; /* Hosts capable of 8-bit can also do 4 bits */ |
6c56e7a0 GL |
296 | case 4: |
297 | host->caps |= MMC_CAP_4_BIT_DATA; | |
298 | break; | |
299 | case 1: | |
300 | break; | |
301 | default: | |
302 | dev_err(host->parent, | |
1c279f4f | 303 | "Invalid \"bus-width\" value %u!\n", bus_width); |
ec0a7517 | 304 | return -EINVAL; |
6c56e7a0 GL |
305 | } |
306 | ||
307 | /* f_max is obtained from the optional "max-frequency" property */ | |
73a47a9b | 308 | device_property_read_u32(dev, "max-frequency", &host->f_max); |
6c56e7a0 GL |
309 | |
310 | /* | |
311 | * Configure CD and WP pins. They are both by default active low to | |
312 | * match the SDHCI spec. If GPIOs are provided for CD and / or WP, the | |
313 | * mmc-gpio helpers are used to attach, configure and use them. If | |
314 | * polarity inversion is specified in DT, one of MMC_CAP2_CD_ACTIVE_HIGH | |
315 | * and MMC_CAP2_RO_ACTIVE_HIGH capability-2 flags is set. If the | |
316 | * "broken-cd" property is provided, the MMC_CAP_NEEDS_POLL capability | |
317 | * is set. If the "non-removable" property is found, the | |
318 | * MMC_CAP_NONREMOVABLE capability is set and no card-detection | |
319 | * configuration is performed. | |
320 | */ | |
321 | ||
322 | /* Parse Card Detection */ | |
0f7c815d | 323 | |
73a47a9b | 324 | if (device_property_read_bool(dev, "non-removable")) { |
6c56e7a0 GL |
325 | host->caps |= MMC_CAP_NONREMOVABLE; |
326 | } else { | |
0f7c815d MM |
327 | if (device_property_read_bool(dev, "cd-inverted")) |
328 | host->caps2 |= MMC_CAP2_CD_ACTIVE_HIGH; | |
6c56e7a0 | 329 | |
bfd694d5 SL |
330 | if (device_property_read_u32(dev, "cd-debounce-delay-ms", |
331 | &cd_debounce_delay_ms)) | |
332 | cd_debounce_delay_ms = 200; | |
333 | ||
73a47a9b | 334 | if (device_property_read_bool(dev, "broken-cd")) |
6c56e7a0 GL |
335 | host->caps |= MMC_CAP_NEEDS_POLL; |
336 | ||
e3e4767b | 337 | ret = mmc_gpiod_request_cd(host, "cd", 0, false, |
d0052ad9 | 338 | cd_debounce_delay_ms * 1000); |
9116752f | 339 | if (!ret) |
98e90de9 | 340 | dev_info(host->parent, "Got CD GPIO\n"); |
43934ece | 341 | else if (ret != -ENOENT && ret != -ENOSYS) |
9116752f | 342 | return ret; |
6c56e7a0 GL |
343 | } |
344 | ||
345 | /* Parse Write Protection */ | |
6c56e7a0 | 346 | |
9073d10b MM |
347 | if (device_property_read_bool(dev, "wp-inverted")) |
348 | host->caps2 |= MMC_CAP2_RO_ACTIVE_HIGH; | |
349 | ||
d0052ad9 | 350 | ret = mmc_gpiod_request_ro(host, "wp", 0, 0); |
9116752f | 351 | if (!ret) |
98e90de9 | 352 | dev_info(host->parent, "Got WP GPIO\n"); |
43934ece | 353 | else if (ret != -ENOENT && ret != -ENOSYS) |
9116752f | 354 | return ret; |
2fdb6e2d | 355 | |
73a47a9b | 356 | if (device_property_read_bool(dev, "disable-wp")) |
19f44246 LPC |
357 | host->caps2 |= MMC_CAP2_NO_WRITE_PROTECT; |
358 | ||
73a47a9b | 359 | if (device_property_read_bool(dev, "cap-sd-highspeed")) |
2fdb6e2d | 360 | host->caps |= MMC_CAP_SD_HIGHSPEED; |
73a47a9b | 361 | if (device_property_read_bool(dev, "cap-mmc-highspeed")) |
2fdb6e2d | 362 | host->caps |= MMC_CAP_MMC_HIGHSPEED; |
73a47a9b | 363 | if (device_property_read_bool(dev, "sd-uhs-sdr12")) |
b66bd0e4 | 364 | host->caps |= MMC_CAP_UHS_SDR12; |
73a47a9b | 365 | if (device_property_read_bool(dev, "sd-uhs-sdr25")) |
b66bd0e4 | 366 | host->caps |= MMC_CAP_UHS_SDR25; |
73a47a9b | 367 | if (device_property_read_bool(dev, "sd-uhs-sdr50")) |
b66bd0e4 | 368 | host->caps |= MMC_CAP_UHS_SDR50; |
73a47a9b | 369 | if (device_property_read_bool(dev, "sd-uhs-sdr104")) |
b66bd0e4 | 370 | host->caps |= MMC_CAP_UHS_SDR104; |
73a47a9b | 371 | if (device_property_read_bool(dev, "sd-uhs-ddr50")) |
b66bd0e4 | 372 | host->caps |= MMC_CAP_UHS_DDR50; |
73a47a9b | 373 | if (device_property_read_bool(dev, "cap-power-off-card")) |
2fdb6e2d | 374 | host->caps |= MMC_CAP_POWER_OFF_CARD; |
73a47a9b | 375 | if (device_property_read_bool(dev, "cap-mmc-hw-reset")) |
794f1578 | 376 | host->caps |= MMC_CAP_HW_RESET; |
73a47a9b | 377 | if (device_property_read_bool(dev, "cap-sdio-irq")) |
2fdb6e2d | 378 | host->caps |= MMC_CAP_SDIO_IRQ; |
73a47a9b | 379 | if (device_property_read_bool(dev, "full-pwr-cycle")) |
5a36d6bc | 380 | host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE; |
ec02760b YS |
381 | if (device_property_read_bool(dev, "full-pwr-cycle-in-suspend")) |
382 | host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE_IN_SUSPEND; | |
73a47a9b | 383 | if (device_property_read_bool(dev, "keep-power-in-suspend")) |
2fdb6e2d | 384 | host->pm_caps |= MMC_PM_KEEP_POWER; |
73a47a9b DW |
385 | if (device_property_read_bool(dev, "wakeup-source") || |
386 | device_property_read_bool(dev, "enable-sdio-wakeup")) /* legacy */ | |
2fdb6e2d | 387 | host->pm_caps |= MMC_PM_WAKE_SDIO_IRQ; |
73a47a9b | 388 | if (device_property_read_bool(dev, "mmc-ddr-3_3v")) |
fb00f196 | 389 | host->caps |= MMC_CAP_3_3V_DDR; |
73a47a9b | 390 | if (device_property_read_bool(dev, "mmc-ddr-1_8v")) |
c0baf848 | 391 | host->caps |= MMC_CAP_1_8V_DDR; |
73a47a9b | 392 | if (device_property_read_bool(dev, "mmc-ddr-1_2v")) |
c0baf848 | 393 | host->caps |= MMC_CAP_1_2V_DDR; |
73a47a9b | 394 | if (device_property_read_bool(dev, "mmc-hs200-1_8v")) |
321bd41d | 395 | host->caps2 |= MMC_CAP2_HS200_1_8V_SDR; |
73a47a9b | 396 | if (device_property_read_bool(dev, "mmc-hs200-1_2v")) |
321bd41d | 397 | host->caps2 |= MMC_CAP2_HS200_1_2V_SDR; |
73a47a9b | 398 | if (device_property_read_bool(dev, "mmc-hs400-1_8v")) |
c373eb48 | 399 | host->caps2 |= MMC_CAP2_HS400_1_8V | MMC_CAP2_HS200_1_8V_SDR; |
73a47a9b | 400 | if (device_property_read_bool(dev, "mmc-hs400-1_2v")) |
c373eb48 | 401 | host->caps2 |= MMC_CAP2_HS400_1_2V | MMC_CAP2_HS200_1_2V_SDR; |
73a47a9b | 402 | if (device_property_read_bool(dev, "mmc-hs400-enhanced-strobe")) |
ef29c0e2 | 403 | host->caps2 |= MMC_CAP2_HS400_ES; |
73a47a9b | 404 | if (device_property_read_bool(dev, "no-sdio")) |
6ae3e537 | 405 | host->caps2 |= MMC_CAP2_NO_SDIO; |
73a47a9b | 406 | if (device_property_read_bool(dev, "no-sd")) |
6ae3e537 | 407 | host->caps2 |= MMC_CAP2_NO_SD; |
73a47a9b | 408 | if (device_property_read_bool(dev, "no-mmc")) |
6ae3e537 | 409 | host->caps2 |= MMC_CAP2_NO_MMC; |
f722e650 LS |
410 | if (device_property_read_bool(dev, "no-mmc-hs400")) |
411 | host->caps2 &= ~(MMC_CAP2_HS400_1_8V | MMC_CAP2_HS400_1_2V | | |
412 | MMC_CAP2_HS400_ES); | |
ec0a7517 | 413 | |
6186d06c WS |
414 | /* Must be after "non-removable" check */ |
415 | if (device_property_read_u32(dev, "fixed-emmc-driver-type", &drv_type) == 0) { | |
416 | if (host->caps & MMC_CAP_NONREMOVABLE) | |
417 | host->fixed_drv_type = drv_type; | |
418 | else | |
419 | dev_err(host->parent, | |
420 | "can't use fixed driver type, media is removable\n"); | |
421 | } | |
422 | ||
73a47a9b | 423 | host->dsr_req = !device_property_read_u32(dev, "dsr", &host->dsr); |
3d705d14 SH |
424 | if (host->dsr_req && (host->dsr & ~0xffff)) { |
425 | dev_err(host->parent, | |
426 | "device tree specified broken value for DSR: 0x%x, ignoring\n", | |
427 | host->dsr); | |
428 | host->dsr_req = 0; | |
429 | } | |
430 | ||
6d796c68 SL |
431 | device_property_read_u32(dev, "post-power-on-delay-ms", |
432 | &host->ios.power_delay_ms); | |
433 | ||
3aa8793f | 434 | return mmc_pwrseq_alloc(host); |
6c56e7a0 GL |
435 | } |
436 | ||
437 | EXPORT_SYMBOL(mmc_of_parse); | |
438 | ||
9d2d2430 UH |
439 | /** |
440 | * mmc_of_parse_voltage - return mask of supported voltages | |
6dab809b | 441 | * @host: host whose properties should be parsed. |
9d2d2430 UH |
442 | * @mask: mask of voltages available for MMC/SD/SDIO |
443 | * | |
6dab809b | 444 | * Parse the "voltage-ranges" property, returning zero if it is not |
9d2d2430 UH |
445 | * found, negative errno if the voltage-range specification is invalid, |
446 | * or one if the voltage-range is specified and successfully parsed. | |
447 | */ | |
6dab809b | 448 | int mmc_of_parse_voltage(struct mmc_host *host, u32 *mask) |
9d2d2430 | 449 | { |
6dab809b AS |
450 | const char *prop = "voltage-ranges"; |
451 | struct device *dev = host->parent; | |
452 | u32 *voltage_ranges; | |
9d2d2430 | 453 | int num_ranges, i; |
6dab809b | 454 | int ret; |
9d2d2430 | 455 | |
6dab809b AS |
456 | if (!device_property_present(dev, prop)) { |
457 | dev_dbg(dev, "%s unspecified\n", prop); | |
9d2d2430 UH |
458 | return 0; |
459 | } | |
6dab809b AS |
460 | |
461 | ret = device_property_count_u32(dev, prop); | |
462 | if (ret < 0) | |
463 | return ret; | |
464 | ||
465 | num_ranges = ret / 2; | |
9d2d2430 | 466 | if (!num_ranges) { |
6dab809b | 467 | dev_err(dev, "%s empty\n", prop); |
9d2d2430 UH |
468 | return -EINVAL; |
469 | } | |
470 | ||
6dab809b AS |
471 | voltage_ranges = kcalloc(2 * num_ranges, sizeof(*voltage_ranges), GFP_KERNEL); |
472 | if (!voltage_ranges) | |
473 | return -ENOMEM; | |
474 | ||
475 | ret = device_property_read_u32_array(dev, prop, voltage_ranges, 2 * num_ranges); | |
476 | if (ret) { | |
477 | kfree(voltage_ranges); | |
478 | return ret; | |
479 | } | |
480 | ||
9d2d2430 UH |
481 | for (i = 0; i < num_ranges; i++) { |
482 | const int j = i * 2; | |
483 | u32 ocr_mask; | |
484 | ||
6dab809b AS |
485 | ocr_mask = mmc_vddrange_to_ocrmask(voltage_ranges[j + 0], |
486 | voltage_ranges[j + 1]); | |
9d2d2430 | 487 | if (!ocr_mask) { |
6dab809b AS |
488 | dev_err(dev, "range #%d in %s is invalid\n", i, prop); |
489 | kfree(voltage_ranges); | |
9d2d2430 UH |
490 | return -EINVAL; |
491 | } | |
492 | *mask |= ocr_mask; | |
493 | } | |
494 | ||
6dab809b AS |
495 | kfree(voltage_ranges); |
496 | ||
9d2d2430 UH |
497 | return 1; |
498 | } | |
499 | EXPORT_SYMBOL(mmc_of_parse_voltage); | |
500 | ||
fa2d0aa9 MS |
501 | /** |
502 | * mmc_first_nonreserved_index() - get the first index that is not reserved | |
503 | */ | |
504 | static int mmc_first_nonreserved_index(void) | |
505 | { | |
506 | int max; | |
507 | ||
508 | max = of_alias_get_highest_id("mmc"); | |
509 | if (max < 0) | |
510 | return 0; | |
511 | ||
512 | return max + 1; | |
513 | } | |
514 | ||
b93931a6 PO |
515 | /** |
516 | * mmc_alloc_host - initialise the per-host structure. | |
517 | * @extra: sizeof private data structure | |
518 | * @dev: pointer to host device model structure | |
519 | * | |
520 | * Initialise the per-host structure. | |
521 | */ | |
522 | struct mmc_host *mmc_alloc_host(int extra, struct device *dev) | |
523 | { | |
10252bae | 524 | int index; |
b93931a6 | 525 | struct mmc_host *host; |
fa2d0aa9 | 526 | int alias_id, min_idx, max_idx; |
b93931a6 | 527 | |
be760a9d | 528 | host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL); |
b93931a6 PO |
529 | if (!host) |
530 | return NULL; | |
531 | ||
d9adcc12 GL |
532 | /* scanning will be enabled when we're ready */ |
533 | host->rescan_disable = 1; | |
5674a9ba | 534 | |
fa2d0aa9 MS |
535 | alias_id = of_alias_get_id(dev->of_node, "mmc"); |
536 | if (alias_id >= 0) { | |
10252bae | 537 | index = alias_id; |
fa2d0aa9 MS |
538 | } else { |
539 | min_idx = mmc_first_nonreserved_index(); | |
540 | max_idx = 0; | |
fa2d0aa9 | 541 | |
10252bae SB |
542 | index = ida_simple_get(&mmc_host_ida, min_idx, max_idx, GFP_KERNEL); |
543 | if (index < 0) { | |
544 | kfree(host); | |
545 | return NULL; | |
546 | } | |
5674a9ba UH |
547 | } |
548 | ||
10252bae | 549 | host->index = index; |
ff3112f5 | 550 | |
d1b26863 | 551 | dev_set_name(&host->class_dev, "mmc%d", host->index); |
b52fb259 | 552 | host->ws = wakeup_source_register(NULL, dev_name(&host->class_dev)); |
ff3112f5 | 553 | |
b93931a6 PO |
554 | host->parent = dev; |
555 | host->class_dev.parent = dev; | |
556 | host->class_dev.class = &mmc_host_class; | |
557 | device_initialize(&host->class_dev); | |
ccf7bfdc | 558 | device_enable_async_suspend(&host->class_dev); |
b93931a6 | 559 | |
df8aca16 UH |
560 | if (mmc_gpio_alloc(host)) { |
561 | put_device(&host->class_dev); | |
562 | return NULL; | |
563 | } | |
04566831 | 564 | |
b93931a6 PO |
565 | spin_lock_init(&host->lock); |
566 | init_waitqueue_head(&host->wq); | |
567 | INIT_DELAYED_WORK(&host->detect, mmc_rescan); | |
1dd611a9 | 568 | INIT_WORK(&host->sdio_irq_work, sdio_irq_work); |
e99e88a9 | 569 | timer_setup(&host->retune_timer, mmc_retune_timer, 0); |
b93931a6 PO |
570 | |
571 | /* | |
572 | * By default, hosts do not support SGIO or large requests. | |
573 | * They have to set these according to their abilities. | |
574 | */ | |
a36274e0 | 575 | host->max_segs = 1; |
09cbfeaf | 576 | host->max_seg_size = PAGE_SIZE; |
b93931a6 | 577 | |
09cbfeaf | 578 | host->max_req_size = PAGE_SIZE; |
b93931a6 | 579 | host->max_blk_size = 512; |
09cbfeaf | 580 | host->max_blk_count = PAGE_SIZE / 512; |
b93931a6 | 581 | |
6186d06c | 582 | host->fixed_drv_type = -EINVAL; |
6d796c68 | 583 | host->ios.power_delay_ms = 10; |
ed54ef98 | 584 | host->ios.power_mode = MMC_POWER_UNDEFINED; |
6186d06c | 585 | |
b93931a6 PO |
586 | return host; |
587 | } | |
588 | ||
589 | EXPORT_SYMBOL(mmc_alloc_host); | |
590 | ||
80df83c2 HK |
591 | static void devm_mmc_host_release(struct device *dev, void *res) |
592 | { | |
593 | mmc_free_host(*(struct mmc_host **)res); | |
594 | } | |
595 | ||
596 | struct mmc_host *devm_mmc_alloc_host(struct device *dev, int extra) | |
597 | { | |
598 | struct mmc_host **dr, *host; | |
599 | ||
600 | dr = devres_alloc(devm_mmc_host_release, sizeof(*dr), GFP_KERNEL); | |
601 | if (!dr) | |
71d04535 | 602 | return NULL; |
80df83c2 HK |
603 | |
604 | host = mmc_alloc_host(extra, dev); | |
71d04535 | 605 | if (!host) { |
80df83c2 | 606 | devres_free(dr); |
71d04535 | 607 | return NULL; |
80df83c2 HK |
608 | } |
609 | ||
610 | *dr = host; | |
611 | devres_add(dev, dr); | |
612 | ||
613 | return host; | |
614 | } | |
615 | EXPORT_SYMBOL(devm_mmc_alloc_host); | |
616 | ||
d6c9219c UH |
617 | static int mmc_validate_host_caps(struct mmc_host *host) |
618 | { | |
23e1b8c1 UH |
619 | struct device *dev = host->parent; |
620 | u32 caps = host->caps, caps2 = host->caps2; | |
621 | ||
622 | if (caps & MMC_CAP_SDIO_IRQ && !host->ops->enable_sdio_irq) { | |
623 | dev_warn(dev, "missing ->enable_sdio_irq() ops\n"); | |
d6c9219c UH |
624 | return -EINVAL; |
625 | } | |
626 | ||
23e1b8c1 | 627 | if (caps2 & (MMC_CAP2_HS400_ES | MMC_CAP2_HS400) && |
6f34a4ee | 628 | !(caps & MMC_CAP_8_BIT_DATA) && !(caps2 & MMC_CAP2_NO_MMC)) { |
23e1b8c1 UH |
629 | dev_warn(dev, "drop HS400 support since no 8-bit bus\n"); |
630 | host->caps2 = caps2 & ~MMC_CAP2_HS400_ES & ~MMC_CAP2_HS400; | |
631 | } | |
632 | ||
d6c9219c UH |
633 | return 0; |
634 | } | |
635 | ||
b93931a6 PO |
636 | /** |
637 | * mmc_add_host - initialise host hardware | |
638 | * @host: mmc host | |
67a61c48 PO |
639 | * |
640 | * Register the host with the driver model. The host must be | |
641 | * prepared to start servicing requests before this function | |
642 | * completes. | |
b93931a6 PO |
643 | */ |
644 | int mmc_add_host(struct mmc_host *host) | |
645 | { | |
646 | int err; | |
647 | ||
d6c9219c UH |
648 | err = mmc_validate_host_caps(host); |
649 | if (err) | |
650 | return err; | |
17b759af | 651 | |
b93931a6 PO |
652 | err = device_add(&host->class_dev); |
653 | if (err) | |
654 | return err; | |
655 | ||
f317dfeb WS |
656 | led_trigger_register_simple(dev_name(&host->class_dev), &host->led); |
657 | ||
6edd8ee6 | 658 | mmc_add_host_debugfs(host); |
6edd8ee6 | 659 | |
b93931a6 | 660 | mmc_start_host(host); |
b93931a6 PO |
661 | return 0; |
662 | } | |
663 | ||
664 | EXPORT_SYMBOL(mmc_add_host); | |
665 | ||
666 | /** | |
667 | * mmc_remove_host - remove host hardware | |
668 | * @host: mmc host | |
669 | * | |
670 | * Unregister and remove all cards associated with this host, | |
67a61c48 PO |
671 | * and power down the MMC bus. No new requests will be issued |
672 | * after this function has returned. | |
b93931a6 PO |
673 | */ |
674 | void mmc_remove_host(struct mmc_host *host) | |
675 | { | |
676 | mmc_stop_host(host); | |
677 | ||
6edd8ee6 | 678 | mmc_remove_host_debugfs(host); |
6edd8ee6 | 679 | |
b93931a6 PO |
680 | device_del(&host->class_dev); |
681 | ||
77f1fd6e | 682 | led_trigger_unregister_simple(host->led); |
b93931a6 PO |
683 | } |
684 | ||
685 | EXPORT_SYMBOL(mmc_remove_host); | |
686 | ||
687 | /** | |
688 | * mmc_free_host - free the host structure | |
689 | * @host: mmc host | |
690 | * | |
691 | * Free the host once all references to it have been dropped. | |
692 | */ | |
693 | void mmc_free_host(struct mmc_host *host) | |
694 | { | |
3aa8793f | 695 | mmc_pwrseq_free(host); |
b93931a6 PO |
696 | put_device(&host->class_dev); |
697 | } | |
698 | ||
699 | EXPORT_SYMBOL(mmc_free_host); |