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>
18 #include <linux/pagemap.h>
19 #include <linux/leds.h>
20 #include <linux/slab.h>
21 #include <linux/suspend.h>
23 #include <linux/mmc/host.h>
24 #include <linux/mmc/card.h>
29 #define cls_dev_to_mmc_host(d) container_of(d, struct mmc_host, class_dev)
31 static void mmc_host_classdev_release(struct device *dev)
33 struct mmc_host *host = cls_dev_to_mmc_host(dev);
37 static struct class mmc_host_class = {
39 .dev_release = mmc_host_classdev_release,
42 int mmc_register_host_class(void)
44 return class_register(&mmc_host_class);
47 void mmc_unregister_host_class(void)
49 class_unregister(&mmc_host_class);
52 static DEFINE_IDR(mmc_host_idr);
53 static DEFINE_SPINLOCK(mmc_host_lock);
55 #ifdef CONFIG_MMC_CLKGATE
58 * Enabling clock gating will make the core call out to the host
59 * once up and once down when it performs a request or card operation
60 * intermingled in any fashion. The driver will see this through
61 * set_ios() operations with ios.clock field set to 0 to gate (disable)
62 * the block clock, and to the old frequency to enable it again.
64 static void mmc_host_clk_gate_delayed(struct mmc_host *host)
66 unsigned long tick_ns;
67 unsigned long freq = host->ios.clock;
71 pr_debug("%s: frequency set to 0 in disable function, "
72 "this means the clock is already disabled.\n",
77 * New requests may have appeared while we were scheduling,
78 * then there is no reason to delay the check before
81 spin_lock_irqsave(&host->clk_lock, flags);
84 * Delay n bus cycles (at least 8 from MMC spec) before attempting
85 * to disable the MCI block clock. The reference count may have
86 * gone up again after this delay due to rescheduling!
88 if (!host->clk_requests) {
89 spin_unlock_irqrestore(&host->clk_lock, flags);
90 tick_ns = DIV_ROUND_UP(1000000000, freq);
91 ndelay(host->clk_delay * tick_ns);
93 /* New users appeared while waiting for this work */
94 spin_unlock_irqrestore(&host->clk_lock, flags);
97 mutex_lock(&host->clk_gate_mutex);
98 spin_lock_irqsave(&host->clk_lock, flags);
99 if (!host->clk_requests) {
100 spin_unlock_irqrestore(&host->clk_lock, flags);
101 /* This will set host->ios.clock to 0 */
102 mmc_gate_clock(host);
103 spin_lock_irqsave(&host->clk_lock, flags);
104 pr_debug("%s: gated MCI clock\n", mmc_hostname(host));
106 spin_unlock_irqrestore(&host->clk_lock, flags);
107 mutex_unlock(&host->clk_gate_mutex);
111 * Internal work. Work to disable the clock at some later point.
113 static void mmc_host_clk_gate_work(struct work_struct *work)
115 struct mmc_host *host = container_of(work, struct mmc_host,
118 mmc_host_clk_gate_delayed(host);
122 * mmc_host_clk_ungate - ungate hardware MCI clocks
123 * @host: host to ungate.
125 * Makes sure the host ios.clock is restored to a non-zero value
126 * past this call. Increase clock reference count and ungate clock
127 * if we're the first user.
129 void mmc_host_clk_ungate(struct mmc_host *host)
133 mutex_lock(&host->clk_gate_mutex);
134 spin_lock_irqsave(&host->clk_lock, flags);
135 if (host->clk_gated) {
136 spin_unlock_irqrestore(&host->clk_lock, flags);
137 mmc_ungate_clock(host);
138 spin_lock_irqsave(&host->clk_lock, flags);
139 pr_debug("%s: ungated MCI clock\n", mmc_hostname(host));
141 host->clk_requests++;
142 spin_unlock_irqrestore(&host->clk_lock, flags);
143 mutex_unlock(&host->clk_gate_mutex);
147 * mmc_host_may_gate_card - check if this card may be gated
148 * @card: card to check.
150 static bool mmc_host_may_gate_card(struct mmc_card *card)
152 /* If there is no card we may gate it */
156 * Don't gate SDIO cards! These need to be clocked at all times
157 * since they may be independent systems generating interrupts
158 * and other events. The clock requests counter from the core will
159 * go down to zero since the core does not need it, but we will not
160 * gate the clock, because there is somebody out there that may still
163 if (mmc_card_sdio(card))
170 * mmc_host_clk_gate - gate off hardware MCI clocks
171 * @host: host to gate.
173 * Calls the host driver with ios.clock set to zero as often as possible
174 * in order to gate off hardware MCI clocks. Decrease clock reference
175 * count and schedule disabling of clock.
177 void mmc_host_clk_gate(struct mmc_host *host)
181 spin_lock_irqsave(&host->clk_lock, flags);
182 host->clk_requests--;
183 if (mmc_host_may_gate_card(host->card) &&
185 schedule_work(&host->clk_gate_work);
186 spin_unlock_irqrestore(&host->clk_lock, flags);
190 * mmc_host_clk_rate - get current clock frequency setting
191 * @host: host to get the clock frequency for.
193 * Returns current clock frequency regardless of gating.
195 unsigned int mmc_host_clk_rate(struct mmc_host *host)
200 spin_lock_irqsave(&host->clk_lock, flags);
202 freq = host->clk_old;
204 freq = host->ios.clock;
205 spin_unlock_irqrestore(&host->clk_lock, flags);
210 * mmc_host_clk_init - set up clock gating code
211 * @host: host with potential clock to control
213 static inline void mmc_host_clk_init(struct mmc_host *host)
215 host->clk_requests = 0;
216 /* Hold MCI clock for 8 cycles by default */
218 host->clk_gated = false;
219 INIT_WORK(&host->clk_gate_work, mmc_host_clk_gate_work);
220 spin_lock_init(&host->clk_lock);
221 mutex_init(&host->clk_gate_mutex);
225 * mmc_host_clk_exit - shut down clock gating code
226 * @host: host with potential clock to control
228 static inline void mmc_host_clk_exit(struct mmc_host *host)
231 * Wait for any outstanding gate and then make sure we're
232 * ungated before exiting.
234 if (cancel_work_sync(&host->clk_gate_work))
235 mmc_host_clk_gate_delayed(host);
237 mmc_host_clk_ungate(host);
238 /* There should be only one user now */
239 WARN_ON(host->clk_requests > 1);
244 static inline void mmc_host_clk_init(struct mmc_host *host)
248 static inline void mmc_host_clk_exit(struct mmc_host *host)
255 * mmc_alloc_host - initialise the per-host structure.
256 * @extra: sizeof private data structure
257 * @dev: pointer to host device model structure
259 * Initialise the per-host structure.
261 struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
264 struct mmc_host *host;
266 if (!idr_pre_get(&mmc_host_idr, GFP_KERNEL))
269 host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL);
273 spin_lock(&mmc_host_lock);
274 err = idr_get_new(&mmc_host_idr, host, &host->index);
275 spin_unlock(&mmc_host_lock);
279 dev_set_name(&host->class_dev, "mmc%d", host->index);
282 host->class_dev.parent = dev;
283 host->class_dev.class = &mmc_host_class;
284 device_initialize(&host->class_dev);
286 mmc_host_clk_init(host);
288 spin_lock_init(&host->lock);
289 init_waitqueue_head(&host->wq);
290 INIT_DELAYED_WORK(&host->detect, mmc_rescan);
291 INIT_DELAYED_WORK_DEFERRABLE(&host->disable, mmc_host_deeper_disable);
293 host->pm_notify.notifier_call = mmc_pm_notify;
297 * By default, hosts do not support SGIO or large requests.
298 * They have to set these according to their abilities.
301 host->max_seg_size = PAGE_CACHE_SIZE;
303 host->max_req_size = PAGE_CACHE_SIZE;
304 host->max_blk_size = 512;
305 host->max_blk_count = PAGE_CACHE_SIZE / 512;
314 EXPORT_SYMBOL(mmc_alloc_host);
317 * mmc_add_host - initialise host hardware
320 * Register the host with the driver model. The host must be
321 * prepared to start servicing requests before this function
324 int mmc_add_host(struct mmc_host *host)
328 WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) &&
329 !host->ops->enable_sdio_irq);
331 led_trigger_register_simple(dev_name(&host->class_dev), &host->led);
333 err = device_add(&host->class_dev);
337 #ifdef CONFIG_DEBUG_FS
338 mmc_add_host_debugfs(host);
341 mmc_start_host(host);
342 register_pm_notifier(&host->pm_notify);
347 EXPORT_SYMBOL(mmc_add_host);
350 * mmc_remove_host - remove host hardware
353 * Unregister and remove all cards associated with this host,
354 * and power down the MMC bus. No new requests will be issued
355 * after this function has returned.
357 void mmc_remove_host(struct mmc_host *host)
359 unregister_pm_notifier(&host->pm_notify);
362 #ifdef CONFIG_DEBUG_FS
363 mmc_remove_host_debugfs(host);
366 device_del(&host->class_dev);
368 led_trigger_unregister_simple(host->led);
370 mmc_host_clk_exit(host);
373 EXPORT_SYMBOL(mmc_remove_host);
376 * mmc_free_host - free the host structure
379 * Free the host once all references to it have been dropped.
381 void mmc_free_host(struct mmc_host *host)
383 spin_lock(&mmc_host_lock);
384 idr_remove(&mmc_host_idr, host->index);
385 spin_unlock(&mmc_host_lock);
387 put_device(&host->class_dev);
390 EXPORT_SYMBOL(mmc_free_host);