setup_mm.c 14 KB

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