Loading...
1/*
2 * Copyright (C) 2016 Imagination Technologies
3 * Author: Paul Burton <paul.burton@imgtec.com>
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; either version 2 of the License, or (at your
8 * option) any later version.
9 */
10
11#define pr_fmt(fmt) "sead3: " fmt
12
13#include <linux/errno.h>
14#include <linux/libfdt.h>
15#include <linux/printk.h>
16
17#include <asm/fw/fw.h>
18#include <asm/io.h>
19#include <asm/machine.h>
20
21#define SEAD_CONFIG CKSEG1ADDR(0x1b100110)
22#define SEAD_CONFIG_GIC_PRESENT BIT(1)
23
24#define MIPS_REVISION CKSEG1ADDR(0x1fc00010)
25#define MIPS_REVISION_MACHINE (0xf << 4)
26#define MIPS_REVISION_MACHINE_SEAD3 (0x4 << 4)
27
28static __init bool sead3_detect(void)
29{
30 uint32_t rev;
31
32 rev = __raw_readl((void *)MIPS_REVISION);
33 return (rev & MIPS_REVISION_MACHINE) == MIPS_REVISION_MACHINE_SEAD3;
34}
35
36static __init int append_cmdline(void *fdt)
37{
38 int err, chosen_off;
39
40 /* find or add chosen node */
41 chosen_off = fdt_path_offset(fdt, "/chosen");
42 if (chosen_off == -FDT_ERR_NOTFOUND)
43 chosen_off = fdt_path_offset(fdt, "/chosen@0");
44 if (chosen_off == -FDT_ERR_NOTFOUND)
45 chosen_off = fdt_add_subnode(fdt, 0, "chosen");
46 if (chosen_off < 0) {
47 pr_err("Unable to find or add DT chosen node: %d\n",
48 chosen_off);
49 return chosen_off;
50 }
51
52 err = fdt_setprop_string(fdt, chosen_off, "bootargs", fw_getcmdline());
53 if (err) {
54 pr_err("Unable to set bootargs property: %d\n", err);
55 return err;
56 }
57
58 return 0;
59}
60
61static __init int append_memory(void *fdt)
62{
63 unsigned long phys_memsize, memsize;
64 __be32 mem_array[2];
65 int err, mem_off;
66 char *var;
67
68 /* find memory size from the bootloader environment */
69 var = fw_getenv("memsize");
70 if (var) {
71 err = kstrtoul(var, 0, &phys_memsize);
72 if (err) {
73 pr_err("Failed to read memsize env variable '%s'\n",
74 var);
75 return -EINVAL;
76 }
77 } else {
78 pr_warn("The bootloader didn't provide memsize: defaulting to 32MB\n");
79 phys_memsize = 32 << 20;
80 }
81
82 /* default to using all available RAM */
83 memsize = phys_memsize;
84
85 /* allow the user to override the usable memory */
86 var = strstr(arcs_cmdline, "memsize=");
87 if (var)
88 memsize = memparse(var + strlen("memsize="), NULL);
89
90 /* if the user says there's more RAM than we thought, believe them */
91 phys_memsize = max_t(unsigned long, phys_memsize, memsize);
92
93 /* find or add a memory node */
94 mem_off = fdt_path_offset(fdt, "/memory");
95 if (mem_off == -FDT_ERR_NOTFOUND)
96 mem_off = fdt_add_subnode(fdt, 0, "memory");
97 if (mem_off < 0) {
98 pr_err("Unable to find or add memory DT node: %d\n", mem_off);
99 return mem_off;
100 }
101
102 err = fdt_setprop_string(fdt, mem_off, "device_type", "memory");
103 if (err) {
104 pr_err("Unable to set memory node device_type: %d\n", err);
105 return err;
106 }
107
108 mem_array[0] = 0;
109 mem_array[1] = cpu_to_be32(phys_memsize);
110 err = fdt_setprop(fdt, mem_off, "reg", mem_array, sizeof(mem_array));
111 if (err) {
112 pr_err("Unable to set memory regs property: %d\n", err);
113 return err;
114 }
115
116 mem_array[0] = 0;
117 mem_array[1] = cpu_to_be32(memsize);
118 err = fdt_setprop(fdt, mem_off, "linux,usable-memory",
119 mem_array, sizeof(mem_array));
120 if (err) {
121 pr_err("Unable to set linux,usable-memory property: %d\n", err);
122 return err;
123 }
124
125 return 0;
126}
127
128static __init int remove_gic(void *fdt)
129{
130 const unsigned int cpu_ehci_int = 2;
131 const unsigned int cpu_uart_int = 4;
132 const unsigned int cpu_eth_int = 6;
133 int gic_off, cpu_off, uart_off, eth_off, ehci_off, err;
134 uint32_t cfg, cpu_phandle;
135
136 /* leave the GIC node intact if a GIC is present */
137 cfg = __raw_readl((uint32_t *)SEAD_CONFIG);
138 if (cfg & SEAD_CONFIG_GIC_PRESENT)
139 return 0;
140
141 gic_off = fdt_node_offset_by_compatible(fdt, -1, "mti,gic");
142 if (gic_off < 0) {
143 pr_err("unable to find DT GIC node: %d\n", gic_off);
144 return gic_off;
145 }
146
147 err = fdt_nop_node(fdt, gic_off);
148 if (err) {
149 pr_err("unable to nop GIC node\n");
150 return err;
151 }
152
153 cpu_off = fdt_node_offset_by_compatible(fdt, -1,
154 "mti,cpu-interrupt-controller");
155 if (cpu_off < 0) {
156 pr_err("unable to find CPU intc node: %d\n", cpu_off);
157 return cpu_off;
158 }
159
160 cpu_phandle = fdt_get_phandle(fdt, cpu_off);
161 if (!cpu_phandle) {
162 pr_err("unable to get CPU intc phandle\n");
163 return -EINVAL;
164 }
165
166 err = fdt_setprop_u32(fdt, 0, "interrupt-parent", cpu_phandle);
167 if (err) {
168 pr_err("unable to set root interrupt-parent: %d\n", err);
169 return err;
170 }
171
172 uart_off = fdt_node_offset_by_compatible(fdt, -1, "ns16550a");
173 while (uart_off >= 0) {
174 err = fdt_setprop_u32(fdt, uart_off, "interrupts",
175 cpu_uart_int);
176 if (err) {
177 pr_err("unable to set UART interrupts property: %d\n",
178 err);
179 return err;
180 }
181
182 uart_off = fdt_node_offset_by_compatible(fdt, uart_off,
183 "ns16550a");
184 }
185 if (uart_off != -FDT_ERR_NOTFOUND) {
186 pr_err("error searching for UART DT node: %d\n", uart_off);
187 return uart_off;
188 }
189
190 eth_off = fdt_node_offset_by_compatible(fdt, -1, "smsc,lan9115");
191 if (eth_off < 0) {
192 pr_err("unable to find ethernet DT node: %d\n", eth_off);
193 return eth_off;
194 }
195
196 err = fdt_setprop_u32(fdt, eth_off, "interrupts", cpu_eth_int);
197 if (err) {
198 pr_err("unable to set ethernet interrupts property: %d\n", err);
199 return err;
200 }
201
202 ehci_off = fdt_node_offset_by_compatible(fdt, -1, "generic-ehci");
203 if (ehci_off < 0) {
204 pr_err("unable to find EHCI DT node: %d\n", ehci_off);
205 return ehci_off;
206 }
207
208 err = fdt_setprop_u32(fdt, ehci_off, "interrupts", cpu_ehci_int);
209 if (err) {
210 pr_err("unable to set EHCI interrupts property: %d\n", err);
211 return err;
212 }
213
214 return 0;
215}
216
217static __init int serial_config(void *fdt)
218{
219 const char *yamontty, *mode_var;
220 char mode_var_name[9], path[18], parity;
221 unsigned int uart, baud, stop_bits;
222 bool hw_flow;
223 int chosen_off, err;
224
225 yamontty = fw_getenv("yamontty");
226 if (!yamontty || !strcmp(yamontty, "tty0")) {
227 uart = 0;
228 } else if (!strcmp(yamontty, "tty1")) {
229 uart = 1;
230 } else {
231 pr_warn("yamontty environment variable '%s' invalid\n",
232 yamontty);
233 uart = 0;
234 }
235
236 baud = stop_bits = 0;
237 parity = 0;
238 hw_flow = false;
239
240 snprintf(mode_var_name, sizeof(mode_var_name), "modetty%u", uart);
241 mode_var = fw_getenv(mode_var_name);
242 if (mode_var) {
243 while (mode_var[0] >= '0' && mode_var[0] <= '9') {
244 baud *= 10;
245 baud += mode_var[0] - '0';
246 mode_var++;
247 }
248 if (mode_var[0] == ',')
249 mode_var++;
250 if (mode_var[0])
251 parity = mode_var[0];
252 if (mode_var[0] == ',')
253 mode_var++;
254 if (mode_var[0])
255 stop_bits = mode_var[0] - '0';
256 if (mode_var[0] == ',')
257 mode_var++;
258 if (!strcmp(mode_var, "hw"))
259 hw_flow = true;
260 }
261
262 if (!baud)
263 baud = 38400;
264
265 if (parity != 'e' && parity != 'n' && parity != 'o')
266 parity = 'n';
267
268 if (stop_bits != 7 && stop_bits != 8)
269 stop_bits = 8;
270
271 WARN_ON(snprintf(path, sizeof(path), "uart%u:%u%c%u%s",
272 uart, baud, parity, stop_bits,
273 hw_flow ? "r" : "") >= sizeof(path));
274
275 /* find or add chosen node */
276 chosen_off = fdt_path_offset(fdt, "/chosen");
277 if (chosen_off == -FDT_ERR_NOTFOUND)
278 chosen_off = fdt_path_offset(fdt, "/chosen@0");
279 if (chosen_off == -FDT_ERR_NOTFOUND)
280 chosen_off = fdt_add_subnode(fdt, 0, "chosen");
281 if (chosen_off < 0) {
282 pr_err("Unable to find or add DT chosen node: %d\n",
283 chosen_off);
284 return chosen_off;
285 }
286
287 err = fdt_setprop_string(fdt, chosen_off, "stdout-path", path);
288 if (err) {
289 pr_err("Unable to set stdout-path property: %d\n", err);
290 return err;
291 }
292
293 return 0;
294}
295
296static __init const void *sead3_fixup_fdt(const void *fdt,
297 const void *match_data)
298{
299 static unsigned char fdt_buf[16 << 10] __initdata;
300 int err;
301
302 if (fdt_check_header(fdt))
303 panic("Corrupt DT");
304
305 /* if this isn't SEAD3, something went wrong */
306 BUG_ON(fdt_node_check_compatible(fdt, 0, "mti,sead-3"));
307
308 fw_init_cmdline();
309
310 err = fdt_open_into(fdt, fdt_buf, sizeof(fdt_buf));
311 if (err)
312 panic("Unable to open FDT: %d", err);
313
314 err = append_cmdline(fdt_buf);
315 if (err)
316 panic("Unable to patch FDT: %d", err);
317
318 err = append_memory(fdt_buf);
319 if (err)
320 panic("Unable to patch FDT: %d", err);
321
322 err = remove_gic(fdt_buf);
323 if (err)
324 panic("Unable to patch FDT: %d", err);
325
326 err = serial_config(fdt_buf);
327 if (err)
328 panic("Unable to patch FDT: %d", err);
329
330 err = fdt_pack(fdt_buf);
331 if (err)
332 panic("Unable to pack FDT: %d\n", err);
333
334 return fdt_buf;
335}
336
337static __init unsigned int sead3_measure_hpt_freq(void)
338{
339 void __iomem *status_reg = (void __iomem *)0xbf000410;
340 unsigned int freq, orig, tick = 0;
341 unsigned long flags;
342
343 local_irq_save(flags);
344
345 orig = readl(status_reg) & 0x2; /* get original sample */
346 /* wait for transition */
347 while ((readl(status_reg) & 0x2) == orig)
348 ;
349 orig = orig ^ 0x2; /* flip the bit */
350
351 write_c0_count(0);
352
353 /* wait 1 second (the sampling clock transitions every 10ms) */
354 while (tick < 100) {
355 /* wait for transition */
356 while ((readl(status_reg) & 0x2) == orig)
357 ;
358 orig = orig ^ 0x2; /* flip the bit */
359 tick++;
360 }
361
362 freq = read_c0_count();
363
364 local_irq_restore(flags);
365
366 return freq;
367}
368
369extern char __dtb_sead3_begin[];
370
371MIPS_MACHINE(sead3) = {
372 .fdt = __dtb_sead3_begin,
373 .detect = sead3_detect,
374 .fixup_fdt = sead3_fixup_fdt,
375 .measure_hpt_freq = sead3_measure_hpt_freq,
376};
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright (C) 2016 Imagination Technologies
4 * Author: Paul Burton <paul.burton@mips.com>
5 */
6
7#define pr_fmt(fmt) "sead3: " fmt
8
9#include <linux/errno.h>
10#include <linux/libfdt.h>
11#include <linux/printk.h>
12#include <linux/sizes.h>
13
14#include <asm/fw/fw.h>
15#include <asm/io.h>
16#include <asm/machine.h>
17#include <asm/yamon-dt.h>
18
19#define SEAD_CONFIG CKSEG1ADDR(0x1b100110)
20#define SEAD_CONFIG_GIC_PRESENT BIT(1)
21
22#define MIPS_REVISION CKSEG1ADDR(0x1fc00010)
23#define MIPS_REVISION_MACHINE (0xf << 4)
24#define MIPS_REVISION_MACHINE_SEAD3 (0x4 << 4)
25
26/*
27 * Maximum 384MB RAM at physical address 0, preceding any I/O.
28 */
29static struct yamon_mem_region mem_regions[] __initdata = {
30 /* start size */
31 { 0, SZ_256M + SZ_128M },
32 {}
33};
34
35static __init bool sead3_detect(void)
36{
37 uint32_t rev;
38
39 rev = __raw_readl((void *)MIPS_REVISION);
40 return (rev & MIPS_REVISION_MACHINE) == MIPS_REVISION_MACHINE_SEAD3;
41}
42
43static __init int append_memory(void *fdt)
44{
45 return yamon_dt_append_memory(fdt, mem_regions);
46}
47
48static __init int remove_gic(void *fdt)
49{
50 const unsigned int cpu_ehci_int = 2;
51 const unsigned int cpu_uart_int = 4;
52 const unsigned int cpu_eth_int = 6;
53 int gic_off, cpu_off, uart_off, eth_off, ehci_off, err;
54 uint32_t cfg, cpu_phandle;
55
56 /* leave the GIC node intact if a GIC is present */
57 cfg = __raw_readl((uint32_t *)SEAD_CONFIG);
58 if (cfg & SEAD_CONFIG_GIC_PRESENT)
59 return 0;
60
61 gic_off = fdt_node_offset_by_compatible(fdt, -1, "mti,gic");
62 if (gic_off < 0) {
63 pr_err("unable to find DT GIC node: %d\n", gic_off);
64 return gic_off;
65 }
66
67 err = fdt_nop_node(fdt, gic_off);
68 if (err) {
69 pr_err("unable to nop GIC node\n");
70 return err;
71 }
72
73 cpu_off = fdt_node_offset_by_compatible(fdt, -1,
74 "mti,cpu-interrupt-controller");
75 if (cpu_off < 0) {
76 pr_err("unable to find CPU intc node: %d\n", cpu_off);
77 return cpu_off;
78 }
79
80 cpu_phandle = fdt_get_phandle(fdt, cpu_off);
81 if (!cpu_phandle) {
82 pr_err("unable to get CPU intc phandle\n");
83 return -EINVAL;
84 }
85
86 uart_off = fdt_node_offset_by_compatible(fdt, -1, "ns16550a");
87 while (uart_off >= 0) {
88 err = fdt_setprop_u32(fdt, uart_off, "interrupt-parent",
89 cpu_phandle);
90 if (err) {
91 pr_warn("unable to set UART interrupt-parent: %d\n",
92 err);
93 return err;
94 }
95
96 err = fdt_setprop_u32(fdt, uart_off, "interrupts",
97 cpu_uart_int);
98 if (err) {
99 pr_err("unable to set UART interrupts property: %d\n",
100 err);
101 return err;
102 }
103
104 uart_off = fdt_node_offset_by_compatible(fdt, uart_off,
105 "ns16550a");
106 }
107 if (uart_off != -FDT_ERR_NOTFOUND) {
108 pr_err("error searching for UART DT node: %d\n", uart_off);
109 return uart_off;
110 }
111
112 eth_off = fdt_node_offset_by_compatible(fdt, -1, "smsc,lan9115");
113 if (eth_off < 0) {
114 pr_err("unable to find ethernet DT node: %d\n", eth_off);
115 return eth_off;
116 }
117
118 err = fdt_setprop_u32(fdt, eth_off, "interrupt-parent", cpu_phandle);
119 if (err) {
120 pr_err("unable to set ethernet interrupt-parent: %d\n", err);
121 return err;
122 }
123
124 err = fdt_setprop_u32(fdt, eth_off, "interrupts", cpu_eth_int);
125 if (err) {
126 pr_err("unable to set ethernet interrupts property: %d\n", err);
127 return err;
128 }
129
130 ehci_off = fdt_node_offset_by_compatible(fdt, -1, "generic-ehci");
131 if (ehci_off < 0) {
132 pr_err("unable to find EHCI DT node: %d\n", ehci_off);
133 return ehci_off;
134 }
135
136 err = fdt_setprop_u32(fdt, ehci_off, "interrupt-parent", cpu_phandle);
137 if (err) {
138 pr_err("unable to set EHCI interrupt-parent: %d\n", err);
139 return err;
140 }
141
142 err = fdt_setprop_u32(fdt, ehci_off, "interrupts", cpu_ehci_int);
143 if (err) {
144 pr_err("unable to set EHCI interrupts property: %d\n", err);
145 return err;
146 }
147
148 return 0;
149}
150
151static const struct mips_fdt_fixup sead3_fdt_fixups[] __initconst = {
152 { yamon_dt_append_cmdline, "append command line" },
153 { append_memory, "append memory" },
154 { remove_gic, "remove GIC when not present" },
155 { yamon_dt_serial_config, "append serial configuration" },
156 { },
157};
158
159static __init const void *sead3_fixup_fdt(const void *fdt,
160 const void *match_data)
161{
162 static unsigned char fdt_buf[16 << 10] __initdata;
163 int err;
164
165 if (fdt_check_header(fdt))
166 panic("Corrupt DT");
167
168 /* if this isn't SEAD3, something went wrong */
169 BUG_ON(fdt_node_check_compatible(fdt, 0, "mti,sead-3"));
170
171 fw_init_cmdline();
172
173 err = apply_mips_fdt_fixups(fdt_buf, sizeof(fdt_buf),
174 fdt, sead3_fdt_fixups);
175 if (err)
176 panic("Unable to fixup FDT: %d", err);
177
178 return fdt_buf;
179}
180
181static __init unsigned int sead3_measure_hpt_freq(void)
182{
183 void __iomem *status_reg = (void __iomem *)0xbf000410;
184 unsigned int freq, orig, tick = 0;
185 unsigned long flags;
186
187 local_irq_save(flags);
188
189 orig = readl(status_reg) & 0x2; /* get original sample */
190 /* wait for transition */
191 while ((readl(status_reg) & 0x2) == orig)
192 ;
193 orig = orig ^ 0x2; /* flip the bit */
194
195 write_c0_count(0);
196
197 /* wait 1 second (the sampling clock transitions every 10ms) */
198 while (tick < 100) {
199 /* wait for transition */
200 while ((readl(status_reg) & 0x2) == orig)
201 ;
202 orig = orig ^ 0x2; /* flip the bit */
203 tick++;
204 }
205
206 freq = read_c0_count();
207
208 local_irq_restore(flags);
209
210 return freq;
211}
212
213extern char __dtb_sead3_begin[];
214
215MIPS_MACHINE(sead3) = {
216 .fdt = __dtb_sead3_begin,
217 .detect = sead3_detect,
218 .fixup_fdt = sead3_fixup_fdt,
219 .measure_hpt_freq = sead3_measure_hpt_freq,
220};