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