[PATCH] ppc64: clean up prom.c and related files

Somebody back in the mists of time decided that call_prom and rtas_call
should return longs even though both of those bits of firmware run in
32-bit mode and produce a 32-bit result.  To make life more interesting,
the 32-bit result gets zero-extended to 64 bits, which makes checking
for a -1 return value more complicated than it should be.

This patch changes call_prom and rtas_call to return an int, and makes
the corresponding changes to use ints for the variables used to hold
those return values. 

While I was doing this I finally got annoyed enough with the strings of
prom_print() and prom_print_hex() calls that we do to write a simple
prom_printf.  I deliberately didn't use snprintf because the execution
environment is weird at this point - we aren't running at the address we
are linked at just yet - and I didn't want to inflict that on any code
outside this file.  I also did a prom_debug() macro, which eliminated a
few ifdefs. 

There are also a bunch of other minor cleanups.  This patch makes very
few algorithmic changes but does get rid of a lot of casts.  :)

I have been running with this patch for a couple of weeks, and Anton has
tested it too.
Signed-off-by: Paul Mackerras <paulus@samba.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

arch/ppc64/kernel/eeh.c

@@ -365,7 +365,8 @@ unsigned long eeh_check_failure(void *token, unsigned long val)
 	unsigned long addr;
 	struct pci_dev *dev;
 	struct device_node *dn;
-	unsigned long ret, rets[2];
+	unsigned long ret;
+	int rets[2];
 	static spinlock_t lock = SPIN_LOCK_UNLOCKED;
 	/* dont want this on the stack */
 	static unsigned char slot_err_buf[RTAS_ERROR_LOG_MAX];
@@ -444,11 +445,11 @@ unsigned long eeh_check_failure(void *token, unsigned long val)
 		 * can use it here.
 		 */
 		if (panic_on_oops) {
-			panic("EEH: MMIO failure (%ld) on device:%s %s\n",
+			panic("EEH: MMIO failure (%d) on device:%s %s\n",
 			      rets[0], pci_name(dev), pci_pretty_name(dev));
 		} else {
 			__get_cpu_var(ignored_failures)++;
-			printk(KERN_INFO "EEH: MMIO failure (%ld) on device:%s %s\n",
+			printk(KERN_INFO "EEH: MMIO failure (%d) on device:%s %s\n",
 			       rets[0], pci_name(dev), pci_pretty_name(dev));
 		}
 	} else {

arch/ppc64/kernel/pSeries_nvram.c

@@ -37,7 +37,8 @@ static spinlock_t nvram_lock = SPIN_LOCK_UNLOCKED;
 static ssize_t pSeries_nvram_read(char *buf, size_t count, loff_t *index)
 {
 	unsigned int i;
-	unsigned long len, done;
+	unsigned long len;
+	int done;
 	unsigned long flags;
 	char *p = buf;
 
@@ -80,7 +81,8 @@ static ssize_t pSeries_nvram_read(char *buf, size_t count, loff_t *index)
 static ssize_t pSeries_nvram_write(char *buf, size_t count, loff_t *index)
 {
 	unsigned int i;
-	unsigned long len, done;
+	unsigned long len;
+	int done;
 	unsigned long flags;
 	const char *p = buf;
 

arch/ppc64/kernel/pSeries_pci.c

@@ -62,7 +62,7 @@ extern unsigned long pci_probe_only;
 
 static int rtas_read_config(struct device_node *dn, int where, int size, u32 *val)
 {
-	unsigned long returnval = ~0L;
+	int returnval = -1;
 	unsigned long buid, addr;
 	int ret;
 
@@ -72,7 +72,8 @@ static int rtas_read_config(struct device_node *dn, int where, int size, u32 *va
 	addr = (dn->busno << 16) | (dn->devfn << 8) | where;
 	buid = dn->phb->buid;
 	if (buid) {
-		ret = rtas_call(ibm_read_pci_config, 4, 2, &returnval, addr, buid >> 32, buid & 0xffffffff, size);
+		ret = rtas_call(ibm_read_pci_config, 4, 2, &returnval,
+				addr, buid >> 32, buid & 0xffffffff, size);
 	} else {
 		ret = rtas_call(read_pci_config, 2, 2, &returnval, addr, size);
 	}

arch/ppc64/kernel/prom.c

@@ -15,9 +15,7 @@
  *      2 of the License, or (at your option) any later version.
  */
 
-#if 0
-#define DEBUG_PROM
-#endif
+#undef DEBUG_PROM
 
 #include <stdarg.h>
 #include <linux/config.h>
@@ -91,15 +89,17 @@ extern const struct linux_logo logo_linux_clut224;
  */
 
 
-#define PROM_BUG() do { \
-        prom_print(RELOC("kernel BUG at ")); \
-        prom_print(RELOC(__FILE__)); \
-        prom_print(RELOC(":")); \
-        prom_print_hex(__LINE__); \
-        prom_print(RELOC("!\n")); \
-        __asm__ __volatile__(".long " BUG_ILLEGAL_INSTR); \
+#define PROM_BUG() do {						\
+        prom_printf("kernel BUG at %s line 0x%x!\n",		\
+		    RELOC(__FILE__), __LINE__);			\
+        __asm__ __volatile__(".long " BUG_ILLEGAL_INSTR);	\
 } while (0)
 
+#ifdef DEBUG_PROM
+#define prom_debug(x...)	prom_printf(x)
+#else
+#define prom_debug(x...)
+#endif
 
 
 struct pci_reg_property {
@@ -178,29 +178,36 @@ struct {
 
 char testString[] = "LINUX\n"; 
 
+/*
+ * This are used in calls to call_prom.  The 4th and following
+ * arguments to call_prom should be 32-bit values.  64 bit values
+ * are truncated to 32 bits (and fortunately don't get interpreted
+ * as two arguments).
+ */
+#define ADDR(x)		(u32) ((unsigned long)(x) - offset)
 
 /* This is the one and *ONLY* place where we actually call open
  * firmware from, since we need to make sure we're running in 32b
  * mode when we do.  We switch back to 64b mode upon return.
  */
 
-#define PROM_ERROR	(0x00000000fffffffful)
+#define PROM_ERROR	(-1)
 
-static unsigned long __init call_prom(const char *service, int nargs, int nret, ...)
+static int __init call_prom(const char *service, int nargs, int nret, ...)
 {
 	int i;
 	unsigned long offset = reloc_offset();
 	struct prom_t *_prom = PTRRELOC(&prom);
 	va_list list;
         
-	_prom->args.service = (u32)LONG_LSW(service);
+	_prom->args.service = ADDR(service);
 	_prom->args.nargs = nargs;
 	_prom->args.nret = nret;
         _prom->args.rets = (prom_arg_t *)&(_prom->args.args[nargs]);
 
         va_start(list, nret);
-	for (i=0; i < nargs ;i++)
-		_prom->args.args[i] = (prom_arg_t)LONG_LSW(va_arg(list, unsigned long));
+	for (i=0; i < nargs; i++)
+		_prom->args.args[i] = va_arg(list, prom_arg_t);
         va_end(list);
 
 	for (i=0; i < nret ;i++)
@@ -208,7 +215,7 @@ static unsigned long __init call_prom(const char *service, int nargs, int nret,
 
 	enter_prom(&_prom->args);
 
-	return (unsigned long)((nret > 0) ? _prom->args.rets[0] : 0);
+	return (nret > 0)? _prom->args.rets[0]: 0;
 }
 
 
@@ -225,21 +232,21 @@ static void __init prom_print(const char *msg)
 		for (q = p; *q != 0 && *q != '\n'; ++q)
 			;
 		if (q > p)
-			call_prom(RELOC("write"), 3, 1, _prom->stdout,
-				  p, q - p);
-		if (*q != 0) {
-			++q;
-			call_prom(RELOC("write"), 3, 1, _prom->stdout,
-				  RELOC("\r\n"), 2);
-		}
+			call_prom("write", 3, 1, _prom->stdout, p, q - p);
+		if (*q == 0)
+			break;
+		++q;
+		call_prom("write", 3, 1, _prom->stdout, ADDR("\r\n"), 2);
 	}
 }
 
 
 static void __init prom_print_hex(unsigned long val)
 {
+	unsigned long offset = reloc_offset();
         int i, nibbles = sizeof(val)*2;
         char buf[sizeof(val)*2+1];
+	struct prom_t *_prom = PTRRELOC(&prom);
 
         for (i = nibbles-1;  i >= 0;  i--) {
                 buf[i] = (val & 0xf) + '0';
@@ -248,24 +255,58 @@ static void __init prom_print_hex(unsigned long val)
                 val >>= 4;
         }
         buf[nibbles] = '\0';
-	prom_print(buf);
+	call_prom("write", 3, 1, _prom->stdout, buf, nibbles);
 }
 
 
-static void __init prom_print_nl(void)
+static void __init prom_printf(const char *format, ...)
 {
 	unsigned long offset = reloc_offset();
-	prom_print(RELOC("\n"));
+	const char *p, *q, *s;
+	va_list args;
+	unsigned long v;
+	struct prom_t *_prom = PTRRELOC(&prom);
+
+	va_start(args, format);
+	for (p = PTRRELOC(format); *p != 0; p = q) {
+		for (q = p; *q != 0 && *q != '\n' && *q != '%'; ++q)
+			;
+		if (q > p)
+			call_prom("write", 3, 1, _prom->stdout, p, q - p);
+		if (*q == 0)
+			break;
+		if (*q == '\n') {
+			++q;
+			call_prom("write", 3, 1, _prom->stdout,
+				  ADDR("\r\n"), 2);
+			continue;
+		}
+		++q;
+		if (*q == 0)
+			break;
+		switch (*q) {
+		case 's':
+			++q;
+			s = va_arg(args, const char *);
+			prom_print(s);
+			break;
+		case 'x':
+			++q;
+			v = va_arg(args, unsigned long);
+			prom_print_hex(v);
+			break;
+		}
+	}
 }
 
 
-static void __init prom_panic(const char *reason)
+static void __init __attribute__((noreturn)) prom_panic(const char *reason)
 {
 	unsigned long offset = reloc_offset();
 
-	prom_print(reason);
+	prom_print(PTRRELOC(reason));
 	/* ToDo: should put up an SRC here */
-	call_prom(RELOC("exit"), 0, 0);
+	call_prom("exit", 0, 0);
 
 	for (;;)			/* should never get here */
 		;
@@ -275,21 +316,28 @@ static void __init prom_panic(const char *reason)
 static int __init prom_next_node(phandle *nodep)
 {
 	phandle node;
-	unsigned long offset = reloc_offset();
 
 	if ((node = *nodep) != 0
-	    && (*nodep = call_prom(RELOC("child"), 1, 1, node)) != 0)
+	    && (*nodep = call_prom("child", 1, 1, node)) != 0)
 		return 1;
-	if ((*nodep = call_prom(RELOC("peer"), 1, 1, node)) != 0)
+	if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
 		return 1;
 	for (;;) {
-		if ((node = call_prom(RELOC("parent"), 1, 1, node)) == 0)
+		if ((node = call_prom("parent", 1, 1, node)) == 0)
 			return 0;
-		if ((*nodep = call_prom(RELOC("peer"), 1, 1, node)) != 0)
+		if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
 			return 1;
 	}
 }
 
+static int __init prom_getprop(phandle node, const char *pname,
+			       void *value, size_t valuelen)
+{
+	unsigned long offset = reloc_offset();
+
+	return call_prom("getprop", 4, 1, node, ADDR(pname),
+			 (u32)(unsigned long) value, (u32) valuelen);
+}
 
 static void __init prom_initialize_naca(void)
 {
@@ -302,16 +350,13 @@ static void __init prom_initialize_naca(void)
         struct systemcfg *_systemcfg = RELOC(systemcfg);
 
 	/* NOTE: _naca->debug_switch is already initialized. */
-#ifdef DEBUG_PROM
-	prom_print(RELOC("prom_initialize_naca: start...\n"));
-#endif
+	prom_debug("prom_initialize_naca: start...\n");
 
 	_naca->pftSize = 0;	/* ilog2 of htab size.  computed below. */
 
         for (node = 0; prom_next_node(&node); ) {
                 type[0] = 0;
-                call_prom(RELOC("getprop"), 4, 1, node, RELOC("device_type"),
-                          type, sizeof(type));
+		prom_getprop(node, "device_type", type, sizeof(type));
 
                 if (!strcmp(type, RELOC("cpu"))) {
 			num_cpus += 1;
@@ -321,37 +366,30 @@ static void __init prom_initialize_naca(void)
 			 */
 			if ( num_cpus == 1 ) {
 				u32 size, lsize;
+				const char *dc, *ic;
+
+				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";
+				}
 
-				call_prom(RELOC("getprop"), 4, 1, node,
-					  RELOC("d-cache-size"),
-					  &size, sizeof(size));
+				prom_getprop(node, "d-cache-size",
+					     &size, sizeof(size));
 
-				if (_systemcfg->platform == PLATFORM_POWERMAC)
-					call_prom(RELOC("getprop"), 4, 1, node,
-						  RELOC("d-cache-block-size"),
-						  &lsize, sizeof(lsize));
-				else
-					call_prom(RELOC("getprop"), 4, 1, node,
-						  RELOC("d-cache-line-size"),
-						  &lsize, sizeof(lsize));
+				prom_getprop(node, dc, &lsize, sizeof(lsize));
 
 				_systemcfg->dCacheL1Size = size;
 				_systemcfg->dCacheL1LineSize = lsize;
 				_naca->dCacheL1LogLineSize = __ilog2(lsize);
 				_naca->dCacheL1LinesPerPage = PAGE_SIZE/lsize;
 
-				call_prom(RELOC("getprop"), 4, 1, node,
-					  RELOC("i-cache-size"),
-					  &size, sizeof(size));
+				prom_getprop(node, "i-cache-size",
+					     &size, sizeof(size));
 
-				if (_systemcfg->platform == PLATFORM_POWERMAC)
-					call_prom(RELOC("getprop"), 4, 1, node,
-						  RELOC("i-cache-block-size"),
-						  &lsize, sizeof(lsize));
-				else
-					call_prom(RELOC("getprop"), 4, 1, node,
-						  RELOC("i-cache-line-size"),
-						  &lsize, sizeof(lsize));
+				prom_getprop(node, ic, &lsize, sizeof(lsize));
 
 				_systemcfg->iCacheL1Size = size;
 				_systemcfg->iCacheL1LineSize = lsize;
@@ -360,9 +398,8 @@ static void __init prom_initialize_naca(void)
 
 				if (_systemcfg->platform == PLATFORM_PSERIES_LPAR) {
 					u32 pft_size[2];
-					call_prom(RELOC("getprop"), 4, 1, node, 
-						  RELOC("ibm,pft-size"),
-						  &pft_size, sizeof(pft_size));
+					prom_getprop(node, "ibm,pft-size",
+						&pft_size, sizeof(pft_size));
 				/* pft_size[0] is the NUMA CEC cookie */
 					_naca->pftSize = pft_size[1];
 				}
@@ -375,24 +412,21 @@ static void __init prom_initialize_naca(void)
 			if (_systemcfg->platform == PLATFORM_POWERMAC)
 				continue;
 			type[0] = 0;
-			call_prom(RELOC("getprop"), 4, 1, node,
-				  RELOC("ibm,aix-loc"), type, sizeof(type));
+			prom_getprop(node, "ibm,aix-loc", type, sizeof(type));
 
 			if (strcmp(type, RELOC("S1")))
 				continue;
 
-			call_prom(RELOC("getprop"), 4, 1, node, RELOC("reg"),
-				  &reg, sizeof(reg));
+			prom_getprop(node, "reg", &reg, sizeof(reg));
 
-			isa = call_prom(RELOC("parent"), 1, 1, node);
+			isa = call_prom("parent", 1, 1, node);
 			if (!isa)
 				PROM_BUG();
-			pci = call_prom(RELOC("parent"), 1, 1, isa);
+			pci = call_prom("parent", 1, 1, isa);
 			if (!pci)
 				PROM_BUG();
 
-			call_prom(RELOC("getprop"), 4, 1, pci, RELOC("ranges"),
-				  &ranges, sizeof(ranges));
+			prom_getprop(pci, "ranges", &ranges, sizeof(ranges));
 
 			if ( _prom->encode_phys_size == 32 )
 				_naca->serialPortAddr = ranges.pci32.phys+reg.address;
@@ -410,25 +444,23 @@ static void __init prom_initialize_naca(void)
 		_naca->interrupt_controller = IC_INVALID;
 		for (node = 0; prom_next_node(&node); ) {
 			type[0] = 0;
-			call_prom(RELOC("getprop"), 4, 1, node, RELOC("name"),
-				  type, sizeof(type));
+			prom_getprop(node, "name", type, sizeof(type));
 			if (strcmp(type, RELOC("interrupt-controller")))
 				continue;
-			call_prom(RELOC("getprop"), 4, 1, node, RELOC("compatible"),
-				  type, sizeof(type));
+			prom_getprop(node, "compatible", type, sizeof(type));
 			if (strstr(type, RELOC("open-pic")))
 				_naca->interrupt_controller = IC_OPEN_PIC;
 			else if (strstr(type, RELOC("ppc-xicp")))
 				_naca->interrupt_controller = IC_PPC_XIC;
 			else
-				prom_print(RELOC("prom: failed to recognize"
-						 " interrupt-controller\n"));
+				prom_printf("prom: failed to recognize"
+					    " interrupt-controller\n");
 			break;
 		}
 	}
 
 	if (_naca->interrupt_controller == IC_INVALID) {
-		prom_print(RELOC("prom: failed to find interrupt-controller\n"));
+		prom_printf("prom: failed to find interrupt-controller\n");
 		PROM_BUG();
 	}
 
@@ -454,7 +486,7 @@ static void __init prom_initialize_naca(void)
 	}
 
 	if (_naca->pftSize == 0) {
-		prom_print(RELOC("prom: failed to compute pftSize!\n"));
+		prom_printf("prom: failed to compute pftSize!\n");
 		PROM_BUG();
 	}
 
@@ -464,41 +496,23 @@ static void __init prom_initialize_naca(void)
 	_systemcfg->version.minor = SYSTEMCFG_MINOR;
 	_systemcfg->processor = _get_PVR();
 
-#ifdef DEBUG_PROM
-        prom_print(RELOC("systemcfg->processorCount       = 0x"));
-        prom_print_hex(_systemcfg->processorCount);
-        prom_print_nl();
-
-        prom_print(RELOC("systemcfg->physicalMemorySize   = 0x"));
-        prom_print_hex(_systemcfg->physicalMemorySize);
-        prom_print_nl();
-
-        prom_print(RELOC("naca->pftSize                   = 0x"));
-        prom_print_hex(_naca->pftSize);
-        prom_print_nl();
-
-        prom_print(RELOC("systemcfg->dCacheL1LineSize     = 0x"));
-        prom_print_hex(_systemcfg->dCacheL1LineSize);
-        prom_print_nl();
-
-        prom_print(RELOC("systemcfg->iCacheL1LineSize     = 0x"));
-        prom_print_hex(_systemcfg->iCacheL1LineSize);
-        prom_print_nl();
-
-        prom_print(RELOC("naca->serialPortAddr            = 0x"));
-        prom_print_hex(_naca->serialPortAddr);
-        prom_print_nl();
-
-        prom_print(RELOC("naca->interrupt_controller      = 0x"));
-        prom_print_hex(_naca->interrupt_controller);
-        prom_print_nl();
-
-        prom_print(RELOC("systemcfg->platform             = 0x"));
-        prom_print_hex(_systemcfg->platform);
-        prom_print_nl();
-
-	prom_print(RELOC("prom_initialize_naca: end...\n"));
-#endif
+        prom_debug("systemcfg->processorCount       = 0x%x\n",
+		   _systemcfg->processorCount);
+        prom_debug("systemcfg->physicalMemorySize   = 0x%x\n",
+		   _systemcfg->physicalMemorySize);
+        prom_debug("naca->pftSize                   = 0x%x\n",
+		   _naca->pftSize);
+        prom_debug("systemcfg->dCacheL1LineSize     = 0x%x\n",
+		   _systemcfg->dCacheL1LineSize);
+        prom_debug("systemcfg->iCacheL1LineSize     = 0x%x\n",
+		   _systemcfg->iCacheL1LineSize);
+        prom_debug("naca->serialPortAddr            = 0x%x\n",
+		   _naca->serialPortAddr);
+        prom_debug("naca->interrupt_controller      = 0x%x\n",
+		   _naca->interrupt_controller);
+        prom_debug("systemcfg->platform             = 0x%x\n",
+		   _systemcfg->platform);
+	prom_debug("prom_initialize_naca: end...\n");
 }
 
 
@@ -512,9 +526,7 @@ static void __init early_cmdline_parse(void)
 
 	opt = strstr(RELOC(cmd_line), RELOC("iommu="));
 	if (opt) {
-		prom_print(RELOC("opt is:"));
-		prom_print(opt);
-		prom_print(RELOC("\n"));
+		prom_printf("opt is:%s\n", opt);
 		opt += 6;
 		while (*opt && *opt == ' ')
 			opt++;
@@ -527,7 +539,7 @@ static void __init early_cmdline_parse(void)
 #ifndef CONFIG_PMAC_DART
 	if (_systemcfg->platform == PLATFORM_POWERMAC) {
 		RELOC(ppc64_iommu_off) = 1;
-		prom_print(RELOC("DART disabled on PowerMac !\n"));
+		prom_printf("DART disabled on PowerMac !\n");
 	}
 #endif
 }
@@ -539,46 +551,31 @@ void prom_dump_lmb(void)
         unsigned long offset = reloc_offset();
 	struct lmb *_lmb  = PTRRELOC(&lmb);
 
-        prom_print(RELOC("\nprom_dump_lmb:\n"));
-        prom_print(RELOC("    memory.cnt                  = 0x"));
-        prom_print_hex(_lmb->memory.cnt);
-	prom_print_nl();
-        prom_print(RELOC("    memory.size                 = 0x"));
-        prom_print_hex(_lmb->memory.size);
-	prom_print_nl();
+        prom_printf("\nprom_dump_lmb:\n");
+        prom_printf("    memory.cnt                  = 0x%x\n",
+		    _lmb->memory.cnt);
+        prom_printf("    memory.size                 = 0x%x\n",
+		    _lmb->memory.size);
         for (i=0; i < _lmb->memory.cnt ;i++) {
-                prom_print(RELOC("    memory.region[0x"));
-		prom_print_hex(i);
-		prom_print(RELOC("].base       = 0x"));
-                prom_print_hex(_lmb->memory.region[i].base);
-		prom_print_nl();
-                prom_print(RELOC("                      .physbase = 0x"));
-                prom_print_hex(_lmb->memory.region[i].physbase);
-		prom_print_nl();
-                prom_print(RELOC("                      .size     = 0x"));
-                prom_print_hex(_lmb->memory.region[i].size);
-		prom_print_nl();
+                prom_printf("    memory.region[0x%x].base       = 0x%x\n",
+			    i, _lmb->memory.region[i].base);
+                prom_printf("                      .physbase = 0x%x\n",
+			    _lmb->memory.region[i].physbase);
+                prom_printf("                      .size     = 0x%x\n",
+			    _lmb->memory.region[i].size);
         }
 
-	prom_print_nl();
-        prom_print(RELOC("    reserved.cnt                  = 0x"));
-        prom_print_hex(_lmb->reserved.cnt);
-	prom_print_nl();
-        prom_print(RELOC("    reserved.size                 = 0x"));
-        prom_print_hex(_lmb->reserved.size);
-	prom_print_nl();
+        prom_printf("\n    reserved.cnt                  = 0x%x\n",
+		    _lmb->reserved.cnt);
+        prom_printf("    reserved.size                 = 0x%x\n",
+		    _lmb->reserved.size);
         for (i=0; i < _lmb->reserved.cnt ;i++) {
-                prom_print(RELOC("    reserved.region[0x"));
-		prom_print_hex(i);
-		prom_print(RELOC("].base       = 0x"));
-                prom_print_hex(_lmb->reserved.region[i].base);
-		prom_print_nl();
-                prom_print(RELOC("                      .physbase = 0x"));
-                prom_print_hex(_lmb->reserved.region[i].physbase);
-		prom_print_nl();
-                prom_print(RELOC("                      .size     = 0x"));
-                prom_print_hex(_lmb->reserved.region[i].size);
-		prom_print_nl();
+                prom_printf("    reserved.region[0x%x\n].base       = 0x%x\n",
+			    i, _lmb->reserved.region[i].base);
+                prom_printf("                      .physbase = 0x%x\n",
+			    _lmb->reserved.region[i].physbase);
+                prom_printf("                      .size     = 0x%x\n",
+			    _lmb->reserved.region[i].size);
         }
 }
 #endif /* DEBUG_PROM */
@@ -604,14 +601,13 @@ static void __init prom_initialize_lmb(void)
 
         for (node = 0; prom_next_node(&node); ) {
                 type[0] = 0;
-                call_prom(RELOC("getprop"), 4, 1, node, RELOC("device_type"),
-                          type, sizeof(type));
+                prom_getprop(node, "device_type", type, sizeof(type));
 
                 if (strcmp(type, RELOC("memory")))
 			continue;
 
-		num_regs = call_prom(RELOC("getprop"), 4, 1, node, RELOC("reg"),
-			&reg, sizeof(reg)) / bytes_per_reg;
+		num_regs = prom_getprop(node, "reg", &reg, sizeof(reg))
+			/ bytes_per_reg;
 
 		for (i=0; i < num_regs ;i++) {
 			if (_systemcfg->platform == PLATFORM_POWERMAC) {
@@ -636,7 +632,7 @@ static void __init prom_initialize_lmb(void)
 			}
 
 			if (lmb_add(lmb_base, lmb_size) < 0)
-				prom_print(RELOC("Too many LMB's, discarding this one...\n"));
+				prom_printf("Too many LMB's, discarding this one...\n");
 		}
 
 	}
@@ -658,30 +654,23 @@ prom_instantiate_rtas(void)
         u32 getprop_rval;
 	char hypertas_funcs[4];
 
-#ifdef DEBUG_PROM
-	prom_print(RELOC("prom_instantiate_rtas: start...\n"));
-#endif
-	prom_rtas = (ihandle)call_prom(RELOC("finddevice"), 1, 1, RELOC("/rtas"));
+	prom_debug("prom_instantiate_rtas: start...\n");
+
+	prom_rtas = call_prom("finddevice", 1, 1, ADDR("/rtas"));
 	if (prom_rtas != (ihandle) -1) {
 		unsigned long x;
-		x = call_prom(RELOC("getprop"),
-				  4, 1, prom_rtas,
-				  RELOC("ibm,hypertas-functions"), 
-				  hypertas_funcs, 
-			      sizeof(hypertas_funcs));
+		x = prom_getprop(prom_rtas, "ibm,hypertas-functions",
+				 hypertas_funcs, sizeof(hypertas_funcs));
 
 		if (x != PROM_ERROR) {
-			prom_print(RELOC("Hypertas detected, assuming LPAR !\n"));
+			prom_printf("Hypertas detected, assuming LPAR !\n");
 			_systemcfg->platform = PLATFORM_PSERIES_LPAR;
 		}
 
-		call_prom(RELOC("getprop"), 
-			  4, 1, prom_rtas,
-			  RELOC("rtas-size"), 
-			  &getprop_rval, 
-			  sizeof(getprop_rval));
+		prom_getprop(prom_rtas, "rtas-size",
+			     &getprop_rval, sizeof(getprop_rval));
 	        _rtas->size = getprop_rval;
-		prom_print(RELOC("instantiating rtas"));
+		prom_printf("instantiating rtas");
 		if (_rtas->size != 0) {
 			unsigned long rtas_region = RTAS_INSTANTIATE_MAX;
 
@@ -696,17 +685,15 @@ prom_instantiate_rtas(void)
 
 			_rtas->base = lmb_alloc_base(_rtas->size, PAGE_SIZE, rtas_region);
 
-			prom_print(RELOC(" at 0x"));
-			prom_print_hex(_rtas->base);
+			prom_printf(" at 0x%x", _rtas->base);
 
-			prom_rtas = (ihandle)call_prom(RELOC("open"), 
-					      	1, 1, RELOC("/rtas"));
-			prom_print(RELOC("..."));
+			prom_rtas = call_prom("open", 1, 1, ADDR("/rtas"));
+			prom_printf("...");
 
-			if (call_prom(RELOC("call-method"), 3, 2,
-						      RELOC("instantiate-rtas"),
-						      prom_rtas,
-						      _rtas->base) != PROM_ERROR) {
+			if (call_prom("call-method", 3, 2,
+				      ADDR("instantiate-rtas"),
+				      prom_rtas,
+				      _rtas->base) != PROM_ERROR) {
 				_rtas->entry = (long)_prom->args.rets[1];
 			}
 			RELOC(rtas_rmo_buf)
@@ -715,26 +702,16 @@ prom_instantiate_rtas(void)
 		}
 
 		if (_rtas->entry <= 0) {
-			prom_print(RELOC(" failed\n"));
+			prom_printf(" failed\n");
 		} else {
-			prom_print(RELOC(" done\n"));
+			prom_printf(" done\n");
 		}
 
-#ifdef DEBUG_PROM
-        	prom_print(RELOC("rtas->base                 = 0x"));
-        	prom_print_hex(_rtas->base);
-        	prom_print_nl();
-        	prom_print(RELOC("rtas->entry                = 0x"));
-        	prom_print_hex(_rtas->entry);
-        	prom_print_nl();
-        	prom_print(RELOC("rtas->size                 = 0x"));
-        	prom_print_hex(_rtas->size);
-        	prom_print_nl();
-#endif
+        	prom_debug("rtas->base                = 0x%x\n", _rtas->base);
+        	prom_debug("rtas->entry               = 0x%x\n", _rtas->entry);
+        	prom_debug("rtas->size                = 0x%x\n", _rtas->size);
 	}
-#ifdef DEBUG_PROM
-	prom_print(RELOC("prom_instantiate_rtas: end...\n"));
-#endif
+	prom_debug("prom_instantiate_rtas: end...\n");
 }
 
 
@@ -759,9 +736,7 @@ static void __init prom_initialize_dart_table(void)
 	RELOC(dart_tablebase) = (unsigned long)
 		abs_to_virt(lmb_alloc_base(1UL<<24, 1UL<<24, 0x80000000L));
 
-	prom_print(RELOC("Dart at: "));
-	prom_print_hex(RELOC(dart_tablebase));
-	prom_print(RELOC("\n"));
+	prom_printf("Dart at: %x\n", RELOC(dart_tablebase));
 }
 #endif /* CONFIG_PMAC_DART */
 
@@ -780,27 +755,23 @@ static void __init prom_initialize_tce_table(void)
 	if (RELOC(ppc64_iommu_off))
 		return;
 
-#ifdef DEBUG_PROM
-	prom_print(RELOC("starting prom_initialize_tce_table\n"));
-#endif
+	prom_debug("starting prom_initialize_tce_table\n");
 
 	/* Search all nodes looking for PHBs. */
 	for (node = 0; prom_next_node(&node); ) {
 		if (table == MAX_PHB) {
-			prom_print(RELOC("WARNING: PCI host bridge ignored, "
-				         "need to increase MAX_PHB\n"));
+			prom_printf("WARNING: PCI host bridge ignored, "
+				    "need to increase MAX_PHB\n");
 			continue;
 		}
 
 		compatible[0] = 0;
 		type[0] = 0;
 		model[0] = 0;
-		call_prom(RELOC("getprop"), 4, 1, node, RELOC("compatible"),
-			  compatible, sizeof(compatible));
-		call_prom(RELOC("getprop"), 4, 1, node, RELOC("device_type"),
-			  type, sizeof(type));
-		call_prom(RELOC("getprop"), 4, 1, node, RELOC("model"),
-			  model, sizeof(model));
+		prom_getprop(node, "compatible",
+			     compatible, sizeof(compatible));
+		prom_getprop(node, "device_type", type, sizeof(type));
+		prom_getprop(node, "model", model, sizeof(model));
 
 		/* Keep the old logic in tack to avoid regression. */
 		if (compatible[0] != 0) {
@@ -819,15 +790,13 @@ static void __init prom_initialize_tce_table(void)
 			continue;
 		}
 
-		if (call_prom(RELOC("getprop"), 4, 1, node, 
-			     RELOC("tce-table-minalign"), &minalign, 
-			     sizeof(minalign)) == PROM_ERROR) {
+		if (prom_getprop(node, "tce-table-minalign", &minalign,
+				 sizeof(minalign)) == PROM_ERROR) {
 			minalign = 0;
 		}
 
-		if (call_prom(RELOC("getprop"), 4, 1, node, 
-			     RELOC("tce-table-minsize"), &minsize, 
-			     sizeof(minsize)) == PROM_ERROR) {
+		if (prom_getprop(node, "tce-table-minsize", &minsize,
+				 sizeof(minsize)) == PROM_ERROR) {
 			minsize = 4UL << 20;
 		}
 
@@ -854,7 +823,7 @@ static void __init prom_initialize_tce_table(void)
 		base = lmb_alloc(minsize, align);
 
 		if ( !base ) {
-			prom_panic(RELOC("ERROR, cannot find space for TCE table.\n"));
+			prom_panic("ERROR, cannot find space for TCE table.\n");
 		}
 
 		vbase = (unsigned long)abs_to_virt(base);
@@ -864,23 +833,10 @@ static void __init prom_initialize_tce_table(void)
 		prom_tce_table[table].base = vbase;
 		prom_tce_table[table].size = minsize;
 
-#ifdef DEBUG_PROM
-		prom_print(RELOC("TCE table: 0x"));
-		prom_print_hex(table);
-		prom_print_nl();
-
-		prom_print(RELOC("\tnode = 0x"));
-		prom_print_hex(node);
-		prom_print_nl();
-
-		prom_print(RELOC("\tbase = 0x"));
-		prom_print_hex(vbase);
-		prom_print_nl();
-
-		prom_print(RELOC("\tsize = 0x"));
-		prom_print_hex(minsize);
-		prom_print_nl();
-#endif
+		prom_debug("TCE table: 0x%x\n", table);
+		prom_debug("\tnode = 0x%x\n", node);
+		prom_debug("\tbase = 0x%x\n", vbase);
+		prom_debug("\tsize = 0x%x\n", minsize);
 
 		/* Initialize the table to have a one-to-one mapping
 		 * over the allocated size.
@@ -895,37 +851,30 @@ static void __init prom_initialize_tce_table(void)
 		/* It seems OF doesn't null-terminate the path :-( */
 		memset(path, 0, sizeof(path));
 		/* Call OF to setup the TCE hardware */
-		if (call_prom(RELOC("package-to-path"), 3, 1, node,
-                             path, sizeof(path)-1) == PROM_ERROR) {
-                        prom_print(RELOC("package-to-path failed\n"));
+		if (call_prom("package-to-path", 3, 1, node,
+			      path, sizeof(path)-1) == PROM_ERROR) {
+                        prom_printf("package-to-path failed\n");
                 } else {
-                        prom_print(RELOC("opening PHB "));
-                        prom_print(path);
+                        prom_printf("opening PHB %s", path);
                 }
 
-                phb_node = (ihandle)call_prom(RELOC("open"), 1, 1, path);
+                phb_node = call_prom("open", 1, 1, path);
                 if ( (long)phb_node <= 0) {
-                        prom_print(RELOC("... failed\n"));
+                        prom_printf("... failed\n");
                 } else {
-                        prom_print(RELOC("... done\n"));
+                        prom_printf("... done\n");
                 }
-                call_prom(RELOC("call-method"), 6, 0,
-                             RELOC("set-64-bit-addressing"),
-			     phb_node,
-			     -1,
-                             minsize, 
-                             base & 0xffffffff,
-                             (base >> 32) & 0xffffffff);
-                call_prom(RELOC("close"), 1, 0, phb_node);
+                call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"),
+			  phb_node, -1, minsize,
+			  (u32) base, (u32) (base >> 32));
+                call_prom("close", 1, 0, phb_node);
 
 		table++;
 	}
 
 	/* Flag the first invalid entry */
 	prom_tce_table[table].node = 0;
-#ifdef DEBUG_PROM
-	prom_print(RELOC("ending prom_initialize_tce_table\n"));
-#endif
+	prom_debug("ending prom_initialize_tce_table\n");
 }
 
 /*
@@ -983,13 +932,11 @@ static void __init prom_hold_cpus(unsigned long mem)
 	if (_systemcfg->platform == PLATFORM_POWERMAC) {
 		for (node = 0; prom_next_node(&node); ) {
 			type[0] = 0;
-			call_prom(RELOC("getprop"), 4, 1, node, RELOC("device_type"),
-				  type, sizeof(type));
+			prom_getprop(node, "device_type", type, sizeof(type));
 			if (strcmp(type, RELOC("cpu")) != 0)
 				continue;
 			reg = -1;
-			call_prom(RELOC("getprop"), 4, 1, node, RELOC("reg"),
-				  &reg, sizeof(reg));
+			prom_getprop(node, "reg", &reg, sizeof(reg));
 			_xPaca[cpuid].xHwProcNum = reg;
 
 #ifdef CONFIG_SMP
@@ -1007,24 +954,13 @@ static void __init prom_hold_cpus(unsigned long mem)
 	/* Initially, we must have one active CPU. */
 	_systemcfg->processorCount = 1;
 
-#ifdef DEBUG_PROM
-	prom_print(RELOC("prom_hold_cpus: start...\n"));
-	prom_print(RELOC("    1) spinloop       = 0x"));
-	prom_print_hex((unsigned long)spinloop);
-	prom_print_nl();
-	prom_print(RELOC("    1) *spinloop      = 0x"));
-	prom_print_hex(*spinloop);
-	prom_print_nl();
-	prom_print(RELOC("    1) acknowledge    = 0x"));
-	prom_print_hex((unsigned long)acknowledge);
-	prom_print_nl();
-	prom_print(RELOC("    1) *acknowledge   = 0x"));
-	prom_print_hex(*acknowledge);
-	prom_print_nl();
-	prom_print(RELOC("    1) secondary_hold = 0x"));
-	prom_print_hex(secondary_hold);
-	prom_print_nl();
-#endif
+	prom_debug("prom_hold_cpus: start...\n");
+	prom_debug("    1) spinloop       = 0x%x\n", (unsigned long)spinloop);
+	prom_debug("    1) *spinloop      = 0x%x\n", *spinloop);
+	prom_debug("    1) acknowledge    = 0x%x\n",
+		   (unsigned long)acknowledge);
+	prom_debug("    1) *acknowledge   = 0x%x\n", *acknowledge);
+	prom_debug("    1) secondary_hold = 0x%x\n", secondary_hold);
 
         /* Set the common spinloop variable, so all of the secondary cpus
 	 * will block when they are awakened from their OF spinloop.
@@ -1041,36 +977,26 @@ static void __init prom_hold_cpus(unsigned long mem)
 	/* look for cpus */
 	for (node = 0; prom_next_node(&node); ) {
 		type[0] = 0;
-		call_prom(RELOC("getprop"), 4, 1, node, RELOC("device_type"),
-			  type, sizeof(type));
+		prom_getprop(node, "device_type", type, sizeof(type));
 		if (strcmp(type, RELOC("cpu")) != 0)
 			continue;
 
 		/* Skip non-configured cpus. */
-		call_prom(RELOC("getprop"), 4, 1, node, RELOC("status"),
-			  type, sizeof(type));
+		prom_getprop(node, "status", type, sizeof(type));
 		if (strcmp(type, RELOC("okay")) != 0)
 			continue;
 
                 reg = -1;
-		call_prom(RELOC("getprop"), 4, 1, node, RELOC("reg"),
-			  &reg, sizeof(reg));
+		prom_getprop(node, "reg", &reg, sizeof(reg));
 
 		path = (char *) mem;
 		memset(path, 0, 256);
-		if ((long) call_prom(RELOC("package-to-path"), 3, 1,
-				     node, path, 255) == PROM_ERROR)
+		if (call_prom("package-to-path", 3, 1,
+			      node, path, 255) == PROM_ERROR)
 			continue;
 
-#ifdef DEBUG_PROM
-		prom_print_nl();
-		prom_print(RELOC("cpuid        = 0x"));
-		prom_print_hex(cpuid);
-		prom_print_nl();
-		prom_print(RELOC("cpu hw idx   = 0x"));
-		prom_print_hex(reg);
-		prom_print_nl();
-#endif
+		prom_debug("\ncpuid        = 0x%x\n", cpuid);
+		prom_debug("cpu hw idx   = 0x%x\n", reg);
 		_xPaca[cpuid].xHwProcNum = reg;
 
 		/* Init the acknowledge var which will be reset by
@@ -1079,10 +1005,9 @@ static void __init prom_hold_cpus(unsigned long mem)
 		 */
 		*acknowledge = (unsigned long)-1;
 
-		propsize = call_prom(RELOC("getprop"), 4, 1, node,
-				     RELOC("ibm,ppc-interrupt-server#s"), 
-				     &interrupt_server, 
-				     sizeof(interrupt_server));
+		propsize = prom_getprop(node, "ibm,ppc-interrupt-server#s",
+					&interrupt_server,
+					sizeof(interrupt_server));
 		if (propsize < 0) {
 			/* no property.  old hardware has no SMT */
 			cpu_threads = 1;
@@ -1091,11 +1016,9 @@ static void __init prom_hold_cpus(unsigned long mem)
 			/* We have a threaded processor */
 			cpu_threads = propsize / sizeof(u32);
 			if (cpu_threads > MAX_CPU_THREADS) {
-				prom_print(RELOC("SMT: too many threads!\nSMT: found "));
-				prom_print_hex(cpu_threads);
-				prom_print(RELOC(", max is "));
-				prom_print_hex(MAX_CPU_THREADS);
-				prom_print_nl();
+				prom_printf("SMT: too many threads!\n"
+					    "SMT: found %x, max is %x\n",
+					    cpu_threads, MAX_CPU_THREADS);
 				cpu_threads = 1; /* ToDo: panic? */
 			}
 		}
@@ -1103,18 +1026,15 @@ static void __init prom_hold_cpus(unsigned long mem)
 		hw_cpu_num = interrupt_server[0];
 		if (hw_cpu_num != _prom->cpu) {
 			/* Primary Thread of non-boot cpu */
-			prom_print_hex(cpuid);
-			prom_print(RELOC(" : starting cpu "));
-			prom_print(path);
-			prom_print(RELOC("... "));
-			call_prom(RELOC("start-cpu"), 3, 0, node, 
+			prom_printf("%x : starting cpu %s... ", cpuid, path);
+			call_prom("start-cpu", 3, 0, node,
 				  secondary_hold, cpuid);
 
 			for ( i = 0 ; (i < 100000000) && 
 			      (*acknowledge == ((unsigned long)-1)); i++ ) ;
 
 			if (*acknowledge == cpuid) {
-				prom_print(RELOC("... done\n"));
+				prom_printf("... done\n");
 				/* We have to get every CPU out of OF,
 				 * even if we never start it. */
 				if (cpuid >= NR_CPUS)
@@ -1127,17 +1047,12 @@ static void __init prom_hold_cpus(unsigned long mem)
 				cpu_set(cpuid, RELOC(cpu_present_at_boot));
 #endif
 			} else {
-				prom_print(RELOC("... failed: "));
-				prom_print_hex(*acknowledge);
-				prom_print_nl();
+				prom_printf("... failed: %x\n", *acknowledge);
 			}
 		}
 #ifdef CONFIG_SMP
 		else {
-			prom_print_hex(cpuid);
-			prom_print(RELOC(" : booting  cpu "));
-			prom_print(path);
-			prom_print_nl();
+			prom_printf("%x : booting  cpu %s\n", cpuid, path);
 			cpu_set(cpuid, RELOC(cpu_available_map));
 			cpu_set(cpuid, RELOC(cpu_possible_map));
 			cpu_set(cpuid, RELOC(cpu_online_map));
@@ -1152,16 +1067,15 @@ static void __init prom_hold_cpus(unsigned long mem)
 			if (cpuid >= NR_CPUS)
 				continue;
 			_xPaca[cpuid].xHwProcNum = interrupt_server[i];
-			prom_print_hex(interrupt_server[i]);
-			prom_print(RELOC(" : preparing thread ... "));
+			prom_printf("%x : preparing thread ... ",
+				    interrupt_server[i]);
 			if (_naca->smt_state) {
 				cpu_set(cpuid, RELOC(cpu_available_map));
 				cpu_set(cpuid, RELOC(cpu_present_at_boot));
-				prom_print(RELOC("available"));
+				prom_printf("available\n");
 			} else {
-				prom_print(RELOC("not available"));
+				prom_printf("not available\n");
 			}
-			prom_print_nl();
 		}
 #endif
 		cpuid++;
@@ -1171,7 +1085,7 @@ static void __init prom_hold_cpus(unsigned long mem)
 	if (__is_processor(PV_PULSAR) || 
 	    __is_processor(PV_ICESTAR) ||
 	    __is_processor(PV_SSTAR)) {
-		prom_print(RELOC("    starting secondary threads\n"));
+		prom_printf("    starting secondary threads\n");
 
 		for (i = 0; i < NR_CPUS; i += 2) {
 			if (!cpu_online(i))
@@ -1192,24 +1106,22 @@ static void __init prom_hold_cpus(unsigned long mem)
 		}
 		_systemcfg->processorCount *= 2;
 	} else {
-		prom_print(RELOC("Processor is not HMT capable\n"));
+		prom_printf("Processor is not HMT capable\n");
 	}
 #endif
 
-	if (cpuid >= NR_CPUS)
-		prom_print(RELOC("WARNING: maximum CPUs (" __stringify(NR_CPUS)
-				 ") exceeded: ignoring extras\n"));
+	if (cpuid > NR_CPUS)
+		prom_printf("WARNING: maximum CPUs (" __stringify(NR_CPUS)
+			    ") exceeded: ignoring extras\n");
 
-#ifdef DEBUG_PROM
-	prom_print(RELOC("prom_hold_cpus: end...\n"));
-#endif
+	prom_debug("prom_hold_cpus: end...\n");
 }
 
 static void __init smt_setup(void)
 {
 	char *p, *q;
 	char my_smt_enabled = SMT_DYNAMIC;
-	ihandle prom_options = NULL;
+	ihandle prom_options = 0;
 	char option[9];
 	unsigned long offset = reloc_offset();
         struct naca_struct *_naca = RELOC(naca);
@@ -1233,13 +1145,10 @@ static void __init smt_setup(void)
 		}
 	}
 	if (!found) {
-		prom_options = (ihandle)call_prom(RELOC("finddevice"), 1, 1, RELOC("/options"));
+		prom_options = call_prom("finddevice", 1, 1, ADDR("/options"));
 		if (prom_options != (ihandle) -1) {
-			call_prom(RELOC("getprop"), 
-				4, 1, prom_options,
-				RELOC("ibm,smt-enabled"), 
-				option, 
-				sizeof(option));
+			prom_getprop(prom_options, "ibm,smt-enabled",
+				     option, sizeof(option));
 			if (option[0] != 0) {
 				found = 1;
 				if (!strcmp(option, RELOC("off")))
@@ -1272,43 +1181,29 @@ static void __init setup_disp_fake_bi(ihandle dp)
 	int i, naddrs;
 	char name[64];
 	unsigned long offset = reloc_offset();
-	char *getprop = RELOC("getprop");
-
-	prom_print(RELOC("Initializing fake screen: "));
 
 	memset(name, 0, sizeof(name));
-	call_prom(getprop, 4, 1, dp, RELOC("name"), name, sizeof(name));
+	prom_getprop(dp, "name", name, sizeof(name));
 	name[sizeof(name)-1] = 0;
-	prom_print(name);
-	prom_print(RELOC("\n"));
-	call_prom(getprop, 4, 1, dp, RELOC("width"), &width, sizeof(width));
-	call_prom(getprop, 4, 1, dp, RELOC("height"), &height, sizeof(height));
-	call_prom(getprop, 4, 1, dp, RELOC("depth"), &depth, sizeof(depth));
+	prom_printf("Initializing fake screen: %s\n", name);
+
+	prom_getprop(dp, "width", &width, sizeof(width));
+	prom_getprop(dp, "height", &height, sizeof(height));
+	prom_getprop(dp, "depth", &depth, sizeof(depth));
 	pitch = width * ((depth + 7) / 8);
-	call_prom(getprop, 4, 1, dp, RELOC("linebytes"),
-		  &pitch, sizeof(pitch));
+	prom_getprop(dp, "linebytes", &pitch, sizeof(pitch));
 	if (pitch == 1)
 		pitch = 0x1000;		/* for strange IBM display */
 	address = 0;
 
-	prom_print(RELOC("width "));
-	prom_print_hex(width);
-	prom_print(RELOC(" height "));
-	prom_print_hex(height);
-	prom_print(RELOC(" depth "));
-	prom_print_hex(depth);
-	prom_print(RELOC(" linebytes "));
-	prom_print_hex(pitch);
-	prom_print(RELOC("\n"));
-
+	prom_printf("width %x height %x depth %x linebytes %x\n",
+		    width, height, depth, depth);
 
-	call_prom(getprop, 4, 1, dp, RELOC("address"),
-		  &address, sizeof(address));
+	prom_getprop(dp, "address", &address, sizeof(address));
 	if (address == 0) {
 		/* look for an assigned address with a size of >= 1MB */
-		naddrs = (int) call_prom(getprop, 4, 1, dp,
-				RELOC("assigned-addresses"),
-				addrs, sizeof(addrs));
+		naddrs = prom_getprop(dp, "assigned-addresses",
+				      addrs, sizeof(addrs));
 		naddrs /= sizeof(struct pci_reg_property);
 		for (i = 0; i < naddrs; ++i) {
 			if (addrs[i].size_lo >= (1 << 20)) {
@@ -1320,14 +1215,12 @@ static void __init setup_disp_fake_bi(ihandle dp)
 			}
 		}
 		if (address == 0) {
-			prom_print(RELOC("Failed to get address of frame buffer\n"));
+			prom_printf("Failed to get address of frame buffer\n");
 			return;
 		}
 	}
 	btext_setup_display(width, height, depth, pitch, address);
-	prom_print(RELOC("Addr of fb: "));
-	prom_print_hex(address);
-	prom_print_nl();
+	prom_printf("Addr of fb: %x\n", address);
 	RELOC(boot_text_mapped) = 0;
 }
 #endif /* CONFIG_BOOTX_TEXT */
@@ -1344,15 +1237,14 @@ static void __init prom_init_client_services(unsigned long pp)
 	_prom->encode_phys_size = 32;
 
 	/* get a handle for the stdout device */
-	_prom->chosen = (ihandle)call_prom(RELOC("finddevice"), 1, 1,
-				       RELOC("/chosen"));
+	_prom->chosen = call_prom("finddevice", 1, 1, ADDR("/chosen"));
 	if ((long)_prom->chosen <= 0)
-		prom_panic(RELOC("cannot find chosen")); /* msg won't be printed :( */
+		prom_panic("cannot find chosen"); /* msg won't be printed :( */
 
 	/* get device tree root */
-	_prom->root = (ihandle)call_prom(RELOC("finddevice"), 1, 1, RELOC("/"));
+	_prom->root = call_prom("finddevice", 1, 1, ADDR("/"));
 	if ((long)_prom->root <= 0)
-		prom_panic(RELOC("cannot find device tree root")); /* msg won't be printed :( */
+		prom_panic("cannot find device tree root"); /* msg won't be printed :( */
 }
 
 static void __init prom_init_stdout(void)
@@ -1361,12 +1253,10 @@ static void __init prom_init_stdout(void)
 	struct prom_t *_prom = PTRRELOC(&prom);
 	u32 val;
 
-        if ((long)call_prom(RELOC("getprop"), 4, 1, _prom->chosen,
-			    RELOC("stdout"), &val,
-			    sizeof(val)) <= 0)
-                prom_panic(RELOC("cannot find stdout"));
+        if (prom_getprop(_prom->chosen, "stdout", &val, sizeof(val)) <= 0)
+                prom_panic("cannot find stdout");
 
-        _prom->stdout = (ihandle)(unsigned long)val;
+        _prom->stdout = val;
 }
 
 static int __init prom_find_machine_type(void)
@@ -1376,9 +1266,8 @@ static int __init prom_find_machine_type(void)
 	char compat[256];
 	int len, i = 0;
 
-	len = (int)(long)call_prom(RELOC("getprop"), 4, 1, _prom->root,
-				   RELOC("compatible"),
-				   compat, sizeof(compat)-1);
+	len = prom_getprop(_prom->root, "compatible",
+			   compat, sizeof(compat)-1);
 	if (len > 0) {
 		compat[len] = 0;
 		while (i < len) {
@@ -1400,13 +1289,7 @@ static int __init prom_set_color(ihandle ih, int i, int r, int g, int b)
 {
 	unsigned long offset = reloc_offset();
 
-	return (int)(long)call_prom(RELOC("call-method"), 6, 1,
-		                    RELOC("color!"),
-                                    ih,
-                                    (void *)(long) i,
-                                    (void *)(long) b,
-                                    (void *)(long) g,
-                                    (void *)(long) r );
+	return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r);
 }
 
 /*
@@ -1447,16 +1330,13 @@ static unsigned long __init check_display(unsigned long mem)
 
 	_prom->disp_node = 0;
 
-	prom_print(RELOC("Looking for displays\n"));
-	if (RELOC(of_stdout_device) != 0) {
-		prom_print(RELOC("OF stdout is    : "));
-		prom_print(PTRRELOC(RELOC(of_stdout_device)));
-		prom_print(RELOC("\n"));
-	}
+	prom_printf("Looking for displays\n");
+	if (RELOC(of_stdout_device) != 0)
+		prom_printf("OF stdout is    : %s\n",
+			    PTRRELOC(RELOC(of_stdout_device)));
 	for (node = 0; prom_next_node(&node); ) {
 		type[0] = 0;
-		call_prom(RELOC("getprop"), 4, 1, node, RELOC("device_type"),
-			  type, sizeof(type));
+		prom_getprop(node, "device_type", type, sizeof(type));
 		if (strcmp(type, RELOC("display")) != 0)
 			continue;
 		/* It seems OF doesn't null-terminate the path :-( */
@@ -1467,12 +1347,9 @@ static unsigned long __init check_display(unsigned long mem)
 		 * leave some room at the end of the path for appending extra
 		 * arguments
 		 */
-		if ((long) call_prom(RELOC("package-to-path"), 3, 1,
-				    node, path, 250) < 0)
+		if (call_prom("package-to-path", 3, 1, node, path, 250) < 0)
 			continue;
-		prom_print(RELOC("found display   : "));
-		prom_print(path);
-		prom_print(RELOC("\n"));
+		prom_printf("found display   : %s\n", path);
 		
 		/*
 		 * If this display is the device that OF is using for stdout,
@@ -1489,27 +1366,26 @@ static unsigned long __init check_display(unsigned long mem)
 				RELOC(prom_display_nodes[i])
 					= RELOC(prom_display_nodes[i-1]);
 			}
-			_prom->disp_node = (ihandle)(unsigned long)node;
+			_prom->disp_node = node;
 		}
 		RELOC(prom_display_paths[i]) = PTRUNRELOC(path);
 		RELOC(prom_display_nodes[i]) = node;
 		if (_prom->disp_node == 0)
-			_prom->disp_node = (ihandle)(unsigned long)node;
+			_prom->disp_node = node;
 		if (RELOC(prom_num_displays) >= FB_MAX)
 			break;
 	}
-	prom_print(RELOC("Opening displays...\n"));
+	prom_printf("Opening displays...\n");
 	for (j = RELOC(prom_num_displays) - 1; j >= 0; j--) {
 		path = PTRRELOC(RELOC(prom_display_paths[j]));
-		prom_print(RELOC("opening display : "));
-		prom_print(path);
-		ih = (ihandle)call_prom(RELOC("open"), 1, 1, path);
+		prom_printf("opening display : %s", path);
+		ih = call_prom("open", 1, 1, path);
 		if (ih == (ihandle)0 || ih == (ihandle)-1) {
-			prom_print(RELOC("... failed\n"));
+			prom_printf("... failed\n");
 			continue;
 		}
 
-		prom_print(RELOC("... done\n"));
+		prom_printf("... done\n");
 
 		/* Setup a useable color table when the appropriate
 		 * method is available. Should update this to set-colors */
@@ -1546,9 +1422,9 @@ static void __init *__make_room(unsigned long *mem_start, unsigned long *mem_end
 		unsigned long initrd_len;
 
 		if (*mem_end != RELOC(initrd_start))
-			prom_panic(RELOC("No memory for copy_device_tree"));
+			prom_panic("No memory for copy_device_tree");
 
-		prom_print(RELOC("Huge device_tree: moving initrd\n"));
+		prom_printf("Huge device_tree: moving initrd\n");
 		/* Move by 4M. */
 		initrd_len = RELOC(initrd_end) - RELOC(initrd_start);
 		*mem_end = RELOC(initrd_start) + 4 * 1024 * 1024;
@@ -1557,7 +1433,7 @@ static void __init *__make_room(unsigned long *mem_start, unsigned long *mem_end
 		RELOC(initrd_start) = *mem_end;
 		RELOC(initrd_end) = RELOC(initrd_start) + initrd_len;
 #else
-		prom_panic(RELOC("No memory for copy_device_tree"));
+		prom_panic("No memory for copy_device_tree");
 #endif
 	}
 
@@ -1606,8 +1482,7 @@ inspect_node(phandle node, struct device_node *dad,
 	for (;;) {
 		/* 32 is max len of name including nul. */
 		namep = make_room(mem_start, mem_end, char[32]);
-		if ((long) call_prom(RELOC("nextprop"), 3, 1, node, prev_name,
-				     namep) <= 0) {
+		if (call_prom("nextprop", 3, 1, node, prev_name, namep) <= 0) {
 			/* No more nodes: unwind alloc */
 			*mem_start = (unsigned long)namep;
 			break;
@@ -1619,28 +1494,24 @@ inspect_node(phandle node, struct device_node *dad,
 		pp->name = PTRUNRELOC(namep);
 		prev_name = namep;
 
-		pp->length = call_prom(RELOC("getproplen"), 2, 1, node, namep);
+		pp->length = call_prom("getproplen", 2, 1, node, namep);
 		if (pp->length < 0)
 			continue;
 		if (pp->length > MAX_PROPERTY_LENGTH) {
 			char path[128];
 
-			prom_print(RELOC("WARNING: ignoring large property "));
+			prom_printf("WARNING: ignoring large property ");
 			/* It seems OF doesn't null-terminate the path :-( */
 			memset(path, 0, sizeof(path));
-			if (call_prom(RELOC("package-to-path"), 3, 1, node,
-                            path, sizeof(path)-1) > 0)
-				prom_print(path);
-			prom_print(namep);
-			prom_print(RELOC(" length 0x"));
-			prom_print_hex(pp->length);
-			prom_print_nl();
-
+			if (call_prom("package-to-path", 3, 1, node,
+				      path, sizeof(path)-1) > 0)
+				prom_printf("[%s] ", path);
+			prom_printf("%s length 0x%x\n", namep, pp->length);
 			continue;
 		}
 		valp = __make_room(mem_start, mem_end, pp->length, 1);
 		pp->value = PTRUNRELOC(valp);
-		call_prom(RELOC("getprop"), 4, 1, node, namep,valp,pp->length);
+		call_prom("getprop", 4, 1, node, namep, valp, pp->length);
 		*prev_propp = PTRUNRELOC(pp);
 		prev_propp = &pp->next;
 	}
@@ -1660,19 +1531,19 @@ inspect_node(phandle node, struct device_node *dad,
 	/* Set np->linux_phandle to the value of the ibm,phandle property
 	   if it exists, otherwise to the phandle for this node. */
 	np->linux_phandle = node;
-	if ((int)call_prom(RELOC("getprop"), 4, 1, node, RELOC("ibm,phandle"),
-			   &ibm_phandle, sizeof(ibm_phandle)) > 0)
+	if (prom_getprop(node, "ibm,phandle",
+			 &ibm_phandle, sizeof(ibm_phandle)) > 0)
 		np->linux_phandle = ibm_phandle;
 
 	/* get the node's full name */
 	namep = (char *)*mem_start;
-	l = (long) call_prom(RELOC("package-to-path"), 3, 1, node,
-			     namep, *mem_end - *mem_start);
+	l = call_prom("package-to-path", 3, 1, node,
+		      namep, *mem_end - *mem_start);
 	if (l >= 0) {
 		/* Didn't fit?  Get more room. */
 		if (l+1 > *mem_end - *mem_start) {
 			namep = __make_room(mem_start, mem_end, l+1, 1);
-			call_prom(RELOC("package-to-path"),3,1,node,namep,l);
+			call_prom("package-to-path", 3, 1, node, namep, l);
 		}
 		np->full_name = PTRUNRELOC(namep);
 		namep[l] = '\0';
@@ -1680,11 +1551,11 @@ inspect_node(phandle node, struct device_node *dad,
 	}
 
 	/* do all our children */
-	child = call_prom(RELOC("child"), 1, 1, node);
+	child = call_prom("child", 1, 1, node);
 	while (child != (phandle)0) {
 		inspect_node(child, np, mem_start, mem_end,
 					 allnextpp);
-		child = call_prom(RELOC("peer"), 1, 1, child);
+		child = call_prom("peer", 1, 1, child);
 	}
 }
 
@@ -1706,9 +1577,9 @@ copy_device_tree(unsigned long mem_start)
 		mem_end = RELOC(initrd_start);
 #endif /* CONFIG_BLK_DEV_INITRD */
 
-	root = call_prom(RELOC("peer"), 1, 1, (phandle)0);
+	root = call_prom("peer", 1, 1, (phandle)0);
 	if (root == (phandle)0) {
-		prom_panic(RELOC("couldn't get device tree root\n"));
+		prom_panic("couldn't get device tree root\n");
 	}
 	allnextp = &RELOC(allnodes);
 	inspect_node(root, 0, &mem_start, &mem_end, &allnextp);
@@ -1720,44 +1591,25 @@ copy_device_tree(unsigned long mem_start)
 static struct bi_record * __init prom_bi_rec_verify(struct bi_record *bi_recs)
 {
 	struct bi_record *first, *last;
-#ifdef DEBUG_PROM
-	unsigned long offset = reloc_offset();
 
-  	prom_print(RELOC("birec_verify: r6=0x"));
-  	prom_print_hex((unsigned long)bi_recs);
-  	prom_print_nl();
-	if (bi_recs != NULL) {
-		prom_print(RELOC("  tag=0x"));
-		prom_print_hex(bi_recs->tag);
-		prom_print_nl();
-	}
-#endif /* DEBUG_PROM */
+  	prom_debug("birec_verify: r6=0x%x\n", (unsigned long)bi_recs);
+	if (bi_recs != NULL)
+		prom_debug("  tag=0x%x\n", bi_recs->tag);
 
 	if ( bi_recs == NULL || bi_recs->tag != BI_FIRST )
 		return NULL;
 
 	last = (struct bi_record *)(long)bi_recs->data[0];
 
-#ifdef DEBUG_PROM
-  	prom_print(RELOC("  last=0x"));
-  	prom_print_hex((unsigned long)last);
-  	prom_print_nl();
-	if (last != NULL) {
-		prom_print(RELOC("  last_tag=0x"));
-		prom_print_hex(last->tag);
-		prom_print_nl();
-	}
-#endif /* DEBUG_PROM */
+  	prom_debug("  last=0x%x\n", (unsigned long)last);
+	if (last != NULL)
+		prom_debug("  last_tag=0x%x\n", last->tag);
 
 	if ( last == NULL || last->tag != BI_LAST )
 		return NULL;
 
 	first = (struct bi_record *)(long)last->data[0];
-#ifdef DEBUG_PROM
-  	prom_print(RELOC("  first=0x"));
-  	prom_print_hex((unsigned long)first);
-  	prom_print_nl();
-#endif /* DEBUG_PROM */
+  	prom_debug("  first=0x%x\n", (unsigned long)first);
 
 	if ( first == NULL || first != bi_recs )
 		return NULL;
@@ -1776,11 +1628,7 @@ static void __init prom_bi_rec_reserve(void)
 		for ( rec=_prom->bi_recs;
 		      rec->tag != BI_LAST;
 		      rec=bi_rec_next(rec) ) {
-#ifdef DEBUG_PROM
-			prom_print(RELOC("bi: 0x"));
-			prom_print_hex(rec->tag);
-			prom_print_nl();
-#endif /* DEBUG_PROM */
+			prom_debug("bi: 0x%x\n", rec->tag);
 			switch (rec->tag) {
 #ifdef CONFIG_BLK_DEV_INITRD
 			case BI_INITRD:
@@ -1833,31 +1681,17 @@ prom_init(unsigned long r3, unsigned long r4, unsigned long pp,
 	/* Init prom stdout device */
 	prom_init_stdout();
 
-#ifdef DEBUG_PROM
-  	prom_print(RELOC("klimit=0x"));
-  	prom_print_hex(RELOC(klimit));
-  	prom_print_nl();
-  	prom_print(RELOC("offset=0x"));
-  	prom_print_hex(offset);
-  	prom_print_nl();
-  	prom_print(RELOC("->mem=0x"));
-  	prom_print_hex(RELOC(klimit) - offset);
-  	prom_print_nl();
-#endif /* DEBUG_PROM */
+  	prom_debug("klimit=0x%x\n", RELOC(klimit));
+  	prom_debug("offset=0x%x\n", offset);
+  	prom_debug("->mem=0x%x\n", RELOC(klimit) - offset);
 
 	/* check out if we have bi_recs */
 	_prom->bi_recs = prom_bi_rec_verify((struct bi_record *)r6);
 	if ( _prom->bi_recs != NULL ) {
 		RELOC(klimit) = PTRUNRELOC((unsigned long)_prom->bi_recs +
 					   _prom->bi_recs->data[1]);
-#ifdef DEBUG_PROM
-		prom_print(RELOC("bi_recs=0x"));
-		prom_print_hex((unsigned long)_prom->bi_recs);
-		prom_print_nl();
-		prom_print(RELOC("new mem=0x"));
-		prom_print_hex(RELOC(klimit) - offset);
-		prom_print_nl();
-#endif /* DEBUG_PROM */
+		prom_debug("bi_recs=0x%x\n", (unsigned long)_prom->bi_recs);
+		prom_debug("new mem=0x%x\n", RELOC(klimit) - offset);
 	}
 
 	/* If we don't have birec's or didn't find them, check for an initrd
@@ -1884,57 +1718,46 @@ prom_init(unsigned long r3, unsigned long r4, unsigned long pp,
 	/* Get the full OF pathname of the stdout device */
 	p = (char *) mem;
 	memset(p, 0, 256);
-	call_prom(RELOC("instance-to-path"), 3, 1, _prom->stdout, p, 255);
+	call_prom("instance-to-path", 3, 1, _prom->stdout, p, 255);
 	RELOC(of_stdout_device) = PTRUNRELOC(p);
 	mem += strlen(p) + 1;
 
 	getprop_rval = 1;
-	call_prom(RELOC("getprop"), 4, 1,
-		  _prom->root, RELOC("#size-cells"),
-		  &getprop_rval, sizeof(getprop_rval));
+	prom_getprop(_prom->root, "#size-cells",
+		     &getprop_rval, sizeof(getprop_rval));
 	_prom->encode_phys_size = (getprop_rval == 1) ? 32 : 64;
 
 	/* Determine which cpu is actually running right _now_ */
-        if ((long)call_prom(RELOC("getprop"), 4, 1, _prom->chosen,
-			    RELOC("cpu"), &getprop_rval,
-			    sizeof(getprop_rval)) <= 0)
-                prom_panic(RELOC("cannot find boot cpu"));
-
-	prom_cpu = (ihandle)(unsigned long)getprop_rval;
-	cpu_pkg = call_prom(RELOC("instance-to-package"), 1, 1, prom_cpu);
-	call_prom(RELOC("getprop"), 4, 1,
-		cpu_pkg, RELOC("reg"),
-		&getprop_rval, sizeof(getprop_rval));
-	_prom->cpu = (int)(unsigned long)getprop_rval;
+        if (prom_getprop(_prom->chosen, "cpu",
+			 &prom_cpu, sizeof(prom_cpu)) <= 0)
+                prom_panic("cannot find boot cpu");
+
+	cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);
+	prom_getprop(cpu_pkg, "reg", &getprop_rval, sizeof(getprop_rval));
+	_prom->cpu = getprop_rval;
 	_xPaca[0].xHwProcNum = _prom->cpu;
 
 	RELOC(boot_cpuid) = 0;
 
-#ifdef DEBUG_PROM
-  	prom_print(RELOC("Booting CPU hw index = 0x"));
-  	prom_print_hex(_prom->cpu);
-  	prom_print_nl();
-#endif
+  	prom_debug("Booting CPU hw index = 0x%x\n", _prom->cpu);
 
 	/* Get the boot device and translate it to a full OF pathname. */
 	p = (char *) mem;
-	l = (long) call_prom(RELOC("getprop"), 4, 1, _prom->chosen,
-			    RELOC("bootpath"), p, 1<<20);
+	l = prom_getprop(_prom->chosen, "bootpath", p, 1<<20);
 	if (l > 0) {
 		p[l] = 0;	/* should already be null-terminated */
 		RELOC(bootpath) = PTRUNRELOC(p);
 		mem += l + 1;
 		d = (char *) mem;
 		*d = 0;
-		call_prom(RELOC("canon"), 3, 1, p, d, 1<<20);
+		call_prom("canon", 3, 1, p, d, 1<<20);
 		RELOC(bootdevice) = PTRUNRELOC(d);
 		mem = DOUBLEWORD_ALIGN(mem + strlen(d) + 1);
 	}
 
 	RELOC(cmd_line[0]) = 0;
 	if ((long)_prom->chosen > 0) {
-		call_prom(RELOC("getprop"), 4, 1, _prom->chosen,
-			  RELOC("bootargs"), p, sizeof(cmd_line));
+		prom_getprop(_prom->chosen, "bootargs", p, sizeof(cmd_line));
 		if (p != NULL && p[0] != 0)
 			strlcpy(RELOC(cmd_line), p, sizeof(cmd_line));
 	}
@@ -1961,33 +1784,20 @@ prom_init(unsigned long r3, unsigned long r4, unsigned long pp,
          */
 	prom_hold_cpus(mem);
 
-#ifdef DEBUG_PROM
-  	prom_print(RELOC("after basic inits, mem=0x"));
-  	prom_print_hex(mem);
-  	prom_print_nl();
+  	prom_debug("after basic inits, mem=0x%x\n", mem);
 #ifdef CONFIG_BLK_DEV_INITRD
-	prom_print(RELOC("initrd_start=0x"));
-	prom_print_hex(RELOC(initrd_start));
-	prom_print_nl();
-	prom_print(RELOC("initrd_end=0x"));
-	prom_print_hex(RELOC(initrd_end));
-	prom_print_nl();
+	prom_debug("initrd_start=0x%x\n", RELOC(initrd_start));
+	prom_debug("initrd_end=0x%x\n", RELOC(initrd_end));
 #endif /* CONFIG_BLK_DEV_INITRD */
-	prom_print(RELOC("copying OF device tree...\n"));
-#endif /* DEBUG_PROM */
+	prom_debug("copying OF device tree...\n");
+
 	mem = copy_device_tree(mem);
 
 	RELOC(klimit) = mem + offset;
 
-#ifdef DEBUG_PROM
-	prom_print(RELOC("new klimit is\n"));
-  	prom_print(RELOC("klimit=0x"));
-  	prom_print_hex(RELOC(klimit));
-	prom_print(RELOC(" ->mem=0x\n"));
-  	prom_print(RELOC("klimit=0x"));
-  	prom_print_hex(mem);
-  	prom_print_nl();
-#endif /* DEBUG_PROM */
+	prom_debug("new klimit is\n");
+  	prom_debug("klimit=0x%x\n", RELOC(klimit));
+	prom_debug(" ->mem=0x%x\n", mem);
 
 	lmb_reserve(0, __pa(RELOC(klimit)));
 
@@ -2017,14 +1827,14 @@ prom_init(unsigned long r3, unsigned long r4, unsigned long pp,
 #endif
 
 #ifdef CONFIG_BOOTX_TEXT
-	if(_prom->disp_node) {
-		prom_print(RELOC("Setting up bi display...\n"));
+	if (_prom->disp_node) {
+		prom_printf("Setting up bi display...\n");
 		setup_disp_fake_bi(_prom->disp_node);
 	}
 #endif /* CONFIG_BOOTX_TEXT */
 
-	prom_print(RELOC("Calling quiesce ...\n"));
-	call_prom(RELOC("quiesce"), 0, 0);
+	prom_printf("Calling quiesce ...\n");
+	call_prom("quiesce", 0, 0);
 	phys = KERNELBASE - offset;
 
 #ifdef CONFIG_BLK_DEV_INITRD
@@ -2035,7 +1845,7 @@ prom_init(unsigned long r3, unsigned long r4, unsigned long pp,
 	}
 #endif /* CONFIG_BLK_DEV_INITRD */
 
-	prom_print(RELOC("returning from prom_init\n"));
+	prom_printf("returning from prom_init\n");
 	return phys;
 }
 

arch/ppc64/kernel/rtas-proc.c

@@ -394,7 +394,7 @@ static ssize_t ppc_rtas_clock_read(struct file * file, char * buf,
 		size_t count, loff_t *ppos)
 {
 	unsigned int year, mon, day, hour, min, sec;
-	unsigned long *ret = kmalloc(4*8, GFP_KERNEL);
+	int ret[8];
 	int n, sn, error;
 	char stkbuf[40];  /* its small, its on stack */
 
@@ -411,7 +411,6 @@ static ssize_t ppc_rtas_clock_read(struct file * file, char * buf,
 		n = scnprintf (stkbuf, sizeof(stkbuf), "%lu\n",
 				mktime(year, mon, day, hour, min, sec));
 	}
-	kfree(ret);
 
 	sn = strlen (stkbuf) +1;
 	if (*ppos >= sn)
@@ -434,7 +433,6 @@ static int ppc_rtas_sensor_read(char * buf, char ** start, off_t off,
 		int count, int *eof, void *data)
 {
 	int i,j,n;
-	unsigned long ret;
 	int state, error;
 	char *buffer;
 	int get_sensor_state = rtas_token("get-sensor-state");
@@ -464,11 +462,10 @@ static int ppc_rtas_sensor_read(char * buf, char ** start, off_t off,
 		/* A sensor may have multiple instances */
 		while (j >= 0) {
 
-			error =	rtas_call(get_sensor_state, 2, 2, &ret, 
+			error =	rtas_call(get_sensor_state, 2, 2, &state, 
 				  	  sensors.sensor[i].token, 
 				  	  sensors.sensor[i].quant - j);
 
-			state = (int) ret;
 			n += ppc_rtas_process_sensor(sensors.sensor[i], state, 
 					     	     error, buffer+n );
 			n += sprintf (buffer+n, "\n");

arch/ppc64/kernel/rtas.c

@@ -139,15 +139,13 @@ log_rtas_error(struct rtas_args	*rtas_args)
 		log_error(rtas_err_buf, ERR_TYPE_RTAS_LOG, 0);
 }
 
-long
-rtas_call(int token, int nargs, int nret,
-	  unsigned long *outputs, ...)
+int rtas_call(int token, int nargs, int nret, int *outputs, ...)
 {
 	va_list list;
 	int i, logit = 0;
 	unsigned long s;
 	struct rtas_args *rtas_args;
-	long ret;
+	int ret;
 
 	PPCDBG(PPCDBG_RTAS, "Entering rtas_call\n");
 	PPCDBG(PPCDBG_RTAS, "\ttoken    = 0x%x\n", token);
@@ -167,8 +165,8 @@ rtas_call(int token, int nargs, int nret,
 	rtas_args->rets  = (rtas_arg_t *)&(rtas_args->args[nargs]);
 	va_start(list, outputs);
 	for (i = 0; i < nargs; ++i) {
-		rtas_args->args[i] = (rtas_arg_t)LONG_LSW(va_arg(list, ulong));
-		PPCDBG(PPCDBG_RTAS, "\tnarg[%d] = 0x%lx\n", i, rtas_args->args[i]);
+		rtas_args->args[i] = va_arg(list, rtas_arg_t);
+		PPCDBG(PPCDBG_RTAS, "\tnarg[%d] = 0x%x\n", i, rtas_args->args[i]);
 	}
 	va_end(list);
 
@@ -191,7 +189,7 @@ rtas_call(int token, int nargs, int nret,
 	if (nret > 1 && outputs != NULL)
 		for (i = 0; i < nret-1; ++i)
 			outputs[i] = rtas_args->rets[i+1];
-	ret = (ulong)((nret > 0) ? rtas_args->rets[0] : 0);
+	ret = (nret > 0)? rtas_args->rets[0]: 0;
 
 	/* Gotta do something different here, use global lock for now... */
 	spin_unlock_irqrestore(&rtas.lock, s);
@@ -227,20 +225,13 @@ int
 rtas_get_power_level(int powerdomain, int *level)
 {
 	int token = rtas_token("get-power-level");
-	long powerlevel;
 	int rc;
 
 	if (token == RTAS_UNKNOWN_SERVICE)
 		return RTAS_UNKNOWN_OP;
 
-	while(1) {
-		rc = (int) rtas_call(token, 1, 2, &powerlevel, powerdomain);
-		if (rc == RTAS_BUSY)
-			udelay(1);
-		else
-			break;
-	}
-	*level = (int) powerlevel;
+	while ((rc = rtas_call(token, 1, 2, level, powerdomain)) == RTAS_BUSY)
+		udelay(1);
 	return rc;
 }
 
@@ -249,25 +240,21 @@ rtas_set_power_level(int powerdomain, int level, int *setlevel)
 {
 	int token = rtas_token("set-power-level");
 	unsigned int wait_time;
-	long returned_level;
 	int rc;
 
 	if (token == RTAS_UNKNOWN_SERVICE)
 		return RTAS_UNKNOWN_OP;
 
 	while (1) {
-		rc = (int) rtas_call(token, 2, 2, &returned_level, powerdomain,
-					level);
+		rc = rtas_call(token, 2, 2, setlevel, powerdomain, level);
 		if (rc == RTAS_BUSY)
 			udelay(1);
 		else if (rtas_is_extended_busy(rc)) {
 			wait_time = rtas_extended_busy_delay_time(rc);
 			udelay(wait_time * 1000);
-		}
-		else
+		} else
 			break;
 	}
-	*setlevel = (int) returned_level;
 	return rc;
 }
 
@@ -276,25 +263,21 @@ rtas_get_sensor(int sensor, int index, int *state)
 {
 	int token = rtas_token("get-sensor-state");
 	unsigned int wait_time;
-	long returned_state;
 	int rc;
 
 	if (token == RTAS_UNKNOWN_SERVICE)
 		return RTAS_UNKNOWN_OP;
 
 	while (1) {
-		rc = (int) rtas_call(token, 2, 2, &returned_state, sensor,
-					index);
+		rc = rtas_call(token, 2, 2, state, sensor, index);
 		if (rc == RTAS_BUSY)
 			udelay(1);
 		else if (rtas_is_extended_busy(rc)) {
 			wait_time = rtas_extended_busy_delay_time(rc);
 			udelay(wait_time * 1000);
-		}
-		else
+		} else
 			break;
 	}
-	*state = (int) returned_state;
 	return rc;
 }
 
@@ -309,8 +292,7 @@ rtas_set_indicator(int indicator, int index, int new_value)
 		return RTAS_UNKNOWN_OP;
 
 	while (1) {
-		rc = (int) rtas_call(token, 3, 1, NULL, indicator, index,
-					new_value);
+		rc = rtas_call(token, 3, 1, NULL, indicator, index, new_value);
 		if (rc == RTAS_BUSY)
 			udelay(1);
 		else if (rtas_is_extended_busy(rc)) {
@@ -409,7 +391,7 @@ rtas_restart(char *cmd)
 	if (rtas_firmware_flash_list.next)
 		rtas_flash_firmware();
 
-        printk("RTAS system-reboot returned %ld\n",
+        printk("RTAS system-reboot returned %d\n",
 	       rtas_call(rtas_token("system-reboot"), 0, 1, NULL));
         for (;;);
 }
@@ -420,8 +402,8 @@ rtas_power_off(void)
 	if (rtas_firmware_flash_list.next)
 		rtas_flash_bypass_warning();
         /* allow power on only with power button press */
-        printk("RTAS power-off returned %ld\n",
-               rtas_call(rtas_token("power-off"), 2, 1, NULL,0xffffffff,0xffffffff));
+        printk("RTAS power-off returned %d\n",
+               rtas_call(rtas_token("power-off"), 2, 1, NULL, -1, -1));
         for (;;);
 }
 
@@ -438,7 +420,7 @@ static char rtas_os_term_buf[2048];
 
 void rtas_os_term(char *str)
 {
-	long status;
+	int status;
 
 	snprintf(rtas_os_term_buf, 2048, "OS panic: %s", str);
 
@@ -449,7 +431,7 @@ void rtas_os_term(char *str)
 		if (status == RTAS_BUSY)
 			udelay(1);
 		else if (status != 0)
-			printk(KERN_EMERG "ibm,os-term call failed %ld\n",
+			printk(KERN_EMERG "ibm,os-term call failed %d\n",
 			       status);
 	} while (status == RTAS_BUSY);
 }

arch/ppc64/kernel/rtas_flash.c

@@ -344,8 +344,8 @@ static void manage_flash(struct rtas_manage_flash_t *args_buf)
 	s32 rc;
 
 	while (1) {
-		rc = (s32) rtas_call(rtas_token("ibm,manage-flash-image"), 1, 
-				1, NULL, (long) args_buf->op);
+		rc = rtas_call(rtas_token("ibm,manage-flash-image"), 1, 
+			       1, NULL, args_buf->op);
 		if (rc == RTAS_RC_BUSY)
 			udelay(1);
 		else if (rtas_is_extended_busy(rc)) {
@@ -429,15 +429,15 @@ static void validate_flash(struct rtas_validate_flash_t *args_buf)
 {
 	int token = rtas_token("ibm,validate-flash-image");
 	unsigned int wait_time;
-	long update_results;
+	int update_results;
 	s32 rc;	
 
 	rc = 0;
 	while(1) {
 		spin_lock(&rtas_data_buf_lock);
 		memcpy(rtas_data_buf, args_buf->buf, VALIDATE_BUF_SIZE);
-		rc = (s32) rtas_call(token, 2, 2, &update_results, 
-				     __pa(rtas_data_buf), args_buf->buf_size);
+		rc = rtas_call(token, 2, 2, &update_results, 
+			       (u32) __pa(rtas_data_buf), args_buf->buf_size);
 		memcpy(args_buf->buf, rtas_data_buf, VALIDATE_BUF_SIZE);
 		spin_unlock(&rtas_data_buf_lock);
 			
@@ -451,7 +451,7 @@ static void validate_flash(struct rtas_validate_flash_t *args_buf)
 	}
 
 	args_buf->status = rc;
-	args_buf->update_results = (u32) update_results;
+	args_buf->update_results = update_results;
 }
 
 static int get_validate_flash_msg(struct rtas_validate_flash_t *args_buf, 

arch/ppc64/kernel/rtc.c

@@ -346,13 +346,13 @@ void iSeries_get_boot_time(struct rtc_time *tm)
 #define RTAS_CLOCK_BUSY (-2)
 void pSeries_get_boot_time(struct rtc_time *rtc_tm)
 {
-	unsigned long ret[8];
+	int ret[8];
 	int error, wait_time;
 	unsigned long max_wait_tb;
 
 	max_wait_tb = __get_tb() + tb_ticks_per_usec * 1000 * MAX_RTC_WAIT;
 	do {
-		error = rtas_call(rtas_token("get-time-of-day"), 0, 8, (void *)&ret);
+		error = rtas_call(rtas_token("get-time-of-day"), 0, 8, ret);
 		if (error == RTAS_CLOCK_BUSY || rtas_is_extended_busy(error)) {
 			wait_time = rtas_extended_busy_delay_time(error);
 			/* This is boot time so we spin. */
@@ -381,13 +381,13 @@ void pSeries_get_boot_time(struct rtc_time *rtc_tm)
  */
 void pSeries_get_rtc_time(struct rtc_time *rtc_tm)
 {
-        unsigned long ret[8];
+        int ret[8];
 	int error, wait_time;
 	unsigned long max_wait_tb;
 
 	max_wait_tb = __get_tb() + tb_ticks_per_usec * 1000 * MAX_RTC_WAIT;
 	do {
-		error = rtas_call(rtas_token("get-time-of-day"), 0, 8, (void *)&ret);
+		error = rtas_call(rtas_token("get-time-of-day"), 0, 8, ret);
 		if (error == RTAS_CLOCK_BUSY || rtas_is_extended_busy(error)) {
 			if (in_interrupt()) {
 				printk(KERN_WARNING "error: reading clock would delay interrupt\n");

arch/ppc64/kernel/scanlog.c

@@ -49,7 +49,7 @@ static ssize_t scanlog_read(struct file *file, char *buf,
         struct inode * inode = file->f_dentry->d_inode;
 	struct proc_dir_entry *dp;
 	unsigned int *data;
-	unsigned long status;
+	int status;
 	unsigned long len, off;
 	unsigned int wait_time;
 
@@ -81,11 +81,11 @@ static ssize_t scanlog_read(struct file *file, char *buf,
 		spin_lock(&rtas_data_buf_lock);
 		memcpy(rtas_data_buf, data, RTAS_DATA_BUF_SIZE);
 		status = rtas_call(ibm_scan_log_dump, 2, 1, NULL,
-				   __pa(rtas_data_buf), count);
+				   (u32) __pa(rtas_data_buf), (u32) count);
 		memcpy(data, rtas_data_buf, RTAS_DATA_BUF_SIZE);
 		spin_unlock(&rtas_data_buf_lock);
 
-		DEBUG("status=%ld, data[0]=%x, data[1]=%x, data[2]=%x\n",
+		DEBUG("status=%d, data[0]=%x, data[1]=%x, data[2]=%x\n",
 		      status, data[0], data[1], data[2]);
 		switch (status) {
 		    case SCANLOG_COMPLETE:
@@ -133,7 +133,7 @@ static ssize_t scanlog_write(struct file * file, const char * buf,
 			     size_t count, loff_t *ppos)
 {
 	char stkbuf[20];
-	unsigned long status;
+	int status;
 
 	if (count > 19) count = 19;
 	if (copy_from_user (stkbuf, buf, count)) {
@@ -144,8 +144,8 @@ static ssize_t scanlog_write(struct file * file, const char * buf,
 	if (buf) {
 		if (strncmp(stkbuf, "reset", 5) == 0) {
 			DEBUG("reset scanlog\n");
-			status = rtas_call(ibm_scan_log_dump, 2, 1, NULL, NULL, 0);
-			DEBUG("rtas returns %ld\n", status);
+			status = rtas_call(ibm_scan_log_dump, 2, 1, NULL, 0, 0);
+			DEBUG("rtas returns %d\n", status);
 		} else if (strncmp(stkbuf, "debugon", 7) == 0) {
 			printk(KERN_ERR "scanlog: debug on\n");
 			scanlog_debug = 1;

arch/ppc64/kernel/setup.c

@@ -164,7 +164,7 @@ void setup_system(unsigned long r3, unsigned long r4, unsigned long r5,
 		  unsigned long r6, unsigned long r7)
 {
 #if defined(CONFIG_SMP) && defined(CONFIG_PPC_PSERIES)
-	unsigned int ret, i;
+	int ret, i;
 #endif
 
 #ifdef CONFIG_XMON_DEFAULT
@@ -232,12 +232,11 @@ void setup_system(unsigned long r3, unsigned long r4, unsigned long r5,
 #ifdef CONFIG_SMP
 		/* Start secondary threads on SMT systems */
 		for (i = 0; i < NR_CPUS; i++) {
-			if(cpu_available(i)  && !cpu_possible(i)) {
+			if (cpu_available(i) && !cpu_possible(i)) {
 				printk("%16.16x : starting thread\n", i);
-				rtas_call(rtas_token("start-cpu"), 3, 1, 
-					  (void *)&ret,
+				rtas_call(rtas_token("start-cpu"), 3, 1, &ret,
 					  get_hard_smp_processor_id(i), 
-					  *((unsigned long *)pseries_secondary_smp_init),
+					  (u32)*((unsigned long *)pseries_secondary_smp_init),
 					  i);
 				cpu_set(i, cpu_possible_map);
 				systemcfg->processorCount++;

arch/ppc64/kernel/smp.c

@@ -241,7 +241,7 @@ static void __devinit smp_openpic_setup_cpu(int cpu)
  */
 static int query_cpu_stopped(unsigned int pcpu)
 {
-	long cpu_status;
+	int cpu_status;
 	int status, qcss_tok;
 
 	qcss_tok = rtas_token("query-cpu-stopped-state");

arch/ppc64/kernel/traps.c

@@ -172,9 +172,9 @@ static struct rtas_error_log *FWNMI_get_errinfo(struct pt_regs *regs)
  */
 static void FWNMI_release_errinfo(void)
 {
-	unsigned long ret = rtas_call(rtas_token("ibm,nmi-interlock"), 0, 1, NULL);
+	int ret = rtas_call(rtas_token("ibm,nmi-interlock"), 0, 1, NULL);
 	if (ret != 0)
-		printk("FWNMI: nmi-interlock failed: %ld\n", ret);
+		printk("FWNMI: nmi-interlock failed: %d\n", ret);
 }
 #endif
 

arch/ppc64/kernel/xics.c

@@ -275,7 +275,7 @@ static int get_irq_server(unsigned int irq)
 static void xics_enable_irq(unsigned int virq)
 {
 	unsigned int irq;
-	long call_status;
+	int call_status;
 	unsigned int server;
 
 	irq = virt_irq_to_real(irq_offset_down(virq));
@@ -287,7 +287,7 @@ static void xics_enable_irq(unsigned int virq)
 				DEFAULT_PRIORITY);
 	if (call_status != 0) {
 		printk(KERN_ERR "xics_enable_irq: irq=%x: ibm_set_xive "
-		       "returned %lx\n", irq, call_status);
+		       "returned %x\n", irq, call_status);
 		return;
 	}
 
@@ -295,14 +295,14 @@ static void xics_enable_irq(unsigned int virq)
 	call_status = rtas_call(ibm_int_on, 1, 1, NULL, irq);
 	if (call_status != 0) {
 		printk(KERN_ERR "xics_enable_irq: irq=%x: ibm_int_on "
-		       "returned %lx\n", irq, call_status);
+		       "returned %x\n", irq, call_status);
 		return;
 	}
 }
 
 static void xics_disable_real_irq(unsigned int irq)
 {
-	long call_status;
+	int call_status;
 	unsigned int server;
 
 	if (irq == XICS_IPI)
@@ -311,7 +311,7 @@ static void xics_disable_real_irq(unsigned int irq)
 	call_status = rtas_call(ibm_int_off, 1, 1, NULL, irq);
 	if (call_status != 0) {
 		printk(KERN_ERR "xics_disable_real_irq: irq=%x: "
-		       "ibm_int_off returned %lx\n", irq, call_status);
+		       "ibm_int_off returned %x\n", irq, call_status);
 		return;
 	}
 
@@ -320,7 +320,7 @@ static void xics_disable_real_irq(unsigned int irq)
 	call_status = rtas_call(ibm_set_xive, 3, 1, NULL, irq, server, 0xff);
 	if (call_status != 0) {
 		printk(KERN_ERR "xics_disable_irq: irq=%x: ibm_set_xive(0xff)"
-		       " returned %lx\n", irq, call_status);
+		       " returned %x\n", irq, call_status);
 		return;
 	}
 }
@@ -612,8 +612,8 @@ void xics_request_IPIs(void)
 static void xics_set_affinity(unsigned int virq, cpumask_t cpumask)
 {
 	unsigned int irq;
-	long status;
-	unsigned long xics_status[2];
+	int status;
+	int xics_status[2];
 	unsigned long newmask;
 	cpumask_t tmp = CPU_MASK_NONE;
 
@@ -621,11 +621,11 @@ static void xics_set_affinity(unsigned int virq, cpumask_t cpumask)
 	if (irq == XICS_IPI || irq == NO_IRQ)
 		return;
 
-	status = rtas_call(ibm_get_xive, 1, 3, (void *)&xics_status, irq);
+	status = rtas_call(ibm_get_xive, 1, 3, xics_status, irq);
 
 	if (status) {
 		printk(KERN_ERR "xics_set_affinity: irq=%d ibm,get-xive "
-		       "returns %ld\n", irq, status);
+		       "returns %d\n", irq, status);
 		return;
 	}
 
@@ -644,7 +644,7 @@ static void xics_set_affinity(unsigned int virq, cpumask_t cpumask)
 
 	if (status) {
 		printk(KERN_ERR "xics_set_affinity irq=%d ibm,set-xive "
-		       "returns %ld\n", irq, status);
+		       "returns %d\n", irq, status);
 		return;
 	}
 }
@@ -655,10 +655,10 @@ static void xics_set_affinity(unsigned int virq, cpumask_t cpumask)
 void xics_migrate_irqs_away(void)
 {
 	int set_indicator = rtas_token("set-indicator");
-	const unsigned long giqs = 9005UL; /* Global Interrupt Queue Server */
-	unsigned long status = 0;
+	const unsigned int giqs = 9005UL; /* Global Interrupt Queue Server */
+	int status = 0;
 	unsigned int irq, cpu = smp_processor_id();
-	unsigned long xics_status[2];
+	int xics_status[2];
 	unsigned long flags;
 
 	BUG_ON(set_indicator == RTAS_UNKNOWN_SERVICE);
@@ -669,7 +669,7 @@ void xics_migrate_irqs_away(void)
 
 	/* Refuse any new interrupts... */
 	rtas_call(set_indicator, 3, 1, &status, giqs,
-		  hard_smp_processor_id(), 0UL);
+		  hard_smp_processor_id(), 0);
 	WARN_ON(status != 0);
 
 	/* Allow IPIs again... */
@@ -692,11 +692,10 @@ void xics_migrate_irqs_away(void)
 
 		spin_lock_irqsave(&desc->lock, flags);
 
-		status = rtas_call(ibm_get_xive, 1, 3, (void *)&xics_status,
-				   irq);
+		status = rtas_call(ibm_get_xive, 1, 3, xics_status, irq);
 		if (status) {
 			printk(KERN_ERR "migrate_irqs_away: irq=%d "
-					"ibm,get-xive returns %ld\n",
+					"ibm,get-xive returns %d\n",
 					irq, status);
 			goto unlock;
 		}
@@ -719,7 +718,7 @@ void xics_migrate_irqs_away(void)
 				irq, xics_status[0], xics_status[1]);
 		if (status)
 			printk(KERN_ERR "migrate_irqs_away irq=%d "
-					"ibm,set-xive returns %ld\n",
+					"ibm,set-xive returns %d\n",
 					irq, status);
 
 unlock:

include/asm-ppc64/prom.h

@@ -25,7 +25,7 @@
 #define LONG_MSW(X) (((unsigned long)X) >> 32)
 
 typedef u32 phandle;
-typedef void *ihandle;
+typedef u32 ihandle;
 typedef u32 phandle32;
 typedef u32 ihandle32;
 

include/asm-ppc64/rtas.h

@@ -37,7 +37,7 @@
  * Where n_in is the number of input parameters and
  *       n_out is the number of output parameters
  *
- * If the "string" is invalid on this system, RTAS_UNKOWN_SERVICE
+ * If the "string" is invalid on this system, RTAS_UNKNOWN_SERVICE
  * will be returned as a token.  rtas_call() does look for this
  * token and error out gracefully so rtas_call(rtas_token("str"), ...)
  * may be safely used for one-shot calls to RTAS.
@@ -168,7 +168,7 @@ extern struct rtas_t rtas;
 
 extern void enter_rtas(unsigned long);
 extern int rtas_token(const char *service);
-extern long rtas_call(int token, int, int, unsigned long *, ...);
+extern int rtas_call(int token, int, int, int *, ...);
 extern void call_rtas_display_status(char);
 extern void rtas_restart(char *cmd);
 extern void rtas_power_off(void);