1 /* Copyright (c) 2012, The Linux Foundation. All rights reserved.
2 *
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 and
5 * only version 2 as published by the Free Software Foundation.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 */
12
13 #include <linux/types.h>
14 #include <linux/err.h>
15 #include <linux/slab.h>
16 #include <linux/clk.h>
17 #include <linux/of.h>
18 #include <linux/of_address.h>
19 #include <linux/of_graph.h>
20 #include <linux/of_platform.h>
21 #include <linux/platform_device.h>
22 #include <linux/amba/bus.h>
23 #include <linux/coresight.h>
24 #include <linux/cpumask.h>
25 #include <asm/smp_plat.h>
26
27
of_dev_node_match(struct device * dev,void * data)28 static int of_dev_node_match(struct device *dev, void *data)
29 {
30 return dev->of_node == data;
31 }
32
33 static struct device *
of_coresight_get_endpoint_device(struct device_node * endpoint)34 of_coresight_get_endpoint_device(struct device_node *endpoint)
35 {
36 struct device *dev = NULL;
37
38 /*
39 * If we have a non-configurable replicator, it will be found on the
40 * platform bus.
41 */
42 dev = bus_find_device(&platform_bus_type, NULL,
43 endpoint, of_dev_node_match);
44 if (dev)
45 return dev;
46
47 /*
48 * We have a configurable component - circle through the AMBA bus
49 * looking for the device that matches the endpoint node.
50 */
51 return bus_find_device(&amba_bustype, NULL,
52 endpoint, of_dev_node_match);
53 }
54
of_coresight_get_ports(struct device_node * node,int * nr_inport,int * nr_outport)55 static void of_coresight_get_ports(struct device_node *node,
56 int *nr_inport, int *nr_outport)
57 {
58 struct device_node *ep = NULL;
59 int in = 0, out = 0;
60
61 do {
62 ep = of_graph_get_next_endpoint(node, ep);
63 if (!ep)
64 break;
65
66 if (of_property_read_bool(ep, "slave-mode"))
67 in++;
68 else
69 out++;
70
71 } while (ep);
72
73 *nr_inport = in;
74 *nr_outport = out;
75 }
76
of_coresight_alloc_memory(struct device * dev,struct coresight_platform_data * pdata)77 static int of_coresight_alloc_memory(struct device *dev,
78 struct coresight_platform_data *pdata)
79 {
80 /* List of output port on this component */
81 pdata->outports = devm_kzalloc(dev, pdata->nr_outport *
82 sizeof(*pdata->outports),
83 GFP_KERNEL);
84 if (!pdata->outports)
85 return -ENOMEM;
86
87 /* Children connected to this component via @outports */
88 pdata->child_names = devm_kzalloc(dev, pdata->nr_outport *
89 sizeof(*pdata->child_names),
90 GFP_KERNEL);
91 if (!pdata->child_names)
92 return -ENOMEM;
93
94 /* Port number on the child this component is connected to */
95 pdata->child_ports = devm_kzalloc(dev, pdata->nr_outport *
96 sizeof(*pdata->child_ports),
97 GFP_KERNEL);
98 if (!pdata->child_ports)
99 return -ENOMEM;
100
101 return 0;
102 }
103
of_get_coresight_platform_data(struct device * dev,struct device_node * node)104 struct coresight_platform_data *of_get_coresight_platform_data(
105 struct device *dev, struct device_node *node)
106 {
107 int i = 0, ret = 0, cpu;
108 struct coresight_platform_data *pdata;
109 struct of_endpoint endpoint, rendpoint;
110 struct device *rdev;
111 struct device_node *dn;
112 struct device_node *ep = NULL;
113 struct device_node *rparent = NULL;
114 struct device_node *rport = NULL;
115
116 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
117 if (!pdata)
118 return ERR_PTR(-ENOMEM);
119
120 /* Use device name as sysfs handle */
121 pdata->name = dev_name(dev);
122
123 /* Get the number of input and output port for this component */
124 of_coresight_get_ports(node, &pdata->nr_inport, &pdata->nr_outport);
125
126 if (pdata->nr_outport) {
127 ret = of_coresight_alloc_memory(dev, pdata);
128 if (ret)
129 return ERR_PTR(ret);
130
131 /* Iterate through each port to discover topology */
132 do {
133 /* Get a handle on a port */
134 ep = of_graph_get_next_endpoint(node, ep);
135 if (!ep)
136 break;
137
138 /*
139 * No need to deal with input ports, processing for as
140 * processing for output ports will deal with them.
141 */
142 if (of_find_property(ep, "slave-mode", NULL))
143 continue;
144
145 /* Get a handle on the local endpoint */
146 ret = of_graph_parse_endpoint(ep, &endpoint);
147
148 if (ret)
149 continue;
150
151 /* The local out port number */
152 pdata->outports[i] = endpoint.port;
153
154 /*
155 * Get a handle on the remote port and parent
156 * attached to it.
157 */
158 rparent = of_graph_get_remote_port_parent(ep);
159 rport = of_graph_get_remote_port(ep);
160
161 if (!rparent || !rport)
162 continue;
163
164 if (of_graph_parse_endpoint(rport, &rendpoint))
165 continue;
166
167 rdev = of_coresight_get_endpoint_device(rparent);
168 if (!rdev)
169 return ERR_PTR(-EPROBE_DEFER);
170
171 pdata->child_names[i] = dev_name(rdev);
172 pdata->child_ports[i] = rendpoint.id;
173
174 i++;
175 } while (ep);
176 }
177
178 /* Affinity defaults to CPU0 */
179 pdata->cpu = 0;
180 dn = of_parse_phandle(node, "cpu", 0);
181 for (cpu = 0; dn && cpu < nr_cpu_ids; cpu++) {
182 if (dn == of_get_cpu_node(cpu, NULL)) {
183 pdata->cpu = cpu;
184 break;
185 }
186 }
187 of_node_put(dn);
188
189 return pdata;
190 }
191 EXPORT_SYMBOL_GPL(of_get_coresight_platform_data);
192