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 28 static __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 36 static __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 61 static __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 128 static __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 217 static __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 296 static __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 337 static __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 369 extern char __dtb_sead3_begin[]; 370 371 MIPS_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 }; 377