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