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