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