1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * linux/drivers/mmc/core/host.c |
4 | * |
5 | * Copyright (C) 2003 Russell King, All Rights Reserved. |
6 | * Copyright (C) 2007-2008 Pierre Ossman |
7 | * Copyright (C) 2010 Linus Walleij |
8 | * |
9 | * MMC host class device management |
10 | */ |
11 | |
12 | #include <linux/device.h> |
13 | #include <linux/err.h> |
14 | #include <linux/idr.h> |
15 | #include <linux/of.h> |
16 | #include <linux/of_gpio.h> |
17 | #include <linux/pagemap.h> |
18 | #include <linux/pm_wakeup.h> |
19 | #include <linux/export.h> |
20 | #include <linux/leds.h> |
21 | #include <linux/slab.h> |
22 | |
23 | #include <linux/mmc/host.h> |
24 | #include <linux/mmc/card.h> |
25 | #include <linux/mmc/slot-gpio.h> |
26 | |
27 | #include "core.h" |
28 | #include "crypto.h" |
29 | #include "host.h" |
30 | #include "slot-gpio.h" |
31 | #include "pwrseq.h" |
32 | #include "sdio_ops.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 | #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, delay: 0, cd_irq: 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 | |
74 | static void mmc_host_classdev_release(struct device *dev) |
75 | { |
76 | struct mmc_host *host = cls_dev_to_mmc_host(dev); |
77 | wakeup_source_unregister(ws: host->ws); |
78 | if (of_alias_get_id(np: host->parent->of_node, stem: "mmc" ) < 0) |
79 | ida_simple_remove(&mmc_host_ida, host->index); |
80 | kfree(objp: host); |
81 | } |
82 | |
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 | |
91 | static struct class mmc_host_class = { |
92 | .name = "mmc_host" , |
93 | .dev_release = mmc_host_classdev_release, |
94 | .shutdown_pre = mmc_host_classdev_shutdown, |
95 | .pm = MMC_HOST_CLASS_DEV_PM_OPS, |
96 | }; |
97 | |
98 | int mmc_register_host_class(void) |
99 | { |
100 | return class_register(class: &mmc_host_class); |
101 | } |
102 | |
103 | void mmc_unregister_host_class(void) |
104 | { |
105 | class_unregister(class: &mmc_host_class); |
106 | } |
107 | |
108 | /** |
109 | * mmc_retune_enable() - enter a transfer mode that requires retuning |
110 | * @host: host which should retune now |
111 | */ |
112 | void mmc_retune_enable(struct mmc_host *host) |
113 | { |
114 | host->can_retune = 1; |
115 | if (host->retune_period) |
116 | mod_timer(timer: &host->retune_timer, |
117 | expires: jiffies + host->retune_period * HZ); |
118 | } |
119 | |
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 | |
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 | */ |
149 | void mmc_retune_disable(struct mmc_host *host) |
150 | { |
151 | mmc_retune_unpause(host); |
152 | host->can_retune = 0; |
153 | del_timer_sync(timer: &host->retune_timer); |
154 | mmc_retune_clear(host); |
155 | } |
156 | |
157 | void mmc_retune_timer_stop(struct mmc_host *host) |
158 | { |
159 | del_timer_sync(timer: &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 | } |
177 | EXPORT_SYMBOL(mmc_retune_release); |
178 | |
179 | int mmc_retune(struct mmc_host *host) |
180 | { |
181 | bool return_to_hs400 = false; |
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 | |
196 | if (host->ios.timing == MMC_TIMING_MMC_HS400) { |
197 | err = mmc_hs400_to_hs200(card: host->card); |
198 | if (err) |
199 | goto out; |
200 | |
201 | return_to_hs400 = true; |
202 | } |
203 | |
204 | err = mmc_execute_tuning(card: host->card); |
205 | if (err) |
206 | goto out; |
207 | |
208 | if (return_to_hs400) |
209 | err = mmc_hs200_to_hs400(card: host->card); |
210 | out: |
211 | host->doing_retune = 0; |
212 | |
213 | return err; |
214 | } |
215 | |
216 | static void mmc_retune_timer(struct timer_list *t) |
217 | { |
218 | struct mmc_host *host = from_timer(host, t, retune_timer); |
219 | |
220 | mmc_retune_needed(host); |
221 | } |
222 | |
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, propname: prop, val: degrees, nval: 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, prop: "clk-phase-legacy" , |
243 | phase: &map->phase[MMC_TIMING_LEGACY]); |
244 | mmc_of_parse_timing_phase(dev, prop: "clk-phase-mmc-hs" , |
245 | phase: &map->phase[MMC_TIMING_MMC_HS]); |
246 | mmc_of_parse_timing_phase(dev, prop: "clk-phase-sd-hs" , |
247 | phase: &map->phase[MMC_TIMING_SD_HS]); |
248 | mmc_of_parse_timing_phase(dev, prop: "clk-phase-uhs-sdr12" , |
249 | phase: &map->phase[MMC_TIMING_UHS_SDR12]); |
250 | mmc_of_parse_timing_phase(dev, prop: "clk-phase-uhs-sdr25" , |
251 | phase: &map->phase[MMC_TIMING_UHS_SDR25]); |
252 | mmc_of_parse_timing_phase(dev, prop: "clk-phase-uhs-sdr50" , |
253 | phase: &map->phase[MMC_TIMING_UHS_SDR50]); |
254 | mmc_of_parse_timing_phase(dev, prop: "clk-phase-uhs-sdr104" , |
255 | phase: &map->phase[MMC_TIMING_UHS_SDR104]); |
256 | mmc_of_parse_timing_phase(dev, prop: "clk-phase-uhs-ddr50" , |
257 | phase: &map->phase[MMC_TIMING_UHS_DDR50]); |
258 | mmc_of_parse_timing_phase(dev, prop: "clk-phase-mmc-ddr52" , |
259 | phase: &map->phase[MMC_TIMING_MMC_DDR52]); |
260 | mmc_of_parse_timing_phase(dev, prop: "clk-phase-mmc-hs200" , |
261 | phase: &map->phase[MMC_TIMING_MMC_HS200]); |
262 | mmc_of_parse_timing_phase(dev, prop: "clk-phase-mmc-hs400" , |
263 | phase: &map->phase[MMC_TIMING_MMC_HS400]); |
264 | } |
265 | EXPORT_SYMBOL(mmc_of_parse_clk_phase); |
266 | |
267 | /** |
268 | * mmc_of_parse() - parse host's device properties |
269 | * @host: host whose properties should be parsed. |
270 | * |
271 | * To keep the rest of the MMC subsystem unaware of whether DT has been |
272 | * used to instantiate and configure this host instance or not, we |
273 | * parse the properties and set respective generic mmc-host flags and |
274 | * parameters. |
275 | */ |
276 | int mmc_of_parse(struct mmc_host *host) |
277 | { |
278 | struct device *dev = host->parent; |
279 | u32 bus_width, drv_type, cd_debounce_delay_ms; |
280 | int ret; |
281 | |
282 | if (!dev || !dev_fwnode(dev)) |
283 | return 0; |
284 | |
285 | /* "bus-width" is translated to MMC_CAP_*_BIT_DATA flags */ |
286 | if (device_property_read_u32(dev, propname: "bus-width" , val: &bus_width) < 0) { |
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; |
295 | fallthrough; /* Hosts capable of 8-bit can also do 4 bits */ |
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, |
303 | "Invalid \"bus-width\" value %u!\n" , bus_width); |
304 | return -EINVAL; |
305 | } |
306 | |
307 | /* f_max is obtained from the optional "max-frequency" property */ |
308 | device_property_read_u32(dev, propname: "max-frequency" , val: &host->f_max); |
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 */ |
323 | |
324 | if (device_property_read_bool(dev, propname: "non-removable" )) { |
325 | host->caps |= MMC_CAP_NONREMOVABLE; |
326 | } else { |
327 | if (device_property_read_bool(dev, propname: "cd-inverted" )) |
328 | host->caps2 |= MMC_CAP2_CD_ACTIVE_HIGH; |
329 | |
330 | if (device_property_read_u32(dev, propname: "cd-debounce-delay-ms" , |
331 | val: &cd_debounce_delay_ms)) |
332 | cd_debounce_delay_ms = 200; |
333 | |
334 | if (device_property_read_bool(dev, propname: "broken-cd" )) |
335 | host->caps |= MMC_CAP_NEEDS_POLL; |
336 | |
337 | ret = mmc_gpiod_request_cd(host, con_id: "cd" , idx: 0, override_active_level: false, |
338 | debounce: cd_debounce_delay_ms * 1000); |
339 | if (!ret) |
340 | dev_info(host->parent, "Got CD GPIO\n" ); |
341 | else if (ret != -ENOENT && ret != -ENOSYS) |
342 | return ret; |
343 | } |
344 | |
345 | /* Parse Write Protection */ |
346 | |
347 | if (device_property_read_bool(dev, propname: "wp-inverted" )) |
348 | host->caps2 |= MMC_CAP2_RO_ACTIVE_HIGH; |
349 | |
350 | ret = mmc_gpiod_request_ro(host, con_id: "wp" , idx: 0, debounce: 0); |
351 | if (!ret) |
352 | dev_info(host->parent, "Got WP GPIO\n" ); |
353 | else if (ret != -ENOENT && ret != -ENOSYS) |
354 | return ret; |
355 | |
356 | if (device_property_read_bool(dev, propname: "disable-wp" )) |
357 | host->caps2 |= MMC_CAP2_NO_WRITE_PROTECT; |
358 | |
359 | if (device_property_read_bool(dev, propname: "cap-sd-highspeed" )) |
360 | host->caps |= MMC_CAP_SD_HIGHSPEED; |
361 | if (device_property_read_bool(dev, propname: "cap-mmc-highspeed" )) |
362 | host->caps |= MMC_CAP_MMC_HIGHSPEED; |
363 | if (device_property_read_bool(dev, propname: "sd-uhs-sdr12" )) |
364 | host->caps |= MMC_CAP_UHS_SDR12; |
365 | if (device_property_read_bool(dev, propname: "sd-uhs-sdr25" )) |
366 | host->caps |= MMC_CAP_UHS_SDR25; |
367 | if (device_property_read_bool(dev, propname: "sd-uhs-sdr50" )) |
368 | host->caps |= MMC_CAP_UHS_SDR50; |
369 | if (device_property_read_bool(dev, propname: "sd-uhs-sdr104" )) |
370 | host->caps |= MMC_CAP_UHS_SDR104; |
371 | if (device_property_read_bool(dev, propname: "sd-uhs-ddr50" )) |
372 | host->caps |= MMC_CAP_UHS_DDR50; |
373 | if (device_property_read_bool(dev, propname: "cap-power-off-card" )) |
374 | host->caps |= MMC_CAP_POWER_OFF_CARD; |
375 | if (device_property_read_bool(dev, propname: "cap-mmc-hw-reset" )) |
376 | host->caps |= MMC_CAP_HW_RESET; |
377 | if (device_property_read_bool(dev, propname: "cap-sdio-irq" )) |
378 | host->caps |= MMC_CAP_SDIO_IRQ; |
379 | if (device_property_read_bool(dev, propname: "full-pwr-cycle" )) |
380 | host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE; |
381 | if (device_property_read_bool(dev, propname: "full-pwr-cycle-in-suspend" )) |
382 | host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE_IN_SUSPEND; |
383 | if (device_property_read_bool(dev, propname: "keep-power-in-suspend" )) |
384 | host->pm_caps |= MMC_PM_KEEP_POWER; |
385 | if (device_property_read_bool(dev, propname: "wakeup-source" ) || |
386 | device_property_read_bool(dev, propname: "enable-sdio-wakeup" )) /* legacy */ |
387 | host->pm_caps |= MMC_PM_WAKE_SDIO_IRQ; |
388 | if (device_property_read_bool(dev, propname: "mmc-ddr-3_3v" )) |
389 | host->caps |= MMC_CAP_3_3V_DDR; |
390 | if (device_property_read_bool(dev, propname: "mmc-ddr-1_8v" )) |
391 | host->caps |= MMC_CAP_1_8V_DDR; |
392 | if (device_property_read_bool(dev, propname: "mmc-ddr-1_2v" )) |
393 | host->caps |= MMC_CAP_1_2V_DDR; |
394 | if (device_property_read_bool(dev, propname: "mmc-hs200-1_8v" )) |
395 | host->caps2 |= MMC_CAP2_HS200_1_8V_SDR; |
396 | if (device_property_read_bool(dev, propname: "mmc-hs200-1_2v" )) |
397 | host->caps2 |= MMC_CAP2_HS200_1_2V_SDR; |
398 | if (device_property_read_bool(dev, propname: "mmc-hs400-1_8v" )) |
399 | host->caps2 |= MMC_CAP2_HS400_1_8V | MMC_CAP2_HS200_1_8V_SDR; |
400 | if (device_property_read_bool(dev, propname: "mmc-hs400-1_2v" )) |
401 | host->caps2 |= MMC_CAP2_HS400_1_2V | MMC_CAP2_HS200_1_2V_SDR; |
402 | if (device_property_read_bool(dev, propname: "mmc-hs400-enhanced-strobe" )) |
403 | host->caps2 |= MMC_CAP2_HS400_ES; |
404 | if (device_property_read_bool(dev, propname: "no-sdio" )) |
405 | host->caps2 |= MMC_CAP2_NO_SDIO; |
406 | if (device_property_read_bool(dev, propname: "no-sd" )) |
407 | host->caps2 |= MMC_CAP2_NO_SD; |
408 | if (device_property_read_bool(dev, propname: "no-mmc" )) |
409 | host->caps2 |= MMC_CAP2_NO_MMC; |
410 | if (device_property_read_bool(dev, propname: "no-mmc-hs400" )) |
411 | host->caps2 &= ~(MMC_CAP2_HS400_1_8V | MMC_CAP2_HS400_1_2V | |
412 | MMC_CAP2_HS400_ES); |
413 | |
414 | /* Must be after "non-removable" check */ |
415 | if (device_property_read_u32(dev, propname: "fixed-emmc-driver-type" , val: &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 | |
423 | host->dsr_req = !device_property_read_u32(dev, propname: "dsr" , val: &host->dsr); |
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 | |
431 | device_property_read_u32(dev, propname: "post-power-on-delay-ms" , |
432 | val: &host->ios.power_delay_ms); |
433 | |
434 | return mmc_pwrseq_alloc(host); |
435 | } |
436 | |
437 | EXPORT_SYMBOL(mmc_of_parse); |
438 | |
439 | /** |
440 | * mmc_of_parse_voltage - return mask of supported voltages |
441 | * @host: host whose properties should be parsed. |
442 | * @mask: mask of voltages available for MMC/SD/SDIO |
443 | * |
444 | * Parse the "voltage-ranges" property, returning zero if it is not |
445 | * found, negative errno if the voltage-range specification is invalid, |
446 | * or one if the voltage-range is specified and successfully parsed. |
447 | */ |
448 | int mmc_of_parse_voltage(struct mmc_host *host, u32 *mask) |
449 | { |
450 | const char *prop = "voltage-ranges" ; |
451 | struct device *dev = host->parent; |
452 | u32 *voltage_ranges; |
453 | int num_ranges, i; |
454 | int ret; |
455 | |
456 | if (!device_property_present(dev, propname: prop)) { |
457 | dev_dbg(dev, "%s unspecified\n" , prop); |
458 | return 0; |
459 | } |
460 | |
461 | ret = device_property_count_u32(dev, propname: prop); |
462 | if (ret < 0) |
463 | return ret; |
464 | |
465 | num_ranges = ret / 2; |
466 | if (!num_ranges) { |
467 | dev_err(dev, "%s empty\n" , prop); |
468 | return -EINVAL; |
469 | } |
470 | |
471 | voltage_ranges = kcalloc(n: 2 * num_ranges, size: sizeof(*voltage_ranges), GFP_KERNEL); |
472 | if (!voltage_ranges) |
473 | return -ENOMEM; |
474 | |
475 | ret = device_property_read_u32_array(dev, propname: prop, val: voltage_ranges, nval: 2 * num_ranges); |
476 | if (ret) { |
477 | kfree(objp: voltage_ranges); |
478 | return ret; |
479 | } |
480 | |
481 | for (i = 0; i < num_ranges; i++) { |
482 | const int j = i * 2; |
483 | u32 ocr_mask; |
484 | |
485 | ocr_mask = mmc_vddrange_to_ocrmask(vdd_min: voltage_ranges[j + 0], |
486 | vdd_max: voltage_ranges[j + 1]); |
487 | if (!ocr_mask) { |
488 | dev_err(dev, "range #%d in %s is invalid\n" , i, prop); |
489 | kfree(objp: voltage_ranges); |
490 | return -EINVAL; |
491 | } |
492 | *mask |= ocr_mask; |
493 | } |
494 | |
495 | kfree(objp: voltage_ranges); |
496 | |
497 | return 1; |
498 | } |
499 | EXPORT_SYMBOL(mmc_of_parse_voltage); |
500 | |
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(stem: "mmc" ); |
509 | if (max < 0) |
510 | return 0; |
511 | |
512 | return max + 1; |
513 | } |
514 | |
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 , struct device *dev) |
523 | { |
524 | int index; |
525 | struct mmc_host *host; |
526 | int alias_id, min_idx, max_idx; |
527 | |
528 | host = kzalloc(size: sizeof(struct mmc_host) + extra, GFP_KERNEL); |
529 | if (!host) |
530 | return NULL; |
531 | |
532 | /* scanning will be enabled when we're ready */ |
533 | host->rescan_disable = 1; |
534 | |
535 | alias_id = of_alias_get_id(np: dev->of_node, stem: "mmc" ); |
536 | if (alias_id >= 0) { |
537 | index = alias_id; |
538 | } else { |
539 | min_idx = mmc_first_nonreserved_index(); |
540 | max_idx = 0; |
541 | |
542 | index = ida_simple_get(&mmc_host_ida, min_idx, max_idx, GFP_KERNEL); |
543 | if (index < 0) { |
544 | kfree(objp: host); |
545 | return NULL; |
546 | } |
547 | } |
548 | |
549 | host->index = index; |
550 | |
551 | dev_set_name(dev: &host->class_dev, name: "mmc%d" , host->index); |
552 | host->ws = wakeup_source_register(NULL, name: dev_name(dev: &host->class_dev)); |
553 | |
554 | host->parent = dev; |
555 | host->class_dev.parent = dev; |
556 | host->class_dev.class = &mmc_host_class; |
557 | device_initialize(dev: &host->class_dev); |
558 | device_enable_async_suspend(dev: &host->class_dev); |
559 | |
560 | if (mmc_gpio_alloc(host)) { |
561 | put_device(dev: &host->class_dev); |
562 | return NULL; |
563 | } |
564 | |
565 | spin_lock_init(&host->lock); |
566 | init_waitqueue_head(&host->wq); |
567 | INIT_DELAYED_WORK(&host->detect, mmc_rescan); |
568 | INIT_WORK(&host->sdio_irq_work, sdio_irq_work); |
569 | timer_setup(&host->retune_timer, mmc_retune_timer, 0); |
570 | |
571 | /* |
572 | * By default, hosts do not support SGIO or large requests. |
573 | * They have to set these according to their abilities. |
574 | */ |
575 | host->max_segs = 1; |
576 | host->max_seg_size = PAGE_SIZE; |
577 | |
578 | host->max_req_size = PAGE_SIZE; |
579 | host->max_blk_size = 512; |
580 | host->max_blk_count = PAGE_SIZE / 512; |
581 | |
582 | host->fixed_drv_type = -EINVAL; |
583 | host->ios.power_delay_ms = 10; |
584 | host->ios.power_mode = MMC_POWER_UNDEFINED; |
585 | |
586 | return host; |
587 | } |
588 | |
589 | EXPORT_SYMBOL(mmc_alloc_host); |
590 | |
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 ) |
597 | { |
598 | struct mmc_host **dr, *host; |
599 | |
600 | dr = devres_alloc(devm_mmc_host_release, sizeof(*dr), GFP_KERNEL); |
601 | if (!dr) |
602 | return NULL; |
603 | |
604 | host = mmc_alloc_host(extra, dev); |
605 | if (!host) { |
606 | devres_free(res: dr); |
607 | return NULL; |
608 | } |
609 | |
610 | *dr = host; |
611 | devres_add(dev, res: dr); |
612 | |
613 | return host; |
614 | } |
615 | EXPORT_SYMBOL(devm_mmc_alloc_host); |
616 | |
617 | static int mmc_validate_host_caps(struct mmc_host *host) |
618 | { |
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" ); |
624 | return -EINVAL; |
625 | } |
626 | |
627 | if (caps2 & (MMC_CAP2_HS400_ES | MMC_CAP2_HS400) && |
628 | !(caps & MMC_CAP_8_BIT_DATA) && !(caps2 & MMC_CAP2_NO_MMC)) { |
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 | |
633 | return 0; |
634 | } |
635 | |
636 | /** |
637 | * mmc_add_host - initialise host hardware |
638 | * @host: mmc host |
639 | * |
640 | * Register the host with the driver model. The host must be |
641 | * prepared to start servicing requests before this function |
642 | * completes. |
643 | */ |
644 | int mmc_add_host(struct mmc_host *host) |
645 | { |
646 | int err; |
647 | |
648 | err = mmc_validate_host_caps(host); |
649 | if (err) |
650 | return err; |
651 | |
652 | err = device_add(dev: &host->class_dev); |
653 | if (err) |
654 | return err; |
655 | |
656 | led_trigger_register_simple(name: dev_name(dev: &host->class_dev), trigger: &host->led); |
657 | |
658 | mmc_add_host_debugfs(host); |
659 | |
660 | mmc_start_host(host); |
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, |
671 | * and power down the MMC bus. No new requests will be issued |
672 | * after this function has returned. |
673 | */ |
674 | void mmc_remove_host(struct mmc_host *host) |
675 | { |
676 | mmc_stop_host(host); |
677 | |
678 | mmc_remove_host_debugfs(host); |
679 | |
680 | device_del(dev: &host->class_dev); |
681 | |
682 | led_trigger_unregister_simple(trigger: host->led); |
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 | { |
695 | mmc_pwrseq_free(host); |
696 | put_device(dev: &host->class_dev); |
697 | } |
698 | |
699 | EXPORT_SYMBOL(mmc_free_host); |
700 | |