[people/ms/u-boot.git] / drivers / misc / fsl_portals.c

/*
 * Copyright 2008-2011 Freescale Semiconductor, Inc.
 * Copyright 2017 NXP
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <libfdt.h>
#include <fdt_support.h>

#include <asm/processor.h>
#include <asm/io.h>
#ifdef CONFIG_PPC
#include <asm/fsl_portals.h>
#include <asm/fsl_liodn.h>
#endif
#include <fsl_qbman.h>

#define MAX_BPORTALS (CONFIG_SYS_BMAN_CINH_SIZE / CONFIG_SYS_BMAN_SP_CINH_SIZE)
#define MAX_QPORTALS (CONFIG_SYS_QMAN_CINH_SIZE / CONFIG_SYS_QMAN_SP_CINH_SIZE)
void setup_qbman_portals(void)
{
	void __iomem *bpaddr = (void *)CONFIG_SYS_BMAN_CINH_BASE +
				CONFIG_SYS_BMAN_SWP_ISDR_REG;
	void __iomem *qpaddr = (void *)CONFIG_SYS_QMAN_CINH_BASE +
				CONFIG_SYS_QMAN_SWP_ISDR_REG;
#ifdef CONFIG_PPC
	struct ccsr_qman *qman = (void *)CONFIG_SYS_FSL_QMAN_ADDR;

	/* Set the Qman initiator BAR to match the LAW (for DQRR stashing) */
#ifdef CONFIG_PHYS_64BIT
	out_be32(&qman->qcsp_bare, (u32)(CONFIG_SYS_QMAN_MEM_PHYS >> 32));
#endif
	out_be32(&qman->qcsp_bar, (u32)CONFIG_SYS_QMAN_MEM_PHYS);
#endif
#ifdef CONFIG_FSL_CORENET
	int i;

	for (i = 0; i < CONFIG_SYS_QMAN_NUM_PORTALS; i++) {
		u8 sdest = qp_info[i].sdest;
		u16 fliodn = qp_info[i].fliodn;
		u16 dliodn = qp_info[i].dliodn;
		u16 liodn_off = qp_info[i].liodn_offset;

		out_be32(&qman->qcsp[i].qcsp_lio_cfg, (liodn_off << 16) |
					dliodn);
		/* set frame liodn */
		out_be32(&qman->qcsp[i].qcsp_io_cfg, (sdest << 16) | fliodn);
	}
#endif

	/* Change default state of BMan ISDR portals to all 1s */
	inhibit_portals(bpaddr, CONFIG_SYS_BMAN_NUM_PORTALS, MAX_BPORTALS,
			CONFIG_SYS_BMAN_SP_CINH_SIZE);
	inhibit_portals(qpaddr, CONFIG_SYS_QMAN_NUM_PORTALS, MAX_QPORTALS,
			CONFIG_SYS_QMAN_SP_CINH_SIZE);
}

void inhibit_portals(void __iomem *addr, int max_portals,
		     int arch_max_portals, int portal_cinh_size)
{
	u32 val;
	int i;

	/* arch_max_portals is the maximum based on memory size. This includes
	 * the reserved memory in the SoC.  max_portals the number of physical
	 * portals in the SoC
	 */
	if (max_portals > arch_max_portals) {
		printf("ERROR: portal config error\n");
		max_portals = arch_max_portals;
	}

	for (i = 0; i < max_portals; i++) {
		out_be32(addr, -1);
		val = in_be32(addr);
		if (!val) {
			printf("ERROR: Stopped after %d portals\n", i);
			return;
		}
		addr += portal_cinh_size;
	}
	debug("Cleared %d portals\n", i);
}

#ifdef CONFIG_PPC
static int fdt_qportal(void *blob, int off, int id, char *name,
		       enum fsl_dpaa_dev dev, int create)
{
	int childoff, dev_off, ret = 0;
	u32 dev_handle;
#ifdef CONFIG_FSL_CORENET
	int num;
	u32 liodns[2];
#endif

	childoff = fdt_subnode_offset(blob, off, name);
	if (create) {
		char handle[64], *p;

		strncpy(handle, name, sizeof(handle));
		p = strchr(handle, '@');
		if (!strncmp(name, "fman", 4)) {
			*p = *(p + 1);
			p++;
		}
		*p = '\0';

		dev_off = fdt_path_offset(blob, handle);
		/* skip this node if alias is not found */
		if (dev_off == -FDT_ERR_BADPATH)
			return 0;
		if (dev_off < 0)
			return dev_off;

		if (childoff <= 0)
			childoff = fdt_add_subnode(blob, off, name);

		/* need to update the dev_off after adding a subnode */
		dev_off = fdt_path_offset(blob, handle);
		if (dev_off < 0)
			return dev_off;

		if (childoff > 0) {
			dev_handle = fdt_get_phandle(blob, dev_off);
			if (dev_handle <= 0) {
				dev_handle = fdt_alloc_phandle(blob);
				ret = fdt_set_phandle(blob, dev_off,
						      dev_handle);
				if (ret < 0)
					return ret;
			}

			ret = fdt_setprop(blob, childoff, "dev-handle",
					  &dev_handle, sizeof(dev_handle));
			if (ret < 0)
				return ret;

#ifdef CONFIG_FSL_CORENET
			num = get_dpaa_liodn(dev, &liodns[0], id);
			ret = fdt_setprop(blob, childoff, "fsl,liodn",
					  &liodns[0], sizeof(u32) * num);
			if (!strncmp(name, "pme", 3)) {
				u32 pme_rev1, pme_rev2;
				ccsr_pme_t *pme_regs =
					(void *)CONFIG_SYS_FSL_CORENET_PME_ADDR;

				pme_rev1 = in_be32(&pme_regs->pm_ip_rev_1);
				pme_rev2 = in_be32(&pme_regs->pm_ip_rev_2);
				ret = fdt_setprop(blob, childoff,
						  "fsl,pme-rev1", &pme_rev1,
						  sizeof(u32));
				if (ret < 0)
					return ret;
				ret = fdt_setprop(blob, childoff,
						  "fsl,pme-rev2", &pme_rev2,
						  sizeof(u32));
			}
#endif
		} else {
			return childoff;
		}
	} else {
		if (childoff > 0)
			ret = fdt_del_node(blob, childoff);
	}

	return ret;
}
#endif /* CONFIG_PPC */

void fdt_fixup_qportals(void *blob)
{
	int off, err;
	unsigned int maj, min;
	unsigned int ip_cfg;
	struct ccsr_qman *qman = (void *)CONFIG_SYS_FSL_QMAN_ADDR;
	u32 rev_1 = in_be32(&qman->ip_rev_1);
	u32 rev_2 = in_be32(&qman->ip_rev_2);
	char compat[64];
	int compat_len;

	maj = (rev_1 >> 8) & 0xff;
	min = rev_1 & 0xff;
	ip_cfg = rev_2 & 0xff;

	compat_len = sprintf(compat, "fsl,qman-portal-%u.%u.%u",
			     maj, min, ip_cfg) + 1;
	compat_len += sprintf(compat + compat_len, "fsl,qman-portal") + 1;

	off = fdt_node_offset_by_compatible(blob, -1, "fsl,qman-portal");
	while (off != -FDT_ERR_NOTFOUND) {
#ifdef CONFIG_PPC
#ifdef CONFIG_FSL_CORENET
		u32 liodns[2];
#endif
		const int *ci = fdt_getprop(blob, off, "cell-index", &err);
		int i;

		if (!ci)
			goto err;

		i = *ci;
#ifdef CONFIG_SYS_DPAA_FMAN
		int j;
#endif

#endif /* CONFIG_PPC */
		err = fdt_setprop(blob, off, "compatible", compat, compat_len);
		if (err < 0)
			goto err;
#ifdef CONFIG_PPC
#ifdef CONFIG_FSL_CORENET
		liodns[0] = qp_info[i].dliodn;
		liodns[1] = qp_info[i].fliodn;
		err = fdt_setprop(blob, off, "fsl,liodn",
				  &liodns, sizeof(u32) * 2);
		if (err < 0)
			goto err;
#endif

		i++;

		err = fdt_qportal(blob, off, i, "crypto@0", FSL_HW_PORTAL_SEC,
				  IS_E_PROCESSOR(get_svr()));
		if (err < 0)
			goto err;

#ifdef CONFIG_FSL_CORENET
#ifdef CONFIG_SYS_DPAA_PME
		err = fdt_qportal(blob, off, i, "pme@0", FSL_HW_PORTAL_PME, 1);
		if (err < 0)
			goto err;
#else
		fdt_qportal(blob, off, i, "pme@0", FSL_HW_PORTAL_PME, 0);
#endif
#endif

#ifdef CONFIG_SYS_DPAA_FMAN
		for (j = 0; j < CONFIG_SYS_NUM_FMAN; j++) {
			char name[] = "fman@0";

			name[sizeof(name) - 2] = '0' + j;
			err = fdt_qportal(blob, off, i, name,
					  FSL_HW_PORTAL_FMAN1 + j, 1);
			if (err < 0)
				goto err;
		}
#endif
#ifdef CONFIG_SYS_DPAA_RMAN
		err = fdt_qportal(blob, off, i, "rman@0",
				  FSL_HW_PORTAL_RMAN, 1);
		if (err < 0)
			goto err;
#endif
#endif /* CONFIG_PPC */

err:
		if (err < 0) {
			printf("ERROR: unable to create props for %s: %s\n",
			       fdt_get_name(blob, off, NULL),
			       fdt_strerror(err));
			return;
		}

		off = fdt_node_offset_by_compatible(blob, off,
						    "fsl,qman-portal");
	}
}

void fdt_fixup_bportals(void *blob)
{
	int off, err;
	unsigned int maj, min;
	unsigned int ip_cfg;
	struct ccsr_bman *bman = (void *)CONFIG_SYS_FSL_BMAN_ADDR;
	u32 rev_1 = in_be32(&bman->ip_rev_1);
	u32 rev_2 = in_be32(&bman->ip_rev_2);
	char compat[64];
	int compat_len;

	maj = (rev_1 >> 8) & 0xff;
	min = rev_1 & 0xff;

	ip_cfg = rev_2 & 0xff;

	compat_len = sprintf(compat, "fsl,bman-portal-%u.%u.%u",
			     maj, min, ip_cfg) + 1;
	compat_len += sprintf(compat + compat_len, "fsl,bman-portal") + 1;

	off = fdt_node_offset_by_compatible(blob, -1, "fsl,bman-portal");
	while (off != -FDT_ERR_NOTFOUND) {
		err = fdt_setprop(blob, off, "compatible", compat, compat_len);
		if (err < 0) {
			printf("ERROR: unable to create props for %s: %s\n",
			       fdt_get_name(blob, off, NULL),
			       fdt_strerror(err));
			return;
		}

		off = fdt_node_offset_by_compatible(blob, off,
						    "fsl,bman-portal");
	}
}
Commit	Line	Data
44262327 AM	1	/*
	2	* Copyright 2008-2011 Freescale Semiconductor, Inc.
	3	* Copyright 2017 NXP
	4	*
	5	* SPDX-License-Identifier: GPL-2.0+
	6	*/
	7
	8	#include <common.h>
	9	#include <libfdt.h>
	10	#include <fdt_support.h>
	11
	12	#include <asm/processor.h>
	13	#include <asm/io.h>
	14	#ifdef CONFIG_PPC
	15	#include <asm/fsl_portals.h>
	16	#include <asm/fsl_liodn.h>
	17	#endif
	18	#include <fsl_qbman.h>
	19
	20	#define MAX_BPORTALS (CONFIG_SYS_BMAN_CINH_SIZE / CONFIG_SYS_BMAN_SP_CINH_SIZE)
	21	#define MAX_QPORTALS (CONFIG_SYS_QMAN_CINH_SIZE / CONFIG_SYS_QMAN_SP_CINH_SIZE)
	22	void setup_qbman_portals(void)
	23	{
	24	void __iomem bpaddr = (void )CONFIG_SYS_BMAN_CINH_BASE +
	25	CONFIG_SYS_BMAN_SWP_ISDR_REG;
	26	void __iomem qpaddr = (void )CONFIG_SYS_QMAN_CINH_BASE +
	27	CONFIG_SYS_QMAN_SWP_ISDR_REG;
	28	#ifdef CONFIG_PPC
	29	struct ccsr_qman qman = (void )CONFIG_SYS_FSL_QMAN_ADDR;
	30
	31	/* Set the Qman initiator BAR to match the LAW (for DQRR stashing) */
	32	#ifdef CONFIG_PHYS_64BIT
	33	out_be32(&qman->qcsp_bare, (u32)(CONFIG_SYS_QMAN_MEM_PHYS >> 32));
	34	#endif
	35	out_be32(&qman->qcsp_bar, (u32)CONFIG_SYS_QMAN_MEM_PHYS);
	36	#endif
	37	#ifdef CONFIG_FSL_CORENET
	38	int i;
	39
	40	for (i = 0; i < CONFIG_SYS_QMAN_NUM_PORTALS; i++) {
	41	u8 sdest = qp_info[i].sdest;
	42	u16 fliodn = qp_info[i].fliodn;
	43	u16 dliodn = qp_info[i].dliodn;
	44	u16 liodn_off = qp_info[i].liodn_offset;
	45
	46	out_be32(&qman->qcsp[i].qcsp_lio_cfg, (liodn_off << 16) \|
	47	dliodn);
	48	/* set frame liodn */
	49	out_be32(&qman->qcsp[i].qcsp_io_cfg, (sdest << 16) \| fliodn);
	50	}
	51	#endif
	52
	53	/* Change default state of BMan ISDR portals to all 1s */
	54	inhibit_portals(bpaddr, CONFIG_SYS_BMAN_NUM_PORTALS, MAX_BPORTALS,
	55	CONFIG_SYS_BMAN_SP_CINH_SIZE);
	56	inhibit_portals(qpaddr, CONFIG_SYS_QMAN_NUM_PORTALS, MAX_QPORTALS,
	57	CONFIG_SYS_QMAN_SP_CINH_SIZE);
	58	}
	59
	60	void inhibit_portals(void __iomem *addr, int max_portals,
	61	int arch_max_portals, int portal_cinh_size)
	62	{
	63	u32 val;
	64	int i;
65
66	/* arch_max_portals is the maximum based on memory size. This includes
67	* the reserved memory in the SoC. max_portals the number of physical
68	* portals in the SoC
69	*/
70	if (max_portals > arch_max_portals) {
71	printf("ERROR: portal config error\n");
72	max_portals = arch_max_portals;
73	}
74
75	for (i = 0; i < max_portals; i++) {
76	out_be32(addr, -1);
77	val = in_be32(addr);
78	if (!val) {
79	printf("ERROR: Stopped after %d portals\n", i);
80	return;
81	}
82	addr += portal_cinh_size;
83	}
84	debug("Cleared %d portals\n", i);
85	}
86
87	#ifdef CONFIG_PPC
88	static int fdt_qportal(void blob, int off, int id, char name,
89	enum fsl_dpaa_dev dev, int create)
90	{
91	int childoff, dev_off, ret = 0;
92	u32 dev_handle;
93	#ifdef CONFIG_FSL_CORENET
94	int num;
95	u32 liodns[2];
96	#endif
97
98	childoff = fdt_subnode_offset(blob, off, name);
99	if (create) {
100	char handle[64], *p;
101
102	strncpy(handle, name, sizeof(handle));
103	p = strchr(handle, '@');
104	if (!strncmp(name, "fman", 4)) {
105	p = (p + 1);
106	p++;
107	}
108	*p = '\0';
109
110	dev_off = fdt_path_offset(blob, handle);
111	/* skip this node if alias is not found */
112	if (dev_off == -FDT_ERR_BADPATH)
113	return 0;
114	if (dev_off < 0)
115	return dev_off;
116
117	if (childoff <= 0)
118	childoff = fdt_add_subnode(blob, off, name);
119
120	/* need to update the dev_off after adding a subnode */
121	dev_off = fdt_path_offset(blob, handle);
122	if (dev_off < 0)
123	return dev_off;
124
125	if (childoff > 0) {
126	dev_handle = fdt_get_phandle(blob, dev_off);
127	if (dev_handle <= 0) {
128	dev_handle = fdt_alloc_phandle(blob);
129	ret = fdt_set_phandle(blob, dev_off,
130	dev_handle);
131	if (ret < 0)
132	return ret;
133	}
134
135	ret = fdt_setprop(blob, childoff, "dev-handle",
136	&dev_handle, sizeof(dev_handle));
137	if (ret < 0)
138	return ret;
139
140	#ifdef CONFIG_FSL_CORENET
141	num = get_dpaa_liodn(dev, &liodns[0], id);
142	ret = fdt_setprop(blob, childoff, "fsl,liodn",
143	&liodns[0], sizeof(u32) * num);
144	if (!strncmp(name, "pme", 3)) {
145	u32 pme_rev1, pme_rev2;
146	ccsr_pme_t *pme_regs =
147	(void *)CONFIG_SYS_FSL_CORENET_PME_ADDR;
148
149	pme_rev1 = in_be32(&pme_regs->pm_ip_rev_1);
150	pme_rev2 = in_be32(&pme_regs->pm_ip_rev_2);
151	ret = fdt_setprop(blob, childoff,
152	"fsl,pme-rev1", &pme_rev1,
153	sizeof(u32));
154	if (ret < 0)
155	return ret;
156	ret = fdt_setprop(blob, childoff,
157	"fsl,pme-rev2", &pme_rev2,
158	sizeof(u32));
159	}
160	#endif
161	} else {
162	return childoff;
163	}
164	} else {
165	if (childoff > 0)
166	ret = fdt_del_node(blob, childoff);
167	}
168
169	return ret;
170	}
171	#endif /* CONFIG_PPC */
172
173	void fdt_fixup_qportals(void *blob)
174	{
175	int off, err;
176	unsigned int maj, min;
177	unsigned int ip_cfg;
178	struct ccsr_qman qman = (void )CONFIG_SYS_FSL_QMAN_ADDR;
179	u32 rev_1 = in_be32(&qman->ip_rev_1);
180	u32 rev_2 = in_be32(&qman->ip_rev_2);
181	char compat[64];
182	int compat_len;
183
184	maj = (rev_1 >> 8) & 0xff;
185	min = rev_1 & 0xff;
186	ip_cfg = rev_2 & 0xff;
187
188	compat_len = sprintf(compat, "fsl,qman-portal-%u.%u.%u",
189	maj, min, ip_cfg) + 1;
190	compat_len += sprintf(compat + compat_len, "fsl,qman-portal") + 1;
191
192	off = fdt_node_offset_by_compatible(blob, -1, "fsl,qman-portal");
193	while (off != -FDT_ERR_NOTFOUND) {
194	#ifdef CONFIG_PPC
195	#ifdef CONFIG_FSL_CORENET
196	u32 liodns[2];
197	#endif
198	const int *ci = fdt_getprop(blob, off, "cell-index", &err);
199	int i;
200
201	if (!ci)
202	goto err;
203
204	i = *ci;
205	#ifdef CONFIG_SYS_DPAA_FMAN
206	int j;
207	#endif
208
209	#endif /* CONFIG_PPC */
210	err = fdt_setprop(blob, off, "compatible", compat, compat_len);
211	if (err < 0)
212	goto err;
213	#ifdef CONFIG_PPC
214	#ifdef CONFIG_FSL_CORENET
215	liodns[0] = qp_info[i].dliodn;
216	liodns[1] = qp_info[i].fliodn;
217	err = fdt_setprop(blob, off, "fsl,liodn",
218	&liodns, sizeof(u32) * 2);
219	if (err < 0)
220	goto err;
221	#endif
222
223	i++;
224
225	err = fdt_qportal(blob, off, i, "crypto@0", FSL_HW_PORTAL_SEC,
226	IS_E_PROCESSOR(get_svr()));
227	if (err < 0)
228	goto err;
229
230	#ifdef CONFIG_FSL_CORENET
231	#ifdef CONFIG_SYS_DPAA_PME
232	err = fdt_qportal(blob, off, i, "pme@0", FSL_HW_PORTAL_PME, 1);
233	if (err < 0)
234	goto err;
235	#else
236	fdt_qportal(blob, off, i, "pme@0", FSL_HW_PORTAL_PME, 0);
237	#endif
238	#endif
239
240	#ifdef CONFIG_SYS_DPAA_FMAN
241	for (j = 0; j < CONFIG_SYS_NUM_FMAN; j++) {
242	char name[] = "fman@0";
243
244	name[sizeof(name) - 2] = '0' + j;
245	err = fdt_qportal(blob, off, i, name,
246	FSL_HW_PORTAL_FMAN1 + j, 1);
247	if (err < 0)
248	goto err;
249	}
250	#endif
251	#ifdef CONFIG_SYS_DPAA_RMAN
252	err = fdt_qportal(blob, off, i, "rman@0",
253	FSL_HW_PORTAL_RMAN, 1);
254	if (err < 0)
255	goto err;
256	#endif
257	#endif /* CONFIG_PPC */
258
259	err:
260	if (err < 0) {
261	printf("ERROR: unable to create props for %s: %s\n",
262	fdt_get_name(blob, off, NULL),
263	fdt_strerror(err));
264	return;
265	}
266
267	off = fdt_node_offset_by_compatible(blob, off,
268	"fsl,qman-portal");
269	}
270	}
271
272	void fdt_fixup_bportals(void *blob)
273	{
274	int off, err;
275	unsigned int maj, min;
276	unsigned int ip_cfg;
277	struct ccsr_bman bman = (void )CONFIG_SYS_FSL_BMAN_ADDR;
278	u32 rev_1 = in_be32(&bman->ip_rev_1);
279	u32 rev_2 = in_be32(&bman->ip_rev_2);
280	char compat[64];
281	int compat_len;
282
283	maj = (rev_1 >> 8) & 0xff;
284	min = rev_1 & 0xff;
285
286	ip_cfg = rev_2 & 0xff;
287
288	compat_len = sprintf(compat, "fsl,bman-portal-%u.%u.%u",
289	maj, min, ip_cfg) + 1;
290	compat_len += sprintf(compat + compat_len, "fsl,bman-portal") + 1;
291
292	off = fdt_node_offset_by_compatible(blob, -1, "fsl,bman-portal");
293	while (off != -FDT_ERR_NOTFOUND) {
294	err = fdt_setprop(blob, off, "compatible", compat, compat_len);
295	if (err < 0) {
296	printf("ERROR: unable to create props for %s: %s\n",
297	fdt_get_name(blob, off, NULL),
298	fdt_strerror(err));
299	return;
300	}
301
302	off = fdt_node_offset_by_compatible(blob, off,
303	"fsl,bman-portal");
304	}
305	}