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 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 ida_simple_remove(&mmc_host_ida, host->index); 42 kfree(host); 43 } 44 45 static struct class mmc_host_class = { 46 .name = "mmc_host", 47 .dev_release = mmc_host_classdev_release, 48 }; 49 50 int mmc_register_host_class(void) 51 { 52 return class_register(&mmc_host_class); 53 } 54 55 void mmc_unregister_host_class(void) 56 { 57 class_unregister(&mmc_host_class); 58 } 59 60 void mmc_retune_enable(struct mmc_host *host) 61 { 62 host->can_retune = 1; 63 if (host->retune_period) 64 mod_timer(&host->retune_timer, 65 jiffies + host->retune_period * HZ); 66 } 67 68 /* 69 * Pause re-tuning for a small set of operations. The pause begins after the 70 * next command and after first doing re-tuning. 71 */ 72 void mmc_retune_pause(struct mmc_host *host) 73 { 74 if (!host->retune_paused) { 75 host->retune_paused = 1; 76 mmc_retune_needed(host); 77 mmc_retune_hold(host); 78 } 79 } 80 EXPORT_SYMBOL(mmc_retune_pause); 81 82 void mmc_retune_unpause(struct mmc_host *host) 83 { 84 if (host->retune_paused) { 85 host->retune_paused = 0; 86 mmc_retune_release(host); 87 } 88 } 89 EXPORT_SYMBOL(mmc_retune_unpause); 90 91 void mmc_retune_disable(struct mmc_host *host) 92 { 93 mmc_retune_unpause(host); 94 host->can_retune = 0; 95 del_timer_sync(&host->retune_timer); 96 host->retune_now = 0; 97 host->need_retune = 0; 98 } 99 100 void mmc_retune_timer_stop(struct mmc_host *host) 101 { 102 del_timer_sync(&host->retune_timer); 103 } 104 EXPORT_SYMBOL(mmc_retune_timer_stop); 105 106 void mmc_retune_hold(struct mmc_host *host) 107 { 108 if (!host->hold_retune) 109 host->retune_now = 1; 110 host->hold_retune += 1; 111 } 112 113 void mmc_retune_release(struct mmc_host *host) 114 { 115 if (host->hold_retune) 116 host->hold_retune -= 1; 117 else 118 WARN_ON(1); 119 } 120 121 int mmc_retune(struct mmc_host *host) 122 { 123 bool return_to_hs400 = false; 124 int err; 125 126 if (host->retune_now) 127 host->retune_now = 0; 128 else 129 return 0; 130 131 if (!host->need_retune || host->doing_retune || !host->card) 132 return 0; 133 134 host->need_retune = 0; 135 136 host->doing_retune = 1; 137 138 if (host->ios.timing == MMC_TIMING_MMC_HS400) { 139 err = mmc_hs400_to_hs200(host->card); 140 if (err) 141 goto out; 142 143 return_to_hs400 = true; 144 145 if (host->ops->prepare_hs400_tuning) 146 host->ops->prepare_hs400_tuning(host, &host->ios); 147 } 148 149 err = mmc_execute_tuning(host->card); 150 if (err) 151 goto out; 152 153 if (return_to_hs400) 154 err = mmc_hs200_to_hs400(host->card); 155 out: 156 host->doing_retune = 0; 157 158 return err; 159 } 160 161 static void mmc_retune_timer(unsigned long data) 162 { 163 struct mmc_host *host = (struct mmc_host *)data; 164 165 mmc_retune_needed(host); 166 } 167 168 /** 169 * mmc_of_parse() - parse host's device-tree node 170 * @host: host whose node should be parsed. 171 * 172 * To keep the rest of the MMC subsystem unaware of whether DT has been 173 * used to to instantiate and configure this host instance or not, we 174 * parse the properties and set respective generic mmc-host flags and 175 * parameters. 176 */ 177 int mmc_of_parse(struct mmc_host *host) 178 { 179 struct device_node *np; 180 u32 bus_width; 181 int ret; 182 bool cd_cap_invert, cd_gpio_invert = false; 183 bool ro_cap_invert, ro_gpio_invert = false; 184 185 if (!host->parent || !host->parent->of_node) 186 return 0; 187 188 np = host->parent->of_node; 189 190 /* "bus-width" is translated to MMC_CAP_*_BIT_DATA flags */ 191 if (of_property_read_u32(np, "bus-width", &bus_width) < 0) { 192 dev_dbg(host->parent, 193 "\"bus-width\" property is missing, assuming 1 bit.\n"); 194 bus_width = 1; 195 } 196 197 switch (bus_width) { 198 case 8: 199 host->caps |= MMC_CAP_8_BIT_DATA; 200 /* Hosts capable of 8-bit transfers can also do 4 bits */ 201 case 4: 202 host->caps |= MMC_CAP_4_BIT_DATA; 203 break; 204 case 1: 205 break; 206 default: 207 dev_err(host->parent, 208 "Invalid \"bus-width\" value %u!\n", bus_width); 209 return -EINVAL; 210 } 211 212 /* f_max is obtained from the optional "max-frequency" property */ 213 of_property_read_u32(np, "max-frequency", &host->f_max); 214 215 /* 216 * Configure CD and WP pins. They are both by default active low to 217 * match the SDHCI spec. If GPIOs are provided for CD and / or WP, the 218 * mmc-gpio helpers are used to attach, configure and use them. If 219 * polarity inversion is specified in DT, one of MMC_CAP2_CD_ACTIVE_HIGH 220 * and MMC_CAP2_RO_ACTIVE_HIGH capability-2 flags is set. If the 221 * "broken-cd" property is provided, the MMC_CAP_NEEDS_POLL capability 222 * is set. If the "non-removable" property is found, the 223 * MMC_CAP_NONREMOVABLE capability is set and no card-detection 224 * configuration is performed. 225 */ 226 227 /* Parse Card Detection */ 228 if (of_property_read_bool(np, "non-removable")) { 229 host->caps |= MMC_CAP_NONREMOVABLE; 230 } else { 231 cd_cap_invert = of_property_read_bool(np, "cd-inverted"); 232 233 if (of_property_read_bool(np, "broken-cd")) 234 host->caps |= MMC_CAP_NEEDS_POLL; 235 236 ret = mmc_gpiod_request_cd(host, "cd", 0, true, 237 0, &cd_gpio_invert); 238 if (!ret) 239 dev_info(host->parent, "Got CD GPIO\n"); 240 else if (ret != -ENOENT && ret != -ENOSYS) 241 return ret; 242 243 /* 244 * There are two ways to flag that the CD line is inverted: 245 * through the cd-inverted flag and by the GPIO line itself 246 * being inverted from the GPIO subsystem. This is a leftover 247 * from the times when the GPIO subsystem did not make it 248 * possible to flag a line as inverted. 249 * 250 * If the capability on the host AND the GPIO line are 251 * both inverted, the end result is that the CD line is 252 * not inverted. 253 */ 254 if (cd_cap_invert ^ cd_gpio_invert) 255 host->caps2 |= MMC_CAP2_CD_ACTIVE_HIGH; 256 } 257 258 /* Parse Write Protection */ 259 ro_cap_invert = of_property_read_bool(np, "wp-inverted"); 260 261 ret = mmc_gpiod_request_ro(host, "wp", 0, false, 0, &ro_gpio_invert); 262 if (!ret) 263 dev_info(host->parent, "Got WP GPIO\n"); 264 else if (ret != -ENOENT && ret != -ENOSYS) 265 return ret; 266 267 if (of_property_read_bool(np, "disable-wp")) 268 host->caps2 |= MMC_CAP2_NO_WRITE_PROTECT; 269 270 /* See the comment on CD inversion above */ 271 if (ro_cap_invert ^ ro_gpio_invert) 272 host->caps2 |= MMC_CAP2_RO_ACTIVE_HIGH; 273 274 if (of_property_read_bool(np, "cap-sd-highspeed")) 275 host->caps |= MMC_CAP_SD_HIGHSPEED; 276 if (of_property_read_bool(np, "cap-mmc-highspeed")) 277 host->caps |= MMC_CAP_MMC_HIGHSPEED; 278 if (of_property_read_bool(np, "sd-uhs-sdr12")) 279 host->caps |= MMC_CAP_UHS_SDR12; 280 if (of_property_read_bool(np, "sd-uhs-sdr25")) 281 host->caps |= MMC_CAP_UHS_SDR25; 282 if (of_property_read_bool(np, "sd-uhs-sdr50")) 283 host->caps |= MMC_CAP_UHS_SDR50; 284 if (of_property_read_bool(np, "sd-uhs-sdr104")) 285 host->caps |= MMC_CAP_UHS_SDR104; 286 if (of_property_read_bool(np, "sd-uhs-ddr50")) 287 host->caps |= MMC_CAP_UHS_DDR50; 288 if (of_property_read_bool(np, "cap-power-off-card")) 289 host->caps |= MMC_CAP_POWER_OFF_CARD; 290 if (of_property_read_bool(np, "cap-mmc-hw-reset")) 291 host->caps |= MMC_CAP_HW_RESET; 292 if (of_property_read_bool(np, "cap-sdio-irq")) 293 host->caps |= MMC_CAP_SDIO_IRQ; 294 if (of_property_read_bool(np, "full-pwr-cycle")) 295 host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE; 296 if (of_property_read_bool(np, "keep-power-in-suspend")) 297 host->pm_caps |= MMC_PM_KEEP_POWER; 298 if (of_property_read_bool(np, "wakeup-source") || 299 of_property_read_bool(np, "enable-sdio-wakeup")) /* legacy */ 300 host->pm_caps |= MMC_PM_WAKE_SDIO_IRQ; 301 if (of_property_read_bool(np, "mmc-ddr-3_3v")) 302 host->caps |= MMC_CAP_3_3V_DDR; 303 if (of_property_read_bool(np, "mmc-ddr-1_8v")) 304 host->caps |= MMC_CAP_1_8V_DDR; 305 if (of_property_read_bool(np, "mmc-ddr-1_2v")) 306 host->caps |= MMC_CAP_1_2V_DDR; 307 if (of_property_read_bool(np, "mmc-hs200-1_8v")) 308 host->caps2 |= MMC_CAP2_HS200_1_8V_SDR; 309 if (of_property_read_bool(np, "mmc-hs200-1_2v")) 310 host->caps2 |= MMC_CAP2_HS200_1_2V_SDR; 311 if (of_property_read_bool(np, "mmc-hs400-1_8v")) 312 host->caps2 |= MMC_CAP2_HS400_1_8V | MMC_CAP2_HS200_1_8V_SDR; 313 if (of_property_read_bool(np, "mmc-hs400-1_2v")) 314 host->caps2 |= MMC_CAP2_HS400_1_2V | MMC_CAP2_HS200_1_2V_SDR; 315 if (of_property_read_bool(np, "mmc-hs400-enhanced-strobe")) 316 host->caps2 |= MMC_CAP2_HS400_ES; 317 if (of_property_read_bool(np, "no-sdio")) 318 host->caps2 |= MMC_CAP2_NO_SDIO; 319 if (of_property_read_bool(np, "no-sd")) 320 host->caps2 |= MMC_CAP2_NO_SD; 321 if (of_property_read_bool(np, "no-mmc")) 322 host->caps2 |= MMC_CAP2_NO_MMC; 323 324 host->dsr_req = !of_property_read_u32(np, "dsr", &host->dsr); 325 if (host->dsr_req && (host->dsr & ~0xffff)) { 326 dev_err(host->parent, 327 "device tree specified broken value for DSR: 0x%x, ignoring\n", 328 host->dsr); 329 host->dsr_req = 0; 330 } 331 332 return mmc_pwrseq_alloc(host); 333 } 334 335 EXPORT_SYMBOL(mmc_of_parse); 336 337 /** 338 * mmc_alloc_host - initialise the per-host structure. 339 * @extra: sizeof private data structure 340 * @dev: pointer to host device model structure 341 * 342 * Initialise the per-host structure. 343 */ 344 struct mmc_host *mmc_alloc_host(int extra, struct device *dev) 345 { 346 int err; 347 struct mmc_host *host; 348 349 host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL); 350 if (!host) 351 return NULL; 352 353 /* scanning will be enabled when we're ready */ 354 host->rescan_disable = 1; 355 356 err = ida_simple_get(&mmc_host_ida, 0, 0, GFP_KERNEL); 357 if (err < 0) { 358 kfree(host); 359 return NULL; 360 } 361 362 host->index = err; 363 364 dev_set_name(&host->class_dev, "mmc%d", host->index); 365 366 host->parent = dev; 367 host->class_dev.parent = dev; 368 host->class_dev.class = &mmc_host_class; 369 device_initialize(&host->class_dev); 370 device_enable_async_suspend(&host->class_dev); 371 372 if (mmc_gpio_alloc(host)) { 373 put_device(&host->class_dev); 374 ida_simple_remove(&mmc_host_ida, host->index); 375 kfree(host); 376 return NULL; 377 } 378 379 spin_lock_init(&host->lock); 380 init_waitqueue_head(&host->wq); 381 INIT_DELAYED_WORK(&host->detect, mmc_rescan); 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