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_IDR(mmc_host_idr); 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 idr_remove(&mmc_host_idr, 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 void mmc_retune_disable(struct mmc_host *host) 72 { 73 host->can_retune = 0; 74 del_timer_sync(&host->retune_timer); 75 host->retune_now = 0; 76 host->need_retune = 0; 77 } 78 79 void mmc_retune_timer_stop(struct mmc_host *host) 80 { 81 del_timer_sync(&host->retune_timer); 82 } 83 EXPORT_SYMBOL(mmc_retune_timer_stop); 84 85 void mmc_retune_hold(struct mmc_host *host) 86 { 87 if (!host->hold_retune) 88 host->retune_now = 1; 89 host->hold_retune += 1; 90 } 91 92 void mmc_retune_release(struct mmc_host *host) 93 { 94 if (host->hold_retune) 95 host->hold_retune -= 1; 96 else 97 WARN_ON(1); 98 } 99 100 int mmc_retune(struct mmc_host *host) 101 { 102 bool return_to_hs400 = false; 103 int err; 104 105 if (host->retune_now) 106 host->retune_now = 0; 107 else 108 return 0; 109 110 if (!host->need_retune || host->doing_retune || !host->card) 111 return 0; 112 113 host->need_retune = 0; 114 115 host->doing_retune = 1; 116 117 if (host->ios.timing == MMC_TIMING_MMC_HS400) { 118 err = mmc_hs400_to_hs200(host->card); 119 if (err) 120 goto out; 121 122 return_to_hs400 = true; 123 124 if (host->ops->prepare_hs400_tuning) 125 host->ops->prepare_hs400_tuning(host, &host->ios); 126 } 127 128 err = mmc_execute_tuning(host->card); 129 if (err) 130 goto out; 131 132 if (return_to_hs400) 133 err = mmc_hs200_to_hs400(host->card); 134 out: 135 host->doing_retune = 0; 136 137 return err; 138 } 139 140 static void mmc_retune_timer(unsigned long data) 141 { 142 struct mmc_host *host = (struct mmc_host *)data; 143 144 mmc_retune_needed(host); 145 } 146 147 /** 148 * mmc_of_parse() - parse host's device-tree node 149 * @host: host whose node should be parsed. 150 * 151 * To keep the rest of the MMC subsystem unaware of whether DT has been 152 * used to to instantiate and configure this host instance or not, we 153 * parse the properties and set respective generic mmc-host flags and 154 * parameters. 155 */ 156 int mmc_of_parse(struct mmc_host *host) 157 { 158 struct device_node *np; 159 u32 bus_width; 160 int ret; 161 bool cd_cap_invert, cd_gpio_invert = false; 162 bool ro_cap_invert, ro_gpio_invert = false; 163 164 if (!host->parent || !host->parent->of_node) 165 return 0; 166 167 np = host->parent->of_node; 168 169 /* "bus-width" is translated to MMC_CAP_*_BIT_DATA flags */ 170 if (of_property_read_u32(np, "bus-width", &bus_width) < 0) { 171 dev_dbg(host->parent, 172 "\"bus-width\" property is missing, assuming 1 bit.\n"); 173 bus_width = 1; 174 } 175 176 switch (bus_width) { 177 case 8: 178 host->caps |= MMC_CAP_8_BIT_DATA; 179 /* Hosts capable of 8-bit transfers can also do 4 bits */ 180 case 4: 181 host->caps |= MMC_CAP_4_BIT_DATA; 182 break; 183 case 1: 184 break; 185 default: 186 dev_err(host->parent, 187 "Invalid \"bus-width\" value %u!\n", bus_width); 188 return -EINVAL; 189 } 190 191 /* f_max is obtained from the optional "max-frequency" property */ 192 of_property_read_u32(np, "max-frequency", &host->f_max); 193 194 /* 195 * Configure CD and WP pins. They are both by default active low to 196 * match the SDHCI spec. If GPIOs are provided for CD and / or WP, the 197 * mmc-gpio helpers are used to attach, configure and use them. If 198 * polarity inversion is specified in DT, one of MMC_CAP2_CD_ACTIVE_HIGH 199 * and MMC_CAP2_RO_ACTIVE_HIGH capability-2 flags is set. If the 200 * "broken-cd" property is provided, the MMC_CAP_NEEDS_POLL capability 201 * is set. If the "non-removable" property is found, the 202 * MMC_CAP_NONREMOVABLE capability is set and no card-detection 203 * configuration is performed. 204 */ 205 206 /* Parse Card Detection */ 207 if (of_property_read_bool(np, "non-removable")) { 208 host->caps |= MMC_CAP_NONREMOVABLE; 209 } else { 210 cd_cap_invert = of_property_read_bool(np, "cd-inverted"); 211 212 if (of_property_read_bool(np, "broken-cd")) 213 host->caps |= MMC_CAP_NEEDS_POLL; 214 215 ret = mmc_gpiod_request_cd(host, "cd", 0, true, 216 0, &cd_gpio_invert); 217 if (!ret) 218 dev_info(host->parent, "Got CD GPIO\n"); 219 else if (ret != -ENOENT && ret != -ENOSYS) 220 return ret; 221 222 /* 223 * There are two ways to flag that the CD line is inverted: 224 * through the cd-inverted flag and by the GPIO line itself 225 * being inverted from the GPIO subsystem. This is a leftover 226 * from the times when the GPIO subsystem did not make it 227 * possible to flag a line as inverted. 228 * 229 * If the capability on the host AND the GPIO line are 230 * both inverted, the end result is that the CD line is 231 * not inverted. 232 */ 233 if (cd_cap_invert ^ cd_gpio_invert) 234 host->caps2 |= MMC_CAP2_CD_ACTIVE_HIGH; 235 } 236 237 /* Parse Write Protection */ 238 ro_cap_invert = of_property_read_bool(np, "wp-inverted"); 239 240 ret = mmc_gpiod_request_ro(host, "wp", 0, false, 0, &ro_gpio_invert); 241 if (!ret) 242 dev_info(host->parent, "Got WP GPIO\n"); 243 else if (ret != -ENOENT && ret != -ENOSYS) 244 return ret; 245 246 if (of_property_read_bool(np, "disable-wp")) 247 host->caps2 |= MMC_CAP2_NO_WRITE_PROTECT; 248 249 /* See the comment on CD inversion above */ 250 if (ro_cap_invert ^ ro_gpio_invert) 251 host->caps2 |= MMC_CAP2_RO_ACTIVE_HIGH; 252 253 if (of_property_read_bool(np, "cap-sd-highspeed")) 254 host->caps |= MMC_CAP_SD_HIGHSPEED; 255 if (of_property_read_bool(np, "cap-mmc-highspeed")) 256 host->caps |= MMC_CAP_MMC_HIGHSPEED; 257 if (of_property_read_bool(np, "sd-uhs-sdr12")) 258 host->caps |= MMC_CAP_UHS_SDR12; 259 if (of_property_read_bool(np, "sd-uhs-sdr25")) 260 host->caps |= MMC_CAP_UHS_SDR25; 261 if (of_property_read_bool(np, "sd-uhs-sdr50")) 262 host->caps |= MMC_CAP_UHS_SDR50; 263 if (of_property_read_bool(np, "sd-uhs-sdr104")) 264 host->caps |= MMC_CAP_UHS_SDR104; 265 if (of_property_read_bool(np, "sd-uhs-ddr50")) 266 host->caps |= MMC_CAP_UHS_DDR50; 267 if (of_property_read_bool(np, "cap-power-off-card")) 268 host->caps |= MMC_CAP_POWER_OFF_CARD; 269 if (of_property_read_bool(np, "cap-mmc-hw-reset")) 270 host->caps |= MMC_CAP_HW_RESET; 271 if (of_property_read_bool(np, "cap-sdio-irq")) 272 host->caps |= MMC_CAP_SDIO_IRQ; 273 if (of_property_read_bool(np, "full-pwr-cycle")) 274 host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE; 275 if (of_property_read_bool(np, "keep-power-in-suspend")) 276 host->pm_caps |= MMC_PM_KEEP_POWER; 277 if (of_property_read_bool(np, "wakeup-source") || 278 of_property_read_bool(np, "enable-sdio-wakeup")) /* legacy */ 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 setup_timer(&host->retune_timer, mmc_retune_timer, (unsigned long)host); 352 353 /* 354 * By default, hosts do not support SGIO or large requests. 355 * They have to set these according to their abilities. 356 */ 357 host->max_segs = 1; 358 host->max_seg_size = PAGE_CACHE_SIZE; 359 360 host->max_req_size = PAGE_CACHE_SIZE; 361 host->max_blk_size = 512; 362 host->max_blk_count = PAGE_CACHE_SIZE / 512; 363 364 return host; 365 } 366 367 EXPORT_SYMBOL(mmc_alloc_host); 368 369 /** 370 * mmc_add_host - initialise host hardware 371 * @host: mmc host 372 * 373 * Register the host with the driver model. The host must be 374 * prepared to start servicing requests before this function 375 * completes. 376 */ 377 int mmc_add_host(struct mmc_host *host) 378 { 379 int err; 380 381 WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) && 382 !host->ops->enable_sdio_irq); 383 384 err = device_add(&host->class_dev); 385 if (err) 386 return err; 387 388 led_trigger_register_simple(dev_name(&host->class_dev), &host->led); 389 390 #ifdef CONFIG_DEBUG_FS 391 mmc_add_host_debugfs(host); 392 #endif 393 394 mmc_start_host(host); 395 mmc_register_pm_notifier(host); 396 397 return 0; 398 } 399 400 EXPORT_SYMBOL(mmc_add_host); 401 402 /** 403 * mmc_remove_host - remove host hardware 404 * @host: mmc host 405 * 406 * Unregister and remove all cards associated with this host, 407 * and power down the MMC bus. No new requests will be issued 408 * after this function has returned. 409 */ 410 void mmc_remove_host(struct mmc_host *host) 411 { 412 mmc_unregister_pm_notifier(host); 413 mmc_stop_host(host); 414 415 #ifdef CONFIG_DEBUG_FS 416 mmc_remove_host_debugfs(host); 417 #endif 418 419 device_del(&host->class_dev); 420 421 led_trigger_unregister_simple(host->led); 422 } 423 424 EXPORT_SYMBOL(mmc_remove_host); 425 426 /** 427 * mmc_free_host - free the host structure 428 * @host: mmc host 429 * 430 * Free the host once all references to it have been dropped. 431 */ 432 void mmc_free_host(struct mmc_host *host) 433 { 434 mmc_pwrseq_free(host); 435 put_device(&host->class_dev); 436 } 437 438 EXPORT_SYMBOL(mmc_free_host); 439