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