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