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