[SPARC64]: First cut at VIS simulator for Niagara.
David S. Miller [Mon, 13 Mar 2006 09:27:34 +0000 (01:27 -0800)]
Niagara does not implement some of the VIS instructions in
hardware, so we have to emulate them.

Signed-off-by: David S. Miller <davem@davemloft.net>

arch/sparc64/kernel/Makefile
arch/sparc64/kernel/traps.c
arch/sparc64/kernel/visemul.c [new file with mode: 0644]

index fedfd9c..6f68164 100644 (file)
@@ -11,7 +11,8 @@ obj-y         := process.o setup.o cpu.o idprom.o \
                   traps.o devices.o auxio.o una_asm.o \
                   irq.o ptrace.o time.o sys_sparc.o signal.o \
                   unaligned.o central.o pci.o starfire.o semaphore.o \
-                  power.o sbus.o iommu_common.o sparc64_ksyms.o chmc.o
+                  power.o sbus.o iommu_common.o sparc64_ksyms.o chmc.o \
+                  visemul.o
 
 obj-$(CONFIG_PCI)       += ebus.o isa.o pci_common.o pci_iommu.o \
                            pci_psycho.o pci_sabre.o pci_schizo.o \
index 043a726..7f7dba0 100644 (file)
@@ -2273,6 +2273,11 @@ void do_illegal_instruction(struct pt_regs *regs)
                } else if ((insn & 0xc1580000) == 0xc1100000) /* LDQ/STQ */ {
                        if (handle_ldf_stq(insn, regs))
                                return;
+               } else if (tlb_type == hypervisor) {
+                       extern int vis_emul(struct pt_regs *, unsigned int);
+
+                       if (!vis_emul(regs, insn))
+                               return;
                }
        }
        info.si_signo = SIGILL;
diff --git a/arch/sparc64/kernel/visemul.c b/arch/sparc64/kernel/visemul.c
new file mode 100644 (file)
index 0000000..84fedaa
--- /dev/null
@@ -0,0 +1,894 @@
+/* visemul.c: Emulation of VIS instructions.
+ *
+ * Copyright (C) 2006 David S. Miller (davem@davemloft.net)
+ */
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/thread_info.h>
+
+#include <asm/ptrace.h>
+#include <asm/pstate.h>
+#include <asm/system.h>
+#include <asm/fpumacro.h>
+#include <asm/uaccess.h>
+
+/* OPF field of various VIS instructions.  */
+
+/* 000111011 - four 16-bit packs  */
+#define FPACK16_OPF    0x03b
+
+/* 000111010 - two 32-bit packs  */
+#define FPACK32_OPF    0x03a
+
+/* 000111101 - four 16-bit packs  */
+#define FPACKFIX_OPF   0x03d
+
+/* 001001101 - four 16-bit expands  */
+#define FEXPAND_OPF    0x04d
+
+/* 001001011 - two 32-bit merges */
+#define FPMERGE_OPF    0x04b
+
+/* 000110001 - 8-by-16-bit partitoned product  */
+#define FMUL8x16_OPF   0x031
+
+/* 000110011 - 8-by-16-bit upper alpha partitioned product  */
+#define FMUL8x16AU_OPF 0x033
+
+/* 000110101 - 8-by-16-bit lower alpha partitioned product  */
+#define FMUL8x16AL_OPF 0x035
+
+/* 000110110 - upper 8-by-16-bit partitioned product  */
+#define FMUL8SUx16_OPF 0x036
+
+/* 000110111 - lower 8-by-16-bit partitioned product  */
+#define FMUL8ULx16_OPF 0x037
+
+/* 000111000 - upper 8-by-16-bit partitioned product  */
+#define FMULD8SUx16_OPF        0x038
+
+/* 000111001 - lower unsigned 8-by-16-bit partitioned product  */
+#define FMULD8ULx16_OPF        0x039
+
+/* 000101000 - four 16-bit compare; set rd if src1 > src2  */
+#define FCMPGT16_OPF   0x028
+
+/* 000101100 - two 32-bit compare; set rd if src1 > src2  */
+#define FCMPGT32_OPF   0x02c
+
+/* 000100000 - four 16-bit compare; set rd if src1 <= src2  */
+#define FCMPLE16_OPF   0x020
+
+/* 000100100 - two 32-bit compare; set rd if src1 <= src2  */
+#define FCMPLE32_OPF   0x024
+
+/* 000100010 - four 16-bit compare; set rd if src1 != src2  */
+#define FCMPNE16_OPF   0x022
+
+/* 000100110 - two 32-bit compare; set rd if src1 != src2  */
+#define FCMPNE32_OPF   0x026
+
+/* 000101010 - four 16-bit compare; set rd if src1 == src2  */
+#define FCMPEQ16_OPF   0x02a
+
+/* 000101110 - two 32-bit compare; set rd if src1 == src2  */
+#define FCMPEQ32_OPF   0x02e
+
+/* 000000000 - Eight 8-bit edge boundary processing  */
+#define EDGE8_OPF      0x000
+
+/* 000000001 - Eight 8-bit edge boundary processing, no CC */
+#define EDGE8N_OPF     0x001
+
+/* 000000010 - Eight 8-bit edge boundary processing, little-endian  */
+#define EDGE8L_OPF     0x002
+
+/* 000000011 - Eight 8-bit edge boundary processing, little-endian, no CC  */
+#define EDGE8LN_OPF    0x003
+
+/* 000000100 - Four 16-bit edge boundary processing  */
+#define EDGE16_OPF     0x004
+
+/* 000000101 - Four 16-bit edge boundary processing, no CC  */
+#define EDGE16N_OPF    0x005
+
+/* 000000110 - Four 16-bit edge boundary processing, little-endian  */
+#define EDGE16L_OPF    0x006
+
+/* 000000111 - Four 16-bit edge boundary processing, little-endian, no CC  */
+#define EDGE16LN_OPF   0x007
+
+/* 000001000 - Two 32-bit edge boundary processing  */
+#define EDGE32_OPF     0x008
+
+/* 000001001 - Two 32-bit edge boundary processing, no CC  */
+#define EDGE32N_OPF    0x009
+
+/* 000001010 - Two 32-bit edge boundary processing, little-endian  */
+#define EDGE32L_OPF    0x00a
+
+/* 000001011 - Two 32-bit edge boundary processing, little-endian, no CC  */
+#define EDGE32LN_OPF   0x00b
+
+/* 000111110 - distance between 8 8-bit components  */
+#define PDIST_OPF      0x03e
+
+/* 000010000 - convert 8-bit 3-D address to blocked byte address  */
+#define ARRAY8_OPF     0x010
+
+/* 000010010 - convert 16-bit 3-D address to blocked byte address  */
+#define ARRAY16_OPF    0x012
+
+/* 000010100 - convert 32-bit 3-D address to blocked byte address  */
+#define ARRAY32_OPF    0x014
+
+/* 000011001 - Set the GSR.MASK field in preparation for a BSHUFFLE  */
+#define BMASK_OPF      0x019
+
+/* 001001100 - Permute bytes as specified by GSR.MASK  */
+#define BSHUFFLE_OPF   0x04c
+
+#define VIS_OPCODE_MASK        ((0x3 << 30) | (0x3f << 19))
+#define VIS_OPCODE_VAL ((0x2 << 30) | (0x36 << 19))
+
+#define VIS_OPF_SHIFT  5
+#define VIS_OPF_MASK   (0x1ff << VIS_OPF_SHIFT)
+
+#define RS1(INSN)      (((INSN) >> 24) & 0x1f)
+#define RS2(INSN)      (((INSN) >>  0) & 0x1f)
+#define RD(INSN)       (((INSN) >> 25) & 0x1f)
+
+static inline void maybe_flush_windows(unsigned int rs1, unsigned int rs2,
+                                      unsigned int rd, int from_kernel)
+{
+       if (rs2 >= 16 || rs1 >= 16 || rd >= 16) {
+               if (from_kernel != 0)
+                       __asm__ __volatile__("flushw");
+               else
+                       flushw_user();
+       }
+}
+
+static unsigned long fetch_reg(unsigned int reg, struct pt_regs *regs)
+{
+       unsigned long value;
+       
+       if (reg < 16)
+               return (!reg ? 0 : regs->u_regs[reg]);
+       if (regs->tstate & TSTATE_PRIV) {
+               struct reg_window *win;
+               win = (struct reg_window *)(regs->u_regs[UREG_FP] + STACK_BIAS);
+               value = win->locals[reg - 16];
+       } else if (test_thread_flag(TIF_32BIT)) {
+               struct reg_window32 __user *win32;
+               win32 = (struct reg_window32 __user *)((unsigned long)((u32)regs->u_regs[UREG_FP]));
+               get_user(value, &win32->locals[reg - 16]);
+       } else {
+               struct reg_window __user *win;
+               win = (struct reg_window __user *)(regs->u_regs[UREG_FP] + STACK_BIAS);
+               get_user(value, &win->locals[reg - 16]);
+       }
+       return value;
+}
+
+static inline unsigned long __user *__fetch_reg_addr_user(unsigned int reg,
+                                                         struct pt_regs *regs)
+{
+       BUG_ON(reg < 16);
+       BUG_ON(regs->tstate & TSTATE_PRIV);
+
+       if (test_thread_flag(TIF_32BIT)) {
+               struct reg_window32 __user *win32;
+               win32 = (struct reg_window32 __user *)((unsigned long)((u32)regs->u_regs[UREG_FP]));
+               return (unsigned long __user *)&win32->locals[reg - 16];
+       } else {
+               struct reg_window __user *win;
+               win = (struct reg_window __user *)(regs->u_regs[UREG_FP] + STACK_BIAS);
+               return &win->locals[reg - 16];
+       }
+}
+
+static inline unsigned long *__fetch_reg_addr_kern(unsigned int reg,
+                                                  struct pt_regs *regs)
+{
+       BUG_ON(reg >= 16);
+       BUG_ON(regs->tstate & TSTATE_PRIV);
+
+       return &regs->u_regs[reg];
+}
+
+static void store_reg(struct pt_regs *regs, unsigned long val, unsigned long rd)
+{
+       if (rd < 16) {
+               unsigned long *rd_kern = __fetch_reg_addr_kern(rd, regs);
+
+               *rd_kern = val;
+       } else {
+               unsigned long __user *rd_user = __fetch_reg_addr_user(rd, regs);
+
+               if (test_thread_flag(TIF_32BIT))
+                       __put_user((u32)val, (u32 __user *)rd_user);
+               else
+                       __put_user(val, rd_user);
+       }
+}
+
+static inline unsigned long fpd_regval(struct fpustate *f,
+                                      unsigned int insn_regnum)
+{
+       insn_regnum = (((insn_regnum & 1) << 5) |
+                      (insn_regnum & 0x1e));
+
+       return *(unsigned long *) &f->regs[insn_regnum];
+}
+
+static inline unsigned long *fpd_regaddr(struct fpustate *f,
+                                        unsigned int insn_regnum)
+{
+       insn_regnum = (((insn_regnum & 1) << 5) |
+                      (insn_regnum & 0x1e));
+
+       return (unsigned long *) &f->regs[insn_regnum];
+}
+
+static inline unsigned int fps_regval(struct fpustate *f,
+                                     unsigned int insn_regnum)
+{
+       return f->regs[insn_regnum];
+}
+
+static inline unsigned int *fps_regaddr(struct fpustate *f,
+                                       unsigned int insn_regnum)
+{
+       return &f->regs[insn_regnum];
+}
+
+struct edge_tab {
+       u16 left, right;
+};
+struct edge_tab edge8_tab[8] = {
+       { 0xff, 0x80 },
+       { 0x7f, 0xc0 },
+       { 0x3f, 0xe0 },
+       { 0x1f, 0xf0 },
+       { 0x0f, 0xf8 },
+       { 0x07, 0xfc },
+       { 0x03, 0xfe },
+       { 0x01, 0xff },
+};
+struct edge_tab edge8_tab_l[8] = {
+       { 0xff, 0x01 },
+       { 0xfe, 0x03 },
+       { 0xfc, 0x07 },
+       { 0xf8, 0x0f },
+       { 0xf0, 0x1f },
+       { 0xe0, 0x3f },
+       { 0xc0, 0x7f },
+       { 0x80, 0xff },
+};
+struct edge_tab edge16_tab[4] = {
+       { 0xf, 0x8 },
+       { 0x7, 0xc },
+       { 0x3, 0xe },
+       { 0x1, 0xf },
+};
+struct edge_tab edge16_tab_l[4] = {
+       { 0xf, 0x1 },
+       { 0xe, 0x3 },
+       { 0xc, 0x7 },
+       { 0x8, 0xf },
+};
+struct edge_tab edge32_tab[2] = {
+       { 0x3, 0x2 },
+       { 0x1, 0x3 },
+};
+struct edge_tab edge32_tab_l[2] = {
+       { 0x3, 0x1 },
+       { 0x2, 0x3 },
+};
+
+static void edge(struct pt_regs *regs, unsigned int insn, unsigned int opf)
+{
+       unsigned long orig_rs1, rs1, orig_rs2, rs2, rd_val;
+       u16 left, right;
+
+       maybe_flush_windows(RS1(insn), RS2(insn), RD(insn), 0);
+       orig_rs1 = rs1 = fetch_reg(RS1(insn), regs);
+       orig_rs2 = rs2 = fetch_reg(RS2(insn), regs);
+
+       if (test_thread_flag(TIF_32BIT)) {
+               rs1 = rs1 & 0xffffffff;
+               rs2 = rs2 & 0xffffffff;
+       }
+       switch (opf) {
+       default:
+       case EDGE8_OPF:
+       case EDGE8N_OPF:
+               left = edge8_tab[rs1 & 0x7].left;
+               right = edge8_tab[rs2 & 0x7].right;
+               break;
+       case EDGE8L_OPF:
+       case EDGE8LN_OPF:
+               left = edge8_tab_l[rs1 & 0x7].left;
+               right = edge8_tab_l[rs2 & 0x7].right;
+               break;
+
+       case EDGE16_OPF:
+       case EDGE16N_OPF:
+               left = edge16_tab[(rs1 >> 1) & 0x3].left;
+               right = edge16_tab[(rs2 >> 1) & 0x3].right;
+               break;
+
+       case EDGE16L_OPF:
+       case EDGE16LN_OPF:
+               left = edge16_tab_l[(rs1 >> 1) & 0x3].left;
+               right = edge16_tab_l[(rs2 >> 1) & 0x3].right;
+               break;
+
+       case EDGE32_OPF:
+       case EDGE32N_OPF:
+               left = edge32_tab[(rs1 >> 2) & 0x1].left;
+               right = edge32_tab[(rs2 >> 2) & 0x1].right;
+               break;
+
+       case EDGE32L_OPF:
+       case EDGE32LN_OPF:
+               left = edge32_tab_l[(rs1 >> 2) & 0x1].left;
+               right = edge32_tab_l[(rs2 >> 2) & 0x1].right;
+               break;
+       };
+
+       if ((rs1 & ~0x7UL) == (rs2 & ~0x7UL))
+               rd_val = right & left;
+       else
+               rd_val = left;
+
+       store_reg(regs, rd_val, RD(insn));
+
+       switch (opf) {
+       case EDGE8_OPF:
+       case EDGE8L_OPF:
+       case EDGE16_OPF:
+       case EDGE16L_OPF:
+       case EDGE32_OPF:
+       case EDGE32L_OPF: {
+               unsigned long ccr, tstate;
+
+               __asm__ __volatile__("subcc     %1, %2, %%g0\n\t"
+                                    "rd        %%ccr, %0"
+                                    : "=r" (ccr)
+                                    : "r" (orig_rs1), "r" (orig_rs2)
+                                    : "cc");
+               tstate = regs->tstate & ~(TSTATE_XCC | TSTATE_ICC);
+               regs->tstate = tstate | (ccr << 32UL);
+       }
+       };
+}
+
+static void array(struct pt_regs *regs, unsigned int insn, unsigned int opf)
+{
+       unsigned long rs1, rs2, rd_val;
+       unsigned int bits, bits_mask;
+
+       maybe_flush_windows(RS1(insn), RS2(insn), RD(insn), 0);
+       rs1 = fetch_reg(RS1(insn), regs);
+       rs2 = fetch_reg(RS2(insn), regs);
+
+       bits = (rs2 > 5 ? 5 : rs2);
+       bits_mask = (1UL << bits) - 1UL;
+
+       rd_val = ((((rs1 >> 11) & 0x3) <<  0) |
+                 (((rs1 >> 33) & 0x3) <<  2) |
+                 (((rs1 >> 55) & 0x1) <<  4) |
+                 (((rs1 >> 13) & 0xf) <<  5) |
+                 (((rs1 >> 35) & 0xf) <<  9) |
+                 (((rs1 >> 56) & 0xf) << 13) |
+                 (((rs1 >> 17) & bits_mask) << 17) |
+                 (((rs1 >> 39) & bits_mask) << (17 + bits)) |
+                 (((rs1 >> 60) & 0xf)       << (17 + (2*bits))));
+
+       switch (opf) {
+       case ARRAY16_OPF:
+               rd_val <<= 1;
+               break;
+
+       case ARRAY32_OPF:
+               rd_val <<= 2;
+       };
+
+       store_reg(regs, rd_val, RD(insn));
+}
+
+static void bmask(struct pt_regs *regs, unsigned int insn)
+{
+       unsigned long rs1, rs2, rd_val, gsr;
+
+       maybe_flush_windows(RS1(insn), RS2(insn), RD(insn), 0);
+       rs1 = fetch_reg(RS1(insn), regs);
+       rs2 = fetch_reg(RS2(insn), regs);
+       rd_val = rs1 + rs2;
+
+       store_reg(regs, rd_val, RD(insn));
+
+       gsr = current_thread_info()->gsr[0] & 0xffffffff;
+       gsr |= rd_val << 32UL;
+       current_thread_info()->gsr[0] = gsr;
+}
+
+static void bshuffle(struct pt_regs *regs, unsigned int insn)
+{
+       struct fpustate *f = FPUSTATE;
+       unsigned long rs1, rs2, rd_val;
+       unsigned long bmask, i;
+
+       bmask = current_thread_info()->gsr[0] >> 32UL;
+
+       rs1 = fpd_regval(f, RS1(insn));
+       rs2 = fpd_regval(f, RS2(insn));
+
+       rd_val = 0UL;
+       for (i = 0; i < 8; i++) {
+               unsigned long which = (bmask >> (i * 4)) & 0xf;
+               unsigned long byte;
+
+               if (which < 8)
+                       byte = (rs1 >> (which * 8)) & 0xff;
+               else
+                       byte = (rs2 >> ((which-8)*8)) & 0xff;
+               rd_val |= (byte << (i * 8));
+       }
+
+       *fpd_regaddr(f, RD(insn)) = rd_val;
+}
+
+static void pdist(struct pt_regs *regs, unsigned int insn)
+{
+       struct fpustate *f = FPUSTATE;
+       unsigned long rs1, rs2, *rd, rd_val;
+       unsigned long i;
+
+       rs1 = fpd_regval(f, RS1(insn));
+       rs2 = fpd_regval(f, RS1(insn));
+       rd = fpd_regaddr(f, RD(insn));
+
+       rd_val = *rd;
+
+       for (i = 0; i < 8; i++) {
+               s16 s1, s2;
+
+               s1 = (rs1 >> (56 - (i * 8))) & 0xff;
+               s2 = (rs2 >> (56 - (i * 8))) & 0xff;
+
+               /* Absolute value of difference. */
+               s1 -= s2;
+               if (s1 < 0)
+                       s1 = ~s1 + 1;
+
+               rd_val += s1;
+       }
+
+       *rd = rd_val;
+}
+
+static void pformat(struct pt_regs *regs, unsigned int insn, unsigned int opf)
+{
+       struct fpustate *f = FPUSTATE;
+       unsigned long rs1, rs2, gsr, scale, rd_val;
+
+       gsr = current_thread_info()->gsr[0];
+       scale = (gsr >> 3) & (opf == FPACK16_OPF ? 0xf : 0x1f);
+       switch (opf) {
+       case FPACK16_OPF: {
+               unsigned long byte;
+
+               rs2 = fpd_regval(f, RS2(insn));
+               rd_val = 0;
+               for (byte = 0; byte < 4; byte++) {
+                       unsigned int val;
+                       s16 src = (rs2 >> (byte * 16UL)) & 0xffffUL;
+                       int scaled = src << scale;
+                       int from_fixed = scaled >> 7;
+
+                       val = ((from_fixed < 0) ?
+                              0 :
+                              (from_fixed > 255) ?
+                              255 : from_fixed);
+
+                       rd_val |= (val << (8 * byte));
+               }
+               *fps_regaddr(f, RD(insn)) = rd_val;
+               break;
+       }
+
+       case FPACK32_OPF: {
+               unsigned long word;
+
+               rs1 = fpd_regval(f, RS1(insn));
+               rs2 = fpd_regval(f, RS2(insn));
+               rd_val = (rs1 << 8) & ~(0x000000ff000000ffUL);
+               for (word = 0; word < 2; word++) {
+                       unsigned long val;
+                       s32 src = (rs2 >> (word * 32UL));
+                       s64 scaled = src << scale;
+                       s64 from_fixed = scaled >> 23;
+
+                       val = ((from_fixed < 0) ?
+                              0 :
+                              (from_fixed > 255) ?
+                              255 : from_fixed);
+
+                       rd_val |= (val << (32 * word));
+               }
+               *fpd_regaddr(f, RD(insn)) = rd_val;
+               break;
+       }
+
+       case FPACKFIX_OPF: {
+               unsigned long word;
+
+               rs2 = fpd_regval(f, RS2(insn));
+
+               rd_val = 0;
+               for (word = 0; word < 2; word++) {
+                       long val;
+                       s32 src = (rs2 >> (word * 32UL));
+                       s64 scaled = src << scale;
+                       s64 from_fixed = scaled >> 16;
+
+                       val = ((from_fixed < -32768) ?
+                              -32768 :
+                              (from_fixed > 32767) ?
+                              32767 : from_fixed);
+
+                       rd_val |= ((val & 0xffff) << (word * 16));
+               }
+               *fps_regaddr(f, RD(insn)) = rd_val;
+               break;
+       }
+
+       case FEXPAND_OPF: {
+               unsigned long byte;
+
+               rs2 = fps_regval(f, RS2(insn));
+
+               rd_val = 0;
+               for (byte = 0; byte < 4; byte++) {
+                       unsigned long val;
+                       u8 src = (rs2 >> (byte * 8)) & 0xff;
+
+                       val = src << 4;
+
+                       rd_val |= (val << (byte * 16));
+               }
+               *fpd_regaddr(f, RD(insn)) = rd_val;
+               break;
+       }
+
+       case FPMERGE_OPF: {
+               rs1 = fps_regval(f, RS1(insn));
+               rs2 = fps_regval(f, RS2(insn));
+
+               rd_val = (((rs2 & 0x000000ff) <<  0) |
+                         ((rs1 & 0x000000ff) <<  8) |
+                         ((rs2 & 0x0000ff00) <<  8) |
+                         ((rs1 & 0x0000ff00) << 16) |
+                         ((rs2 & 0x00ff0000) << 16) |
+                         ((rs1 & 0x00ff0000) << 24) |
+                         ((rs2 & 0xff000000) << 24) |
+                         ((rs1 & 0xff000000) << 32));
+               *fpd_regaddr(f, RD(insn)) = rd_val;
+               break;
+       }
+       };
+}
+
+static void pmul(struct pt_regs *regs, unsigned int insn, unsigned int opf)
+{
+       struct fpustate *f = FPUSTATE;
+       unsigned long rs1, rs2, rd_val;
+
+       switch (opf) {
+       case FMUL8x16_OPF: {
+               unsigned long byte;
+
+               rs1 = fps_regval(f, RS1(insn));
+               rs2 = fpd_regval(f, RS2(insn));
+
+               rd_val = 0;
+               for (byte = 0; byte < 4; byte++) {
+                       u16 src1 = (rs1 >> (byte *  8)) & 0x00ff;
+                       s16 src2 = (rs2 >> (byte * 16)) & 0xffff;
+                       u32 prod = src1 * src2;
+                       u16 scaled = ((prod & 0x00ffff00) >> 8);
+
+                       /* Round up.  */
+                       if (prod & 0x80)
+                               scaled++;
+                       rd_val |= ((scaled & 0xffffUL) << (byte * 16UL));
+               }
+
+               *fpd_regaddr(f, RD(insn)) = rd_val;
+               break;
+       }
+
+       case FMUL8x16AU_OPF:
+       case FMUL8x16AL_OPF: {
+               unsigned long byte;
+               s16 src2;
+
+               rs1 = fps_regval(f, RS1(insn));
+               rs2 = fps_regval(f, RS2(insn));
+
+               rd_val = 0;
+               src2 = (rs2 >> (opf == FMUL8x16AU_OPF) ? 16 : 0);
+               for (byte = 0; byte < 4; byte++) {
+                       u16 src1 = (rs1 >> (byte * 8)) & 0x00ff;
+                       u32 prod = src1 * src2;
+                       u16 scaled = ((prod & 0x00ffff00) >> 8);
+
+                       /* Round up.  */
+                       if (prod & 0x80)
+                               scaled++;
+                       rd_val |= ((scaled & 0xffffUL) << (byte * 16UL));
+               }
+
+               *fpd_regaddr(f, RD(insn)) = rd_val;
+               break;
+       }
+
+       case FMUL8SUx16_OPF:
+       case FMUL8ULx16_OPF: {
+               unsigned long byte, ushift;
+
+               rs1 = fpd_regval(f, RS1(insn));
+               rs2 = fpd_regval(f, RS2(insn));
+
+               rd_val = 0;
+               ushift = (opf == FMUL8SUx16_OPF) ? 8 : 0;
+               for (byte = 0; byte < 4; byte++) {
+                       u16 src1;
+                       s16 src2;
+                       u32 prod;
+                       u16 scaled;
+
+                       src1 = ((rs1 >> ((16 * byte) + ushift)) & 0x00ff);
+                       src2 = ((rs2 >> (16 * byte)) & 0xffff);
+                       prod = src1 * src2;
+                       scaled = ((prod & 0x00ffff00) >> 8);
+
+                       /* Round up.  */
+                       if (prod & 0x80)
+                               scaled++;
+                       rd_val |= ((scaled & 0xffffUL) << (byte * 16UL));
+               }
+
+               *fpd_regaddr(f, RD(insn)) = rd_val;
+               break;
+       }
+
+       case FMULD8SUx16_OPF:
+       case FMULD8ULx16_OPF: {
+               unsigned long byte, ushift;
+
+               rs1 = fps_regval(f, RS1(insn));
+               rs2 = fps_regval(f, RS2(insn));
+
+               rd_val = 0;
+               ushift = (opf == FMULD8SUx16_OPF) ? 8 : 0;
+               for (byte = 0; byte < 2; byte++) {
+                       u16 src1;
+                       s16 src2;
+                       u32 prod;
+                       u16 scaled;
+
+                       src1 = ((rs1 >> ((16 * byte) + ushift)) & 0x00ff);
+                       src2 = ((rs2 >> (16 * byte)) & 0xffff);
+                       prod = src1 * src2;
+                       scaled = ((prod & 0x00ffff00) >> 8);
+
+                       /* Round up.  */
+                       if (prod & 0x80)
+                               scaled++;
+                       rd_val |= ((scaled & 0xffffUL) <<
+                                  ((byte * 32UL) + 7UL));
+               }
+               *fpd_regaddr(f, RD(insn)) = rd_val;
+               break;
+       }
+       };
+}
+
+static void pcmp(struct pt_regs *regs, unsigned int insn, unsigned int opf)
+{
+       struct fpustate *f = FPUSTATE;
+       unsigned long rs1, rs2, rd_val, i;
+
+       rs1 = fpd_regval(f, RS1(insn));
+       rs2 = fpd_regval(f, RS2(insn));
+
+       rd_val = 0;
+
+       switch (opf) {
+       case FCMPGT16_OPF:
+               for (i = 0; i < 4; i++) {
+                       s16 a = (rs1 >> (i * 16)) & 0xffff;
+                       s16 b = (rs2 >> (i * 16)) & 0xffff;
+
+                       if (a > b)
+                               rd_val |= 1 << i;
+               }
+               break;
+
+       case FCMPGT32_OPF:
+               for (i = 0; i < 2; i++) {
+                       s32 a = (rs1 >> (i * 32)) & 0xffff;
+                       s32 b = (rs2 >> (i * 32)) & 0xffff;
+
+                       if (a > b)
+                               rd_val |= 1 << i;
+               }
+               break;
+
+       case FCMPLE16_OPF:
+               for (i = 0; i < 4; i++) {
+                       s16 a = (rs1 >> (i * 16)) & 0xffff;
+                       s16 b = (rs2 >> (i * 16)) & 0xffff;
+
+                       if (a <= b)
+                               rd_val |= 1 << i;
+               }
+               break;
+
+       case FCMPLE32_OPF:
+               for (i = 0; i < 2; i++) {
+                       s32 a = (rs1 >> (i * 32)) & 0xffff;
+                       s32 b = (rs2 >> (i * 32)) & 0xffff;
+
+                       if (a <= b)
+                               rd_val |= 1 << i;
+               }
+               break;
+
+       case FCMPNE16_OPF:
+               for (i = 0; i < 4; i++) {
+                       s16 a = (rs1 >> (i * 16)) & 0xffff;
+                       s16 b = (rs2 >> (i * 16)) & 0xffff;
+
+                       if (a != b)
+                               rd_val |= 1 << i;
+               }
+               break;
+
+       case FCMPNE32_OPF:
+               for (i = 0; i < 2; i++) {
+                       s32 a = (rs1 >> (i * 32)) & 0xffff;
+                       s32 b = (rs2 >> (i * 32)) & 0xffff;
+
+                       if (a != b)
+                               rd_val |= 1 << i;
+               }
+               break;
+
+       case FCMPEQ16_OPF:
+               for (i = 0; i < 4; i++) {
+                       s16 a = (rs1 >> (i * 16)) & 0xffff;
+                       s16 b = (rs2 >> (i * 16)) & 0xffff;
+
+                       if (a == b)
+                               rd_val |= 1 << i;
+               }
+               break;
+
+       case FCMPEQ32_OPF:
+               for (i = 0; i < 2; i++) {
+                       s32 a = (rs1 >> (i * 32)) & 0xffff;
+                       s32 b = (rs2 >> (i * 32)) & 0xffff;
+
+                       if (a == b)
+                               rd_val |= 1 << i;
+               }
+               break;
+       };
+
+       maybe_flush_windows(0, 0, RD(insn), 0);
+       store_reg(regs, rd_val, RD(insn));
+}
+
+/* Emulate the VIS instructions which are not implemented in
+ * hardware on Niagara.
+ */
+int vis_emul(struct pt_regs *regs, unsigned int insn)
+{
+       unsigned long pc = regs->tpc;
+       unsigned int opf;
+
+       BUG_ON(regs->tstate & TSTATE_PRIV);
+
+       if (test_thread_flag(TIF_32BIT))
+               pc = (u32)pc;
+
+       if (get_user(insn, (u32 __user *) pc))
+               return -EFAULT;
+
+       if ((insn & VIS_OPCODE_MASK) != VIS_OPCODE_VAL)
+               return -EINVAL;
+
+       opf = (insn & VIS_OPF_MASK) >> VIS_OPF_SHIFT;
+       switch (opf) {
+       default:
+               return -EINVAL;
+
+       /* Pixel Formatting Instructions.  */
+       case FPACK16_OPF:
+       case FPACK32_OPF:
+       case FPACKFIX_OPF:
+       case FEXPAND_OPF:
+       case FPMERGE_OPF:
+               pformat(regs, insn, opf);
+               break;
+
+       /* Partitioned Multiply Instructions  */
+       case FMUL8x16_OPF:
+       case FMUL8x16AU_OPF:
+       case FMUL8x16AL_OPF:
+       case FMUL8SUx16_OPF:
+       case FMUL8ULx16_OPF:
+       case FMULD8SUx16_OPF:
+       case FMULD8ULx16_OPF:
+               pmul(regs, insn, opf);
+               break;
+
+       /* Pixel Compare Instructions  */
+       case FCMPGT16_OPF:
+       case FCMPGT32_OPF:
+       case FCMPLE16_OPF:
+       case FCMPLE32_OPF:
+       case FCMPNE16_OPF:
+       case FCMPNE32_OPF:
+       case FCMPEQ16_OPF:
+       case FCMPEQ32_OPF:
+               pcmp(regs, insn, opf);
+               break;
+
+       /* Edge Handling Instructions  */
+       case EDGE8_OPF:
+       case EDGE8N_OPF:
+       case EDGE8L_OPF:
+       case EDGE8LN_OPF:
+       case EDGE16_OPF:
+       case EDGE16N_OPF:
+       case EDGE16L_OPF:
+       case EDGE16LN_OPF:
+       case EDGE32_OPF:
+       case EDGE32N_OPF:
+       case EDGE32L_OPF:
+       case EDGE32LN_OPF:
+               edge(regs, insn, opf);
+               break;
+
+       /* Pixel Component Distance  */
+       case PDIST_OPF:
+               pdist(regs, insn);
+               break;
+
+       /* Three-Dimensional Array Addressing Instructions  */
+       case ARRAY8_OPF:
+       case ARRAY16_OPF:
+       case ARRAY32_OPF:
+               array(regs, insn, opf);
+               break;
+
+       /* Byte Mask and Shuffle Instructions  */
+       case BMASK_OPF:
+               bmask(regs, insn);
+               break;
+
+       case BSHUFFLE_OPF:
+               bshuffle(regs, insn);
+               break;
+       };
+
+       regs->tpc = regs->tnpc;
+       regs->tnpc += 4;
+       return 0;
+}