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
33#define cls_dev_to_mmc_host(d) container_of(d, struct mmc_host, class_dev)
34
35static void mmc_host_classdev_release(struct device *dev)
36{
37 struct mmc_host *host = cls_dev_to_mmc_host(dev);
38 mutex_destroy(&host->slot.lock);
39 kfree(host);
40}
41
42static struct class mmc_host_class = {
43 .name = "mmc_host",
44 .dev_release = mmc_host_classdev_release,
45};
46
47int mmc_register_host_class(void)
48{
49 return class_register(&mmc_host_class);
50}
51
52void mmc_unregister_host_class(void)
53{
54 class_unregister(&mmc_host_class);
55}
56
57static DEFINE_IDR(mmc_host_idr);
58static DEFINE_SPINLOCK(mmc_host_lock);
59
60#ifdef CONFIG_MMC_CLKGATE
61static ssize_t clkgate_delay_show(struct device *dev,
62 struct device_attribute *attr, char *buf)
63{
64 struct mmc_host *host = cls_dev_to_mmc_host(dev);
65 return snprintf(buf, PAGE_SIZE, "%lu\n", host->clkgate_delay);
66}
67
68static ssize_t clkgate_delay_store(struct device *dev,
69 struct device_attribute *attr, const char *buf, size_t count)
70{
71 struct mmc_host *host = cls_dev_to_mmc_host(dev);
72 unsigned long flags, value;
73
74 if (kstrtoul(buf, 0, &value))
75 return -EINVAL;
76
77 spin_lock_irqsave(&host->clk_lock, flags);
78 host->clkgate_delay = value;
79 spin_unlock_irqrestore(&host->clk_lock, flags);
80 return count;
81}
82
83
84
85
86
87
88
89
90static void mmc_host_clk_gate_delayed(struct mmc_host *host)
91{
92 unsigned long tick_ns;
93 unsigned long freq = host->ios.clock;
94 unsigned long flags;
95
96 if (!freq) {
97 pr_debug("%s: frequency set to 0 in disable function, "
98 "this means the clock is already disabled.\n",
99 mmc_hostname(host));
100 return;
101 }
102
103
104
105
106
107 spin_lock_irqsave(&host->clk_lock, flags);
108
109
110
111
112
113
114 if (!host->clk_requests) {
115 spin_unlock_irqrestore(&host->clk_lock, flags);
116 tick_ns = DIV_ROUND_UP(1000000000, freq);
117 ndelay(host->clk_delay * tick_ns);
118 } else {
119
120 spin_unlock_irqrestore(&host->clk_lock, flags);
121 return;
122 }
123 mutex_lock(&host->clk_gate_mutex);
124 spin_lock_irqsave(&host->clk_lock, flags);
125 if (!host->clk_requests) {
126 spin_unlock_irqrestore(&host->clk_lock, flags);
127
128 mmc_gate_clock(host);
129 spin_lock_irqsave(&host->clk_lock, flags);
130 pr_debug("%s: gated MCI clock\n", mmc_hostname(host));
131 }
132 spin_unlock_irqrestore(&host->clk_lock, flags);
133 mutex_unlock(&host->clk_gate_mutex);
134}
135
136
137
138
139static void mmc_host_clk_gate_work(struct work_struct *work)
140{
141 struct mmc_host *host = container_of(work, struct mmc_host,
142 clk_gate_work.work);
143
144 mmc_host_clk_gate_delayed(host);
145}
146
147
148
149
150
151
152
153
154
155void mmc_host_clk_hold(struct mmc_host *host)
156{
157 unsigned long flags;
158
159
160 cancel_delayed_work_sync(&host->clk_gate_work);
161 mutex_lock(&host->clk_gate_mutex);
162 spin_lock_irqsave(&host->clk_lock, flags);
163 if (host->clk_gated) {
164 spin_unlock_irqrestore(&host->clk_lock, flags);
165 mmc_ungate_clock(host);
166 spin_lock_irqsave(&host->clk_lock, flags);
167 pr_debug("%s: ungated MCI clock\n", mmc_hostname(host));
168 }
169 host->clk_requests++;
170 spin_unlock_irqrestore(&host->clk_lock, flags);
171 mutex_unlock(&host->clk_gate_mutex);
172}
173
174
175
176
177
178static bool mmc_host_may_gate_card(struct mmc_card *card)
179{
180
181 if (!card)
182 return true;
183
184
185
186
187
188
189
190
191 return !(card->quirks & MMC_QUIRK_BROKEN_CLK_GATING);
192}
193
194
195
196
197
198
199
200
201
202void mmc_host_clk_release(struct mmc_host *host)
203{
204 unsigned long flags;
205
206 spin_lock_irqsave(&host->clk_lock, flags);
207 host->clk_requests--;
208 if (mmc_host_may_gate_card(host->card) &&
209 !host->clk_requests)
210 schedule_delayed_work(&host->clk_gate_work,
211 msecs_to_jiffies(host->clkgate_delay));
212 spin_unlock_irqrestore(&host->clk_lock, flags);
213}
214
215
216
217
218
219
220
221unsigned int mmc_host_clk_rate(struct mmc_host *host)
222{
223 unsigned long freq;
224 unsigned long flags;
225
226 spin_lock_irqsave(&host->clk_lock, flags);
227 if (host->clk_gated)
228 freq = host->clk_old;
229 else
230 freq = host->ios.clock;
231 spin_unlock_irqrestore(&host->clk_lock, flags);
232 return freq;
233}
234
235
236
237
238
239static inline void mmc_host_clk_init(struct mmc_host *host)
240{
241 host->clk_requests = 0;
242
243 host->clk_delay = 8;
244
245
246
247
248 host->clkgate_delay = 0;
249 host->clk_gated = false;
250 INIT_DELAYED_WORK(&host->clk_gate_work, mmc_host_clk_gate_work);
251 spin_lock_init(&host->clk_lock);
252 mutex_init(&host->clk_gate_mutex);
253}
254
255
256
257
258
259static inline void mmc_host_clk_exit(struct mmc_host *host)
260{
261
262
263
264
265 if (cancel_delayed_work_sync(&host->clk_gate_work))
266 mmc_host_clk_gate_delayed(host);
267 if (host->clk_gated)
268 mmc_host_clk_hold(host);
269
270 WARN_ON(host->clk_requests > 1);
271}
272
273static inline void mmc_host_clk_sysfs_init(struct mmc_host *host)
274{
275 host->clkgate_delay_attr.show = clkgate_delay_show;
276 host->clkgate_delay_attr.store = clkgate_delay_store;
277 sysfs_attr_init(&host->clkgate_delay_attr.attr);
278 host->clkgate_delay_attr.attr.name = "clkgate_delay";
279 host->clkgate_delay_attr.attr.mode = S_IRUGO | S_IWUSR;
280 if (device_create_file(&host->class_dev, &host->clkgate_delay_attr))
281 pr_err("%s: Failed to create clkgate_delay sysfs entry\n",
282 mmc_hostname(host));
283}
284#else
285
286static inline void mmc_host_clk_init(struct mmc_host *host)
287{
288}
289
290static inline void mmc_host_clk_exit(struct mmc_host *host)
291{
292}
293
294static inline void mmc_host_clk_sysfs_init(struct mmc_host *host)
295{
296}
297
298#endif
299
300
301
302
303
304
305
306
307
308
309int mmc_of_parse(struct mmc_host *host)
310{
311 struct device_node *np;
312 u32 bus_width;
313 bool explicit_inv_wp, gpio_inv_wp = false;
314 enum of_gpio_flags flags;
315 int len, ret, gpio;
316
317 if (!host->parent || !host->parent->of_node)
318 return 0;
319
320 np = host->parent->of_node;
321
322
323 if (of_property_read_u32(np, "bus-width", &bus_width) < 0) {
324 dev_dbg(host->parent,
325 "\"bus-width\" property is missing, assuming 1 bit.\n");
326 bus_width = 1;
327 }
328
329 switch (bus_width) {
330 case 8:
331 host->caps |= MMC_CAP_8_BIT_DATA;
332
333 case 4:
334 host->caps |= MMC_CAP_4_BIT_DATA;
335 break;
336 case 1:
337 break;
338 default:
339 dev_err(host->parent,
340 "Invalid \"bus-width\" value %ud!\n", bus_width);
341 return -EINVAL;
342 }
343
344
345 of_property_read_u32(np, "max-frequency", &host->f_max);
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360 if (of_find_property(np, "non-removable", &len)) {
361 host->caps |= MMC_CAP_NONREMOVABLE;
362 } else {
363 bool explicit_inv_cd, gpio_inv_cd = false;
364
365 explicit_inv_cd = of_property_read_bool(np, "cd-inverted");
366
367 if (of_find_property(np, "broken-cd", &len))
368 host->caps |= MMC_CAP_NEEDS_POLL;
369
370 gpio = of_get_named_gpio_flags(np, "cd-gpios", 0, &flags);
371 if (gpio == -EPROBE_DEFER)
372 return gpio;
373 if (gpio_is_valid(gpio)) {
374 if (!(flags & OF_GPIO_ACTIVE_LOW))
375 gpio_inv_cd = true;
376
377 ret = mmc_gpio_request_cd(host, gpio, 0);
378 if (ret < 0) {
379 dev_err(host->parent,
380 "Failed to request CD GPIO #%d: %d!\n",
381 gpio, ret);
382 return ret;
383 } else {
384 dev_info(host->parent, "Got CD GPIO #%d.\n",
385 gpio);
386 }
387 }
388
389 if (explicit_inv_cd ^ gpio_inv_cd)
390 host->caps2 |= MMC_CAP2_CD_ACTIVE_HIGH;
391 }
392
393
394 explicit_inv_wp = of_property_read_bool(np, "wp-inverted");
395
396 gpio = of_get_named_gpio_flags(np, "wp-gpios", 0, &flags);
397 if (gpio == -EPROBE_DEFER) {
398 ret = -EPROBE_DEFER;
399 goto out;
400 }
401 if (gpio_is_valid(gpio)) {
402 if (!(flags & OF_GPIO_ACTIVE_LOW))
403 gpio_inv_wp = true;
404
405 ret = mmc_gpio_request_ro(host, gpio);
406 if (ret < 0) {
407 dev_err(host->parent,
408 "Failed to request WP GPIO: %d!\n", ret);
409 goto out;
410 } else {
411 dev_info(host->parent, "Got WP GPIO #%d.\n",
412 gpio);
413 }
414 }
415 if (explicit_inv_wp ^ gpio_inv_wp)
416 host->caps2 |= MMC_CAP2_RO_ACTIVE_HIGH;
417
418 if (of_find_property(np, "cap-sd-highspeed", &len))
419 host->caps |= MMC_CAP_SD_HIGHSPEED;
420 if (of_find_property(np, "cap-mmc-highspeed", &len))
421 host->caps |= MMC_CAP_MMC_HIGHSPEED;
422 if (of_find_property(np, "cap-power-off-card", &len))
423 host->caps |= MMC_CAP_POWER_OFF_CARD;
424 if (of_find_property(np, "cap-sdio-irq", &len))
425 host->caps |= MMC_CAP_SDIO_IRQ;
426 if (of_find_property(np, "full-pwr-cycle", &len))
427 host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE;
428 if (of_find_property(np, "keep-power-in-suspend", &len))
429 host->pm_caps |= MMC_PM_KEEP_POWER;
430 if (of_find_property(np, "enable-sdio-wakeup", &len))
431 host->pm_caps |= MMC_PM_WAKE_SDIO_IRQ;
432
433 return 0;
434
435out:
436 mmc_gpio_free_cd(host);
437 return ret;
438}
439
440EXPORT_SYMBOL(mmc_of_parse);
441
442
443
444
445
446
447
448
449struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
450{
451 int err;
452 struct mmc_host *host;
453
454 host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL);
455 if (!host)
456 return NULL;
457
458
459 host->rescan_disable = 1;
460 idr_preload(GFP_KERNEL);
461 spin_lock(&mmc_host_lock);
462 err = idr_alloc(&mmc_host_idr, host, 0, 0, GFP_NOWAIT);
463 if (err >= 0)
464 host->index = err;
465 spin_unlock(&mmc_host_lock);
466 idr_preload_end();
467 if (err < 0)
468 goto free;
469
470 dev_set_name(&host->class_dev, "mmc%d", host->index);
471
472 host->parent = dev;
473 host->class_dev.parent = dev;
474 host->class_dev.class = &mmc_host_class;
475 device_initialize(&host->class_dev);
476
477 mmc_host_clk_init(host);
478
479 mutex_init(&host->slot.lock);
480 host->slot.cd_irq = -EINVAL;
481
482 spin_lock_init(&host->lock);
483 init_waitqueue_head(&host->wq);
484 INIT_DELAYED_WORK(&host->detect, mmc_rescan);
485#ifdef CONFIG_PM
486 host->pm_notify.notifier_call = mmc_pm_notify;
487#endif
488
489
490
491
492
493 host->max_segs = 1;
494 host->max_seg_size = PAGE_CACHE_SIZE;
495
496 host->max_req_size = PAGE_CACHE_SIZE;
497 host->max_blk_size = 512;
498 host->max_blk_count = PAGE_CACHE_SIZE / 512;
499
500 return host;
501
502free:
503 kfree(host);
504 return NULL;
505}
506
507EXPORT_SYMBOL(mmc_alloc_host);
508
509
510
511
512
513
514
515
516
517int mmc_add_host(struct mmc_host *host)
518{
519 int err;
520
521 WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) &&
522 !host->ops->enable_sdio_irq);
523
524 err = device_add(&host->class_dev);
525 if (err)
526 return err;
527
528 led_trigger_register_simple(dev_name(&host->class_dev), &host->led);
529
530#ifdef CONFIG_DEBUG_FS
531 mmc_add_host_debugfs(host);
532#endif
533 mmc_host_clk_sysfs_init(host);
534
535 mmc_start_host(host);
536 register_pm_notifier(&host->pm_notify);
537
538 return 0;
539}
540
541EXPORT_SYMBOL(mmc_add_host);
542
543
544
545
546
547
548
549
550
551void mmc_remove_host(struct mmc_host *host)
552{
553 unregister_pm_notifier(&host->pm_notify);
554 mmc_stop_host(host);
555
556#ifdef CONFIG_DEBUG_FS
557 mmc_remove_host_debugfs(host);
558#endif
559
560 device_del(&host->class_dev);
561
562 led_trigger_unregister_simple(host->led);
563
564 mmc_host_clk_exit(host);
565}
566
567EXPORT_SYMBOL(mmc_remove_host);
568
569
570
571
572
573
574
575void mmc_free_host(struct mmc_host *host)
576{
577 spin_lock(&mmc_host_lock);
578 idr_remove(&mmc_host_idr, host->index);
579 spin_unlock(&mmc_host_lock);
580
581 put_device(&host->class_dev);
582}
583
584EXPORT_SYMBOL(mmc_free_host);
585