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/pagemap.h> 19 #include <linux/export.h> 20 #include <linux/leds.h> 21 #include <linux/slab.h> 22 #include <linux/suspend.h> 23 24 #include <linux/mmc/host.h> 25 #include <linux/mmc/card.h> 26 27 #include "core.h" 28 #include "host.h" 29 30 #define cls_dev_to_mmc_host(d) container_of(d, struct mmc_host, class_dev) 31 32 static void mmc_host_classdev_release(struct device *dev) 33 { 34 struct mmc_host *host = cls_dev_to_mmc_host(dev); 35 mutex_destroy(&host->slot.lock); 36 kfree(host); 37 } 38 39 static struct class mmc_host_class = { 40 .name = "mmc_host", 41 .dev_release = mmc_host_classdev_release, 42 }; 43 44 int mmc_register_host_class(void) 45 { 46 return class_register(&mmc_host_class); 47 } 48 49 void mmc_unregister_host_class(void) 50 { 51 class_unregister(&mmc_host_class); 52 } 53 54 static DEFINE_IDR(mmc_host_idr); 55 static DEFINE_SPINLOCK(mmc_host_lock); 56 57 #ifdef CONFIG_MMC_CLKGATE 58 static ssize_t clkgate_delay_show(struct device *dev, 59 struct device_attribute *attr, char *buf) 60 { 61 struct mmc_host *host = cls_dev_to_mmc_host(dev); 62 return snprintf(buf, PAGE_SIZE, "%lu\n", host->clkgate_delay); 63 } 64 65 static ssize_t clkgate_delay_store(struct device *dev, 66 struct device_attribute *attr, const char *buf, size_t count) 67 { 68 struct mmc_host *host = cls_dev_to_mmc_host(dev); 69 unsigned long flags, value; 70 71 if (kstrtoul(buf, 0, &value)) 72 return -EINVAL; 73 74 spin_lock_irqsave(&host->clk_lock, flags); 75 host->clkgate_delay = value; 76 spin_unlock_irqrestore(&host->clk_lock, flags); 77 return count; 78 } 79 80 /* 81 * Enabling clock gating will make the core call out to the host 82 * once up and once down when it performs a request or card operation 83 * intermingled in any fashion. The driver will see this through 84 * set_ios() operations with ios.clock field set to 0 to gate (disable) 85 * the block clock, and to the old frequency to enable it again. 86 */ 87 static void mmc_host_clk_gate_delayed(struct mmc_host *host) 88 { 89 unsigned long tick_ns; 90 unsigned long freq = host->ios.clock; 91 unsigned long flags; 92 93 if (!freq) { 94 pr_debug("%s: frequency set to 0 in disable function, " 95 "this means the clock is already disabled.\n", 96 mmc_hostname(host)); 97 return; 98 } 99 /* 100 * New requests may have appeared while we were scheduling, 101 * then there is no reason to delay the check before 102 * clk_disable(). 103 */ 104 spin_lock_irqsave(&host->clk_lock, flags); 105 106 /* 107 * Delay n bus cycles (at least 8 from MMC spec) before attempting 108 * to disable the MCI block clock. The reference count may have 109 * gone up again after this delay due to rescheduling! 110 */ 111 if (!host->clk_requests) { 112 spin_unlock_irqrestore(&host->clk_lock, flags); 113 tick_ns = DIV_ROUND_UP(1000000000, freq); 114 ndelay(host->clk_delay * tick_ns); 115 } else { 116 /* New users appeared while waiting for this work */ 117 spin_unlock_irqrestore(&host->clk_lock, flags); 118 return; 119 } 120 mutex_lock(&host->clk_gate_mutex); 121 spin_lock_irqsave(&host->clk_lock, flags); 122 if (!host->clk_requests) { 123 spin_unlock_irqrestore(&host->clk_lock, flags); 124 /* This will set host->ios.clock to 0 */ 125 mmc_gate_clock(host); 126 spin_lock_irqsave(&host->clk_lock, flags); 127 pr_debug("%s: gated MCI clock\n", mmc_hostname(host)); 128 } 129 spin_unlock_irqrestore(&host->clk_lock, flags); 130 mutex_unlock(&host->clk_gate_mutex); 131 } 132 133 /* 134 * Internal work. Work to disable the clock at some later point. 135 */ 136 static void mmc_host_clk_gate_work(struct work_struct *work) 137 { 138 struct mmc_host *host = container_of(work, struct mmc_host, 139 clk_gate_work.work); 140 141 mmc_host_clk_gate_delayed(host); 142 } 143 144 /** 145 * mmc_host_clk_hold - ungate hardware MCI clocks 146 * @host: host to ungate. 147 * 148 * Makes sure the host ios.clock is restored to a non-zero value 149 * past this call. Increase clock reference count and ungate clock 150 * if we're the first user. 151 */ 152 void mmc_host_clk_hold(struct mmc_host *host) 153 { 154 unsigned long flags; 155 156 /* cancel any clock gating work scheduled by mmc_host_clk_release() */ 157 cancel_delayed_work_sync(&host->clk_gate_work); 158 mutex_lock(&host->clk_gate_mutex); 159 spin_lock_irqsave(&host->clk_lock, flags); 160 if (host->clk_gated) { 161 spin_unlock_irqrestore(&host->clk_lock, flags); 162 mmc_ungate_clock(host); 163 spin_lock_irqsave(&host->clk_lock, flags); 164 pr_debug("%s: ungated MCI clock\n", mmc_hostname(host)); 165 } 166 host->clk_requests++; 167 spin_unlock_irqrestore(&host->clk_lock, flags); 168 mutex_unlock(&host->clk_gate_mutex); 169 } 170 171 /** 172 * mmc_host_may_gate_card - check if this card may be gated 173 * @card: card to check. 174 */ 175 static bool mmc_host_may_gate_card(struct mmc_card *card) 176 { 177 /* If there is no card we may gate it */ 178 if (!card) 179 return true; 180 /* 181 * Don't gate SDIO cards! These need to be clocked at all times 182 * since they may be independent systems generating interrupts 183 * and other events. The clock requests counter from the core will 184 * go down to zero since the core does not need it, but we will not 185 * gate the clock, because there is somebody out there that may still 186 * be using it. 187 */ 188 return !(card->quirks & MMC_QUIRK_BROKEN_CLK_GATING); 189 } 190 191 /** 192 * mmc_host_clk_release - gate off hardware MCI clocks 193 * @host: host to gate. 194 * 195 * Calls the host driver with ios.clock set to zero as often as possible 196 * in order to gate off hardware MCI clocks. Decrease clock reference 197 * count and schedule disabling of clock. 198 */ 199 void mmc_host_clk_release(struct mmc_host *host) 200 { 201 unsigned long flags; 202 203 spin_lock_irqsave(&host->clk_lock, flags); 204 host->clk_requests--; 205 if (mmc_host_may_gate_card(host->card) && 206 !host->clk_requests) 207 schedule_delayed_work(&host->clk_gate_work, 208 msecs_to_jiffies(host->clkgate_delay)); 209 spin_unlock_irqrestore(&host->clk_lock, flags); 210 } 211 212 /** 213 * mmc_host_clk_rate - get current clock frequency setting 214 * @host: host to get the clock frequency for. 215 * 216 * Returns current clock frequency regardless of gating. 217 */ 218 unsigned int mmc_host_clk_rate(struct mmc_host *host) 219 { 220 unsigned long freq; 221 unsigned long flags; 222 223 spin_lock_irqsave(&host->clk_lock, flags); 224 if (host->clk_gated) 225 freq = host->clk_old; 226 else 227 freq = host->ios.clock; 228 spin_unlock_irqrestore(&host->clk_lock, flags); 229 return freq; 230 } 231 232 /** 233 * mmc_host_clk_init - set up clock gating code 234 * @host: host with potential clock to control 235 */ 236 static inline void mmc_host_clk_init(struct mmc_host *host) 237 { 238 host->clk_requests = 0; 239 /* Hold MCI clock for 8 cycles by default */ 240 host->clk_delay = 8; 241 /* 242 * Default clock gating delay is 0ms to avoid wasting power. 243 * This value can be tuned by writing into sysfs entry. 244 */ 245 host->clkgate_delay = 0; 246 host->clk_gated = false; 247 INIT_DELAYED_WORK(&host->clk_gate_work, mmc_host_clk_gate_work); 248 spin_lock_init(&host->clk_lock); 249 mutex_init(&host->clk_gate_mutex); 250 } 251 252 /** 253 * mmc_host_clk_exit - shut down clock gating code 254 * @host: host with potential clock to control 255 */ 256 static inline void mmc_host_clk_exit(struct mmc_host *host) 257 { 258 /* 259 * Wait for any outstanding gate and then make sure we're 260 * ungated before exiting. 261 */ 262 if (cancel_delayed_work_sync(&host->clk_gate_work)) 263 mmc_host_clk_gate_delayed(host); 264 if (host->clk_gated) 265 mmc_host_clk_hold(host); 266 /* There should be only one user now */ 267 WARN_ON(host->clk_requests > 1); 268 } 269 270 static inline void mmc_host_clk_sysfs_init(struct mmc_host *host) 271 { 272 host->clkgate_delay_attr.show = clkgate_delay_show; 273 host->clkgate_delay_attr.store = clkgate_delay_store; 274 sysfs_attr_init(&host->clkgate_delay_attr.attr); 275 host->clkgate_delay_attr.attr.name = "clkgate_delay"; 276 host->clkgate_delay_attr.attr.mode = S_IRUGO | S_IWUSR; 277 if (device_create_file(&host->class_dev, &host->clkgate_delay_attr)) 278 pr_err("%s: Failed to create clkgate_delay sysfs entry\n", 279 mmc_hostname(host)); 280 } 281 #else 282 283 static inline void mmc_host_clk_init(struct mmc_host *host) 284 { 285 } 286 287 static inline void mmc_host_clk_exit(struct mmc_host *host) 288 { 289 } 290 291 static inline void mmc_host_clk_sysfs_init(struct mmc_host *host) 292 { 293 } 294 295 #endif 296 297 /** 298 * mmc_alloc_host - initialise the per-host structure. 299 * @extra: sizeof private data structure 300 * @dev: pointer to host device model structure 301 * 302 * Initialise the per-host structure. 303 */ 304 struct mmc_host *mmc_alloc_host(int extra, struct device *dev) 305 { 306 int err; 307 struct mmc_host *host; 308 309 if (!idr_pre_get(&mmc_host_idr, GFP_KERNEL)) 310 return NULL; 311 312 host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL); 313 if (!host) 314 return NULL; 315 316 /* scanning will be enabled when we're ready */ 317 host->rescan_disable = 1; 318 spin_lock(&mmc_host_lock); 319 err = idr_get_new(&mmc_host_idr, host, &host->index); 320 spin_unlock(&mmc_host_lock); 321 if (err) 322 goto free; 323 324 dev_set_name(&host->class_dev, "mmc%d", host->index); 325 326 host->parent = dev; 327 host->class_dev.parent = dev; 328 host->class_dev.class = &mmc_host_class; 329 device_initialize(&host->class_dev); 330 331 mmc_host_clk_init(host); 332 333 mutex_init(&host->slot.lock); 334 host->slot.cd_irq = -EINVAL; 335 336 spin_lock_init(&host->lock); 337 init_waitqueue_head(&host->wq); 338 INIT_DELAYED_WORK(&host->detect, mmc_rescan); 339 #ifdef CONFIG_PM 340 host->pm_notify.notifier_call = mmc_pm_notify; 341 #endif 342 343 /* 344 * By default, hosts do not support SGIO or large requests. 345 * They have to set these according to their abilities. 346 */ 347 host->max_segs = 1; 348 host->max_seg_size = PAGE_CACHE_SIZE; 349 350 host->max_req_size = PAGE_CACHE_SIZE; 351 host->max_blk_size = 512; 352 host->max_blk_count = PAGE_CACHE_SIZE / 512; 353 354 return host; 355 356 free: 357 kfree(host); 358 return NULL; 359 } 360 361 EXPORT_SYMBOL(mmc_alloc_host); 362 363 /** 364 * mmc_add_host - initialise host hardware 365 * @host: mmc host 366 * 367 * Register the host with the driver model. The host must be 368 * prepared to start servicing requests before this function 369 * completes. 370 */ 371 int mmc_add_host(struct mmc_host *host) 372 { 373 int err; 374 375 WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) && 376 !host->ops->enable_sdio_irq); 377 378 err = device_add(&host->class_dev); 379 if (err) 380 return err; 381 382 led_trigger_register_simple(dev_name(&host->class_dev), &host->led); 383 384 #ifdef CONFIG_DEBUG_FS 385 mmc_add_host_debugfs(host); 386 #endif 387 mmc_host_clk_sysfs_init(host); 388 389 mmc_start_host(host); 390 register_pm_notifier(&host->pm_notify); 391 392 return 0; 393 } 394 395 EXPORT_SYMBOL(mmc_add_host); 396 397 /** 398 * mmc_remove_host - remove host hardware 399 * @host: mmc host 400 * 401 * Unregister and remove all cards associated with this host, 402 * and power down the MMC bus. No new requests will be issued 403 * after this function has returned. 404 */ 405 void mmc_remove_host(struct mmc_host *host) 406 { 407 unregister_pm_notifier(&host->pm_notify); 408 mmc_stop_host(host); 409 410 #ifdef CONFIG_DEBUG_FS 411 mmc_remove_host_debugfs(host); 412 #endif 413 414 device_del(&host->class_dev); 415 416 led_trigger_unregister_simple(host->led); 417 418 mmc_host_clk_exit(host); 419 } 420 421 EXPORT_SYMBOL(mmc_remove_host); 422 423 /** 424 * mmc_free_host - free the host structure 425 * @host: mmc host 426 * 427 * Free the host once all references to it have been dropped. 428 */ 429 void mmc_free_host(struct mmc_host *host) 430 { 431 spin_lock(&mmc_host_lock); 432 idr_remove(&mmc_host_idr, host->index); 433 spin_unlock(&mmc_host_lock); 434 435 put_device(&host->class_dev); 436 } 437 438 EXPORT_SYMBOL(mmc_free_host); 439