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 #include <linux/suspend.h> 25 26 #include <linux/mmc/host.h> 27 #include <linux/mmc/card.h> 28 #include <linux/mmc/slot-gpio.h> 29 30 #include "core.h" 31 #include "host.h" 32 #include "slot-gpio.h" 33 #include "pwrseq.h" 34 35 #define cls_dev_to_mmc_host(d) container_of(d, struct mmc_host, class_dev) 36 37 static DEFINE_IDR(mmc_host_idr); 38 static DEFINE_SPINLOCK(mmc_host_lock); 39 40 static void mmc_host_classdev_release(struct device *dev) 41 { 42 struct mmc_host *host = cls_dev_to_mmc_host(dev); 43 spin_lock(&mmc_host_lock); 44 idr_remove(&mmc_host_idr, host->index); 45 spin_unlock(&mmc_host_lock); 46 kfree(host); 47 } 48 49 static struct class mmc_host_class = { 50 .name = "mmc_host", 51 .dev_release = mmc_host_classdev_release, 52 }; 53 54 int mmc_register_host_class(void) 55 { 56 return class_register(&mmc_host_class); 57 } 58 59 void mmc_unregister_host_class(void) 60 { 61 class_unregister(&mmc_host_class); 62 } 63 64 void mmc_retune_enable(struct mmc_host *host) 65 { 66 host->can_retune = 1; 67 if (host->retune_period) 68 mod_timer(&host->retune_timer, 69 jiffies + host->retune_period * HZ); 70 } 71 72 void mmc_retune_disable(struct mmc_host *host) 73 { 74 host->can_retune = 0; 75 del_timer_sync(&host->retune_timer); 76 host->retune_now = 0; 77 host->need_retune = 0; 78 } 79 80 void mmc_retune_timer_stop(struct mmc_host *host) 81 { 82 del_timer_sync(&host->retune_timer); 83 } 84 EXPORT_SYMBOL(mmc_retune_timer_stop); 85 86 void mmc_retune_hold(struct mmc_host *host) 87 { 88 if (!host->hold_retune) 89 host->retune_now = 1; 90 host->hold_retune += 1; 91 } 92 93 void mmc_retune_release(struct mmc_host *host) 94 { 95 if (host->hold_retune) 96 host->hold_retune -= 1; 97 else 98 WARN_ON(1); 99 } 100 101 int mmc_retune(struct mmc_host *host) 102 { 103 bool return_to_hs400 = false; 104 int err; 105 106 if (host->retune_now) 107 host->retune_now = 0; 108 else 109 return 0; 110 111 if (!host->need_retune || host->doing_retune || !host->card) 112 return 0; 113 114 host->need_retune = 0; 115 116 host->doing_retune = 1; 117 118 if (host->ios.timing == MMC_TIMING_MMC_HS400) { 119 err = mmc_hs400_to_hs200(host->card); 120 if (err) 121 goto out; 122 123 return_to_hs400 = true; 124 125 if (host->ops->prepare_hs400_tuning) 126 host->ops->prepare_hs400_tuning(host, &host->ios); 127 } 128 129 err = mmc_execute_tuning(host->card); 130 if (err) 131 goto out; 132 133 if (return_to_hs400) 134 err = mmc_hs200_to_hs400(host->card); 135 out: 136 host->doing_retune = 0; 137 138 return err; 139 } 140 141 static void mmc_retune_timer(unsigned long data) 142 { 143 struct mmc_host *host = (struct mmc_host *)data; 144 145 mmc_retune_needed(host); 146 } 147 148 /** 149 * mmc_of_parse() - parse host's device-tree node 150 * @host: host whose node should be parsed. 151 * 152 * To keep the rest of the MMC subsystem unaware of whether DT has been 153 * used to to instantiate and configure this host instance or not, we 154 * parse the properties and set respective generic mmc-host flags and 155 * parameters. 156 */ 157 int mmc_of_parse(struct mmc_host *host) 158 { 159 struct device_node *np; 160 u32 bus_width; 161 int ret; 162 bool cd_cap_invert, cd_gpio_invert = false; 163 bool ro_cap_invert, ro_gpio_invert = false; 164 165 if (!host->parent || !host->parent->of_node) 166 return 0; 167 168 np = host->parent->of_node; 169 170 /* "bus-width" is translated to MMC_CAP_*_BIT_DATA flags */ 171 if (of_property_read_u32(np, "bus-width", &bus_width) < 0) { 172 dev_dbg(host->parent, 173 "\"bus-width\" property is missing, assuming 1 bit.\n"); 174 bus_width = 1; 175 } 176 177 switch (bus_width) { 178 case 8: 179 host->caps |= MMC_CAP_8_BIT_DATA; 180 /* Hosts capable of 8-bit transfers can also do 4 bits */ 181 case 4: 182 host->caps |= MMC_CAP_4_BIT_DATA; 183 break; 184 case 1: 185 break; 186 default: 187 dev_err(host->parent, 188 "Invalid \"bus-width\" value %u!\n", bus_width); 189 return -EINVAL; 190 } 191 192 /* f_max is obtained from the optional "max-frequency" property */ 193 of_property_read_u32(np, "max-frequency", &host->f_max); 194 195 /* 196 * Configure CD and WP pins. They are both by default active low to 197 * match the SDHCI spec. If GPIOs are provided for CD and / or WP, the 198 * mmc-gpio helpers are used to attach, configure and use them. If 199 * polarity inversion is specified in DT, one of MMC_CAP2_CD_ACTIVE_HIGH 200 * and MMC_CAP2_RO_ACTIVE_HIGH capability-2 flags is set. If the 201 * "broken-cd" property is provided, the MMC_CAP_NEEDS_POLL capability 202 * is set. If the "non-removable" property is found, the 203 * MMC_CAP_NONREMOVABLE capability is set and no card-detection 204 * configuration is performed. 205 */ 206 207 /* Parse Card Detection */ 208 if (of_property_read_bool(np, "non-removable")) { 209 host->caps |= MMC_CAP_NONREMOVABLE; 210 } else { 211 cd_cap_invert = of_property_read_bool(np, "cd-inverted"); 212 213 if (of_property_read_bool(np, "broken-cd")) 214 host->caps |= MMC_CAP_NEEDS_POLL; 215 216 ret = mmc_gpiod_request_cd(host, "cd", 0, true, 217 0, &cd_gpio_invert); 218 if (!ret) 219 dev_info(host->parent, "Got CD GPIO\n"); 220 else if (ret != -ENOENT && ret != -ENOSYS) 221 return ret; 222 223 /* 224 * There are two ways to flag that the CD line is inverted: 225 * through the cd-inverted flag and by the GPIO line itself 226 * being inverted from the GPIO subsystem. This is a leftover 227 * from the times when the GPIO subsystem did not make it 228 * possible to flag a line as inverted. 229 * 230 * If the capability on the host AND the GPIO line are 231 * both inverted, the end result is that the CD line is 232 * not inverted. 233 */ 234 if (cd_cap_invert ^ cd_gpio_invert) 235 host->caps2 |= MMC_CAP2_CD_ACTIVE_HIGH; 236 } 237 238 /* Parse Write Protection */ 239 ro_cap_invert = of_property_read_bool(np, "wp-inverted"); 240 241 ret = mmc_gpiod_request_ro(host, "wp", 0, false, 0, &ro_gpio_invert); 242 if (!ret) 243 dev_info(host->parent, "Got WP GPIO\n"); 244 else if (ret != -ENOENT && ret != -ENOSYS) 245 return ret; 246 247 if (of_property_read_bool(np, "disable-wp")) 248 host->caps2 |= MMC_CAP2_NO_WRITE_PROTECT; 249 250 /* See the comment on CD inversion above */ 251 if (ro_cap_invert ^ ro_gpio_invert) 252 host->caps2 |= MMC_CAP2_RO_ACTIVE_HIGH; 253 254 if (of_property_read_bool(np, "cap-sd-highspeed")) 255 host->caps |= MMC_CAP_SD_HIGHSPEED; 256 if (of_property_read_bool(np, "cap-mmc-highspeed")) 257 host->caps |= MMC_CAP_MMC_HIGHSPEED; 258 if (of_property_read_bool(np, "sd-uhs-sdr12")) 259 host->caps |= MMC_CAP_UHS_SDR12; 260 if (of_property_read_bool(np, "sd-uhs-sdr25")) 261 host->caps |= MMC_CAP_UHS_SDR25; 262 if (of_property_read_bool(np, "sd-uhs-sdr50")) 263 host->caps |= MMC_CAP_UHS_SDR50; 264 if (of_property_read_bool(np, "sd-uhs-sdr104")) 265 host->caps |= MMC_CAP_UHS_SDR104; 266 if (of_property_read_bool(np, "sd-uhs-ddr50")) 267 host->caps |= MMC_CAP_UHS_DDR50; 268 if (of_property_read_bool(np, "cap-power-off-card")) 269 host->caps |= MMC_CAP_POWER_OFF_CARD; 270 if (of_property_read_bool(np, "cap-mmc-hw-reset")) 271 host->caps |= MMC_CAP_HW_RESET; 272 if (of_property_read_bool(np, "cap-sdio-irq")) 273 host->caps |= MMC_CAP_SDIO_IRQ; 274 if (of_property_read_bool(np, "full-pwr-cycle")) 275 host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE; 276 if (of_property_read_bool(np, "keep-power-in-suspend")) 277 host->pm_caps |= MMC_PM_KEEP_POWER; 278 if (of_property_read_bool(np, "enable-sdio-wakeup")) 279 host->pm_caps |= MMC_PM_WAKE_SDIO_IRQ; 280 if (of_property_read_bool(np, "mmc-ddr-1_8v")) 281 host->caps |= MMC_CAP_1_8V_DDR; 282 if (of_property_read_bool(np, "mmc-ddr-1_2v")) 283 host->caps |= MMC_CAP_1_2V_DDR; 284 if (of_property_read_bool(np, "mmc-hs200-1_8v")) 285 host->caps2 |= MMC_CAP2_HS200_1_8V_SDR; 286 if (of_property_read_bool(np, "mmc-hs200-1_2v")) 287 host->caps2 |= MMC_CAP2_HS200_1_2V_SDR; 288 if (of_property_read_bool(np, "mmc-hs400-1_8v")) 289 host->caps2 |= MMC_CAP2_HS400_1_8V | MMC_CAP2_HS200_1_8V_SDR; 290 if (of_property_read_bool(np, "mmc-hs400-1_2v")) 291 host->caps2 |= MMC_CAP2_HS400_1_2V | MMC_CAP2_HS200_1_2V_SDR; 292 293 host->dsr_req = !of_property_read_u32(np, "dsr", &host->dsr); 294 if (host->dsr_req && (host->dsr & ~0xffff)) { 295 dev_err(host->parent, 296 "device tree specified broken value for DSR: 0x%x, ignoring\n", 297 host->dsr); 298 host->dsr_req = 0; 299 } 300 301 return mmc_pwrseq_alloc(host); 302 } 303 304 EXPORT_SYMBOL(mmc_of_parse); 305 306 /** 307 * mmc_alloc_host - initialise the per-host structure. 308 * @extra: sizeof private data structure 309 * @dev: pointer to host device model structure 310 * 311 * Initialise the per-host structure. 312 */ 313 struct mmc_host *mmc_alloc_host(int extra, struct device *dev) 314 { 315 int err; 316 struct mmc_host *host; 317 318 host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL); 319 if (!host) 320 return NULL; 321 322 /* scanning will be enabled when we're ready */ 323 host->rescan_disable = 1; 324 idr_preload(GFP_KERNEL); 325 spin_lock(&mmc_host_lock); 326 err = idr_alloc(&mmc_host_idr, host, 0, 0, GFP_NOWAIT); 327 if (err >= 0) 328 host->index = err; 329 spin_unlock(&mmc_host_lock); 330 idr_preload_end(); 331 if (err < 0) { 332 kfree(host); 333 return NULL; 334 } 335 336 dev_set_name(&host->class_dev, "mmc%d", host->index); 337 338 host->parent = dev; 339 host->class_dev.parent = dev; 340 host->class_dev.class = &mmc_host_class; 341 device_initialize(&host->class_dev); 342 343 if (mmc_gpio_alloc(host)) { 344 put_device(&host->class_dev); 345 return NULL; 346 } 347 348 spin_lock_init(&host->lock); 349 init_waitqueue_head(&host->wq); 350 INIT_DELAYED_WORK(&host->detect, mmc_rescan); 351 #ifdef CONFIG_PM 352 host->pm_notify.notifier_call = mmc_pm_notify; 353 #endif 354 setup_timer(&host->retune_timer, mmc_retune_timer, (unsigned long)host); 355 356 /* 357 * By default, hosts do not support SGIO or large requests. 358 * They have to set these according to their abilities. 359 */ 360 host->max_segs = 1; 361 host->max_seg_size = PAGE_CACHE_SIZE; 362 363 host->max_req_size = PAGE_CACHE_SIZE; 364 host->max_blk_size = 512; 365 host->max_blk_count = PAGE_CACHE_SIZE / 512; 366 367 return host; 368 } 369 370 EXPORT_SYMBOL(mmc_alloc_host); 371 372 /** 373 * mmc_add_host - initialise host hardware 374 * @host: mmc host 375 * 376 * Register the host with the driver model. The host must be 377 * prepared to start servicing requests before this function 378 * completes. 379 */ 380 int mmc_add_host(struct mmc_host *host) 381 { 382 int err; 383 384 WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) && 385 !host->ops->enable_sdio_irq); 386 387 err = device_add(&host->class_dev); 388 if (err) 389 return err; 390 391 led_trigger_register_simple(dev_name(&host->class_dev), &host->led); 392 393 #ifdef CONFIG_DEBUG_FS 394 mmc_add_host_debugfs(host); 395 #endif 396 397 mmc_start_host(host); 398 register_pm_notifier(&host->pm_notify); 399 400 return 0; 401 } 402 403 EXPORT_SYMBOL(mmc_add_host); 404 405 /** 406 * mmc_remove_host - remove host hardware 407 * @host: mmc host 408 * 409 * Unregister and remove all cards associated with this host, 410 * and power down the MMC bus. No new requests will be issued 411 * after this function has returned. 412 */ 413 void mmc_remove_host(struct mmc_host *host) 414 { 415 unregister_pm_notifier(&host->pm_notify); 416 mmc_stop_host(host); 417 418 #ifdef CONFIG_DEBUG_FS 419 mmc_remove_host_debugfs(host); 420 #endif 421 422 device_del(&host->class_dev); 423 424 led_trigger_unregister_simple(host->led); 425 } 426 427 EXPORT_SYMBOL(mmc_remove_host); 428 429 /** 430 * mmc_free_host - free the host structure 431 * @host: mmc host 432 * 433 * Free the host once all references to it have been dropped. 434 */ 435 void mmc_free_host(struct mmc_host *host) 436 { 437 mmc_pwrseq_free(host); 438 put_device(&host->class_dev); 439 } 440 441 EXPORT_SYMBOL(mmc_free_host); 442