1
2
3
4
5
6
7
8
9
10
11
12
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
37static DEFINE_IDR(mmc_host_idr);
38static DEFINE_SPINLOCK(mmc_host_lock);
39
40static 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
49static struct class mmc_host_class = {
50 .name = "mmc_host",
51 .dev_release = mmc_host_classdev_release,
52};
53
54int mmc_register_host_class(void)
55{
56 return class_register(&mmc_host_class);
57}
58
59void mmc_unregister_host_class(void)
60{
61 class_unregister(&mmc_host_class);
62}
63
64void 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
72void 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
80void mmc_retune_timer_stop(struct mmc_host *host)
81{
82 del_timer_sync(&host->retune_timer);
83}
84EXPORT_SYMBOL(mmc_retune_timer_stop);
85
86void 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
93void 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
101int 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);
135out:
136 host->doing_retune = 0;
137
138 return err;
139}
140
141static 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
150
151
152
153
154
155
156
157int 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
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
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
193 of_property_read_u32(np, "max-frequency", &host->f_max);
194
195
196
197
198
199
200
201
202
203
204
205
206
207
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
225
226
227
228
229
230
231
232
233
234 if (cd_cap_invert ^ cd_gpio_invert)
235 host->caps2 |= MMC_CAP2_CD_ACTIVE_HIGH;
236 }
237
238
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
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
304EXPORT_SYMBOL(mmc_of_parse);
305
306
307
308
309
310
311
312
313struct 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
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
358
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
370EXPORT_SYMBOL(mmc_alloc_host);
371
372
373
374
375
376
377
378
379
380int 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
403EXPORT_SYMBOL(mmc_add_host);
404
405
406
407
408
409
410
411
412
413void 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
427EXPORT_SYMBOL(mmc_remove_host);
428
429
430
431
432
433
434
435void mmc_free_host(struct mmc_host *host)
436{
437 mmc_pwrseq_free(host);
438 put_device(&host->class_dev);
439}
440
441EXPORT_SYMBOL(mmc_free_host);
442