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/export.h>
20 #include <linux/leds.h>
21 #include <linux/slab.h>
22 #include <linux/suspend.h>
24 #include <linux/mmc/host.h>
25 #include <linux/mmc/card.h>
30 #define cls_dev_to_mmc_host(d) container_of(d, struct mmc_host, class_dev)
32 static void mmc_host_classdev_release(struct device
*dev
)
34 struct mmc_host
*host
= cls_dev_to_mmc_host(dev
);
38 static struct class mmc_host_class
= {
40 .dev_release
= mmc_host_classdev_release
,
43 int mmc_register_host_class(void)
45 return class_register(&mmc_host_class
);
48 void mmc_unregister_host_class(void)
50 class_unregister(&mmc_host_class
);
53 static DEFINE_IDR(mmc_host_idr
);
54 static DEFINE_SPINLOCK(mmc_host_lock
);
56 #ifdef CONFIG_MMC_CLKGATE
59 * Enabling clock gating will make the core call out to the host
60 * once up and once down when it performs a request or card operation
61 * intermingled in any fashion. The driver will see this through
62 * set_ios() operations with ios.clock field set to 0 to gate (disable)
63 * the block clock, and to the old frequency to enable it again.
65 static void mmc_host_clk_gate_delayed(struct mmc_host
*host
)
67 unsigned long tick_ns
;
68 unsigned long freq
= host
->ios
.clock
;
72 pr_debug("%s: frequency set to 0 in disable function, "
73 "this means the clock is already disabled.\n",
78 * New requests may have appeared while we were scheduling,
79 * then there is no reason to delay the check before
82 spin_lock_irqsave(&host
->clk_lock
, flags
);
85 * Delay n bus cycles (at least 8 from MMC spec) before attempting
86 * to disable the MCI block clock. The reference count may have
87 * gone up again after this delay due to rescheduling!
89 if (!host
->clk_requests
) {
90 spin_unlock_irqrestore(&host
->clk_lock
, flags
);
91 tick_ns
= DIV_ROUND_UP(1000000000, freq
);
92 ndelay(host
->clk_delay
* tick_ns
);
94 /* New users appeared while waiting for this work */
95 spin_unlock_irqrestore(&host
->clk_lock
, flags
);
98 mutex_lock(&host
->clk_gate_mutex
);
99 spin_lock_irqsave(&host
->clk_lock
, flags
);
100 if (!host
->clk_requests
) {
101 spin_unlock_irqrestore(&host
->clk_lock
, flags
);
102 /* This will set host->ios.clock to 0 */
103 mmc_gate_clock(host
);
104 spin_lock_irqsave(&host
->clk_lock
, flags
);
105 pr_debug("%s: gated MCI clock\n", mmc_hostname(host
));
107 spin_unlock_irqrestore(&host
->clk_lock
, flags
);
108 mutex_unlock(&host
->clk_gate_mutex
);
112 * Internal work. Work to disable the clock at some later point.
114 static void mmc_host_clk_gate_work(struct work_struct
*work
)
116 struct mmc_host
*host
= container_of(work
, struct mmc_host
,
119 mmc_host_clk_gate_delayed(host
);
123 * mmc_host_clk_hold - ungate hardware MCI clocks
124 * @host: host to ungate.
126 * Makes sure the host ios.clock is restored to a non-zero value
127 * past this call. Increase clock reference count and ungate clock
128 * if we're the first user.
130 void mmc_host_clk_hold(struct mmc_host
*host
)
134 mutex_lock(&host
->clk_gate_mutex
);
135 spin_lock_irqsave(&host
->clk_lock
, flags
);
136 if (host
->clk_gated
) {
137 spin_unlock_irqrestore(&host
->clk_lock
, flags
);
138 mmc_ungate_clock(host
);
139 spin_lock_irqsave(&host
->clk_lock
, flags
);
140 pr_debug("%s: ungated MCI clock\n", mmc_hostname(host
));
142 host
->clk_requests
++;
143 spin_unlock_irqrestore(&host
->clk_lock
, flags
);
144 mutex_unlock(&host
->clk_gate_mutex
);
148 * mmc_host_may_gate_card - check if this card may be gated
149 * @card: card to check.
151 static bool mmc_host_may_gate_card(struct mmc_card
*card
)
153 /* If there is no card we may gate it */
157 * Don't gate SDIO cards! These need to be clocked at all times
158 * since they may be independent systems generating interrupts
159 * and other events. The clock requests counter from the core will
160 * go down to zero since the core does not need it, but we will not
161 * gate the clock, because there is somebody out there that may still
164 return !(card
->quirks
& MMC_QUIRK_BROKEN_CLK_GATING
);
168 * mmc_host_clk_release - gate off hardware MCI clocks
169 * @host: host to gate.
171 * Calls the host driver with ios.clock set to zero as often as possible
172 * in order to gate off hardware MCI clocks. Decrease clock reference
173 * count and schedule disabling of clock.
175 void mmc_host_clk_release(struct mmc_host
*host
)
179 spin_lock_irqsave(&host
->clk_lock
, flags
);
180 host
->clk_requests
--;
181 if (mmc_host_may_gate_card(host
->card
) &&
183 queue_work(system_nrt_wq
, &host
->clk_gate_work
);
184 spin_unlock_irqrestore(&host
->clk_lock
, flags
);
188 * mmc_host_clk_rate - get current clock frequency setting
189 * @host: host to get the clock frequency for.
191 * Returns current clock frequency regardless of gating.
193 unsigned int mmc_host_clk_rate(struct mmc_host
*host
)
198 spin_lock_irqsave(&host
->clk_lock
, flags
);
200 freq
= host
->clk_old
;
202 freq
= host
->ios
.clock
;
203 spin_unlock_irqrestore(&host
->clk_lock
, flags
);
208 * mmc_host_clk_init - set up clock gating code
209 * @host: host with potential clock to control
211 static inline void mmc_host_clk_init(struct mmc_host
*host
)
213 host
->clk_requests
= 0;
214 /* Hold MCI clock for 8 cycles by default */
216 host
->clk_gated
= false;
217 INIT_WORK(&host
->clk_gate_work
, mmc_host_clk_gate_work
);
218 spin_lock_init(&host
->clk_lock
);
219 mutex_init(&host
->clk_gate_mutex
);
223 * mmc_host_clk_exit - shut down clock gating code
224 * @host: host with potential clock to control
226 static inline void mmc_host_clk_exit(struct mmc_host
*host
)
229 * Wait for any outstanding gate and then make sure we're
230 * ungated before exiting.
232 if (cancel_work_sync(&host
->clk_gate_work
))
233 mmc_host_clk_gate_delayed(host
);
235 mmc_host_clk_hold(host
);
236 /* There should be only one user now */
237 WARN_ON(host
->clk_requests
> 1);
242 static inline void mmc_host_clk_init(struct mmc_host
*host
)
246 static inline void mmc_host_clk_exit(struct mmc_host
*host
)
253 * mmc_alloc_host - initialise the per-host structure.
254 * @extra: sizeof private data structure
255 * @dev: pointer to host device model structure
257 * Initialise the per-host structure.
259 struct mmc_host
*mmc_alloc_host(int extra
, struct device
*dev
)
262 struct mmc_host
*host
;
264 if (!idr_pre_get(&mmc_host_idr
, GFP_KERNEL
))
267 host
= kzalloc(sizeof(struct mmc_host
) + extra
, GFP_KERNEL
);
271 spin_lock(&mmc_host_lock
);
272 err
= idr_get_new(&mmc_host_idr
, host
, &host
->index
);
273 spin_unlock(&mmc_host_lock
);
277 dev_set_name(&host
->class_dev
, "mmc%d", host
->index
);
280 host
->class_dev
.parent
= dev
;
281 host
->class_dev
.class = &mmc_host_class
;
282 device_initialize(&host
->class_dev
);
284 mmc_host_clk_init(host
);
286 spin_lock_init(&host
->lock
);
287 init_waitqueue_head(&host
->wq
);
288 INIT_DELAYED_WORK(&host
->detect
, mmc_rescan
);
289 INIT_DELAYED_WORK_DEFERRABLE(&host
->disable
, mmc_host_deeper_disable
);
291 host
->pm_notify
.notifier_call
= mmc_pm_notify
;
295 * By default, hosts do not support SGIO or large requests.
296 * They have to set these according to their abilities.
299 host
->max_seg_size
= PAGE_CACHE_SIZE
;
301 host
->max_req_size
= PAGE_CACHE_SIZE
;
302 host
->max_blk_size
= 512;
303 host
->max_blk_count
= PAGE_CACHE_SIZE
/ 512;
306 * Enable runtime power management by default. This flag was added due
307 * to runtime power management causing disruption for some users, but
308 * the power on/off code has been improved since then.
310 * We'll enable this flag by default as an experiment, and if no
311 * problems are reported, we will follow up later and remove the flag
314 host
->caps
= MMC_CAP_POWER_OFF_CARD
;
323 EXPORT_SYMBOL(mmc_alloc_host
);
326 * mmc_add_host - initialise host hardware
329 * Register the host with the driver model. The host must be
330 * prepared to start servicing requests before this function
333 int mmc_add_host(struct mmc_host
*host
)
337 WARN_ON((host
->caps
& MMC_CAP_SDIO_IRQ
) &&
338 !host
->ops
->enable_sdio_irq
);
340 err
= device_add(&host
->class_dev
);
344 led_trigger_register_simple(dev_name(&host
->class_dev
), &host
->led
);
346 #ifdef CONFIG_DEBUG_FS
347 mmc_add_host_debugfs(host
);
350 mmc_start_host(host
);
351 register_pm_notifier(&host
->pm_notify
);
356 EXPORT_SYMBOL(mmc_add_host
);
359 * mmc_remove_host - remove host hardware
362 * Unregister and remove all cards associated with this host,
363 * and power down the MMC bus. No new requests will be issued
364 * after this function has returned.
366 void mmc_remove_host(struct mmc_host
*host
)
368 unregister_pm_notifier(&host
->pm_notify
);
371 #ifdef CONFIG_DEBUG_FS
372 mmc_remove_host_debugfs(host
);
375 device_del(&host
->class_dev
);
377 led_trigger_unregister_simple(host
->led
);
379 mmc_host_clk_exit(host
);
382 EXPORT_SYMBOL(mmc_remove_host
);
385 * mmc_free_host - free the host structure
388 * Free the host once all references to it have been dropped.
390 void mmc_free_host(struct mmc_host
*host
)
392 spin_lock(&mmc_host_lock
);
393 idr_remove(&mmc_host_idr
, host
->index
);
394 spin_unlock(&mmc_host_lock
);
396 put_device(&host
->class_dev
);
399 EXPORT_SYMBOL(mmc_free_host
);