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