setup.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 *    Initial setup-routines for HP 9000 based hardware.
  4 *
  5 *    Copyright (C) 1991, 1992, 1995  Linus Torvalds
  6 *    Modifications for PA-RISC (C) 1999 Helge Deller <deller@gmx.de>
  7 *    Modifications copyright 1999 SuSE GmbH (Philipp Rumpf)
  8 *    Modifications copyright 2000 Martin K. Petersen <mkp@mkp.net>
  9 *    Modifications copyright 2000 Philipp Rumpf <prumpf@tux.org>
 10 *    Modifications copyright 2001 Ryan Bradetich <rbradetich@uswest.net>
 11 *
 12 *    Initial PA-RISC Version: 04-23-1999 by Helge Deller
 13 */
 14
 15#include <linux/kernel.h>
 16#include <linux/initrd.h>
 17#include <linux/init.h>
 18#include <linux/console.h>
 19#include <linux/seq_file.h>
 20#define PCI_DEBUG
 21#include <linux/pci.h>
 22#undef PCI_DEBUG
 23#include <linux/proc_fs.h>
 24#include <linux/export.h>
 25#include <linux/sched.h>
 26#include <linux/sched/clock.h>
 27#include <linux/start_kernel.h>
 28
 29#include <asm/cacheflush.h>
 30#include <asm/processor.h>
 31#include <asm/sections.h>
 32#include <asm/pdc.h>
 33#include <asm/led.h>
 34#include <asm/pdc_chassis.h>
 35#include <asm/io.h>
 36#include <asm/setup.h>
 37#include <asm/unwind.h>
 38#include <asm/smp.h>
 39
 40static char __initdata command_line[COMMAND_LINE_SIZE];
 41
 42static void __init setup_cmdline(char **cmdline_p)
 43{
 44	extern unsigned int boot_args[];
 45	char *p;
 46
 47	*cmdline_p = command_line;
 48
 49	/* boot_args[0] is free-mem start, boot_args[1] is ptr to command line */
 50	if (boot_args[0] < 64)
 51		return;	/* return if called from hpux boot loader */
 52
 53	/* Collect stuff passed in from the boot loader */
 54	strscpy(boot_command_line, (char *)__va(boot_args[1]),
 55		COMMAND_LINE_SIZE);
 56
 57	/* autodetect console type (if not done by palo yet) */
 58	p = boot_command_line;
 59	if (!str_has_prefix(p, "console=") && !strstr(p, " console=")) {
 60		strlcat(p, " console=", COMMAND_LINE_SIZE);
 61		if (PAGE0->mem_cons.cl_class == CL_DUPLEX)
 62			strlcat(p, "ttyS0", COMMAND_LINE_SIZE);
 63		else
 64			strlcat(p, "tty0", COMMAND_LINE_SIZE);
 65	}
 66
 67	/* default to use early console */
 68	if (!strstr(p, "earlycon"))
 69		strlcat(p, " earlycon=pdc", COMMAND_LINE_SIZE);
 70
 71#ifdef CONFIG_BLK_DEV_INITRD
 72	/* did palo pass us a ramdisk? */
 73	if (boot_args[2] != 0) {
 74		initrd_start = (unsigned long)__va(boot_args[2]);
 75		initrd_end = (unsigned long)__va(boot_args[3]);
 76	}
 77#endif
 78
 79	strscpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
 80}
 81
 82#ifdef CONFIG_PA11
 83static void __init dma_ops_init(void)
 84{
 85	switch (boot_cpu_data.cpu_type) {
 86	case pcx:
 87		/*
 88		 * We've got way too many dependencies on 1.1 semantics
 89		 * to support 1.0 boxes at this point.
 90		 */
 91		panic(	"PA-RISC Linux currently only supports machines that conform to\n"
 92			"the PA-RISC 1.1 or 2.0 architecture specification.\n");
 93
 94	case pcxl2:
 95	default:
 96		break;
 97	}
 98}
 99#endif
100
101void __init setup_arch(char **cmdline_p)
102{
103	unwind_init();
104
105	init_per_cpu(smp_processor_id());	/* Set Modes & Enable FP */
106
107#ifdef CONFIG_64BIT
108	printk(KERN_INFO "The 64-bit Kernel has started...\n");
109#else
110	printk(KERN_INFO "The 32-bit Kernel has started...\n");
111#endif
112
113	printk(KERN_INFO "Kernel default page size is %d KB. Huge pages ",
114		(int)(PAGE_SIZE / 1024));
115#ifdef CONFIG_HUGETLB_PAGE
116	printk(KERN_CONT "enabled with %d MB physical and %d MB virtual size",
117		 1 << (REAL_HPAGE_SHIFT - 20), 1 << (HPAGE_SHIFT - 20));
118#else
119	printk(KERN_CONT "disabled");
120#endif
121	printk(KERN_CONT ".\n");
122
123#ifdef CONFIG_64BIT
124	if(parisc_narrow_firmware) {
125		printk(KERN_INFO "Kernel is using PDC in 32-bit mode.\n");
126	}
127#endif
128	setup_pdc();
129	setup_cmdline(cmdline_p);
130	collect_boot_cpu_data();
131	do_memory_inventory();  /* probe for physical memory */
132	parisc_cache_init();
133	paging_init();
134
135#ifdef CONFIG_PA11
136	dma_ops_init();
137#endif
138
139	clear_sched_clock_stable();
140}
141
142/*
143 * Display CPU info for all CPUs.
144 */
145static void *
146c_start (struct seq_file *m, loff_t *pos)
147{
148    	/* Looks like the caller will call repeatedly until we return
149	 * 0, signaling EOF perhaps.  This could be used to sequence
150	 * through CPUs for example.  Since we print all cpu info in our
151	 * show_cpuinfo() disregarding 'pos' (which I assume is 'v' above)
152	 * we only allow for one "position".  */
153	return ((long)*pos < 1) ? (void *)1 : NULL;
154}
155
156static void *
157c_next (struct seq_file *m, void *v, loff_t *pos)
158{
159	++*pos;
160	return c_start(m, pos);
161}
162
163static void
164c_stop (struct seq_file *m, void *v)
165{
166}
167
168const struct seq_operations cpuinfo_op = {
169	.start	= c_start,
170	.next	= c_next,
171	.stop	= c_stop,
172	.show	= show_cpuinfo
173};
174
175static struct resource central_bus = {
176	.name	= "Central Bus",
177	.start	= F_EXTEND(0xfff80000),
178	.end    = F_EXTEND(0xfffaffff),
179	.flags	= IORESOURCE_MEM,
180};
181
182static struct resource local_broadcast = {
183	.name	= "Local Broadcast",
184	.start	= F_EXTEND(0xfffb0000),
185	.end	= F_EXTEND(0xfffdffff),
186	.flags	= IORESOURCE_MEM,
187};
188
189static struct resource global_broadcast = {
190	.name	= "Global Broadcast",
191	.start	= F_EXTEND(0xfffe0000),
192	.end	= F_EXTEND(0xffffffff),
193	.flags	= IORESOURCE_MEM,
194};
195
196static int __init parisc_init_resources(void)
197{
198	int result;
199
200	result = request_resource(&iomem_resource, &central_bus);
201	if (result < 0) {
202		printk(KERN_ERR 
203		       "%s: failed to claim %s address space!\n", 
204		       __FILE__, central_bus.name);
205		return result;
206	}
207
208	result = request_resource(&iomem_resource, &local_broadcast);
209	if (result < 0) {
210		printk(KERN_ERR 
211		       "%s: failed to claim %s address space!\n",
212		       __FILE__, local_broadcast.name);
213		return result;
214	}
215
216	result = request_resource(&iomem_resource, &global_broadcast);
217	if (result < 0) {
218		printk(KERN_ERR 
219		       "%s: failed to claim %s address space!\n", 
220		       __FILE__, global_broadcast.name);
221		return result;
222	}
223
224	return 0;
225}
226
227static int __init parisc_init(void)
228{
229	u32 osid = (OS_ID_LINUX << 16);
230
231	parisc_init_resources();
232	do_device_inventory();                  /* probe for hardware */
233
234	parisc_pdc_chassis_init();
235	
236	/* set up a new led state on systems shipped LED State panel */
237	pdc_chassis_send_status(PDC_CHASSIS_DIRECT_BSTART);
238
239	/* tell PDC we're Linux. Nevermind failure. */
240	pdc_stable_write(0x40, &osid, sizeof(osid));
241	
242	/* start with known state */
243	flush_cache_all_local();
244	flush_tlb_all_local(NULL);
245
246	processor_init();
247#ifdef CONFIG_SMP
248	pr_info("CPU(s): %d out of %d %s at %d.%06d MHz online\n",
249		num_online_cpus(), num_present_cpus(),
250#else
251	pr_info("CPU(s): 1 x %s at %d.%06d MHz\n",
252#endif
253			boot_cpu_data.cpu_name,
254			boot_cpu_data.cpu_hz / 1000000,
255			boot_cpu_data.cpu_hz % 1000000	);
256
257#if defined(CONFIG_64BIT) && defined(CONFIG_SMP)
258	/* Don't serialize TLB flushes if we run on one CPU only. */
259	if (num_online_cpus() == 1)
260		pa_serialize_tlb_flushes = 0;
261#endif
262
263	apply_alternatives_all();
264	parisc_setup_cache_timing();
265	return 0;
266}
267arch_initcall(parisc_init);
268
269void __init start_parisc(void)
270{
271	int ret, cpunum;
272	struct pdc_coproc_cfg coproc_cfg;
273
274	/*
275	 * Check if initial kernel page mapping is sufficient.
276	 * Print warning if not, because we may access kernel functions and
277	 * variables which can't be reached yet through the initial mappings.
278	 * Note that the panic() and printk() functions are not functional
279	 * yet, so we need to use direct iodc() firmware calls instead.
280	 */
281	const char warn1[] = "CRITICAL: Kernel may crash because "
282			     "KERNEL_INITIAL_ORDER is too small.\n";
283	if (__pa((unsigned long) &_end) >= KERNEL_INITIAL_SIZE)
284		pdc_iodc_print(warn1, sizeof(warn1) - 1);
285
286	/* check QEMU/SeaBIOS marker in PAGE0 */
287	running_on_qemu = (memcmp(&PAGE0->pad0, "SeaBIOS", 8) == 0);
288
289	cpunum = smp_processor_id();
290
291	init_cpu_topology();
292
293	set_firmware_width_unlocked();
294
295	ret = pdc_coproc_cfg_unlocked(&coproc_cfg);
296	if (ret >= 0 && coproc_cfg.ccr_functional) {
297		mtctl(coproc_cfg.ccr_functional, 10);
298
299		per_cpu(cpu_data, cpunum).fp_rev = coproc_cfg.revision;
300		per_cpu(cpu_data, cpunum).fp_model = coproc_cfg.model;
301
302		asm volatile ("fstd	%fr0,8(%sp)");
303	} else {
304		panic("must have an fpu to boot linux");
305	}
306
307	early_trap_init(); /* initialize checksum of fault_vector */
308
309	start_kernel();
310	// not reached
311}