1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#undef DEBUG
27
28#include <linux/kernel.h>
29#include <linux/platform_device.h>
30#include <linux/slab.h>
31#include <linux/err.h>
32#include <linux/io.h>
33#include <linux/clk.h>
34#include <linux/clkdev.h>
35#include <linux/pm_runtime.h>
36#include <linux/of.h>
37#include <linux/notifier.h>
38
39#include "soc.h"
40#include "omap_device.h"
41#include "omap_hwmod.h"
42
43
44
45static void _add_clkdev(struct omap_device *od, const char *clk_alias,
46 const char *clk_name)
47{
48 struct clk *r;
49 struct clk_lookup *l;
50
51 if (!clk_alias || !clk_name)
52 return;
53
54 dev_dbg(&od->pdev->dev, "Creating %s -> %s\n", clk_alias, clk_name);
55
56 r = clk_get_sys(dev_name(&od->pdev->dev), clk_alias);
57 if (!IS_ERR(r)) {
58 dev_warn(&od->pdev->dev,
59 "alias %s already exists\n", clk_alias);
60 clk_put(r);
61 return;
62 }
63
64 r = clk_get(NULL, clk_name);
65 if (IS_ERR(r)) {
66 dev_err(&od->pdev->dev,
67 "clk_get for %s failed\n", clk_name);
68 return;
69 }
70
71 l = clkdev_alloc(r, clk_alias, dev_name(&od->pdev->dev));
72 if (!l) {
73 dev_err(&od->pdev->dev,
74 "clkdev_alloc for %s failed\n", clk_alias);
75 return;
76 }
77
78 clkdev_add(l);
79}
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100static void _add_hwmod_clocks_clkdev(struct omap_device *od,
101 struct omap_hwmod *oh)
102{
103 int i;
104
105 _add_clkdev(od, "fck", oh->main_clk);
106
107 for (i = 0; i < oh->opt_clks_cnt; i++)
108 _add_clkdev(od, oh->opt_clks[i].role, oh->opt_clks[i].clk);
109}
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124static int omap_device_build_from_dt(struct platform_device *pdev)
125{
126 struct omap_hwmod **hwmods;
127 struct omap_device *od;
128 struct omap_hwmod *oh;
129 struct device_node *node = pdev->dev.of_node;
130 const char *oh_name;
131 int oh_cnt, i, ret = 0;
132 bool device_active = false;
133
134 oh_cnt = of_property_count_strings(node, "ti,hwmods");
135 if (oh_cnt <= 0) {
136 dev_dbg(&pdev->dev, "No 'hwmods' to build omap_device\n");
137 return -ENODEV;
138 }
139
140 hwmods = kzalloc(sizeof(struct omap_hwmod *) * oh_cnt, GFP_KERNEL);
141 if (!hwmods) {
142 ret = -ENOMEM;
143 goto odbfd_exit;
144 }
145
146 for (i = 0; i < oh_cnt; i++) {
147 of_property_read_string_index(node, "ti,hwmods", i, &oh_name);
148 oh = omap_hwmod_lookup(oh_name);
149 if (!oh) {
150 dev_err(&pdev->dev, "Cannot lookup hwmod '%s'\n",
151 oh_name);
152 ret = -EINVAL;
153 goto odbfd_exit1;
154 }
155 hwmods[i] = oh;
156 if (oh->flags & HWMOD_INIT_NO_IDLE)
157 device_active = true;
158 }
159
160 od = omap_device_alloc(pdev, hwmods, oh_cnt);
161 if (!od) {
162 dev_err(&pdev->dev, "Cannot allocate omap_device for :%s\n",
163 oh_name);
164 ret = PTR_ERR(od);
165 goto odbfd_exit1;
166 }
167
168
169 for (i = 0; i < pdev->num_resources; i++) {
170 struct resource *r = &pdev->resource[i];
171
172 if (r->name == NULL)
173 r->name = dev_name(&pdev->dev);
174 }
175
176 pdev->dev.pm_domain = &omap_device_pm_domain;
177
178 if (device_active) {
179 omap_device_enable(pdev);
180 pm_runtime_set_active(&pdev->dev);
181 }
182
183odbfd_exit1:
184 kfree(hwmods);
185odbfd_exit:
186 return ret;
187}
188
189static int _omap_device_notifier_call(struct notifier_block *nb,
190 unsigned long event, void *dev)
191{
192 struct platform_device *pdev = to_platform_device(dev);
193 struct omap_device *od;
194
195 switch (event) {
196 case BUS_NOTIFY_DEL_DEVICE:
197 if (pdev->archdata.od)
198 omap_device_delete(pdev->archdata.od);
199 break;
200 case BUS_NOTIFY_ADD_DEVICE:
201 if (pdev->dev.of_node)
202 omap_device_build_from_dt(pdev);
203
204 default:
205 od = to_omap_device(pdev);
206 if (od)
207 od->_driver_status = event;
208 }
209
210 return NOTIFY_DONE;
211}
212
213
214
215
216
217
218
219static int _omap_device_enable_hwmods(struct omap_device *od)
220{
221 int i;
222
223 for (i = 0; i < od->hwmods_cnt; i++)
224 omap_hwmod_enable(od->hwmods[i]);
225
226
227 return 0;
228}
229
230
231
232
233
234
235
236static int _omap_device_idle_hwmods(struct omap_device *od)
237{
238 int i;
239
240 for (i = 0; i < od->hwmods_cnt; i++)
241 omap_hwmod_idle(od->hwmods[i]);
242
243
244 return 0;
245}
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264int omap_device_get_context_loss_count(struct platform_device *pdev)
265{
266 struct omap_device *od;
267 u32 ret = 0;
268
269 od = to_omap_device(pdev);
270
271 if (od->hwmods_cnt)
272 ret = omap_hwmod_get_context_loss_count(od->hwmods[0]);
273
274 return ret;
275}
276
277
278
279
280
281
282
283
284
285
286
287static int omap_device_count_resources(struct omap_device *od,
288 unsigned long flags)
289{
290 int c = 0;
291 int i;
292
293 for (i = 0; i < od->hwmods_cnt; i++)
294 c += omap_hwmod_count_resources(od->hwmods[i], flags);
295
296 pr_debug("omap_device: %s: counted %d total resources across %d hwmods\n",
297 od->pdev->name, c, od->hwmods_cnt);
298
299 return c;
300}
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319static int omap_device_fill_resources(struct omap_device *od,
320 struct resource *res)
321{
322 int i, r;
323
324 for (i = 0; i < od->hwmods_cnt; i++) {
325 r = omap_hwmod_fill_resources(od->hwmods[i], res);
326 res += r;
327 }
328
329 return 0;
330}
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346static int _od_fill_dma_resources(struct omap_device *od,
347 struct resource *res)
348{
349 int i, r;
350
351 for (i = 0; i < od->hwmods_cnt; i++) {
352 r = omap_hwmod_fill_dma_resources(od->hwmods[i], res);
353 res += r;
354 }
355
356 return 0;
357}
358
359
360
361
362
363
364
365
366
367
368
369
370
371struct omap_device *omap_device_alloc(struct platform_device *pdev,
372 struct omap_hwmod **ohs, int oh_cnt)
373{
374 int ret = -ENOMEM;
375 struct omap_device *od;
376 struct resource *res = NULL;
377 int i, res_count;
378 struct omap_hwmod **hwmods;
379
380 od = kzalloc(sizeof(struct omap_device), GFP_KERNEL);
381 if (!od) {
382 ret = -ENOMEM;
383 goto oda_exit1;
384 }
385 od->hwmods_cnt = oh_cnt;
386
387 hwmods = kmemdup(ohs, sizeof(struct omap_hwmod *) * oh_cnt, GFP_KERNEL);
388 if (!hwmods)
389 goto oda_exit2;
390
391 od->hwmods = hwmods;
392 od->pdev = pdev;
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413 if (!pdev->num_resources) {
414
415 res_count = omap_device_count_resources(od, IORESOURCE_IRQ |
416 IORESOURCE_DMA |
417 IORESOURCE_MEM);
418 } else {
419
420 for (i = 0; i < pdev->num_resources; i++) {
421 struct resource *r = &pdev->resource[i];
422
423
424 if (r->flags == IORESOURCE_DMA)
425 goto have_everything;
426 }
427
428 res_count = omap_device_count_resources(od, IORESOURCE_DMA);
429
430 if (!res_count)
431 goto have_everything;
432
433 res_count += pdev->num_resources;
434 }
435
436
437 res = kzalloc(sizeof(struct resource) * res_count, GFP_KERNEL);
438 if (!res)
439 goto oda_exit3;
440
441 if (!pdev->num_resources) {
442 dev_dbg(&pdev->dev, "%s: using %d resources from hwmod\n",
443 __func__, res_count);
444 omap_device_fill_resources(od, res);
445 } else {
446 dev_dbg(&pdev->dev,
447 "%s: appending %d DMA resources from hwmod\n",
448 __func__, res_count - pdev->num_resources);
449 memcpy(res, pdev->resource,
450 sizeof(struct resource) * pdev->num_resources);
451 _od_fill_dma_resources(od, &res[pdev->num_resources]);
452 }
453
454 ret = platform_device_add_resources(pdev, res, res_count);
455 kfree(res);
456
457 if (ret)
458 goto oda_exit3;
459
460have_everything:
461 pdev->archdata.od = od;
462
463 for (i = 0; i < oh_cnt; i++) {
464 hwmods[i]->od = od;
465 _add_hwmod_clocks_clkdev(od, hwmods[i]);
466 }
467
468 return od;
469
470oda_exit3:
471 kfree(hwmods);
472oda_exit2:
473 kfree(od);
474oda_exit1:
475 dev_err(&pdev->dev, "omap_device: build failed (%d)\n", ret);
476
477 return ERR_PTR(ret);
478}
479
480void omap_device_delete(struct omap_device *od)
481{
482 if (!od)
483 return;
484
485 od->pdev->archdata.od = NULL;
486 kfree(od->hwmods);
487 kfree(od);
488}
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504struct platform_device __init *omap_device_build(const char *pdev_name,
505 int pdev_id,
506 struct omap_hwmod *oh,
507 void *pdata, int pdata_len)
508{
509 struct omap_hwmod *ohs[] = { oh };
510
511 if (!oh)
512 return ERR_PTR(-EINVAL);
513
514 return omap_device_build_ss(pdev_name, pdev_id, ohs, 1, pdata,
515 pdata_len);
516}
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532struct platform_device __init *omap_device_build_ss(const char *pdev_name,
533 int pdev_id,
534 struct omap_hwmod **ohs,
535 int oh_cnt, void *pdata,
536 int pdata_len)
537{
538 int ret = -ENOMEM;
539 struct platform_device *pdev;
540 struct omap_device *od;
541
542 if (!ohs || oh_cnt == 0 || !pdev_name)
543 return ERR_PTR(-EINVAL);
544
545 if (!pdata && pdata_len > 0)
546 return ERR_PTR(-EINVAL);
547
548 pdev = platform_device_alloc(pdev_name, pdev_id);
549 if (!pdev) {
550 ret = -ENOMEM;
551 goto odbs_exit;
552 }
553
554
555 if (pdev->id != -1)
556 dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);
557 else
558 dev_set_name(&pdev->dev, "%s", pdev->name);
559
560 od = omap_device_alloc(pdev, ohs, oh_cnt);
561 if (IS_ERR(od))
562 goto odbs_exit1;
563
564 ret = platform_device_add_data(pdev, pdata, pdata_len);
565 if (ret)
566 goto odbs_exit2;
567
568 ret = omap_device_register(pdev);
569 if (ret)
570 goto odbs_exit2;
571
572 return pdev;
573
574odbs_exit2:
575 omap_device_delete(od);
576odbs_exit1:
577 platform_device_put(pdev);
578odbs_exit:
579
580 pr_err("omap_device: %s: build failed (%d)\n", pdev_name, ret);
581
582 return ERR_PTR(ret);
583}
584
585#ifdef CONFIG_PM_RUNTIME
586static int _od_runtime_suspend(struct device *dev)
587{
588 struct platform_device *pdev = to_platform_device(dev);
589 int ret;
590
591 ret = pm_generic_runtime_suspend(dev);
592
593 if (!ret)
594 omap_device_idle(pdev);
595
596 return ret;
597}
598
599static int _od_runtime_resume(struct device *dev)
600{
601 struct platform_device *pdev = to_platform_device(dev);
602
603 omap_device_enable(pdev);
604
605 return pm_generic_runtime_resume(dev);
606}
607#endif
608
609#ifdef CONFIG_SUSPEND
610static int _od_suspend_noirq(struct device *dev)
611{
612 struct platform_device *pdev = to_platform_device(dev);
613 struct omap_device *od = to_omap_device(pdev);
614 int ret;
615
616
617 if (od->_driver_status != BUS_NOTIFY_BOUND_DRIVER)
618 return 0;
619
620 ret = pm_generic_suspend_noirq(dev);
621
622 if (!ret && !pm_runtime_status_suspended(dev)) {
623 if (pm_generic_runtime_suspend(dev) == 0) {
624 omap_device_idle(pdev);
625 od->flags |= OMAP_DEVICE_SUSPENDED;
626 }
627 }
628
629 return ret;
630}
631
632static int _od_resume_noirq(struct device *dev)
633{
634 struct platform_device *pdev = to_platform_device(dev);
635 struct omap_device *od = to_omap_device(pdev);
636
637 if ((od->flags & OMAP_DEVICE_SUSPENDED) &&
638 !pm_runtime_status_suspended(dev)) {
639 od->flags &= ~OMAP_DEVICE_SUSPENDED;
640 omap_device_enable(pdev);
641 pm_generic_runtime_resume(dev);
642 }
643
644 return pm_generic_resume_noirq(dev);
645}
646#else
647#define _od_suspend_noirq NULL
648#define _od_resume_noirq NULL
649#endif
650
651struct dev_pm_domain omap_device_pm_domain = {
652 .ops = {
653 SET_RUNTIME_PM_OPS(_od_runtime_suspend, _od_runtime_resume,
654 NULL)
655 USE_PLATFORM_PM_SLEEP_OPS
656 .suspend_noirq = _od_suspend_noirq,
657 .resume_noirq = _od_resume_noirq,
658 }
659};
660
661
662
663
664
665
666
667
668
669int omap_device_register(struct platform_device *pdev)
670{
671 pr_debug("omap_device: %s: registering\n", pdev->name);
672
673 pdev->dev.pm_domain = &omap_device_pm_domain;
674 return platform_device_add(pdev);
675}
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692int omap_device_enable(struct platform_device *pdev)
693{
694 int ret;
695 struct omap_device *od;
696
697 od = to_omap_device(pdev);
698
699 if (od->_state == OMAP_DEVICE_STATE_ENABLED) {
700 dev_warn(&pdev->dev,
701 "omap_device: %s() called from invalid state %d\n",
702 __func__, od->_state);
703 return -EINVAL;
704 }
705
706 ret = _omap_device_enable_hwmods(od);
707
708 od->_state = OMAP_DEVICE_STATE_ENABLED;
709
710 return ret;
711}
712
713
714
715
716
717
718
719
720
721
722int omap_device_idle(struct platform_device *pdev)
723{
724 int ret;
725 struct omap_device *od;
726
727 od = to_omap_device(pdev);
728
729 if (od->_state != OMAP_DEVICE_STATE_ENABLED) {
730 dev_warn(&pdev->dev,
731 "omap_device: %s() called from invalid state %d\n",
732 __func__, od->_state);
733 return -EINVAL;
734 }
735
736 ret = _omap_device_idle_hwmods(od);
737
738 od->_state = OMAP_DEVICE_STATE_IDLE;
739
740 return ret;
741}
742
743
744
745
746
747
748
749
750
751
752
753
754
755int omap_device_assert_hardreset(struct platform_device *pdev, const char *name)
756{
757 struct omap_device *od = to_omap_device(pdev);
758 int ret = 0;
759 int i;
760
761 for (i = 0; i < od->hwmods_cnt; i++) {
762 ret = omap_hwmod_assert_hardreset(od->hwmods[i], name);
763 if (ret)
764 break;
765 }
766
767 return ret;
768}
769
770
771
772
773
774
775
776
777
778
779
780
781
782int omap_device_deassert_hardreset(struct platform_device *pdev,
783 const char *name)
784{
785 struct omap_device *od = to_omap_device(pdev);
786 int ret = 0;
787 int i;
788
789 for (i = 0; i < od->hwmods_cnt; i++) {
790 ret = omap_hwmod_deassert_hardreset(od->hwmods[i], name);
791 if (ret)
792 break;
793 }
794
795 return ret;
796}
797
798
799
800
801
802
803
804
805
806struct device *omap_device_get_by_hwmod_name(const char *oh_name)
807{
808 struct omap_hwmod *oh;
809
810 if (!oh_name) {
811 WARN(1, "%s: no hwmod name!\n", __func__);
812 return ERR_PTR(-EINVAL);
813 }
814
815 oh = omap_hwmod_lookup(oh_name);
816 if (!oh) {
817 WARN(1, "%s: no hwmod for %s\n", __func__,
818 oh_name);
819 return ERR_PTR(-ENODEV);
820 }
821 if (!oh->od) {
822 WARN(1, "%s: no omap_device for %s\n", __func__,
823 oh_name);
824 return ERR_PTR(-ENODEV);
825 }
826
827 return &oh->od->pdev->dev;
828}
829
830static struct notifier_block platform_nb = {
831 .notifier_call = _omap_device_notifier_call,
832};
833
834static int __init omap_device_init(void)
835{
836 bus_register_notifier(&platform_bus_type, &platform_nb);
837 return 0;
838}
839omap_core_initcall(omap_device_init);
840
841
842
843
844
845
846
847
848
849static int __init omap_device_late_idle(struct device *dev, void *data)
850{
851 struct platform_device *pdev = to_platform_device(dev);
852 struct omap_device *od = to_omap_device(pdev);
853 int i;
854
855 if (!od)
856 return 0;
857
858
859
860
861
862
863
864
865
866
867 for (i = 0; i < od->hwmods_cnt; i++)
868 if (od->hwmods[i]->flags & HWMOD_INIT_NO_IDLE)
869 return 0;
870
871 if (od->_driver_status != BUS_NOTIFY_BOUND_DRIVER) {
872 if (od->_state == OMAP_DEVICE_STATE_ENABLED) {
873 dev_warn(dev, "%s: enabled but no driver. Idling\n",
874 __func__);
875 omap_device_idle(pdev);
876 }
877 }
878
879 return 0;
880}
881
882static int __init omap_device_late_init(void)
883{
884 bus_for_each_dev(&platform_bus_type, NULL, NULL, omap_device_late_idle);
885 return 0;
886}
887omap_late_initcall_sync(omap_device_late_init);
888