Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit fca5dcd4835ed09bb1a48a355344aff7a25c76e0

Authored by Paul Mackerras 2005-11-08 19:55:08 +0800

Exists in master and in 7 other branches

powerpc: Simplify and clean up the xmon terminal I/O

This factors out the common bits of arch/powerpc/xmon/start_*.c into
a new nonstdio.c, and removes some stuff that was supposed to make
xmon's I/O routines somewhat stdio-like but was never used.

It also makes the parsing of the xmon= command line option common,
so that ppc32 can now use xmon={off,on,early} also.

Signed-off-by: Paul Mackerras <paulus@samba.org>

Showing 12 changed files with 236 additions and 729 deletions Inline Diff

arch/powerpc/kernel/setup-common.c
arch/powerpc/kernel/setup_32.c
arch/powerpc/kernel/setup_64.c
arch/powerpc/xmon/Makefile
arch/powerpc/xmon/nonstdio.c
arch/powerpc/xmon/nonstdio.h
arch/powerpc/xmon/start_32.c
arch/powerpc/xmon/start_64.c
arch/powerpc/xmon/start_8xx.c
arch/powerpc/xmon/subr_prf.c
arch/powerpc/xmon/xmon.c
include/asm-powerpc/xmon.h

arch/powerpc/kernel/setup-common.c

Diff comments View file @ fca5dcd

 /*
  * Common boot and setup code for both 32-bit and 64-bit.
  * Extracted from arch/powerpc/kernel/setup_64.c.
  *
  * Copyright (C) 2001 PPC64 Team, IBM Corp
  *
  *      This program is free software; you can redistribute it and/or
  *      modify it under the terms of the GNU General Public License
  *      as published by the Free Software Foundation; either version
  *      2 of the License, or (at your option) any later version.
  */
 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/string.h>
 #include <linux/sched.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/reboot.h>
 #include <linux/delay.h>
 #include <linux/initrd.h>
 #include <linux/ide.h>
 #include <linux/seq_file.h>
 #include <linux/ioport.h>
 #include <linux/console.h>
 #include <linux/utsname.h>
 #include <linux/tty.h>
 #include <linux/root_dev.h>
 #include <linux/notifier.h>
 #include <linux/cpu.h>
 #include <linux/unistd.h>
 #include <linux/serial.h>
 #include <linux/serial_8250.h>
 #include <asm/io.h>
 #include <asm/prom.h>
 #include <asm/processor.h>
 #include <asm/pgtable.h>
 #include <asm/smp.h>
 #include <asm/elf.h>
 #include <asm/machdep.h>
 #include <asm/time.h>
 #include <asm/cputable.h>
 #include <asm/sections.h>
 #include <asm/btext.h>
 #include <asm/nvram.h>
 #include <asm/setup.h>
 #include <asm/system.h>
 #include <asm/rtas.h>
 #include <asm/iommu.h>
 #include <asm/serial.h>
 #include <asm/cache.h>
 #include <asm/page.h>
 #include <asm/mmu.h>
 #include <asm/lmb.h>
+#include <asm/xmon.h>
 #undef DEBUG
 #ifdef DEBUG
 #define DBG(fmt...) udbg_printf(fmt)
 #else
 #define DBG(fmt...)
 #endif
 /*
  * This still seems to be needed... -- paulus
  */
 struct screen_info screen_info = {
 	.orig_x = 0,
 	.orig_y = 25,
 	.orig_video_cols = 80,
 	.orig_video_lines = 25,
 	.orig_video_isVGA = 1,
 	.orig_video_points = 16
 };
 #ifdef __DO_IRQ_CANON
 /* XXX should go elsewhere eventually */
 int ppc_do_canonicalize_irqs;
 EXPORT_SYMBOL(ppc_do_canonicalize_irqs);
 #endif
 /* also used by kexec */
 void machine_shutdown(void)
 {
 	if (ppc_md.nvram_sync)
 		ppc_md.nvram_sync();
 }
 void machine_restart(char *cmd)
 {
 	machine_shutdown();
 	ppc_md.restart(cmd);
 #ifdef CONFIG_SMP
 	smp_send_stop();
 #endif
 	printk(KERN_EMERG "System Halted, OK to turn off power\n");
 	local_irq_disable();
 	while (1) ;
 }
 void machine_power_off(void)
 {
 	machine_shutdown();
 	ppc_md.power_off();
 #ifdef CONFIG_SMP
 	smp_send_stop();
 #endif
 	printk(KERN_EMERG "System Halted, OK to turn off power\n");
 	local_irq_disable();
 	while (1) ;
 }
 /* Used by the G5 thermal driver */
 EXPORT_SYMBOL_GPL(machine_power_off);
 void (*pm_power_off)(void) = machine_power_off;
 EXPORT_SYMBOL_GPL(pm_power_off);
 void machine_halt(void)
 {
 	machine_shutdown();
 	ppc_md.halt();
 #ifdef CONFIG_SMP
 	smp_send_stop();
 #endif
 	printk(KERN_EMERG "System Halted, OK to turn off power\n");
 	local_irq_disable();
 	while (1) ;
 }
 #ifdef CONFIG_TAU
 extern u32 cpu_temp(unsigned long cpu);
 extern u32 cpu_temp_both(unsigned long cpu);
 #endif /* CONFIG_TAU */
 #ifdef CONFIG_SMP
 DEFINE_PER_CPU(unsigned int, pvr);
 #endif
 static int show_cpuinfo(struct seq_file *m, void *v)
 {
 	unsigned long cpu_id = (unsigned long)v - 1;
 	unsigned int pvr;
 	unsigned short maj;
 	unsigned short min;
 	if (cpu_id == NR_CPUS) {
 #if defined(CONFIG_SMP) && defined(CONFIG_PPC32)
 		unsigned long bogosum = 0;
 		int i;
 		for (i = 0; i < NR_CPUS; ++i)
 			if (cpu_online(i))
 				bogosum += loops_per_jiffy;
 		seq_printf(m, "total bogomips\t: %lu.%02lu\n",
 			   bogosum/(500000/HZ), bogosum/(5000/HZ) % 100);
 #endif /* CONFIG_SMP && CONFIG_PPC32 */
 		seq_printf(m, "timebase\t: %lu\n", ppc_tb_freq);
 		if (ppc_md.show_cpuinfo != NULL)
 			ppc_md.show_cpuinfo(m);
 		return 0;
 	}
 	/* We only show online cpus: disable preempt (overzealous, I
 	 * knew) to prevent cpu going down. */
 	preempt_disable();
 	if (!cpu_online(cpu_id)) {
 		preempt_enable();
 		return 0;
 	}
 #ifdef CONFIG_SMP
 	pvr = per_cpu(pvr, cpu_id);
 #else
 	pvr = mfspr(SPRN_PVR);
 #endif
 	maj = (pvr >> 8) & 0xFF;
 	min = pvr & 0xFF;
 	seq_printf(m, "processor\t: %lu\n", cpu_id);
 	seq_printf(m, "cpu\t\t: ");
 	if (cur_cpu_spec->pvr_mask)
 		seq_printf(m, "%s", cur_cpu_spec->cpu_name);
 	else
 		seq_printf(m, "unknown (%08x)", pvr);
 #ifdef CONFIG_ALTIVEC
 	if (cpu_has_feature(CPU_FTR_ALTIVEC))
 		seq_printf(m, ", altivec supported");
 #endif /* CONFIG_ALTIVEC */
 	seq_printf(m, "\n");
 #ifdef CONFIG_TAU
 	if (cur_cpu_spec->cpu_features & CPU_FTR_TAU) {
 #ifdef CONFIG_TAU_AVERAGE
 		/* more straightforward, but potentially misleading */
 		seq_printf(m,  "temperature \t: %u C (uncalibrated)\n",
 			   cpu_temp(cpu_id));
 #else
 		/* show the actual temp sensor range */
 		u32 temp;
 		temp = cpu_temp_both(cpu_id);
 		seq_printf(m, "temperature \t: %u-%u C (uncalibrated)\n",
 			   temp & 0xff, temp >> 16);
 #endif
 	}
 #endif /* CONFIG_TAU */
 	/*
 	 * Assume here that all clock rates are the same in a
 	 * smp system.  -- Cort
 	 */
 	if (ppc_proc_freq)
 		seq_printf(m, "clock\t\t: %lu.%06luMHz\n",
 			   ppc_proc_freq / 1000000, ppc_proc_freq % 1000000);
 	if (ppc_md.show_percpuinfo != NULL)
 		ppc_md.show_percpuinfo(m, cpu_id);
 	/* If we are a Freescale core do a simple check so
 	 * we dont have to keep adding cases in the future */
 	if (PVR_VER(pvr) & 0x8000) {
 		maj = PVR_MAJ(pvr);
 		min = PVR_MIN(pvr);
 	} else {
 		switch (PVR_VER(pvr)) {
 			case 0x0020:	/* 403 family */
 				maj = PVR_MAJ(pvr) + 1;
 				min = PVR_MIN(pvr);
 				break;
 			case 0x1008:	/* 740P/750P ?? */
 				maj = ((pvr >> 8) & 0xFF) - 1;
 				min = pvr & 0xFF;
 				break;
 			default:
 				maj = (pvr >> 8) & 0xFF;
 				min = pvr & 0xFF;
 				break;
 		}
 	}
 	seq_printf(m, "revision\t: %hd.%hd (pvr %04x %04x)\n",
 		   maj, min, PVR_VER(pvr), PVR_REV(pvr));
 #ifdef CONFIG_PPC32
 	seq_printf(m, "bogomips\t: %lu.%02lu\n",
 		   loops_per_jiffy / (500000/HZ),
 		   (loops_per_jiffy / (5000/HZ)) % 100);
 #endif
 #ifdef CONFIG_SMP
 	seq_printf(m, "\n");
 #endif
 	preempt_enable();
 	return 0;
 }
 static void *c_start(struct seq_file *m, loff_t *pos)
 {
 	unsigned long i = *pos;
 	return i <= NR_CPUS ? (void *)(i + 1) : 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,
 };
 #ifdef CONFIG_PPC_MULTIPLATFORM
 static int __init set_preferred_console(void)
 {
 	struct device_node *prom_stdout = NULL;
 	char *name;
 	u32 *spd;
 	int offset = 0;
 	DBG(" -> set_preferred_console()\n");
 	/* The user has requested a console so this is already set up. */
 	if (strstr(saved_command_line, "console=")) {
 		DBG(" console was specified !\n");
 		return -EBUSY;
 	}
 	if (!of_chosen) {
 		DBG(" of_chosen is NULL !\n");
 		return -ENODEV;
 	}
 	/* We are getting a weird phandle from OF ... */
 	/* ... So use the full path instead */
 	name = (char *)get_property(of_chosen, "linux,stdout-path", NULL);
 	if (name == NULL) {
 		DBG(" no linux,stdout-path !\n");
 		return -ENODEV;
 	}
 	prom_stdout = of_find_node_by_path(name);
 	if (!prom_stdout) {
 		DBG(" can't find stdout package %s !\n", name);
 		return -ENODEV;
 	}
 	DBG("stdout is %s\n", prom_stdout->full_name);
 	name = (char *)get_property(prom_stdout, "name", NULL);
 	if (!name) {
 		DBG(" stdout package has no name !\n");
 		goto not_found;
 	}
 	spd = (u32 *)get_property(prom_stdout, "current-speed", NULL);
 	if (0)
 		;
 #ifdef CONFIG_SERIAL_8250_CONSOLE
 	else if (strcmp(name, "serial") == 0) {
 		int i;
 		u32 *reg = (u32 *)get_property(prom_stdout, "reg", &i);
 		if (i > 8) {
 			switch (reg[1]) {
 				case 0x3f8:
 					offset = 0;
 					break;
 				case 0x2f8:
 					offset = 1;
 					break;
 				case 0x898:
 					offset = 2;
 					break;
 				case 0x890:
 					offset = 3;
 					break;
 				default:
 					/* We dont recognise the serial port */
 					goto not_found;
 			}
 		}
 	}
 #endif /* CONFIG_SERIAL_8250_CONSOLE */
 #ifdef CONFIG_PPC_PSERIES
 	else if (strcmp(name, "vty") == 0) {
  		u32 *reg = (u32 *)get_property(prom_stdout, "reg", NULL);
  		char *compat = (char *)get_property(prom_stdout, "compatible", NULL);
  		if (reg && compat && (strcmp(compat, "hvterm-protocol") == 0)) {
  			/* Host Virtual Serial Interface */
  			switch (reg[0]) {
  				case 0x30000000:
  					offset = 0;
  					break;
  				case 0x30000001:
  					offset = 1;
  					break;
  				default:
 					goto not_found;
  			}
 			of_node_put(prom_stdout);
 			DBG("Found hvsi console at offset %d\n", offset);
  			return add_preferred_console("hvsi", offset, NULL);
  		} else {
  			/* pSeries LPAR virtual console */
 			of_node_put(prom_stdout);
 			DBG("Found hvc console\n");
  			return add_preferred_console("hvc", 0, NULL);
  		}
 	}
 #endif /* CONFIG_PPC_PSERIES */
 #ifdef CONFIG_SERIAL_PMACZILOG_CONSOLE
 	else if (strcmp(name, "ch-a") == 0)
 		offset = 0;
 	else if (strcmp(name, "ch-b") == 0)
 		offset = 1;
 #endif /* CONFIG_SERIAL_PMACZILOG_CONSOLE */
 	else
 		goto not_found;
 	of_node_put(prom_stdout);
 	DBG("Found serial console at ttyS%d\n", offset);
 	if (spd) {
 		static char __initdata opt[16];
 		sprintf(opt, "%d", *spd);
 		return add_preferred_console("ttyS", offset, opt);
 	} else
 		return add_preferred_console("ttyS", offset, NULL);
  not_found:
 	DBG("No preferred console found !\n");
 	of_node_put(prom_stdout);
 	return -ENODEV;
 }
 console_initcall(set_preferred_console);
 #endif /* CONFIG_PPC_MULTIPLATFORM */
 void __init check_for_initrd(void)
 {
 #ifdef CONFIG_BLK_DEV_INITRD
 	unsigned long *prop;
 	DBG(" -> check_for_initrd()\n");
 	if (of_chosen) {
 		prop = (unsigned long *)get_property(of_chosen,
 				"linux,initrd-start", NULL);
 		if (prop != NULL) {
 			initrd_start = (unsigned long)__va(*prop);
 			prop = (unsigned long *)get_property(of_chosen,
 					"linux,initrd-end", NULL);
 			if (prop != NULL) {
 				initrd_end = (unsigned long)__va(*prop);
 				initrd_below_start_ok = 1;
 			} else
 				initrd_start = 0;
 		}
 	}
 	/* If we were passed an initrd, set the ROOT_DEV properly if the values
 	 * look sensible. If not, clear initrd reference.
 	 */
 	if (initrd_start >= KERNELBASE && initrd_end >= KERNELBASE &&
 	    initrd_end > initrd_start)
 		ROOT_DEV = Root_RAM0;
 	else {
 		printk("Bogus initrd %08lx %08lx\n", initrd_start, initrd_end);
 		initrd_start = initrd_end = 0;
 	}
 	if (initrd_start)
 		printk("Found initrd at 0x%lx:0x%lx\n", initrd_start, initrd_end);
 	DBG(" <- check_for_initrd()\n");
 #endif /* CONFIG_BLK_DEV_INITRD */
 }
 #ifdef CONFIG_SMP
 /**
  * setup_cpu_maps - initialize the following cpu maps:
  *                  cpu_possible_map
  *                  cpu_present_map
  *                  cpu_sibling_map
  *
  * Having the possible map set up early allows us to restrict allocations
  * of things like irqstacks to num_possible_cpus() rather than NR_CPUS.
  *
  * We do not initialize the online map here; cpus set their own bits in
  * cpu_online_map as they come up.
  *
  * This function is valid only for Open Firmware systems.  finish_device_tree
  * must be called before using this.
  *
  * While we're here, we may as well set the "physical" cpu ids in the paca.
  */
 void __init smp_setup_cpu_maps(void)
 {
 	struct device_node *dn = NULL;
 	int cpu = 0;
 	int swap_cpuid = 0;
 	while ((dn = of_find_node_by_type(dn, "cpu")) && cpu < NR_CPUS) {
 		int *intserv;
 		int j, len = sizeof(u32), nthreads = 1;
 		intserv = (int *)get_property(dn, "ibm,ppc-interrupt-server#s",
 					      &len);
 		if (intserv)
 			nthreads = len / sizeof(int);
 		else {
 			intserv = (int *) get_property(dn, "reg", NULL);
 			if (!intserv)
 				intserv = &cpu;	/* assume logical == phys */
 		}
 		for (j = 0; j < nthreads && cpu < NR_CPUS; j++) {
 			cpu_set(cpu, cpu_present_map);
 			set_hard_smp_processor_id(cpu, intserv[j]);
 			if (intserv[j] == boot_cpuid_phys)
 				swap_cpuid = cpu;
 			cpu_set(cpu, cpu_possible_map);
 			cpu++;
 		}
 	}
 	/* Swap CPU id 0 with boot_cpuid_phys, so we can always assume that
 	 * boot cpu is logical 0.
 	 */
 	if (boot_cpuid_phys != get_hard_smp_processor_id(0)) {
 		u32 tmp;
 		tmp = get_hard_smp_processor_id(0);
 		set_hard_smp_processor_id(0, boot_cpuid_phys);
 		set_hard_smp_processor_id(swap_cpuid, tmp);
 	}
 #ifdef CONFIG_PPC64
 	/*
 	 * On pSeries LPAR, we need to know how many cpus
 	 * could possibly be added to this partition.
 	 */
 	if (systemcfg->platform == PLATFORM_PSERIES_LPAR &&
 				(dn = of_find_node_by_path("/rtas"))) {
 		int num_addr_cell, num_size_cell, maxcpus;
 		unsigned int *ireg;
 		num_addr_cell = prom_n_addr_cells(dn);
 		num_size_cell = prom_n_size_cells(dn);
 		ireg = (unsigned int *)
 			get_property(dn, "ibm,lrdr-capacity", NULL);
 		if (!ireg)
 			goto out;
 		maxcpus = ireg[num_addr_cell + num_size_cell];
 		/* Double maxcpus for processors which have SMT capability */
 		if (cpu_has_feature(CPU_FTR_SMT))
 			maxcpus *= 2;
 		if (maxcpus > NR_CPUS) {
 			printk(KERN_WARNING
 			       "Partition configured for %d cpus, "
 			       "operating system maximum is %d.\n",
 			       maxcpus, NR_CPUS);
 			maxcpus = NR_CPUS;
 		} else
 			printk(KERN_INFO "Partition configured for %d cpus.\n",
 			       maxcpus);
 		for (cpu = 0; cpu < maxcpus; cpu++)
 			cpu_set(cpu, cpu_possible_map);
 	out:
 		of_node_put(dn);
 	}
 	/*
 	 * Do the sibling map; assume only two threads per processor.
 	 */
 	for_each_cpu(cpu) {
 		cpu_set(cpu, cpu_sibling_map[cpu]);
 		if (cpu_has_feature(CPU_FTR_SMT))
 			cpu_set(cpu ^ 0x1, cpu_sibling_map[cpu]);
 	}
 	systemcfg->processorCount = num_present_cpus();
 #endif /* CONFIG_PPC64 */
 }
 #endif /* CONFIG_SMP */
+#ifdef CONFIG_XMON
+static int __init early_xmon(char *p)
+{
+	/* ensure xmon is enabled */
+	if (p) {
+		if (strncmp(p, "on", 2) == 0)
+			xmon_init(1);
+		if (strncmp(p, "off", 3) == 0)
+			xmon_init(0);
+		if (strncmp(p, "early", 5) != 0)
+			return 0;
+	}
+	xmon_init(1);
+	debugger(NULL);
+	return 0;
+}
+early_param("xmon", early_xmon);
+#endif

arch/powerpc/kernel/setup_32.c

Diff comments View file @ fca5dcd

 /*
  * Common prep/pmac/chrp boot and setup code.
  */
 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/string.h>
 #include <linux/sched.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/reboot.h>
 #include <linux/delay.h>
 #include <linux/initrd.h>
 #include <linux/ide.h>
 #include <linux/tty.h>
 #include <linux/bootmem.h>
 #include <linux/seq_file.h>
 #include <linux/root_dev.h>
 #include <linux/cpu.h>
 #include <linux/console.h>
 #include <asm/residual.h>
 #include <asm/io.h>
 #include <asm/prom.h>
 #include <asm/processor.h>
 #include <asm/pgtable.h>
 #include <asm/setup.h>
 #include <asm/amigappc.h>
 #include <asm/smp.h>
 #include <asm/elf.h>
 #include <asm/cputable.h>
 #include <asm/bootx.h>
 #include <asm/btext.h>
 #include <asm/machdep.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <asm/pmac_feature.h>
 #include <asm/sections.h>
 #include <asm/nvram.h>
 #include <asm/xmon.h>
 #include <asm/time.h>
 #define DBG(fmt...)
 #if defined CONFIG_KGDB
 #include <asm/kgdb.h>
 #endif
 extern void platform_init(void);
 extern void bootx_init(unsigned long r4, unsigned long phys);
 extern void ppc6xx_idle(void);
 extern void power4_idle(void);
 boot_infos_t *boot_infos;
 struct ide_machdep_calls ppc_ide_md;
 /* XXX should go elsewhere */
 int __irq_offset_value;
 EXPORT_SYMBOL(__irq_offset_value);
 int boot_cpuid;
 EXPORT_SYMBOL_GPL(boot_cpuid);
 int boot_cpuid_phys;
 unsigned long ISA_DMA_THRESHOLD;
 unsigned int DMA_MODE_READ;
 unsigned int DMA_MODE_WRITE;
 int have_of = 1;
 #ifdef CONFIG_PPC_MULTIPLATFORM
 int _machine = 0;
 extern void prep_init(void);
 extern void pmac_init(void);
 extern void chrp_init(void);
 dev_t boot_dev;
 #endif /* CONFIG_PPC_MULTIPLATFORM */
 #ifdef CONFIG_MAGIC_SYSRQ
 unsigned long SYSRQ_KEY = 0x54;
 #endif /* CONFIG_MAGIC_SYSRQ */
 #ifdef CONFIG_VGA_CONSOLE
 unsigned long vgacon_remap_base;
 #endif
 struct machdep_calls ppc_md;
 EXPORT_SYMBOL(ppc_md);
 /*
  * These are used in binfmt_elf.c to put aux entries on the stack
  * for each elf executable being started.
  */
 int dcache_bsize;
 int icache_bsize;
 int ucache_bsize;
 /*
  * We're called here very early in the boot.  We determine the machine
  * type and call the appropriate low-level setup functions.
  *  -- Cort <cort@fsmlabs.com>
  *
  * Note that the kernel may be running at an address which is different
  * from the address that it was linked at, so we must use RELOC/PTRRELOC
  * to access static data (including strings).  -- paulus
  */
 unsigned long __init early_init(unsigned long dt_ptr)
 {
 	unsigned long offset = reloc_offset();
 	/* First zero the BSS -- use memset_io, some platforms don't have
 	 * caches on yet */
 	memset_io(PTRRELOC(&__bss_start), 0, _end - __bss_start);
 	/*
 	 * Identify the CPU type and fix up code sections
 	 * that depend on which cpu we have.
 	 */
 	identify_cpu(offset, 0);
 	do_cpu_ftr_fixups(offset);
 	return KERNELBASE + offset;
 }
 #ifdef CONFIG_PPC_MULTIPLATFORM
 /*
  * The PPC_MULTIPLATFORM version of platform_init...
  */
 void __init platform_init(void)
 {
 	/* if we didn't get any bootinfo telling us what we are... */
 	if (_machine == 0) {
 		/* prep boot loader tells us if we're prep or not */
 		if ( *(unsigned long *)(KERNELBASE) == (0xdeadc0de) )
 			_machine = _MACH_prep;
 	}
 #ifdef CONFIG_PPC_PREP
 	/* not much more to do here, if prep */
 	if (_machine == _MACH_prep) {
 		prep_init();
 		return;
 	}
 #endif
 #ifdef CONFIG_ADB
 	if (strstr(cmd_line, "adb_sync")) {
 		extern int __adb_probe_sync;
 		__adb_probe_sync = 1;
 	}
 #endif /* CONFIG_ADB */
 	switch (_machine) {
 #ifdef CONFIG_PPC_PMAC
 	case _MACH_Pmac:
 		pmac_init();
 		break;
 #endif
 #ifdef CONFIG_PPC_CHRP
 	case _MACH_chrp:
 		chrp_init();
 		break;
 #endif
 	}
 }
 #endif
 /*
  * Find out what kind of machine we're on and save any data we need
  * from the early boot process (devtree is copied on pmac by prom_init()).
  * This is called very early on the boot process, after a minimal
  * MMU environment has been set up but before MMU_init is called.
  */
 void __init machine_init(unsigned long dt_ptr, unsigned long phys)
 {
 	early_init_devtree(__va(dt_ptr));
 #ifdef CONFIG_CMDLINE
 	strlcpy(cmd_line, CONFIG_CMDLINE, sizeof(cmd_line));
 #endif /* CONFIG_CMDLINE */
 	platform_init();
 #ifdef CONFIG_6xx
 	ppc_md.power_save = ppc6xx_idle;
 #endif
 	if (ppc_md.progress)
 		ppc_md.progress("id mach(): done", 0x200);
 }
 #ifdef CONFIG_BOOKE_WDT
 /* Checks wdt=x and wdt_period=xx command-line option */
 int __init early_parse_wdt(char *p)
 {
 	if (p && strncmp(p, "0", 1) != 0)
 	       booke_wdt_enabled = 1;
 	return 0;
 }
 early_param("wdt", early_parse_wdt);
 int __init early_parse_wdt_period (char *p)
 {
 	if (p)
 		booke_wdt_period = simple_strtoul(p, NULL, 0);
 	return 0;
 }
 early_param("wdt_period", early_parse_wdt_period);
 #endif	/* CONFIG_BOOKE_WDT */
 /* Checks "l2cr=xxxx" command-line option */
 int __init ppc_setup_l2cr(char *str)
 {
 	if (cpu_has_feature(CPU_FTR_L2CR)) {
 		unsigned long val = simple_strtoul(str, NULL, 0);
 		printk(KERN_INFO "l2cr set to %lx\n", val);
 		_set_L2CR(0);		/* force invalidate by disable cache */
 		_set_L2CR(val);		/* and enable it */
 	}
 	return 1;
 }
 __setup("l2cr=", ppc_setup_l2cr);
 #ifdef CONFIG_GENERIC_NVRAM
 /* Generic nvram hooks used by drivers/char/gen_nvram.c */
 unsigned char nvram_read_byte(int addr)
 {
 	if (ppc_md.nvram_read_val)
 		return ppc_md.nvram_read_val(addr);
 	return 0xff;
 }
 EXPORT_SYMBOL(nvram_read_byte);
 void nvram_write_byte(unsigned char val, int addr)
 {
 	if (ppc_md.nvram_write_val)
 		ppc_md.nvram_write_val(addr, val);
 }
 EXPORT_SYMBOL(nvram_write_byte);
 void nvram_sync(void)
 {
 	if (ppc_md.nvram_sync)
 		ppc_md.nvram_sync();
 }
 EXPORT_SYMBOL(nvram_sync);
 #endif /* CONFIG_NVRAM */
 static struct cpu cpu_devices[NR_CPUS];
 int __init ppc_init(void)
 {
 	int i;
 	/* clear the progress line */
 	if ( ppc_md.progress ) ppc_md.progress("             ", 0xffff);
 	/* register CPU devices */
 	for (i = 0; i < NR_CPUS; i++)
 		if (cpu_possible(i))
 			register_cpu(&cpu_devices[i], i, NULL);
 	/* call platform init */
 	if (ppc_md.init != NULL) {
 		ppc_md.init();
 	}
 	return 0;
 }
 arch_initcall(ppc_init);
 /* Warning, IO base is not yet inited */
 void __init setup_arch(char **cmdline_p)
 {
 	extern char *klimit;
 	extern void do_init_bootmem(void);
 	/* so udelay does something sensible, assume <= 1000 bogomips */
 	loops_per_jiffy = 500000000 / HZ;
 	unflatten_device_tree();
 	check_for_initrd();
 	finish_device_tree();
 	smp_setup_cpu_maps();
 #ifdef CONFIG_BOOTX_TEXT
 	init_boot_display();
 #endif
 #ifdef CONFIG_PPC_PMAC
 	/* This could be called "early setup arch", it must be done
 	 * now because xmon need it
 	 */
 	if (_machine == _MACH_Pmac)
 		pmac_feature_init();	/* New cool way */
 #endif
-#ifdef CONFIG_XMON
+#ifdef CONFIG_XMON_DEFAULT
-	xmon_map_scc();
+	xmon_init(1);
-	if (strstr(cmd_line, "xmon")) {
+#endif
-		xmon_init(1);
-		debugger(NULL);
-	}
-#endif /* CONFIG_XMON */
-	if ( ppc_md.progress ) ppc_md.progress("setup_arch: enter", 0x3eab);
 #if defined(CONFIG_KGDB)
 	if (ppc_md.kgdb_map_scc)
 		ppc_md.kgdb_map_scc();
 	set_debug_traps();
 	if (strstr(cmd_line, "gdb")) {
 		if (ppc_md.progress)
 			ppc_md.progress("setup_arch: kgdb breakpoint", 0x4000);
 		printk("kgdb breakpoint activated\n");
 		breakpoint();
 	}
 #endif
 	/*
 	 * Set cache line size based on type of cpu as a default.
 	 * Systems with OF can look in the properties on the cpu node(s)
 	 * for a possibly more accurate value.
 	 */
 	if (cpu_has_feature(CPU_FTR_SPLIT_ID_CACHE)) {
 		dcache_bsize = cur_cpu_spec->dcache_bsize;
 		icache_bsize = cur_cpu_spec->icache_bsize;
 		ucache_bsize = 0;
 	} else
 		ucache_bsize = dcache_bsize = icache_bsize
 			= cur_cpu_spec->dcache_bsize;
 	/* reboot on panic */
 	panic_timeout = 180;
 	init_mm.start_code = PAGE_OFFSET;
 	init_mm.end_code = (unsigned long) _etext;
 	init_mm.end_data = (unsigned long) _edata;
 	init_mm.brk = (unsigned long) klimit;
 	/* Save unparsed command line copy for /proc/cmdline */
 	strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE);
 	*cmdline_p = cmd_line;
 	parse_early_param();
 	/* set up the bootmem stuff with available memory */
 	do_init_bootmem();
 	if ( ppc_md.progress ) ppc_md.progress("setup_arch: bootmem", 0x3eab);
 #ifdef CONFIG_PPC_OCP
 	/* Initialize OCP device list */
 	ocp_early_init();
 	if ( ppc_md.progress ) ppc_md.progress("ocp: exit", 0x3eab);
 #endif
 #ifdef CONFIG_DUMMY_CONSOLE
 	conswitchp = &dummy_con;
 #endif
 	ppc_md.setup_arch();
 	if ( ppc_md.progress ) ppc_md.progress("arch: exit", 0x3eab);
 	paging_init();
 	/* this is for modules since _machine can be a define -- Cort */
 	ppc_md.ppc_machine = _machine;
 }

arch/powerpc/kernel/setup_64.c

Diff comments View file @ fca5dcd

 /*
  *
  * Common boot and setup code.
  *
  * Copyright (C) 2001 PPC64 Team, IBM Corp
  *
  *      This program is free software; you can redistribute it and/or
  *      modify it under the terms of the GNU General Public License
  *      as published by the Free Software Foundation; either version
  *      2 of the License, or (at your option) any later version.
  */
 #undef DEBUG
 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/string.h>
 #include <linux/sched.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/reboot.h>
 #include <linux/delay.h>
 #include <linux/initrd.h>
 #include <linux/ide.h>
 #include <linux/seq_file.h>
 #include <linux/ioport.h>
 #include <linux/console.h>
 #include <linux/utsname.h>
 #include <linux/tty.h>
 #include <linux/root_dev.h>
 #include <linux/notifier.h>
 #include <linux/cpu.h>
 #include <linux/unistd.h>
 #include <linux/serial.h>
 #include <linux/serial_8250.h>
 #include <asm/io.h>
 #include <asm/prom.h>
 #include <asm/processor.h>
 #include <asm/pgtable.h>
 #include <asm/smp.h>
 #include <asm/elf.h>
 #include <asm/machdep.h>
 #include <asm/paca.h>
 #include <asm/time.h>
 #include <asm/cputable.h>
 #include <asm/sections.h>
 #include <asm/btext.h>
 #include <asm/nvram.h>
 #include <asm/setup.h>
 #include <asm/system.h>
 #include <asm/rtas.h>
 #include <asm/iommu.h>
 #include <asm/serial.h>
 #include <asm/cache.h>
 #include <asm/page.h>
 #include <asm/mmu.h>
 #include <asm/lmb.h>
 #include <asm/iseries/it_lp_naca.h>
 #include <asm/firmware.h>
 #include <asm/systemcfg.h>
 #include <asm/xmon.h>
 #include <asm/udbg.h>
 #ifdef DEBUG
 #define DBG(fmt...) udbg_printf(fmt)
 #else
 #define DBG(fmt...)
 #endif
 /*
  * Here are some early debugging facilities. You can enable one
  * but your kernel will not boot on anything else if you do so
  */
 /* This one is for use on LPAR machines that support an HVC console
  * on vterm 0
  */
 extern void udbg_init_debug_lpar(void);
 /* This one is for use on Apple G5 machines
  */
 extern void udbg_init_pmac_realmode(void);
 /* That's RTAS panel debug */
 extern void call_rtas_display_status_delay(unsigned char c);
 /* Here's maple real mode debug */
 extern void udbg_init_maple_realmode(void);
 #define EARLY_DEBUG_INIT() do {} while(0)
 #if 0
 #define EARLY_DEBUG_INIT() udbg_init_debug_lpar()
 #define EARLY_DEBUG_INIT() udbg_init_maple_realmode()
 #define EARLY_DEBUG_INIT() udbg_init_pmac_realmode()
 #define EARLY_DEBUG_INIT()						\
 	do { udbg_putc = call_rtas_display_status_delay; } while(0)
 #endif
 /* extern void *stab; */
 extern unsigned long klimit;
 extern void mm_init_ppc64(void);
 extern void stab_initialize(unsigned long stab);
 extern void htab_initialize(void);
 extern void early_init_devtree(void *flat_dt);
 extern void unflatten_device_tree(void);
 int have_of = 1;
 int boot_cpuid = 0;
 int boot_cpuid_phys = 0;
 dev_t boot_dev;
 u64 ppc64_pft_size;
 struct ppc64_caches ppc64_caches;
 EXPORT_SYMBOL_GPL(ppc64_caches);
 /*
  * These are used in binfmt_elf.c to put aux entries on the stack
  * for each elf executable being started.
  */
 int dcache_bsize;
 int icache_bsize;
 int ucache_bsize;
 /* The main machine-dep calls structure
  */
 struct machdep_calls ppc_md;
 EXPORT_SYMBOL(ppc_md);
 #ifdef CONFIG_MAGIC_SYSRQ
 unsigned long SYSRQ_KEY;
 #endif /* CONFIG_MAGIC_SYSRQ */
 static int ppc64_panic_event(struct notifier_block *, unsigned long, void *);
 static struct notifier_block ppc64_panic_block = {
 	.notifier_call = ppc64_panic_event,
 	.priority = INT_MIN /* may not return; must be done last */
 };
 #ifdef CONFIG_SMP
 static int smt_enabled_cmdline;
 /* Look for ibm,smt-enabled OF option */
 static void check_smt_enabled(void)
 {
 	struct device_node *dn;
 	char *smt_option;
 	/* Allow the command line to overrule the OF option */
 	if (smt_enabled_cmdline)
 		return;
 	dn = of_find_node_by_path("/options");
 	if (dn) {
 		smt_option = (char *)get_property(dn, "ibm,smt-enabled", NULL);
                 if (smt_option) {
 			if (!strcmp(smt_option, "on"))
 				smt_enabled_at_boot = 1;
 			else if (!strcmp(smt_option, "off"))
 				smt_enabled_at_boot = 0;
                 }
         }
 }
 /* Look for smt-enabled= cmdline option */
 static int __init early_smt_enabled(char *p)
 {
 	smt_enabled_cmdline = 1;
 	if (!p)
 		return 0;
 	if (!strcmp(p, "on") || !strcmp(p, "1"))
 		smt_enabled_at_boot = 1;
 	else if (!strcmp(p, "off") || !strcmp(p, "0"))
 		smt_enabled_at_boot = 0;
 	return 0;
 }
 early_param("smt-enabled", early_smt_enabled);
 #else
 #define check_smt_enabled()
 #endif /* CONFIG_SMP */
 extern struct machdep_calls pSeries_md;
 extern struct machdep_calls pmac_md;
 extern struct machdep_calls maple_md;
 extern struct machdep_calls cell_md;
 extern struct machdep_calls iseries_md;
 /* Ultimately, stuff them in an elf section like initcalls... */
 static struct machdep_calls __initdata *machines[] = {
 #ifdef CONFIG_PPC_PSERIES
 	&pSeries_md,
 #endif /* CONFIG_PPC_PSERIES */
 #ifdef CONFIG_PPC_PMAC
 	&pmac_md,
 #endif /* CONFIG_PPC_PMAC */
 #ifdef CONFIG_PPC_MAPLE
 	&maple_md,
 #endif /* CONFIG_PPC_MAPLE */
 #ifdef CONFIG_PPC_CELL
 	&cell_md,
 #endif
 #ifdef CONFIG_PPC_ISERIES
 	&iseries_md,
 #endif
 	NULL
 };
 /*
  * Early initialization entry point. This is called by head.S
  * with MMU translation disabled. We rely on the "feature" of
  * the CPU that ignores the top 2 bits of the address in real
  * mode so we can access kernel globals normally provided we
  * only toy with things in the RMO region. From here, we do
  * some early parsing of the device-tree to setup out LMB
  * data structures, and allocate & initialize the hash table
  * and segment tables so we can start running with translation
  * enabled.
  *
  * It is this function which will call the probe() callback of
  * the various platform types and copy the matching one to the
  * global ppc_md structure. Your platform can eventually do
  * some very early initializations from the probe() routine, but
  * this is not recommended, be very careful as, for example, the
  * device-tree is not accessible via normal means at this point.
  */
 void __init early_setup(unsigned long dt_ptr)
 {
 	struct paca_struct *lpaca = get_paca();
 	static struct machdep_calls **mach;
 	/*
 	 * Enable early debugging if any specified (see top of
 	 * this file)
 	 */
 	EARLY_DEBUG_INIT();
 	DBG(" -> early_setup()\n");
 	/*
 	 * Do early initializations using the flattened device
 	 * tree, like retreiving the physical memory map or
 	 * calculating/retreiving the hash table size
 	 */
 	early_init_devtree(__va(dt_ptr));
 	/*
 	 * Iterate all ppc_md structures until we find the proper
 	 * one for the current machine type
 	 */
 	DBG("Probing machine type for platform %x...\n",
 	    systemcfg->platform);
 	for (mach = machines; *mach; mach++) {
 		if ((*mach)->probe(systemcfg->platform))
 			break;
 	}
 	/* What can we do if we didn't find ? */
 	if (*mach == NULL) {
 		DBG("No suitable machine found !\n");
 		for (;;);
 	}
 	ppc_md = **mach;
 	DBG("Found, Initializing memory management...\n");
 	/*
 	 * Initialize the MMU Hash table and create the linear mapping
 	 * of memory. Has to be done before stab/slb initialization as
 	 * this is currently where the page size encoding is obtained
 	 */
 	htab_initialize();
 	/*
 	 * Initialize stab / SLB management except on iSeries
 	 */
 	if (!firmware_has_feature(FW_FEATURE_ISERIES)) {
 		if (cpu_has_feature(CPU_FTR_SLB))
 			slb_initialize();
 		else
 			stab_initialize(lpaca->stab_real);
 	}
 	DBG(" <- early_setup()\n");
 }
 #if defined(CONFIG_SMP) || defined(CONFIG_KEXEC)
 void smp_release_cpus(void)
 {
 	extern unsigned long __secondary_hold_spinloop;
 	DBG(" -> smp_release_cpus()\n");
 	/* All secondary cpus are spinning on a common spinloop, release them
 	 * all now so they can start to spin on their individual paca
 	 * spinloops. For non SMP kernels, the secondary cpus never get out
 	 * of the common spinloop.
 	 * This is useless but harmless on iSeries, secondaries are already
 	 * waiting on their paca spinloops. */
 	__secondary_hold_spinloop = 1;
 	mb();
 	DBG(" <- smp_release_cpus()\n");
 }
 #else
 #define smp_release_cpus()
 #endif /* CONFIG_SMP || CONFIG_KEXEC */
 /*
  * Initialize some remaining members of the ppc64_caches and systemcfg structures
  * (at least until we get rid of them completely). This is mostly some
  * cache informations about the CPU that will be used by cache flush
  * routines and/or provided to userland
  */
 static void __init initialize_cache_info(void)
 {
 	struct device_node *np;
 	unsigned long num_cpus = 0;
 	DBG(" -> initialize_cache_info()\n");
 	for (np = NULL; (np = of_find_node_by_type(np, "cpu"));) {
 		num_cpus += 1;
 		/* We're assuming *all* of the CPUs have the same
 		 * d-cache and i-cache sizes... -Peter
 		 */
 		if ( num_cpus == 1 ) {
 			u32 *sizep, *lsizep;
 			u32 size, lsize;
 			const char *dc, *ic;
 			/* Then read cache informations */
 			if (systemcfg->platform == PLATFORM_POWERMAC) {
 				dc = "d-cache-block-size";
 				ic = "i-cache-block-size";
 			} else {
 				dc = "d-cache-line-size";
 				ic = "i-cache-line-size";
 			}
 			size = 0;
 			lsize = cur_cpu_spec->dcache_bsize;
 			sizep = (u32 *)get_property(np, "d-cache-size", NULL);
 			if (sizep != NULL)
 				size = *sizep;
 			lsizep = (u32 *) get_property(np, dc, NULL);
 			if (lsizep != NULL)
 				lsize = *lsizep;
 			if (sizep == 0 || lsizep == 0)
 				DBG("Argh, can't find dcache properties ! "
 				    "sizep: %p, lsizep: %p\n", sizep, lsizep);
 			systemcfg->dcache_size = ppc64_caches.dsize = size;
 			systemcfg->dcache_line_size =
 				ppc64_caches.dline_size = lsize;
 			ppc64_caches.log_dline_size = __ilog2(lsize);
 			ppc64_caches.dlines_per_page = PAGE_SIZE / lsize;
 			size = 0;
 			lsize = cur_cpu_spec->icache_bsize;
 			sizep = (u32 *)get_property(np, "i-cache-size", NULL);
 			if (sizep != NULL)
 				size = *sizep;
 			lsizep = (u32 *)get_property(np, ic, NULL);
 			if (lsizep != NULL)
 				lsize = *lsizep;
 			if (sizep == 0 || lsizep == 0)
 				DBG("Argh, can't find icache properties ! "
 				    "sizep: %p, lsizep: %p\n", sizep, lsizep);
 			systemcfg->icache_size = ppc64_caches.isize = size;
 			systemcfg->icache_line_size =
 				ppc64_caches.iline_size = lsize;
 			ppc64_caches.log_iline_size = __ilog2(lsize);
 			ppc64_caches.ilines_per_page = PAGE_SIZE / lsize;
 		}
 	}
 	/* Add an eye catcher and the systemcfg layout version number */
 	strcpy(systemcfg->eye_catcher, "SYSTEMCFG:PPC64");
 	systemcfg->version.major = SYSTEMCFG_MAJOR;
 	systemcfg->version.minor = SYSTEMCFG_MINOR;
 	systemcfg->processor = mfspr(SPRN_PVR);
 	DBG(" <- initialize_cache_info()\n");
 }
 /*
  * Do some initial setup of the system.  The parameters are those which
  * were passed in from the bootloader.
  */
 void __init setup_system(void)
 {
 	DBG(" -> setup_system()\n");
 	/*
 	 * Unflatten the device-tree passed by prom_init or kexec
 	 */
 	unflatten_device_tree();
 	/*
 	 * Fill the ppc64_caches & systemcfg structures with informations
 	 * retreived from the device-tree. Need to be called before
 	 * finish_device_tree() since the later requires some of the
 	 * informations filled up here to properly parse the interrupt
 	 * tree.
 	 * It also sets up the cache line sizes which allows to call
 	 * routines like flush_icache_range (used by the hash init
 	 * later on).
 	 */
 	initialize_cache_info();
 #ifdef CONFIG_PPC_RTAS
 	/*
 	 * Initialize RTAS if available
 	 */
 	rtas_initialize();
 #endif /* CONFIG_PPC_RTAS */
 	/*
 	 * Check if we have an initrd provided via the device-tree
 	 */
 	check_for_initrd();
 	/*
 	 * Do some platform specific early initializations, that includes
 	 * setting up the hash table pointers. It also sets up some interrupt-mapping
 	 * related options that will be used by finish_device_tree()
 	 */
 	ppc_md.init_early();
 	/*
 	 * "Finish" the device-tree, that is do the actual parsing of
 	 * some of the properties like the interrupt map
 	 */
 	finish_device_tree();
 #ifdef CONFIG_BOOTX_TEXT
 	init_boot_display();
 #endif
 	/*
 	 * Initialize xmon
 	 */
 #ifdef CONFIG_XMON_DEFAULT
 	xmon_init(1);
 #endif
 	/*
 	 * Register early console
 	 */
 	register_early_udbg_console();
 	/* Save unparsed command line copy for /proc/cmdline */
 	strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE);
 	parse_early_param();
 	check_smt_enabled();
 	smp_setup_cpu_maps();
 	/* Release secondary cpus out of their spinloops at 0x60 now that
 	 * we can map physical -> logical CPU ids
 	 */
 	smp_release_cpus();
 	printk("Starting Linux PPC64 %s\n", system_utsname.version);
 	printk("-----------------------------------------------------\n");
 	printk("ppc64_pft_size                = 0x%lx\n", ppc64_pft_size);
 	printk("ppc64_interrupt_controller    = 0x%ld\n", ppc64_interrupt_controller);
 	printk("systemcfg                     = 0x%p\n", systemcfg);
 	printk("systemcfg->platform           = 0x%x\n", systemcfg->platform);
 	printk("systemcfg->processorCount     = 0x%lx\n", systemcfg->processorCount);
 	printk("systemcfg->physicalMemorySize = 0x%lx\n", systemcfg->physicalMemorySize);
 	printk("ppc64_caches.dcache_line_size = 0x%x\n",
 			ppc64_caches.dline_size);
 	printk("ppc64_caches.icache_line_size = 0x%x\n",
 			ppc64_caches.iline_size);
 	printk("htab_address                  = 0x%p\n", htab_address);
 	printk("htab_hash_mask                = 0x%lx\n", htab_hash_mask);
 	printk("-----------------------------------------------------\n");
 	mm_init_ppc64();
 	DBG(" <- setup_system()\n");
 }
 static int ppc64_panic_event(struct notifier_block *this,
                              unsigned long event, void *ptr)
 {
 	ppc_md.panic((char *)ptr);  /* May not return */
 	return NOTIFY_DONE;
 }
 #ifdef CONFIG_IRQSTACKS
 static void __init irqstack_early_init(void)
 {
 	unsigned int i;
 	/*
 	 * interrupt stacks must be under 256MB, we cannot afford to take
 	 * SLB misses on them.
 	 */
 	for_each_cpu(i) {
 		softirq_ctx[i] = (struct thread_info *)
 			__va(lmb_alloc_base(THREAD_SIZE,
 					    THREAD_SIZE, 0x10000000));
 		hardirq_ctx[i] = (struct thread_info *)
 			__va(lmb_alloc_base(THREAD_SIZE,
 					    THREAD_SIZE, 0x10000000));
 	}
 }
 #else
 #define irqstack_early_init()
 #endif
 /*
  * Stack space used when we detect a bad kernel stack pointer, and
  * early in SMP boots before relocation is enabled.
  */
 static void __init emergency_stack_init(void)
 {
 	unsigned long limit;
 	unsigned int i;
 	/*
 	 * Emergency stacks must be under 256MB, we cannot afford to take
 	 * SLB misses on them. The ABI also requires them to be 128-byte
 	 * aligned.
 	 *
 	 * Since we use these as temporary stacks during secondary CPU
 	 * bringup, we need to get at them in real mode. This means they
 	 * must also be within the RMO region.
 	 */
 	limit = min(0x10000000UL, lmb.rmo_size);
 	for_each_cpu(i)
 		paca[i].emergency_sp =
 		__va(lmb_alloc_base(HW_PAGE_SIZE, 128, limit)) + HW_PAGE_SIZE;
 }
 /*
  * Called from setup_arch to initialize the bitmap of available
  * syscalls in the systemcfg page
  */
 void __init setup_syscall_map(void)
 {
 	unsigned int i, count64 = 0, count32 = 0;
 	extern unsigned long *sys_call_table;
 	extern unsigned long sys_ni_syscall;
 	for (i = 0; i < __NR_syscalls; i++) {
 		if (sys_call_table[i*2] != sys_ni_syscall) {
 			count64++;
 			systemcfg->syscall_map_64[i >> 5] |=
 				0x80000000UL >> (i & 0x1f);
 		}
 		if (sys_call_table[i*2+1] != sys_ni_syscall) {
 			count32++;
 			systemcfg->syscall_map_32[i >> 5] |=
 				0x80000000UL >> (i & 0x1f);
 		}
 	}
 	printk(KERN_INFO "Syscall map setup, %d 32-bit and %d 64-bit syscalls\n",
 	       count32, count64);
 }
 /*
  * Called into from start_kernel, after lock_kernel has been called.
  * Initializes bootmem, which is unsed to manage page allocation until
  * mem_init is called.
  */
 void __init setup_arch(char **cmdline_p)
 {
 	extern void do_init_bootmem(void);
 	ppc64_boot_msg(0x12, "Setup Arch");
 	*cmdline_p = cmd_line;
 	/*
 	 * Set cache line size based on type of cpu as a default.
 	 * Systems with OF can look in the properties on the cpu node(s)
 	 * for a possibly more accurate value.
 	 */
 	dcache_bsize = ppc64_caches.dline_size;
 	icache_bsize = ppc64_caches.iline_size;
 	/* reboot on panic */
 	panic_timeout = 180;
 	if (ppc_md.panic)
 		notifier_chain_register(&panic_notifier_list, &ppc64_panic_block);
 	init_mm.start_code = PAGE_OFFSET;
 	init_mm.end_code = (unsigned long) _etext;
 	init_mm.end_data = (unsigned long) _edata;
 	init_mm.brk = klimit;
 	irqstack_early_init();
 	emergency_stack_init();
 	stabs_alloc();
 	/* set up the bootmem stuff with available memory */
 	do_init_bootmem();
 	sparse_init();
 	/* initialize the syscall map in systemcfg */
 	setup_syscall_map();
 #ifdef CONFIG_DUMMY_CONSOLE
 	conswitchp = &dummy_con;
 #endif
 	ppc_md.setup_arch();
 	/* Use the default idle loop if the platform hasn't provided one. */
 	if (NULL == ppc_md.idle_loop) {
 		ppc_md.idle_loop = default_idle;
 		printk(KERN_INFO "Using default idle loop\n");
 	}
 	paging_init();
 	ppc64_boot_msg(0x15, "Setup Done");
 }
 /* ToDo: do something useful if ppc_md is not yet setup. */
 #define PPC64_LINUX_FUNCTION 0x0f000000
 #define PPC64_IPL_MESSAGE 0xc0000000
 #define PPC64_TERM_MESSAGE 0xb0000000
 static void ppc64_do_msg(unsigned int src, const char *msg)
 {
 	if (ppc_md.progress) {
 		char buf[128];
 		sprintf(buf, "%08X\n", src);
 		ppc_md.progress(buf, 0);
 		snprintf(buf, 128, "%s", msg);
 		ppc_md.progress(buf, 0);
 	}
 }
 /* Print a boot progress message. */
 void ppc64_boot_msg(unsigned int src, const char *msg)
 {
 	ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_IPL_MESSAGE|src, msg);
 	printk("[boot]%04x %s\n", src, msg);
 }
 /* Print a termination message (print only -- does not stop the kernel) */
 void ppc64_terminate_msg(unsigned int src, const char *msg)
 {
 	ppc64_do_msg(PPC64_LINUX_FUNCTION|PPC64_TERM_MESSAGE|src, msg);
 	printk("[terminate]%04x %s\n", src, msg);
 }
 #ifndef CONFIG_PPC_ISERIES
 /*
  * This function can be used by platforms to "find" legacy serial ports.
  * It works for "serial" nodes under an "isa" node, and will try to
  * respect the "ibm,aix-loc" property if any. It works with up to 8
  * ports.
  */
 #define MAX_LEGACY_SERIAL_PORTS	8
 static struct plat_serial8250_port serial_ports[MAX_LEGACY_SERIAL_PORTS+1];
 static unsigned int old_serial_count;
 void __init generic_find_legacy_serial_ports(u64 *physport,
 		unsigned int *default_speed)
 {
 	struct device_node *np;
 	u32 *sizeprop;
 	struct isa_reg_property {
 		u32 space;
 		u32 address;
 		u32 size;
 	};
 	struct pci_reg_property {
 		struct pci_address addr;
 		u32 size_hi;
 		u32 size_lo;
 	};
 	DBG(" -> generic_find_legacy_serial_port()\n");
 	*physport = 0;
 	if (default_speed)
 		*default_speed = 0;
 	np = of_find_node_by_path("/");
 	if (!np)
 		return;
 	/* First fill our array */
 	for (np = NULL; (np = of_find_node_by_type(np, "serial"));) {
 		struct device_node *isa, *pci;
 		struct isa_reg_property *reg;
 		unsigned long phys_size, addr_size, io_base;
 		u32 *rangesp;
 		u32 *interrupts, *clk, *spd;
 		char *typep;
 		int index, rlen, rentsize;
 		/* Ok, first check if it's under an "isa" parent */
 		isa = of_get_parent(np);
 		if (!isa || strcmp(isa->name, "isa")) {
 			DBG("%s: no isa parent found\n", np->full_name);
 			continue;
 		}
 		/* Now look for an "ibm,aix-loc" property that gives us ordering
 		 * if any...
 		 */
 	 	typep = (char *)get_property(np, "ibm,aix-loc", NULL);
 		/* Get the ISA port number */
 		reg = (struct isa_reg_property *)get_property(np, "reg", NULL);
 		if (reg == NULL)
 			goto next_port;
 		/* We assume the interrupt number isn't translated ... */
 		interrupts = (u32 *)get_property(np, "interrupts", NULL);
 		/* get clock freq. if present */
 		clk = (u32 *)get_property(np, "clock-frequency", NULL);
 		/* get default speed if present */
 		spd = (u32 *)get_property(np, "current-speed", NULL);
 		/* Default to locate at end of array */
 		index = old_serial_count; /* end of the array by default */
 		/* If we have a location index, then use it */
 		if (typep && *typep == 'S') {
 			index = simple_strtol(typep+1, NULL, 0) - 1;
 			/* if index is out of range, use end of array instead */
 			if (index >= MAX_LEGACY_SERIAL_PORTS)
 				index = old_serial_count;
 			/* if our index is still out of range, that mean that
 			 * array is full, we could scan for a free slot but that
 			 * make little sense to bother, just skip the port
 			 */
 			if (index >= MAX_LEGACY_SERIAL_PORTS)
 				goto next_port;
 			if (index >= old_serial_count)
 				old_serial_count = index + 1;
 			/* Check if there is a port who already claimed our slot */
 			if (serial_ports[index].iobase != 0) {
 				/* if we still have some room, move it, else override */
 				if (old_serial_count < MAX_LEGACY_SERIAL_PORTS) {
 					DBG("Moved legacy port %d -> %d\n", index,
 					    old_serial_count);
 					serial_ports[old_serial_count++] =
 						serial_ports[index];
 				} else {
 					DBG("Replacing legacy port %d\n", index);
 				}
 			}
 		}
 		if (index >= MAX_LEGACY_SERIAL_PORTS)
 			goto next_port;
 		if (index >= old_serial_count)
 			old_serial_count = index + 1;
 		/* Now fill the entry */
 		memset(&serial_ports[index], 0, sizeof(struct plat_serial8250_port));
 		serial_ports[index].uartclk = clk ? *clk : BASE_BAUD * 16;
 		serial_ports[index].iobase = reg->address;
 		serial_ports[index].irq = interrupts ? interrupts[0] : 0;
 		serial_ports[index].flags = ASYNC_BOOT_AUTOCONF;
 		DBG("Added legacy port, index: %d, port: %x, irq: %d, clk: %d\n",
 		    index,
 		    serial_ports[index].iobase,
 		    serial_ports[index].irq,
 		    serial_ports[index].uartclk);
 		/* Get phys address of IO reg for port 1 */
 		if (index != 0)
 			goto next_port;
 		pci = of_get_parent(isa);
 		if (!pci) {
 			DBG("%s: no pci parent found\n", np->full_name);
 			goto next_port;
 		}
 		rangesp = (u32 *)get_property(pci, "ranges", &rlen);
 		if (rangesp == NULL) {
 			of_node_put(pci);
 			goto next_port;
 		}
 		rlen /= 4;
 		/* we need the #size-cells of the PCI bridge node itself */
 		phys_size = 1;
 		sizeprop = (u32 *)get_property(pci, "#size-cells", NULL);
 		if (sizeprop != NULL)
 			phys_size = *sizeprop;
 		/* we need the parent #addr-cells */
 		addr_size = prom_n_addr_cells(pci);
 		rentsize = 3 + addr_size + phys_size;
 		io_base = 0;
 		for (;rlen >= rentsize; rlen -= rentsize,rangesp += rentsize) {
 			if (((rangesp[0] >> 24) & 0x3) != 1)
 				continue; /* not IO space */
 			io_base = rangesp[3];
 			if (addr_size == 2)
 				io_base = (io_base << 32) | rangesp[4];
 		}
 		if (io_base != 0) {
 			*physport = io_base + reg->address;
 			if (default_speed && spd)
 				*default_speed = *spd;
 		}
 		of_node_put(pci);
 	next_port:
 		of_node_put(isa);
 	}
 	DBG(" <- generic_find_legacy_serial_port()\n");
 }
 static struct platform_device serial_device = {
 	.name	= "serial8250",
 	.id	= PLAT8250_DEV_PLATFORM,
 	.dev	= {
 		.platform_data = serial_ports,
 	},
 };
 static int __init serial_dev_init(void)
 {
 	return platform_device_register(&serial_device);
 }
 arch_initcall(serial_dev_init);
 #endif /* CONFIG_PPC_ISERIES */
 int check_legacy_ioport(unsigned long base_port)
 {
 	if (ppc_md.check_legacy_ioport == NULL)
 		return 0;
 	return ppc_md.check_legacy_ioport(base_port);
 }
 EXPORT_SYMBOL(check_legacy_ioport);
-#ifdef CONFIG_XMON
-static int __init early_xmon(char *p)
-{
-	/* ensure xmon is enabled */
-	if (p) {
-		if (strncmp(p, "on", 2) == 0)
-			xmon_init(1);
-		if (strncmp(p, "off", 3) == 0)
-			xmon_init(0);
-		if (strncmp(p, "early", 5) != 0)
-			return 0;
-	}
-	xmon_init(1);
-	debugger(NULL);
-	return 0;
-}
-early_param("xmon", early_xmon);
-#endif
 void cpu_die(void)
 {
 	if (ppc_md.cpu_die)
 		ppc_md.cpu_die();
 }

arch/powerpc/xmon/Makefile

Diff comments View file @ fca5dcd

1	# Makefile for xmon	1	# Makefile for xmon
2		2
3	ifdef CONFIG_PPC64	3	ifdef CONFIG_PPC64
4	EXTRA_CFLAGS += -mno-minimal-toc	4	EXTRA_CFLAGS += -mno-minimal-toc
5	endif	5	endif
6		6
7	obj-$(CONFIG_8xx) += start_8xx.o	7	obj-$(CONFIG_8xx) += start_8xx.o
8	obj-$(CONFIG_6xx) += start_32.o	8	obj-$(CONFIG_6xx) += start_32.o
9	obj-$(CONFIG_4xx) += start_32.o	9	obj-$(CONFIG_4xx) += start_32.o
10	obj-$(CONFIG_PPC64) += start_64.o	10	obj-$(CONFIG_PPC64) += start_64.o
11	obj-y += xmon.o ppc-dis.o ppc-opc.o subr_prf.o setjmp.o	11	obj-y += xmon.o ppc-dis.o ppc-opc.o setjmp.o nonstdio.o
12		12

arch/powerpc/xmon/nonstdio.c

Diff comments View file @ fca5dcd

File was created	1	/*
	2	* Copyright (C) 1996-2005 Paul Mackerras.
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation; either version
	7	* 2 of the License, or (at your option) any later version.
	8	*/
	9	#include <linux/string.h>
	10	#include <asm/time.h>
	11	#include "nonstdio.h"
	12
	13	int xmon_putchar(int c)
	14	{
	15	char ch = c;
	16
	17	if (c == '\n')
	18	xmon_putchar('\r');
	19	return xmon_write(&ch, 1) == 1? c: -1;
	20	}
	21
	22	static char line[256];
	23	static char *lineptr;
	24	static int lineleft;
	25
	26	int xmon_expect(const char *str, unsigned long timeout)
	27	{
	28	int c;
	29	unsigned long t0;
	30
	31	/* assume 25MHz default timebase if tb_ticks_per_sec not set yet */
	32	timeout *= tb_ticks_per_sec? tb_ticks_per_sec: 25000000;
	33	t0 = get_tbl();
	34	do {
	35	lineptr = line;
	36	for (;;) {
	37	c = xmon_read_poll();
	38	if (c == -1) {
	39	if (get_tbl() - t0 > timeout)
	40	return 0;
	41	continue;
	42	}
	43	if (c == '\n')
	44	break;
	45	if (c != '\r' && lineptr < &line[sizeof(line) - 1])
	46	*lineptr++ = c;
	47	}
	48	*lineptr = 0;
	49	} while (strstr(line, str) == NULL);
	50	return 1;
	51	}
	52
	53	int xmon_getchar(void)
	54	{
	55	int c;
	56
	57	if (lineleft == 0) {
	58	lineptr = line;
	59	for (;;) {
	60	c = xmon_readchar();
	61	if (c == -1 \|\| c == 4)
	62	break;
	63	if (c == '\r' \|\| c == '\n') {
	64	*lineptr++ = '\n';
	65	xmon_putchar('\n');
	66	break;
	67	}
	68	switch (c) {
	69	case 0177:
	70	case '\b':
	71	if (lineptr > line) {
	72	xmon_putchar('\b');
	73	xmon_putchar(' ');
	74	xmon_putchar('\b');
	75	--lineptr;
	76	}
	77	break;
	78	case 'U' & 0x1F:
	79	while (lineptr > line) {
	80	xmon_putchar('\b');
	81	xmon_putchar(' ');
	82	xmon_putchar('\b');
	83	--lineptr;
	84	}
	85	break;
	86	default:
	87	if (lineptr >= &line[sizeof(line) - 1])
	88	xmon_putchar('\a');
	89	else {
	90	xmon_putchar(c);
	91	*lineptr++ = c;
	92	}
	93	}
	94	}
	95	lineleft = lineptr - line;
	96	lineptr = line;
	97	}
	98	if (lineleft == 0)
	99	return -1;
	100	--lineleft;
	101	return *lineptr++;
	102	}
	103
	104	char xmon_gets(char str, int nb)
	105	{
	106	char *p;
	107	int c;
	108
	109	for (p = str; p < str + nb - 1; ) {
	110	c = xmon_getchar();
	111	if (c == -1) {
	112	if (p == str)
	113	return NULL;
	114	break;
	115	}
	116	*p++ = c;
	117	if (c == '\n')
	118	break;
	119	}
	120	*p = 0;
	121	return str;
	122	}
	123
	124	void xmon_printf(const char *format, ...)
	125	{
	126	va_list args;
	127	int n;
	128	static char xmon_outbuf[1024];
	129
	130	va_start(args, format);
	131	n = vsnprintf(xmon_outbuf, sizeof(xmon_outbuf), format, args);
	132	va_end(args);
	133	xmon_write(xmon_outbuf, n);
	134	}
	135

arch/powerpc/xmon/nonstdio.h

Diff comments View file @ fca5dcd

1	typedef int FILE;
2	extern FILE xmon_stdin, xmon_stdout;
3	#define EOF (-1)	1	#define EOF (-1)
4	#define stdin xmon_stdin	2
5	#define stdout xmon_stdout
6	#define printf xmon_printf	3	#define printf xmon_printf
7	#define fprintf xmon_fprintf
8	#define fputs xmon_fputs
9	#define fgets xmon_fgets
10	#define putchar xmon_putchar	4	#define putchar xmon_putchar
11	#define getchar xmon_getchar
12	#define putc xmon_putc
13	#define getc xmon_getc
14	#define fopen(n, m) NULL
15	#define fflush(f) do {} while (0)
16	#define fclose(f) do {} while (0)
17	extern char fgets(char , int, void *);
18	extern void xmon_printf(const char *, ...);
19	extern void xmon_fprintf(void , const char , ...);
20	extern void xmon_sprintf(char , const char , ...);
21		5
22	#define perror(s) printf("%s: no files!\n", (s))	6	extern int xmon_putchar(int c);
		7	extern int xmon_getchar(void);

arch/powerpc/xmon/start_32.c

Diff comments View file @ fca5dcd

 /*
  * Copyright (C) 1996 Paul Mackerras.
  */
 #include <linux/config.h>
 #include <linux/string.h>
 #include <asm/machdep.h>
 #include <asm/io.h>
 #include <asm/page.h>
 #include <linux/adb.h>
 #include <linux/pmu.h>
 #include <linux/cuda.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
-#include <linux/sysrq.h>
 #include <linux/bitops.h>
 #include <asm/xmon.h>
 #include <asm/prom.h>
 #include <asm/bootx.h>
 #include <asm/machdep.h>
 #include <asm/errno.h>
 #include <asm/pmac_feature.h>
 #include <asm/processor.h>
 #include <asm/delay.h>
 #include <asm/btext.h>
+#include <asm/time.h>
+#include "nonstdio.h"
 static volatile unsigned char __iomem *sccc, *sccd;
 unsigned int TXRDY, RXRDY, DLAB;
-static int xmon_expect(const char *str, unsigned int timeout);
 static int use_serial;
 static int use_screen;
 static int via_modem;
 static int xmon_use_sccb;
 static struct device_node *channel_node;
-#define TB_SPEED	25000000
-static inline unsigned int readtb(void)
-{
-	unsigned int ret;
-	asm volatile("mftb %0" : "=r" (ret) :);
-	return ret;
-}
 void buf_access(void)
 {
 	if (DLAB)
 		sccd[3] &= ~DLAB;	/* reset DLAB */
 }
 extern int adb_init(void);
 #ifdef CONFIG_PPC_CHRP
 /*
  * This looks in the "ranges" property for the primary PCI host bridge
  * to find the physical address of the start of PCI/ISA I/O space.
  * It is basically a cut-down version of pci_process_bridge_OF_ranges.
  */
 static unsigned long chrp_find_phys_io_base(void)
 {
 	struct device_node *node;
 	unsigned int *ranges;
 	unsigned long base = CHRP_ISA_IO_BASE;
 	int rlen = 0;
 	int np;
 	node = find_devices("isa");
 	if (node != NULL) {
 		node = node->parent;
 		if (node == NULL || node->type == NULL
 		    || strcmp(node->type, "pci") != 0)
 			node = NULL;
 	}
 	if (node == NULL)
 		node = find_devices("pci");
 	if (node == NULL)
 		return base;
 	ranges = (unsigned int *) get_property(node, "ranges", &rlen);
 	np = prom_n_addr_cells(node) + 5;
 	while ((rlen -= np * sizeof(unsigned int)) >= 0) {
 		if ((ranges[0] >> 24) == 1 && ranges[2] == 0) {
 			/* I/O space starting at 0, grab the phys base */
 			base = ranges[np - 3];
 			break;
 		}
 		ranges += np;
 	}
 	return base;
 }
 #endif /* CONFIG_PPC_CHRP */
-#ifdef CONFIG_MAGIC_SYSRQ
+void xmon_map_scc(void)
-static void sysrq_handle_xmon(int key, struct pt_regs *regs,
-			      struct tty_struct *tty)
 {
-	xmon(regs);
-}
-static struct sysrq_key_op sysrq_xmon_op =
-{
-	.handler =	sysrq_handle_xmon,
-	.help_msg =	"Xmon",
-	.action_msg =	"Entering xmon",
-};
-#endif
-void
-xmon_map_scc(void)
-{
 #ifdef CONFIG_PPC_MULTIPLATFORM
 	volatile unsigned char __iomem *base;
 	if (_machine == _MACH_Pmac) {
 		struct device_node *np;
 		unsigned long addr;
 #ifdef CONFIG_BOOTX_TEXT
 		if (!use_screen && !use_serial
 		    && !machine_is_compatible("iMac")) {
 			/* see if there is a keyboard in the device tree
 			   with a parent of type "adb" */
 			for (np = find_devices("keyboard"); np; np = np->next)
 				if (np->parent && np->parent->type
 				    && strcmp(np->parent->type, "adb") == 0)
 					break;
 			/* needs to be hacked if xmon_printk is to be used
 			   from within find_via_pmu() */
 #ifdef CONFIG_ADB_PMU
 			if (np != NULL && boot_text_mapped && find_via_pmu())
 				use_screen = 1;
 #endif
 #ifdef CONFIG_ADB_CUDA
 			if (np != NULL && boot_text_mapped && find_via_cuda())
 				use_screen = 1;
 #endif
 		}
 		if (!use_screen && (np = find_devices("escc")) != NULL) {
 			/*
 			 * look for the device node for the serial port
 			 * we're using and see if it says it has a modem
 			 */
 			char *name = xmon_use_sccb? "ch-b": "ch-a";
 			char *slots;
 			int l;
 			np = np->child;
 			while (np != NULL && strcmp(np->name, name) != 0)
 				np = np->sibling;
 			if (np != NULL) {
 				/* XXX should parse this properly */
 				channel_node = np;
 				slots = get_property(np, "slot-names", &l);
 				if (slots != NULL && l >= 10
 				    && strcmp(slots+4, "Modem") == 0)
 					via_modem = 1;
 			}
 		}
 		btext_drawstring("xmon uses ");
 		if (use_screen)
 			btext_drawstring("screen and keyboard\n");
 		else {
 			if (via_modem)
 				btext_drawstring("modem on ");
 			btext_drawstring(xmon_use_sccb? "printer": "modem");
 			btext_drawstring(" port\n");
 		}
 #endif /* CONFIG_BOOTX_TEXT */
 #ifdef CHRP_ESCC
 		addr = 0xc1013020;
 #else
 		addr = 0xf3013020;
 #endif
 		TXRDY = 4;
 		RXRDY = 1;
 		np = find_devices("mac-io");
 		if (np && np->n_addrs)
 			addr = np->addrs[0].address + 0x13020;
 		base = (volatile unsigned char *) ioremap(addr & PAGE_MASK, PAGE_SIZE);
 		sccc = base + (addr & ~PAGE_MASK);
 		sccd = sccc + 0x10;
 	} else {
 		base = (volatile unsigned char *) isa_io_base;
 #ifdef CONFIG_PPC_CHRP
 		if (_machine == _MACH_chrp)
 			base = (volatile unsigned char __iomem *)
 				ioremap(chrp_find_phys_io_base(), 0x1000);
 #endif
 		sccc = base + 0x3fd;
 		sccd = base + 0x3f8;
 		if (xmon_use_sccb) {
 			sccc -= 0x100;
 			sccd -= 0x100;
 		}
 		TXRDY = 0x20;
 		RXRDY = 1;
 		DLAB = 0x80;
 	}
 #elif defined(CONFIG_GEMINI)
 	/* should already be mapped by the kernel boot */
 	sccc = (volatile unsigned char __iomem *) 0xffeffb0d;
 	sccd = (volatile unsigned char __iomem *) 0xffeffb08;
 	TXRDY = 0x20;
 	RXRDY = 1;
 	DLAB = 0x80;
 #elif defined(CONFIG_405GP)
 	sccc = (volatile unsigned char __iomem *)0xef600305;
 	sccd = (volatile unsigned char __iomem *)0xef600300;
 	TXRDY = 0x20;
 	RXRDY = 1;
 	DLAB = 0x80;
 #endif /* platform */
-	register_sysrq_key('x', &sysrq_xmon_op);
 }
 static int scc_initialized = 0;
 void xmon_init_scc(void);
 extern void cuda_poll(void);
 static inline void do_poll_adb(void)
 {
 #ifdef CONFIG_ADB_PMU
 	if (sys_ctrler == SYS_CTRLER_PMU)
 		pmu_poll_adb();
 #endif /* CONFIG_ADB_PMU */
 #ifdef CONFIG_ADB_CUDA
 	if (sys_ctrler == SYS_CTRLER_CUDA)
 		cuda_poll();
 #endif /* CONFIG_ADB_CUDA */
 }
-int
+int xmon_write(void *ptr, int nb)
-xmon_write(void *handle, void *ptr, int nb)
 {
 	char *p = ptr;
 	int i, c, ct;
 #ifdef CONFIG_SMP
 	static unsigned long xmon_write_lock;
 	int lock_wait = 1000000;
 	int locked;
 	while ((locked = test_and_set_bit(0, &xmon_write_lock)) != 0)
 		if (--lock_wait == 0)
 			break;
 #endif
 #ifdef CONFIG_BOOTX_TEXT
 	if (use_screen) {
 		/* write it on the screen */
 		for (i = 0; i < nb; ++i)
 			btext_drawchar(*p++);
 		goto out;
 	}
 #endif
 	if (!scc_initialized)
 		xmon_init_scc();
 	ct = 0;
 	for (i = 0; i < nb; ++i) {
 		while ((*sccc & TXRDY) == 0)
 			do_poll_adb();
 		c = p[i];
 		if (c == '\n' && !ct) {
 			c = '\r';
 			ct = 1;
 			--i;
 		} else {
 			ct = 0;
 		}
 		buf_access();
 		*sccd = c;
 		eieio();
 	}
  out:
 #ifdef CONFIG_SMP
 	if (!locked)
 		clear_bit(0, &xmon_write_lock);
 #endif
 	return nb;
 }
 int xmon_wants_key;
 int xmon_adb_keycode;
 #ifdef CONFIG_BOOTX_TEXT
 static int xmon_adb_shiftstate;
 static unsigned char xmon_keytab[128] =
 	"asdfhgzxcv\000bqwer"				/* 0x00 - 0x0f */
 	"yt123465=97-80]o"				/* 0x10 - 0x1f */
 	"u[ip\rlj'k;\\,/nm."				/* 0x20 - 0x2f */
 	"\t `\177\0\033\0\0\0\0\0\0\0\0\0\0"		/* 0x30 - 0x3f */
 	"\0.\0*\0+\0\0\0\0\0/\r\0-\0"			/* 0x40 - 0x4f */
 	"\0\0000123456789\0\0\0";			/* 0x50 - 0x5f */
 static unsigned char xmon_shift_keytab[128] =
 	"ASDFHGZXCV\000BQWER"				/* 0x00 - 0x0f */
 	"YT!@#$^%+(&_*)}O"				/* 0x10 - 0x1f */
 	"U{IP\rLJ\"K:|<?NM>"				/* 0x20 - 0x2f */
 	"\t ~\177\0\033\0\0\0\0\0\0\0\0\0\0"		/* 0x30 - 0x3f */
 	"\0.\0*\0+\0\0\0\0\0/\r\0-\0"			/* 0x40 - 0x4f */
 	"\0\0000123456789\0\0\0";			/* 0x50 - 0x5f */
-static int
+static int xmon_get_adb_key(void)
-xmon_get_adb_key(void)
 {
 	int k, t, on;
 	xmon_wants_key = 1;
 	for (;;) {
 		xmon_adb_keycode = -1;
 		t = 0;
 		on = 0;
 		do {
 			if (--t < 0) {
 				on = 1 - on;
 				btext_drawchar(on? 0xdb: 0x20);
 				btext_drawchar('\b');
 				t = 200000;
 			}
 			do_poll_adb();
 		} while (xmon_adb_keycode == -1);
 		k = xmon_adb_keycode;
 		if (on)
 			btext_drawstring(" \b");
 		/* test for shift keys */
 		if ((k & 0x7f) == 0x38 || (k & 0x7f) == 0x7b) {
 			xmon_adb_shiftstate = (k & 0x80) == 0;
 			continue;
 		}
 		if (k >= 0x80)
 			continue;	/* ignore up transitions */
 		k = (xmon_adb_shiftstate? xmon_shift_keytab: xmon_keytab)[k];
 		if (k != 0)
 			break;
 	}
 	xmon_wants_key = 0;
 	return k;
 }
 #endif /* CONFIG_BOOTX_TEXT */
-int
+int xmon_readchar(void)
-xmon_read(void *handle, void *ptr, int nb)
 {
-    char *p = ptr;
-    int i;
 #ifdef CONFIG_BOOTX_TEXT
-    if (use_screen) {
+	if (use_screen)
-	for (i = 0; i < nb; ++i)
+		return xmon_get_adb_key();
-	    *p++ = xmon_get_adb_key();
-	return i;
-    }
 #endif
-    if (!scc_initialized)
+	if (!scc_initialized)
-	xmon_init_scc();
+		xmon_init_scc();
-    for (i = 0; i < nb; ++i) {
 	while ((*sccc & RXRDY) == 0)
-	    do_poll_adb();
+		do_poll_adb();
 	buf_access();
-	*p++ = *sccd;
+	return *sccd;
-    }
-    return i;
 }
-int
+int xmon_read_poll(void)
-xmon_read_poll(void)
 {
 	if ((*sccc & RXRDY) == 0) {
 		do_poll_adb();
 		return -1;
 	}
 	buf_access();
 	return *sccd;
 }
 static unsigned char scc_inittab[] = {
     13, 0,		/* set baud rate divisor */
     12, 1,
     14, 1,		/* baud rate gen enable, src=rtxc */
     11, 0x50,		/* clocks = br gen */
     5,  0xea,		/* tx 8 bits, assert DTR & RTS */
     4,  0x46,		/* x16 clock, 1 stop */
     3,  0xc1,		/* rx enable, 8 bits */
 };
-void
+void xmon_init_scc(void)
-xmon_init_scc(void)
 {
 	if ( _machine == _MACH_chrp )
 	{
 		sccd[3] = 0x83; eieio();	/* LCR = 8N1 + DLAB */
 		sccd[0] = 12; eieio();		/* DLL = 9600 baud */
 		sccd[1] = 0; eieio();
 		sccd[2] = 0; eieio();		/* FCR = 0 */
 		sccd[3] = 3; eieio();		/* LCR = 8N1 */
 		sccd[1] = 0; eieio();		/* IER = 0 */
 	}
 	else if ( _machine == _MACH_Pmac )
 	{
 		int i, x;
+		unsigned long timeout;
 		if (channel_node != 0)
 			pmac_call_feature(
 				PMAC_FTR_SCC_ENABLE,
 				channel_node,
 				PMAC_SCC_ASYNC | PMAC_SCC_FLAG_XMON, 1);
 			printk(KERN_INFO "Serial port locked ON by debugger !\n");
 		if (via_modem && channel_node != 0) {
 			unsigned int t0;
 			pmac_call_feature(
 				PMAC_FTR_MODEM_ENABLE,
 				channel_node, 0, 1);
 			printk(KERN_INFO "Modem powered up by debugger !\n");
-			t0 = readtb();
+			t0 = get_tbl();
-			while (readtb() - t0 < 3*TB_SPEED)
+			timeout = 3 * tb_ticks_per_sec;
+			if (timeout == 0)
+				/* assume 25MHz if tb_ticks_per_sec not set */
+				timeout = 75000000;
+			while (get_tbl() - t0 < timeout)
 				eieio();
 		}
 		/* use the B channel if requested */
 		if (xmon_use_sccb) {
 			sccc = (volatile unsigned char *)
 				((unsigned long)sccc & ~0x20);
 			sccd = sccc + 0x10;
 		}
 		for (i = 20000; i != 0; --i) {
 			x = *sccc; eieio();
 		}
 		*sccc = 9; eieio();		/* reset A or B side */
 		*sccc = ((unsigned long)sccc & 0x20)? 0x80: 0x40; eieio();
 		for (i = 0; i < sizeof(scc_inittab); ++i) {
 			*sccc = scc_inittab[i];
 			eieio();
 		}
 	}
 	scc_initialized = 1;
 	if (via_modem) {
 		for (;;) {
-			xmon_write(NULL, "ATE1V1\r", 7);
+			xmon_write("ATE1V1\r", 7);
 			if (xmon_expect("OK", 5)) {
-				xmon_write(NULL, "ATA\r", 4);
+				xmon_write("ATA\r", 4);
 				if (xmon_expect("CONNECT", 40))
 					break;
 			}
-			xmon_write(NULL, "+++", 3);
+			xmon_write("+++", 3);
 			xmon_expect("OK", 3);
 		}
 	}
 }
-void *xmon_stdin;
+void xmon_enter(void)
-void *xmon_stdout;
-void *xmon_stderr;
-int xmon_putc(int c, void *f)
 {
-    char ch = c;
-    if (c == '\n')
-	xmon_putc('\r', f);
-    return xmon_write(f, &ch, 1) == 1? c: -1;
-}
-int xmon_putchar(int c)
-{
-	return xmon_putc(c, xmon_stdout);
-}
-int xmon_fputs(char *str, void *f)
-{
-	int n = strlen(str);
-	return xmon_write(f, str, n) == n? 0: -1;
-}
-int
-xmon_readchar(void)
-{
-	char ch;
-	for (;;) {
-		switch (xmon_read(xmon_stdin, &ch, 1)) {
-		case 1:
-			return ch;
-		case -1:
-			xmon_printf("read(stdin) returned -1\r\n", 0, 0);
-			return -1;
-		}
-	}
-}
-static char line[256];
-static char *lineptr;
-static int lineleft;
-int xmon_expect(const char *str, unsigned int timeout)
-{
-	int c;
-	unsigned int t0;
-	timeout *= TB_SPEED;
-	t0 = readtb();
-	do {
-		lineptr = line;
-		for (;;) {
-			c = xmon_read_poll();
-			if (c == -1) {
-				if (readtb() - t0 > timeout)
-					return 0;
-				continue;
-			}
-			if (c == '\n')
-				break;
-			if (c != '\r' && lineptr < &line[sizeof(line) - 1])
-				*lineptr++ = c;
-		}
-		*lineptr = 0;
-	} while (strstr(line, str) == NULL);
-	return 1;
-}
-int
-xmon_getchar(void)
-{
-    int c;
-    if (lineleft == 0) {
-	lineptr = line;
-	for (;;) {
-	    c = xmon_readchar();
-	    if (c == -1 || c == 4)
-		break;
-	    if (c == '\r' || c == '\n') {
-		*lineptr++ = '\n';
-		xmon_putchar('\n');
-		break;
-	    }
-	    switch (c) {
-	    case 0177:
-	    case '\b':
-		if (lineptr > line) {
-		    xmon_putchar('\b');
-		    xmon_putchar(' ');
-		    xmon_putchar('\b');
-		    --lineptr;
-		}
-		break;
-	    case 'U' & 0x1F:
-		while (lineptr > line) {
-		    xmon_putchar('\b');
-		    xmon_putchar(' ');
-		    xmon_putchar('\b');
-		    --lineptr;
-		}
-		break;
-	    default:
-		if (lineptr >= &line[sizeof(line) - 1])
-		    xmon_putchar('\a');
-		else {
-		    xmon_putchar(c);
-		    *lineptr++ = c;
-		}
-	    }
-	}
-	lineleft = lineptr - line;
-	lineptr = line;
-    }
-    if (lineleft == 0)
-	return -1;
-    --lineleft;
-    return *lineptr++;
-}
-char *
-xmon_fgets(char *str, int nb, void *f)
-{
-    char *p;
-    int c;
-    for (p = str; p < str + nb - 1; ) {
-	c = xmon_getchar();
-	if (c == -1) {
-	    if (p == str)
-		return NULL;
-	    break;
-	}
-	*p++ = c;
-	if (c == '\n')
-	    break;
-    }
-    *p = 0;
-    return str;
-}
-void
-xmon_enter(void)
-{
 #ifdef CONFIG_ADB_PMU
 	if (_machine == _MACH_Pmac) {
 		pmu_suspend();
 	}
 #endif
 }
-void
+void xmon_leave(void)
-xmon_leave(void)
 {

arch/powerpc/xmon/start_64.c

Diff comments View file @ fca5dcd

1	/*	1	/*
2	* Copyright (C) 1996 Paul Mackerras.	2	* Copyright (C) 1996 Paul Mackerras.
3	*	3	*
4	* This program is free software; you can redistribute it and/or	4	* This program is free software; you can redistribute it and/or
5	* modify it under the terms of the GNU General Public License	5	* modify it under the terms of the GNU General Public License
6	* as published by the Free Software Foundation; either version	6	* as published by the Free Software Foundation; either version
7	* 2 of the License, or (at your option) any later version.	7	* 2 of the License, or (at your option) any later version.
8	*/	8	*/
9	#include <linux/config.h>
10	#include <linux/string.h>
11	#include <linux/kernel.h>
12	#include <linux/errno.h>
13	#include <linux/sysrq.h>
14	#include <linux/init.h>
15	#include <asm/machdep.h>	9	#include <asm/machdep.h>
16	#include <asm/io.h>
17	#include <asm/page.h>
18	#include <asm/prom.h>
19	#include <asm/processor.h>
20	#include <asm/udbg.h>	10	#include <asm/udbg.h>
21	#include <asm/system.h>
22	#include "nonstdio.h"	11	#include "nonstdio.h"
23		12
24	#ifdef CONFIG_MAGIC_SYSRQ	13	void xmon_map_scc(void)
25
26	static void sysrq_handle_xmon(int key, struct pt_regs *pt_regs,
27	struct tty_struct *tty)
28	{	14	{
29	/* ensure xmon is enabled */
30	xmon_init(1);
31	debugger(pt_regs);
32	}	15	}
33		16
34	static struct sysrq_key_op sysrq_xmon_op =	17	int xmon_write(void *ptr, int nb)
35	{	18	{
36	.handler = sysrq_handle_xmon,
37	.help_msg = "Xmon",
38	.action_msg = "Entering xmon",
39	};
40
41	static int __init setup_xmon_sysrq(void)
42	{
43	register_sysrq_key('x', &sysrq_xmon_op);
44	return 0;
45	}
46	__initcall(setup_xmon_sysrq);
47	#endif /* CONFIG_MAGIC_SYSRQ */
48
49	int
50	xmon_write(void handle, void ptr, int nb)
51	{
52	return udbg_write(ptr, nb);	19	return udbg_write(ptr, nb);
53	}	20	}
54		21
55	int	22	int xmon_readchar(void)
56	xmon_read(void handle, void ptr, int nb)
57	{	23	{
58	return udbg_read(ptr, nb);	24	if (udbg_getc)
		25	return udbg_getc();
		26	return -1;
59	}	27	}
60		28
61	int	29	int xmon_read_poll(void)
62	xmon_read_poll(void)
63	{	30	{
64	if (udbg_getc_poll)	31	if (udbg_getc_poll)
65	return udbg_getc_poll();	32	return udbg_getc_poll();
66	return -1;	33	return -1;
67	}
68
69	FILE *xmon_stdin;
70	FILE *xmon_stdout;
71
72	int
73	xmon_putc(int c, void *f)
74	{
75	char ch = c;
76
77	if (c == '\n')
78	xmon_putc('\r', f);
79	return xmon_write(f, &ch, 1) == 1? c: -1;
80	}
81
82	int
83	xmon_putchar(int c)
84	{
85	return xmon_putc(c, xmon_stdout);
86	}
87
88	int
89	xmon_fputs(char str, void f)
90	{
91	int n = strlen(str);
92
93	return xmon_write(f, str, n) == n? 0: -1;
94	}
95
96	int
97	xmon_readchar(void)
98	{
99	char ch;
100
101	for (;;) {
102	switch (xmon_read(xmon_stdin, &ch, 1)) {
103	case 1:
104	return ch;
105	case -1:
106	xmon_printf("read(stdin) returned -1\r\n", 0, 0);
107	return -1;
108	}
109	}
110	}
111
112	static char line[256];
113	static char *lineptr;
114	static int lineleft;
115
116	int
117	xmon_getchar(void)
118	{
119	int c;
120
121	if (lineleft == 0) {
122	lineptr = line;
123	for (;;) {
124	c = xmon_readchar();
125	if (c == -1 \|\| c == 4)
126	break;
127	if (c == '\r' \|\| c == '\n') {
128	*lineptr++ = '\n';
129	xmon_putchar('\n');
130	break;
131	}
132	switch (c) {
133	case 0177:
134	case '\b':
135	if (lineptr > line) {
136	xmon_putchar('\b');
137	xmon_putchar(' ');
138	xmon_putchar('\b');
139	--lineptr;
140	}
141	break;
142	case 'U' & 0x1F:
143	while (lineptr > line) {
144	xmon_putchar('\b');
145	xmon_putchar(' ');
146	xmon_putchar('\b');
147	--lineptr;
148	}
149	break;
150	default:
151	if (lineptr >= &line[sizeof(line) - 1])
152	xmon_putchar('\a');
153	else {
154	xmon_putchar(c);
155	*lineptr++ = c;
156	}
157	}
158	}
159	lineleft = lineptr - line;
160	lineptr = line;
161	}
162	if (lineleft == 0)
163	return -1;
164	--lineleft;
165	return *lineptr++;
166	}
167
168	char *
169	xmon_fgets(char str, int nb, void f)
170	{
171	char *p;
172	int c;
173
174	for (p = str; p < str + nb - 1; ) {
175	c = xmon_getchar();
176	if (c == -1) {
177	if (p == str)
178	return NULL;
179	break;
180	}
181	*p++ = c;
182	if (c == '\n')
183	break;
184	}
185	*p = 0;
186	return str;

arch/powerpc/xmon/start_8xx.c

Diff comments View file @ fca5dcd

1	/*	1	/*
2	* Copyright (C) 1996 Paul Mackerras.	2	* Copyright (C) 1996 Paul Mackerras.
3	* Copyright (C) 2000 Dan Malek.	3	* Copyright (C) 2000 Dan Malek.
4	* Quick hack of Paul's code to make XMON work on 8xx processors. Lots	4	* Quick hack of Paul's code to make XMON work on 8xx processors. Lots
5	* of assumptions, like the SMC1 is used, it has been initialized by the	5	* of assumptions, like the SMC1 is used, it has been initialized by the
6	* loader at some point, and we can just stuff and suck bytes.	6	* loader at some point, and we can just stuff and suck bytes.
7	* We rely upon the 8xx uart driver to support us, as the interface	7	* We rely upon the 8xx uart driver to support us, as the interface
8	* changes between boot up and operational phases of the kernel.	8	* changes between boot up and operational phases of the kernel.
9	*/	9	*/
10	#include <linux/string.h>	10	#include <linux/string.h>
11	#include <asm/machdep.h>	11	#include <asm/machdep.h>
12	#include <asm/io.h>	12	#include <asm/io.h>
13	#include <asm/page.h>	13	#include <asm/page.h>
14	#include <linux/kernel.h>	14	#include <linux/kernel.h>
15	#include <asm/8xx_immap.h>	15	#include <asm/8xx_immap.h>
16	#include <asm/mpc8xx.h>	16	#include <asm/mpc8xx.h>
17	#include <asm/commproc.h>	17	#include <asm/commproc.h>
		18	#include "nonstdio.h"
18		19
19	extern void xmon_printf(const char *fmt, ...);
20	extern int xmon_8xx_write(char *str, int nb);	20	extern int xmon_8xx_write(char *str, int nb);
21	extern int xmon_8xx_read_poll(void);	21	extern int xmon_8xx_read_poll(void);
22	extern int xmon_8xx_read_char(void);	22	extern int xmon_8xx_read_char(void);
23	void prom_drawhex(uint);
24	void prom_drawstring(const char *str);
25		23
26	static int use_screen = 1; /* default */	24	void xmon_map_scc(void)
27
28	#define TB_SPEED 25000000
29
30	static inline unsigned int readtb(void)
31	{	25	{
32	unsigned int ret;
33
34	asm volatile("mftb %0" : "=r" (ret) :);
35	return ret;
36	}
37
38	void buf_access(void)
39	{
40	}
41
42	void
43	xmon_map_scc(void)
44	{
45
46	cpmp = (cpm8xx_t )&(((immap_t )IMAP_ADDR)->im_cpm);	26	cpmp = (cpm8xx_t )&(((immap_t )IMAP_ADDR)->im_cpm);
47	use_screen = 0;
48
49	prom_drawstring("xmon uses serial port\n");
50	}	27	}
51		28
52	static int scc_initialized = 0;
53
54	void xmon_init_scc(void);	29	void xmon_init_scc(void);
55		30
56	int	31	int xmon_write(void *ptr, int nb)
57	xmon_write(void handle, void ptr, int nb)
58	{	32	{
59	char *p = ptr;
60	int i, c, ct;
61
62	if (!scc_initialized)
63	xmon_init_scc();
64
65	return(xmon_8xx_write(ptr, nb));	33	return(xmon_8xx_write(ptr, nb));
66	}	34	}
67		35
68	int xmon_wants_key;	36	int xmon_readchar(void)
69
70	int
71	xmon_read(void handle, void ptr, int nb)
72	{	37	{
73	char *p = ptr;	38	return xmon_8xx_read_char();
74	int i;
75
76	if (!scc_initialized)
77	xmon_init_scc();
78
79	for (i = 0; i < nb; ++i) {
80	*p++ = xmon_8xx_read_char();
81	}
82	return i;
83	}	39	}
84		40
85	int	41	int xmon_read_poll(void)
86	xmon_read_poll(void)
87	{	42	{
88	return(xmon_8xx_read_poll());	43	return(xmon_8xx_read_poll());
89	}
90
91	void
92	xmon_init_scc()
93	{
94	scc_initialized = 1;
95	}
96
97	#if 0
98	extern int (prom_entry)(void );
99
100	int
101	xmon_exit(void)
102	{
103	struct prom_args {
104	char *service;
105	} args;
106
107	for (;;) {
108	args.service = "exit";
109	(*prom_entry)(&args);
110	}
111	}
112	#endif
113
114	void *xmon_stdin;
115	void *xmon_stdout;
116	void *xmon_stderr;
117
118	void
119	xmon_init(void)
120	{
121	}
122
123	int
124	xmon_putc(int c, void *f)
125	{
126	char ch = c;
127
128	if (c == '\n')
129	xmon_putc('\r', f);
130	return xmon_write(f, &ch, 1) == 1? c: -1;
131	}
132
133	int
134	xmon_putchar(int c)
135	{
136	return xmon_putc(c, xmon_stdout);
137	}
138
139	int
140	xmon_fputs(char str, void f)
141	{
142	int n = strlen(str);
143
144	return xmon_write(f, str, n) == n? 0: -1;
145	}
146
147	int
148	xmon_readchar(void)
149	{
150	char ch;
151
152	for (;;) {
153	switch (xmon_read(xmon_stdin, &ch, 1)) {
154	case 1:
155	return ch;
156	case -1:
157	xmon_printf("read(stdin) returned -1\r\n", 0, 0);
158	return -1;
159	}
160	}
161	}
162
163	static char line[256];
164	static char *lineptr;
165	static int lineleft;
166
167	#if 0
168	int xmon_expect(const char *str, unsigned int timeout)
169	{
170	int c;
171	unsigned int t0;
172
173	timeout *= TB_SPEED;
174	t0 = readtb();
175	do {
176	lineptr = line;
177	for (;;) {
178	c = xmon_read_poll();
179	if (c == -1) {
180	if (readtb() - t0 > timeout)
181	return 0;
182	continue;
183	}
184	if (c == '\n')
185	break;
186	if (c != '\r' && lineptr < &line[sizeof(line) - 1])
187	*lineptr++ = c;
188	}
189	*lineptr = 0;
190	} while (strstr(line, str) == NULL);
191	return 1;
192	}
193	#endif
194
195	int
196	xmon_getchar(void)
197	{
198	int c;
199
200	if (lineleft == 0) {
201	lineptr = line;
202	for (;;) {
203	c = xmon_readchar();
204	if (c == -1 \|\| c == 4)
205	break;
206	if (c == '\r' \|\| c == '\n') {
207	*lineptr++ = '\n';
208	xmon_putchar('\n');
209	break;
210	}
211	switch (c) {
212	case 0177:
213	case '\b':
214	if (lineptr > line) {
215	xmon_putchar('\b');
216	xmon_putchar(' ');
217	xmon_putchar('\b');
218	--lineptr;
219	}
220	break;
221	case 'U' & 0x1F:
222	while (lineptr > line) {
223	xmon_putchar('\b');
224	xmon_putchar(' ');
225	xmon_putchar('\b');
226	--lineptr;
227	}
228	break;
229	default:
230	if (lineptr >= &line[sizeof(line) - 1])
231	xmon_putchar('\a');
232	else {
233	xmon_putchar(c);
234	*lineptr++ = c;
235	}
236	}
237	}
238	lineleft = lineptr - line;
239	lineptr = line;
240	}
241	if (lineleft == 0)
242	return -1;
243	--lineleft;
244	return *lineptr++;
245	}
246
247	char *
248	xmon_fgets(char str, int nb, void f)
249	{
250	char *p;
251	int c;
252
253	for (p = str; p < str + nb - 1; ) {
254	c = xmon_getchar();
255	if (c == -1) {
256	if (p == str)
257	return 0;
258	break;
259	}
260	*p++ = c;
261	if (c == '\n')
262	break;
263	}
264	*p = 0;
265	return str;
266	}
267
268	void
269	prom_drawhex(uint val)
270	{
271	unsigned char buf[10];
272
273	int i;
274	for (i = 7; i >= 0; i--)
275	{
276	buf[i] = "0123456789abcdef"[val & 0x0f];
277	val >>= 4;
278	}
279	buf[8] = '\0';
280	xmon_fputs(buf, xmon_stdout);
281	}
282
283	void
284	prom_drawstring(const char *str)
285	{
286	xmon_fputs(str, xmon_stdout);
287	}	44	}

arch/powerpc/xmon/subr_prf.c

View file @ fca5dcd

1	/*		File was deleted
2	* Written by Cort Dougan to replace the version originally used
3	* by Paul Mackerras, which came from NetBSD and thus had copyright
4	* conflicts with Linux.
5	*
6	* This file makes liberal use of the standard linux utility
7	* routines to reduce the size of the binary. We assume we can
8	* trust some parts of Linux inside the debugger.
9	* -- Cort (cort@cs.nmt.edu)
10	*
11	* Copyright (C) 1999 Cort Dougan.
12	*
13	* This program is free software; you can redistribute it and/or
14	* modify it under the terms of the GNU General Public License
15	* as published by the Free Software Foundation; either version
16	* 2 of the License, or (at your option) any later version.
17	*/
18
19	#include <linux/kernel.h>
20	#include <linux/string.h>
21	#include <linux/module.h>
22	#include <stdarg.h>
23	#include "nonstdio.h"
24
25	extern int xmon_write(void , void , int);
26
27	void xmon_vfprintf(void f, const char fmt, va_list ap)
28	{
29	static char xmon_buf[2048];
30	int n;
31
32	n = vsprintf(xmon_buf, fmt, ap);
33	xmon_write(f, xmon_buf, n);
34	}
35
36	void xmon_printf(const char *fmt, ...)
37	{
38	va_list ap;
39
40	va_start(ap, fmt);
41	xmon_vfprintf(stdout, fmt, ap);
42	va_end(ap);
43	}
44	EXPORT_SYMBOL(xmon_printf);
45
46	void xmon_fprintf(void f, const char fmt, ...)
47	{
48	va_list ap;
49
50	va_start(ap, fmt);
51	xmon_vfprintf(f, fmt, ap);
52	va_end(ap);
53	}
54		1	/*
55		2	* Written by Cort Dougan to replace the version originally used

arch/powerpc/xmon/xmon.c

Diff comments View file @ fca5dcd

 /*
  * Routines providing a simple monitor for use on the PowerMac.
  *
- * Copyright (C) 1996 Paul Mackerras.
+ * Copyright (C) 1996-2005 Paul Mackerras.
  *
  *      This program is free software; you can redistribute it and/or
  *      modify it under the terms of the GNU General Public License
  *      as published by the Free Software Foundation; either version
  *      2 of the License, or (at your option) any later version.
  */
 #include <linux/config.h>
 #include <linux/errno.h>
 #include <linux/sched.h>
 #include <linux/smp.h>
 #include <linux/mm.h>
 #include <linux/reboot.h>
 #include <linux/delay.h>
 #include <linux/kallsyms.h>
 #include <linux/cpumask.h>
 #include <linux/module.h>
+#include <linux/sysrq.h>
 #include <asm/ptrace.h>
 #include <asm/string.h>
 #include <asm/prom.h>
 #include <asm/machdep.h>
 #include <asm/xmon.h>
 #ifdef CONFIG_PMAC_BACKLIGHT
 #include <asm/backlight.h>
 #endif
 #include <asm/processor.h>
 #include <asm/pgtable.h>
 #include <asm/mmu.h>
 #include <asm/mmu_context.h>
 #include <asm/cputable.h>
 #include <asm/rtas.h>
 #include <asm/sstep.h>
 #include <asm/bug.h>
 #ifdef CONFIG_PPC64
 #include <asm/hvcall.h>
 #include <asm/paca.h>
 #endif
 #include "nonstdio.h"
 #define scanhex	xmon_scanhex
 #define skipbl	xmon_skipbl
 #ifdef CONFIG_SMP
 cpumask_t cpus_in_xmon = CPU_MASK_NONE;
 static unsigned long xmon_taken = 1;
 static int xmon_owner;
 static int xmon_gate;
 #endif /* CONFIG_SMP */
 static unsigned long in_xmon = 0;
 static unsigned long adrs;
 static int size = 1;
 #define MAX_DUMP (128 * 1024)
 static unsigned long ndump = 64;
 static unsigned long nidump = 16;
 static unsigned long ncsum = 4096;
 static int termch;
 static char tmpstr[128];
 #define JMP_BUF_LEN	23
 static long bus_error_jmp[JMP_BUF_LEN];
 static int catch_memory_errors;
 static long *xmon_fault_jmp[NR_CPUS];
 #define setjmp xmon_setjmp
 #define longjmp xmon_longjmp
 /* Breakpoint stuff */
 struct bpt {
 	unsigned long	address;
 	unsigned int	instr[2];
 	atomic_t	ref_count;
 	int		enabled;
 	unsigned long	pad;
 };
 /* Bits in bpt.enabled */
 #define BP_IABR_TE	1		/* IABR translation enabled */
 #define BP_IABR		2
 #define BP_TRAP		8
 #define BP_DABR		0x10
 #define NBPTS	256
 static struct bpt bpts[NBPTS];
 static struct bpt dabr;
 static struct bpt *iabr;
 static unsigned bpinstr = 0x7fe00008;	/* trap */
 #define BP_NUM(bp)	((bp) - bpts + 1)
 /* Prototypes */
 static int cmds(struct pt_regs *);
 static int mread(unsigned long, void *, int);
 static int mwrite(unsigned long, void *, int);
 static int handle_fault(struct pt_regs *);
 static void byterev(unsigned char *, int);
 static void memex(void);
 static int bsesc(void);
 static void dump(void);
 static void prdump(unsigned long, long);
 static int ppc_inst_dump(unsigned long, long, int);
 void print_address(unsigned long);
 static void backtrace(struct pt_regs *);
 static void excprint(struct pt_regs *);
 static void prregs(struct pt_regs *);
 static void memops(int);
 static void memlocate(void);
 static void memzcan(void);
 static void memdiffs(unsigned char *, unsigned char *, unsigned, unsigned);
 int skipbl(void);
 int scanhex(unsigned long *valp);
 static void scannl(void);
 static int hexdigit(int);
 void getstring(char *, int);
 static void flush_input(void);
 static int inchar(void);
 static void take_input(char *);
 static unsigned long read_spr(int);
 static void write_spr(int, unsigned long);
 static void super_regs(void);
 static void remove_bpts(void);
 static void insert_bpts(void);
 static void remove_cpu_bpts(void);
 static void insert_cpu_bpts(void);
 static struct bpt *at_breakpoint(unsigned long pc);
 static struct bpt *in_breakpoint_table(unsigned long pc, unsigned long *offp);
 static int  do_step(struct pt_regs *);
 static void bpt_cmds(void);
 static void cacheflush(void);
 static int  cpu_cmd(void);
 static void csum(void);
 static void bootcmds(void);
 static void proccall(void);
 void dump_segments(void);
 static void symbol_lookup(void);
 static void xmon_print_symbol(unsigned long address, const char *mid,
 			      const char *after);
 static const char *getvecname(unsigned long vec);
 extern int print_insn_powerpc(unsigned long, unsigned long, int);
-extern void printf(const char *fmt, ...);
-extern void xmon_vfprintf(void *f, const char *fmt, va_list ap);
-extern int xmon_putc(int c, void *f);
-extern int putchar(int ch);
 extern void xmon_enter(void);
 extern void xmon_leave(void);
-extern int xmon_read_poll(void);
 extern long setjmp(long *);
 extern void longjmp(long *, long);
 extern void xmon_save_regs(struct pt_regs *);
 #ifdef CONFIG_PPC64
 #define REG		"%.16lx"
 #define REGS_PER_LINE	4
 #define LAST_VOLATILE	13
 #else
 #define REG		"%.8lx"
 #define REGS_PER_LINE	8
 #define LAST_VOLATILE	12
 #endif
 #define GETWORD(v)	(((v)[0] << 24) + ((v)[1] << 16) + ((v)[2] << 8) + (v)[3])
 #define isxdigit(c)	(('0' <= (c) && (c) <= '9') \
 			 || ('a' <= (c) && (c) <= 'f') \
 			 || ('A' <= (c) && (c) <= 'F'))
 #define isalnum(c)	(('0' <= (c) && (c) <= '9') \
 			 || ('a' <= (c) && (c) <= 'z') \
 			 || ('A' <= (c) && (c) <= 'Z'))
 #define isspace(c)	(c == ' ' || c == '\t' || c == 10 || c == 13 || c == 0)
 static char *help_string = "\
 Commands:\n\
   b	show breakpoints\n\
   bd	set data breakpoint\n\
   bi	set instruction breakpoint\n\
   bc	clear breakpoint\n"
 #ifdef CONFIG_SMP
   "\
   c	print cpus stopped in xmon\n\
   c#	try to switch to cpu number h (in hex)\n"
 #endif
   "\
   C	checksum\n\
   d	dump bytes\n\
   di	dump instructions\n\
   df	dump float values\n\
   dd	dump double values\n\
   e	print exception information\n\
   f	flush cache\n\
   la	lookup symbol+offset of specified address\n\
   ls	lookup address of specified symbol\n\
   m	examine/change memory\n\
   mm	move a block of memory\n\
   ms	set a block of memory\n\
   md	compare two blocks of memory\n\
   ml	locate a block of memory\n\
   mz	zero a block of memory\n\
   mi	show information about memory allocation\n\
   p 	call a procedure\n\
   r	print registers\n\
   s	single step\n\
   S	print special registers\n\
   t	print backtrace\n\
   x	exit monitor and recover\n\
   X	exit monitor and dont recover\n"
 #ifdef CONFIG_PPC64
 "  u	dump segment table or SLB\n"
 #endif
 #ifdef CONFIG_PPC_STD_MMU_32
 "  u	dump segment registers\n"
 #endif
 "  ?	help\n"
 "  zr	reboot\n\
   zh	halt\n"
 ;
 static struct pt_regs *xmon_regs;
 static inline void sync(void)
 {
 	asm volatile("sync; isync");
 }
 static inline void store_inst(void *p)
 {
 	asm volatile ("dcbst 0,%0; sync; icbi 0,%0; isync" : : "r" (p));
 }
 static inline void cflush(void *p)
 {
 	asm volatile ("dcbf 0,%0; icbi 0,%0" : : "r" (p));
 }
 static inline void cinval(void *p)
 {
 	asm volatile ("dcbi 0,%0; icbi 0,%0" : : "r" (p));
 }
 /*
  * Disable surveillance (the service processor watchdog function)
  * while we are in xmon.
  * XXX we should re-enable it when we leave. :)
  */
 #define SURVEILLANCE_TOKEN	9000
 static inline void disable_surveillance(void)
 {
 #ifdef CONFIG_PPC_PSERIES
 	/* Since this can't be a module, args should end up below 4GB. */
 	static struct rtas_args args;
 	/*
 	 * At this point we have got all the cpus we can into
 	 * xmon, so there is hopefully no other cpu calling RTAS
 	 * at the moment, even though we don't take rtas.lock.
 	 * If we did try to take rtas.lock there would be a
 	 * real possibility of deadlock.
 	 */
 	args.token = rtas_token("set-indicator");
 	if (args.token == RTAS_UNKNOWN_SERVICE)
 		return;
 	args.nargs = 3;
 	args.nret = 1;
 	args.rets = &args.args[3];
 	args.args[0] = SURVEILLANCE_TOKEN;
 	args.args[1] = 0;
 	args.args[2] = 0;
 	enter_rtas(__pa(&args));
 #endif /* CONFIG_PPC_PSERIES */
 }
 #ifdef CONFIG_SMP
 static int xmon_speaker;
 static void get_output_lock(void)
 {
 	int me = smp_processor_id() + 0x100;
 	int last_speaker = 0, prev;
 	long timeout;
 	if (xmon_speaker == me)
 		return;
 	for (;;) {
 		if (xmon_speaker == 0) {
 			last_speaker = cmpxchg(&xmon_speaker, 0, me);
 			if (last_speaker == 0)
 				return;
 		}
 		timeout = 10000000;
 		while (xmon_speaker == last_speaker) {
 			if (--timeout > 0)
 				continue;
 			/* hostile takeover */
 			prev = cmpxchg(&xmon_speaker, last_speaker, me);
 			if (prev == last_speaker)
 				return;
 			break;
 		}
 	}
 }
 static void release_output_lock(void)
 {
 	xmon_speaker = 0;
 }
 #endif
 int xmon_core(struct pt_regs *regs, int fromipi)
 {
 	int cmd = 0;
 	unsigned long msr;
 	struct bpt *bp;
 	long recurse_jmp[JMP_BUF_LEN];
 	unsigned long offset;
 #ifdef CONFIG_SMP
 	int cpu;
 	int secondary;
 	unsigned long timeout;
 #endif
 	msr = mfmsr();
 	mtmsr(msr & ~MSR_EE);	/* disable interrupts */
 	bp = in_breakpoint_table(regs->nip, &offset);
 	if (bp != NULL) {
 		regs->nip = bp->address + offset;
 		atomic_dec(&bp->ref_count);
 	}
 	remove_cpu_bpts();
 #ifdef CONFIG_SMP
 	cpu = smp_processor_id();
 	if (cpu_isset(cpu, cpus_in_xmon)) {
 		get_output_lock();
 		excprint(regs);
 		printf("cpu 0x%x: Exception %lx %s in xmon, "
 		       "returning to main loop\n",
 		       cpu, regs->trap, getvecname(TRAP(regs)));
 		release_output_lock();
 		longjmp(xmon_fault_jmp[cpu], 1);
 	}
 	if (setjmp(recurse_jmp) != 0) {
 		if (!in_xmon || !xmon_gate) {
 			get_output_lock();
 			printf("xmon: WARNING: bad recursive fault "
 			       "on cpu 0x%x\n", cpu);
 			release_output_lock();
 			goto waiting;
 		}
 		secondary = !(xmon_taken && cpu == xmon_owner);
 		goto cmdloop;
 	}
 	xmon_fault_jmp[cpu] = recurse_jmp;
 	cpu_set(cpu, cpus_in_xmon);
 	bp = NULL;
 	if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) == (MSR_IR|MSR_SF))
 		bp = at_breakpoint(regs->nip);
 	if (bp || (regs->msr & MSR_RI) == 0)
 		fromipi = 0;
 	if (!fromipi) {
 		get_output_lock();
 		excprint(regs);
 		if (bp) {
 			printf("cpu 0x%x stopped at breakpoint 0x%x (",
 			       cpu, BP_NUM(bp));
 			xmon_print_symbol(regs->nip, " ", ")\n");
 		}
 		if ((regs->msr & MSR_RI) == 0)
 			printf("WARNING: exception is not recoverable, "
 			       "can't continue\n");
 		release_output_lock();
 	}
  waiting:
 	secondary = 1;
 	while (secondary && !xmon_gate) {
 		if (in_xmon == 0) {
 			if (fromipi)
 				goto leave;
 			secondary = test_and_set_bit(0, &in_xmon);
 		}
 		barrier();
 	}
 	if (!secondary && !xmon_gate) {
 		/* we are the first cpu to come in */
 		/* interrupt other cpu(s) */
 		int ncpus = num_online_cpus();
 		xmon_owner = cpu;
 		mb();
 		if (ncpus > 1) {
 			smp_send_debugger_break(MSG_ALL_BUT_SELF);
 			/* wait for other cpus to come in */
 			for (timeout = 100000000; timeout != 0; --timeout) {
 				if (cpus_weight(cpus_in_xmon) >= ncpus)
 					break;
 				barrier();
 			}
 		}
 		remove_bpts();
 		disable_surveillance();
 		/* for breakpoint or single step, print the current instr. */
 		if (bp || TRAP(regs) == 0xd00)
 			ppc_inst_dump(regs->nip, 1, 0);
 		printf("enter ? for help\n");
 		mb();
 		xmon_gate = 1;
 		barrier();
 	}
  cmdloop:
 	while (in_xmon) {
 		if (secondary) {
 			if (cpu == xmon_owner) {
 				if (!test_and_set_bit(0, &xmon_taken)) {
 					secondary = 0;
 					continue;
 				}
 				/* missed it */
 				while (cpu == xmon_owner)
 					barrier();
 			}
 			barrier();
 		} else {
 			cmd = cmds(regs);
 			if (cmd != 0) {
 				/* exiting xmon */
 				insert_bpts();
 				xmon_gate = 0;
 				wmb();
 				in_xmon = 0;
 				break;
 			}
 			/* have switched to some other cpu */
 			secondary = 1;
 		}
 	}
  leave:
 	cpu_clear(cpu, cpus_in_xmon);
 	xmon_fault_jmp[cpu] = NULL;
 #else
 	/* UP is simple... */
 	if (in_xmon) {
 		printf("Exception %lx %s in xmon, returning to main loop\n",
 		       regs->trap, getvecname(TRAP(regs)));
 		longjmp(xmon_fault_jmp[0], 1);
 	}
 	if (setjmp(recurse_jmp) == 0) {
 		xmon_fault_jmp[0] = recurse_jmp;
 		in_xmon = 1;
 		excprint(regs);
 		bp = at_breakpoint(regs->nip);
 		if (bp) {
 			printf("Stopped at breakpoint %x (", BP_NUM(bp));
 			xmon_print_symbol(regs->nip, " ", ")\n");
 		}
 		if ((regs->msr & MSR_RI) == 0)
 			printf("WARNING: exception is not recoverable, "
 			       "can't continue\n");
 		remove_bpts();
 		disable_surveillance();
 		/* for breakpoint or single step, print the current instr. */
 		if (bp || TRAP(regs) == 0xd00)
 			ppc_inst_dump(regs->nip, 1, 0);
 		printf("enter ? for help\n");
 	}
 	cmd = cmds(regs);
 	insert_bpts();
 	in_xmon = 0;
 #endif
 	if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) == (MSR_IR|MSR_SF)) {
 		bp = at_breakpoint(regs->nip);
 		if (bp != NULL) {
 			int stepped = emulate_step(regs, bp->instr[0]);
 			if (stepped == 0) {
 				regs->nip = (unsigned long) &bp->instr[0];
 				atomic_inc(&bp->ref_count);
 			} else if (stepped < 0) {
 				printf("Couldn't single-step %s instruction\n",
 				    (IS_RFID(bp->instr[0])? "rfid": "mtmsrd"));
 			}
 		}
 	}
 	insert_cpu_bpts();
 	mtmsr(msr);		/* restore interrupt enable */
 	return cmd != 'X';
 }
 int xmon(struct pt_regs *excp)
 {
 	struct pt_regs regs;
 	if (excp == NULL) {
 		xmon_save_regs(&regs);
 		excp = &regs;
 	}
 	return xmon_core(excp, 0);
 }
 EXPORT_SYMBOL(xmon);
 irqreturn_t
 xmon_irq(int irq, void *d, struct pt_regs *regs)
 {
 	unsigned long flags;
 	local_irq_save(flags);
 	printf("Keyboard interrupt\n");
 	xmon(regs);
 	local_irq_restore(flags);
 	return IRQ_HANDLED;
 }
 int xmon_bpt(struct pt_regs *regs)
 {
 	struct bpt *bp;
 	unsigned long offset;
 	if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) != (MSR_IR|MSR_SF))
 		return 0;
 	/* Are we at the trap at bp->instr[1] for some bp? */
 	bp = in_breakpoint_table(regs->nip, &offset);
 	if (bp != NULL && offset == 4) {
 		regs->nip = bp->address + 4;
 		atomic_dec(&bp->ref_count);
 		return 1;
 	}
 	/* Are we at a breakpoint? */
 	bp = at_breakpoint(regs->nip);
 	if (!bp)
 		return 0;
 	xmon_core(regs, 0);
 	return 1;
 }
 int xmon_sstep(struct pt_regs *regs)
 {
 	if (user_mode(regs))
 		return 0;
 	xmon_core(regs, 0);
 	return 1;
 }
 int xmon_dabr_match(struct pt_regs *regs)
 {
 	if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) != (MSR_IR|MSR_SF))
 		return 0;
 	if (dabr.enabled == 0)
 		return 0;
 	xmon_core(regs, 0);
 	return 1;
 }
 int xmon_iabr_match(struct pt_regs *regs)
 {
 	if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) != (MSR_IR|MSR_SF))
 		return 0;
 	if (iabr == 0)
 		return 0;
 	xmon_core(regs, 0);
 	return 1;
 }
 int xmon_ipi(struct pt_regs *regs)
 {
 #ifdef CONFIG_SMP
 	if (in_xmon && !cpu_isset(smp_processor_id(), cpus_in_xmon))
 		xmon_core(regs, 1);
 #endif
 	return 0;
 }
 int xmon_fault_handler(struct pt_regs *regs)
 {
 	struct bpt *bp;
 	unsigned long offset;
 	if (in_xmon && catch_memory_errors)
 		handle_fault(regs);	/* doesn't return */
 	if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) == (MSR_IR|MSR_SF)) {
 		bp = in_breakpoint_table(regs->nip, &offset);
 		if (bp != NULL) {
 			regs->nip = bp->address + offset;
 			atomic_dec(&bp->ref_count);
 		}
 	}
 	return 0;
 }
 static struct bpt *at_breakpoint(unsigned long pc)
 {
 	int i;
 	struct bpt *bp;
 	bp = bpts;
 	for (i = 0; i < NBPTS; ++i, ++bp)
 		if (bp->enabled && pc == bp->address)
 			return bp;
 	return NULL;
 }
 static struct bpt *in_breakpoint_table(unsigned long nip, unsigned long *offp)
 {
 	unsigned long off;
 	off = nip - (unsigned long) bpts;
 	if (off >= sizeof(bpts))
 		return NULL;
 	off %= sizeof(struct bpt);
 	if (off != offsetof(struct bpt, instr[0])
 	    && off != offsetof(struct bpt, instr[1]))
 		return NULL;
 	*offp = off - offsetof(struct bpt, instr[0]);
 	return (struct bpt *) (nip - off);
 }
 static struct bpt *new_breakpoint(unsigned long a)
 {
 	struct bpt *bp;
 	a &= ~3UL;
 	bp = at_breakpoint(a);
 	if (bp)
 		return bp;
 	for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
 		if (!bp->enabled && atomic_read(&bp->ref_count) == 0) {
 			bp->address = a;
 			bp->instr[1] = bpinstr;
 			store_inst(&bp->instr[1]);
 			return bp;
 		}
 	}
 	printf("Sorry, no free breakpoints.  Please clear one first.\n");
 	return NULL;
 }
 static void insert_bpts(void)
 {
 	int i;
 	struct bpt *bp;
 	bp = bpts;
 	for (i = 0; i < NBPTS; ++i, ++bp) {
 		if ((bp->enabled & (BP_TRAP|BP_IABR)) == 0)
 			continue;
 		if (mread(bp->address, &bp->instr[0], 4) != 4) {
 			printf("Couldn't read instruction at %lx, "
 			       "disabling breakpoint there\n", bp->address);
 			bp->enabled = 0;
 			continue;
 		}
 		if (IS_MTMSRD(bp->instr[0]) || IS_RFID(bp->instr[0])) {
 			printf("Breakpoint at %lx is on an mtmsrd or rfid "
 			       "instruction, disabling it\n", bp->address);
 			bp->enabled = 0;
 			continue;
 		}
 		store_inst(&bp->instr[0]);
 		if (bp->enabled & BP_IABR)
 			continue;
 		if (mwrite(bp->address, &bpinstr, 4) != 4) {
 			printf("Couldn't write instruction at %lx, "
 			       "disabling breakpoint there\n", bp->address);
 			bp->enabled &= ~BP_TRAP;
 			continue;
 		}
 		store_inst((void *)bp->address);
 	}
 }
 static void insert_cpu_bpts(void)
 {
 	if (dabr.enabled)
 		set_dabr(dabr.address | (dabr.enabled & 7));
 	if (iabr && cpu_has_feature(CPU_FTR_IABR))
 		mtspr(SPRN_IABR, iabr->address
 			 | (iabr->enabled & (BP_IABR|BP_IABR_TE)));
 }
 static void remove_bpts(void)
 {
 	int i;
 	struct bpt *bp;
 	unsigned instr;
 	bp = bpts;
 	for (i = 0; i < NBPTS; ++i, ++bp) {
 		if ((bp->enabled & (BP_TRAP|BP_IABR)) != BP_TRAP)
 			continue;
 		if (mread(bp->address, &instr, 4) == 4
 		    && instr == bpinstr
 		    && mwrite(bp->address, &bp->instr, 4) != 4)
 			printf("Couldn't remove breakpoint at %lx\n",
 			       bp->address);
 		else
 			store_inst((void *)bp->address);
 	}
 }
 static void remove_cpu_bpts(void)
 {
 	set_dabr(0);
 	if (cpu_has_feature(CPU_FTR_IABR))
 		mtspr(SPRN_IABR, 0);
 }
 /* Command interpreting routine */
 static char *last_cmd;
 static int
 cmds(struct pt_regs *excp)
 {
 	int cmd = 0;
 	last_cmd = NULL;
 	xmon_regs = excp;
 	for(;;) {
 #ifdef CONFIG_SMP
 		printf("%x:", smp_processor_id());
 #endif /* CONFIG_SMP */
 		printf("mon> ");
-		fflush(stdout);
 		flush_input();
 		termch = 0;
 		cmd = skipbl();
 		if( cmd == '\n' ) {
 			if (last_cmd == NULL)
 				continue;
 			take_input(last_cmd);
 			last_cmd = NULL;
 			cmd = inchar();
 		}
 		switch (cmd) {
 		case 'm':
 			cmd = inchar();
 			switch (cmd) {
 			case 'm':
 			case 's':
 			case 'd':
 				memops(cmd);
 				break;
 			case 'l':
 				memlocate();
 				break;
 			case 'z':
 				memzcan();
 				break;
 			case 'i':
 				show_mem();
 				break;
 			default:
 				termch = cmd;
 				memex();
 			}
 			break;
 		case 'd':
 			dump();
 			break;
 		case 'l':
 			symbol_lookup();
 			break;
 		case 'r':
 			prregs(excp);	/* print regs */
 			break;
 		case 'e':
 			excprint(excp);
 			break;
 		case 'S':
 			super_regs();
 			break;
 		case 't':
 			backtrace(excp);
 			break;
 		case 'f':
 			cacheflush();
 			break;
 		case 's':
 			if (do_step(excp))
 				return cmd;
 			break;
 		case 'x':
 		case 'X':
 		case EOF:
 			return cmd;
 		case '?':
 			printf(help_string);
 			break;
 		case 'b':
 			bpt_cmds();
 			break;
 		case 'C':
 			csum();
 			break;
 		case 'c':
 			if (cpu_cmd())
 				return 0;
 			break;
 		case 'z':
 			bootcmds();
 			break;
 		case 'p':
 			proccall();
 			break;
 #ifdef CONFIG_PPC_STD_MMU
 		case 'u':
 			dump_segments();
 			break;
 #endif
 		default:
 			printf("Unrecognized command: ");
 		        do {
 				if (' ' < cmd && cmd <= '~')
 					putchar(cmd);
 				else
 					printf("\\x%x", cmd);
 				cmd = inchar();
 		        } while (cmd != '\n');
 			printf(" (type ? for help)\n");
 			break;
 		}
 	}
 }
 /*
  * Step a single instruction.
  * Some instructions we emulate, others we execute with MSR_SE set.
  */
 static int do_step(struct pt_regs *regs)
 {
 	unsigned int instr;
 	int stepped;
 	/* check we are in 64-bit kernel mode, translation enabled */
 	if ((regs->msr & (MSR_SF|MSR_PR|MSR_IR)) == (MSR_SF|MSR_IR)) {
 		if (mread(regs->nip, &instr, 4) == 4) {
 			stepped = emulate_step(regs, instr);
 			if (stepped < 0) {
 				printf("Couldn't single-step %s instruction\n",
 				       (IS_RFID(instr)? "rfid": "mtmsrd"));
 				return 0;
 			}
 			if (stepped > 0) {
 				regs->trap = 0xd00 | (regs->trap & 1);
 				printf("stepped to ");
 				xmon_print_symbol(regs->nip, " ", "\n");
 				ppc_inst_dump(regs->nip, 1, 0);
 				return 0;
 			}
 		}
 	}
 	regs->msr |= MSR_SE;
 	return 1;
 }
 static void bootcmds(void)
 {
 	int cmd;
 	cmd = inchar();
 	if (cmd == 'r')
 		ppc_md.restart(NULL);
 	else if (cmd == 'h')
 		ppc_md.halt();
 	else if (cmd == 'p')
 		ppc_md.power_off();
 }
 static int cpu_cmd(void)
 {
 #ifdef CONFIG_SMP
 	unsigned long cpu;
 	int timeout;
 	int count;
 	if (!scanhex(&cpu)) {
 		/* print cpus waiting or in xmon */
 		printf("cpus stopped:");
 		count = 0;
 		for (cpu = 0; cpu < NR_CPUS; ++cpu) {
 			if (cpu_isset(cpu, cpus_in_xmon)) {
 				if (count == 0)
 					printf(" %x", cpu);
 				++count;
 			} else {
 				if (count > 1)
 					printf("-%x", cpu - 1);
 				count = 0;
 			}
 		}
 		if (count > 1)
 			printf("-%x", NR_CPUS - 1);
 		printf("\n");
 		return 0;
 	}
 	/* try to switch to cpu specified */
 	if (!cpu_isset(cpu, cpus_in_xmon)) {
 		printf("cpu 0x%x isn't in xmon\n", cpu);
 		return 0;
 	}
 	xmon_taken = 0;
 	mb();
 	xmon_owner = cpu;
 	timeout = 10000000;
 	while (!xmon_taken) {
 		if (--timeout == 0) {
 			if (test_and_set_bit(0, &xmon_taken))
 				break;
 			/* take control back */
 			mb();
 			xmon_owner = smp_processor_id();
 			printf("cpu %u didn't take control\n", cpu);
 			return 0;
 		}
 		barrier();
 	}
 	return 1;
 #else
 	return 0;
 #endif /* CONFIG_SMP */
 }
 static unsigned short fcstab[256] = {
 	0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
 	0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
 	0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
 	0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
 	0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
 	0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
 	0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
 	0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
 	0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
 	0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
 	0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
 	0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
 	0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
 	0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
 	0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
 	0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
 	0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
 	0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
 	0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
 	0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
 	0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
 	0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
 	0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
 	0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
 	0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
 	0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
 	0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
 	0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
 	0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
 	0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
 	0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
 	0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
 };
 #define FCS(fcs, c)	(((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff])
 static void
 csum(void)
 {
 	unsigned int i;
 	unsigned short fcs;
 	unsigned char v;
 	if (!scanhex(&adrs))
 		return;
 	if (!scanhex(&ncsum))
 		return;
 	fcs = 0xffff;
 	for (i = 0; i < ncsum; ++i) {
 		if (mread(adrs+i, &v, 1) == 0) {
 			printf("csum stopped at %x\n", adrs+i);
 			break;
 		}
 		fcs = FCS(fcs, v);
 	}
 	printf("%x\n", fcs);
 }
 /*
  * Check if this is a suitable place to put a breakpoint.
  */
 static long check_bp_loc(unsigned long addr)
 {
 	unsigned int instr;
 	addr &= ~3;
 	if (addr < KERNELBASE) {
 		printf("Breakpoints may only be placed at kernel addresses\n");
 		return 0;
 	}
 	if (!mread(addr, &instr, sizeof(instr))) {
 		printf("Can't read instruction at address %lx\n", addr);
 		return 0;
 	}
 	if (IS_MTMSRD(instr) || IS_RFID(instr)) {
 		printf("Breakpoints may not be placed on mtmsrd or rfid "
 		       "instructions\n");
 		return 0;
 	}
 	return 1;
 }
 static char *breakpoint_help_string =
     "Breakpoint command usage:\n"
     "b                show breakpoints\n"
     "b <addr> [cnt]   set breakpoint at given instr addr\n"
     "bc               clear all breakpoints\n"
     "bc <n/addr>      clear breakpoint number n or at addr\n"
     "bi <addr> [cnt]  set hardware instr breakpoint (POWER3/RS64 only)\n"
     "bd <addr> [cnt]  set hardware data breakpoint\n"
     "";
 static void
 bpt_cmds(void)
 {
 	int cmd;
 	unsigned long a;
 	int mode, i;
 	struct bpt *bp;
 	const char badaddr[] = "Only kernel addresses are permitted "
 		"for breakpoints\n";
 	cmd = inchar();
 	switch (cmd) {
 #ifndef CONFIG_8xx
 	case 'd':	/* bd - hardware data breakpoint */
 		mode = 7;
 		cmd = inchar();
 		if (cmd == 'r')
 			mode = 5;
 		else if (cmd == 'w')
 			mode = 6;
 		else
 			termch = cmd;
 		dabr.address = 0;
 		dabr.enabled = 0;
 		if (scanhex(&dabr.address)) {
 			if (dabr.address < KERNELBASE) {
 				printf(badaddr);
 				break;
 			}
 			dabr.address &= ~7;
 			dabr.enabled = mode | BP_DABR;
 		}
 		break;
 	case 'i':	/* bi - hardware instr breakpoint */
 		if (!cpu_has_feature(CPU_FTR_IABR)) {
 			printf("Hardware instruction breakpoint "
 			       "not supported on this cpu\n");
 			break;
 		}
 		if (iabr) {
 			iabr->enabled &= ~(BP_IABR | BP_IABR_TE);
 			iabr = NULL;
 		}
 		if (!scanhex(&a))
 			break;
 		if (!check_bp_loc(a))
 			break;
 		bp = new_breakpoint(a);
 		if (bp != NULL) {
 			bp->enabled |= BP_IABR | BP_IABR_TE;
 			iabr = bp;
 		}
 		break;
 #endif
 	case 'c':
 		if (!scanhex(&a)) {
 			/* clear all breakpoints */
 			for (i = 0; i < NBPTS; ++i)
 				bpts[i].enabled = 0;
 			iabr = NULL;
 			dabr.enabled = 0;
 			printf("All breakpoints cleared\n");
 			break;
 		}
 		if (a <= NBPTS && a >= 1) {
 			/* assume a breakpoint number */
 			bp = &bpts[a-1];	/* bp nums are 1 based */
 		} else {
 			/* assume a breakpoint address */
 			bp = at_breakpoint(a);
 			if (bp == 0) {
 				printf("No breakpoint at %x\n", a);
 				break;
 			}
 		}
 		printf("Cleared breakpoint %x (", BP_NUM(bp));
 		xmon_print_symbol(bp->address, " ", ")\n");
 		bp->enabled = 0;
 		break;
 	default:
 		termch = cmd;
 	        cmd = skipbl();
 		if (cmd == '?') {
 			printf(breakpoint_help_string);
 			break;
 		}
 		termch = cmd;
 		if (!scanhex(&a)) {
 			/* print all breakpoints */
 			printf("   type            address\n");
 			if (dabr.enabled) {
 				printf("   data   "REG"  [", dabr.address);
 				if (dabr.enabled & 1)
 					printf("r");
 				if (dabr.enabled & 2)
 					printf("w");
 				printf("]\n");
 			}
 			for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
 				if (!bp->enabled)
 					continue;
 				printf("%2x %s   ", BP_NUM(bp),
 				    (bp->enabled & BP_IABR)? "inst": "trap");
 				xmon_print_symbol(bp->address, "  ", "\n");
 			}
 			break;
 		}
 		if (!check_bp_loc(a))
 			break;
 		bp = new_breakpoint(a);
 		if (bp != NULL)
 			bp->enabled |= BP_TRAP;
 		break;
 	}
 }
 /* Very cheap human name for vector lookup. */
 static
 const char *getvecname(unsigned long vec)
 {
 	char *ret;
 	switch (vec) {
 	case 0x100:	ret = "(System Reset)"; break;
 	case 0x200:	ret = "(Machine Check)"; break;
 	case 0x300:	ret = "(Data Access)"; break;
 	case 0x380:	ret = "(Data SLB Access)"; break;
 	case 0x400:	ret = "(Instruction Access)"; break;
 	case 0x480:	ret = "(Instruction SLB Access)"; break;
 	case 0x500:	ret = "(Hardware Interrupt)"; break;
 	case 0x600:	ret = "(Alignment)"; break;
 	case 0x700:	ret = "(Program Check)"; break;
 	case 0x800:	ret = "(FPU Unavailable)"; break;
 	case 0x900:	ret = "(Decrementer)"; break;
 	case 0xc00:	ret = "(System Call)"; break;
 	case 0xd00:	ret = "(Single Step)"; break;
 	case 0xf00:	ret = "(Performance Monitor)"; break;
 	case 0xf20:	ret = "(Altivec Unavailable)"; break;
 	case 0x1300:	ret = "(Instruction Breakpoint)"; break;
 	default: ret = "";
 	}
 	return ret;
 }
 static void get_function_bounds(unsigned long pc, unsigned long *startp,
 				unsigned long *endp)
 {
 	unsigned long size, offset;
 	const char *name;
 	char *modname;
 	*startp = *endp = 0;
 	if (pc == 0)
 		return;
 	if (setjmp(bus_error_jmp) == 0) {
 		catch_memory_errors = 1;
 		sync();
 		name = kallsyms_lookup(pc, &size, &offset, &modname, tmpstr);
 		if (name != NULL) {
 			*startp = pc - offset;
 			*endp = pc - offset + size;
 		}
 		sync();
 	}
 	catch_memory_errors = 0;
 }
 static int xmon_depth_to_print = 64;
 #ifdef CONFIG_PPC64
 #define LRSAVE_OFFSET		0x10
 #define REG_FRAME_MARKER	0x7265677368657265ul	/* "regshere" */
 #define MARKER_OFFSET		0x60
 #define REGS_OFFSET		0x70
 #else
 #define LRSAVE_OFFSET		4
 #define REG_FRAME_MARKER	0x72656773
 #define MARKER_OFFSET		8
 #define REGS_OFFSET		16
 #endif
 static void xmon_show_stack(unsigned long sp, unsigned long lr,
 			    unsigned long pc)
 {
 	unsigned long ip;
 	unsigned long newsp;
 	unsigned long marker;
 	int count = 0;
 	struct pt_regs regs;
 	do {
 		if (sp < PAGE_OFFSET) {
 			if (sp != 0)
 				printf("SP (%lx) is in userspace\n", sp);
 			break;
 		}
 		if (!mread(sp + LRSAVE_OFFSET, &ip, sizeof(unsigned long))
 		    || !mread(sp, &newsp, sizeof(unsigned long))) {
 			printf("Couldn't read stack frame at %lx\n", sp);
 			break;
 		}
 		/*
 		 * For the first stack frame, try to work out if
 		 * LR and/or the saved LR value in the bottommost
 		 * stack frame are valid.
 		 */
 		if ((pc | lr) != 0) {
 			unsigned long fnstart, fnend;
 			unsigned long nextip;
 			int printip = 1;
 			get_function_bounds(pc, &fnstart, &fnend);
 			nextip = 0;
 			if (newsp > sp)
 				mread(newsp + LRSAVE_OFFSET, &nextip,
 				      sizeof(unsigned long));
 			if (lr == ip) {
 				if (lr < PAGE_OFFSET
 				    || (fnstart <= lr && lr < fnend))
 					printip = 0;
 			} else if (lr == nextip) {
 				printip = 0;
 			} else if (lr >= PAGE_OFFSET
 				   && !(fnstart <= lr && lr < fnend)) {
 				printf("[link register   ] ");
 				xmon_print_symbol(lr, " ", "\n");
 			}
 			if (printip) {
 				printf("["REG"] ", sp);
 				xmon_print_symbol(ip, " ", " (unreliable)\n");
 			}
 			pc = lr = 0;
 		} else {
 			printf("["REG"] ", sp);
 			xmon_print_symbol(ip, " ", "\n");
 		}
 		/* Look for "regshere" marker to see if this is
 		   an exception frame. */
 		if (mread(sp + MARKER_OFFSET, &marker, sizeof(unsigned long))
 		    && marker == REG_FRAME_MARKER) {
 			if (mread(sp + REGS_OFFSET, &regs, sizeof(regs))
 			    != sizeof(regs)) {
 				printf("Couldn't read registers at %lx\n",
 				       sp + REGS_OFFSET);
 				break;
 			}
                         printf("--- Exception: %lx %s at ", regs.trap,
 			       getvecname(TRAP(&regs)));
 			pc = regs.nip;
 			lr = regs.link;
 			xmon_print_symbol(pc, " ", "\n");
 		}
 		if (newsp == 0)
 			break;
 		sp = newsp;
 	} while (count++ < xmon_depth_to_print);
 }
 static void backtrace(struct pt_regs *excp)
 {
 	unsigned long sp;
 	if (scanhex(&sp))
 		xmon_show_stack(sp, 0, 0);
 	else
 		xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
 	scannl();
 }
 static void print_bug_trap(struct pt_regs *regs)
 {
 	struct bug_entry *bug;
 	unsigned long addr;
 	if (regs->msr & MSR_PR)
 		return;		/* not in kernel */
 	addr = regs->nip;	/* address of trap instruction */
 	if (addr < PAGE_OFFSET)
 		return;
 	bug = find_bug(regs->nip);
 	if (bug == NULL)
 		return;
 	if (bug->line & BUG_WARNING_TRAP)
 		return;
 	printf("kernel BUG in %s at %s:%d!\n",
 	       bug->function, bug->file, (unsigned int)bug->line);
 }
 void excprint(struct pt_regs *fp)
 {
 	unsigned long trap;
 #ifdef CONFIG_SMP
 	printf("cpu 0x%x: ", smp_processor_id());
 #endif /* CONFIG_SMP */
 	trap = TRAP(fp);
 	printf("Vector: %lx %s at [%lx]\n", fp->trap, getvecname(trap), fp);
 	printf("    pc: ");
 	xmon_print_symbol(fp->nip, ": ", "\n");
 	printf("    lr: ", fp->link);
 	xmon_print_symbol(fp->link, ": ", "\n");
 	printf("    sp: %lx\n", fp->gpr[1]);
 	printf("   msr: %lx\n", fp->msr);
 	if (trap == 0x300 || trap == 0x380 || trap == 0x600) {
 		printf("   dar: %lx\n", fp->dar);
 		if (trap != 0x380)
 			printf(" dsisr: %lx\n", fp->dsisr);
 	}
 	printf("  current = 0x%lx\n", current);
 #ifdef CONFIG_PPC64
 	printf("  paca    = 0x%lx\n", get_paca());
 #endif
 	if (current) {
 		printf("    pid   = %ld, comm = %s\n",
 		       current->pid, current->comm);
 	}
 	if (trap == 0x700)
 		print_bug_trap(fp);
 }
 void prregs(struct pt_regs *fp)
 {
 	int n, trap;
 	unsigned long base;
 	struct pt_regs regs;
 	if (scanhex(&base)) {
 		if (setjmp(bus_error_jmp) == 0) {
 			catch_memory_errors = 1;
 			sync();
 			regs = *(struct pt_regs *)base;
 			sync();
 			__delay(200);
 		} else {
 			catch_memory_errors = 0;
 			printf("*** Error reading registers from "REG"\n",
 			       base);
 			return;
 		}
 		catch_memory_errors = 0;
 		fp = &regs;
 	}
 #ifdef CONFIG_PPC64
 	if (FULL_REGS(fp)) {
 		for (n = 0; n < 16; ++n)
 			printf("R%.2ld = "REG"   R%.2ld = "REG"\n",
 			       n, fp->gpr[n], n+16, fp->gpr[n+16]);
 	} else {
 		for (n = 0; n < 7; ++n)
 			printf("R%.2ld = "REG"   R%.2ld = "REG"\n",
 			       n, fp->gpr[n], n+7, fp->gpr[n+7]);
 	}
 #else
 	for (n = 0; n < 32; ++n) {
 		printf("R%.2d = %.8x%s", n, fp->gpr[n],
 		       (n & 3) == 3? "\n": "   ");
 		if (n == 12 && !FULL_REGS(fp)) {
 			printf("\n");
 			break;
 		}
 	}
 #endif
 	printf("pc  = ");
 	xmon_print_symbol(fp->nip, " ", "\n");
 	printf("lr  = ");
 	xmon_print_symbol(fp->link, " ", "\n");
 	printf("msr = "REG"   cr  = %.8lx\n", fp->msr, fp->ccr);
 	printf("ctr = "REG"   xer = "REG"   trap = %4lx\n",
 	       fp->ctr, fp->xer, fp->trap);
 	trap = TRAP(fp);
 	if (trap == 0x300 || trap == 0x380 || trap == 0x600)
 		printf("dar = "REG"   dsisr = %.8lx\n", fp->dar, fp->dsisr);
 }
 void cacheflush(void)
 {
 	int cmd;
 	unsigned long nflush;
 	cmd = inchar();
 	if (cmd != 'i')
 		termch = cmd;
 	scanhex((void *)&adrs);
 	if (termch != '\n')
 		termch = 0;
 	nflush = 1;
 	scanhex(&nflush);
 	nflush = (nflush + L1_CACHE_BYTES - 1) / L1_CACHE_BYTES;
 	if (setjmp(bus_error_jmp) == 0) {
 		catch_memory_errors = 1;
 		sync();
 		if (cmd != 'i') {
 			for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
 				cflush((void *) adrs);
 		} else {
 			for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
 				cinval((void *) adrs);
 		}
 		sync();
 		/* wait a little while to see if we get a machine check */
 		__delay(200);
 	}
 	catch_memory_errors = 0;
 }
 unsigned long
 read_spr(int n)
 {
 	unsigned int instrs[2];
 	unsigned long (*code)(void);
 	unsigned long opd[3];
 	unsigned long ret = -1UL;
 	instrs[0] = 0x7c6002a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6);
 	instrs[1] = 0x4e800020;
 	opd[0] = (unsigned long)instrs;
 	opd[1] = 0;
 	opd[2] = 0;
 	store_inst(instrs);
 	store_inst(instrs+1);
 	code = (unsigned long (*)(void)) opd;
 	if (setjmp(bus_error_jmp) == 0) {
 		catch_memory_errors = 1;
 		sync();
 		ret = code();
 		sync();
 		/* wait a little while to see if we get a machine check */
 		__delay(200);
 		n = size;
 	}
 	return ret;
 }
 void
 write_spr(int n, unsigned long val)
 {
 	unsigned int instrs[2];
 	unsigned long (*code)(unsigned long);
 	unsigned long opd[3];
 	instrs[0] = 0x7c6003a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6);
 	instrs[1] = 0x4e800020;
 	opd[0] = (unsigned long)instrs;
 	opd[1] = 0;
 	opd[2] = 0;
 	store_inst(instrs);
 	store_inst(instrs+1);
 	code = (unsigned long (*)(unsigned long)) opd;
 	if (setjmp(bus_error_jmp) == 0) {
 		catch_memory_errors = 1;
 		sync();
 		code(val);
 		sync();
 		/* wait a little while to see if we get a machine check */
 		__delay(200);
 		n = size;
 	}
 }
 static unsigned long regno;
 extern char exc_prolog;
 extern char dec_exc;
 void super_regs(void)
 {
 	int cmd;
 	unsigned long val;
 #ifdef CONFIG_PPC_ISERIES
 	struct paca_struct *ptrPaca = NULL;
 	struct lppaca *ptrLpPaca = NULL;
 	struct ItLpRegSave *ptrLpRegSave = NULL;
 #endif
 	cmd = skipbl();
 	if (cmd == '\n') {
 	        unsigned long sp, toc;
 		asm("mr %0,1" : "=r" (sp) :);
 		asm("mr %0,2" : "=r" (toc) :);
 		printf("msr  = "REG"  sprg0= "REG"\n",
 		       mfmsr(), mfspr(SPRN_SPRG0));
 		printf("pvr  = "REG"  sprg1= "REG"\n",
 		       mfspr(SPRN_PVR), mfspr(SPRN_SPRG1));
 		printf("dec  = "REG"  sprg2= "REG"\n",
 		       mfspr(SPRN_DEC), mfspr(SPRN_SPRG2));
 		printf("sp   = "REG"  sprg3= "REG"\n", sp, mfspr(SPRN_SPRG3));
 		printf("toc  = "REG"  dar  = "REG"\n", toc, mfspr(SPRN_DAR));
 #ifdef CONFIG_PPC_ISERIES
 		// Dump out relevant Paca data areas.
 		printf("Paca: \n");
 		ptrPaca = get_paca();
 		printf("  Local Processor Control Area (LpPaca): \n");
 		ptrLpPaca = ptrPaca->lppaca_ptr;
 		printf("    Saved Srr0=%.16lx  Saved Srr1=%.16lx \n",
 		       ptrLpPaca->saved_srr0, ptrLpPaca->saved_srr1);
 		printf("    Saved Gpr3=%.16lx  Saved Gpr4=%.16lx \n",
 		       ptrLpPaca->saved_gpr3, ptrLpPaca->saved_gpr4);
 		printf("    Saved Gpr5=%.16lx \n", ptrLpPaca->saved_gpr5);
 		printf("  Local Processor Register Save Area (LpRegSave): \n");
 		ptrLpRegSave = ptrPaca->reg_save_ptr;
 		printf("    Saved Sprg0=%.16lx  Saved Sprg1=%.16lx \n",
 		       ptrLpRegSave->xSPRG0, ptrLpRegSave->xSPRG0);
 		printf("    Saved Sprg2=%.16lx  Saved Sprg3=%.16lx \n",
 		       ptrLpRegSave->xSPRG2, ptrLpRegSave->xSPRG3);
 		printf("    Saved Msr  =%.16lx  Saved Nia  =%.16lx \n",
 		       ptrLpRegSave->xMSR, ptrLpRegSave->xNIA);
 #endif
 		return;
 	}
 	scanhex(&regno);
 	switch (cmd) {
 	case 'w':
 		val = read_spr(regno);
 		scanhex(&val);
 		write_spr(regno, val);
 		/* fall through */
 	case 'r':
 		printf("spr %lx = %lx\n", regno, read_spr(regno));
 		break;
 	}
 	scannl();
 }
 /*
  * Stuff for reading and writing memory safely
  */
 int
 mread(unsigned long adrs, void *buf, int size)
 {
 	volatile int n;
 	char *p, *q;
 	n = 0;
 	if (setjmp(bus_error_jmp) == 0) {
 		catch_memory_errors = 1;
 		sync();
 		p = (char *)adrs;
 		q = (char *)buf;
 		switch (size) {
 		case 2:
 			*(u16 *)q = *(u16 *)p;
 			break;
 		case 4:
 			*(u32 *)q = *(u32 *)p;
 			break;
 		case 8:
 			*(u64 *)q = *(u64 *)p;
 			break;
 		default:
 			for( ; n < size; ++n) {
 				*q++ = *p++;
 				sync();
 			}
 		}
 		sync();
 		/* wait a little while to see if we get a machine check */
 		__delay(200);
 		n = size;
 	}
 	catch_memory_errors = 0;
 	return n;
 }
 int
 mwrite(unsigned long adrs, void *buf, int size)
 {
 	volatile int n;
 	char *p, *q;
 	n = 0;
 	if (setjmp(bus_error_jmp) == 0) {
 		catch_memory_errors = 1;
 		sync();
 		p = (char *) adrs;
 		q = (char *) buf;
 		switch (size) {
 		case 2:
 			*(u16 *)p = *(u16 *)q;
 			break;
 		case 4:
 			*(u32 *)p = *(u32 *)q;
 			break;
 		case 8:
 			*(u64 *)p = *(u64 *)q;
 			break;
 		default:
 			for ( ; n < size; ++n) {
 				*p++ = *q++;
 				sync();
 			}
 		}
 		sync();
 		/* wait a little while to see if we get a machine check */
 		__delay(200);
 		n = size;
 	} else {
 		printf("*** Error writing address %x\n", adrs + n);
 	}
 	catch_memory_errors = 0;
 	return n;
 }
 static int fault_type;
 static int fault_except;
 static char *fault_chars[] = { "--", "**", "##" };
 static int handle_fault(struct pt_regs *regs)
 {
 	fault_except = TRAP(regs);
 	switch (TRAP(regs)) {
 	case 0x200:
 		fault_type = 0;
 		break;
 	case 0x300:
 	case 0x380:
 		fault_type = 1;
 		break;
 	default:
 		fault_type = 2;
 	}
 	longjmp(bus_error_jmp, 1);
 	return 0;
 }
 #define SWAP(a, b, t)	((t) = (a), (a) = (b), (b) = (t))
 void
 byterev(unsigned char *val, int size)
 {
 	int t;
 	switch (size) {
 	case 2:
 		SWAP(val[0], val[1], t);
 		break;
 	case 4:
 		SWAP(val[0], val[3], t);
 		SWAP(val[1], val[2], t);
 		break;
 	case 8: /* is there really any use for this? */
 		SWAP(val[0], val[7], t);
 		SWAP(val[1], val[6], t);
 		SWAP(val[2], val[5], t);
 		SWAP(val[3], val[4], t);
 		break;
 	}
 }
 static int brev;
 static int mnoread;
 static char *memex_help_string =
     "Memory examine command usage:\n"
     "m [addr] [flags] examine/change memory\n"
     "  addr is optional.  will start where left off.\n"
     "  flags may include chars from this set:\n"
     "    b   modify by bytes (default)\n"
     "    w   modify by words (2 byte)\n"
     "    l   modify by longs (4 byte)\n"
     "    d   modify by doubleword (8 byte)\n"
     "    r   toggle reverse byte order mode\n"
     "    n   do not read memory (for i/o spaces)\n"
     "    .   ok to read (default)\n"
     "NOTE: flags are saved as defaults\n"
     "";
 static char *memex_subcmd_help_string =
     "Memory examine subcommands:\n"
     "  hexval   write this val to current location\n"
     "  'string' write chars from string to this location\n"
     "  '        increment address\n"
     "  ^        decrement address\n"
     "  /        increment addr by 0x10.  //=0x100, ///=0x1000, etc\n"
     "  \\        decrement addr by 0x10.  \\\\=0x100, \\\\\\=0x1000, etc\n"
     "  `        clear no-read flag\n"
     "  ;        stay at this addr\n"
     "  v        change to byte mode\n"
     "  w        change to word (2 byte) mode\n"
     "  l        change to long (4 byte) mode\n"
     "  u        change to doubleword (8 byte) mode\n"
     "  m addr   change current addr\n"
     "  n        toggle no-read flag\n"
     "  r        toggle byte reverse flag\n"
     "  < count  back up count bytes\n"
     "  > count  skip forward count bytes\n"
     "  x        exit this mode\n"
     "";
 void
 memex(void)
 {
 	int cmd, inc, i, nslash;
 	unsigned long n;
 	unsigned char val[16];
 	scanhex((void *)&adrs);
 	cmd = skipbl();
 	if (cmd == '?') {
 		printf(memex_help_string);
 		return;
 	} else {
 		termch = cmd;
 	}
 	last_cmd = "m\n";
 	while ((cmd = skipbl()) != '\n') {
 		switch( cmd ){
 		case 'b':	size = 1;	break;
 		case 'w':	size = 2;	break;
 		case 'l':	size = 4;	break;
 		case 'd':	size = 8;	break;
 		case 'r': 	brev = !brev;	break;
 		case 'n':	mnoread = 1;	break;
 		case '.':	mnoread = 0;	break;
 		}
 	}
 	if( size <= 0 )
 		size = 1;
 	else if( size > 8 )
 		size = 8;
 	for(;;){
 		if (!mnoread)
 			n = mread(adrs, val, size);
 		printf("%.16x%c", adrs, brev? 'r': ' ');
 		if (!mnoread) {
 			if (brev)
 				byterev(val, size);
 			putchar(' ');
 			for (i = 0; i < n; ++i)
 				printf("%.2x", val[i]);
 			for (; i < size; ++i)
 				printf("%s", fault_chars[fault_type]);
 		}
 		putchar(' ');
 		inc = size;
 		nslash = 0;
 		for(;;){
 			if( scanhex(&n) ){
 				for (i = 0; i < size; ++i)
 					val[i] = n >> (i * 8);
 				if (!brev)
 					byterev(val, size);
 				mwrite(adrs, val, size);
 				inc = size;
 			}
 			cmd = skipbl();
 			if (cmd == '\n')
 				break;
 			inc = 0;
 			switch (cmd) {
 			case '\'':
 				for(;;){
 					n = inchar();
 					if( n == '\\' )
 						n = bsesc();
 					else if( n == '\'' )
 						break;
 					for (i = 0; i < size; ++i)
 						val[i] = n >> (i * 8);
 					if (!brev)
 						byterev(val, size);
 					mwrite(adrs, val, size);
 					adrs += size;
 				}
 				adrs -= size;
 				inc = size;
 				break;
 			case ',':
 				adrs += size;
 				break;
 			case '.':
 				mnoread = 0;
 				break;
 			case ';':
 				break;
 			case 'x':
 			case EOF:
 				scannl();
 				return;
 			case 'b':
 			case 'v':
 				size = 1;
 				break;
 			case 'w':
 				size = 2;
 				break;
 			case 'l':
 				size = 4;
 				break;
 			case 'u':
 				size = 8;
 				break;
 			case '^':
 				adrs -= size;
 				break;
 				break;
 			case '/':
 				if (nslash > 0)
 					adrs -= 1 << nslash;
 				else
 					nslash = 0;
 				nslash += 4;
 				adrs += 1 << nslash;
 				break;
 			case '\\':
 				if (nslash < 0)
 					adrs += 1 << -nslash;
 				else
 					nslash = 0;
 				nslash -= 4;
 				adrs -= 1 << -nslash;
 				break;
 			case 'm':
 				scanhex((void *)&adrs);
 				break;
 			case 'n':
 				mnoread = 1;
 				break;
 			case 'r':
 				brev = !brev;
 				break;
 			case '<':
 				n = size;
 				scanhex(&n);
 				adrs -= n;
 				break;
 			case '>':
 				n = size;
 				scanhex(&n);
 				adrs += n;
 				break;
 			case '?':
 				printf(memex_subcmd_help_string);
 				break;
 			}
 		}
 		adrs += inc;
 	}
 }
 int
 bsesc(void)
 {
 	int c;
 	c = inchar();
 	switch( c ){
 	case 'n':	c = '\n';	break;
 	case 'r':	c = '\r';	break;
 	case 'b':	c = '\b';	break;
 	case 't':	c = '\t';	break;
 	}
 	return c;
 }
 #define isxdigit(c)	(('0' <= (c) && (c) <= '9') \
 			 || ('a' <= (c) && (c) <= 'f') \
 			 || ('A' <= (c) && (c) <= 'F'))
 void
 dump(void)
 {
 	int c;
 	c = inchar();
 	if ((isxdigit(c) && c != 'f' && c != 'd') || c == '\n')
 		termch = c;
 	scanhex((void *)&adrs);
 	if (termch != '\n')
 		termch = 0;
 	if (c == 'i') {
 		scanhex(&nidump);
 		if (nidump == 0)
 			nidump = 16;
 		else if (nidump > MAX_DUMP)
 			nidump = MAX_DUMP;
 		adrs += ppc_inst_dump(adrs, nidump, 1);
 		last_cmd = "di\n";
 	} else {
 		scanhex(&ndump);
 		if (ndump == 0)
 			ndump = 64;
 		else if (ndump > MAX_DUMP)
 			ndump = MAX_DUMP;
 		prdump(adrs, ndump);
 		adrs += ndump;
 		last_cmd = "d\n";
 	}
 }
 void
 prdump(unsigned long adrs, long ndump)
 {
 	long n, m, c, r, nr;
 	unsigned char temp[16];
 	for (n = ndump; n > 0;) {
 		printf(REG, adrs);
 		putchar(' ');
 		r = n < 16? n: 16;
 		nr = mread(adrs, temp, r);
 		adrs += nr;
 		for (m = 0; m < r; ++m) {
 		        if ((m & 7) == 0 && m > 0)
 			    putchar(' ');
 			if (m < nr)
 				printf("%.2x", temp[m]);
 			else
 				printf("%s", fault_chars[fault_type]);
 		}
 		if (m <= 8)
 			printf(" ");
 		for (; m < 16; ++m)
 			printf("  ");
 		printf("  |");
 		for (m = 0; m < r; ++m) {
 			if (m < nr) {
 				c = temp[m];
 				putchar(' ' <= c && c <= '~'? c: '.');
 			} else
 				putchar(' ');
 		}
 		n -= r;
 		for (; m < 16; ++m)
 			putchar(' ');
 		printf("|\n");
 		if (nr < r)
 			break;
 	}
 }
 int
 ppc_inst_dump(unsigned long adr, long count, int praddr)
 {
 	int nr, dotted;
 	unsigned long first_adr;
 	unsigned long inst, last_inst = 0;
 	unsigned char val[4];
 	dotted = 0;
 	for (first_adr = adr; count > 0; --count, adr += 4) {
 		nr = mread(adr, val, 4);
 		if (nr == 0) {
 			if (praddr) {
 				const char *x = fault_chars[fault_type];
 				printf(REG"  %s%s%s%s\n", adr, x, x, x, x);
 			}
 			break;
 		}
 		inst = GETWORD(val);
 		if (adr > first_adr && inst == last_inst) {
 			if (!dotted) {
 				printf(" ...\n");
 				dotted = 1;
 			}
 			continue;
 		}
 		dotted = 0;
 		last_inst = inst;
 		if (praddr)
 			printf(REG"  %.8x", adr, inst);
 		printf("\t");
 		print_insn_powerpc(inst, adr, 0);	/* always returns 4 */
 		printf("\n");
 	}
 	return adr - first_adr;
 }
 void
 print_address(unsigned long addr)
 {
 	xmon_print_symbol(addr, "\t# ", "");
 }
 /*
  * Memory operations - move, set, print differences
  */
 static unsigned long mdest;		/* destination address */
 static unsigned long msrc;		/* source address */
 static unsigned long mval;		/* byte value to set memory to */
 static unsigned long mcount;		/* # bytes to affect */
 static unsigned long mdiffs;		/* max # differences to print */
 void
 memops(int cmd)
 {
 	scanhex((void *)&mdest);
 	if( termch != '\n' )
 		termch = 0;
 	scanhex((void *)(cmd == 's'? &mval: &msrc));
 	if( termch != '\n' )
 		termch = 0;
 	scanhex((void *)&mcount);
 	switch( cmd ){
 	case 'm':
 		memmove((void *)mdest, (void *)msrc, mcount);
 		break;
 	case 's':
 		memset((void *)mdest, mval, mcount);
 		break;
 	case 'd':
 		if( termch != '\n' )
 			termch = 0;
 		scanhex((void *)&mdiffs);
 		memdiffs((unsigned char *)mdest, (unsigned char *)msrc, mcount, mdiffs);
 		break;
 	}
 }
 void
 memdiffs(unsigned char *p1, unsigned char *p2, unsigned nb, unsigned maxpr)
 {
 	unsigned n, prt;
 	prt = 0;
 	for( n = nb; n > 0; --n )
 		if( *p1++ != *p2++ )
 			if( ++prt <= maxpr )
 				printf("%.16x %.2x # %.16x %.2x\n", p1 - 1,
 					p1[-1], p2 - 1, p2[-1]);
 	if( prt > maxpr )
 		printf("Total of %d differences\n", prt);
 }
 static unsigned mend;
 static unsigned mask;
 void
 memlocate(void)
 {
 	unsigned a, n;
 	unsigned char val[4];
 	last_cmd = "ml";
 	scanhex((void *)&mdest);
 	if (termch != '\n') {
 		termch = 0;
 		scanhex((void *)&mend);
 		if (termch != '\n') {
 			termch = 0;
 			scanhex((void *)&mval);
 			mask = ~0;
 			if (termch != '\n') termch = 0;
 			scanhex((void *)&mask);
 		}
 	}
 	n = 0;
 	for (a = mdest; a < mend; a += 4) {
 		if (mread(a, val, 4) == 4
 			&& ((GETWORD(val) ^ mval) & mask) == 0) {
 			printf("%.16x:  %.16x\n", a, GETWORD(val));
 			if (++n >= 10)
 				break;
 		}
 	}
 }
 static unsigned long mskip = 0x1000;
 static unsigned long mlim = 0xffffffff;
 void
 memzcan(void)
 {
 	unsigned char v;
 	unsigned a;
 	int ok, ook;
 	scanhex(&mdest);
 	if (termch != '\n') termch = 0;
 	scanhex(&mskip);
 	if (termch != '\n') termch = 0;
 	scanhex(&mlim);
 	ook = 0;
 	for (a = mdest; a < mlim; a += mskip) {
 		ok = mread(a, &v, 1);
 		if (ok && !ook) {
 			printf("%.8x .. ", a);
-			fflush(stdout);
 		} else if (!ok && ook)
 			printf("%.8x\n", a - mskip);
 		ook = ok;
 		if (a + mskip < a)
 			break;
 	}
 	if (ook)
 		printf("%.8x\n", a - mskip);
 }
 void proccall(void)
 {
 	unsigned long args[8];
 	unsigned long ret;
 	int i;
 	typedef unsigned long (*callfunc_t)(unsigned long, unsigned long,
 			unsigned long, unsigned long, unsigned long,
 			unsigned long, unsigned long, unsigned long);
 	callfunc_t func;
 	if (!scanhex(&adrs))
 		return;
 	if (termch != '\n')
 		termch = 0;
 	for (i = 0; i < 8; ++i)
 		args[i] = 0;
 	for (i = 0; i < 8; ++i) {
 		if (!scanhex(&args[i]) || termch == '\n')
 			break;
 		termch = 0;
 	}
 	func = (callfunc_t) adrs;
 	ret = 0;
 	if (setjmp(bus_error_jmp) == 0) {
 		catch_memory_errors = 1;
 		sync();
 		ret = func(args[0], args[1], args[2], args[3],
 			   args[4], args[5], args[6], args[7]);
 		sync();
 		printf("return value is %x\n", ret);
 	} else {
 		printf("*** %x exception occurred\n", fault_except);
 	}
 	catch_memory_errors = 0;
 }
 /* Input scanning routines */
 int
 skipbl(void)
 {
 	int c;
 	if( termch != 0 ){
 		c = termch;
 		termch = 0;
 	} else
 		c = inchar();
 	while( c == ' ' || c == '\t' )
 		c = inchar();
 	return c;
 }
 #define N_PTREGS	44
 static char *regnames[N_PTREGS] = {
 	"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 	"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 	"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
 	"r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
 	"pc", "msr", "or3", "ctr", "lr", "xer", "ccr",
 #ifdef CONFIG_PPC64
 	"softe",
 #else
 	"mq",
 #endif
 	"trap", "dar", "dsisr", "res"
 };
 int
 scanhex(unsigned long *vp)
 {
 	int c, d;
 	unsigned long v;
 	c = skipbl();
 	if (c == '%') {
 		/* parse register name */
 		char regname[8];
 		int i;
 		for (i = 0; i < sizeof(regname) - 1; ++i) {
 			c = inchar();
 			if (!isalnum(c)) {
 				termch = c;
 				break;
 			}
 			regname[i] = c;
 		}
 		regname[i] = 0;
 		for (i = 0; i < N_PTREGS; ++i) {
 			if (strcmp(regnames[i], regname) == 0) {
 				if (xmon_regs == NULL) {
 					printf("regs not available\n");
 					return 0;
 				}
 				*vp = ((unsigned long *)xmon_regs)[i];
 				return 1;
 			}
 		}
 		printf("invalid register name '%%%s'\n", regname);
 		return 0;
 	}
 	/* skip leading "0x" if any */
 	if (c == '0') {
 		c = inchar();
 		if (c == 'x') {
 			c = inchar();
 		} else {
 			d = hexdigit(c);
 			if (d == EOF) {
 				termch = c;
 				*vp = 0;
 				return 1;
 			}
 		}
 	} else if (c == '$') {
 		int i;
 		for (i=0; i<63; i++) {
 			c = inchar();
 			if (isspace(c)) {
 				termch = c;
 				break;
 			}
 			tmpstr[i] = c;
 		}
 		tmpstr[i++] = 0;
 		*vp = 0;
 		if (setjmp(bus_error_jmp) == 0) {
 			catch_memory_errors = 1;
 			sync();
 			*vp = kallsyms_lookup_name(tmpstr);
 			sync();
 		}
 		catch_memory_errors = 0;
 		if (!(*vp)) {
 			printf("unknown symbol '%s'\n", tmpstr);
 			return 0;
 		}
 		return 1;
 	}
 	d = hexdigit(c);
 	if (d == EOF) {
 		termch = c;
 		return 0;
 	}
 	v = 0;
 	do {
 		v = (v << 4) + d;
 		c = inchar();
 		d = hexdigit(c);
 	} while (d != EOF);
 	termch = c;
 	*vp = v;
 	return 1;
 }
 void
 scannl(void)
 {
 	int c;
 	c = termch;
 	termch = 0;
 	while( c != '\n' )
 		c = inchar();
 }
 int hexdigit(int c)
 {
 	if( '0' <= c && c <= '9' )
 		return c - '0';
 	if( 'A' <= c && c <= 'F' )
 		return c - ('A' - 10);
 	if( 'a' <= c && c <= 'f' )
 		return c - ('a' - 10);
 	return EOF;
 }
 void
 getstring(char *s, int size)
 {
 	int c;
 	c = skipbl();
 	do {
 		if( size > 1 ){
 			*s++ = c;
 			--size;
 		}
 		c = inchar();
 	} while( c != ' ' && c != '\t' && c != '\n' );
 	termch = c;
 	*s = 0;
 }
 static char line[256];
 static char *lineptr;
 void
 flush_input(void)
 {
 	lineptr = NULL;
 }
 int
 inchar(void)
 {
 	if (lineptr == NULL || *lineptr == 0) {
-		if (fgets(line, sizeof(line), stdin) == NULL) {
+		if (xmon_gets(line, sizeof(line)) == NULL) {
 			lineptr = NULL;
 			return EOF;
 		}
 		lineptr = line;
 	}
 	return *lineptr++;
 }
 void
 take_input(char *str)
 {
 	lineptr = str;
 }
 static void
 symbol_lookup(void)
 {
 	int type = inchar();
 	unsigned long addr;
 	static char tmp[64];
 	switch (type) {
 	case 'a':
 		if (scanhex(&addr))
 			xmon_print_symbol(addr, ": ", "\n");
 		termch = 0;
 		break;
 	case 's':
 		getstring(tmp, 64);
 		if (setjmp(bus_error_jmp) == 0) {
 			catch_memory_errors = 1;
 			sync();
 			addr = kallsyms_lookup_name(tmp);
 			if (addr)
 				printf("%s: %lx\n", tmp, addr);
 			else
 				printf("Symbol '%s' not found.\n", tmp);
 			sync();
 		}
 		catch_memory_errors = 0;
 		termch = 0;
 		break;
 	}
 }
 /* Print an address in numeric and symbolic form (if possible) */
 static void xmon_print_symbol(unsigned long address, const char *mid,
 			      const char *after)
 {
 	char *modname;
 	const char *name = NULL;
 	unsigned long offset, size;
 	printf(REG, address);
 	if (setjmp(bus_error_jmp) == 0) {
 		catch_memory_errors = 1;
 		sync();
 		name = kallsyms_lookup(address, &size, &offset, &modname,
 				       tmpstr);
 		sync();
 		/* wait a little while to see if we get a machine check */
 		__delay(200);
 	}
 	catch_memory_errors = 0;
 	if (name) {
 		printf("%s%s+%#lx/%#lx", mid, name, offset, size);
 		if (modname)
 			printf(" [%s]", modname);
 	}
 	printf("%s", after);
 }
 #ifdef CONFIG_PPC64
 static void dump_slb(void)
 {
 	int i;
 	unsigned long tmp;
 	printf("SLB contents of cpu %x\n", smp_processor_id());
 	for (i = 0; i < SLB_NUM_ENTRIES; i++) {
 		asm volatile("slbmfee  %0,%1" : "=r" (tmp) : "r" (i));
 		printf("%02d %016lx ", i, tmp);
 		asm volatile("slbmfev  %0,%1" : "=r" (tmp) : "r" (i));
 		printf("%016lx\n", tmp);
 	}
 }
 static void dump_stab(void)
 {
 	int i;
 	unsigned long *tmp = (unsigned long *)get_paca()->stab_addr;
 	printf("Segment table contents of cpu %x\n", smp_processor_id());
 	for (i = 0; i < PAGE_SIZE/16; i++) {
 		unsigned long a, b;
 		a = *tmp++;
 		b = *tmp++;
 		if (a || b) {
 			printf("%03d %016lx ", i, a);
 			printf("%016lx\n", b);
 		}
 	}
 }
 void dump_segments(void)
 {
 	if (cpu_has_feature(CPU_FTR_SLB))
 		dump_slb();
 	else
 		dump_stab();
 }
 #endif
 #ifdef CONFIG_PPC_STD_MMU_32
 void dump_segments(void)
 {
 	int i;
 	printf("sr0-15 =");
 	for (i = 0; i < 16; ++i)
 		printf(" %x", mfsrin(i));
 	printf("\n");
 }
 #endif
 void xmon_init(int enable)
 {
 	if (enable) {
 		__debugger = xmon;
 		__debugger_ipi = xmon_ipi;
 		__debugger_bpt = xmon_bpt;
 		__debugger_sstep = xmon_sstep;
 		__debugger_iabr_match = xmon_iabr_match;
 		__debugger_dabr_match = xmon_dabr_match;
 		__debugger_fault_handler = xmon_fault_handler;
 	} else {
 		__debugger = NULL;
 		__debugger_ipi = NULL;
 		__debugger_bpt = NULL;
 		__debugger_sstep = NULL;
 		__debugger_iabr_match = NULL;
 		__debugger_dabr_match = NULL;
 		__debugger_fault_handler = NULL;
 	}
+	xmon_map_scc();
 }
+#ifdef CONFIG_MAGIC_SYSRQ
+static void sysrq_handle_xmon(int key, struct pt_regs *pt_regs,
+			      struct tty_struct *tty)
+{
+	/* ensure xmon is enabled */
+	xmon_init(1);
+	debugger(pt_regs);
+}
+static struct sysrq_key_op sysrq_xmon_op =
+{
+	.handler =	sysrq_handle_xmon,
+	.help_msg =	"Xmon",
+	.action_msg =	"Entering xmon",
+};
+static int __init setup_xmon_sysrq(void)

include/asm-powerpc/xmon.h

Diff comments View file @ fca5dcd

 #ifndef __PPC_XMON_H
 #define __PPC_XMON_H
 #ifdef __KERNEL__
 struct pt_regs;
 extern int xmon(struct pt_regs *excp);
 extern void xmon_printf(const char *fmt, ...);
 extern void xmon_init(int);
-extern void xmon_map_scc(void);
 #endif
 #endif