Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 1 | /* |
| 2 | * linux/drivers/mmc/core/host.c |
| 3 | * |
| 4 | * Copyright (C) 2003 Russell King, All Rights Reserved. |
Pierre Ossman | ff3112f | 2008-03-08 23:43:19 +0100 | [diff] [blame] | 5 | * Copyright (C) 2007-2008 Pierre Ossman |
Linus Walleij | 0456683 | 2010-11-08 21:36:50 -0500 | [diff] [blame] | 6 | * Copyright (C) 2010 Linus Walleij |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 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> |
Guennadi Liakhovetski | 6c56e7a | 2013-02-16 16:21:16 +0100 | [diff] [blame] | 18 | #include <linux/of.h> |
| 19 | #include <linux/of_gpio.h> |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 20 | #include <linux/pagemap.h> |
Paul Gortmaker | 3ef77af | 2011-07-10 12:42:00 -0400 | [diff] [blame] | 21 | #include <linux/export.h> |
Pierre Ossman | af8350c | 2007-09-24 07:15:48 +0200 | [diff] [blame] | 22 | #include <linux/leds.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 23 | #include <linux/slab.h> |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 24 | |
| 25 | #include <linux/mmc/host.h> |
Linus Walleij | 0456683 | 2010-11-08 21:36:50 -0500 | [diff] [blame] | 26 | #include <linux/mmc/card.h> |
Guennadi Liakhovetski | 6c56e7a | 2013-02-16 16:21:16 +0100 | [diff] [blame] | 27 | #include <linux/mmc/slot-gpio.h> |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 28 | |
| 29 | #include "core.h" |
| 30 | #include "host.h" |
Ulf Hansson | df8aca1 | 2014-12-18 15:44:36 +0100 | [diff] [blame] | 31 | #include "slot-gpio.h" |
Ulf Hansson | 3aa8793 | 2014-11-28 14:38:36 +0100 | [diff] [blame] | 32 | #include "pwrseq.h" |
Ulf Hansson | 6826966 | 2017-04-13 16:48:11 +0200 | [diff] [blame] | 33 | #include "sdio_ops.h" |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 34 | |
| 35 | #define cls_dev_to_mmc_host(d) container_of(d, struct mmc_host, class_dev) |
| 36 | |
Ulf Hansson | 5674a9b | 2016-04-07 11:40:59 +0200 | [diff] [blame] | 37 | static DEFINE_IDA(mmc_host_ida); |
Ulf Hansson | e2d1926 | 2014-12-18 15:44:35 +0100 | [diff] [blame] | 38 | |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 39 | static void mmc_host_classdev_release(struct device *dev) |
| 40 | { |
| 41 | struct mmc_host *host = cls_dev_to_mmc_host(dev); |
Heiner Kallweit | 7413d1f | 2017-01-28 09:32:35 +0100 | [diff] [blame] | 42 | ida_simple_remove(&mmc_host_ida, host->index); |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 43 | kfree(host); |
| 44 | } |
| 45 | |
| 46 | static struct class mmc_host_class = { |
| 47 | .name = "mmc_host", |
| 48 | .dev_release = mmc_host_classdev_release, |
| 49 | }; |
| 50 | |
| 51 | int mmc_register_host_class(void) |
| 52 | { |
| 53 | return class_register(&mmc_host_class); |
| 54 | } |
| 55 | |
| 56 | void mmc_unregister_host_class(void) |
| 57 | { |
| 58 | class_unregister(&mmc_host_class); |
| 59 | } |
| 60 | |
Adrian Hunter | dfa13eb | 2015-05-07 13:10:12 +0300 | [diff] [blame] | 61 | void mmc_retune_enable(struct mmc_host *host) |
| 62 | { |
| 63 | host->can_retune = 1; |
| 64 | if (host->retune_period) |
| 65 | mod_timer(&host->retune_timer, |
| 66 | jiffies + host->retune_period * HZ); |
| 67 | } |
| 68 | |
Adrian Hunter | 7ff2760 | 2016-05-16 15:35:24 +0300 | [diff] [blame] | 69 | /* |
| 70 | * Pause re-tuning for a small set of operations. The pause begins after the |
| 71 | * next command and after first doing re-tuning. |
| 72 | */ |
| 73 | void mmc_retune_pause(struct mmc_host *host) |
| 74 | { |
| 75 | if (!host->retune_paused) { |
| 76 | host->retune_paused = 1; |
| 77 | mmc_retune_needed(host); |
| 78 | mmc_retune_hold(host); |
| 79 | } |
| 80 | } |
| 81 | EXPORT_SYMBOL(mmc_retune_pause); |
| 82 | |
| 83 | void mmc_retune_unpause(struct mmc_host *host) |
| 84 | { |
| 85 | if (host->retune_paused) { |
| 86 | host->retune_paused = 0; |
| 87 | mmc_retune_release(host); |
| 88 | } |
| 89 | } |
| 90 | EXPORT_SYMBOL(mmc_retune_unpause); |
| 91 | |
Adrian Hunter | dfa13eb | 2015-05-07 13:10:12 +0300 | [diff] [blame] | 92 | void mmc_retune_disable(struct mmc_host *host) |
| 93 | { |
Adrian Hunter | 7ff2760 | 2016-05-16 15:35:24 +0300 | [diff] [blame] | 94 | mmc_retune_unpause(host); |
Adrian Hunter | dfa13eb | 2015-05-07 13:10:12 +0300 | [diff] [blame] | 95 | host->can_retune = 0; |
| 96 | del_timer_sync(&host->retune_timer); |
| 97 | host->retune_now = 0; |
| 98 | host->need_retune = 0; |
| 99 | } |
| 100 | |
| 101 | void mmc_retune_timer_stop(struct mmc_host *host) |
| 102 | { |
| 103 | del_timer_sync(&host->retune_timer); |
| 104 | } |
| 105 | EXPORT_SYMBOL(mmc_retune_timer_stop); |
| 106 | |
| 107 | void mmc_retune_hold(struct mmc_host *host) |
| 108 | { |
| 109 | if (!host->hold_retune) |
| 110 | host->retune_now = 1; |
| 111 | host->hold_retune += 1; |
| 112 | } |
| 113 | |
| 114 | void mmc_retune_release(struct mmc_host *host) |
| 115 | { |
| 116 | if (host->hold_retune) |
| 117 | host->hold_retune -= 1; |
| 118 | else |
| 119 | WARN_ON(1); |
| 120 | } |
Adrian Hunter | cb39f61 | 2017-09-22 15:36:59 +0300 | [diff] [blame] | 121 | EXPORT_SYMBOL(mmc_retune_release); |
Adrian Hunter | dfa13eb | 2015-05-07 13:10:12 +0300 | [diff] [blame] | 122 | |
| 123 | int mmc_retune(struct mmc_host *host) |
| 124 | { |
Adrian Hunter | 6376f69 | 2015-05-07 13:10:20 +0300 | [diff] [blame] | 125 | bool return_to_hs400 = false; |
Adrian Hunter | dfa13eb | 2015-05-07 13:10:12 +0300 | [diff] [blame] | 126 | int err; |
| 127 | |
| 128 | if (host->retune_now) |
| 129 | host->retune_now = 0; |
| 130 | else |
| 131 | return 0; |
| 132 | |
| 133 | if (!host->need_retune || host->doing_retune || !host->card) |
| 134 | return 0; |
| 135 | |
| 136 | host->need_retune = 0; |
| 137 | |
| 138 | host->doing_retune = 1; |
| 139 | |
Adrian Hunter | 6376f69 | 2015-05-07 13:10:20 +0300 | [diff] [blame] | 140 | if (host->ios.timing == MMC_TIMING_MMC_HS400) { |
| 141 | err = mmc_hs400_to_hs200(host->card); |
| 142 | if (err) |
| 143 | goto out; |
Adrian Hunter | dfa13eb | 2015-05-07 13:10:12 +0300 | [diff] [blame] | 144 | |
Adrian Hunter | 6376f69 | 2015-05-07 13:10:20 +0300 | [diff] [blame] | 145 | return_to_hs400 = true; |
Adrian Hunter | 6376f69 | 2015-05-07 13:10:20 +0300 | [diff] [blame] | 146 | } |
| 147 | |
| 148 | err = mmc_execute_tuning(host->card); |
| 149 | if (err) |
| 150 | goto out; |
| 151 | |
| 152 | if (return_to_hs400) |
| 153 | err = mmc_hs200_to_hs400(host->card); |
| 154 | out: |
Adrian Hunter | dfa13eb | 2015-05-07 13:10:12 +0300 | [diff] [blame] | 155 | host->doing_retune = 0; |
| 156 | |
| 157 | return err; |
| 158 | } |
| 159 | |
Kees Cook | e99e88a | 2017-10-16 14:43:17 -0700 | [diff] [blame] | 160 | static void mmc_retune_timer(struct timer_list *t) |
Adrian Hunter | dfa13eb | 2015-05-07 13:10:12 +0300 | [diff] [blame] | 161 | { |
Kees Cook | e99e88a | 2017-10-16 14:43:17 -0700 | [diff] [blame] | 162 | struct mmc_host *host = from_timer(host, t, retune_timer); |
Adrian Hunter | dfa13eb | 2015-05-07 13:10:12 +0300 | [diff] [blame] | 163 | |
| 164 | mmc_retune_needed(host); |
| 165 | } |
| 166 | |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 167 | /** |
Guennadi Liakhovetski | 6c56e7a | 2013-02-16 16:21:16 +0100 | [diff] [blame] | 168 | * mmc_of_parse() - parse host's device-tree node |
| 169 | * @host: host whose node should be parsed. |
| 170 | * |
| 171 | * To keep the rest of the MMC subsystem unaware of whether DT has been |
| 172 | * used to to instantiate and configure this host instance or not, we |
| 173 | * parse the properties and set respective generic mmc-host flags and |
| 174 | * parameters. |
| 175 | */ |
Simon Baatz | ec0a751 | 2013-06-09 22:14:11 +0200 | [diff] [blame] | 176 | int mmc_of_parse(struct mmc_host *host) |
Guennadi Liakhovetski | 6c56e7a | 2013-02-16 16:21:16 +0100 | [diff] [blame] | 177 | { |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 178 | struct device *dev = host->parent; |
Shawn Lin | bfd694d | 2018-04-24 08:42:57 +0800 | [diff] [blame] | 179 | u32 bus_width, drv_type, cd_debounce_delay_ms; |
Sergei Shtylyov | 90614cd | 2015-08-07 01:06:48 +0300 | [diff] [blame] | 180 | int ret; |
Kristina Martsenko | a31b0c6 | 2014-11-05 02:22:41 +0200 | [diff] [blame] | 181 | bool cd_cap_invert, cd_gpio_invert = false; |
| 182 | bool ro_cap_invert, ro_gpio_invert = false; |
Guennadi Liakhovetski | 6c56e7a | 2013-02-16 16:21:16 +0100 | [diff] [blame] | 183 | |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 184 | if (!dev || !dev_fwnode(dev)) |
Simon Baatz | ec0a751 | 2013-06-09 22:14:11 +0200 | [diff] [blame] | 185 | return 0; |
Guennadi Liakhovetski | 6c56e7a | 2013-02-16 16:21:16 +0100 | [diff] [blame] | 186 | |
Guennadi Liakhovetski | 6c56e7a | 2013-02-16 16:21:16 +0100 | [diff] [blame] | 187 | /* "bus-width" is translated to MMC_CAP_*_BIT_DATA flags */ |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 188 | if (device_property_read_u32(dev, "bus-width", &bus_width) < 0) { |
Guennadi Liakhovetski | 6c56e7a | 2013-02-16 16:21:16 +0100 | [diff] [blame] | 189 | dev_dbg(host->parent, |
| 190 | "\"bus-width\" property is missing, assuming 1 bit.\n"); |
| 191 | bus_width = 1; |
| 192 | } |
| 193 | |
| 194 | switch (bus_width) { |
| 195 | case 8: |
| 196 | host->caps |= MMC_CAP_8_BIT_DATA; |
| 197 | /* Hosts capable of 8-bit transfers can also do 4 bits */ |
| 198 | case 4: |
| 199 | host->caps |= MMC_CAP_4_BIT_DATA; |
| 200 | break; |
| 201 | case 1: |
| 202 | break; |
| 203 | default: |
| 204 | dev_err(host->parent, |
Alexander Shiyan | 1c279f4 | 2014-02-15 15:40:58 +0400 | [diff] [blame] | 205 | "Invalid \"bus-width\" value %u!\n", bus_width); |
Simon Baatz | ec0a751 | 2013-06-09 22:14:11 +0200 | [diff] [blame] | 206 | return -EINVAL; |
Guennadi Liakhovetski | 6c56e7a | 2013-02-16 16:21:16 +0100 | [diff] [blame] | 207 | } |
| 208 | |
| 209 | /* f_max is obtained from the optional "max-frequency" property */ |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 210 | device_property_read_u32(dev, "max-frequency", &host->f_max); |
Guennadi Liakhovetski | 6c56e7a | 2013-02-16 16:21:16 +0100 | [diff] [blame] | 211 | |
| 212 | /* |
| 213 | * Configure CD and WP pins. They are both by default active low to |
| 214 | * match the SDHCI spec. If GPIOs are provided for CD and / or WP, the |
| 215 | * mmc-gpio helpers are used to attach, configure and use them. If |
| 216 | * polarity inversion is specified in DT, one of MMC_CAP2_CD_ACTIVE_HIGH |
| 217 | * and MMC_CAP2_RO_ACTIVE_HIGH capability-2 flags is set. If the |
| 218 | * "broken-cd" property is provided, the MMC_CAP_NEEDS_POLL capability |
| 219 | * is set. If the "non-removable" property is found, the |
| 220 | * MMC_CAP_NONREMOVABLE capability is set and no card-detection |
| 221 | * configuration is performed. |
| 222 | */ |
| 223 | |
| 224 | /* Parse Card Detection */ |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 225 | if (device_property_read_bool(dev, "non-removable")) { |
Guennadi Liakhovetski | 6c56e7a | 2013-02-16 16:21:16 +0100 | [diff] [blame] | 226 | host->caps |= MMC_CAP_NONREMOVABLE; |
| 227 | } else { |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 228 | cd_cap_invert = device_property_read_bool(dev, "cd-inverted"); |
Guennadi Liakhovetski | 6c56e7a | 2013-02-16 16:21:16 +0100 | [diff] [blame] | 229 | |
Shawn Lin | bfd694d | 2018-04-24 08:42:57 +0800 | [diff] [blame] | 230 | if (device_property_read_u32(dev, "cd-debounce-delay-ms", |
| 231 | &cd_debounce_delay_ms)) |
| 232 | cd_debounce_delay_ms = 200; |
| 233 | |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 234 | if (device_property_read_bool(dev, "broken-cd")) |
Guennadi Liakhovetski | 6c56e7a | 2013-02-16 16:21:16 +0100 | [diff] [blame] | 235 | host->caps |= MMC_CAP_NEEDS_POLL; |
| 236 | |
Martin Blumenstingl | e3e4767 | 2019-01-01 20:44:14 +0100 | [diff] [blame] | 237 | ret = mmc_gpiod_request_cd(host, "cd", 0, false, |
Tony Lindgren | 1d71926 | 2018-09-18 16:16:56 -0700 | [diff] [blame] | 238 | cd_debounce_delay_ms * 1000, |
Shawn Lin | bfd694d | 2018-04-24 08:42:57 +0800 | [diff] [blame] | 239 | &cd_gpio_invert); |
Ulf Hansson | 9116752 | 2014-12-18 10:41:44 +0100 | [diff] [blame] | 240 | if (!ret) |
Linus Walleij | 98e90de | 2014-08-27 13:00:52 +0200 | [diff] [blame] | 241 | dev_info(host->parent, "Got CD GPIO\n"); |
Ulf Hansson | 43934ec | 2015-09-14 12:18:55 +0200 | [diff] [blame] | 242 | else if (ret != -ENOENT && ret != -ENOSYS) |
Ulf Hansson | 9116752 | 2014-12-18 10:41:44 +0100 | [diff] [blame] | 243 | return ret; |
Linus Walleij | 89168b4 | 2014-10-02 09:08:46 +0200 | [diff] [blame] | 244 | |
| 245 | /* |
| 246 | * There are two ways to flag that the CD line is inverted: |
| 247 | * through the cd-inverted flag and by the GPIO line itself |
| 248 | * being inverted from the GPIO subsystem. This is a leftover |
| 249 | * from the times when the GPIO subsystem did not make it |
| 250 | * possible to flag a line as inverted. |
| 251 | * |
| 252 | * If the capability on the host AND the GPIO line are |
| 253 | * both inverted, the end result is that the CD line is |
| 254 | * not inverted. |
| 255 | */ |
Kristina Martsenko | a31b0c6 | 2014-11-05 02:22:41 +0200 | [diff] [blame] | 256 | if (cd_cap_invert ^ cd_gpio_invert) |
Linus Walleij | 89168b4 | 2014-10-02 09:08:46 +0200 | [diff] [blame] | 257 | host->caps2 |= MMC_CAP2_CD_ACTIVE_HIGH; |
Guennadi Liakhovetski | 6c56e7a | 2013-02-16 16:21:16 +0100 | [diff] [blame] | 258 | } |
| 259 | |
| 260 | /* Parse Write Protection */ |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 261 | ro_cap_invert = device_property_read_bool(dev, "wp-inverted"); |
Guennadi Liakhovetski | 2fdb6e2 | 2013-02-15 16:14:01 +0100 | [diff] [blame] | 262 | |
Kristina Martsenko | a31b0c6 | 2014-11-05 02:22:41 +0200 | [diff] [blame] | 263 | ret = mmc_gpiod_request_ro(host, "wp", 0, false, 0, &ro_gpio_invert); |
Ulf Hansson | 9116752 | 2014-12-18 10:41:44 +0100 | [diff] [blame] | 264 | if (!ret) |
Linus Walleij | 98e90de | 2014-08-27 13:00:52 +0200 | [diff] [blame] | 265 | dev_info(host->parent, "Got WP GPIO\n"); |
Ulf Hansson | 43934ec | 2015-09-14 12:18:55 +0200 | [diff] [blame] | 266 | else if (ret != -ENOENT && ret != -ENOSYS) |
Ulf Hansson | 9116752 | 2014-12-18 10:41:44 +0100 | [diff] [blame] | 267 | return ret; |
Linus Walleij | 98e90de | 2014-08-27 13:00:52 +0200 | [diff] [blame] | 268 | |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 269 | if (device_property_read_bool(dev, "disable-wp")) |
Lars-Peter Clausen | 19f4424 | 2015-05-06 20:31:20 +0200 | [diff] [blame] | 270 | host->caps2 |= MMC_CAP2_NO_WRITE_PROTECT; |
| 271 | |
Linus Walleij | 89168b4 | 2014-10-02 09:08:46 +0200 | [diff] [blame] | 272 | /* See the comment on CD inversion above */ |
Kristina Martsenko | a31b0c6 | 2014-11-05 02:22:41 +0200 | [diff] [blame] | 273 | if (ro_cap_invert ^ ro_gpio_invert) |
Linus Walleij | 89168b4 | 2014-10-02 09:08:46 +0200 | [diff] [blame] | 274 | host->caps2 |= MMC_CAP2_RO_ACTIVE_HIGH; |
| 275 | |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 276 | if (device_property_read_bool(dev, "cap-sd-highspeed")) |
Guennadi Liakhovetski | 2fdb6e2 | 2013-02-15 16:14:01 +0100 | [diff] [blame] | 277 | host->caps |= MMC_CAP_SD_HIGHSPEED; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 278 | if (device_property_read_bool(dev, "cap-mmc-highspeed")) |
Guennadi Liakhovetski | 2fdb6e2 | 2013-02-15 16:14:01 +0100 | [diff] [blame] | 279 | host->caps |= MMC_CAP_MMC_HIGHSPEED; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 280 | if (device_property_read_bool(dev, "sd-uhs-sdr12")) |
Ulf Hansson | b66bd0e | 2014-02-14 13:27:07 +0100 | [diff] [blame] | 281 | host->caps |= MMC_CAP_UHS_SDR12; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 282 | if (device_property_read_bool(dev, "sd-uhs-sdr25")) |
Ulf Hansson | b66bd0e | 2014-02-14 13:27:07 +0100 | [diff] [blame] | 283 | host->caps |= MMC_CAP_UHS_SDR25; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 284 | if (device_property_read_bool(dev, "sd-uhs-sdr50")) |
Ulf Hansson | b66bd0e | 2014-02-14 13:27:07 +0100 | [diff] [blame] | 285 | host->caps |= MMC_CAP_UHS_SDR50; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 286 | if (device_property_read_bool(dev, "sd-uhs-sdr104")) |
Ulf Hansson | b66bd0e | 2014-02-14 13:27:07 +0100 | [diff] [blame] | 287 | host->caps |= MMC_CAP_UHS_SDR104; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 288 | if (device_property_read_bool(dev, "sd-uhs-ddr50")) |
Ulf Hansson | b66bd0e | 2014-02-14 13:27:07 +0100 | [diff] [blame] | 289 | host->caps |= MMC_CAP_UHS_DDR50; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 290 | if (device_property_read_bool(dev, "cap-power-off-card")) |
Guennadi Liakhovetski | 2fdb6e2 | 2013-02-15 16:14:01 +0100 | [diff] [blame] | 291 | host->caps |= MMC_CAP_POWER_OFF_CARD; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 292 | if (device_property_read_bool(dev, "cap-mmc-hw-reset")) |
Chaotian Jing | 794f157 | 2015-10-27 14:24:21 +0800 | [diff] [blame] | 293 | host->caps |= MMC_CAP_HW_RESET; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 294 | if (device_property_read_bool(dev, "cap-sdio-irq")) |
Guennadi Liakhovetski | 2fdb6e2 | 2013-02-15 16:14:01 +0100 | [diff] [blame] | 295 | host->caps |= MMC_CAP_SDIO_IRQ; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 296 | if (device_property_read_bool(dev, "full-pwr-cycle")) |
Ulf Hansson | 5a36d6b | 2013-06-10 17:03:47 +0200 | [diff] [blame] | 297 | host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 298 | if (device_property_read_bool(dev, "keep-power-in-suspend")) |
Guennadi Liakhovetski | 2fdb6e2 | 2013-02-15 16:14:01 +0100 | [diff] [blame] | 299 | host->pm_caps |= MMC_PM_KEEP_POWER; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 300 | if (device_property_read_bool(dev, "wakeup-source") || |
| 301 | device_property_read_bool(dev, "enable-sdio-wakeup")) /* legacy */ |
Guennadi Liakhovetski | 2fdb6e2 | 2013-02-15 16:14:01 +0100 | [diff] [blame] | 302 | host->pm_caps |= MMC_PM_WAKE_SDIO_IRQ; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 303 | if (device_property_read_bool(dev, "mmc-ddr-3_3v")) |
Ulf Hansson | fb00f19 | 2017-01-25 12:45:43 +0100 | [diff] [blame] | 304 | host->caps |= MMC_CAP_3_3V_DDR; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 305 | if (device_property_read_bool(dev, "mmc-ddr-1_8v")) |
Ulf Hansson | c0baf84 | 2014-02-14 13:27:08 +0100 | [diff] [blame] | 306 | host->caps |= MMC_CAP_1_8V_DDR; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 307 | if (device_property_read_bool(dev, "mmc-ddr-1_2v")) |
Ulf Hansson | c0baf84 | 2014-02-14 13:27:08 +0100 | [diff] [blame] | 308 | host->caps |= MMC_CAP_1_2V_DDR; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 309 | if (device_property_read_bool(dev, "mmc-hs200-1_8v")) |
Jaehoon Chung | 321bd41 | 2014-02-14 13:27:09 +0100 | [diff] [blame] | 310 | host->caps2 |= MMC_CAP2_HS200_1_8V_SDR; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 311 | if (device_property_read_bool(dev, "mmc-hs200-1_2v")) |
Jaehoon Chung | 321bd41 | 2014-02-14 13:27:09 +0100 | [diff] [blame] | 312 | host->caps2 |= MMC_CAP2_HS200_1_2V_SDR; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 313 | if (device_property_read_bool(dev, "mmc-hs400-1_8v")) |
Seungwon Jeon | c373eb4 | 2014-04-23 17:15:08 +0900 | [diff] [blame] | 314 | host->caps2 |= MMC_CAP2_HS400_1_8V | MMC_CAP2_HS200_1_8V_SDR; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 315 | if (device_property_read_bool(dev, "mmc-hs400-1_2v")) |
Seungwon Jeon | c373eb4 | 2014-04-23 17:15:08 +0900 | [diff] [blame] | 316 | host->caps2 |= MMC_CAP2_HS400_1_2V | MMC_CAP2_HS200_1_2V_SDR; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 317 | if (device_property_read_bool(dev, "mmc-hs400-enhanced-strobe")) |
Shawn Lin | ef29c0e | 2016-05-26 09:56:12 +0800 | [diff] [blame] | 318 | host->caps2 |= MMC_CAP2_HS400_ES; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 319 | if (device_property_read_bool(dev, "no-sdio")) |
Shawn Lin | 6ae3e53 | 2016-07-14 16:26:04 +0800 | [diff] [blame] | 320 | host->caps2 |= MMC_CAP2_NO_SDIO; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 321 | if (device_property_read_bool(dev, "no-sd")) |
Shawn Lin | 6ae3e53 | 2016-07-14 16:26:04 +0800 | [diff] [blame] | 322 | host->caps2 |= MMC_CAP2_NO_SD; |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 323 | if (device_property_read_bool(dev, "no-mmc")) |
Shawn Lin | 6ae3e53 | 2016-07-14 16:26:04 +0800 | [diff] [blame] | 324 | host->caps2 |= MMC_CAP2_NO_MMC; |
Simon Baatz | ec0a751 | 2013-06-09 22:14:11 +0200 | [diff] [blame] | 325 | |
Wolfram Sang | 6186d06 | 2017-10-15 14:46:14 +0200 | [diff] [blame] | 326 | /* Must be after "non-removable" check */ |
| 327 | if (device_property_read_u32(dev, "fixed-emmc-driver-type", &drv_type) == 0) { |
| 328 | if (host->caps & MMC_CAP_NONREMOVABLE) |
| 329 | host->fixed_drv_type = drv_type; |
| 330 | else |
| 331 | dev_err(host->parent, |
| 332 | "can't use fixed driver type, media is removable\n"); |
| 333 | } |
| 334 | |
David Woods | 73a47a9 | 2017-05-26 17:53:21 -0400 | [diff] [blame] | 335 | host->dsr_req = !device_property_read_u32(dev, "dsr", &host->dsr); |
Sascha Hauer | 3d705d1 | 2014-08-19 10:45:51 +0200 | [diff] [blame] | 336 | if (host->dsr_req && (host->dsr & ~0xffff)) { |
| 337 | dev_err(host->parent, |
| 338 | "device tree specified broken value for DSR: 0x%x, ignoring\n", |
| 339 | host->dsr); |
| 340 | host->dsr_req = 0; |
| 341 | } |
| 342 | |
Shawn Lin | 6d796c6 | 2018-05-08 09:04:20 +0800 | [diff] [blame] | 343 | device_property_read_u32(dev, "post-power-on-delay-ms", |
| 344 | &host->ios.power_delay_ms); |
| 345 | |
Ulf Hansson | 3aa8793 | 2014-11-28 14:38:36 +0100 | [diff] [blame] | 346 | return mmc_pwrseq_alloc(host); |
Guennadi Liakhovetski | 6c56e7a | 2013-02-16 16:21:16 +0100 | [diff] [blame] | 347 | } |
| 348 | |
| 349 | EXPORT_SYMBOL(mmc_of_parse); |
| 350 | |
| 351 | /** |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 352 | * mmc_alloc_host - initialise the per-host structure. |
| 353 | * @extra: sizeof private data structure |
| 354 | * @dev: pointer to host device model structure |
| 355 | * |
| 356 | * Initialise the per-host structure. |
| 357 | */ |
| 358 | struct mmc_host *mmc_alloc_host(int extra, struct device *dev) |
| 359 | { |
Pierre Ossman | ff3112f | 2008-03-08 23:43:19 +0100 | [diff] [blame] | 360 | int err; |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 361 | struct mmc_host *host; |
| 362 | |
Mariusz Kozlowski | be760a9 | 2007-08-10 14:00:50 -0700 | [diff] [blame] | 363 | host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL); |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 364 | if (!host) |
| 365 | return NULL; |
| 366 | |
Guennadi Liakhovetski | d9adcc1 | 2012-06-14 10:17:39 +0200 | [diff] [blame] | 367 | /* scanning will be enabled when we're ready */ |
| 368 | host->rescan_disable = 1; |
Ulf Hansson | 5674a9b | 2016-04-07 11:40:59 +0200 | [diff] [blame] | 369 | |
Heiner Kallweit | 7413d1f | 2017-01-28 09:32:35 +0100 | [diff] [blame] | 370 | err = ida_simple_get(&mmc_host_ida, 0, 0, GFP_KERNEL); |
| 371 | if (err < 0) { |
Ulf Hansson | 5674a9b | 2016-04-07 11:40:59 +0200 | [diff] [blame] | 372 | kfree(host); |
| 373 | return NULL; |
| 374 | } |
| 375 | |
Heiner Kallweit | 7413d1f | 2017-01-28 09:32:35 +0100 | [diff] [blame] | 376 | host->index = err; |
Pierre Ossman | ff3112f | 2008-03-08 23:43:19 +0100 | [diff] [blame] | 377 | |
Kay Sievers | d1b2686 | 2008-11-08 21:37:46 +0100 | [diff] [blame] | 378 | dev_set_name(&host->class_dev, "mmc%d", host->index); |
Pierre Ossman | ff3112f | 2008-03-08 23:43:19 +0100 | [diff] [blame] | 379 | |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 380 | host->parent = dev; |
| 381 | host->class_dev.parent = dev; |
| 382 | host->class_dev.class = &mmc_host_class; |
| 383 | device_initialize(&host->class_dev); |
Fu, Zhonghui | ccf7bfd | 2016-01-22 11:32:18 +0800 | [diff] [blame] | 384 | device_enable_async_suspend(&host->class_dev); |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 385 | |
Ulf Hansson | df8aca1 | 2014-12-18 15:44:36 +0100 | [diff] [blame] | 386 | if (mmc_gpio_alloc(host)) { |
| 387 | put_device(&host->class_dev); |
Heiner Kallweit | 1ed2171 | 2017-01-28 09:32:50 +0100 | [diff] [blame] | 388 | ida_simple_remove(&mmc_host_ida, host->index); |
| 389 | kfree(host); |
Ulf Hansson | df8aca1 | 2014-12-18 15:44:36 +0100 | [diff] [blame] | 390 | return NULL; |
| 391 | } |
Linus Walleij | 0456683 | 2010-11-08 21:36:50 -0500 | [diff] [blame] | 392 | |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 393 | spin_lock_init(&host->lock); |
| 394 | init_waitqueue_head(&host->wq); |
| 395 | INIT_DELAYED_WORK(&host->detect, mmc_rescan); |
Ulf Hansson | 6826966 | 2017-04-13 16:48:11 +0200 | [diff] [blame] | 396 | INIT_DELAYED_WORK(&host->sdio_irq_work, sdio_irq_work); |
Kees Cook | e99e88a | 2017-10-16 14:43:17 -0700 | [diff] [blame] | 397 | timer_setup(&host->retune_timer, mmc_retune_timer, 0); |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 398 | |
| 399 | /* |
| 400 | * By default, hosts do not support SGIO or large requests. |
| 401 | * They have to set these according to their abilities. |
| 402 | */ |
Martin K. Petersen | a36274e | 2010-09-10 01:33:59 -0400 | [diff] [blame] | 403 | host->max_segs = 1; |
Kirill A. Shutemov | 09cbfea | 2016-04-01 15:29:47 +0300 | [diff] [blame] | 404 | host->max_seg_size = PAGE_SIZE; |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 405 | |
Kirill A. Shutemov | 09cbfea | 2016-04-01 15:29:47 +0300 | [diff] [blame] | 406 | host->max_req_size = PAGE_SIZE; |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 407 | host->max_blk_size = 512; |
Kirill A. Shutemov | 09cbfea | 2016-04-01 15:29:47 +0300 | [diff] [blame] | 408 | host->max_blk_count = PAGE_SIZE / 512; |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 409 | |
Wolfram Sang | 6186d06 | 2017-10-15 14:46:14 +0200 | [diff] [blame] | 410 | host->fixed_drv_type = -EINVAL; |
Shawn Lin | 6d796c6 | 2018-05-08 09:04:20 +0800 | [diff] [blame] | 411 | host->ios.power_delay_ms = 10; |
Wolfram Sang | 6186d06 | 2017-10-15 14:46:14 +0200 | [diff] [blame] | 412 | |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 413 | return host; |
| 414 | } |
| 415 | |
| 416 | EXPORT_SYMBOL(mmc_alloc_host); |
| 417 | |
| 418 | /** |
| 419 | * mmc_add_host - initialise host hardware |
| 420 | * @host: mmc host |
Pierre Ossman | 67a61c4 | 2007-07-11 20:22:11 +0200 | [diff] [blame] | 421 | * |
| 422 | * Register the host with the driver model. The host must be |
| 423 | * prepared to start servicing requests before this function |
| 424 | * completes. |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 425 | */ |
| 426 | int mmc_add_host(struct mmc_host *host) |
| 427 | { |
| 428 | int err; |
| 429 | |
Nicolas Pitre | 17b759a | 2007-07-24 02:09:39 -0400 | [diff] [blame] | 430 | WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) && |
| 431 | !host->ops->enable_sdio_irq); |
| 432 | |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 433 | err = device_add(&host->class_dev); |
| 434 | if (err) |
| 435 | return err; |
| 436 | |
Wolfram Sang | f317dfe | 2011-04-11 06:11:29 +0200 | [diff] [blame] | 437 | led_trigger_register_simple(dev_name(&host->class_dev), &host->led); |
| 438 | |
Haavard Skinnemoen | 6edd8ee | 2008-07-24 14:18:57 +0200 | [diff] [blame] | 439 | #ifdef CONFIG_DEBUG_FS |
| 440 | mmc_add_host_debugfs(host); |
| 441 | #endif |
| 442 | |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 443 | mmc_start_host(host); |
Ulf Hansson | 8dede18 | 2015-11-05 16:11:12 +0100 | [diff] [blame] | 444 | mmc_register_pm_notifier(host); |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 445 | |
| 446 | return 0; |
| 447 | } |
| 448 | |
| 449 | EXPORT_SYMBOL(mmc_add_host); |
| 450 | |
| 451 | /** |
| 452 | * mmc_remove_host - remove host hardware |
| 453 | * @host: mmc host |
| 454 | * |
| 455 | * Unregister and remove all cards associated with this host, |
Pierre Ossman | 67a61c4 | 2007-07-11 20:22:11 +0200 | [diff] [blame] | 456 | * and power down the MMC bus. No new requests will be issued |
| 457 | * after this function has returned. |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 458 | */ |
| 459 | void mmc_remove_host(struct mmc_host *host) |
| 460 | { |
Ulf Hansson | 8dede18 | 2015-11-05 16:11:12 +0100 | [diff] [blame] | 461 | mmc_unregister_pm_notifier(host); |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 462 | mmc_stop_host(host); |
| 463 | |
Haavard Skinnemoen | 6edd8ee | 2008-07-24 14:18:57 +0200 | [diff] [blame] | 464 | #ifdef CONFIG_DEBUG_FS |
| 465 | mmc_remove_host_debugfs(host); |
| 466 | #endif |
| 467 | |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 468 | device_del(&host->class_dev); |
| 469 | |
Pierre Ossman | 77f1fd6e | 2007-10-12 22:48:46 +0200 | [diff] [blame] | 470 | led_trigger_unregister_simple(host->led); |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 471 | } |
| 472 | |
| 473 | EXPORT_SYMBOL(mmc_remove_host); |
| 474 | |
| 475 | /** |
| 476 | * mmc_free_host - free the host structure |
| 477 | * @host: mmc host |
| 478 | * |
| 479 | * Free the host once all references to it have been dropped. |
| 480 | */ |
| 481 | void mmc_free_host(struct mmc_host *host) |
| 482 | { |
Ulf Hansson | 3aa8793 | 2014-11-28 14:38:36 +0100 | [diff] [blame] | 483 | mmc_pwrseq_free(host); |
Pierre Ossman | b93931a | 2007-05-19 14:06:24 +0200 | [diff] [blame] | 484 | put_device(&host->class_dev); |
| 485 | } |
| 486 | |
| 487 | EXPORT_SYMBOL(mmc_free_host); |