1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * linux/drivers/mmc/core/host.c 4 * 5 * Copyright (C) 2003 Russell King, All Rights Reserved. 6 * Copyright (C) 2007-2008 Pierre Ossman 7 * Copyright (C) 2010 Linus Walleij 8 * 9 * MMC host class device management 10 */ 11 12 #include <linux/device.h> 13 #include <linux/err.h> 14 #include <linux/idr.h> 15 #include <linux/of.h> 16 #include <linux/of_gpio.h> 17 #include <linux/pagemap.h> 18 #include <linux/pm_wakeup.h> 19 #include <linux/export.h> 20 #include <linux/leds.h> 21 #include <linux/slab.h> 22 23 #include <linux/mmc/host.h> 24 #include <linux/mmc/card.h> 25 #include <linux/mmc/slot-gpio.h> 26 27 #include "core.h" 28 #include "crypto.h" 29 #include "host.h" 30 #include "slot-gpio.h" 31 #include "pwrseq.h" 32 #include "sdio_ops.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 38 #ifdef CONFIG_PM_SLEEP 39 static int mmc_host_class_prepare(struct device *dev) 40 { 41 struct mmc_host *host = cls_dev_to_mmc_host(dev); 42 43 /* 44 * It's safe to access the bus_ops pointer, as both userspace and the 45 * workqueue for detecting cards are frozen at this point. 46 */ 47 if (!host->bus_ops) 48 return 0; 49 50 /* Validate conditions for system suspend. */ 51 if (host->bus_ops->pre_suspend) 52 return host->bus_ops->pre_suspend(host); 53 54 return 0; 55 } 56 57 static void mmc_host_class_complete(struct device *dev) 58 { 59 struct mmc_host *host = cls_dev_to_mmc_host(dev); 60 61 _mmc_detect_change(host, 0, false); 62 } 63 64 static const struct dev_pm_ops mmc_host_class_dev_pm_ops = { 65 .prepare = mmc_host_class_prepare, 66 .complete = mmc_host_class_complete, 67 }; 68 69 #define MMC_HOST_CLASS_DEV_PM_OPS (&mmc_host_class_dev_pm_ops) 70 #else 71 #define MMC_HOST_CLASS_DEV_PM_OPS NULL 72 #endif 73 74 static void mmc_host_classdev_release(struct device *dev) 75 { 76 struct mmc_host *host = cls_dev_to_mmc_host(dev); 77 wakeup_source_unregister(host->ws); 78 if (of_alias_get_id(host->parent->of_node, "mmc") < 0) 79 ida_simple_remove(&mmc_host_ida, host->index); 80 kfree(host); 81 } 82 83 static struct class mmc_host_class = { 84 .name = "mmc_host", 85 .dev_release = mmc_host_classdev_release, 86 .pm = MMC_HOST_CLASS_DEV_PM_OPS, 87 }; 88 89 int mmc_register_host_class(void) 90 { 91 return class_register(&mmc_host_class); 92 } 93 94 void mmc_unregister_host_class(void) 95 { 96 class_unregister(&mmc_host_class); 97 } 98 99 void mmc_retune_enable(struct mmc_host *host) 100 { 101 host->can_retune = 1; 102 if (host->retune_period) 103 mod_timer(&host->retune_timer, 104 jiffies + host->retune_period * HZ); 105 } 106 107 /* 108 * Pause re-tuning for a small set of operations. The pause begins after the 109 * next command and after first doing re-tuning. 110 */ 111 void mmc_retune_pause(struct mmc_host *host) 112 { 113 if (!host->retune_paused) { 114 host->retune_paused = 1; 115 mmc_retune_needed(host); 116 mmc_retune_hold(host); 117 } 118 } 119 EXPORT_SYMBOL(mmc_retune_pause); 120 121 void mmc_retune_unpause(struct mmc_host *host) 122 { 123 if (host->retune_paused) { 124 host->retune_paused = 0; 125 mmc_retune_release(host); 126 } 127 } 128 EXPORT_SYMBOL(mmc_retune_unpause); 129 130 void mmc_retune_disable(struct mmc_host *host) 131 { 132 mmc_retune_unpause(host); 133 host->can_retune = 0; 134 del_timer_sync(&host->retune_timer); 135 host->retune_now = 0; 136 host->need_retune = 0; 137 } 138 139 void mmc_retune_timer_stop(struct mmc_host *host) 140 { 141 del_timer_sync(&host->retune_timer); 142 } 143 EXPORT_SYMBOL(mmc_retune_timer_stop); 144 145 void mmc_retune_hold(struct mmc_host *host) 146 { 147 if (!host->hold_retune) 148 host->retune_now = 1; 149 host->hold_retune += 1; 150 } 151 152 void mmc_retune_release(struct mmc_host *host) 153 { 154 if (host->hold_retune) 155 host->hold_retune -= 1; 156 else 157 WARN_ON(1); 158 } 159 EXPORT_SYMBOL(mmc_retune_release); 160 161 int mmc_retune(struct mmc_host *host) 162 { 163 bool return_to_hs400 = false; 164 int err; 165 166 if (host->retune_now) 167 host->retune_now = 0; 168 else 169 return 0; 170 171 if (!host->need_retune || host->doing_retune || !host->card) 172 return 0; 173 174 host->need_retune = 0; 175 176 host->doing_retune = 1; 177 178 if (host->ios.timing == MMC_TIMING_MMC_HS400) { 179 err = mmc_hs400_to_hs200(host->card); 180 if (err) 181 goto out; 182 183 return_to_hs400 = true; 184 } 185 186 err = mmc_execute_tuning(host->card); 187 if (err) 188 goto out; 189 190 if (return_to_hs400) 191 err = mmc_hs200_to_hs400(host->card); 192 out: 193 host->doing_retune = 0; 194 195 return err; 196 } 197 198 static void mmc_retune_timer(struct timer_list *t) 199 { 200 struct mmc_host *host = from_timer(host, t, retune_timer); 201 202 mmc_retune_needed(host); 203 } 204 205 static void mmc_of_parse_timing_phase(struct device *dev, const char *prop, 206 struct mmc_clk_phase *phase) 207 { 208 int degrees[2] = {0}; 209 int rc; 210 211 rc = device_property_read_u32_array(dev, prop, degrees, 2); 212 phase->valid = !rc; 213 if (phase->valid) { 214 phase->in_deg = degrees[0]; 215 phase->out_deg = degrees[1]; 216 } 217 } 218 219 void 220 mmc_of_parse_clk_phase(struct mmc_host *host, struct mmc_clk_phase_map *map) 221 { 222 struct device *dev = host->parent; 223 224 mmc_of_parse_timing_phase(dev, "clk-phase-legacy", 225 &map->phase[MMC_TIMING_LEGACY]); 226 mmc_of_parse_timing_phase(dev, "clk-phase-mmc-hs", 227 &map->phase[MMC_TIMING_MMC_HS]); 228 mmc_of_parse_timing_phase(dev, "clk-phase-sd-hs", 229 &map->phase[MMC_TIMING_SD_HS]); 230 mmc_of_parse_timing_phase(dev, "clk-phase-uhs-sdr12", 231 &map->phase[MMC_TIMING_UHS_SDR12]); 232 mmc_of_parse_timing_phase(dev, "clk-phase-uhs-sdr25", 233 &map->phase[MMC_TIMING_UHS_SDR25]); 234 mmc_of_parse_timing_phase(dev, "clk-phase-uhs-sdr50", 235 &map->phase[MMC_TIMING_UHS_SDR50]); 236 mmc_of_parse_timing_phase(dev, "clk-phase-uhs-sdr104", 237 &map->phase[MMC_TIMING_UHS_SDR104]); 238 mmc_of_parse_timing_phase(dev, "clk-phase-uhs-ddr50", 239 &map->phase[MMC_TIMING_UHS_DDR50]); 240 mmc_of_parse_timing_phase(dev, "clk-phase-mmc-ddr52", 241 &map->phase[MMC_TIMING_MMC_DDR52]); 242 mmc_of_parse_timing_phase(dev, "clk-phase-mmc-hs200", 243 &map->phase[MMC_TIMING_MMC_HS200]); 244 mmc_of_parse_timing_phase(dev, "clk-phase-mmc-hs400", 245 &map->phase[MMC_TIMING_MMC_HS400]); 246 } 247 EXPORT_SYMBOL(mmc_of_parse_clk_phase); 248 249 /** 250 * mmc_of_parse() - parse host's device properties 251 * @host: host whose properties should be parsed. 252 * 253 * To keep the rest of the MMC subsystem unaware of whether DT has been 254 * used to to instantiate and configure this host instance or not, we 255 * parse the properties and set respective generic mmc-host flags and 256 * parameters. 257 */ 258 int mmc_of_parse(struct mmc_host *host) 259 { 260 struct device *dev = host->parent; 261 u32 bus_width, drv_type, cd_debounce_delay_ms; 262 int ret; 263 264 if (!dev || !dev_fwnode(dev)) 265 return 0; 266 267 /* "bus-width" is translated to MMC_CAP_*_BIT_DATA flags */ 268 if (device_property_read_u32(dev, "bus-width", &bus_width) < 0) { 269 dev_dbg(host->parent, 270 "\"bus-width\" property is missing, assuming 1 bit.\n"); 271 bus_width = 1; 272 } 273 274 switch (bus_width) { 275 case 8: 276 host->caps |= MMC_CAP_8_BIT_DATA; 277 fallthrough; /* Hosts capable of 8-bit can also do 4 bits */ 278 case 4: 279 host->caps |= MMC_CAP_4_BIT_DATA; 280 break; 281 case 1: 282 break; 283 default: 284 dev_err(host->parent, 285 "Invalid \"bus-width\" value %u!\n", bus_width); 286 return -EINVAL; 287 } 288 289 /* f_max is obtained from the optional "max-frequency" property */ 290 device_property_read_u32(dev, "max-frequency", &host->f_max); 291 292 /* 293 * Configure CD and WP pins. They are both by default active low to 294 * match the SDHCI spec. If GPIOs are provided for CD and / or WP, the 295 * mmc-gpio helpers are used to attach, configure and use them. If 296 * polarity inversion is specified in DT, one of MMC_CAP2_CD_ACTIVE_HIGH 297 * and MMC_CAP2_RO_ACTIVE_HIGH capability-2 flags is set. If the 298 * "broken-cd" property is provided, the MMC_CAP_NEEDS_POLL capability 299 * is set. If the "non-removable" property is found, the 300 * MMC_CAP_NONREMOVABLE capability is set and no card-detection 301 * configuration is performed. 302 */ 303 304 /* Parse Card Detection */ 305 306 if (device_property_read_bool(dev, "non-removable")) { 307 host->caps |= MMC_CAP_NONREMOVABLE; 308 } else { 309 if (device_property_read_bool(dev, "cd-inverted")) 310 host->caps2 |= MMC_CAP2_CD_ACTIVE_HIGH; 311 312 if (device_property_read_u32(dev, "cd-debounce-delay-ms", 313 &cd_debounce_delay_ms)) 314 cd_debounce_delay_ms = 200; 315 316 if (device_property_read_bool(dev, "broken-cd")) 317 host->caps |= MMC_CAP_NEEDS_POLL; 318 319 ret = mmc_gpiod_request_cd(host, "cd", 0, false, 320 cd_debounce_delay_ms * 1000); 321 if (!ret) 322 dev_info(host->parent, "Got CD GPIO\n"); 323 else if (ret != -ENOENT && ret != -ENOSYS) 324 return ret; 325 } 326 327 /* Parse Write Protection */ 328 329 if (device_property_read_bool(dev, "wp-inverted")) 330 host->caps2 |= MMC_CAP2_RO_ACTIVE_HIGH; 331 332 ret = mmc_gpiod_request_ro(host, "wp", 0, 0); 333 if (!ret) 334 dev_info(host->parent, "Got WP GPIO\n"); 335 else if (ret != -ENOENT && ret != -ENOSYS) 336 return ret; 337 338 if (device_property_read_bool(dev, "disable-wp")) 339 host->caps2 |= MMC_CAP2_NO_WRITE_PROTECT; 340 341 if (device_property_read_bool(dev, "cap-sd-highspeed")) 342 host->caps |= MMC_CAP_SD_HIGHSPEED; 343 if (device_property_read_bool(dev, "cap-mmc-highspeed")) 344 host->caps |= MMC_CAP_MMC_HIGHSPEED; 345 if (device_property_read_bool(dev, "sd-uhs-sdr12")) 346 host->caps |= MMC_CAP_UHS_SDR12; 347 if (device_property_read_bool(dev, "sd-uhs-sdr25")) 348 host->caps |= MMC_CAP_UHS_SDR25; 349 if (device_property_read_bool(dev, "sd-uhs-sdr50")) 350 host->caps |= MMC_CAP_UHS_SDR50; 351 if (device_property_read_bool(dev, "sd-uhs-sdr104")) 352 host->caps |= MMC_CAP_UHS_SDR104; 353 if (device_property_read_bool(dev, "sd-uhs-ddr50")) 354 host->caps |= MMC_CAP_UHS_DDR50; 355 if (device_property_read_bool(dev, "cap-power-off-card")) 356 host->caps |= MMC_CAP_POWER_OFF_CARD; 357 if (device_property_read_bool(dev, "cap-mmc-hw-reset")) 358 host->caps |= MMC_CAP_HW_RESET; 359 if (device_property_read_bool(dev, "cap-sdio-irq")) 360 host->caps |= MMC_CAP_SDIO_IRQ; 361 if (device_property_read_bool(dev, "full-pwr-cycle")) 362 host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE; 363 if (device_property_read_bool(dev, "full-pwr-cycle-in-suspend")) 364 host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE_IN_SUSPEND; 365 if (device_property_read_bool(dev, "keep-power-in-suspend")) 366 host->pm_caps |= MMC_PM_KEEP_POWER; 367 if (device_property_read_bool(dev, "wakeup-source") || 368 device_property_read_bool(dev, "enable-sdio-wakeup")) /* legacy */ 369 host->pm_caps |= MMC_PM_WAKE_SDIO_IRQ; 370 if (device_property_read_bool(dev, "mmc-ddr-3_3v")) 371 host->caps |= MMC_CAP_3_3V_DDR; 372 if (device_property_read_bool(dev, "mmc-ddr-1_8v")) 373 host->caps |= MMC_CAP_1_8V_DDR; 374 if (device_property_read_bool(dev, "mmc-ddr-1_2v")) 375 host->caps |= MMC_CAP_1_2V_DDR; 376 if (device_property_read_bool(dev, "mmc-hs200-1_8v")) 377 host->caps2 |= MMC_CAP2_HS200_1_8V_SDR; 378 if (device_property_read_bool(dev, "mmc-hs200-1_2v")) 379 host->caps2 |= MMC_CAP2_HS200_1_2V_SDR; 380 if (device_property_read_bool(dev, "mmc-hs400-1_8v")) 381 host->caps2 |= MMC_CAP2_HS400_1_8V | MMC_CAP2_HS200_1_8V_SDR; 382 if (device_property_read_bool(dev, "mmc-hs400-1_2v")) 383 host->caps2 |= MMC_CAP2_HS400_1_2V | MMC_CAP2_HS200_1_2V_SDR; 384 if (device_property_read_bool(dev, "mmc-hs400-enhanced-strobe")) 385 host->caps2 |= MMC_CAP2_HS400_ES; 386 if (device_property_read_bool(dev, "no-sdio")) 387 host->caps2 |= MMC_CAP2_NO_SDIO; 388 if (device_property_read_bool(dev, "no-sd")) 389 host->caps2 |= MMC_CAP2_NO_SD; 390 if (device_property_read_bool(dev, "no-mmc")) 391 host->caps2 |= MMC_CAP2_NO_MMC; 392 if (device_property_read_bool(dev, "no-mmc-hs400")) 393 host->caps2 &= ~(MMC_CAP2_HS400_1_8V | MMC_CAP2_HS400_1_2V | 394 MMC_CAP2_HS400_ES); 395 396 /* Must be after "non-removable" check */ 397 if (device_property_read_u32(dev, "fixed-emmc-driver-type", &drv_type) == 0) { 398 if (host->caps & MMC_CAP_NONREMOVABLE) 399 host->fixed_drv_type = drv_type; 400 else 401 dev_err(host->parent, 402 "can't use fixed driver type, media is removable\n"); 403 } 404 405 host->dsr_req = !device_property_read_u32(dev, "dsr", &host->dsr); 406 if (host->dsr_req && (host->dsr & ~0xffff)) { 407 dev_err(host->parent, 408 "device tree specified broken value for DSR: 0x%x, ignoring\n", 409 host->dsr); 410 host->dsr_req = 0; 411 } 412 413 device_property_read_u32(dev, "post-power-on-delay-ms", 414 &host->ios.power_delay_ms); 415 416 return mmc_pwrseq_alloc(host); 417 } 418 419 EXPORT_SYMBOL(mmc_of_parse); 420 421 /** 422 * mmc_of_parse_voltage - return mask of supported voltages 423 * @host: host whose properties should be parsed. 424 * @mask: mask of voltages available for MMC/SD/SDIO 425 * 426 * Parse the "voltage-ranges" property, returning zero if it is not 427 * found, negative errno if the voltage-range specification is invalid, 428 * or one if the voltage-range is specified and successfully parsed. 429 */ 430 int mmc_of_parse_voltage(struct mmc_host *host, u32 *mask) 431 { 432 const char *prop = "voltage-ranges"; 433 struct device *dev = host->parent; 434 u32 *voltage_ranges; 435 int num_ranges, i; 436 int ret; 437 438 if (!device_property_present(dev, prop)) { 439 dev_dbg(dev, "%s unspecified\n", prop); 440 return 0; 441 } 442 443 ret = device_property_count_u32(dev, prop); 444 if (ret < 0) 445 return ret; 446 447 num_ranges = ret / 2; 448 if (!num_ranges) { 449 dev_err(dev, "%s empty\n", prop); 450 return -EINVAL; 451 } 452 453 voltage_ranges = kcalloc(2 * num_ranges, sizeof(*voltage_ranges), GFP_KERNEL); 454 if (!voltage_ranges) 455 return -ENOMEM; 456 457 ret = device_property_read_u32_array(dev, prop, voltage_ranges, 2 * num_ranges); 458 if (ret) { 459 kfree(voltage_ranges); 460 return ret; 461 } 462 463 for (i = 0; i < num_ranges; i++) { 464 const int j = i * 2; 465 u32 ocr_mask; 466 467 ocr_mask = mmc_vddrange_to_ocrmask(voltage_ranges[j + 0], 468 voltage_ranges[j + 1]); 469 if (!ocr_mask) { 470 dev_err(dev, "range #%d in %s is invalid\n", i, prop); 471 kfree(voltage_ranges); 472 return -EINVAL; 473 } 474 *mask |= ocr_mask; 475 } 476 477 kfree(voltage_ranges); 478 479 return 1; 480 } 481 EXPORT_SYMBOL(mmc_of_parse_voltage); 482 483 /** 484 * mmc_first_nonreserved_index() - get the first index that is not reserved 485 */ 486 static int mmc_first_nonreserved_index(void) 487 { 488 int max; 489 490 max = of_alias_get_highest_id("mmc"); 491 if (max < 0) 492 return 0; 493 494 return max + 1; 495 } 496 497 /** 498 * mmc_alloc_host - initialise the per-host structure. 499 * @extra: sizeof private data structure 500 * @dev: pointer to host device model structure 501 * 502 * Initialise the per-host structure. 503 */ 504 struct mmc_host *mmc_alloc_host(int extra, struct device *dev) 505 { 506 int index; 507 struct mmc_host *host; 508 int alias_id, min_idx, max_idx; 509 510 host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL); 511 if (!host) 512 return NULL; 513 514 /* scanning will be enabled when we're ready */ 515 host->rescan_disable = 1; 516 517 alias_id = of_alias_get_id(dev->of_node, "mmc"); 518 if (alias_id >= 0) { 519 index = alias_id; 520 } else { 521 min_idx = mmc_first_nonreserved_index(); 522 max_idx = 0; 523 524 index = ida_simple_get(&mmc_host_ida, min_idx, max_idx, GFP_KERNEL); 525 if (index < 0) { 526 kfree(host); 527 return NULL; 528 } 529 } 530 531 host->index = index; 532 533 dev_set_name(&host->class_dev, "mmc%d", host->index); 534 host->ws = wakeup_source_register(NULL, dev_name(&host->class_dev)); 535 536 host->parent = dev; 537 host->class_dev.parent = dev; 538 host->class_dev.class = &mmc_host_class; 539 device_initialize(&host->class_dev); 540 device_enable_async_suspend(&host->class_dev); 541 542 if (mmc_gpio_alloc(host)) { 543 put_device(&host->class_dev); 544 return NULL; 545 } 546 547 spin_lock_init(&host->lock); 548 init_waitqueue_head(&host->wq); 549 INIT_DELAYED_WORK(&host->detect, mmc_rescan); 550 INIT_DELAYED_WORK(&host->sdio_irq_work, sdio_irq_work); 551 timer_setup(&host->retune_timer, mmc_retune_timer, 0); 552 553 /* 554 * By default, hosts do not support SGIO or large requests. 555 * They have to set these according to their abilities. 556 */ 557 host->max_segs = 1; 558 host->max_seg_size = PAGE_SIZE; 559 560 host->max_req_size = PAGE_SIZE; 561 host->max_blk_size = 512; 562 host->max_blk_count = PAGE_SIZE / 512; 563 564 host->fixed_drv_type = -EINVAL; 565 host->ios.power_delay_ms = 10; 566 host->ios.power_mode = MMC_POWER_UNDEFINED; 567 568 return host; 569 } 570 571 EXPORT_SYMBOL(mmc_alloc_host); 572 573 /** 574 * mmc_add_host - initialise host hardware 575 * @host: mmc host 576 * 577 * Register the host with the driver model. The host must be 578 * prepared to start servicing requests before this function 579 * completes. 580 */ 581 int mmc_add_host(struct mmc_host *host) 582 { 583 int err; 584 585 WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) && 586 !host->ops->enable_sdio_irq); 587 588 err = device_add(&host->class_dev); 589 if (err) 590 return err; 591 592 led_trigger_register_simple(dev_name(&host->class_dev), &host->led); 593 594 #ifdef CONFIG_DEBUG_FS 595 mmc_add_host_debugfs(host); 596 #endif 597 598 mmc_start_host(host); 599 return 0; 600 } 601 602 EXPORT_SYMBOL(mmc_add_host); 603 604 /** 605 * mmc_remove_host - remove host hardware 606 * @host: mmc host 607 * 608 * Unregister and remove all cards associated with this host, 609 * and power down the MMC bus. No new requests will be issued 610 * after this function has returned. 611 */ 612 void mmc_remove_host(struct mmc_host *host) 613 { 614 mmc_stop_host(host); 615 616 #ifdef CONFIG_DEBUG_FS 617 mmc_remove_host_debugfs(host); 618 #endif 619 620 device_del(&host->class_dev); 621 622 led_trigger_unregister_simple(host->led); 623 } 624 625 EXPORT_SYMBOL(mmc_remove_host); 626 627 /** 628 * mmc_free_host - free the host structure 629 * @host: mmc host 630 * 631 * Free the host once all references to it have been dropped. 632 */ 633 void mmc_free_host(struct mmc_host *host) 634 { 635 mmc_pwrseq_free(host); 636 put_device(&host->class_dev); 637 } 638 639 EXPORT_SYMBOL(mmc_free_host); 640