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
 28static int of_dev_node_match(struct device *dev, void *data)
 29{
 30	return dev->of_node == data;
 31}
 32
 33static struct device *
 34of_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
 55static void of_coresight_get_ports(const 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
 77static 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
104int of_coresight_get_cpu(const struct device_node *node)
105{
106	int cpu;
107	struct device_node *dn;
108
109	dn = of_parse_phandle(node, "cpu", 0);
110	/* Affinity defaults to CPU0 */
111	if (!dn)
112		return 0;
113	cpu = of_cpu_node_to_id(dn);
114	of_node_put(dn);
115
116	/* Affinity to CPU0 if no cpu nodes are found */
117	return (cpu < 0) ? 0 : cpu;
118}
119EXPORT_SYMBOL_GPL(of_coresight_get_cpu);
120
121struct coresight_platform_data *
122of_get_coresight_platform_data(struct device *dev,
123			       const struct device_node *node)
124{
125	int i = 0, ret = 0;
126	struct coresight_platform_data *pdata;
127	struct of_endpoint endpoint, rendpoint;
128	struct device *rdev;
129	struct device_node *ep = NULL;
130	struct device_node *rparent = NULL;
131	struct device_node *rport = NULL;
132
133	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
134	if (!pdata)
135		return ERR_PTR(-ENOMEM);
136
137	/* Use device name as sysfs handle */
138	pdata->name = dev_name(dev);
139
140	/* Get the number of input and output port for this component */
141	of_coresight_get_ports(node, &pdata->nr_inport, &pdata->nr_outport);
142
143	if (pdata->nr_outport) {
144		ret = of_coresight_alloc_memory(dev, pdata);
145		if (ret)
146			return ERR_PTR(ret);
147
148		/* Iterate through each port to discover topology */
149		do {
150			/* Get a handle on a port */
151			ep = of_graph_get_next_endpoint(node, ep);
152			if (!ep)
153				break;
154
155			/*
156			 * No need to deal with input ports, processing for as
157			 * processing for output ports will deal with them.
158			 */
159			if (of_find_property(ep, "slave-mode", NULL))
160				continue;
161
162			/* Get a handle on the local endpoint */
163			ret = of_graph_parse_endpoint(ep, &endpoint);
164
165			if (ret)
166				continue;
167
168			/* The local out port number */
169			pdata->outports[i] = endpoint.port;
170
171			/*
172			 * Get a handle on the remote port and parent
173			 * attached to it.
174			 */
175			rparent = of_graph_get_remote_port_parent(ep);
176			rport = of_graph_get_remote_port(ep);
177
178			if (!rparent || !rport)
179				continue;
180
181			if (of_graph_parse_endpoint(rport, &rendpoint))
182				continue;
183
184			rdev = of_coresight_get_endpoint_device(rparent);
185			if (!rdev)
186				return ERR_PTR(-EPROBE_DEFER);
187
188			pdata->child_names[i] = dev_name(rdev);
189			pdata->child_ports[i] = rendpoint.id;
190
191			i++;
192		} while (ep);
193	}
194
195	pdata->cpu = of_coresight_get_cpu(node);
196
197	return pdata;
198}
199EXPORT_SYMBOL_GPL(of_get_coresight_platform_data);