Import 2.3.4pre3

README

@@ -46,11 +46,11 @@ DOCUMENTATION:
  - There is a lot of documentation available both in electronic form on
    the Internet and in books, both Linux-specific and pertaining to
    general UNIX questions.  I'd recommend looking into the documentation
-   subdirectories on any Linux ftp site for the LDP (Linux Documentation
+   subdirectories on any Linux FTP site for the LDP (Linux Documentation
    Project) books.  This README is not meant to be documentation on the
    system: there are much better sources available.
 
- - There are various readme's in the kernel Documentation/ subdirectory:
+ - There are various README files in the Documentation/ subdirectory:
    these typically contain kernel-specific installation notes for some 
    drivers for example. See ./Documentation/00-INDEX for a list of what
    is contained in each file.  Please read the Changes file, as it
@@ -233,7 +233,7 @@ IF SOMETHING GOES WRONG:
    isn't anyone listed there, then the second best thing is to mail
    them to me (torvalds@transmeta.com), and possibly to any other
    relevant mailing-list or to the newsgroup.  The mailing-lists are
-   useful especially for SCSI and NETworking problems, as I can't test
+   useful especially for SCSI and networking problems, as I can't test
    either of those personally anyway. 
 
  - In all bug-reports, *please* tell what kernel you are talking about,

arch/i386/defconfig

@@ -304,6 +304,7 @@ CONFIG_USB_UHCI=y
 # CONFIG_USB_OHCI_HCD is not set
 CONFIG_USB_MOUSE=y
 CONFIG_USB_KBD=y
+CONFIG_USB_HUB=y
 # CONFIG_USB_AUDIO is not set
 # CONFIG_USB_ACM is not set
 # CONFIG_USB_PRINTER is not set

arch/sparc/defconfig

@@ -128,6 +128,10 @@ CONFIG_IPX=m
 # CONFIG_IPX_INTERN is not set
 # CONFIG_SPX is not set
 CONFIG_ATALK=m
+CONFIG_DECNET=m
+CONFIG_DECNET_SIOCGIFCONF=y
+# CONFIG_DECNET_ROUTER is not set
+CONFIG_DECNET_RAW=y
 # CONFIG_X25 is not set
 # CONFIG_LAPB is not set
 # CONFIG_BRIDGE is not set
@@ -272,6 +276,7 @@ CONFIG_BSD_DISKLABEL=y
 # CONFIG_MAC_PARTITION is not set
 CONFIG_SMD_DISKLABEL=y
 CONFIG_SOLARIS_X86_PARTITION=y
+# CONFIG_SGI_DISKLABEL is not set
 # CONFIG_UNIXWARE_DISKLABEL is not set
 CONFIG_AMIGA_PARTITION=y
 CONFIG_NLS=y

arch/sparc/kernel/irq.c

-/*  $Id: irq.c,v 1.93 1999/04/21 06:15:45 anton Exp $
+/*  $Id: irq.c,v 1.94 1999/05/28 14:59:20 anton Exp $
  *  arch/sparc/kernel/irq.c:  Interrupt request handling routines. On the
  *                            Sparc the IRQ's are basically 'cast in stone'
  *                            and you are supposed to probe the prom's device
@@ -491,15 +491,13 @@ void handler_irq(int irq, struct pt_regs * regs)
 	extern void smp4m_irq_rotate(int cpu);
 #endif
 
+	irq_enter(cpu, irq);
 	disable_pil_irq(irq);
-#if 0 /* FIXME: rotating IRQs halts the machine during SCSI probe. -ecd */
 #ifdef __SMP__
 	/* Only rotate on lower priority IRQ's (scsi, ethernet, etc.). */
 	if(irq < 10)
 		smp4m_irq_rotate(cpu);
 #endif
-#endif
-	irq_enter(cpu, irq);
 	action = *(irq + irq_action);
 	kstat.irqs[cpu][irq]++;
 	do {
@@ -508,8 +506,8 @@ void handler_irq(int irq, struct pt_regs * regs)
 		action->handler(irq, action->dev_id, regs);
 		action = action->next;
 	} while (action);
-	irq_exit(cpu, irq);
 	enable_pil_irq(irq);
+	irq_exit(cpu, irq);
 }
 
 #ifdef CONFIG_BLK_DEV_FD

arch/sparc/kernel/setup.c

-/*  $Id: setup.c,v 1.105 1999/04/13 14:17:08 jj Exp $
+/*  $Id: setup.c,v 1.106 1999/05/28 16:03:18 anton Exp $
  *  linux/arch/sparc/kernel/setup.c
  *
  *  Copyright (C) 1995  David S. Miller (davem@caip.rutgers.edu)
@@ -456,6 +456,7 @@ __initfunc(void setup_arch(char **cmdline_p,
 					prom_printf("MrCoffee keyboard\n");
 				} else {
 					prom_printf("Inconsistent or unknown console\n");
+					prom_printf("You cannot mix serial and non serial input/output devices\n");
 					prom_halt();
 				}
 			}

arch/sparc/math-emu/Makefile

@@ -14,13 +14,13 @@ O_OBJS   := math.o ashldi3.o fabss.o faddd.o faddq.o fadds.o 		\
 		fdtos.o fitoq.o fmovs.o fmuld.o fmulq.o fmuls.o		\
 		fnegs.o fqtod.o fqtoi.o fqtos.o fsmuld.o fsqrtd.o	\
 		fsqrtq.o fsqrts.o fstod.o fstoi.o fstoq.o fsubd.o 	\
-		fsubq.o	fsubs.o udivmodti4.o
+		fsubq.o	fsubs.o
 
 LINKS	 := double.h faddd.c faddq.c fadds.c fdivd.c fdivq.c fdivs.c	\
 		fdtoi.c fitoq.c fmuld.c fmulq.c fmuls.c fqtoi.c		\
 		fsqrtd.c fsqrtq.c fsqrts.c fstoi.c fsubd.c 		\
-		fsubq.c	fsubs.c op-1.h op-2.h op-4.h op-common.h quad.h	\
-		single.h soft-fp.h udivmodti4.c
+		fsubq.c	fsubs.c op-1.h op-2.h op-4.h op-8.h		\
+		op-common.h quad.h single.h soft-fp.h
 
 .S.s:
 	$(CPP) -D__ASSEMBLY__ -ansi $< -o $*.s

arch/sparc/math-emu/fabss.c

+/* $Id: fabss.c,v 1.8 1999/05/28 13:41:33 jj Exp $
+ * arch/sparc/math-emu/fabss.c
+ *
+ * Copyright (C) 1998 Peter Maydell (pmaydell@chiark.greenend.org.uk)
+ *
+ */
+
 int FABSS(unsigned long *rd, unsigned long *rs2)
 {
-	/* Clear the sign bit (high bit of word 0) */
 	rd[0] = rs2[0] & 0x7fffffffUL;
 	return 0;
 }

arch/sparc/math-emu/fcmpd.c

+/* $Id: fcmpd.c,v 1.8 1999/05/28 13:41:36 jj Exp $
+ * arch/sparc/math-emu/fcmpd.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1998 Peter Maydell (pmaydell@chiark.greenend.org.uk)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "double.h"
 
 int FCMPD(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_D(A); FP_DECL_D(B);
 	long ret;
-	unsigned long *fsr = rd;
+	unsigned long fsr;
 	
-	__FP_UNPACK_D(A, rs1);
-	__FP_UNPACK_D(B, rs2);
-	FP_CMP_D(ret, B, A, 2);
-	if (ret == -1)
-		ret = 2;
-
-	*fsr = (*fsr & ~0xc00) | (ret << 10); 
-	return 0;
+	FP_UNPACK_RAW_DP(A, rs1);
+	FP_UNPACK_RAW_DP(B, rs2);
+	FP_CMP_D(ret, B, A, 3);
+	if (ret == 3 && (FP_ISSIGNAN_D(A) || FP_ISSIGNAN_D(B)))
+		FP_SET_EXCEPTION(FP_EX_INVALID);
+	if (!FP_INHIBIT_RESULTS) {
+		if (ret == -1) ret = 2;
+		fsr = *(long *)rd;
+		fsr &= ~0xc00;
+		fsr |= (ret << 10);
+		*(long *)rd = fsr;
+	}
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc/math-emu/fcmped.c

+/* $Id: fcmped.c,v 1.8 1999/05/28 13:41:38 jj Exp $
+ * arch/sparc/math-emu/fcmped.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1998 Peter Maydell (pmaydell@chiark.greenend.org.uk)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "double.h"
 
 int FCMPED(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_D(A); FP_DECL_D(B);
 	long ret;
-	unsigned long *fsr = rd;
+	unsigned long fsr;
 	
-	__FP_UNPACK_D(A, rs1);
-	__FP_UNPACK_D(B, rs2);
-	FP_CMP_D(ret, B, A, 2);
-	if (ret == -1)
-		ret = 2;
-
-	*fsr = (*fsr & ~0xc00) | (ret << 10); 
-	return 0;
+	FP_UNPACK_RAW_DP(A, rs1);
+	FP_UNPACK_RAW_DP(B, rs2);
+	FP_CMP_D(ret, B, A, 3);
+	if (ret == 3)
+		FP_SET_EXCEPTION(FP_EX_INVALID);
+	if (!FP_INHIBIT_RESULTS) {
+		if (ret == -1) ret = 2;
+		fsr = *(long *)rd;
+		fsr &= ~0xc00;
+		fsr |= (ret << 10);
+		*(long *)rd = fsr;
+	}
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc/math-emu/fcmpeq.c

+/* $Id: fcmpeq.c,v 1.8 1999/05/28 13:41:42 jj Exp $
+ * arch/sparc/math-emu/fcmpeq.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1998 Peter Maydell (pmaydell@chiark.greenend.org.uk)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 
 int FCMPEQ(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_Q(A); FP_DECL_Q(B);
 	long ret;
 	unsigned long fsr;
 	
-	__FP_UNPACK_Q(A, rs1);
-	__FP_UNPACK_Q(B, rs2);
+	FP_UNPACK_RAW_QP(A, rs1);
+	FP_UNPACK_RAW_QP(B, rs2);
 	FP_CMP_Q(ret, B, A, 3);
-	if (ret == -1) ret = 2;
-	fsr = *(unsigned long *)rd;
-	fsr &= ~0xc00; fsr |= (ret << 10);
-	*(unsigned long *)rd = fsr;
-	return 0;
+	if (ret == 3)
+		FP_SET_EXCEPTION(FP_EX_INVALID);
+	if (!FP_INHIBIT_RESULTS) {
+		if (ret == -1) ret = 2;
+		fsr = *(long *)rd;
+		fsr &= ~0xc00;
+		fsr |= (ret << 10);
+		*(long *)rd = fsr;
+	}
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc/math-emu/fcmpes.c

+/* $Id: fcmpes.c,v 1.8 1999/05/28 13:41:45 jj Exp $
+ * arch/sparc/math-emu/fcmpes.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1998 Peter Maydell (pmaydell@chiark.greenend.org.uk)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "single.h"
 
 int FCMPES(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_S(A); FP_DECL_S(B);
 	long ret;
-	unsigned long *fsr = rd;
+	unsigned long fsr;
 	
-	__FP_UNPACK_S(A, rs1);
-	__FP_UNPACK_S(B, rs2);
-	FP_CMP_S(ret, B, A, 1);
-	if (ret == -1)
-		ret = 2;
-
-	*fsr = (*fsr & ~0xc00) | (ret << 10); 
-	return 0;
+	FP_UNPACK_RAW_SP(A, rs1);
+	FP_UNPACK_RAW_SP(B, rs2);
+	FP_CMP_S(ret, B, A, 3);
+	if (ret == 3)
+		FP_SET_EXCEPTION(FP_EX_INVALID);
+	if (!FP_INHIBIT_RESULTS) {
+		if (ret == -1) ret = 2;
+		fsr = *(long *)rd;
+		fsr &= ~0xc00;
+		fsr |= (ret << 10);
+		*(long *)rd = fsr;
+	}
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc/math-emu/fcmpq.c

+/* $Id: fcmpq.c,v 1.8 1999/05/28 13:41:48 jj Exp $
+ * arch/sparc/math-emu/fcmpq.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1998 Peter Maydell (pmaydell@chiark.greenend.org.uk)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 
 int FCMPQ(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_Q(A); FP_DECL_Q(B);
 	long ret;
 	unsigned long fsr;
 	
-	__FP_UNPACK_Q(A, rs1);
-	__FP_UNPACK_Q(B, rs2);
+	FP_UNPACK_RAW_QP(A, rs1);
+	FP_UNPACK_RAW_QP(B, rs2);
 	FP_CMP_Q(ret, B, A, 3);
-	if (ret == -1) ret = 2;
-	fsr = *(unsigned long *)rd;
-	fsr &= ~0xc00; fsr |= (ret << 10);
-	*(unsigned long *)rd = fsr;
-	return 0;
+	if (ret == 3 && (FP_ISSIGNAN_Q(A) || FP_ISSIGNAN_Q(B)))
+		FP_SET_EXCEPTION(FP_EX_INVALID);
+	if (!FP_INHIBIT_RESULTS) {
+		if (ret == -1) ret = 2;
+		fsr = *(long *)rd;
+		fsr &= ~0xc00;
+		fsr |= (ret << 10);
+		*(long *)rd = fsr;
+	}
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc/math-emu/fcmps.c

+/* $Id: fcmps.c,v 1.8 1999/05/28 13:41:51 jj Exp $
+ * arch/sparc/math-emu/fcmps.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1998 Peter Maydell (pmaydell@chiark.greenend.org.uk)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "single.h"
 
 int FCMPS(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_S(A); FP_DECL_S(B);
 	long ret;
-	unsigned long *fsr = rd;
+	unsigned long fsr;
 	
-	__FP_UNPACK_S(A, rs1);
-	__FP_UNPACK_S(B, rs2);
-	FP_CMP_S(ret, B, A, 1);
-	if (ret == -1)
-		ret = 2;
-
-	*fsr = (*fsr & ~0xc00) | (ret << 10); 
-	return 0;
+	FP_UNPACK_RAW_SP(A, rs1);
+	FP_UNPACK_RAW_SP(B, rs2);
+	FP_CMP_S(ret, B, A, 3);
+	if (ret == 3 && (FP_ISSIGNAN_S(A) || FP_ISSIGNAN_S(B)))
+		FP_SET_EXCEPTION(FP_EX_INVALID);
+	if (!FP_INHIBIT_RESULTS) {
+		if (ret == -1) ret = 2;
+		fsr = *(long *)rd;
+		fsr &= ~0xc00;
+		fsr |= (ret << 10);
+		*(long *)rd = fsr;
+	}
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc/math-emu/fdmulq.c

+/* $Id: fdmulq.c,v 1.9 1999/05/28 13:41:56 jj Exp $
+ * arch/sparc/math-emu/fdmulq.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1998 Peter Maydell (pmaydell@chiark.greenend.org.uk)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 #include "double.h"
 
 int FDMULQ(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_D(IN); FP_DECL_Q(A); FP_DECL_Q(B); FP_DECL_Q(R);
 
-	__FP_UNPACK_D(IN, rs1);
+	FP_UNPACK_DP(IN, rs1);
 	FP_CONV(Q,D,4,2,A,IN);
-	__FP_UNPACK_D(IN, rs2);
+	FP_UNPACK_DP(IN, rs2);
 	FP_CONV(Q,D,4,2,B,IN);
 	FP_MUL_Q(R, A, B);
-	return __FP_PACK_Q(rd, R);
+	FP_PACK_QP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc/math-emu/fdtoq.c

+/* $Id: fdtoq.c,v 1.9 1999/05/28 13:42:01 jj Exp $
+ * arch/sparc/math-emu/fdtoq.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1998 Peter Maydell (pmaydell@chiark.greenend.org.uk)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 #include "double.h"
 
 int FDTOQ(void *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_D(A); FP_DECL_Q(R);
 
-	__FP_UNPACK_D(A, rs2);
+	FP_UNPACK_DP(A, rs2);
 	FP_CONV(Q,D,4,2,R,A);
-	return __FP_PACK_Q(rd, R);
+	FP_PACK_QP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc/math-emu/fdtos.c

+/* $Id: fdtos.c,v 1.9 1999/05/28 13:42:03 jj Exp $
+ * arch/sparc/math-emu/fdtos.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1998 Peter Maydell (pmaydell@chiark.greenend.org.uk)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "double.h"
 #include "single.h"
 
 int FDTOS(void *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_D(A); FP_DECL_S(R);
 
-	__FP_UNPACK_D(A, rs2);
+	FP_UNPACK_DP(A, rs2);
 	FP_CONV(S,D,1,2,R,A);
-	return __FP_PACK_S(rd, R);
+	FP_PACK_SP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc/math-emu/fmovs.c

+/* $Id: fmovs.c,v 1.7 1999/05/28 13:42:05 jj Exp $
+ * arch/sparc/math-emu/fmovs.c
+ *
+ * Copyright (C) 1998 Peter Maydell (pmaydell@chiark.greenend.org.uk)
+ *
+ */
+
 int FMOVS(unsigned long *rd, unsigned long *rs2)
 {
 	rd[0] = rs2[0];

arch/sparc/math-emu/fnegs.c

+/* $Id: fnegs.c,v 1.9 1999/05/28 13:42:06 jj Exp $
+ * arch/sparc/math-emu/fnegs.c
+ *
+ * Copyright (C) 1998 Peter Maydell (pmaydell@chiark.greenend.org.uk)
+ *
+ */
+
 int FNEGS(unsigned long *rd, unsigned long *rs2)
 {
  	/* just change the sign bit */

arch/sparc/math-emu/fqtod.c

+/* $Id: fqtod.c,v 1.9 1999/05/28 13:42:08 jj Exp $
+ * arch/sparc/math-emu/fqtod.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1998 Peter Maydell (pmaydell@chiark.greenend.org.uk)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 #include "double.h"
 
 int FQTOD(void *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_Q(A); FP_DECL_D(R);
 
-	__FP_UNPACK_Q(A, rs2);
+	FP_UNPACK_QP(A, rs2);
 	FP_CONV(D,Q,2,4,R,A);
-	return __FP_PACK_D(rd, R);
+	FP_PACK_DP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc/math-emu/fqtos.c

+/* $Id: fqtos.c,v 1.9 1999/05/28 13:42:10 jj Exp $
+ * arch/sparc/math-emu/fqtos.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1998 Peter Maydell (pmaydell@chiark.greenend.org.uk)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 #include "single.h"
 
 int FQTOS(void *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_Q(A); FP_DECL_S(R);
 
-	__FP_UNPACK_Q(A, rs2);
+	FP_UNPACK_QP(A, rs2);
 	FP_CONV(S,Q,1,4,R,A);
-	return __FP_PACK_S(rd, R);
+	FP_PACK_SP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc/math-emu/fsmuld.c

+/* $Id: fsmuld.c,v 1.9 1999/05/28 13:42:12 jj Exp $
+ * arch/sparc/math-emu/fsmuld.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1998 Peter Maydell (pmaydell@chiark.greenend.org.uk)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "double.h"
 #include "single.h"
 
 int FSMULD(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_S(IN); FP_DECL_D(A); FP_DECL_D(B); FP_DECL_D(R);
 
-	__FP_UNPACK_S(IN, rs1);
+	FP_UNPACK_SP(IN, rs1);
 	FP_CONV(D,S,2,1,A,IN);
-	__FP_UNPACK_S(IN, rs2);
+	FP_UNPACK_SP(IN, rs2);
 	FP_CONV(D,S,2,1,B,IN);
 	FP_MUL_D(R, A, B);
-	return __FP_PACK_D(rd, R);
+	FP_PACK_DP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc/math-emu/fstod.c

+/* $Id: fstod.c,v 1.9 1999/05/28 13:42:14 jj Exp $
+ * arch/sparc/math-emu/fstod.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1998 Peter Maydell (pmaydell@chiark.greenend.org.uk)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "double.h"
 #include "single.h"
 
 int FSTOD(void *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_S(A); FP_DECL_D(R);
 
-	__FP_UNPACK_S(A, rs2);
+	FP_UNPACK_SP(A, rs2);
 	FP_CONV(D,S,2,1,R,A);
-	return __FP_PACK_D(rd, R);
+	FP_PACK_DP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc/math-emu/fstoq.c

+/* $Id: fstoq.c,v 1.9 1999/05/28 13:42:16 jj Exp $
+ * arch/sparc/math-emu/fstoq.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1998 Peter Maydell (pmaydell@chiark.greenend.org.uk)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 #include "single.h"
 
 int FSTOQ(void *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_S(A); FP_DECL_Q(R);
 
-	__FP_UNPACK_S(A, rs2);
+	FP_UNPACK_SP(A, rs2);
 	FP_CONV(Q,S,4,1,R,A);
-	return __FP_PACK_Q(rd, R);
+	FP_PACK_QP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc/math-emu/sfp-util.h

+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/types.h>
+#include <asm/byteorder.h>
+
+#define add_ssaaaa(sh, sl, ah, al, bh, bl) 				\
+  __asm__ ("addcc %r4,%5,%1
+	addx %r2,%3,%0"							\
+	   : "=r" ((USItype)(sh)),					\
+	     "=&r" ((USItype)(sl))					\
+	   : "%rJ" ((USItype)(ah)),					\
+	     "rI" ((USItype)(bh)),					\
+	     "%rJ" ((USItype)(al)),					\
+	     "rI" ((USItype)(bl))					\
+	   : "cc")
+#define sub_ddmmss(sh, sl, ah, al, bh, bl) 				\
+  __asm__ ("subcc %r4,%5,%1
+	subx %r2,%3,%0"							\
+	   : "=r" ((USItype)(sh)),					\
+	     "=&r" ((USItype)(sl))					\
+	   : "rJ" ((USItype)(ah)),					\
+	     "rI" ((USItype)(bh)),					\
+	     "rJ" ((USItype)(al)),					\
+	     "rI" ((USItype)(bl))					\
+	   : "cc")
+
+#define umul_ppmm(w1, w0, u, v) \
+  __asm__ ("! Inlined umul_ppmm
+	wr	%%g0,%2,%%y	! SPARC has 0-3 delay insn after a wr
+	sra	%3,31,%%g2	! Don't move this insn
+	and	%2,%%g2,%%g2	! Don't move this insn
+	andcc	%%g0,0,%%g1	! Don't move this insn
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,%3,%%g1
+	mulscc	%%g1,0,%%g1
+	add	%%g1,%%g2,%0
+	rd	%%y,%1"							\
+	   : "=r" ((USItype)(w1)),					\
+	     "=r" ((USItype)(w0))					\
+	   : "%rI" ((USItype)(u)),					\
+	     "r" ((USItype)(v))						\
+	   : "%g1", "%g2", "cc")
+
+/* It's quite necessary to add this much assembler for the sparc.
+   The default udiv_qrnnd (in C) is more than 10 times slower!  */
+#define udiv_qrnnd(q, r, n1, n0, d) \
+  __asm__ ("! Inlined udiv_qrnnd
+	mov	32,%%g1
+	subcc	%1,%2,%%g0
+1:	bcs	5f
+	 addxcc %0,%0,%0	! shift n1n0 and a q-bit in lsb
+	sub	%1,%2,%1	! this kills msb of n
+	addx	%1,%1,%1	! so this can't give carry
+	subcc	%%g1,1,%%g1
+2:	bne	1b
+	 subcc	%1,%2,%%g0
+	bcs	3f
+	 addxcc %0,%0,%0	! shift n1n0 and a q-bit in lsb
+	b	3f
+	 sub	%1,%2,%1	! this kills msb of n
+4:	sub	%1,%2,%1
+5:	addxcc	%1,%1,%1
+	bcc	2b
+	 subcc	%%g1,1,%%g1
+! Got carry from n.  Subtract next step to cancel this carry.
+	bne	4b
+	 addcc	%0,%0,%0	! shift n1n0 and a 0-bit in lsb
+	sub	%1,%2,%1
+3:	xnor	%0,0,%0
+	! End of inline udiv_qrnnd"					\
+	   : "=&r" ((USItype)(q)),					\
+	     "=&r" ((USItype)(r))					\
+	   : "r" ((USItype)(d)),					\
+	     "1" ((USItype)(n1)),					\
+	     "0" ((USItype)(n0)) : "%g1", "cc")
+#define UDIV_NEEDS_NORMALIZATION 0
+
+#define abort()								\
+	return 0
+
+#ifdef __BIG_ENDIAN
+#define __BYTE_ORDER __BIG_ENDIAN
+#else
+#define __BYTE_ORDER __LITTLE_ENDIAN
+#endif

arch/sparc64/defconfig

@@ -156,6 +156,10 @@ CONFIG_IPX=m
 # CONFIG_IPX_INTERN is not set
 # CONFIG_SPX is not set
 CONFIG_ATALK=m
+CONFIG_DECNET=m
+CONFIG_DECNET_SIOCGIFCONF=y
+# CONFIG_DECNET_ROUTER is not set
+CONFIG_DECNET_RAW=y
 # CONFIG_X25 is not set
 # CONFIG_LAPB is not set
 # CONFIG_BRIDGE is not set
@@ -310,6 +314,7 @@ CONFIG_BSD_DISKLABEL=y
 # CONFIG_MAC_PARTITION is not set
 CONFIG_SMD_DISKLABEL=y
 CONFIG_SOLARIS_X86_PARTITION=y
+# CONFIG_SGI_DISKLABEL is not set
 # CONFIG_UNIXWARE_DISKLABEL is not set
 CONFIG_AMIGA_PARTITION=y
 CONFIG_NLS=y

arch/sparc64/kernel/setup.c

-/*  $Id: setup.c,v 1.43 1999/04/12 08:08:24 davem Exp $
+/*  $Id: setup.c,v 1.44 1999/05/28 02:17:29 davem Exp $
  *  linux/arch/sparc64/kernel/setup.c
  *
  *  Copyright (C) 1995,1996  David S. Miller (davem@caip.rutgers.edu)
@@ -550,7 +550,9 @@ __initfunc(void setup_arch(char **cmdline_p,
 			ic_servaddr = sv;
 			if (gw)
 				ic_gateway = gw;
+#if defined(CONFIG_IP_PNP_BOOTP) || defined(CONFIG_IP_PNP_RARP)
 			ic_proto_enabled = 0;
+#endif
 		}
 	}
 #endif

arch/sparc64/math-emu/Makefile

@@ -11,7 +11,7 @@ O_TARGET := math-emu.o
 O_OBJS   := math.o fabsq.o faddq.o fdivq.o fdmulq.o fitoq.o 		\
 		fmovq.o fmulq.o fnegq.o fqtoi.o fqtox.o fsubq.o		\
 		fxtoq.o fdtoq.o fstoq.o fqtos.o fqtod.o fsqrtq.o	\
-		fcmpq.o fcmpeq.o udivmodti4.o				\
+		fcmpq.o fcmpeq.o					\
 		fsqrts.o fsqrtd.o fadds.o faddd.o fsubs.o fsubd.o	\
 		fmuls.o fmuld.o fdivs.o fdivd.o fsmuld.o		\
 		fstoi.o fdtoi.o fstox.o fdtox.o fstod.o fdtos.o

arch/sparc64/math-emu/double.h

-/*
- * Definitions for IEEE Double Precision
- */
+/* Software floating-point emulation.
+   Definitions for IEEE Double Precision
+   Copyright (C) 1997,1998,1999 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Richard Henderson (rth@cygnus.com),
+		  Jakub Jelinek (jj@ultra.linux.cz),
+		  David S. Miller (davem@redhat.com) and
+		  Peter Maydell (pmaydell@chiark.greenend.org.uk).
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If
+   not, write to the Free Software Foundation, Inc.,
+   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #if _FP_W_TYPE_SIZE < 32
 #error "Here's a nickel kid.  Go buy yourself a real computer."
@@ -49,7 +69,13 @@ union _FP_UNION_D
 
 #define FP_DECL_D(X)		_FP_DECL(2,X)
 #define FP_UNPACK_RAW_D(X,val)	_FP_UNPACK_RAW_2(D,X,val)
+#define FP_UNPACK_RAW_DP(X,val)	_FP_UNPACK_RAW_2_P(D,X,val)
 #define FP_PACK_RAW_D(val,X)	_FP_PACK_RAW_2(D,val,X)
+#define FP_PACK_RAW_DP(val,X)		\
+  do {					\
+    if (!FP_INHIBIT_RESULTS)		\
+      _FP_PACK_RAW_2_P(D,val,X);	\
+  } while (0)
 
 #define FP_UNPACK_D(X,val)		\
   do {					\
@@ -57,24 +83,42 @@ union _FP_UNION_D
     _FP_UNPACK_CANONICAL(D,2,X);	\
   } while (0)
 
+#define FP_UNPACK_DP(X,val)		\
+  do {					\
+    _FP_UNPACK_RAW_2_P(D,X,val);	\
+    _FP_UNPACK_CANONICAL(D,2,X);	\
+  } while (0)
+
 #define FP_PACK_D(val,X)		\
   do {					\
     _FP_PACK_CANONICAL(D,2,X);		\
     _FP_PACK_RAW_2(D,val,X);		\
   } while (0)
 
-#define FP_NEG_D(R,X)		_FP_NEG(D,2,R,X)
-#define FP_ADD_D(R,X,Y)		_FP_ADD(D,2,R,X,Y)
-#define FP_SUB_D(R,X,Y)		_FP_SUB(D,2,R,X,Y)
-#define FP_MUL_D(R,X,Y)		_FP_MUL(D,2,R,X,Y)
-#define FP_DIV_D(R,X,Y)		_FP_DIV(D,2,R,X,Y)
-#define FP_SQRT_D(R,X)		_FP_SQRT(D,2,R,X)
+#define FP_PACK_DP(val,X)		\
+  do {					\
+    _FP_PACK_CANONICAL(D,2,X);		\
+    if (!FP_INHIBIT_RESULTS)		\
+      _FP_PACK_RAW_2_P(D,val,X);	\
+  } while (0)
+
+#define FP_ISSIGNAN_D(X)		_FP_ISSIGNAN(D,2,X)
+#define FP_NEG_D(R,X)			_FP_NEG(D,2,R,X)
+#define FP_ADD_D(R,X,Y)			_FP_ADD(D,2,R,X,Y)
+#define FP_SUB_D(R,X,Y)			_FP_SUB(D,2,R,X,Y)
+#define FP_MUL_D(R,X,Y)			_FP_MUL(D,2,R,X,Y)
+#define FP_DIV_D(R,X,Y)			_FP_DIV(D,2,R,X,Y)
+#define FP_SQRT_D(R,X)			_FP_SQRT(D,2,R,X)
+#define _FP_SQRT_MEAT_D(R,S,T,X,Q)	_FP_SQRT_MEAT_2(R,S,T,X,Q)
 
 #define FP_CMP_D(r,X,Y,un)	_FP_CMP(D,2,r,X,Y,un)
 #define FP_CMP_EQ_D(r,X,Y)	_FP_CMP_EQ(D,2,r,X,Y)
 
-#define FP_TO_INT_D(r,X,rsz,rsg)  _FP_TO_INT(D,2,r,X,rsz,rsg)
-#define FP_FROM_INT_D(X,r,rs,rt)  _FP_FROM_INT(D,2,X,r,rs,rt)
+#define FP_TO_INT_D(r,X,rsz,rsg)	_FP_TO_INT(D,2,r,X,rsz,rsg)
+#define FP_FROM_INT_D(X,r,rs,rt)	_FP_FROM_INT(D,2,X,r,rs,rt)
+
+#define _FP_FRAC_HIGH_D(X)	_FP_FRAC_HIGH_2(X)
+#define _FP_FRAC_HIGH_RAW_D(X)	_FP_FRAC_HIGH_2(X)
 
 #else
 
@@ -96,7 +140,13 @@ union _FP_UNION_D
 
 #define FP_DECL_D(X)		_FP_DECL(1,X)
 #define FP_UNPACK_RAW_D(X,val)	_FP_UNPACK_RAW_1(D,X,val)
+#define FP_UNPACK_RAW_DP(X,val)	_FP_UNPACK_RAW_1_P(D,X,val)
 #define FP_PACK_RAW_D(val,X)	_FP_PACK_RAW_1(D,val,X)
+#define FP_PACK_RAW_DP(val,X)		\
+  do {					\
+    if (!FP_INHIBIT_RESULTS)		\
+      _FP_PACK_RAW_1_P(D,val,X);	\
+  } while (0)
 
 #define FP_UNPACK_D(X,val)		\
   do {					\
@@ -104,18 +154,33 @@ union _FP_UNION_D
     _FP_UNPACK_CANONICAL(D,1,X);	\
   } while (0)
 
+#define FP_UNPACK_DP(X,val)		\
+  do {					\
+    _FP_UNPACK_RAW_1_P(D,X,val);	\
+    _FP_UNPACK_CANONICAL(D,1,X);	\
+  } while (0)
+
 #define FP_PACK_D(val,X)		\
   do {					\
     _FP_PACK_CANONICAL(D,1,X);		\
     _FP_PACK_RAW_1(D,val,X);		\
   } while (0)
 
-#define FP_NEG_D(R,X)		_FP_NEG(D,1,R,X)
-#define FP_ADD_D(R,X,Y)		_FP_ADD(D,1,R,X,Y)
-#define FP_SUB_D(R,X,Y)		_FP_SUB(D,1,R,X,Y)
-#define FP_MUL_D(R,X,Y)		_FP_MUL(D,1,R,X,Y)
-#define FP_DIV_D(R,X,Y)		_FP_DIV(D,1,R,X,Y)
-#define FP_SQRT_D(R,X)		_FP_SQRT(D,1,R,X)
+#define FP_PACK_DP(val,X)		\
+  do {					\
+    _FP_PACK_CANONICAL(D,1,X);		\
+    if (!FP_INHIBIT_RESULTS)		\
+      _FP_PACK_RAW_1_P(D,val,X);	\
+  } while (0)
+
+#define FP_ISSIGNAN_D(X)		_FP_ISSIGNAN(D,1,X)
+#define FP_NEG_D(R,X)			_FP_NEG(D,1,R,X)
+#define FP_ADD_D(R,X,Y)			_FP_ADD(D,1,R,X,Y)
+#define FP_SUB_D(R,X,Y)			_FP_SUB(D,1,R,X,Y)
+#define FP_MUL_D(R,X,Y)			_FP_MUL(D,1,R,X,Y)
+#define FP_DIV_D(R,X,Y)			_FP_DIV(D,1,R,X,Y)
+#define FP_SQRT_D(R,X)			_FP_SQRT(D,1,R,X)
+#define _FP_SQRT_MEAT_D(R,S,T,X,Q)	_FP_SQRT_MEAT_1(R,S,T,X,Q)
 
 /* The implementation of _FP_MUL_D and _FP_DIV_D should be chosen by
    the target machine.  */
@@ -123,7 +188,10 @@ union _FP_UNION_D
 #define FP_CMP_D(r,X,Y,un)	_FP_CMP(D,1,r,X,Y,un)
 #define FP_CMP_EQ_D(r,X,Y)	_FP_CMP_EQ(D,1,r,X,Y)
 
-#define FP_TO_INT_D(r,X,rsz,rsg)  _FP_TO_INT(D,1,r,X,rsz,rsg)
-#define FP_FROM_INT_D(X,r,rs,rt)  _FP_FROM_INT(D,1,X,r,rs,rt)
+#define FP_TO_INT_D(r,X,rsz,rsg)	_FP_TO_INT(D,1,r,X,rsz,rsg)
+#define FP_FROM_INT_D(X,r,rs,rt)	_FP_FROM_INT(D,1,X,r,rs,rt)
+
+#define _FP_FRAC_HIGH_D(X)	_FP_FRAC_HIGH_1(X)
+#define _FP_FRAC_HIGH_RAW_D(X)	_FP_FRAC_HIGH_1(X)
 
 #endif /* W_TYPE_SIZE < 64 */

arch/sparc64/math-emu/fabsq.c

+/* $Id: fabsq.c,v 1.5 1999/05/28 13:42:27 jj Exp $
+ * arch/sparc64/math-emu/fabsq.c
+ *
+ * Copyright (C) 1997 Jakub Jelinek (jj@ultra.linux.cz)
+ *
+ */
+
 int FABSQ(unsigned long *rd, unsigned long *rs2)
 {
 	rd[0] = rs2[0] & 0x7fffffffffffffffUL;

arch/sparc64/math-emu/faddd.c

+/* $Id: faddd.c,v 1.4 1999/05/28 13:43:17 jj Exp $
+ * arch/sparc64/math-emu/faddd.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "double.h"
 
 int FADDD(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_D(A); FP_DECL_D(B); FP_DECL_D(R);
 
-	__FP_UNPACK_D(A, rs1);
-	__FP_UNPACK_D(B, rs2);
+	FP_UNPACK_DP(A, rs1);
+	FP_UNPACK_DP(B, rs2);
 	FP_ADD_D(R, A, B);
-	return __FP_PACK_D(rd, R);
+	FP_PACK_DP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/faddq.c

+/* $Id: faddq.c,v 1.4 1999/05/28 13:43:19 jj Exp $
+ * arch/sparc64/math-emu/faddq.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 
 int FADDQ(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_Q(A); FP_DECL_Q(B); FP_DECL_Q(R);
 
-	__FP_UNPACK_Q(A, rs1);
-	__FP_UNPACK_Q(B, rs2);
+	FP_UNPACK_QP(A, rs1);
+	FP_UNPACK_QP(B, rs2);
 	FP_ADD_Q(R, A, B);
-	return __FP_PACK_Q(rd, R);
+	FP_PACK_QP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fadds.c

+/* $Id: fadds.c,v 1.4 1999/05/28 13:43:25 jj Exp $
+ * arch/sparc64/math-emu/fadds.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "single.h"
 
 int FADDS(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_S(A); FP_DECL_S(B); FP_DECL_S(R);
 
-	__FP_UNPACK_S(A, rs1);
-	__FP_UNPACK_S(B, rs2);
+	FP_UNPACK_SP(A, rs1);
+	FP_UNPACK_SP(B, rs2);
 	FP_ADD_S(R, A, B);
-	return __FP_PACK_S(rd, R);
+	FP_PACK_SP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fcmpeq.c

+/* $Id: fcmpeq.c,v 1.5 1999/05/28 13:43:29 jj Exp $
+ * arch/sparc64/math-emu/fcmpeq.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 
 int FCMPEQ(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_Q(A); FP_DECL_Q(B);
 	long ret;
-	int fccno = ((long)rd) & 3;
+	long fccno = (long)rd;
 	unsigned long fsr;
 	
-	rd = (void *)(((long)rd)&~3);
-	__FP_UNPACK_Q(A, rs1);
-	__FP_UNPACK_Q(B, rs2);
+	FP_UNPACK_RAW_QP(A, rs1);
+	FP_UNPACK_RAW_QP(B, rs2);
 	FP_CMP_Q(ret, B, A, 3);
-	if (ret == -1) ret = 2;
-	fsr = *(unsigned long *)rd;
-	switch (fccno) {
-	case 0: fsr &= ~0xc00; fsr |= (ret << 10); break;
-	case 1: fsr &= ~0x300000000UL; fsr |= (ret << 32); break;
-	case 2: fsr &= ~0xc00000000UL; fsr |= (ret << 34); break;
-	case 3: fsr &= ~0x3000000000UL; fsr |= (ret << 36); break;
+	if (ret == 3)
+		FP_SET_EXCEPTION(FP_EX_INVALID);
+	if (!FP_INHIBIT_RESULTS) {
+		rd = (void *)(((long)rd)&~3);
+		if (ret == -1) ret = 2;
+		fsr = current->tss.xfsr[0];
+		switch (fccno) {
+		case 0: fsr &= ~0xc00; fsr |= (ret << 10); break;
+		case 1: fsr &= ~0x300000000UL; fsr |= (ret << 32); break;
+		case 2: fsr &= ~0xc00000000UL; fsr |= (ret << 34); break;
+		case 3: fsr &= ~0x3000000000UL; fsr |= (ret << 36); break;
+		}
+		current->tss.xfsr[0] = fsr;
 	}
-	*(unsigned long *)rd = fsr;
-	return 0;
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fcmpq.c

+/* $Id: fcmpq.c,v 1.5 1999/05/28 13:43:33 jj Exp $
+ * arch/sparc64/math-emu/fcmpq.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 
 int FCMPQ(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_Q(A); FP_DECL_Q(B);
 	long ret;
-	int fccno = ((long)rd) & 3;
+	long fccno = (long)rd;
 	unsigned long fsr;
 	
-	rd = (void *)(((long)rd)&~3);
-	__FP_UNPACK_Q(A, rs1);
-	__FP_UNPACK_Q(B, rs2);
+	FP_UNPACK_RAW_QP(A, rs1);
+	FP_UNPACK_RAW_QP(B, rs2);
 	FP_CMP_Q(ret, B, A, 3);
-	if (ret == -1) ret = 2;
-	fsr = *(unsigned long *)rd;
-	switch (fccno) {
-	case 0: fsr &= ~0xc00; fsr |= (ret << 10); break;
-	case 1: fsr &= ~0x300000000UL; fsr |= (ret << 32); break;
-	case 2: fsr &= ~0xc00000000UL; fsr |= (ret << 34); break;
-	case 3: fsr &= ~0x3000000000UL; fsr |= (ret << 36); break;
+	if (ret == 3 && (FP_ISSIGNAN_Q(A) || FP_ISSIGNAN_Q(B)))
+		FP_SET_EXCEPTION(FP_EX_INVALID);
+	if (!FP_INHIBIT_RESULTS) {
+		rd = (void *)(((long)rd)&~3);
+		if (ret == -1) ret = 2;
+		fsr = current->tss.xfsr[0];
+		switch (fccno) {
+		case 0: fsr &= ~0xc00; fsr |= (ret << 10); break;
+		case 1: fsr &= ~0x300000000UL; fsr |= (ret << 32); break;
+		case 2: fsr &= ~0xc00000000UL; fsr |= (ret << 34); break;
+		case 3: fsr &= ~0x3000000000UL; fsr |= (ret << 36); break;
+		}
+		current->tss.xfsr[0] = fsr;
 	}
-	*(unsigned long *)rd = fsr;
-	return 0;
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fdivd.c

+/* $Id: fdivd.c,v 1.4 1999/05/28 13:43:36 jj Exp $
+ * arch/sparc64/math-emu/fdivd.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "double.h"
 
 int FDIVD(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_D(A); FP_DECL_D(B); FP_DECL_D(R);
-	int ret = 0;
 
-	__FP_UNPACK_D(A, rs1);
-	__FP_UNPACK_D(B, rs2);
-	if(B_c == FP_CLS_ZERO &&
-	   A_c != FP_CLS_ZERO) {
-		ret |= EFLAG_DIVZERO;
-		if(__FPU_TRAP_P(EFLAG_DIVZERO))
-			return ret;
-	}
+	FP_UNPACK_DP(A, rs1);
+	FP_UNPACK_DP(B, rs2);
 	FP_DIV_D(R, A, B);
-	return (ret | __FP_PACK_D(rd, R));
+	FP_PACK_DP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fdivq.c

+/* $Id: fdivq.c,v 1.4 1999/05/28 13:43:41 jj Exp $
+ * arch/sparc64/math-emu/fdivq.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 
 int FDIVQ(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_Q(A); FP_DECL_Q(B); FP_DECL_Q(R);
-	int ret;
 
-	__FP_UNPACK_Q(A, rs1);
-	__FP_UNPACK_Q(B, rs2);
-	if(B_c == FP_CLS_ZERO &&
-	   A_c != FP_CLS_ZERO) {
-		ret |= EFLAG_DIVZERO;
-		if(__FPU_TRAP_P(EFLAG_DIVZERO))
-			return ret;
-	}
+	FP_UNPACK_QP(A, rs1);
+	FP_UNPACK_QP(B, rs2);
 	FP_DIV_Q(R, A, B);
-	return (ret | __FP_PACK_Q(rd, R));
+	FP_PACK_QP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fdivs.c

+/* $Id: fdivs.c,v 1.4 1999/05/28 13:43:45 jj Exp $
+ * arch/sparc64/math-emu/fdivs.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "single.h"
 
 int FDIVS(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_S(A); FP_DECL_S(B); FP_DECL_S(R);
-	int ret = 0;
 
-	__FP_UNPACK_S(A, rs1);
-	__FP_UNPACK_S(B, rs2);
-	if(B_c == FP_CLS_ZERO &&
-	   A_c != FP_CLS_ZERO) {
-		ret |= EFLAG_DIVZERO;
-		if(__FPU_TRAP_P(EFLAG_DIVZERO))
-			return ret;
-	}
+	FP_UNPACK_SP(A, rs1);
+	FP_UNPACK_SP(B, rs2);
 	FP_DIV_S(R, A, B);
-	return (ret | __FP_PACK_S(rd, R));
+	FP_PACK_SP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }
 

arch/sparc64/math-emu/fdmulq.c

+/* $Id: fdmulq.c,v 1.4 1999/05/28 13:43:48 jj Exp $
+ * arch/sparc64/math-emu/fdmulq.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 #include "double.h"
 
 int FDMULQ(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_D(IN); FP_DECL_Q(A); FP_DECL_Q(B); FP_DECL_Q(R);
 
-	__FP_UNPACK_D(IN, rs1);
+	FP_UNPACK_DP(IN, rs1);
 	FP_CONV(Q,D,2,1,A,IN);
-	__FP_UNPACK_D(IN, rs2);
+	FP_UNPACK_DP(IN, rs2);
 	FP_CONV(Q,D,2,1,B,IN);
 	FP_MUL_Q(R, A, B);
-	return __FP_PACK_Q(rd, R);
+	FP_PACK_QP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fdtoi.c

+/* $Id: fdtoi.c,v 1.3 1999/05/28 13:43:52 jj Exp $
+ * arch/sparc64/math-emu/fdtoi.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#define FP_ROUNDMODE FP_RND_ZERO
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "double.h"
 
-int FDTOI(unsigned *rd, void *rs2)
+int FDTOI(int *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_D(A);
-	unsigned r;
+	int r;
 
-	__FP_UNPACK_D(A, rs2);
+	FP_UNPACK_DP(A, rs2);
 	FP_TO_INT_D(r, A, 32, 1);
-	*rd = r;
-	return 0;
+	if (!FP_INHIBIT_RESULTS)
+		*rd = r;
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fdtoq.c

+/* $Id: fdtoq.c,v 1.4 1999/05/28 13:43:56 jj Exp $
+ * arch/sparc64/math-emu/fdtoq.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 #include "double.h"
 
 int FDTOQ(void *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_D(A); FP_DECL_Q(R);
 
-	__FP_UNPACK_D(A, rs2);
+	FP_UNPACK_DP(A, rs2);
 	FP_CONV(Q,D,2,1,R,A);
-	return __FP_PACK_Q(rd, R);
+	FP_PACK_QP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fdtos.c

+/* $Id: fdtos.c,v 1.4 1999/05/28 13:43:58 jj Exp $
+ * arch/sparc64/math-emu/fdtos.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "double.h"
 #include "single.h"
 
 int FDTOS(void *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_D(A); FP_DECL_S(R);
 
-	__FP_UNPACK_D(A, rs2);
+	FP_UNPACK_DP(A, rs2);
 	FP_CONV(S,D,1,1,R,A);
-	return __FP_PACK_S(rd, R);
+	FP_PACK_SP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fdtox.c

+/* $Id: fdtox.c,v 1.3 1999/05/28 13:44:02 jj Exp $
+ * arch/sparc64/math-emu/fdtox.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#define FP_ROUNDMODE FP_RND_ZERO
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "double.h"
 
-int FDTOX(unsigned long *rd, void *rs2)
+int FDTOX(long *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_D(A);
-	unsigned long r;
+	long r;
 
-	__FP_UNPACK_D(A, rs2);
+	FP_UNPACK_DP(A, rs2);
 	FP_TO_INT_D(r, A, 64, 1);
-	*rd = r;
-	return 0;
+	if (!FP_INHIBIT_RESULTS)
+		*rd = r;
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fitoq.c

+/* $Id: fitoq.c,v 1.5 1999/05/28 13:44:06 jj Exp $
+ * arch/sparc64/math-emu/fitoq.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 
 int FITOQ(void *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_Q(R);
 	int a = *(int *)rs2;
 
 	FP_FROM_INT_Q(R, a, 32, int);
-	return __FP_PACK_Q(rd, R);
+	FP_PACK_QP(rd, R);
+	return 0;
 }

arch/sparc64/math-emu/fmovq.c

+/* $Id: fmovq.c,v 1.2 1999/05/28 13:44:09 jj Exp $
+ * arch/sparc64/math-emu/fmovq.c
+ *
+ * Copyright (C) 1997 Jakub Jelinek (jj@ultra.linux.cz)
+ *
+ */
+
 int FMOVQ(unsigned long *rd, unsigned long *rs2)
 {
 	rd[0] = rs2[0];

arch/sparc64/math-emu/fmuld.c

+/* $Id: fmuld.c,v 1.4 1999/05/28 13:44:11 jj Exp $
+ * arch/sparc64/math-emu/fmuld.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "double.h"
 
 int FMULD(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_D(A); FP_DECL_D(B); FP_DECL_D(R);
 
-	__FP_UNPACK_D(A, rs1);
-	__FP_UNPACK_D(B, rs2);
+	FP_UNPACK_DP(A, rs1);
+	FP_UNPACK_DP(B, rs2);
 	FP_MUL_D(R, A, B);
-	return __FP_PACK_D(rd, R);
+	FP_PACK_DP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fmulq.c

+/* $Id: fmulq.c,v 1.4 1999/05/28 13:44:14 jj Exp $
+ * arch/sparc64/math-emu/fmulq.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 
 int FMULQ(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_Q(A); FP_DECL_Q(B); FP_DECL_Q(R);
 
-	__FP_UNPACK_Q(A, rs1);
-	__FP_UNPACK_Q(B, rs2);
+	FP_UNPACK_QP(A, rs1);
+	FP_UNPACK_QP(B, rs2);
 	FP_MUL_Q(R, A, B);
-	return __FP_PACK_Q(rd, R);
+	FP_PACK_QP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fmuls.c

+/* $Id: fmuls.c,v 1.4 1999/05/28 13:44:18 jj Exp $
+ * arch/sparc64/math-emu/fmuls.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "single.h"
 
 int FMULS(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_S(A); FP_DECL_S(B); FP_DECL_S(R);
 
-	__FP_UNPACK_S(A, rs1);
-	__FP_UNPACK_S(B, rs2);
+	FP_UNPACK_SP(A, rs1);
+	FP_UNPACK_SP(B, rs2);
 	FP_MUL_S(R, A, B);
-	return __FP_PACK_S(rd, R);
+	FP_PACK_SP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fnegq.c

+/* $Id: fnegq.c,v 1.6 1999/05/28 13:44:21 jj Exp $
+ * arch/sparc64/math-emu/fnegq.c
+ *
+ * Copyright (C) 1997 Jakub Jelinek (jj@ultra.linux.cz)
+ *
+ */
+
 int FNEGQ(unsigned long *rd, unsigned long *rs2)
 {
 	rd[0] = rs2[0] ^ 0x8000000000000000UL;
 	rd[1] = rs2[1];
 	return 0;
 }
-

arch/sparc64/math-emu/fqtod.c

+/* $Id: fqtod.c,v 1.4 1999/05/28 13:44:24 jj Exp $
+ * arch/sparc64/math-emu/fqtod.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 #include "double.h"
 
 int FQTOD(void *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_Q(A); FP_DECL_D(R);
 
-	__FP_UNPACK_Q(A, rs2);
+	FP_UNPACK_QP(A, rs2);
 	FP_CONV(D,Q,1,2,R,A);
-	return __FP_PACK_D(rd, R);
+	FP_PACK_DP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fqtoi.c

+/* $Id: fqtoi.c,v 1.4 1999/05/28 13:44:26 jj Exp $
+ * arch/sparc64/math-emu/fqtoi.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#define FP_ROUNDMODE FP_RND_ZERO
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 
-int FQTOI(unsigned *rd, void *rs2)
+int FQTOI(int *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_Q(A);
-	unsigned r;
+	int r;
 
-	__FP_UNPACK_Q(A, rs2);
+	FP_UNPACK_QP(A, rs2);
 	FP_TO_INT_Q(r, A, 32, 1);
-	*rd = r;
-	return 0;
+	if (!FP_INHIBIT_RESULTS)
+		*rd = r;
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fqtos.c

+/* $Id: fqtos.c,v 1.4 1999/05/28 13:44:30 jj Exp $
+ * arch/sparc64/math-emu/fqtos.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 #include "single.h"
 
 int FQTOS(void *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_Q(A); FP_DECL_S(R);
 
-	__FP_UNPACK_Q(A, rs2);
+	FP_UNPACK_QP(A, rs2);
 	FP_CONV(S,Q,1,2,R,A);
-	return __FP_PACK_S(rd, R);
+	FP_PACK_SP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fqtox.c

+/* $Id: fqtox.c,v 1.4 1999/05/28 13:44:34 jj Exp $
+ * arch/sparc64/math-emu/fqtox.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#define FP_ROUNDMODE FP_RND_ZERO
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 
-int FQTOX(unsigned long *rd, void *rs2)
+int FQTOX(long *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_Q(A);
-	unsigned long r;
+	long r;
 
-	__FP_UNPACK_Q(A, rs2);
+	FP_UNPACK_QP(A, rs2);
 	FP_TO_INT_Q(r, A, 64, 1);
-	*rd = r;
-	return 0;
+	if (!FP_INHIBIT_RESULTS)
+		*rd = r;
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fsmuld.c

+/* $Id: fsmuld.c,v 1.4 1999/05/28 13:44:37 jj Exp $
+ * arch/sparc64/math-emu/fsmuld.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "double.h"
 #include "single.h"
 
 int FSMULD(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_S(IN); FP_DECL_D(A); FP_DECL_D(B); FP_DECL_D(R);
 
-	__FP_UNPACK_S(IN, rs1);
+	FP_UNPACK_SP(IN, rs1);
 	FP_CONV(D,S,1,1,A,IN);
-	__FP_UNPACK_S(IN, rs2);
+	FP_UNPACK_SP(IN, rs2);
 	FP_CONV(D,S,1,1,B,IN);
 	FP_MUL_D(R, A, B);
-	return __FP_PACK_D(rd, R);
+	FP_PACK_DP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fsqrtd.c

+/* $Id: fsqrtd.c,v 1.4 1999/05/28 13:44:39 jj Exp $
+ * arch/sparc64/math-emu/fsqrtd.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "double.h"
 
 int FSQRTD(void *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_D(A); FP_DECL_D(R);
         
-	__FP_UNPACK_D(A, rs2);
+	FP_UNPACK_DP(A, rs2);
 	FP_SQRT_D(R, A);
-	return __FP_PACK_D(rd, R);
+	FP_PACK_DP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fsqrtq.c

+/* $Id: fsqrtq.c,v 1.5 1999/05/28 13:44:44 jj Exp $
+ * arch/sparc64/math-emu/fsqrtq.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 
 int FSQRTQ(void *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_Q(A); FP_DECL_Q(R);
         
-	__FP_UNPACK_Q(A, rs2);
+	FP_UNPACK_QP(A, rs2);
 	FP_SQRT_Q(R, A);
-	return __FP_PACK_Q(rd, R);
+	FP_PACK_QP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fsqrts.c

+/* $Id: fsqrts.c,v 1.4 1999/05/28 13:44:48 jj Exp $
+ * arch/sparc64/math-emu/fsqrts.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "single.h"
 
 int FSQRTS(void *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_S(A); FP_DECL_S(R);
         
-	__FP_UNPACK_S(A, rs2);
+	FP_UNPACK_SP(A, rs2);
 	FP_SQRT_S(R, A);
-	return __FP_PACK_S(rd, R);
+	FP_PACK_SP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fstod.c

+/* $Id: fstod.c,v 1.4 1999/05/28 13:44:51 jj Exp $
+ * arch/sparc64/math-emu/fstod.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "double.h"
 #include "single.h"
 
 int FSTOD(void *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_S(A); FP_DECL_D(R);
 
-	__FP_UNPACK_S(A, rs2);
+	FP_UNPACK_SP(A, rs2);
 	FP_CONV(D,S,1,1,R,A);
-	return __FP_PACK_D(rd, R);
+	FP_PACK_DP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fstoi.c

+/* $Id: fstoi.c,v 1.3 1999/05/28 13:44:54 jj Exp $
+ * arch/sparc64/math-emu/fstoi.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#define FP_ROUNDMODE FP_RND_ZERO
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "single.h"
 
-int FSTOI(unsigned *rd, void *rs2)
+int FSTOI(int *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_S(A);
-	unsigned r;
+	int r;
 
-	__FP_UNPACK_S(A, rs2);
+	FP_UNPACK_SP(A, rs2);
 	FP_TO_INT_S(r, A, 32, 1);
-	*rd = r;
-	return 0;
+	if (!FP_INHIBIT_RESULTS)
+		*rd = r;
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fstoq.c

+/* $Id: fstoq.c,v 1.4 1999/05/28 13:44:58 jj Exp $
+ * arch/sparc64/math-emu/fstoq.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 #include "single.h"
 
 int FSTOQ(void *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_S(A); FP_DECL_Q(R);
 
-	__FP_UNPACK_S(A, rs2);
+	FP_UNPACK_SP(A, rs2);
 	FP_CONV(Q,S,2,1,R,A);
-	return __FP_PACK_Q(rd, R);
+	FP_PACK_QP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fstox.c

+/* $Id: fstox.c,v 1.3 1999/05/28 13:45:01 jj Exp $
+ * arch/sparc64/math-emu/fstox.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#define FP_ROUNDMODE FP_RND_ZERO
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "single.h"
 
-int FSTOX(unsigned long *rd, void *rs2)
+int FSTOX(long *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_S(A);
-	unsigned long r;
+	long r;
 
-	__FP_UNPACK_S(A, rs2);
+	FP_UNPACK_SP(A, rs2);
 	FP_TO_INT_S(r, A, 64, 1);
-	*rd = r;
-	return 0;
+	if (!FP_INHIBIT_RESULTS)
+		*rd = r;
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fsubd.c

+/* $Id: fsubd.c,v 1.4 1999/05/28 13:45:04 jj Exp $
+ * arch/sparc64/math-emu/fsubd.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "double.h"
 
 int FSUBD(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_D(A); FP_DECL_D(B); FP_DECL_D(R);
 
-	__FP_UNPACK_D(A, rs1);
-	__FP_UNPACK_D(B, rs2);
+	FP_UNPACK_DP(A, rs1);
+	FP_UNPACK_DP(B, rs2);
 	if (B_c != FP_CLS_NAN)
 		B_s ^= 1;
 	FP_ADD_D(R, A, B);
-	return __FP_PACK_D(rd, R);
+	FP_PACK_DP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fsubq.c

+/* $Id: fsubq.c,v 1.4 1999/05/28 13:45:09 jj Exp $
+ * arch/sparc64/math-emu/fsubq.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 
 int FSUBQ(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_Q(A); FP_DECL_Q(B); FP_DECL_Q(R);
 
-	__FP_UNPACK_Q(A, rs1);
-	__FP_UNPACK_Q(B, rs2);
+	FP_UNPACK_QP(A, rs1);
+	FP_UNPACK_QP(B, rs2);
 	if (B_c != FP_CLS_NAN)
 		B_s ^= 1;
 	FP_ADD_Q(R, A, B);
-	return __FP_PACK_Q(rd, R);
+	FP_PACK_QP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fsubs.c

+/* $Id: fsubs.c,v 1.4 1999/05/28 13:45:12 jj Exp $
+ * arch/sparc64/math-emu/fsubs.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "single.h"
 
 int FSUBS(void *rd, void *rs2, void *rs1)
 {
+	FP_DECL_EX;
 	FP_DECL_S(A); FP_DECL_S(B); FP_DECL_S(R);
 
-	__FP_UNPACK_S(A, rs1);
-	__FP_UNPACK_S(B, rs2);
+	FP_UNPACK_SP(A, rs1);
+	FP_UNPACK_SP(B, rs2);
 	if (B_c != FP_CLS_NAN)
 		B_s ^= 1;
 	FP_ADD_S(R, A, B);
-	return __FP_PACK_S(rd, R);
+	FP_PACK_SP(rd, R);
+	FP_HANDLE_EXCEPTIONS;
 }

arch/sparc64/math-emu/fxtoq.c

+/* $Id: fxtoq.c,v 1.5 1999/05/28 13:45:15 jj Exp $
+ * arch/sparc64/math-emu/fxtoq.c
+ *
+ * Copyright (C) 1997, 1999 Jakub Jelinek (jj@ultra.linux.cz)
+ * Copyright (C) 1999 David S. Miller (davem@redhat.com)
+ *
+ */
+
+#include "sfp-util.h"
 #include "soft-fp.h"
 #include "quad.h"
 
 int FXTOQ(void *rd, void *rs2)
 {
+	FP_DECL_EX;
 	FP_DECL_Q(R);
 	long a = *(long *)rs2;
 
 	FP_FROM_INT_Q(R, a, 64, long);
-	return __FP_PACK_Q(rd, R);
+	FP_PACK_QP(rd, R);
+	return 0;
 }

arch/sparc64/math-emu/math.c

-/* $Id: math.c,v 1.7 1999/02/10 14:16:26 davem Exp $
+/* $Id: math.c,v 1.8 1999/05/28 13:43:11 jj Exp $
  * arch/sparc64/math-emu/math.c
  *
- * Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
+ * Copyright (C) 1997,1999 Jakub Jelinek (jj@ultra.linux.cz)
  * Copyright (C) 1999 David S. Miller (davem@redhat.com)
  *
  * Emulation routines originate from soft-fp package, which is part
@@ -15,6 +15,7 @@
 #include <asm/ptrace.h>
 #include <asm/uaccess.h>
 
+#include "sfp-util.h"
 #include "soft-fp.h"
 
 #define FLOATFUNC(x) extern int x(void *,void *,void *);
@@ -84,46 +85,36 @@ static int record_exception(struct pt_regs *regs, int eflag)
 	if(would_trap != 0) {
 		eflag &= ((fsr & FSR_TEM_MASK) >> FSR_TEM_SHIFT);
 		if((eflag & (eflag - 1)) != 0) {
-			if(eflag & EFLAG_INVALID)
-				eflag = EFLAG_INVALID;
-			else if(eflag & EFLAG_DIVZERO)
-				eflag = EFLAG_DIVZERO;
-			else if(eflag & EFLAG_INEXACT)
-				eflag = EFLAG_INEXACT;
+			if(eflag & FP_EX_INVALID)
+				eflag = FP_EX_INVALID;
+			else if(eflag & FP_EX_OVERFLOW)
+				eflag = FP_EX_OVERFLOW;
+			else if(eflag & FP_EX_UNDERFLOW)
+				eflag = FP_EX_UNDERFLOW;
+			else if(eflag & FP_EX_DIVZERO)
+				eflag = FP_EX_DIVZERO;
+			else if(eflag & FP_EX_INEXACT)
+				eflag = FP_EX_INEXACT;
 		}
 	}
 
-	/* Set CEXC, here are the rules:
+	/* Set CEXC, here is the rule:
 	 *
-	 * 1) In general all FPU ops will set one and only one
+	 *    In general all FPU ops will set one and only one
 	 *    bit in the CEXC field, this is always the case
 	 *    when the IEEE exception trap is enabled in TEM.
-	 *
-	 * 2) As a special case, if an overflow or underflow
-	 *    is being signalled, AND the trap is not enabled
-	 *    in TEM, then the inexact field shall also be set.
 	 */
 	fsr &= ~(FSR_CEXC_MASK);
-	if(would_trap ||
-	   (eflag & (EFLAG_OVERFLOW | EFLAG_UNDERFLOW)) == 0) {
-		fsr |= ((long)eflag << FSR_CEXC_SHIFT);
-	} else {
-		fsr |= (((long)eflag << FSR_CEXC_SHIFT) |
-			(EFLAG_INEXACT << FSR_CEXC_SHIFT));
-	}
+	fsr |= ((long)eflag << FSR_CEXC_SHIFT);
 
-	/* Set the AEXC field, rules are:
+	/* Set the AEXC field, rule is:
 	 *
-	 * 1) If a trap would not be generated, the
+	 *    If a trap would not be generated, the
 	 *    CEXC just generated is OR'd into the
 	 *    existing value of AEXC.
-	 *
-	 * 2) When a trap is generated, AEXC is cleared.
 	 */
 	if(would_trap == 0)
 		fsr |= ((long)eflag << FSR_AEXC_SHIFT);
-	else
-		fsr &= ~(FSR_AEXC_MASK);
 
 	/* If trapping, indicate fault trap type IEEE. */
 	if(would_trap != 0)
@@ -242,7 +233,7 @@ int do_mathemu(struct pt_regs *regs, struct fpustate *f)
 		}
 		freg = ((insn >> 25) & 0x1f);
 		switch ((type >> 4) & 0x3) {
-		case 0: rd = (void *)(((long)&current->tss.xfsr[0]) | (freg & 3)); break;
+		case 0: rd = (void *)(long)(freg & 3); break;
 		case 3: if (freg & 2) {
 				current->tss.xfsr[0] |= (6 << 14) /* invalid_fp_register */;
 				goto err;

arch/sparc64/math-emu/op-1.h

-/*
- * Basic one-word fraction declaration and manipulation.
- */
+/* Software floating-point emulation.
+   Basic one-word fraction declaration and manipulation.
+   Copyright (C) 1997,1998,1999 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Richard Henderson (rth@cygnus.com),
+		  Jakub Jelinek (jj@ultra.linux.cz),
+		  David S. Miller (davem@redhat.com) and
+		  Peter Maydell (pmaydell@chiark.greenend.org.uk).
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If
+   not, write to the Free Software Foundation, Inc.,
+   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #define _FP_FRAC_DECL_1(X)	_FP_W_TYPE X##_f
 #define _FP_FRAC_COPY_1(D,S)	(D##_f = S##_f)
@@ -28,6 +48,7 @@
 
 #define _FP_FRAC_ADD_1(R,X,Y)	(R##_f = X##_f + Y##_f)
 #define _FP_FRAC_SUB_1(R,X,Y)	(R##_f = X##_f - Y##_f)
+#define _FP_FRAC_DEC_1(X,Y)	(X##_f -= Y##_f)
 #define _FP_FRAC_CLZ_1(z, X)	__FP_CLZ(z, X##_f)
 
 /* Predicates */
@@ -40,6 +61,7 @@
 
 #define _FP_ZEROFRAC_1		0
 #define _FP_MINFRAC_1		1
+#define _FP_MAXFRAC_1		(~(_FP_WS_TYPE)0)
 
 /*
  * Unpack the raw bits of a native fp value.  Do not classify or
@@ -55,6 +77,15 @@
     X##_s = _flo.bits.sign;					\
   } while (0)
 
+#define _FP_UNPACK_RAW_1_P(fs, X, val)				\
+  do {								\
+    union _FP_UNION_##fs *_flo =				\
+      (union _FP_UNION_##fs *)(val);				\
+								\
+    X##_f = _flo->bits.frac;					\
+    X##_e = _flo->bits.exp;					\
+    X##_s = _flo->bits.sign;					\
+  } while (0)
 
 /*
  * Repack the raw bits of a native fp value.
@@ -71,6 +102,16 @@
     (val) = _flo.flt;						\
   } while (0)
 
+#define _FP_PACK_RAW_1_P(fs, val, X)				\
+  do {								\
+    union _FP_UNION_##fs *_flo =				\
+      (union _FP_UNION_##fs *)(val);				\
+								\
+    _flo->bits.frac = X##_f;					\
+    _flo->bits.exp  = X##_e;					\
+    _flo->bits.sign = X##_s;					\
+  } while (0)
+
 
 /*
  * Multiplication algorithms:
@@ -207,7 +248,7 @@
  
 #define _FP_SQRT_MEAT_1(R, S, T, X, q)			\
   do {							\
-    while (q)						\
+    while (q != _FP_WORK_ROUND)				\
       {							\
         T##_f = S##_f + q;				\
         if (T##_f <= X##_f)				\
@@ -219,6 +260,12 @@
         _FP_FRAC_SLL_1(X, 1);				\
         q >>= 1;					\
       }							\
+    if (X##_f)						\
+      {							\
+	if (S##_f < X##_f)				\
+	  R##_f |= _FP_WORK_ROUND;			\
+	R##_f |= _FP_WORK_STICKY;			\
+      }							\
   } while (0)
 
 /*
@@ -238,8 +285,13 @@
   do {									\
     D##_f = S##_f;							\
     if (_FP_WFRACBITS_##sfs > _FP_WFRACBITS_##dfs)			\
-      _FP_FRAC_SRS_1(D, (_FP_WFRACBITS_##sfs-_FP_WFRACBITS_##dfs),	\
-		     _FP_WFRACBITS_##sfs);				\
+      {									\
+	if (S##_c != FP_CLS_NAN)					\
+	  _FP_FRAC_SRS_1(D, (_FP_WFRACBITS_##sfs-_FP_WFRACBITS_##dfs),	\
+			 _FP_WFRACBITS_##sfs);				\
+	else								\
+	  _FP_FRAC_SRL_1(D, (_FP_WFRACBITS_##sfs-_FP_WFRACBITS_##dfs));	\
+      }									\
     else								\
       D##_f <<= _FP_WFRACBITS_##dfs - _FP_WFRACBITS_##sfs;		\
   } while (0)

drivers/block/loop.c

@@ -504,6 +504,8 @@ static int loop_set_status(struct loop_device *lo, struct loop_info *arg)
 	if ((unsigned int) info.lo_encrypt_key_size > LO_KEY_SIZE)
 		return -EINVAL;
 	type = info.lo_encrypt_type; 
+	if (info.lo_encrypt_key_size == 0 && type == LO_CRYPT_XOR)
+		return -EINVAL;
 	if (type >= MAX_LO_CRYPT || xfer_funcs[type] == NULL)
 		return -EINVAL;
 	err = loop_release_xfer(lo);

drivers/block/ns87415.c

@@ -49,8 +49,25 @@ static void ns87415_prepare_drive (ide_drive_t *drive, unsigned int use_dma)
 	new = use_dma ? ((new & ~other) | bit) : (new & ~bit);
 
 	if (new != *old) {
+		unsigned char stat;
+
+		/*
+		 * Don't change DMA engine settings while Write Buffers
+		 * are busy.
+		 */
+		(void) pci_read_config_byte(dev, 0x43, &stat);
+		while (stat & 0x03) {
+			udelay(1);
+			(void) pci_read_config_byte(dev, 0x43, &stat);
+		}
+
 		*old = new;
 		(void) pci_write_config_dword(dev, 0x40, new);
+
+		/*
+		 * And let things settle...
+		 */
+		udelay(10);
 	}
 
 	__restore_flags(flags);	/* local CPU only */

drivers/net/cosa.c

@@ -2,6 +2,9 @@
 
 /*
  *  Copyright (C) 1995-1997  Jan "Yenya" Kasprzak <kas@fi.muni.cz>
+ * 
+ * 	5/25/1999 : Marcelo Tosatti <marcelo@conectiva.com.br>
+ * 		fixed a deadlock in cosa_sppp_open 
  *
  *  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
@@ -599,6 +602,7 @@ static int cosa_sppp_open(struct device *d)
 	if (chan->usage != 0) {
 		printk(KERN_WARNING "%s: sppp_open called with usage count %d\n",
 			chan->name, chan->usage);
+		spin_unlock_irqrestore(&chan->cosa->lock, flags);
 		return -EBUSY;
 	}
 	chan->setup_rx = sppp_setup_rx;