host.c 13 KB

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