[deliverable/linux.git] / arch / sparc64 / kernel / setup.c

/*  $Id: setup.c,v 1.72 2002/02/09 19:49:30 davem Exp $
 *  linux/arch/sparc64/kernel/setup.c
 *
 *  Copyright (C) 1995,1996  David S. Miller (davem@caip.rutgers.edu)
 *  Copyright (C) 1997       Jakub Jelinek (jj@sunsite.mff.cuni.cz)
 */

#include <linux/errno.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/stddef.h>
#include <linux/unistd.h>
#include <linux/ptrace.h>
#include <linux/slab.h>
#include <asm/smp.h>
#include <linux/user.h>
#include <linux/a.out.h>
#include <linux/tty.h>
#include <linux/delay.h>
#include <linux/config.h>
#include <linux/fs.h>
#include <linux/seq_file.h>
#include <linux/syscalls.h>
#include <linux/kdev_t.h>
#include <linux/major.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/inet.h>
#include <linux/console.h>
#include <linux/root_dev.h>
#include <linux/interrupt.h>
#include <linux/cpu.h>
#include <linux/initrd.h>

#include <asm/system.h>
#include <asm/io.h>
#include <asm/processor.h>
#include <asm/oplib.h>
#include <asm/page.h>
#include <asm/pgtable.h>
#include <asm/idprom.h>
#include <asm/head.h>
#include <asm/starfire.h>
#include <asm/mmu_context.h>
#include <asm/timer.h>
#include <asm/sections.h>
#include <asm/setup.h>
#include <asm/mmu.h>

#ifdef CONFIG_IP_PNP
#include <net/ipconfig.h>
#endif

struct screen_info screen_info = {
	0, 0,			/* orig-x, orig-y */
	0,			/* unused */
	0,			/* orig-video-page */
	0,			/* orig-video-mode */
	128,			/* orig-video-cols */
	0, 0, 0,		/* unused, ega_bx, unused */
	54,			/* orig-video-lines */
	0,                      /* orig-video-isVGA */
	16                      /* orig-video-points */
};

/* Typing sync at the prom prompt calls the function pointed to by
 * the sync callback which I set to the following function.
 * This should sync all filesystems and return, for now it just
 * prints out pretty messages and returns.
 */

void (*prom_palette)(int);
void (*prom_keyboard)(void);

static void
prom_console_write(struct console *con, const char *s, unsigned n)
{
	prom_write(s, n);
}

static struct console prom_console = {
	.name =		"prom",
	.write =	prom_console_write,
	.flags =	CON_CONSDEV | CON_ENABLED,
	.index =	-1,
};

#define PROM_TRUE	-1
#define PROM_FALSE	0

/* Pretty sick eh? */
int prom_callback(long *args)
{
	struct console *cons, *saved_console = NULL;
	unsigned long flags;
	char *cmd;
	extern spinlock_t prom_entry_lock;

	if (!args)
		return -1;
	if (!(cmd = (char *)args[0]))
		return -1;

	/*
	 * The callback can be invoked on the cpu that first dropped 
	 * into prom_cmdline after taking the serial interrupt, or on 
	 * a slave processor that was smp_captured() if the 
	 * administrator has done a switch-cpu inside obp. In either 
	 * case, the cpu is marked as in-interrupt. Drop IRQ locks.
	 */
	irq_exit();

	/* XXX Revisit the locking here someday.  This is a debugging
	 * XXX feature so it isnt all that critical.  -DaveM
	 */
	local_irq_save(flags);

	spin_unlock(&prom_entry_lock);
	cons = console_drivers;
	while (cons) {
		unregister_console(cons);
		cons->flags &= ~(CON_PRINTBUFFER);
		cons->next = saved_console;
		saved_console = cons;
		cons = console_drivers;
	}
	register_console(&prom_console);
	if (!strcmp(cmd, "sync")) {
		prom_printf("PROM `%s' command...\n", cmd);
		show_free_areas();
		if (current->pid != 0) {
			local_irq_enable();
			sys_sync();
			local_irq_disable();
		}
		args[2] = 0;
		args[args[1] + 3] = -1;
		prom_printf("Returning to PROM\n");
	} else if (!strcmp(cmd, "va>tte-data")) {
		unsigned long ctx, va;
		unsigned long tte = 0;
		long res = PROM_FALSE;

		ctx = args[3];
		va = args[4];
		if (ctx) {
			/*
			 * Find process owning ctx, lookup mapping.
			 */
			struct task_struct *p;
			struct mm_struct *mm = NULL;
			pgd_t *pgdp;
			pud_t *pudp;
			pmd_t *pmdp;
			pte_t *ptep;
			pte_t pte;

			for_each_process(p) {
				mm = p->mm;
				if (CTX_NRBITS(mm->context) == ctx)
					break;
			}
			if (!mm ||
			    CTX_NRBITS(mm->context) != ctx)
				goto done;

			pgdp = pgd_offset(mm, va);
			if (pgd_none(*pgdp))
				goto done;
			pudp = pud_offset(pgdp, va);
			if (pud_none(*pudp))
				goto done;
			pmdp = pmd_offset(pudp, va);
			if (pmd_none(*pmdp))
				goto done;

			/* Preemption implicitly disabled by virtue of
			 * being called from inside OBP.
			 */
			ptep = pte_offset_map(pmdp, va);
			pte = *ptep;
			if (pte_present(pte)) {
				tte = pte_val(pte);
				res = PROM_TRUE;
			}
			pte_unmap(ptep);
			goto done;
		}

		if ((va >= KERNBASE) && (va < (KERNBASE + (4 * 1024 * 1024)))) {
			extern unsigned long sparc64_kern_pri_context;

			/* Spitfire Errata #32 workaround */
			__asm__ __volatile__("stxa	%0, [%1] %2\n\t"
					     "flush	%%g6"
					     : /* No outputs */
					     : "r" (sparc64_kern_pri_context),
					       "r" (PRIMARY_CONTEXT),
					       "i" (ASI_DMMU));

			/*
			 * Locked down tlb entry.
			 */

			if (tlb_type == spitfire)
				tte = spitfire_get_dtlb_data(SPITFIRE_HIGHEST_LOCKED_TLBENT);
			else if (tlb_type == cheetah || tlb_type == cheetah_plus)
				tte = cheetah_get_ldtlb_data(CHEETAH_HIGHEST_LOCKED_TLBENT);

			res = PROM_TRUE;
			goto done;
		}

		if (va < PGDIR_SIZE) {
			/*
			 * vmalloc or prom_inherited mapping.
			 */
			pgd_t *pgdp;
			pud_t *pudp;
			pmd_t *pmdp;
			pte_t *ptep;
			pte_t pte;
			int error;

			if ((va >= LOW_OBP_ADDRESS) && (va < HI_OBP_ADDRESS)) {
				tte = prom_virt_to_phys(va, &error);
				if (!error)
					res = PROM_TRUE;
				goto done;
			}
			pgdp = pgd_offset_k(va);
			if (pgd_none(*pgdp))
				goto done;
			pudp = pud_offset(pgdp, va);
			if (pud_none(*pudp))
				goto done;
			pmdp = pmd_offset(pudp, va);
			if (pmd_none(*pmdp))
				goto done;

			/* Preemption implicitly disabled by virtue of
			 * being called from inside OBP.
			 */
			ptep = pte_offset_kernel(pmdp, va);
			pte = *ptep;
			if (pte_present(pte)) {
				tte = pte_val(pte);
				res = PROM_TRUE;
			}
			goto done;
		}

		if (va < PAGE_OFFSET) {
			/*
			 * No mappings here.
			 */
			goto done;
		}

		if (va & (1UL << 40)) {
			/*
			 * I/O page.
			 */

			tte = (__pa(va) & _PAGE_PADDR) |
			      _PAGE_VALID | _PAGE_SZ4MB |
			      _PAGE_E | _PAGE_P | _PAGE_W;
			res = PROM_TRUE;
			goto done;
		}

		/*
		 * Normal page.
		 */
		tte = (__pa(va) & _PAGE_PADDR) |
		      _PAGE_VALID | _PAGE_SZ4MB |
		      _PAGE_CP | _PAGE_CV | _PAGE_P | _PAGE_W;
		res = PROM_TRUE;

	done:
		if (res == PROM_TRUE) {
			args[2] = 3;
			args[args[1] + 3] = 0;
			args[args[1] + 4] = res;
			args[args[1] + 5] = tte;
		} else {
			args[2] = 2;
			args[args[1] + 3] = 0;
			args[args[1] + 4] = res;
		}
	} else if (!strcmp(cmd, ".soft1")) {
		unsigned long tte;

		tte = args[3];
		prom_printf("%lx:\"%s%s%s%s%s\" ",
			    (tte & _PAGE_SOFT) >> 7,
			    tte & _PAGE_MODIFIED ? "M" : "-",
			    tte & _PAGE_ACCESSED ? "A" : "-",
			    tte & _PAGE_READ     ? "W" : "-",
			    tte & _PAGE_WRITE    ? "R" : "-",
			    tte & _PAGE_PRESENT  ? "P" : "-");

		args[2] = 2;
		args[args[1] + 3] = 0;
		args[args[1] + 4] = PROM_TRUE;
	} else if (!strcmp(cmd, ".soft2")) {
		unsigned long tte;

		tte = args[3];
		prom_printf("%lx ", (tte & 0x07FC000000000000UL) >> 50);

		args[2] = 2;
		args[args[1] + 3] = 0;
		args[args[1] + 4] = PROM_TRUE;
	} else {
		prom_printf("unknown PROM `%s' command...\n", cmd);
	}
	unregister_console(&prom_console);
	while (saved_console) {
		cons = saved_console;
		saved_console = cons->next;
		register_console(cons);
	}
	spin_lock(&prom_entry_lock);
	local_irq_restore(flags);

	/*
	 * Restore in-interrupt status for a resume from obp.
	 */
	irq_enter();
	return 0;
}

unsigned int boot_flags = 0;
#define BOOTME_DEBUG  0x1
#define BOOTME_SINGLE 0x2

/* Exported for mm/init.c:paging_init. */
unsigned long cmdline_memory_size = 0;

static struct console prom_debug_console = {
	.name =		"debug",
	.write =	prom_console_write,
	.flags =	CON_PRINTBUFFER,
	.index =	-1,
};

/* XXX Implement this at some point... */
void kernel_enter_debugger(void)
{
}

int obp_system_intr(void)
{
	if (boot_flags & BOOTME_DEBUG) {
		printk("OBP: system interrupted\n");
		prom_halt();
		return 1;
	}
	return 0;
}

/* 
 * Process kernel command line switches that are specific to the
 * SPARC or that require special low-level processing.
 */
static void __init process_switch(char c)
{
	switch (c) {
	case 'd':
		boot_flags |= BOOTME_DEBUG;
		break;
	case 's':
		boot_flags |= BOOTME_SINGLE;
		break;
	case 'h':
		prom_printf("boot_flags_init: Halt!\n");
		prom_halt();
		break;
	case 'p':
		/* Use PROM debug console. */
		register_console(&prom_debug_console);
		break;
	case 'P':
		/* Force UltraSPARC-III P-Cache on. */
		if (tlb_type != cheetah) {
			printk("BOOT: Ignoring P-Cache force option.\n");
			break;
		}
		cheetah_pcache_forced_on = 1;
		add_taint(TAINT_MACHINE_CHECK);
		cheetah_enable_pcache();
		break;

	default:
		printk("Unknown boot switch (-%c)\n", c);
		break;
	}
}

static void __init process_console(char *commands)
{
	serial_console = 0;
	commands += 8;
	/* Linux-style serial */
	if (!strncmp(commands, "ttyS", 4))
		serial_console = simple_strtoul(commands + 4, NULL, 10) + 1;
	else if (!strncmp(commands, "tty", 3)) {
		char c = *(commands + 3);
		/* Solaris-style serial */
		if (c == 'a' || c == 'b') {
			serial_console = c - 'a' + 1;
			prom_printf ("Using /dev/tty%c as console.\n", c);
		}
		/* else Linux-style fbcon, not serial */
	}
#if defined(CONFIG_PROM_CONSOLE)
	if (!strncmp(commands, "prom", 4)) {
		char *p;

		for (p = commands - 8; *p && *p != ' '; p++)
			*p = ' ';
		conswitchp = &prom_con;
	}
#endif
}

static void __init boot_flags_init(char *commands)
{
	while (*commands) {
		/* Move to the start of the next "argument". */
		while (*commands && *commands == ' ')
			commands++;

		/* Process any command switches, otherwise skip it. */
		if (*commands == '\0')
			break;
		if (*commands == '-') {
			commands++;
			while (*commands && *commands != ' ')
				process_switch(*commands++);
			continue;
		}
		if (!strncmp(commands, "console=", 8)) {
			process_console(commands);
		} else if (!strncmp(commands, "mem=", 4)) {
			/*
			 * "mem=XXX[kKmM]" overrides the PROM-reported
			 * memory size.
			 */
			cmdline_memory_size = simple_strtoul(commands + 4,
							     &commands, 0);
			if (*commands == 'K' || *commands == 'k') {
				cmdline_memory_size <<= 10;
				commands++;
			} else if (*commands=='M' || *commands=='m') {
				cmdline_memory_size <<= 20;
				commands++;
			}
		}
		while (*commands && *commands != ' ')
			commands++;
	}
}

extern void panic_setup(char *, int *);

extern unsigned short root_flags;
extern unsigned short root_dev;
extern unsigned short ram_flags;
#define RAMDISK_IMAGE_START_MASK	0x07FF
#define RAMDISK_PROMPT_FLAG		0x8000
#define RAMDISK_LOAD_FLAG		0x4000

extern int root_mountflags;

char reboot_command[COMMAND_LINE_SIZE];

static struct pt_regs fake_swapper_regs = { { 0, }, 0, 0, 0, 0 };

void register_prom_callbacks(void)
{
	prom_setcallback(prom_callback);
	prom_feval(": linux-va>tte-data 2 \" va>tte-data\" $callback drop ; "
		   "' linux-va>tte-data to va>tte-data");
	prom_feval(": linux-.soft1 1 \" .soft1\" $callback 2drop ; "
		   "' linux-.soft1 to .soft1");
	prom_feval(": linux-.soft2 1 \" .soft2\" $callback 2drop ; "
		   "' linux-.soft2 to .soft2");
}

void __init setup_arch(char **cmdline_p)
{
	/* Initialize PROM console and command line. */
	*cmdline_p = prom_getbootargs();
	strcpy(saved_command_line, *cmdline_p);

	printk("ARCH: SUN4U\n");

#ifdef CONFIG_DUMMY_CONSOLE
	conswitchp = &dummy_con;
#elif defined(CONFIG_PROM_CONSOLE)
	conswitchp = &prom_con;
#endif

	/* Work out if we are starfire early on */
	check_if_starfire();

	boot_flags_init(*cmdline_p);

	idprom_init();

	if (!root_flags)
		root_mountflags &= ~MS_RDONLY;
	ROOT_DEV = old_decode_dev(root_dev);
#ifdef CONFIG_BLK_DEV_INITRD
	rd_image_start = ram_flags & RAMDISK_IMAGE_START_MASK;
	rd_prompt = ((ram_flags & RAMDISK_PROMPT_FLAG) != 0);
	rd_doload = ((ram_flags & RAMDISK_LOAD_FLAG) != 0);	
#endif

	task_thread_info(&init_task)->kregs = &fake_swapper_regs;

#ifdef CONFIG_IP_PNP
	if (!ic_set_manually) {
		int chosen = prom_finddevice ("/chosen");
		u32 cl, sv, gw;
		
		cl = prom_getintdefault (chosen, "client-ip", 0);
		sv = prom_getintdefault (chosen, "server-ip", 0);
		gw = prom_getintdefault (chosen, "gateway-ip", 0);
		if (cl && sv) {
			ic_myaddr = cl;
			ic_servaddr = sv;
			if (gw)
				ic_gateway = gw;
#if defined(CONFIG_IP_PNP_BOOTP) || defined(CONFIG_IP_PNP_RARP)
			ic_proto_enabled = 0;
#endif
		}
	}
#endif

	smp_setup_cpu_possible_map();

	paging_init();
}

static int __init set_preferred_console(void)
{
	int idev, odev;

	/* The user has requested a console so this is already set up. */
	if (serial_console >= 0)
		return -EBUSY;

	idev = prom_query_input_device();
	odev = prom_query_output_device();
	if (idev == PROMDEV_IKBD && odev == PROMDEV_OSCREEN) {
		serial_console = 0;
	} else if (idev == PROMDEV_ITTYA && odev == PROMDEV_OTTYA) {
		serial_console = 1;
	} else if (idev == PROMDEV_ITTYB && odev == PROMDEV_OTTYB) {
		serial_console = 2;
	} else if (idev == PROMDEV_IRSC && odev == PROMDEV_ORSC) {
		serial_console = 3;
	} else {
		prom_printf("Inconsistent console: "
			    "input %d, output %d\n",
			    idev, odev);
		prom_halt();
	}

	if (serial_console)
		return add_preferred_console("ttyS", serial_console - 1, NULL);

	return -ENODEV;
}
console_initcall(set_preferred_console);

/* BUFFER is PAGE_SIZE bytes long. */

extern char *sparc_cpu_type;
extern char *sparc_fpu_type;

extern void smp_info(struct seq_file *);
extern void smp_bogo(struct seq_file *);
extern void mmu_info(struct seq_file *);

unsigned int dcache_parity_tl1_occurred;
unsigned int icache_parity_tl1_occurred;

static int ncpus_probed;

static int show_cpuinfo(struct seq_file *m, void *__unused)
{
	seq_printf(m, 
		   "cpu\t\t: %s\n"
		   "fpu\t\t: %s\n"
		   "promlib\t\t: Version 3 Revision %d\n"
		   "prom\t\t: %d.%d.%d\n"
		   "type\t\t: sun4u\n"
		   "ncpus probed\t: %d\n"
		   "ncpus active\t: %d\n"
		   "D$ parity tl1\t: %u\n"
		   "I$ parity tl1\t: %u\n"
#ifndef CONFIG_SMP
		   "Cpu0Bogo\t: %lu.%02lu\n"
		   "Cpu0ClkTck\t: %016lx\n"
#endif
		   ,
		   sparc_cpu_type,
		   sparc_fpu_type,
		   prom_rev,
		   prom_prev >> 16,
		   (prom_prev >> 8) & 0xff,
		   prom_prev & 0xff,
		   ncpus_probed,
		   num_online_cpus(),
		   dcache_parity_tl1_occurred,
		   icache_parity_tl1_occurred
#ifndef CONFIG_SMP
		   , cpu_data(0).udelay_val/(500000/HZ),
		   (cpu_data(0).udelay_val/(5000/HZ)) % 100,
		   cpu_data(0).clock_tick
#endif
		);
#ifdef CONFIG_SMP
	smp_bogo(m);
#endif
	mmu_info(m);
#ifdef CONFIG_SMP
	smp_info(m);
#endif
	return 0;
}

static void *c_start(struct seq_file *m, loff_t *pos)
{
	/* The pointer we are returning is arbitrary,
	 * it just has to be non-NULL and not IS_ERR
	 * in the success case.
	 */
	return *pos == 0 ? &c_start : 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)
{
}

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

extern int stop_a_enabled;

void sun_do_break(void)
{
	if (!stop_a_enabled)
		return;

	prom_printf("\n");
	flush_user_windows();

	prom_cmdline();
}

int serial_console = -1;
int stop_a_enabled = 1;

static int __init topology_init(void)
{
	int i, err;

	err = -ENOMEM;

	/* Count the number of physically present processors in
	 * the machine, even on uniprocessor, so that /proc/cpuinfo
	 * output is consistent with 2.4.x
	 */
	ncpus_probed = 0;
	while (!cpu_find_by_instance(ncpus_probed, NULL, NULL))
		ncpus_probed++;

	for (i = 0; i < NR_CPUS; i++) {
		if (cpu_possible(i)) {
			struct cpu *p = kmalloc(sizeof(*p), GFP_KERNEL);

			if (p) {
				memset(p, 0, sizeof(*p));
				register_cpu(p, i, NULL);
				err = 0;
			}
		}
	}

	return err;
}

subsys_initcall(topology_init);
Commit	Line	Data
1da177e4 LT	1	/* $Id: setup.c,v 1.72 2002/02/09 19:49:30 davem Exp $
	2	* linux/arch/sparc64/kernel/setup.c
	3	*
	4	* Copyright (C) 1995,1996 David S. Miller (davem@caip.rutgers.edu)
	5	* Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
	6	*/
	7
	8	#include <linux/errno.h>
	9	#include <linux/sched.h>
	10	#include <linux/kernel.h>
	11	#include <linux/mm.h>
	12	#include <linux/stddef.h>
	13	#include <linux/unistd.h>
	14	#include <linux/ptrace.h>
	15	#include <linux/slab.h>
	16	#include <asm/smp.h>
	17	#include <linux/user.h>
	18	#include <linux/a.out.h>
	19	#include <linux/tty.h>
	20	#include <linux/delay.h>
	21	#include <linux/config.h>
	22	#include <linux/fs.h>
	23	#include <linux/seq_file.h>
	24	#include <linux/syscalls.h>
	25	#include <linux/kdev_t.h>
	26	#include <linux/major.h>
	27	#include <linux/string.h>
	28	#include <linux/init.h>
	29	#include <linux/inet.h>
	30	#include <linux/console.h>
	31	#include <linux/root_dev.h>
	32	#include <linux/interrupt.h>
	33	#include <linux/cpu.h>
	34	#include <linux/initrd.h>
	35
1da177e4 LT	36	#include <asm/system.h>
	37	#include <asm/io.h>
	38	#include <asm/processor.h>
	39	#include <asm/oplib.h>
	40	#include <asm/page.h>
	41	#include <asm/pgtable.h>
	42	#include <asm/idprom.h>
	43	#include <asm/head.h>
	44	#include <asm/starfire.h>
	45	#include <asm/mmu_context.h>
	46	#include <asm/timer.h>
	47	#include <asm/sections.h>
	48	#include <asm/setup.h>
	49	#include <asm/mmu.h>
	50
	51	#ifdef CONFIG_IP_PNP
	52	#include <net/ipconfig.h>
	53	#endif
	54
	55	struct screen_info screen_info = {
	56	0, 0, /* orig-x, orig-y */
	57	0, /* unused */
	58	0, /* orig-video-page */
	59	0, /* orig-video-mode */
	60	128, /* orig-video-cols */
	61	0, 0, 0, /* unused, ega_bx, unused */
	62	54, /* orig-video-lines */
	63	0, /* orig-video-isVGA */
	64	16 /* orig-video-points */
	65	};
	66
	67	/* Typing sync at the prom prompt calls the function pointed to by
	68	* the sync callback which I set to the following function.
	69	* This should sync all filesystems and return, for now it just
	70	* prints out pretty messages and returns.
	71	*/
	72
	73	void (*prom_palette)(int);
	74	void (*prom_keyboard)(void);
	75
	76	static void
	77	prom_console_write(struct console con, const char s, unsigned n)
	78	{
	79	prom_write(s, n);
	80	}
	81
	82	static struct console prom_console = {
	83	.name = "prom",
	84	.write = prom_console_write,
	85	.flags = CON_CONSDEV \| CON_ENABLED,
	86	.index = -1,
	87	};
	88
	89	#define PROM_TRUE -1
	90	#define PROM_FALSE 0
	91
	92	/* Pretty sick eh? */
	93	int prom_callback(long *args)
	94	{
	95	struct console cons, saved_console = NULL;
	96	unsigned long flags;
	97	char *cmd;
	98	extern spinlock_t prom_entry_lock;
	99
100	if (!args)
101	return -1;
102	if (!(cmd = (char *)args[0]))
103	return -1;
104
105	/*
106	* The callback can be invoked on the cpu that first dropped
107	* into prom_cmdline after taking the serial interrupt, or on
108	* a slave processor that was smp_captured() if the
109	* administrator has done a switch-cpu inside obp. In either
110	* case, the cpu is marked as in-interrupt. Drop IRQ locks.
111	*/
112	irq_exit();
113
114	/* XXX Revisit the locking here someday. This is a debugging
115	* XXX feature so it isnt all that critical. -DaveM
116	*/
117	local_irq_save(flags);
118
119	spin_unlock(&prom_entry_lock);
120	cons = console_drivers;
121	while (cons) {
122	unregister_console(cons);
123	cons->flags &= ~(CON_PRINTBUFFER);
124	cons->next = saved_console;
125	saved_console = cons;
126	cons = console_drivers;
127	}
128	register_console(&prom_console);
129	if (!strcmp(cmd, "sync")) {
130	prom_printf("PROM `%s' command...\n", cmd);
131	show_free_areas();
132	if (current->pid != 0) {
133	local_irq_enable();
134	sys_sync();
135	local_irq_disable();
136	}
137	args[2] = 0;
138	args[args[1] + 3] = -1;
139	prom_printf("Returning to PROM\n");
140	} else if (!strcmp(cmd, "va>tte-data")) {
141	unsigned long ctx, va;
142	unsigned long tte = 0;
143	long res = PROM_FALSE;
144
145	ctx = args[3];
146	va = args[4];
147	if (ctx) {
148	/*
149	* Find process owning ctx, lookup mapping.
150	*/
151	struct task_struct *p;
152	struct mm_struct *mm = NULL;
153	pgd_t *pgdp;
154	pud_t *pudp;
155	pmd_t *pmdp;
156	pte_t *ptep;
b8ae4865	157	pte_t pte;
1da177e4 LT	158
	159	for_each_process(p) {
	160	mm = p->mm;
	161	if (CTX_NRBITS(mm->context) == ctx)
	162	break;
	163	}
	164	if (!mm \|\|
	165	CTX_NRBITS(mm->context) != ctx)
	166	goto done;
	167
	168	pgdp = pgd_offset(mm, va);
	169	if (pgd_none(*pgdp))
	170	goto done;
	171	pudp = pud_offset(pgdp, va);
	172	if (pud_none(*pudp))
	173	goto done;
	174	pmdp = pmd_offset(pudp, va);
	175	if (pmd_none(*pmdp))
	176	goto done;
	177
	178	/* Preemption implicitly disabled by virtue of
	179	* being called from inside OBP.
	180	*/
	181	ptep = pte_offset_map(pmdp, va);
b8ae4865 HD	182	pte = *ptep;
	183	if (pte_present(pte)) {
	184	tte = pte_val(pte);
1da177e4 LT	185	res = PROM_TRUE;
	186	}
	187	pte_unmap(ptep);
	188	goto done;
	189	}
	190
	191	if ((va >= KERNBASE) && (va < (KERNBASE + (4 * 1024 * 1024)))) {
0835ae0f	192	extern unsigned long sparc64_kern_pri_context;
1da177e4 LT	193
	194	/* Spitfire Errata #32 workaround */
	195	__asm__ __volatile__("stxa %0, [%1] %2\n\t"
	196	"flush %%g6"
	197	: /* No outputs */
0835ae0f	198	: "r" (sparc64_kern_pri_context),
1da177e4 LT	199	"r" (PRIMARY_CONTEXT),
	200	"i" (ASI_DMMU));
	201
	202	/*
	203	* Locked down tlb entry.
	204	*/
	205
	206	if (tlb_type == spitfire)
	207	tte = spitfire_get_dtlb_data(SPITFIRE_HIGHEST_LOCKED_TLBENT);
	208	else if (tlb_type == cheetah \|\| tlb_type == cheetah_plus)
	209	tte = cheetah_get_ldtlb_data(CHEETAH_HIGHEST_LOCKED_TLBENT);
	210
	211	res = PROM_TRUE;
	212	goto done;
	213	}
	214
	215	if (va < PGDIR_SIZE) {
	216	/*
	217	* vmalloc or prom_inherited mapping.
	218	*/
	219	pgd_t *pgdp;
	220	pud_t *pudp;
	221	pmd_t *pmdp;
	222	pte_t *ptep;
b8ae4865	223	pte_t pte;
1da177e4 LT	224	int error;
	225
	226	if ((va >= LOW_OBP_ADDRESS) && (va < HI_OBP_ADDRESS)) {
	227	tte = prom_virt_to_phys(va, &error);
	228	if (!error)
	229	res = PROM_TRUE;
	230	goto done;
	231	}
	232	pgdp = pgd_offset_k(va);
	233	if (pgd_none(*pgdp))
	234	goto done;
	235	pudp = pud_offset(pgdp, va);
	236	if (pud_none(*pudp))
	237	goto done;
	238	pmdp = pmd_offset(pudp, va);
	239	if (pmd_none(*pmdp))
	240	goto done;
	241
	242	/* Preemption implicitly disabled by virtue of
	243	* being called from inside OBP.
	244	*/
	245	ptep = pte_offset_kernel(pmdp, va);
b8ae4865 HD	246	pte = *ptep;
	247	if (pte_present(pte)) {
	248	tte = pte_val(pte);
1da177e4 LT	249	res = PROM_TRUE;
	250	}
	251	goto done;
	252	}
	253
	254	if (va < PAGE_OFFSET) {
	255	/*
	256	* No mappings here.
	257	*/
	258	goto done;
	259	}
	260
	261	if (va & (1UL << 40)) {
	262	/*
	263	* I/O page.
	264	*/
	265
	266	tte = (__pa(va) & _PAGE_PADDR) \|
	267	_PAGE_VALID \| _PAGE_SZ4MB \|
	268	_PAGE_E \| _PAGE_P \| _PAGE_W;
	269	res = PROM_TRUE;
	270	goto done;
	271	}
	272
	273	/*
	274	* Normal page.
	275	*/
	276	tte = (__pa(va) & _PAGE_PADDR) \|
	277	_PAGE_VALID \| _PAGE_SZ4MB \|
	278	_PAGE_CP \| _PAGE_CV \| _PAGE_P \| _PAGE_W;
	279	res = PROM_TRUE;
	280
	281	done:
	282	if (res == PROM_TRUE) {
	283	args[2] = 3;
	284	args[args[1] + 3] = 0;
	285	args[args[1] + 4] = res;
	286	args[args[1] + 5] = tte;
	287	} else {
	288	args[2] = 2;
	289	args[args[1] + 3] = 0;
	290	args[args[1] + 4] = res;
	291	}
	292	} else if (!strcmp(cmd, ".soft1")) {
	293	unsigned long tte;
	294
	295	tte = args[3];
	296	prom_printf("%lx:\"%s%s%s%s%s\" ",
	297	(tte & _PAGE_SOFT) >> 7,
	298	tte & _PAGE_MODIFIED ? "M" : "-",
	299	tte & _PAGE_ACCESSED ? "A" : "-",
	300	tte & _PAGE_READ ? "W" : "-",
	301	tte & _PAGE_WRITE ? "R" : "-",
	302	tte & _PAGE_PRESENT ? "P" : "-");
	303
	304	args[2] = 2;
	305	args[args[1] + 3] = 0;
	306	args[args[1] + 4] = PROM_TRUE;
	307	} else if (!strcmp(cmd, ".soft2")) {
	308	unsigned long tte;
	309
	310	tte = args[3];
	311	prom_printf("%lx ", (tte & 0x07FC000000000000UL) >> 50);
	312
313	args[2] = 2;
314	args[args[1] + 3] = 0;
315	args[args[1] + 4] = PROM_TRUE;
316	} else {
317	prom_printf("unknown PROM `%s' command...\n", cmd);
318	}
319	unregister_console(&prom_console);
320	while (saved_console) {
321	cons = saved_console;
322	saved_console = cons->next;
323	register_console(cons);
324	}
325	spin_lock(&prom_entry_lock);
326	local_irq_restore(flags);
327
328	/*
329	* Restore in-interrupt status for a resume from obp.
330	*/
331	irq_enter();
332	return 0;
333	}
334
335	unsigned int boot_flags = 0;
336	#define BOOTME_DEBUG 0x1
337	#define BOOTME_SINGLE 0x2
338
339	/* Exported for mm/init.c:paging_init. */
340	unsigned long cmdline_memory_size = 0;
341
342	static struct console prom_debug_console = {
343	.name = "debug",
344	.write = prom_console_write,
345	.flags = CON_PRINTBUFFER,
346	.index = -1,
347	};
348
349	/* XXX Implement this at some point... */
350	void kernel_enter_debugger(void)
351	{
352	}
353
354	int obp_system_intr(void)
355	{
356	if (boot_flags & BOOTME_DEBUG) {
357	printk("OBP: system interrupted\n");
358	prom_halt();
359	return 1;
360	}
361	return 0;
362	}
363
364	/*
365	* Process kernel command line switches that are specific to the
366	* SPARC or that require special low-level processing.
367	*/
368	static void __init process_switch(char c)
369	{
370	switch (c) {
371	case 'd':
372	boot_flags \|= BOOTME_DEBUG;
373	break;
374	case 's':
375	boot_flags \|= BOOTME_SINGLE;
376	break;
377	case 'h':
378	prom_printf("boot_flags_init: Halt!\n");
379	prom_halt();
380	break;
381	case 'p':
382	/* Use PROM debug console. */
383	register_console(&prom_debug_console);
384	break;
816242da DM	385	case 'P':
	386	/* Force UltraSPARC-III P-Cache on. */
	387	if (tlb_type != cheetah) {
	388	printk("BOOT: Ignoring P-Cache force option.\n");
	389	break;
	390	}
	391	cheetah_pcache_forced_on = 1;
	392	add_taint(TAINT_MACHINE_CHECK);
	393	cheetah_enable_pcache();
	394	break;
	395
1da177e4 LT	396	default:
	397	printk("Unknown boot switch (-%c)\n", c);
	398	break;
	399	}
	400	}
	401
	402	static void __init process_console(char *commands)
	403	{
	404	serial_console = 0;
	405	commands += 8;
	406	/* Linux-style serial */
	407	if (!strncmp(commands, "ttyS", 4))
	408	serial_console = simple_strtoul(commands + 4, NULL, 10) + 1;
	409	else if (!strncmp(commands, "tty", 3)) {
	410	char c = *(commands + 3);
	411	/* Solaris-style serial */
	412	if (c == 'a' \|\| c == 'b') {
	413	serial_console = c - 'a' + 1;
	414	prom_printf ("Using /dev/tty%c as console.\n", c);
	415	}
	416	/* else Linux-style fbcon, not serial */
	417	}
	418	#if defined(CONFIG_PROM_CONSOLE)
	419	if (!strncmp(commands, "prom", 4)) {
	420	char *p;
	421
	422	for (p = commands - 8; p && p != ' '; p++)
	423	*p = ' ';
	424	conswitchp = &prom_con;
	425	}
	426	#endif
	427	}
	428
	429	static void __init boot_flags_init(char *commands)
	430	{
	431	while (*commands) {
	432	/* Move to the start of the next "argument". */
	433	while (commands && commands == ' ')
	434	commands++;
	435
	436	/* Process any command switches, otherwise skip it. */
	437	if (*commands == '\0')
	438	break;
	439	if (*commands == '-') {
	440	commands++;
	441	while (commands && commands != ' ')
	442	process_switch(*commands++);
	443	continue;
	444	}
	445	if (!strncmp(commands, "console=", 8)) {
	446	process_console(commands);
	447	} else if (!strncmp(commands, "mem=", 4)) {
	448	/*
	449	* "mem=XXX[kKmM]" overrides the PROM-reported
	450	* memory size.
	451	*/
	452	cmdline_memory_size = simple_strtoul(commands + 4,
	453	&commands, 0);
	454	if (commands == 'K' \|\| commands == 'k') {
	455	cmdline_memory_size <<= 10;
	456	commands++;
	457	} else if (commands=='M' \|\| commands=='m') {
	458	cmdline_memory_size <<= 20;
	459	commands++;
460	}
461	}
462	while (commands && commands != ' ')
463	commands++;
464	}
465	}
466
1da177e4 LT	467	extern void panic_setup(char , int );
	468
	469	extern unsigned short root_flags;
	470	extern unsigned short root_dev;
	471	extern unsigned short ram_flags;
	472	#define RAMDISK_IMAGE_START_MASK 0x07FF
	473	#define RAMDISK_PROMPT_FLAG 0x8000
	474	#define RAMDISK_LOAD_FLAG 0x4000
	475
	476	extern int root_mountflags;
	477
	478	char reboot_command[COMMAND_LINE_SIZE];
	479
	480	static struct pt_regs fake_swapper_regs = { { 0, }, 0, 0, 0, 0 };
	481
	482	void register_prom_callbacks(void)
	483	{
	484	prom_setcallback(prom_callback);
	485	prom_feval(": linux-va>tte-data 2 \" va>tte-data\" $callback drop ; "
	486	"' linux-va>tte-data to va>tte-data");
	487	prom_feval(": linux-.soft1 1 \" .soft1\" $callback 2drop ; "
	488	"' linux-.soft1 to .soft1");
	489	prom_feval(": linux-.soft2 1 \" .soft2\" $callback 2drop ; "
	490	"' linux-.soft2 to .soft2");
	491	}
	492
1da177e4 LT	493	void __init setup_arch(char **cmdline_p)
1da177e4 LT	494	{
1da177e4 LT	495	/* Initialize PROM console and command line. */
	496	*cmdline_p = prom_getbootargs();
	497	strcpy(saved_command_line, *cmdline_p);
	498
	499	printk("ARCH: SUN4U\n");
	500
	501	#ifdef CONFIG_DUMMY_CONSOLE
	502	conswitchp = &dummy_con;
	503	#elif defined(CONFIG_PROM_CONSOLE)
	504	conswitchp = &prom_con;
	505	#endif
	506
1da177e4 LT	507	/* Work out if we are starfire early on */
	508	check_if_starfire();
	509
	510	boot_flags_init(*cmdline_p);
	511
	512	idprom_init();
1da177e4 LT	513
	514	if (!root_flags)
	515	root_mountflags &= ~MS_RDONLY;
	516	ROOT_DEV = old_decode_dev(root_dev);
	517	#ifdef CONFIG_BLK_DEV_INITRD
	518	rd_image_start = ram_flags & RAMDISK_IMAGE_START_MASK;
	519	rd_prompt = ((ram_flags & RAMDISK_PROMPT_FLAG) != 0);
	520	rd_doload = ((ram_flags & RAMDISK_LOAD_FLAG) != 0);
	521	#endif
	522
f3169641	523	task_thread_info(&init_task)->kregs = &fake_swapper_regs;
1da177e4 LT	524
	525	#ifdef CONFIG_IP_PNP
	526	if (!ic_set_manually) {
	527	int chosen = prom_finddevice ("/chosen");
	528	u32 cl, sv, gw;
	529
	530	cl = prom_getintdefault (chosen, "client-ip", 0);
	531	sv = prom_getintdefault (chosen, "server-ip", 0);
	532	gw = prom_getintdefault (chosen, "gateway-ip", 0);
	533	if (cl && sv) {
	534	ic_myaddr = cl;
	535	ic_servaddr = sv;
	536	if (gw)
	537	ic_gateway = gw;
	538	#if defined(CONFIG_IP_PNP_BOOTP) \|\| defined(CONFIG_IP_PNP_RARP)
	539	ic_proto_enabled = 0;
	540	#endif
	541	}
	542	}
	543	#endif
	544
7abea921 DM	545	smp_setup_cpu_possible_map();
7abea921 DM	546
1da177e4 LT	547	paging_init();
	548	}
	549
	550	static int __init set_preferred_console(void)
	551	{
	552	int idev, odev;
	553
	554	/* The user has requested a console so this is already set up. */
	555	if (serial_console >= 0)
	556	return -EBUSY;
	557
	558	idev = prom_query_input_device();
	559	odev = prom_query_output_device();
	560	if (idev == PROMDEV_IKBD && odev == PROMDEV_OSCREEN) {
	561	serial_console = 0;
	562	} else if (idev == PROMDEV_ITTYA && odev == PROMDEV_OTTYA) {
	563	serial_console = 1;
	564	} else if (idev == PROMDEV_ITTYB && odev == PROMDEV_OTTYB) {
	565	serial_console = 2;
c126cf80 ED	566	} else if (idev == PROMDEV_IRSC && odev == PROMDEV_ORSC) {
c126cf80 ED	567	serial_console = 3;
1da177e4 LT	568	} else {
	569	prom_printf("Inconsistent console: "
	570	"input %d, output %d\n",
	571	idev, odev);
	572	prom_halt();
	573	}
	574
	575	if (serial_console)
	576	return add_preferred_console("ttyS", serial_console - 1, NULL);
	577
	578	return -ENODEV;
	579	}
	580	console_initcall(set_preferred_console);
	581
	582	/* BUFFER is PAGE_SIZE bytes long. */
	583
	584	extern char *sparc_cpu_type;
	585	extern char *sparc_fpu_type;
	586
	587	extern void smp_info(struct seq_file *);
	588	extern void smp_bogo(struct seq_file *);
	589	extern void mmu_info(struct seq_file *);
	590
80dc0d6b DM	591	unsigned int dcache_parity_tl1_occurred;
	592	unsigned int icache_parity_tl1_occurred;
	593
4d45cbac DM	594	static int ncpus_probed;
4d45cbac DM	595
1da177e4 LT	596	static int show_cpuinfo(struct seq_file m, void __unused)
	597	{
	598	seq_printf(m,
	599	"cpu\t\t: %s\n"
	600	"fpu\t\t: %s\n"
	601	"promlib\t\t: Version 3 Revision %d\n"
	602	"prom\t\t: %d.%d.%d\n"
	603	"type\t\t: sun4u\n"
4d45cbac DM	604	"ncpus probed\t: %d\n"
4d45cbac DM	605	"ncpus active\t: %d\n"
80dc0d6b DM	606	"D$ parity tl1\t: %u\n"
80dc0d6b DM	607	"I$ parity tl1\t: %u\n"
1da177e4 LT	608	#ifndef CONFIG_SMP
	609	"Cpu0Bogo\t: %lu.%02lu\n"
	610	"Cpu0ClkTck\t: %016lx\n"
	611	#endif
	612	,
	613	sparc_cpu_type,
	614	sparc_fpu_type,
	615	prom_rev,
	616	prom_prev >> 16,
	617	(prom_prev >> 8) & 0xff,
	618	prom_prev & 0xff,
4d45cbac DM	619	ncpus_probed,
4d45cbac DM	620	num_online_cpus(),
80dc0d6b DM	621	dcache_parity_tl1_occurred,
80dc0d6b DM	622	icache_parity_tl1_occurred
1da177e4 LT	623	#ifndef CONFIG_SMP
	624	, cpu_data(0).udelay_val/(500000/HZ),
	625	(cpu_data(0).udelay_val/(5000/HZ)) % 100,
	626	cpu_data(0).clock_tick
	627	#endif
	628	);
	629	#ifdef CONFIG_SMP
	630	smp_bogo(m);
	631	#endif
	632	mmu_info(m);
	633	#ifdef CONFIG_SMP
	634	smp_info(m);
	635	#endif
	636	return 0;
	637	}
	638
	639	static void c_start(struct seq_file m, loff_t *pos)
	640	{
	641	/* The pointer we are returning is arbitrary,
	642	* it just has to be non-NULL and not IS_ERR
	643	* in the success case.
	644	*/
	645	return *pos == 0 ? &c_start : NULL;
	646	}
	647
	648	static void c_next(struct seq_file m, void v, loff_t pos)
	649	{
	650	++*pos;
	651	return c_start(m, pos);
	652	}
	653
	654	static void c_stop(struct seq_file m, void v)
	655	{
	656	}
	657
	658	struct seq_operations cpuinfo_op = {
	659	.start =c_start,
	660	.next = c_next,
	661	.stop = c_stop,
	662	.show = show_cpuinfo,
	663	};
	664
	665	extern int stop_a_enabled;
	666
	667	void sun_do_break(void)
	668	{
	669	if (!stop_a_enabled)
	670	return;
	671
	672	prom_printf("\n");
	673	flush_user_windows();
	674
	675	prom_cmdline();
	676	}
	677
	678	int serial_console = -1;
	679	int stop_a_enabled = 1;
	680
	681	static int __init topology_init(void)
	682	{
	683	int i, err;
	684
	685	err = -ENOMEM;
4d45cbac DM	686
	687	/* Count the number of physically present processors in
	688	* the machine, even on uniprocessor, so that /proc/cpuinfo
	689	* output is consistent with 2.4.x
	690	*/
	691	ncpus_probed = 0;
	692	while (!cpu_find_by_instance(ncpus_probed, NULL, NULL))
	693	ncpus_probed++;
	694
1da177e4 LT	695	for (i = 0; i < NR_CPUS; i++) {
	696	if (cpu_possible(i)) {
	697	struct cpu p = kmalloc(sizeof(p), GFP_KERNEL);
	698
	699	if (p) {
	700	memset(p, 0, sizeof(*p));
	701	register_cpu(p, i, NULL);
	702	err = 0;
	703	}
	704	}
	705	}
	706
	707	return err;
	708	}
	709
	710	subsys_initcall(topology_init);