2 * linux/drivers/mmc/core/host.c
4 * Copyright (C) 2003 Russell King, All Rights Reserved.
5 * Copyright (C) 2007-2008 Pierre Ossman
6 * Copyright (C) 2010 Linus Walleij
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.
12 * MMC host class device management
15 #include <linux/device.h>
16 #include <linux/err.h>
17 #include <linux/idr.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>
26 #include <linux/mmc/host.h>
27 #include <linux/mmc/card.h>
28 #include <linux/mmc/slot-gpio.h>
33 #define cls_dev_to_mmc_host(d) container_of(d, struct mmc_host, class_dev)
35 static DEFINE_IDR(mmc_host_idr
);
36 static DEFINE_SPINLOCK(mmc_host_lock
);
38 static void mmc_host_classdev_release(struct device
*dev
)
40 struct mmc_host
*host
= cls_dev_to_mmc_host(dev
);
41 mutex_destroy(&host
->slot
.lock
);
42 spin_lock(&mmc_host_lock
);
43 idr_remove(&mmc_host_idr
, host
->index
);
44 spin_unlock(&mmc_host_lock
);
48 static struct class mmc_host_class
= {
50 .dev_release
= mmc_host_classdev_release
,
53 int mmc_register_host_class(void)
55 return class_register(&mmc_host_class
);
58 void mmc_unregister_host_class(void)
60 class_unregister(&mmc_host_class
);
63 #ifdef CONFIG_MMC_CLKGATE
64 static ssize_t
clkgate_delay_show(struct device
*dev
,
65 struct device_attribute
*attr
, char *buf
)
67 struct mmc_host
*host
= cls_dev_to_mmc_host(dev
);
68 return snprintf(buf
, PAGE_SIZE
, "%lu\n", host
->clkgate_delay
);
71 static ssize_t
clkgate_delay_store(struct device
*dev
,
72 struct device_attribute
*attr
, const char *buf
, size_t count
)
74 struct mmc_host
*host
= cls_dev_to_mmc_host(dev
);
75 unsigned long flags
, value
;
77 if (kstrtoul(buf
, 0, &value
))
80 spin_lock_irqsave(&host
->clk_lock
, flags
);
81 host
->clkgate_delay
= value
;
82 spin_unlock_irqrestore(&host
->clk_lock
, flags
);
87 * Enabling clock gating will make the core call out to the host
88 * once up and once down when it performs a request or card operation
89 * intermingled in any fashion. The driver will see this through
90 * set_ios() operations with ios.clock field set to 0 to gate (disable)
91 * the block clock, and to the old frequency to enable it again.
93 static void mmc_host_clk_gate_delayed(struct mmc_host
*host
)
95 unsigned long tick_ns
;
96 unsigned long freq
= host
->ios
.clock
;
100 pr_debug("%s: frequency set to 0 in disable function, "
101 "this means the clock is already disabled.\n",
106 * New requests may have appeared while we were scheduling,
107 * then there is no reason to delay the check before
110 spin_lock_irqsave(&host
->clk_lock
, flags
);
113 * Delay n bus cycles (at least 8 from MMC spec) before attempting
114 * to disable the MCI block clock. The reference count may have
115 * gone up again after this delay due to rescheduling!
117 if (!host
->clk_requests
) {
118 spin_unlock_irqrestore(&host
->clk_lock
, flags
);
119 tick_ns
= DIV_ROUND_UP(1000000000, freq
);
120 ndelay(host
->clk_delay
* tick_ns
);
122 /* New users appeared while waiting for this work */
123 spin_unlock_irqrestore(&host
->clk_lock
, flags
);
126 mutex_lock(&host
->clk_gate_mutex
);
127 spin_lock_irqsave(&host
->clk_lock
, flags
);
128 if (!host
->clk_requests
) {
129 spin_unlock_irqrestore(&host
->clk_lock
, flags
);
130 /* This will set host->ios.clock to 0 */
131 mmc_gate_clock(host
);
132 spin_lock_irqsave(&host
->clk_lock
, flags
);
133 pr_debug("%s: gated MCI clock\n", mmc_hostname(host
));
135 spin_unlock_irqrestore(&host
->clk_lock
, flags
);
136 mutex_unlock(&host
->clk_gate_mutex
);
140 * Internal work. Work to disable the clock at some later point.
142 static void mmc_host_clk_gate_work(struct work_struct
*work
)
144 struct mmc_host
*host
= container_of(work
, struct mmc_host
,
147 mmc_host_clk_gate_delayed(host
);
151 * mmc_host_clk_hold - ungate hardware MCI clocks
152 * @host: host to ungate.
154 * Makes sure the host ios.clock is restored to a non-zero value
155 * past this call. Increase clock reference count and ungate clock
156 * if we're the first user.
158 void mmc_host_clk_hold(struct mmc_host
*host
)
162 /* cancel any clock gating work scheduled by mmc_host_clk_release() */
163 cancel_delayed_work_sync(&host
->clk_gate_work
);
164 mutex_lock(&host
->clk_gate_mutex
);
165 spin_lock_irqsave(&host
->clk_lock
, flags
);
166 if (host
->clk_gated
) {
167 spin_unlock_irqrestore(&host
->clk_lock
, flags
);
168 mmc_ungate_clock(host
);
169 spin_lock_irqsave(&host
->clk_lock
, flags
);
170 pr_debug("%s: ungated MCI clock\n", mmc_hostname(host
));
172 host
->clk_requests
++;
173 spin_unlock_irqrestore(&host
->clk_lock
, flags
);
174 mutex_unlock(&host
->clk_gate_mutex
);
178 * mmc_host_may_gate_card - check if this card may be gated
179 * @card: card to check.
181 static bool mmc_host_may_gate_card(struct mmc_card
*card
)
183 /* If there is no card we may gate it */
187 * Don't gate SDIO cards! These need to be clocked at all times
188 * since they may be independent systems generating interrupts
189 * and other events. The clock requests counter from the core will
190 * go down to zero since the core does not need it, but we will not
191 * gate the clock, because there is somebody out there that may still
194 return !(card
->quirks
& MMC_QUIRK_BROKEN_CLK_GATING
);
198 * mmc_host_clk_release - gate off hardware MCI clocks
199 * @host: host to gate.
201 * Calls the host driver with ios.clock set to zero as often as possible
202 * in order to gate off hardware MCI clocks. Decrease clock reference
203 * count and schedule disabling of clock.
205 void mmc_host_clk_release(struct mmc_host
*host
)
209 spin_lock_irqsave(&host
->clk_lock
, flags
);
210 host
->clk_requests
--;
211 if (mmc_host_may_gate_card(host
->card
) &&
213 schedule_delayed_work(&host
->clk_gate_work
,
214 msecs_to_jiffies(host
->clkgate_delay
));
215 spin_unlock_irqrestore(&host
->clk_lock
, flags
);
219 * mmc_host_clk_rate - get current clock frequency setting
220 * @host: host to get the clock frequency for.
222 * Returns current clock frequency regardless of gating.
224 unsigned int mmc_host_clk_rate(struct mmc_host
*host
)
229 spin_lock_irqsave(&host
->clk_lock
, flags
);
231 freq
= host
->clk_old
;
233 freq
= host
->ios
.clock
;
234 spin_unlock_irqrestore(&host
->clk_lock
, flags
);
239 * mmc_host_clk_init - set up clock gating code
240 * @host: host with potential clock to control
242 static inline void mmc_host_clk_init(struct mmc_host
*host
)
244 host
->clk_requests
= 0;
245 /* Hold MCI clock for 8 cycles by default */
248 * Default clock gating delay is 0ms to avoid wasting power.
249 * This value can be tuned by writing into sysfs entry.
251 host
->clkgate_delay
= 0;
252 host
->clk_gated
= false;
253 INIT_DELAYED_WORK(&host
->clk_gate_work
, mmc_host_clk_gate_work
);
254 spin_lock_init(&host
->clk_lock
);
255 mutex_init(&host
->clk_gate_mutex
);
259 * mmc_host_clk_exit - shut down clock gating code
260 * @host: host with potential clock to control
262 static inline void mmc_host_clk_exit(struct mmc_host
*host
)
265 * Wait for any outstanding gate and then make sure we're
266 * ungated before exiting.
268 if (cancel_delayed_work_sync(&host
->clk_gate_work
))
269 mmc_host_clk_gate_delayed(host
);
271 mmc_host_clk_hold(host
);
272 /* There should be only one user now */
273 WARN_ON(host
->clk_requests
> 1);
276 static inline void mmc_host_clk_sysfs_init(struct mmc_host
*host
)
278 host
->clkgate_delay_attr
.show
= clkgate_delay_show
;
279 host
->clkgate_delay_attr
.store
= clkgate_delay_store
;
280 sysfs_attr_init(&host
->clkgate_delay_attr
.attr
);
281 host
->clkgate_delay_attr
.attr
.name
= "clkgate_delay";
282 host
->clkgate_delay_attr
.attr
.mode
= S_IRUGO
| S_IWUSR
;
283 if (device_create_file(&host
->class_dev
, &host
->clkgate_delay_attr
))
284 pr_err("%s: Failed to create clkgate_delay sysfs entry\n",
289 static inline void mmc_host_clk_init(struct mmc_host
*host
)
293 static inline void mmc_host_clk_exit(struct mmc_host
*host
)
297 static inline void mmc_host_clk_sysfs_init(struct mmc_host
*host
)
304 * mmc_of_parse() - parse host's device-tree node
305 * @host: host whose node should be parsed.
307 * To keep the rest of the MMC subsystem unaware of whether DT has been
308 * used to to instantiate and configure this host instance or not, we
309 * parse the properties and set respective generic mmc-host flags and
312 int mmc_of_parse(struct mmc_host
*host
)
314 struct device_node
*np
;
317 bool cd_cap_invert
, cd_gpio_invert
= false;
318 bool ro_cap_invert
, ro_gpio_invert
= false;
320 if (!host
->parent
|| !host
->parent
->of_node
)
323 np
= host
->parent
->of_node
;
325 /* "bus-width" is translated to MMC_CAP_*_BIT_DATA flags */
326 if (of_property_read_u32(np
, "bus-width", &bus_width
) < 0) {
327 dev_dbg(host
->parent
,
328 "\"bus-width\" property is missing, assuming 1 bit.\n");
334 host
->caps
|= MMC_CAP_8_BIT_DATA
;
335 /* Hosts capable of 8-bit transfers can also do 4 bits */
337 host
->caps
|= MMC_CAP_4_BIT_DATA
;
342 dev_err(host
->parent
,
343 "Invalid \"bus-width\" value %u!\n", bus_width
);
347 /* f_max is obtained from the optional "max-frequency" property */
348 of_property_read_u32(np
, "max-frequency", &host
->f_max
);
351 * Configure CD and WP pins. They are both by default active low to
352 * match the SDHCI spec. If GPIOs are provided for CD and / or WP, the
353 * mmc-gpio helpers are used to attach, configure and use them. If
354 * polarity inversion is specified in DT, one of MMC_CAP2_CD_ACTIVE_HIGH
355 * and MMC_CAP2_RO_ACTIVE_HIGH capability-2 flags is set. If the
356 * "broken-cd" property is provided, the MMC_CAP_NEEDS_POLL capability
357 * is set. If the "non-removable" property is found, the
358 * MMC_CAP_NONREMOVABLE capability is set and no card-detection
359 * configuration is performed.
362 /* Parse Card Detection */
363 if (of_find_property(np
, "non-removable", &len
)) {
364 host
->caps
|= MMC_CAP_NONREMOVABLE
;
366 cd_cap_invert
= of_property_read_bool(np
, "cd-inverted");
368 if (of_find_property(np
, "broken-cd", &len
))
369 host
->caps
|= MMC_CAP_NEEDS_POLL
;
371 ret
= mmc_gpiod_request_cd(host
, "cd", 0, true,
374 dev_info(host
->parent
, "Got CD GPIO\n");
375 else if (ret
!= -ENOENT
)
379 * There are two ways to flag that the CD line is inverted:
380 * through the cd-inverted flag and by the GPIO line itself
381 * being inverted from the GPIO subsystem. This is a leftover
382 * from the times when the GPIO subsystem did not make it
383 * possible to flag a line as inverted.
385 * If the capability on the host AND the GPIO line are
386 * both inverted, the end result is that the CD line is
389 if (cd_cap_invert
^ cd_gpio_invert
)
390 host
->caps2
|= MMC_CAP2_CD_ACTIVE_HIGH
;
393 /* Parse Write Protection */
394 ro_cap_invert
= of_property_read_bool(np
, "wp-inverted");
396 ret
= mmc_gpiod_request_ro(host
, "wp", 0, false, 0, &ro_gpio_invert
);
398 dev_info(host
->parent
, "Got WP GPIO\n");
399 else if (ret
!= -ENOENT
)
402 /* See the comment on CD inversion above */
403 if (ro_cap_invert
^ ro_gpio_invert
)
404 host
->caps2
|= MMC_CAP2_RO_ACTIVE_HIGH
;
406 if (of_find_property(np
, "cap-sd-highspeed", &len
))
407 host
->caps
|= MMC_CAP_SD_HIGHSPEED
;
408 if (of_find_property(np
, "cap-mmc-highspeed", &len
))
409 host
->caps
|= MMC_CAP_MMC_HIGHSPEED
;
410 if (of_find_property(np
, "sd-uhs-sdr12", &len
))
411 host
->caps
|= MMC_CAP_UHS_SDR12
;
412 if (of_find_property(np
, "sd-uhs-sdr25", &len
))
413 host
->caps
|= MMC_CAP_UHS_SDR25
;
414 if (of_find_property(np
, "sd-uhs-sdr50", &len
))
415 host
->caps
|= MMC_CAP_UHS_SDR50
;
416 if (of_find_property(np
, "sd-uhs-sdr104", &len
))
417 host
->caps
|= MMC_CAP_UHS_SDR104
;
418 if (of_find_property(np
, "sd-uhs-ddr50", &len
))
419 host
->caps
|= MMC_CAP_UHS_DDR50
;
420 if (of_find_property(np
, "cap-power-off-card", &len
))
421 host
->caps
|= MMC_CAP_POWER_OFF_CARD
;
422 if (of_find_property(np
, "cap-sdio-irq", &len
))
423 host
->caps
|= MMC_CAP_SDIO_IRQ
;
424 if (of_find_property(np
, "full-pwr-cycle", &len
))
425 host
->caps2
|= MMC_CAP2_FULL_PWR_CYCLE
;
426 if (of_find_property(np
, "keep-power-in-suspend", &len
))
427 host
->pm_caps
|= MMC_PM_KEEP_POWER
;
428 if (of_find_property(np
, "enable-sdio-wakeup", &len
))
429 host
->pm_caps
|= MMC_PM_WAKE_SDIO_IRQ
;
430 if (of_find_property(np
, "mmc-ddr-1_8v", &len
))
431 host
->caps
|= MMC_CAP_1_8V_DDR
;
432 if (of_find_property(np
, "mmc-ddr-1_2v", &len
))
433 host
->caps
|= MMC_CAP_1_2V_DDR
;
434 if (of_find_property(np
, "mmc-hs200-1_8v", &len
))
435 host
->caps2
|= MMC_CAP2_HS200_1_8V_SDR
;
436 if (of_find_property(np
, "mmc-hs200-1_2v", &len
))
437 host
->caps2
|= MMC_CAP2_HS200_1_2V_SDR
;
438 if (of_find_property(np
, "mmc-hs400-1_8v", &len
))
439 host
->caps2
|= MMC_CAP2_HS400_1_8V
| MMC_CAP2_HS200_1_8V_SDR
;
440 if (of_find_property(np
, "mmc-hs400-1_2v", &len
))
441 host
->caps2
|= MMC_CAP2_HS400_1_2V
| MMC_CAP2_HS200_1_2V_SDR
;
443 host
->dsr_req
= !of_property_read_u32(np
, "dsr", &host
->dsr
);
444 if (host
->dsr_req
&& (host
->dsr
& ~0xffff)) {
445 dev_err(host
->parent
,
446 "device tree specified broken value for DSR: 0x%x, ignoring\n",
454 EXPORT_SYMBOL(mmc_of_parse
);
457 * mmc_alloc_host - initialise the per-host structure.
458 * @extra: sizeof private data structure
459 * @dev: pointer to host device model structure
461 * Initialise the per-host structure.
463 struct mmc_host
*mmc_alloc_host(int extra
, struct device
*dev
)
466 struct mmc_host
*host
;
468 host
= kzalloc(sizeof(struct mmc_host
) + extra
, GFP_KERNEL
);
472 /* scanning will be enabled when we're ready */
473 host
->rescan_disable
= 1;
474 idr_preload(GFP_KERNEL
);
475 spin_lock(&mmc_host_lock
);
476 err
= idr_alloc(&mmc_host_idr
, host
, 0, 0, GFP_NOWAIT
);
479 spin_unlock(&mmc_host_lock
);
484 dev_set_name(&host
->class_dev
, "mmc%d", host
->index
);
487 host
->class_dev
.parent
= dev
;
488 host
->class_dev
.class = &mmc_host_class
;
489 device_initialize(&host
->class_dev
);
491 mmc_host_clk_init(host
);
493 mutex_init(&host
->slot
.lock
);
494 host
->slot
.cd_irq
= -EINVAL
;
496 spin_lock_init(&host
->lock
);
497 init_waitqueue_head(&host
->wq
);
498 INIT_DELAYED_WORK(&host
->detect
, mmc_rescan
);
500 host
->pm_notify
.notifier_call
= mmc_pm_notify
;
504 * By default, hosts do not support SGIO or large requests.
505 * They have to set these according to their abilities.
508 host
->max_seg_size
= PAGE_CACHE_SIZE
;
510 host
->max_req_size
= PAGE_CACHE_SIZE
;
511 host
->max_blk_size
= 512;
512 host
->max_blk_count
= PAGE_CACHE_SIZE
/ 512;
521 EXPORT_SYMBOL(mmc_alloc_host
);
524 * mmc_add_host - initialise host hardware
527 * Register the host with the driver model. The host must be
528 * prepared to start servicing requests before this function
531 int mmc_add_host(struct mmc_host
*host
)
535 WARN_ON((host
->caps
& MMC_CAP_SDIO_IRQ
) &&
536 !host
->ops
->enable_sdio_irq
);
538 err
= device_add(&host
->class_dev
);
542 led_trigger_register_simple(dev_name(&host
->class_dev
), &host
->led
);
544 #ifdef CONFIG_DEBUG_FS
545 mmc_add_host_debugfs(host
);
547 mmc_host_clk_sysfs_init(host
);
549 mmc_start_host(host
);
550 register_pm_notifier(&host
->pm_notify
);
555 EXPORT_SYMBOL(mmc_add_host
);
558 * mmc_remove_host - remove host hardware
561 * Unregister and remove all cards associated with this host,
562 * and power down the MMC bus. No new requests will be issued
563 * after this function has returned.
565 void mmc_remove_host(struct mmc_host
*host
)
567 unregister_pm_notifier(&host
->pm_notify
);
570 #ifdef CONFIG_DEBUG_FS
571 mmc_remove_host_debugfs(host
);
574 device_del(&host
->class_dev
);
576 led_trigger_unregister_simple(host
->led
);
578 mmc_host_clk_exit(host
);
581 EXPORT_SYMBOL(mmc_remove_host
);
584 * mmc_free_host - free the host structure
587 * Free the host once all references to it have been dropped.
589 void mmc_free_host(struct mmc_host
*host
)
591 put_device(&host
->class_dev
);
594 EXPORT_SYMBOL(mmc_free_host
);