[mirror_ubuntu-disco-kernel.git] / arch / h8300 / kernel / setup.c

// SPDX-License-Identifier: GPL-2.0
/*
 *  linux/arch/h8300/kernel/setup.c
 *
 *  Copyright (C) 2001-2014 Yoshinori Sato <ysato@users.sourceforge.jp>
 */

/*
 * This file handles the architecture-dependent parts of system setup
 */

#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/delay.h>
#include <linux/interrupt.h>
#include <linux/mm.h>
#include <linux/fs.h>
#include <linux/console.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/bootmem.h>
#include <linux/seq_file.h>
#include <linux/init.h>
#include <linux/of.h>
#include <linux/of_fdt.h>
#include <linux/of_platform.h>
#include <linux/of_address.h>
#include <linux/clk-provider.h>
#include <linux/memblock.h>
#include <linux/screen_info.h>
#include <linux/clocksource.h>

#include <asm/setup.h>
#include <asm/irq.h>
#include <asm/pgtable.h>
#include <asm/sections.h>
#include <asm/page.h>

#if defined(CONFIG_CPU_H8300H)
#define CPU "H8/300H"
#elif defined(CONFIG_CPU_H8S)
#define CPU "H8S"
#else
#define CPU "Unknown"
#endif

unsigned long memory_start;
unsigned long memory_end;
EXPORT_SYMBOL(memory_end);
static unsigned long freq;
extern char __dtb_start[];

#ifdef CONFIG_VT
struct screen_info screen_info;
#endif

char __initdata command_line[COMMAND_LINE_SIZE];

void sim_console_register(void);

void __init h8300_fdt_init(void *fdt, char *bootargs)
{
	if (!fdt)
		fdt = __dtb_start;
	else
		strcpy(command_line, bootargs);

	early_init_dt_scan(fdt);
	memblock_allow_resize();
}

static void __init bootmem_init(void)
{
	int bootmap_size;
	unsigned long ram_start_pfn;
	unsigned long free_ram_start_pfn;
	unsigned long ram_end_pfn;
	struct memblock_region *region;

	memory_end = memory_start = 0;

	/* Find main memory where is the kernel */
	for_each_memblock(memory, region) {
		memory_start = region->base;
		memory_end = region->base + region->size;
	}

	if (!memory_end)
		panic("No memory!");

	ram_start_pfn = PFN_UP(memory_start);
	/* free_ram_start_pfn is first page after kernel */
	free_ram_start_pfn = PFN_UP(__pa(_end));
	ram_end_pfn = PFN_DOWN(memblock_end_of_DRAM());

	max_pfn = ram_end_pfn;

	/*
	 * give all the memory to the bootmap allocator,  tell it to put the
	 * boot mem_map at the start of memory
	 */
	bootmap_size = init_bootmem_node(NODE_DATA(0),
					 free_ram_start_pfn,
					 0,
					 ram_end_pfn);
	/*
	 * free the usable memory,  we have to make sure we do not free
	 * the bootmem bitmap so we then reserve it after freeing it :-)
	 */
	free_bootmem(PFN_PHYS(free_ram_start_pfn),
		     (ram_end_pfn - free_ram_start_pfn) << PAGE_SHIFT);
	reserve_bootmem(PFN_PHYS(free_ram_start_pfn), bootmap_size,
			BOOTMEM_DEFAULT);

	for_each_memblock(reserved, region) {
		reserve_bootmem(region->base, region->size, BOOTMEM_DEFAULT);
	}
}

void __init setup_arch(char **cmdline_p)
{
	unflatten_and_copy_device_tree();

	init_mm.start_code = (unsigned long) _stext;
	init_mm.end_code = (unsigned long) _etext;
	init_mm.end_data = (unsigned long) _edata;
	init_mm.brk = (unsigned long) 0;

	pr_notice("\r\n\nuClinux " CPU "\n");
	pr_notice("Flat model support (C) 1998,1999 Kenneth Albanowski, D. Jeff Dionne\n");

	if (*command_line)
		strcpy(boot_command_line, command_line);
	*cmdline_p = boot_command_line;

	parse_early_param();

	bootmem_init();
	/*
	 * get kmalloc into gear
	 */
	paging_init();
}

/*
 *	Get CPU information for use by the procfs.
 */

static int show_cpuinfo(struct seq_file *m, void *v)
{
	char *cpu;

	cpu = CPU;

	seq_printf(m,  "CPU:\t\t%s\n"
		   "Clock:\t\t%lu.%1luMHz\n"
		   "BogoMips:\t%lu.%02lu\n"
		   "Calibration:\t%lu loops\n",
		   cpu,
		   freq/1000, freq%1000,
		   (loops_per_jiffy*HZ)/500000,
		   ((loops_per_jiffy*HZ)/5000)%100,
		   (loops_per_jiffy*HZ));

	return 0;
}

static void *c_start(struct seq_file *m, loff_t *pos)
{
	return *pos < num_possible_cpus() ?
		((void *) 0x12345678) : NULL;
}

static void *c_next(struct seq_file *m, void *v, loff_t *pos)
{
	++*pos;
	return c_start(m, pos);
}

static void c_stop(struct seq_file *m, void *v)
{
}

const struct seq_operations cpuinfo_op = {
	.start	= c_start,
	.next	= c_next,
	.stop	= c_stop,
	.show	= show_cpuinfo,
};

static int __init device_probe(void)
{
	of_platform_populate(NULL, NULL, NULL, NULL);

	return 0;
}

device_initcall(device_probe);

#if defined(CONFIG_CPU_H8300H)
#define get_wait(base, addr) ({		\
	int baddr;			\
	baddr = ((addr) / 0x200000 * 2);			     \
	w *= (readw((base) + 2) & (3 << baddr)) + 1;		     \
	})
#endif
#if defined(CONFIG_CPU_H8S)
#define get_wait(base, addr) ({		\
	int baddr;			\
	baddr = ((addr) / 0x200000 * 16);			     \
	w *= (readl((base) + 2) & (7 << baddr)) + 1;	\
	})
#endif

static __init int access_timing(void)
{
	struct device_node *bsc;
	void __iomem *base;
	unsigned long addr = (unsigned long)&__delay;
	int bit = 1 << (addr / 0x200000);
	int w;

	bsc = of_find_compatible_node(NULL, NULL, "renesas,h8300-bsc");
	base = of_iomap(bsc, 0);
	w = (readb(base + 0) & bit)?2:1;
	if (readb(base + 1) & bit)
		w *= get_wait(base, addr);
	else
		w *= 2;
	return w * 3 / 2;
}

void __init calibrate_delay(void)
{
	struct device_node *cpu;
	int freq;

	cpu = of_find_compatible_node(NULL, NULL, "renesas,h8300");
	of_property_read_s32(cpu, "clock-frequency", &freq);
	loops_per_jiffy = freq / HZ / (access_timing() * 2);
	pr_cont("%lu.%02lu BogoMIPS (lpj=%lu)\n",
		loops_per_jiffy / (500000 / HZ),
		(loops_per_jiffy / (5000 / HZ)) % 100, loops_per_jiffy);
}


void __init time_init(void)
{
	of_clk_init(NULL);
	timer_probe();
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
d8b0bdb4 YS	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/bootmem.h>
	22	#include <linux/seq_file.h>
	23	#include <linux/init.h>
d8b0bdb4 YS	24	#include <linux/of.h>
	25	#include <linux/of_fdt.h>
	26	#include <linux/of_platform.h>
	27	#include <linux/of_address.h>
	28	#include <linux/clk-provider.h>
	29	#include <linux/memblock.h>
	30	#include <linux/screen_info.h>
f639eeb4	31	#include <linux/clocksource.h>
d8b0bdb4 YS	32
	33	#include <asm/setup.h>
	34	#include <asm/irq.h>
	35	#include <asm/pgtable.h>
	36	#include <asm/sections.h>
	37	#include <asm/page.h>
	38
	39	#if defined(CONFIG_CPU_H8300H)
	40	#define CPU "H8/300H"
	41	#elif defined(CONFIG_CPU_H8S)
	42	#define CPU "H8S"
	43	#else
	44	#define CPU "Unknown"
	45	#endif
	46
	47	unsigned long memory_start;
	48	unsigned long memory_end;
	49	EXPORT_SYMBOL(memory_end);
	50	static unsigned long freq;
	51	extern char __dtb_start[];
	52
	53	#ifdef CONFIG_VT
	54	struct screen_info screen_info;
	55	#endif
	56
	57	char __initdata command_line[COMMAND_LINE_SIZE];
	58
	59	void sim_console_register(void);
	60
	61	void __init h8300_fdt_init(void fdt, char bootargs)
	62	{
	63	if (!fdt)
	64	fdt = __dtb_start;
	65	else
	66	strcpy(command_line, bootargs);
	67
	68	early_init_dt_scan(fdt);
	69	memblock_allow_resize();
	70	}
	71
	72	static void __init bootmem_init(void)
	73	{
	74	int bootmap_size;
	75	unsigned long ram_start_pfn;
	76	unsigned long free_ram_start_pfn;
	77	unsigned long ram_end_pfn;
	78	struct memblock_region *region;
	79
	80	memory_end = memory_start = 0;
	81
	82	/* Find main memory where is the kernel */
	83	for_each_memblock(memory, region) {
	84	memory_start = region->base;
	85	memory_end = region->base + region->size;
	86	}
	87
	88	if (!memory_end)
	89	panic("No memory!");
	90
	91	ram_start_pfn = PFN_UP(memory_start);
	92	/* free_ram_start_pfn is first page after kernel */
	93	free_ram_start_pfn = PFN_UP(__pa(_end));
	94	ram_end_pfn = PFN_DOWN(memblock_end_of_DRAM());
	95
96	max_pfn = ram_end_pfn;
97
98	/*
99	* give all the memory to the bootmap allocator, tell it to put the
100	* boot mem_map at the start of memory
101	*/
102	bootmap_size = init_bootmem_node(NODE_DATA(0),
103	free_ram_start_pfn,
104	0,
105	ram_end_pfn);
106	/*
107	* free the usable memory, we have to make sure we do not free
108	* the bootmem bitmap so we then reserve it after freeing it :-)
109	*/
110	free_bootmem(PFN_PHYS(free_ram_start_pfn),
111	(ram_end_pfn - free_ram_start_pfn) << PAGE_SHIFT);
112	reserve_bootmem(PFN_PHYS(free_ram_start_pfn), bootmap_size,
113	BOOTMEM_DEFAULT);
114
115	for_each_memblock(reserved, region) {
116	reserve_bootmem(region->base, region->size, BOOTMEM_DEFAULT);
117	}
118	}
119
120	void __init setup_arch(char **cmdline_p)
121	{
122	unflatten_and_copy_device_tree();
123
124	init_mm.start_code = (unsigned long) _stext;
125	init_mm.end_code = (unsigned long) _etext;
126	init_mm.end_data = (unsigned long) _edata;
127	init_mm.brk = (unsigned long) 0;
128
129	pr_notice("\r\n\nuClinux " CPU "\n");
130	pr_notice("Flat model support (C) 1998,1999 Kenneth Albanowski, D. Jeff Dionne\n");
131
132	if (*command_line)
133	strcpy(boot_command_line, command_line);
134	*cmdline_p = boot_command_line;
135
136	parse_early_param();
137
138	bootmem_init();
d8b0bdb4 YS	139	/*
	140	* get kmalloc into gear
	141	*/
	142	paging_init();
	143	}
	144
	145	/*
	146	* Get CPU information for use by the procfs.
	147	*/
	148
	149	static int show_cpuinfo(struct seq_file m, void v)
	150	{
	151	char *cpu;
	152
	153	cpu = CPU;
	154
	155	seq_printf(m, "CPU:\t\t%s\n"
	156	"Clock:\t\t%lu.%1luMHz\n"
	157	"BogoMips:\t%lu.%02lu\n"
	158	"Calibration:\t%lu loops\n",
	159	cpu,
	160	freq/1000, freq%1000,
	161	(loops_per_jiffy*HZ)/500000,
	162	((loops_per_jiffy*HZ)/5000)%100,
	163	(loops_per_jiffy*HZ));
	164
	165	return 0;
	166	}
	167
	168	static void c_start(struct seq_file m, loff_t *pos)
	169	{
	170	return *pos < num_possible_cpus() ?
	171	((void *) 0x12345678) : NULL;
	172	}
	173
	174	static void c_next(struct seq_file m, void v, loff_t pos)
	175	{
	176	++*pos;
	177	return c_start(m, pos);
	178	}
	179
	180	static void c_stop(struct seq_file m, void v)
	181	{
	182	}
	183
	184	const struct seq_operations cpuinfo_op = {
	185	.start = c_start,
	186	.next = c_next,
	187	.stop = c_stop,
	188	.show = show_cpuinfo,
	189	};
	190
	191	static int __init device_probe(void)
	192	{
	193	of_platform_populate(NULL, NULL, NULL, NULL);
	194
	195	return 0;
	196	}
	197
	198	device_initcall(device_probe);
	199
	200	#if defined(CONFIG_CPU_H8300H)
	201	#define get_wait(base, addr) ({ \
	202	int baddr; \
203	baddr = ((addr) / 0x200000 * 2); \
75160515	204	w *= (readw((base) + 2) & (3 << baddr)) + 1; \
d8b0bdb4 YS	205	})
	206	#endif
	207	#if defined(CONFIG_CPU_H8S)
	208	#define get_wait(base, addr) ({ \
	209	int baddr; \
	210	baddr = ((addr) / 0x200000 * 16); \
75160515	211	w *= (readl((base) + 2) & (7 << baddr)) + 1; \
d8b0bdb4 YS	212	})
	213	#endif
	214
	215	static __init int access_timing(void)
	216	{
	217	struct device_node *bsc;
	218	void __iomem *base;
	219	unsigned long addr = (unsigned long)&__delay;
	220	int bit = 1 << (addr / 0x200000);
	221	int w;
	222
	223	bsc = of_find_compatible_node(NULL, NULL, "renesas,h8300-bsc");
	224	base = of_iomap(bsc, 0);
75160515 DL	225	w = (readb(base + 0) & bit)?2:1;
75160515 DL	226	if (readb(base + 1) & bit)
d8b0bdb4 YS	227	w *= get_wait(base, addr);
	228	else
	229	w *= 2;
	230	return w * 3 / 2;
	231	}
	232
	233	void __init calibrate_delay(void)
	234	{
	235	struct device_node *cpu;
	236	int freq;
	237
	238	cpu = of_find_compatible_node(NULL, NULL, "renesas,h8300");
	239	of_property_read_s32(cpu, "clock-frequency", &freq);
	240	loops_per_jiffy = freq / HZ / (access_timing() * 2);
	241	pr_cont("%lu.%02lu BogoMIPS (lpj=%lu)\n",
	242	loops_per_jiffy / (500000 / HZ),
	243	(loops_per_jiffy / (5000 / HZ)) % 100, loops_per_jiffy);
	244	}
	245
	246
	247	void __init time_init(void)
	248	{
	249	of_clk_init(NULL);
ba5d08c0	250	timer_probe();
d8b0bdb4	251	}