arch/h8300/kernel/setup.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  linux/arch/h8300/kernel/setup.c
   4  *
   5  *  Copyright (C) 2001-2014 Yoshinori Sato <ysato@users.sourceforge.jp>
   6  */
   7
   8 /*
   9  * This file handles the architecture-dependent parts of system setup
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/sched.h>
  14 #include <linux/delay.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/mm.h>
  17 #include <linux/fs.h>
  18 #include <linux/console.h>
  19 #include <linux/errno.h>
  20 #include <linux/string.h>
  21 #include <linux/seq_file.h>
  22 #include <linux/init.h>
  23 #include <linux/of.h>
  24 #include <linux/of_fdt.h>
  25 #include <linux/of_address.h>
  26 #include <linux/clk-provider.h>
  27 #include <linux/memblock.h>
  28 #include <linux/screen_info.h>
  29 #include <linux/clocksource.h>
  30
  31 #include <asm/setup.h>
  32 #include <asm/irq.h>
  33 #include <asm/pgtable.h>
  34 #include <asm/sections.h>
  35 #include <asm/page.h>
  36
  37 #if defined(CONFIG_CPU_H8300H)
  38 #define CPU "H8/300H"
  39 #elif defined(CONFIG_CPU_H8S)
  40 #define CPU "H8S"
  41 #else
  42 #define CPU "Unknown"
  43 #endif
  44
  45 unsigned long memory_start;
  46 unsigned long memory_end;
  47 EXPORT_SYMBOL(memory_end);
  48 static unsigned long freq;
  49 extern char __dtb_start[];
  50
  51 #ifdef CONFIG_VT
  52 struct screen_info screen_info;
  53 #endif
  54
  55 char __initdata command_line[COMMAND_LINE_SIZE];
  56
  57 void sim_console_register(void);
  58
  59 void __init h8300_fdt_init(void *fdt, char *bootargs)
  60 {
  61         if (!fdt)
  62                 fdt = __dtb_start;
  63         else
  64                 strcpy(command_line, bootargs);
  65
  66         early_init_dt_scan(fdt);
  67         memblock_allow_resize();
  68 }
  69
  70 static void __init bootmem_init(void)
  71 {
  72         struct memblock_region *region;
  73
  74         memory_end = memory_start = 0;
  75
  76         /* Find main memory where is the kernel */
  77         for_each_memblock(memory, region) {
  78                 memory_start = region->base;
  79                 memory_end = region->base + region->size;
  80         }
  81
  82         if (!memory_end)
  83                 panic("No memory!");
  84
  85         /* setup bootmem globals (we use no_bootmem, but mm still depends on this) */
  86         min_low_pfn = PFN_UP(memory_start);
  87         max_low_pfn = PFN_DOWN(memblock_end_of_DRAM());
  88         max_pfn = max_low_pfn;
  89
  90         memblock_reserve(__pa(_stext), _end - _stext);
  91
  92         early_init_fdt_reserve_self();
  93         early_init_fdt_scan_reserved_mem();
  94
  95         memblock_dump_all();
  96 }
  97
  98 void __init setup_arch(char **cmdline_p)
  99 {
 100         unflatten_and_copy_device_tree();
 101
 102         init_mm.start_code = (unsigned long) _stext;
 103         init_mm.end_code = (unsigned long) _etext;
 104         init_mm.end_data = (unsigned long) _edata;
 105         init_mm.brk = (unsigned long) 0;
 106
 107         pr_notice("\r\n\nuClinux " CPU "\n");
 108         pr_notice("Flat model support (C) 1998,1999 Kenneth Albanowski, D. Jeff Dionne\n");
 109
 110         if (*command_line)
 111                 strcpy(boot_command_line, command_line);
 112         *cmdline_p = boot_command_line;
 113
 114         parse_early_param();
 115
 116         bootmem_init();
 117         /*
 118          * get kmalloc into gear
 119          */
 120         paging_init();
 121 }
 122
 123 /*
 124  *      Get CPU information for use by the procfs.
 125  */
 126
 127 static int show_cpuinfo(struct seq_file *m, void *v)
 128 {
 129         char *cpu;
 130
 131         cpu = CPU;
 132
 133         seq_printf(m,  "CPU:\t\t%s\n"
 134                    "Clock:\t\t%lu.%1luMHz\n"
 135                    "BogoMips:\t%lu.%02lu\n"
 136                    "Calibration:\t%lu loops\n",
 137                    cpu,
 138                    freq/1000, freq%1000,
 139                    (loops_per_jiffy*HZ)/500000,
 140                    ((loops_per_jiffy*HZ)/5000)%100,
 141                    (loops_per_jiffy*HZ));
 142
 143         return 0;
 144 }
 145
 146 static void *c_start(struct seq_file *m, loff_t *pos)
 147 {
 148         return *pos < num_possible_cpus() ?
 149                 ((void *) 0x12345678) : NULL;
 150 }
 151
 152 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
 153 {
 154         ++*pos;
 155         return c_start(m, pos);
 156 }
 157
 158 static void c_stop(struct seq_file *m, void *v)
 159 {
 160 }
 161
 162 const struct seq_operations cpuinfo_op = {
 163         .start  = c_start,
 164         .next   = c_next,
 165         .stop   = c_stop,
 166         .show   = show_cpuinfo,
 167 };
 168
 169 #if defined(CONFIG_CPU_H8300H)
 170 #define get_wait(base, addr) ({         \
 171         int baddr;                      \
 172         baddr = ((addr) / 0x200000 * 2);                             \
 173         w *= (readw((base) + 2) & (3 << baddr)) + 1;                 \
 174         })
 175 #endif
 176 #if defined(CONFIG_CPU_H8S)
 177 #define get_wait(base, addr) ({         \
 178         int baddr;                      \
 179         baddr = ((addr) / 0x200000 * 16);                            \
 180         w *= (readl((base) + 2) & (7 << baddr)) + 1;    \
 181         })
 182 #endif
 183
 184 static __init int access_timing(void)
 185 {
 186         struct device_node *bsc;
 187         void __iomem *base;
 188         unsigned long addr = (unsigned long)&__delay;
 189         int bit = 1 << (addr / 0x200000);
 190         int w;
 191
 192         bsc = of_find_compatible_node(NULL, NULL, "renesas,h8300-bsc");
 193         base = of_iomap(bsc, 0);
 194         w = (readb(base + 0) & bit)?2:1;
 195         if (readb(base + 1) & bit)
 196                 w *= get_wait(base, addr);
 197         else
 198                 w *= 2;
 199         return w * 3 / 2;
 200 }
 201
 202 void __init calibrate_delay(void)
 203 {
 204         struct device_node *cpu;
 205         int freq;
 206
 207         cpu = of_find_compatible_node(NULL, NULL, "renesas,h8300");
 208         of_property_read_s32(cpu, "clock-frequency", &freq);
 209         loops_per_jiffy = freq / HZ / (access_timing() * 2);
 210         pr_cont("%lu.%02lu BogoMIPS (lpj=%lu)\n",
 211                 loops_per_jiffy / (500000 / HZ),
 212                 (loops_per_jiffy / (5000 / HZ)) % 100, loops_per_jiffy);
 213 }
 214
 215
 216 void __init time_init(void)
 217 {
 218         of_clk_init(NULL);
 219         timer_probe();
 220 }