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