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
mmc_host_classdev_release(struct device * dev)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
mmc_register_host_class(void)51 int mmc_register_host_class(void)
52 {
53 return class_register(&mmc_host_class);
54 }
55
mmc_unregister_host_class(void)56 void mmc_unregister_host_class(void)
57 {
58 class_unregister(&mmc_host_class);
59 }
60
mmc_retune_enable(struct mmc_host * host)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 */
mmc_retune_pause(struct mmc_host * host)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
mmc_retune_unpause(struct mmc_host * host)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
mmc_retune_disable(struct mmc_host * host)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
mmc_retune_timer_stop(struct mmc_host * host)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
mmc_retune_hold(struct mmc_host * host)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
mmc_retune_hold_now(struct mmc_host * host)114 void mmc_retune_hold_now(struct mmc_host *host)
115 {
116 host->retune_now = 0;
117 host->hold_retune += 1;
118 }
119
mmc_retune_release(struct mmc_host * host)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
mmc_retune(struct mmc_host * host)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
mmc_retune_timer(unsigned long data)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 */
mmc_of_parse(struct mmc_host * host)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 */
mmc_alloc_host(int extra,struct device * dev)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 return NULL;
380 }
381
382 spin_lock_init(&host->lock);
383 init_waitqueue_head(&host->wq);
384 INIT_DELAYED_WORK(&host->detect, mmc_rescan);
385 INIT_DELAYED_WORK(&host->sdio_irq_work, sdio_irq_work);
386 setup_timer(&host->retune_timer, mmc_retune_timer, (unsigned long)host);
387
388 /*
389 * By default, hosts do not support SGIO or large requests.
390 * They have to set these according to their abilities.
391 */
392 host->max_segs = 1;
393 host->max_seg_size = PAGE_SIZE;
394
395 host->max_req_size = PAGE_SIZE;
396 host->max_blk_size = 512;
397 host->max_blk_count = PAGE_SIZE / 512;
398
399 return host;
400 }
401
402 EXPORT_SYMBOL(mmc_alloc_host);
403
404 /**
405 * mmc_add_host - initialise host hardware
406 * @host: mmc host
407 *
408 * Register the host with the driver model. The host must be
409 * prepared to start servicing requests before this function
410 * completes.
411 */
mmc_add_host(struct mmc_host * host)412 int mmc_add_host(struct mmc_host *host)
413 {
414 int err;
415
416 WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) &&
417 !host->ops->enable_sdio_irq);
418
419 err = device_add(&host->class_dev);
420 if (err)
421 return err;
422
423 led_trigger_register_simple(dev_name(&host->class_dev), &host->led);
424
425 #ifdef CONFIG_DEBUG_FS
426 mmc_add_host_debugfs(host);
427 #endif
428
429 mmc_start_host(host);
430 if (!(host->pm_flags & MMC_PM_IGNORE_PM_NOTIFY))
431 mmc_register_pm_notifier(host);
432
433 return 0;
434 }
435
436 EXPORT_SYMBOL(mmc_add_host);
437
438 /**
439 * mmc_remove_host - remove host hardware
440 * @host: mmc host
441 *
442 * Unregister and remove all cards associated with this host,
443 * and power down the MMC bus. No new requests will be issued
444 * after this function has returned.
445 */
mmc_remove_host(struct mmc_host * host)446 void mmc_remove_host(struct mmc_host *host)
447 {
448 if (!(host->pm_flags & MMC_PM_IGNORE_PM_NOTIFY))
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 */
mmc_free_host(struct mmc_host * host)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