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