blob: 105b7a7c025133b8afbf3a3221376caa16015ce8 [file] [log] [blame]
Thomas Gleixnerd2912cb2019-06-04 10:11:33 +02001// SPDX-License-Identifier: GPL-2.0-only
Pierre Ossmanb93931a2007-05-19 14:06:24 +02002/*
3 * linux/drivers/mmc/core/host.c
4 *
5 * Copyright (C) 2003 Russell King, All Rights Reserved.
Pierre Ossmanff3112f2008-03-08 23:43:19 +01006 * Copyright (C) 2007-2008 Pierre Ossman
Linus Walleij04566832010-11-08 21:36:50 -05007 * Copyright (C) 2010 Linus Walleij
Pierre Ossmanb93931a2007-05-19 14:06:24 +02008 *
Pierre Ossmanb93931a2007-05-19 14:06:24 +02009 * MMC host class device management
10 */
11
12#include <linux/device.h>
13#include <linux/err.h>
14#include <linux/idr.h>
Guennadi Liakhovetski6c56e7a2013-02-16 16:21:16 +010015#include <linux/of.h>
16#include <linux/of_gpio.h>
Pierre Ossmanb93931a2007-05-19 14:06:24 +020017#include <linux/pagemap.h>
Paul Gortmaker3ef77af2011-07-10 12:42:00 -040018#include <linux/export.h>
Pierre Ossmanaf8350c2007-09-24 07:15:48 +020019#include <linux/leds.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090020#include <linux/slab.h>
Pierre Ossmanb93931a2007-05-19 14:06:24 +020021
22#include <linux/mmc/host.h>
Linus Walleij04566832010-11-08 21:36:50 -050023#include <linux/mmc/card.h>
Guennadi Liakhovetski6c56e7a2013-02-16 16:21:16 +010024#include <linux/mmc/slot-gpio.h>
Pierre Ossmanb93931a2007-05-19 14:06:24 +020025
26#include "core.h"
27#include "host.h"
Ulf Hanssondf8aca12014-12-18 15:44:36 +010028#include "slot-gpio.h"
Ulf Hansson3aa87932014-11-28 14:38:36 +010029#include "pwrseq.h"
Ulf Hansson68269662017-04-13 16:48:11 +020030#include "sdio_ops.h"
Pierre Ossmanb93931a2007-05-19 14:06:24 +020031
32#define cls_dev_to_mmc_host(d) container_of(d, struct mmc_host, class_dev)
33
Ulf Hansson5674a9b2016-04-07 11:40:59 +020034static DEFINE_IDA(mmc_host_ida);
Ulf Hanssone2d19262014-12-18 15:44:35 +010035
Pierre Ossmanb93931a2007-05-19 14:06:24 +020036static void mmc_host_classdev_release(struct device *dev)
37{
38 struct mmc_host *host = cls_dev_to_mmc_host(dev);
Heiner Kallweit7413d1f2017-01-28 09:32:35 +010039 ida_simple_remove(&mmc_host_ida, host->index);
Pierre Ossmanb93931a2007-05-19 14:06:24 +020040 kfree(host);
41}
42
43static struct class mmc_host_class = {
44 .name = "mmc_host",
45 .dev_release = mmc_host_classdev_release,
46};
47
48int mmc_register_host_class(void)
49{
50 return class_register(&mmc_host_class);
51}
52
53void mmc_unregister_host_class(void)
54{
55 class_unregister(&mmc_host_class);
56}
57
Adrian Hunterdfa13eb2015-05-07 13:10:12 +030058void mmc_retune_enable(struct mmc_host *host)
59{
60 host->can_retune = 1;
61 if (host->retune_period)
62 mod_timer(&host->retune_timer,
63 jiffies + host->retune_period * HZ);
64}
65
Adrian Hunter7ff27602016-05-16 15:35:24 +030066/*
67 * Pause re-tuning for a small set of operations. The pause begins after the
68 * next command and after first doing re-tuning.
69 */
70void mmc_retune_pause(struct mmc_host *host)
71{
72 if (!host->retune_paused) {
73 host->retune_paused = 1;
74 mmc_retune_needed(host);
75 mmc_retune_hold(host);
76 }
77}
78EXPORT_SYMBOL(mmc_retune_pause);
79
80void mmc_retune_unpause(struct mmc_host *host)
81{
82 if (host->retune_paused) {
83 host->retune_paused = 0;
84 mmc_retune_release(host);
85 }
86}
87EXPORT_SYMBOL(mmc_retune_unpause);
88
Adrian Hunterdfa13eb2015-05-07 13:10:12 +030089void mmc_retune_disable(struct mmc_host *host)
90{
Adrian Hunter7ff27602016-05-16 15:35:24 +030091 mmc_retune_unpause(host);
Adrian Hunterdfa13eb2015-05-07 13:10:12 +030092 host->can_retune = 0;
93 del_timer_sync(&host->retune_timer);
94 host->retune_now = 0;
95 host->need_retune = 0;
96}
97
98void mmc_retune_timer_stop(struct mmc_host *host)
99{
100 del_timer_sync(&host->retune_timer);
101}
102EXPORT_SYMBOL(mmc_retune_timer_stop);
103
104void mmc_retune_hold(struct mmc_host *host)
105{
106 if (!host->hold_retune)
107 host->retune_now = 1;
108 host->hold_retune += 1;
109}
110
111void mmc_retune_release(struct mmc_host *host)
112{
113 if (host->hold_retune)
114 host->hold_retune -= 1;
115 else
116 WARN_ON(1);
117}
Adrian Huntercb39f612017-09-22 15:36:59 +0300118EXPORT_SYMBOL(mmc_retune_release);
Adrian Hunterdfa13eb2015-05-07 13:10:12 +0300119
120int mmc_retune(struct mmc_host *host)
121{
Adrian Hunter6376f692015-05-07 13:10:20 +0300122 bool return_to_hs400 = false;
Adrian Hunterdfa13eb2015-05-07 13:10:12 +0300123 int err;
124
125 if (host->retune_now)
126 host->retune_now = 0;
127 else
128 return 0;
129
130 if (!host->need_retune || host->doing_retune || !host->card)
131 return 0;
132
133 host->need_retune = 0;
134
135 host->doing_retune = 1;
136
Adrian Hunter6376f692015-05-07 13:10:20 +0300137 if (host->ios.timing == MMC_TIMING_MMC_HS400) {
138 err = mmc_hs400_to_hs200(host->card);
139 if (err)
140 goto out;
Adrian Hunterdfa13eb2015-05-07 13:10:12 +0300141
Adrian Hunter6376f692015-05-07 13:10:20 +0300142 return_to_hs400 = true;
Adrian Hunter6376f692015-05-07 13:10:20 +0300143 }
144
145 err = mmc_execute_tuning(host->card);
146 if (err)
147 goto out;
148
149 if (return_to_hs400)
150 err = mmc_hs200_to_hs400(host->card);
151out:
Adrian Hunterdfa13eb2015-05-07 13:10:12 +0300152 host->doing_retune = 0;
153
154 return err;
155}
156
Kees Cooke99e88a2017-10-16 14:43:17 -0700157static void mmc_retune_timer(struct timer_list *t)
Adrian Hunterdfa13eb2015-05-07 13:10:12 +0300158{
Kees Cooke99e88a2017-10-16 14:43:17 -0700159 struct mmc_host *host = from_timer(host, t, retune_timer);
Adrian Hunterdfa13eb2015-05-07 13:10:12 +0300160
161 mmc_retune_needed(host);
162}
163
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200164/**
Guennadi Liakhovetski6c56e7a2013-02-16 16:21:16 +0100165 * mmc_of_parse() - parse host's device-tree node
166 * @host: host whose node should be parsed.
167 *
168 * To keep the rest of the MMC subsystem unaware of whether DT has been
169 * used to to instantiate and configure this host instance or not, we
170 * parse the properties and set respective generic mmc-host flags and
171 * parameters.
172 */
Simon Baatzec0a7512013-06-09 22:14:11 +0200173int mmc_of_parse(struct mmc_host *host)
Guennadi Liakhovetski6c56e7a2013-02-16 16:21:16 +0100174{
David Woods73a47a92017-05-26 17:53:21 -0400175 struct device *dev = host->parent;
Shawn Linbfd694d2018-04-24 08:42:57 +0800176 u32 bus_width, drv_type, cd_debounce_delay_ms;
Sergei Shtylyov90614cd2015-08-07 01:06:48 +0300177 int ret;
Kristina Martsenkoa31b0c62014-11-05 02:22:41 +0200178 bool cd_cap_invert, cd_gpio_invert = false;
179 bool ro_cap_invert, ro_gpio_invert = false;
Guennadi Liakhovetski6c56e7a2013-02-16 16:21:16 +0100180
David Woods73a47a92017-05-26 17:53:21 -0400181 if (!dev || !dev_fwnode(dev))
Simon Baatzec0a7512013-06-09 22:14:11 +0200182 return 0;
Guennadi Liakhovetski6c56e7a2013-02-16 16:21:16 +0100183
Guennadi Liakhovetski6c56e7a2013-02-16 16:21:16 +0100184 /* "bus-width" is translated to MMC_CAP_*_BIT_DATA flags */
David Woods73a47a92017-05-26 17:53:21 -0400185 if (device_property_read_u32(dev, "bus-width", &bus_width) < 0) {
Guennadi Liakhovetski6c56e7a2013-02-16 16:21:16 +0100186 dev_dbg(host->parent,
187 "\"bus-width\" property is missing, assuming 1 bit.\n");
188 bus_width = 1;
189 }
190
191 switch (bus_width) {
192 case 8:
193 host->caps |= MMC_CAP_8_BIT_DATA;
Mathieu Malaterre451e3192019-01-14 21:42:11 +0100194 /* fall through - Hosts capable of 8-bit can also do 4 bits */
Guennadi Liakhovetski6c56e7a2013-02-16 16:21:16 +0100195 case 4:
196 host->caps |= MMC_CAP_4_BIT_DATA;
197 break;
198 case 1:
199 break;
200 default:
201 dev_err(host->parent,
Alexander Shiyan1c279f42014-02-15 15:40:58 +0400202 "Invalid \"bus-width\" value %u!\n", bus_width);
Simon Baatzec0a7512013-06-09 22:14:11 +0200203 return -EINVAL;
Guennadi Liakhovetski6c56e7a2013-02-16 16:21:16 +0100204 }
205
206 /* f_max is obtained from the optional "max-frequency" property */
David Woods73a47a92017-05-26 17:53:21 -0400207 device_property_read_u32(dev, "max-frequency", &host->f_max);
Guennadi Liakhovetski6c56e7a2013-02-16 16:21:16 +0100208
209 /*
210 * Configure CD and WP pins. They are both by default active low to
211 * match the SDHCI spec. If GPIOs are provided for CD and / or WP, the
212 * mmc-gpio helpers are used to attach, configure and use them. If
213 * polarity inversion is specified in DT, one of MMC_CAP2_CD_ACTIVE_HIGH
214 * and MMC_CAP2_RO_ACTIVE_HIGH capability-2 flags is set. If the
215 * "broken-cd" property is provided, the MMC_CAP_NEEDS_POLL capability
216 * is set. If the "non-removable" property is found, the
217 * MMC_CAP_NONREMOVABLE capability is set and no card-detection
218 * configuration is performed.
219 */
220
221 /* Parse Card Detection */
David Woods73a47a92017-05-26 17:53:21 -0400222 if (device_property_read_bool(dev, "non-removable")) {
Guennadi Liakhovetski6c56e7a2013-02-16 16:21:16 +0100223 host->caps |= MMC_CAP_NONREMOVABLE;
224 } else {
David Woods73a47a92017-05-26 17:53:21 -0400225 cd_cap_invert = device_property_read_bool(dev, "cd-inverted");
Guennadi Liakhovetski6c56e7a2013-02-16 16:21:16 +0100226
Shawn Linbfd694d2018-04-24 08:42:57 +0800227 if (device_property_read_u32(dev, "cd-debounce-delay-ms",
228 &cd_debounce_delay_ms))
229 cd_debounce_delay_ms = 200;
230
David Woods73a47a92017-05-26 17:53:21 -0400231 if (device_property_read_bool(dev, "broken-cd"))
Guennadi Liakhovetski6c56e7a2013-02-16 16:21:16 +0100232 host->caps |= MMC_CAP_NEEDS_POLL;
233
Martin Blumenstingle3e47672019-01-01 20:44:14 +0100234 ret = mmc_gpiod_request_cd(host, "cd", 0, false,
Tony Lindgren1d719262018-09-18 16:16:56 -0700235 cd_debounce_delay_ms * 1000,
Shawn Linbfd694d2018-04-24 08:42:57 +0800236 &cd_gpio_invert);
Ulf Hansson91167522014-12-18 10:41:44 +0100237 if (!ret)
Linus Walleij98e90de2014-08-27 13:00:52 +0200238 dev_info(host->parent, "Got CD GPIO\n");
Ulf Hansson43934ec2015-09-14 12:18:55 +0200239 else if (ret != -ENOENT && ret != -ENOSYS)
Ulf Hansson91167522014-12-18 10:41:44 +0100240 return ret;
Linus Walleij89168b42014-10-02 09:08:46 +0200241
242 /*
243 * There are two ways to flag that the CD line is inverted:
244 * through the cd-inverted flag and by the GPIO line itself
245 * being inverted from the GPIO subsystem. This is a leftover
246 * from the times when the GPIO subsystem did not make it
247 * possible to flag a line as inverted.
248 *
249 * If the capability on the host AND the GPIO line are
250 * both inverted, the end result is that the CD line is
251 * not inverted.
252 */
Kristina Martsenkoa31b0c62014-11-05 02:22:41 +0200253 if (cd_cap_invert ^ cd_gpio_invert)
Linus Walleij89168b42014-10-02 09:08:46 +0200254 host->caps2 |= MMC_CAP2_CD_ACTIVE_HIGH;
Guennadi Liakhovetski6c56e7a2013-02-16 16:21:16 +0100255 }
256
257 /* Parse Write Protection */
David Woods73a47a92017-05-26 17:53:21 -0400258 ro_cap_invert = device_property_read_bool(dev, "wp-inverted");
Guennadi Liakhovetski2fdb6e22013-02-15 16:14:01 +0100259
Linus Walleija2b760a2019-02-05 10:30:22 +0100260 ret = mmc_gpiod_request_ro(host, "wp", 0, 0, &ro_gpio_invert);
Ulf Hansson91167522014-12-18 10:41:44 +0100261 if (!ret)
Linus Walleij98e90de2014-08-27 13:00:52 +0200262 dev_info(host->parent, "Got WP GPIO\n");
Ulf Hansson43934ec2015-09-14 12:18:55 +0200263 else if (ret != -ENOENT && ret != -ENOSYS)
Ulf Hansson91167522014-12-18 10:41:44 +0100264 return ret;
Linus Walleij98e90de2014-08-27 13:00:52 +0200265
David Woods73a47a92017-05-26 17:53:21 -0400266 if (device_property_read_bool(dev, "disable-wp"))
Lars-Peter Clausen19f44242015-05-06 20:31:20 +0200267 host->caps2 |= MMC_CAP2_NO_WRITE_PROTECT;
268
Linus Walleij89168b42014-10-02 09:08:46 +0200269 /* See the comment on CD inversion above */
Kristina Martsenkoa31b0c62014-11-05 02:22:41 +0200270 if (ro_cap_invert ^ ro_gpio_invert)
Linus Walleij89168b42014-10-02 09:08:46 +0200271 host->caps2 |= MMC_CAP2_RO_ACTIVE_HIGH;
272
David Woods73a47a92017-05-26 17:53:21 -0400273 if (device_property_read_bool(dev, "cap-sd-highspeed"))
Guennadi Liakhovetski2fdb6e22013-02-15 16:14:01 +0100274 host->caps |= MMC_CAP_SD_HIGHSPEED;
David Woods73a47a92017-05-26 17:53:21 -0400275 if (device_property_read_bool(dev, "cap-mmc-highspeed"))
Guennadi Liakhovetski2fdb6e22013-02-15 16:14:01 +0100276 host->caps |= MMC_CAP_MMC_HIGHSPEED;
David Woods73a47a92017-05-26 17:53:21 -0400277 if (device_property_read_bool(dev, "sd-uhs-sdr12"))
Ulf Hanssonb66bd0e2014-02-14 13:27:07 +0100278 host->caps |= MMC_CAP_UHS_SDR12;
David Woods73a47a92017-05-26 17:53:21 -0400279 if (device_property_read_bool(dev, "sd-uhs-sdr25"))
Ulf Hanssonb66bd0e2014-02-14 13:27:07 +0100280 host->caps |= MMC_CAP_UHS_SDR25;
David Woods73a47a92017-05-26 17:53:21 -0400281 if (device_property_read_bool(dev, "sd-uhs-sdr50"))
Ulf Hanssonb66bd0e2014-02-14 13:27:07 +0100282 host->caps |= MMC_CAP_UHS_SDR50;
David Woods73a47a92017-05-26 17:53:21 -0400283 if (device_property_read_bool(dev, "sd-uhs-sdr104"))
Ulf Hanssonb66bd0e2014-02-14 13:27:07 +0100284 host->caps |= MMC_CAP_UHS_SDR104;
David Woods73a47a92017-05-26 17:53:21 -0400285 if (device_property_read_bool(dev, "sd-uhs-ddr50"))
Ulf Hanssonb66bd0e2014-02-14 13:27:07 +0100286 host->caps |= MMC_CAP_UHS_DDR50;
David Woods73a47a92017-05-26 17:53:21 -0400287 if (device_property_read_bool(dev, "cap-power-off-card"))
Guennadi Liakhovetski2fdb6e22013-02-15 16:14:01 +0100288 host->caps |= MMC_CAP_POWER_OFF_CARD;
David Woods73a47a92017-05-26 17:53:21 -0400289 if (device_property_read_bool(dev, "cap-mmc-hw-reset"))
Chaotian Jing794f1572015-10-27 14:24:21 +0800290 host->caps |= MMC_CAP_HW_RESET;
David Woods73a47a92017-05-26 17:53:21 -0400291 if (device_property_read_bool(dev, "cap-sdio-irq"))
Guennadi Liakhovetski2fdb6e22013-02-15 16:14:01 +0100292 host->caps |= MMC_CAP_SDIO_IRQ;
David Woods73a47a92017-05-26 17:53:21 -0400293 if (device_property_read_bool(dev, "full-pwr-cycle"))
Ulf Hansson5a36d6b2013-06-10 17:03:47 +0200294 host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE;
David Woods73a47a92017-05-26 17:53:21 -0400295 if (device_property_read_bool(dev, "keep-power-in-suspend"))
Guennadi Liakhovetski2fdb6e22013-02-15 16:14:01 +0100296 host->pm_caps |= MMC_PM_KEEP_POWER;
David Woods73a47a92017-05-26 17:53:21 -0400297 if (device_property_read_bool(dev, "wakeup-source") ||
298 device_property_read_bool(dev, "enable-sdio-wakeup")) /* legacy */
Guennadi Liakhovetski2fdb6e22013-02-15 16:14:01 +0100299 host->pm_caps |= MMC_PM_WAKE_SDIO_IRQ;
David Woods73a47a92017-05-26 17:53:21 -0400300 if (device_property_read_bool(dev, "mmc-ddr-3_3v"))
Ulf Hanssonfb00f192017-01-25 12:45:43 +0100301 host->caps |= MMC_CAP_3_3V_DDR;
David Woods73a47a92017-05-26 17:53:21 -0400302 if (device_property_read_bool(dev, "mmc-ddr-1_8v"))
Ulf Hanssonc0baf842014-02-14 13:27:08 +0100303 host->caps |= MMC_CAP_1_8V_DDR;
David Woods73a47a92017-05-26 17:53:21 -0400304 if (device_property_read_bool(dev, "mmc-ddr-1_2v"))
Ulf Hanssonc0baf842014-02-14 13:27:08 +0100305 host->caps |= MMC_CAP_1_2V_DDR;
David Woods73a47a92017-05-26 17:53:21 -0400306 if (device_property_read_bool(dev, "mmc-hs200-1_8v"))
Jaehoon Chung321bd412014-02-14 13:27:09 +0100307 host->caps2 |= MMC_CAP2_HS200_1_8V_SDR;
David Woods73a47a92017-05-26 17:53:21 -0400308 if (device_property_read_bool(dev, "mmc-hs200-1_2v"))
Jaehoon Chung321bd412014-02-14 13:27:09 +0100309 host->caps2 |= MMC_CAP2_HS200_1_2V_SDR;
David Woods73a47a92017-05-26 17:53:21 -0400310 if (device_property_read_bool(dev, "mmc-hs400-1_8v"))
Seungwon Jeonc373eb42014-04-23 17:15:08 +0900311 host->caps2 |= MMC_CAP2_HS400_1_8V | MMC_CAP2_HS200_1_8V_SDR;
David Woods73a47a92017-05-26 17:53:21 -0400312 if (device_property_read_bool(dev, "mmc-hs400-1_2v"))
Seungwon Jeonc373eb42014-04-23 17:15:08 +0900313 host->caps2 |= MMC_CAP2_HS400_1_2V | MMC_CAP2_HS200_1_2V_SDR;
David Woods73a47a92017-05-26 17:53:21 -0400314 if (device_property_read_bool(dev, "mmc-hs400-enhanced-strobe"))
Shawn Linef29c0e2016-05-26 09:56:12 +0800315 host->caps2 |= MMC_CAP2_HS400_ES;
David Woods73a47a92017-05-26 17:53:21 -0400316 if (device_property_read_bool(dev, "no-sdio"))
Shawn Lin6ae3e532016-07-14 16:26:04 +0800317 host->caps2 |= MMC_CAP2_NO_SDIO;
David Woods73a47a92017-05-26 17:53:21 -0400318 if (device_property_read_bool(dev, "no-sd"))
Shawn Lin6ae3e532016-07-14 16:26:04 +0800319 host->caps2 |= MMC_CAP2_NO_SD;
David Woods73a47a92017-05-26 17:53:21 -0400320 if (device_property_read_bool(dev, "no-mmc"))
Shawn Lin6ae3e532016-07-14 16:26:04 +0800321 host->caps2 |= MMC_CAP2_NO_MMC;
Simon Baatzec0a7512013-06-09 22:14:11 +0200322
Wolfram Sang6186d062017-10-15 14:46:14 +0200323 /* Must be after "non-removable" check */
324 if (device_property_read_u32(dev, "fixed-emmc-driver-type", &drv_type) == 0) {
325 if (host->caps & MMC_CAP_NONREMOVABLE)
326 host->fixed_drv_type = drv_type;
327 else
328 dev_err(host->parent,
329 "can't use fixed driver type, media is removable\n");
330 }
331
David Woods73a47a92017-05-26 17:53:21 -0400332 host->dsr_req = !device_property_read_u32(dev, "dsr", &host->dsr);
Sascha Hauer3d705d12014-08-19 10:45:51 +0200333 if (host->dsr_req && (host->dsr & ~0xffff)) {
334 dev_err(host->parent,
335 "device tree specified broken value for DSR: 0x%x, ignoring\n",
336 host->dsr);
337 host->dsr_req = 0;
338 }
339
Shawn Lin6d796c62018-05-08 09:04:20 +0800340 device_property_read_u32(dev, "post-power-on-delay-ms",
341 &host->ios.power_delay_ms);
342
Ulf Hansson3aa87932014-11-28 14:38:36 +0100343 return mmc_pwrseq_alloc(host);
Guennadi Liakhovetski6c56e7a2013-02-16 16:21:16 +0100344}
345
346EXPORT_SYMBOL(mmc_of_parse);
347
348/**
Ulf Hansson9d2d2432019-02-13 18:46:45 +0100349 * mmc_of_parse_voltage - return mask of supported voltages
350 * @np: The device node need to be parsed.
351 * @mask: mask of voltages available for MMC/SD/SDIO
352 *
353 * Parse the "voltage-ranges" DT property, returning zero if it is not
354 * found, negative errno if the voltage-range specification is invalid,
355 * or one if the voltage-range is specified and successfully parsed.
356 */
357int mmc_of_parse_voltage(struct device_node *np, u32 *mask)
358{
359 const u32 *voltage_ranges;
360 int num_ranges, i;
361
362 voltage_ranges = of_get_property(np, "voltage-ranges", &num_ranges);
Ulf Hansson9d2d2432019-02-13 18:46:45 +0100363 if (!voltage_ranges) {
364 pr_debug("%pOF: voltage-ranges unspecified\n", np);
365 return 0;
366 }
Pavel Machek42c38d42019-04-16 09:58:45 +0200367 num_ranges = num_ranges / sizeof(*voltage_ranges) / 2;
Ulf Hansson9d2d2432019-02-13 18:46:45 +0100368 if (!num_ranges) {
369 pr_err("%pOF: voltage-ranges empty\n", np);
370 return -EINVAL;
371 }
372
373 for (i = 0; i < num_ranges; i++) {
374 const int j = i * 2;
375 u32 ocr_mask;
376
377 ocr_mask = mmc_vddrange_to_ocrmask(
378 be32_to_cpu(voltage_ranges[j]),
379 be32_to_cpu(voltage_ranges[j + 1]));
380 if (!ocr_mask) {
381 pr_err("%pOF: voltage-range #%d is invalid\n",
382 np, i);
383 return -EINVAL;
384 }
385 *mask |= ocr_mask;
386 }
387
388 return 1;
389}
390EXPORT_SYMBOL(mmc_of_parse_voltage);
391
392/**
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200393 * mmc_alloc_host - initialise the per-host structure.
394 * @extra: sizeof private data structure
395 * @dev: pointer to host device model structure
396 *
397 * Initialise the per-host structure.
398 */
399struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
400{
Pierre Ossmanff3112f2008-03-08 23:43:19 +0100401 int err;
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200402 struct mmc_host *host;
403
Mariusz Kozlowskibe760a92007-08-10 14:00:50 -0700404 host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL);
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200405 if (!host)
406 return NULL;
407
Guennadi Liakhovetskid9adcc12012-06-14 10:17:39 +0200408 /* scanning will be enabled when we're ready */
409 host->rescan_disable = 1;
Ulf Hansson5674a9b2016-04-07 11:40:59 +0200410
Heiner Kallweit7413d1f2017-01-28 09:32:35 +0100411 err = ida_simple_get(&mmc_host_ida, 0, 0, GFP_KERNEL);
412 if (err < 0) {
Ulf Hansson5674a9b2016-04-07 11:40:59 +0200413 kfree(host);
414 return NULL;
415 }
416
Heiner Kallweit7413d1f2017-01-28 09:32:35 +0100417 host->index = err;
Pierre Ossmanff3112f2008-03-08 23:43:19 +0100418
Kay Sieversd1b26862008-11-08 21:37:46 +0100419 dev_set_name(&host->class_dev, "mmc%d", host->index);
Pierre Ossmanff3112f2008-03-08 23:43:19 +0100420
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200421 host->parent = dev;
422 host->class_dev.parent = dev;
423 host->class_dev.class = &mmc_host_class;
424 device_initialize(&host->class_dev);
Fu, Zhonghuiccf7bfd2016-01-22 11:32:18 +0800425 device_enable_async_suspend(&host->class_dev);
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200426
Ulf Hanssondf8aca12014-12-18 15:44:36 +0100427 if (mmc_gpio_alloc(host)) {
428 put_device(&host->class_dev);
429 return NULL;
430 }
Linus Walleij04566832010-11-08 21:36:50 -0500431
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200432 spin_lock_init(&host->lock);
433 init_waitqueue_head(&host->wq);
434 INIT_DELAYED_WORK(&host->detect, mmc_rescan);
Ulf Hansson68269662017-04-13 16:48:11 +0200435 INIT_DELAYED_WORK(&host->sdio_irq_work, sdio_irq_work);
Kees Cooke99e88a2017-10-16 14:43:17 -0700436 timer_setup(&host->retune_timer, mmc_retune_timer, 0);
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200437
438 /*
439 * By default, hosts do not support SGIO or large requests.
440 * They have to set these according to their abilities.
441 */
Martin K. Petersena36274e2010-09-10 01:33:59 -0400442 host->max_segs = 1;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300443 host->max_seg_size = PAGE_SIZE;
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200444
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300445 host->max_req_size = PAGE_SIZE;
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200446 host->max_blk_size = 512;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300447 host->max_blk_count = PAGE_SIZE / 512;
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200448
Wolfram Sang6186d062017-10-15 14:46:14 +0200449 host->fixed_drv_type = -EINVAL;
Shawn Lin6d796c62018-05-08 09:04:20 +0800450 host->ios.power_delay_ms = 10;
Wolfram Sang6186d062017-10-15 14:46:14 +0200451
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200452 return host;
453}
454
455EXPORT_SYMBOL(mmc_alloc_host);
456
457/**
458 * mmc_add_host - initialise host hardware
459 * @host: mmc host
Pierre Ossman67a61c42007-07-11 20:22:11 +0200460 *
461 * Register the host with the driver model. The host must be
462 * prepared to start servicing requests before this function
463 * completes.
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200464 */
465int mmc_add_host(struct mmc_host *host)
466{
467 int err;
468
Nicolas Pitre17b759a2007-07-24 02:09:39 -0400469 WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) &&
470 !host->ops->enable_sdio_irq);
471
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200472 err = device_add(&host->class_dev);
473 if (err)
474 return err;
475
Wolfram Sangf317dfe2011-04-11 06:11:29 +0200476 led_trigger_register_simple(dev_name(&host->class_dev), &host->led);
477
Haavard Skinnemoen6edd8ee2008-07-24 14:18:57 +0200478#ifdef CONFIG_DEBUG_FS
479 mmc_add_host_debugfs(host);
480#endif
481
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200482 mmc_start_host(host);
Ulf Hansson8dede182015-11-05 16:11:12 +0100483 mmc_register_pm_notifier(host);
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200484
485 return 0;
486}
487
488EXPORT_SYMBOL(mmc_add_host);
489
490/**
491 * mmc_remove_host - remove host hardware
492 * @host: mmc host
493 *
494 * Unregister and remove all cards associated with this host,
Pierre Ossman67a61c42007-07-11 20:22:11 +0200495 * and power down the MMC bus. No new requests will be issued
496 * after this function has returned.
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200497 */
498void mmc_remove_host(struct mmc_host *host)
499{
Ulf Hansson8dede182015-11-05 16:11:12 +0100500 mmc_unregister_pm_notifier(host);
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200501 mmc_stop_host(host);
502
Haavard Skinnemoen6edd8ee2008-07-24 14:18:57 +0200503#ifdef CONFIG_DEBUG_FS
504 mmc_remove_host_debugfs(host);
505#endif
506
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200507 device_del(&host->class_dev);
508
Pierre Ossman77f1fd62007-10-12 22:48:46 +0200509 led_trigger_unregister_simple(host->led);
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200510}
511
512EXPORT_SYMBOL(mmc_remove_host);
513
514/**
515 * mmc_free_host - free the host structure
516 * @host: mmc host
517 *
518 * Free the host once all references to it have been dropped.
519 */
520void mmc_free_host(struct mmc_host *host)
521{
Ulf Hansson3aa87932014-11-28 14:38:36 +0100522 mmc_pwrseq_free(host);
Pierre Ossmanb93931a2007-05-19 14:06:24 +0200523 put_device(&host->class_dev);
524}
525
526EXPORT_SYMBOL(mmc_free_host);