1
2
3
4
5
6
7
8
9
10#define pr_fmt(fmt) "board_staging: " fmt
11
12#include <linux/clkdev.h>
13#include <linux/init.h>
14#include <linux/irq.h>
15#include <linux/device.h>
16#include <linux/kernel.h>
17#include <linux/of.h>
18#include <linux/of_address.h>
19#include <linux/of_irq.h>
20#include <linux/platform_device.h>
21#include <linux/pm_domain.h>
22
23#include "board.h"
24
25static struct device_node *irqc_node __initdata;
26static unsigned int irqc_base __initdata;
27
28static bool find_by_address(u64 base_address)
29{
30 struct device_node *dn = of_find_all_nodes(NULL);
31 struct resource res;
32
33 while (dn) {
34 if (!of_address_to_resource(dn, 0, &res)) {
35 if (res.start == base_address) {
36 of_node_put(dn);
37 return true;
38 }
39 }
40 dn = of_find_all_nodes(dn);
41 }
42
43 return false;
44}
45
46bool __init board_staging_dt_node_available(const struct resource *resource,
47 unsigned int num_resources)
48{
49 unsigned int i;
50
51 for (i = 0; i < num_resources; i++) {
52 const struct resource *r = resource + i;
53
54 if (resource_type(r) == IORESOURCE_MEM)
55 if (find_by_address(r->start))
56 return true;
57 }
58
59 return false;
60}
61
62int __init board_staging_gic_setup_xlate(const char *gic_match,
63 unsigned int base)
64{
65 WARN_ON(irqc_node);
66
67 irqc_node = of_find_compatible_node(NULL, NULL, gic_match);
68
69 WARN_ON(!irqc_node);
70 if (!irqc_node)
71 return -ENOENT;
72
73 irqc_base = base;
74 return 0;
75}
76
77static void __init gic_fixup_resource(struct resource *res)
78{
79 struct of_phandle_args irq_data;
80 unsigned int hwirq = res->start;
81 unsigned int virq;
82
83 if (resource_type(res) != IORESOURCE_IRQ || !irqc_node)
84 return;
85
86 irq_data.np = irqc_node;
87 irq_data.args_count = 3;
88 irq_data.args[0] = 0;
89 irq_data.args[1] = hwirq - irqc_base;
90 switch (res->flags &
91 (IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE |
92 IORESOURCE_IRQ_LOWLEVEL | IORESOURCE_IRQ_HIGHLEVEL)) {
93 case IORESOURCE_IRQ_LOWEDGE:
94 irq_data.args[2] = IRQ_TYPE_EDGE_FALLING;
95 break;
96 case IORESOURCE_IRQ_HIGHEDGE:
97 irq_data.args[2] = IRQ_TYPE_EDGE_RISING;
98 break;
99 case IORESOURCE_IRQ_LOWLEVEL:
100 irq_data.args[2] = IRQ_TYPE_LEVEL_LOW;
101 break;
102 case IORESOURCE_IRQ_HIGHLEVEL:
103 default:
104 irq_data.args[2] = IRQ_TYPE_LEVEL_HIGH;
105 break;
106 }
107
108 virq = irq_create_of_mapping(&irq_data);
109 if (WARN_ON(!virq))
110 return;
111
112 pr_debug("hwirq %u -> virq %u\n", hwirq, virq);
113 res->start = virq;
114}
115
116void __init board_staging_gic_fixup_resources(struct resource *res,
117 unsigned int nres)
118{
119 unsigned int i;
120
121 for (i = 0; i < nres; i++)
122 gic_fixup_resource(&res[i]);
123}
124
125int __init board_staging_register_clock(const struct board_staging_clk *bsc)
126{
127 int error;
128
129 pr_debug("Aliasing clock %s for con_id %s dev_id %s\n", bsc->clk,
130 bsc->con_id, bsc->dev_id);
131 error = clk_add_alias(bsc->con_id, bsc->dev_id, bsc->clk, NULL);
132 if (error)
133 pr_err("Failed to alias clock %s (%d)\n", bsc->clk, error);
134
135 return error;
136}
137
138#ifdef CONFIG_PM_GENERIC_DOMAINS_OF
139static int board_staging_add_dev_domain(struct platform_device *pdev,
140 const char *domain)
141{
142 struct of_phandle_args pd_args;
143 struct generic_pm_domain *pd;
144 struct device_node *np;
145
146 np = of_find_node_by_path(domain);
147 if (!np) {
148 pr_err("Cannot find domain node %s\n", domain);
149 return -ENOENT;
150 }
151
152 pd_args.np = np;
153 pd_args.args_count = 0;
154 pd = of_genpd_get_from_provider(&pd_args);
155 if (IS_ERR(pd)) {
156 pr_err("Cannot find genpd %s (%ld)\n", domain, PTR_ERR(pd));
157 return PTR_ERR(pd);
158 }
159 pr_debug("Found genpd %s for device %s\n", pd->name, pdev->name);
160
161 return pm_genpd_add_device(pd, &pdev->dev);
162}
163#else
164static inline int board_staging_add_dev_domain(struct platform_device *pdev,
165 const char *domain)
166{
167 return 0;
168}
169#endif
170
171int __init board_staging_register_device(const struct board_staging_dev *dev)
172{
173 struct platform_device *pdev = dev->pdev;
174 unsigned int i;
175 int error;
176
177 pr_debug("Trying to register device %s\n", pdev->name);
178 if (board_staging_dt_node_available(pdev->resource,
179 pdev->num_resources)) {
180 pr_warn("Skipping %s, already in DT\n", pdev->name);
181 return -EEXIST;
182 }
183
184 board_staging_gic_fixup_resources(pdev->resource, pdev->num_resources);
185
186 for (i = 0; i < dev->nclocks; i++)
187 board_staging_register_clock(&dev->clocks[i]);
188
189 if (dev->domain)
190 board_staging_add_dev_domain(pdev, dev->domain);
191
192 error = platform_device_register(pdev);
193 if (error) {
194 pr_err("Failed to register device %s (%d)\n", pdev->name,
195 error);
196 return error;
197 }
198
199 return error;
200}
201
202void __init board_staging_register_devices(const struct board_staging_dev *devs,
203 unsigned int ndevs)
204{
205 unsigned int i;
206
207 for (i = 0; i < ndevs; i++)
208 board_staging_register_device(&devs[i]);
209}
210