1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * linux/arch/m68k/kernel/setup.c 4 * 5 * Copyright (C) 1995 Hamish Macdonald 6 */ 7 8 /* 9 * This file handles the architecture-dependent parts of system setup 10 */ 11 12 #include <linux/kernel.h> 13 #include <linux/cpu.h> 14 #include <linux/mm.h> 15 #include <linux/sched.h> 16 #include <linux/delay.h> 17 #include <linux/interrupt.h> 18 #include <linux/fs.h> 19 #include <linux/console.h> 20 #include <linux/errno.h> 21 #include <linux/string.h> 22 #include <linux/init.h> 23 #include <linux/memblock.h> 24 #include <linux/proc_fs.h> 25 #include <linux/seq_file.h> 26 #include <linux/module.h> 27 #include <linux/nvram.h> 28 #include <linux/initrd.h> 29 #include <linux/random.h> 30 31 #include <asm/bootinfo.h> 32 #include <asm/byteorder.h> 33 #include <asm/sections.h> 34 #include <asm/setup.h> 35 #include <asm/fpu.h> 36 #include <asm/irq.h> 37 #include <asm/io.h> 38 #include <asm/machdep.h> 39 #ifdef CONFIG_AMIGA 40 #include <asm/amigahw.h> 41 #endif 42 #include <asm/atarihw.h> 43 #ifdef CONFIG_ATARI 44 #include <asm/atari_stram.h> 45 #endif 46 #ifdef CONFIG_SUN3X 47 #include <asm/dvma.h> 48 #endif 49 #include <asm/macintosh.h> 50 #include <asm/natfeat.h> 51 #include <asm/config.h> 52 53 #if !FPSTATESIZE || !NR_IRQS 54 #warning No CPU/platform type selected, your kernel will not work! 55 #warning Are you building an allnoconfig kernel? 56 #endif 57 58 unsigned long m68k_machtype; 59 EXPORT_SYMBOL(m68k_machtype); 60 unsigned long m68k_cputype; 61 EXPORT_SYMBOL(m68k_cputype); 62 unsigned long m68k_fputype; 63 unsigned long m68k_mmutype; 64 EXPORT_SYMBOL(m68k_mmutype); 65 #ifdef CONFIG_VME 66 unsigned long vme_brdtype; 67 EXPORT_SYMBOL(vme_brdtype); 68 #endif 69 70 int m68k_is040or060; 71 EXPORT_SYMBOL(m68k_is040or060); 72 73 extern unsigned long availmem; 74 75 int m68k_num_memory; 76 EXPORT_SYMBOL(m68k_num_memory); 77 int m68k_realnum_memory; 78 EXPORT_SYMBOL(m68k_realnum_memory); 79 unsigned long m68k_memoffset; 80 struct m68k_mem_info m68k_memory[NUM_MEMINFO]; 81 EXPORT_SYMBOL(m68k_memory); 82 83 static struct m68k_mem_info m68k_ramdisk __initdata; 84 85 static char m68k_command_line[CL_SIZE] __initdata; 86 87 void (*mach_sched_init) (void) __initdata = NULL; 88 /* machine dependent irq functions */ 89 void (*mach_init_IRQ) (void) __initdata = NULL; 90 void (*mach_get_model) (char *model); 91 void (*mach_get_hardware_list) (struct seq_file *m); 92 void (*mach_reset)( void ); 93 void (*mach_halt)( void ); 94 #ifdef CONFIG_HEARTBEAT 95 void (*mach_heartbeat) (int); 96 EXPORT_SYMBOL(mach_heartbeat); 97 #endif 98 #ifdef CONFIG_M68K_L2_CACHE 99 void (*mach_l2_flush) (int); 100 #endif 101 #if defined(CONFIG_ISA) && defined(MULTI_ISA) 102 int isa_type; 103 int isa_sex; 104 EXPORT_SYMBOL(isa_type); 105 EXPORT_SYMBOL(isa_sex); 106 #endif 107 108 #define MASK_256K 0xfffc0000 109 110 static void __init m68k_parse_bootinfo(const struct bi_record *record) 111 { 112 const struct bi_record *first_record = record; 113 uint16_t tag; 114 115 while ((tag = be16_to_cpu(record->tag)) != BI_LAST) { 116 int unknown = 0; 117 const void *data = record->data; 118 uint16_t size = be16_to_cpu(record->size); 119 120 switch (tag) { 121 case BI_MACHTYPE: 122 case BI_CPUTYPE: 123 case BI_FPUTYPE: 124 case BI_MMUTYPE: 125 /* Already set up by head.S */ 126 break; 127 128 case BI_MEMCHUNK: 129 if (m68k_num_memory < NUM_MEMINFO) { 130 const struct mem_info *m = data; 131 m68k_memory[m68k_num_memory].addr = 132 be32_to_cpu(m->addr); 133 m68k_memory[m68k_num_memory].size = 134 be32_to_cpu(m->size); 135 m68k_num_memory++; 136 } else 137 pr_warn("%s: too many memory chunks\n", 138 __func__); 139 break; 140 141 case BI_RAMDISK: 142 { 143 const struct mem_info *m = data; 144 m68k_ramdisk.addr = be32_to_cpu(m->addr); 145 m68k_ramdisk.size = be32_to_cpu(m->size); 146 } 147 break; 148 149 case BI_COMMAND_LINE: 150 strscpy(m68k_command_line, data, 151 sizeof(m68k_command_line)); 152 break; 153 154 case BI_RNG_SEED: { 155 u16 len = be16_to_cpup(data); 156 add_bootloader_randomness(data + 2, len); 157 /* 158 * Zero the data to preserve forward secrecy, and zero the 159 * length to prevent kexec from using it. 160 */ 161 memzero_explicit((void *)data, len + 2); 162 break; 163 } 164 165 default: 166 if (MACH_IS_AMIGA) 167 unknown = amiga_parse_bootinfo(record); 168 else if (MACH_IS_ATARI) 169 unknown = atari_parse_bootinfo(record); 170 else if (MACH_IS_MAC) 171 unknown = mac_parse_bootinfo(record); 172 else if (MACH_IS_Q40) 173 unknown = q40_parse_bootinfo(record); 174 else if (MACH_IS_BVME6000) 175 unknown = bvme6000_parse_bootinfo(record); 176 else if (MACH_IS_MVME16x) 177 unknown = mvme16x_parse_bootinfo(record); 178 else if (MACH_IS_MVME147) 179 unknown = mvme147_parse_bootinfo(record); 180 else if (MACH_IS_HP300) 181 unknown = hp300_parse_bootinfo(record); 182 else if (MACH_IS_APOLLO) 183 unknown = apollo_parse_bootinfo(record); 184 else if (MACH_IS_VIRT) 185 unknown = virt_parse_bootinfo(record); 186 else 187 unknown = 1; 188 } 189 if (unknown) 190 pr_warn("%s: unknown tag 0x%04x ignored\n", __func__, 191 tag); 192 record = (struct bi_record *)((unsigned long)record + size); 193 } 194 195 save_bootinfo(first_record); 196 197 m68k_realnum_memory = m68k_num_memory; 198 #ifdef CONFIG_SINGLE_MEMORY_CHUNK 199 if (m68k_num_memory > 1) { 200 pr_warn("%s: ignoring last %i chunks of physical memory\n", 201 __func__, (m68k_num_memory - 1)); 202 m68k_num_memory = 1; 203 } 204 #endif 205 } 206 207 void __init setup_arch(char **cmdline_p) 208 { 209 /* The bootinfo is located right after the kernel */ 210 if (!CPU_IS_COLDFIRE) 211 m68k_parse_bootinfo((const struct bi_record *)_end); 212 213 if (CPU_IS_040) 214 m68k_is040or060 = 4; 215 else if (CPU_IS_060) 216 m68k_is040or060 = 6; 217 218 /* FIXME: m68k_fputype is passed in by Penguin booter, which can 219 * be confused by software FPU emulation. BEWARE. 220 * We should really do our own FPU check at startup. 221 * [what do we do with buggy 68LC040s? if we have problems 222 * with them, we should add a test to check_bugs() below] */ 223 #if defined(CONFIG_FPU) && !defined(CONFIG_M68KFPU_EMU_ONLY) 224 /* clear the fpu if we have one */ 225 if (m68k_fputype & (FPU_68881|FPU_68882|FPU_68040|FPU_68060|FPU_COLDFIRE)) { 226 volatile int zero = 0; 227 asm volatile ("frestore %0" : : "m" (zero)); 228 } 229 #endif 230 231 if (CPU_IS_060) { 232 u32 pcr; 233 234 asm (".chip 68060; movec %%pcr,%0; .chip 68k" 235 : "=d" (pcr)); 236 if (((pcr >> 8) & 0xff) <= 5) { 237 pr_warn("Enabling workaround for errata I14\n"); 238 asm (".chip 68060; movec %0,%%pcr; .chip 68k" 239 : : "d" (pcr | 0x20)); 240 } 241 } 242 243 setup_initial_init_mm((void *)PAGE_OFFSET, _etext, _edata, _end); 244 245 #if defined(CONFIG_BOOTPARAM) 246 strncpy(m68k_command_line, CONFIG_BOOTPARAM_STRING, CL_SIZE); 247 m68k_command_line[CL_SIZE - 1] = 0; 248 #endif /* CONFIG_BOOTPARAM */ 249 process_uboot_commandline(&m68k_command_line[0], CL_SIZE); 250 *cmdline_p = m68k_command_line; 251 memcpy(boot_command_line, *cmdline_p, CL_SIZE); 252 /* 253 * Initialise the static keys early as they may be enabled by the 254 * cpufeature code and early parameters. 255 */ 256 jump_label_init(); 257 parse_early_param(); 258 259 switch (m68k_machtype) { 260 #ifdef CONFIG_AMIGA 261 case MACH_AMIGA: 262 config_amiga(); 263 break; 264 #endif 265 #ifdef CONFIG_ATARI 266 case MACH_ATARI: 267 config_atari(); 268 break; 269 #endif 270 #ifdef CONFIG_MAC 271 case MACH_MAC: 272 config_mac(); 273 break; 274 #endif 275 #ifdef CONFIG_SUN3 276 case MACH_SUN3: 277 config_sun3(); 278 break; 279 #endif 280 #ifdef CONFIG_APOLLO 281 case MACH_APOLLO: 282 config_apollo(); 283 break; 284 #endif 285 #ifdef CONFIG_MVME147 286 case MACH_MVME147: 287 config_mvme147(); 288 break; 289 #endif 290 #ifdef CONFIG_MVME16x 291 case MACH_MVME16x: 292 config_mvme16x(); 293 break; 294 #endif 295 #ifdef CONFIG_BVME6000 296 case MACH_BVME6000: 297 config_bvme6000(); 298 break; 299 #endif 300 #ifdef CONFIG_HP300 301 case MACH_HP300: 302 config_hp300(); 303 break; 304 #endif 305 #ifdef CONFIG_Q40 306 case MACH_Q40: 307 config_q40(); 308 break; 309 #endif 310 #ifdef CONFIG_SUN3X 311 case MACH_SUN3X: 312 config_sun3x(); 313 break; 314 #endif 315 #ifdef CONFIG_COLDFIRE 316 case MACH_M54XX: 317 case MACH_M5441X: 318 cf_bootmem_alloc(); 319 cf_mmu_context_init(); 320 config_BSP(NULL, 0); 321 break; 322 #endif 323 #ifdef CONFIG_VIRT 324 case MACH_VIRT: 325 config_virt(); 326 break; 327 #endif 328 default: 329 panic("No configuration setup"); 330 } 331 332 if (IS_ENABLED(CONFIG_BLK_DEV_INITRD) && m68k_ramdisk.size) 333 memblock_reserve(m68k_ramdisk.addr, m68k_ramdisk.size); 334 335 paging_init(); 336 337 if (IS_ENABLED(CONFIG_BLK_DEV_INITRD) && m68k_ramdisk.size) { 338 initrd_start = (unsigned long)phys_to_virt(m68k_ramdisk.addr); 339 initrd_end = initrd_start + m68k_ramdisk.size; 340 pr_info("initrd: %08lx - %08lx\n", initrd_start, initrd_end); 341 } 342 343 #ifdef CONFIG_NATFEAT 344 nf_init(); 345 #endif 346 347 #ifdef CONFIG_ATARI 348 if (MACH_IS_ATARI) 349 atari_stram_reserve_pages((void *)availmem); 350 #endif 351 #ifdef CONFIG_SUN3X 352 if (MACH_IS_SUN3X) { 353 dvma_init(); 354 } 355 #endif 356 357 /* set ISA defs early as possible */ 358 #if defined(CONFIG_ISA) && defined(MULTI_ISA) 359 if (MACH_IS_Q40) { 360 isa_type = ISA_TYPE_Q40; 361 isa_sex = 0; 362 } 363 #ifdef CONFIG_AMIGA_PCMCIA 364 if (MACH_IS_AMIGA && AMIGAHW_PRESENT(PCMCIA)) { 365 isa_type = ISA_TYPE_AG; 366 isa_sex = 1; 367 } 368 #endif 369 #ifdef CONFIG_ATARI_ROM_ISA 370 if (MACH_IS_ATARI) { 371 isa_type = ISA_TYPE_ENEC; 372 isa_sex = 0; 373 } 374 #endif 375 #endif 376 } 377 378 static int show_cpuinfo(struct seq_file *m, void *v) 379 { 380 const char *cpu, *mmu, *fpu; 381 unsigned long clockfreq, clockfactor; 382 383 #define LOOP_CYCLES_68020 (8) 384 #define LOOP_CYCLES_68030 (8) 385 #define LOOP_CYCLES_68040 (3) 386 #define LOOP_CYCLES_68060 (1) 387 #define LOOP_CYCLES_COLDFIRE (2) 388 389 if (CPU_IS_020) { 390 cpu = "68020"; 391 clockfactor = LOOP_CYCLES_68020; 392 } else if (CPU_IS_030) { 393 cpu = "68030"; 394 clockfactor = LOOP_CYCLES_68030; 395 } else if (CPU_IS_040) { 396 cpu = "68040"; 397 clockfactor = LOOP_CYCLES_68040; 398 } else if (CPU_IS_060) { 399 cpu = "68060"; 400 clockfactor = LOOP_CYCLES_68060; 401 } else if (CPU_IS_COLDFIRE) { 402 cpu = "ColdFire"; 403 clockfactor = LOOP_CYCLES_COLDFIRE; 404 } else { 405 cpu = "680x0"; 406 clockfactor = 0; 407 } 408 409 #ifdef CONFIG_M68KFPU_EMU_ONLY 410 fpu = "none(soft float)"; 411 #else 412 if (m68k_fputype & FPU_68881) 413 fpu = "68881"; 414 else if (m68k_fputype & FPU_68882) 415 fpu = "68882"; 416 else if (m68k_fputype & FPU_68040) 417 fpu = "68040"; 418 else if (m68k_fputype & FPU_68060) 419 fpu = "68060"; 420 else if (m68k_fputype & FPU_SUNFPA) 421 fpu = "Sun FPA"; 422 else if (m68k_fputype & FPU_COLDFIRE) 423 fpu = "ColdFire"; 424 else 425 fpu = "none"; 426 #endif 427 428 if (m68k_mmutype & MMU_68851) 429 mmu = "68851"; 430 else if (m68k_mmutype & MMU_68030) 431 mmu = "68030"; 432 else if (m68k_mmutype & MMU_68040) 433 mmu = "68040"; 434 else if (m68k_mmutype & MMU_68060) 435 mmu = "68060"; 436 else if (m68k_mmutype & MMU_SUN3) 437 mmu = "Sun-3"; 438 else if (m68k_mmutype & MMU_APOLLO) 439 mmu = "Apollo"; 440 else if (m68k_mmutype & MMU_COLDFIRE) 441 mmu = "ColdFire"; 442 else 443 mmu = "unknown"; 444 445 clockfreq = loops_per_jiffy * HZ * clockfactor; 446 447 seq_printf(m, "CPU:\t\t%s\n" 448 "MMU:\t\t%s\n" 449 "FPU:\t\t%s\n" 450 "Clocking:\t%lu.%1luMHz\n" 451 "BogoMips:\t%lu.%02lu\n" 452 "Calibration:\t%lu loops\n", 453 cpu, mmu, fpu, 454 clockfreq/1000000,(clockfreq/100000)%10, 455 loops_per_jiffy/(500000/HZ),(loops_per_jiffy/(5000/HZ))%100, 456 loops_per_jiffy); 457 return 0; 458 } 459 460 static void *c_start(struct seq_file *m, loff_t *pos) 461 { 462 return *pos < 1 ? (void *)1 : NULL; 463 } 464 static void *c_next(struct seq_file *m, void *v, loff_t *pos) 465 { 466 ++*pos; 467 return NULL; 468 } 469 static void c_stop(struct seq_file *m, void *v) 470 { 471 } 472 const struct seq_operations cpuinfo_op = { 473 .start = c_start, 474 .next = c_next, 475 .stop = c_stop, 476 .show = show_cpuinfo, 477 }; 478 479 #ifdef CONFIG_PROC_HARDWARE 480 static int hardware_proc_show(struct seq_file *m, void *v) 481 { 482 char model[80]; 483 unsigned long mem; 484 int i; 485 486 if (mach_get_model) 487 mach_get_model(model); 488 else 489 strcpy(model, "Unknown m68k"); 490 491 seq_printf(m, "Model:\t\t%s\n", model); 492 for (mem = 0, i = 0; i < m68k_num_memory; i++) 493 mem += m68k_memory[i].size; 494 seq_printf(m, "System Memory:\t%ldK\n", mem >> 10); 495 496 if (mach_get_hardware_list) 497 mach_get_hardware_list(m); 498 499 return 0; 500 } 501 502 static int __init proc_hardware_init(void) 503 { 504 proc_create_single("hardware", 0, NULL, hardware_proc_show); 505 return 0; 506 } 507 module_init(proc_hardware_init); 508 #endif 509 510 void __init arch_cpu_finalize_init(void) 511 { 512 #if defined(CONFIG_FPU) && !defined(CONFIG_M68KFPU_EMU) 513 if (m68k_fputype == 0) { 514 pr_emerg("*** YOU DO NOT HAVE A FLOATING POINT UNIT, " 515 "WHICH IS REQUIRED BY LINUX/M68K ***\n"); 516 pr_emerg("Upgrade your hardware or join the FPU " 517 "emulation project\n"); 518 panic("no FPU"); 519 } 520 #endif /* !CONFIG_M68KFPU_EMU */ 521 } 522 523 #ifdef CONFIG_ADB 524 static int __init adb_probe_sync_enable (char *str) { 525 extern int __adb_probe_sync; 526 __adb_probe_sync = 1; 527 return 1; 528 } 529 530 __setup("adb_sync", adb_probe_sync_enable); 531 #endif /* CONFIG_ADB */ 532 533 #if IS_ENABLED(CONFIG_NVRAM) 534 #ifdef CONFIG_MAC 535 static unsigned char m68k_nvram_read_byte(int addr) 536 { 537 if (MACH_IS_MAC) 538 return mac_pram_read_byte(addr); 539 return 0xff; 540 } 541 542 static void m68k_nvram_write_byte(unsigned char val, int addr) 543 { 544 if (MACH_IS_MAC) 545 mac_pram_write_byte(val, addr); 546 } 547 #endif /* CONFIG_MAC */ 548 549 #ifdef CONFIG_ATARI 550 static ssize_t m68k_nvram_read(char *buf, size_t count, loff_t *ppos) 551 { 552 if (MACH_IS_ATARI) 553 return atari_nvram_read(buf, count, ppos); 554 else if (MACH_IS_MAC) 555 return nvram_read_bytes(buf, count, ppos); 556 return -EINVAL; 557 } 558 559 static ssize_t m68k_nvram_write(char *buf, size_t count, loff_t *ppos) 560 { 561 if (MACH_IS_ATARI) 562 return atari_nvram_write(buf, count, ppos); 563 else if (MACH_IS_MAC) 564 return nvram_write_bytes(buf, count, ppos); 565 return -EINVAL; 566 } 567 568 static long m68k_nvram_set_checksum(void) 569 { 570 if (MACH_IS_ATARI) 571 return atari_nvram_set_checksum(); 572 return -EINVAL; 573 } 574 575 static long m68k_nvram_initialize(void) 576 { 577 if (MACH_IS_ATARI) 578 return atari_nvram_initialize(); 579 return -EINVAL; 580 } 581 #endif /* CONFIG_ATARI */ 582 583 static ssize_t m68k_nvram_get_size(void) 584 { 585 if (MACH_IS_ATARI) 586 return atari_nvram_get_size(); 587 else if (MACH_IS_MAC) 588 return mac_pram_get_size(); 589 return -ENODEV; 590 } 591 592 /* Atari device drivers call .read (to get checksum validation) whereas 593 * Mac and PowerMac device drivers just use .read_byte. 594 */ 595 const struct nvram_ops arch_nvram_ops = { 596 #ifdef CONFIG_MAC 597 .read_byte = m68k_nvram_read_byte, 598 .write_byte = m68k_nvram_write_byte, 599 #endif 600 #ifdef CONFIG_ATARI 601 .read = m68k_nvram_read, 602 .write = m68k_nvram_write, 603 .set_checksum = m68k_nvram_set_checksum, 604 .initialize = m68k_nvram_initialize, 605 #endif 606 .get_size = m68k_nvram_get_size, 607 }; 608 EXPORT_SYMBOL(arch_nvram_ops); 609 #endif /* CONFIG_NVRAM */ 610