LXR linux/arch/mips/loongson64/cop2-ex.c

   1/*
   2 * This file is subject to the terms and conditions of the GNU General Public
   3 * License.  See the file "COPYING" in the main directory of this archive
   4 * for more details.
   5 *
   6 * Copyright (C) 2014 Lemote Corporation.
   7 *   written by Huacai Chen <chenhc@lemote.com>
   8 *
   9 * based on arch/mips/cavium-octeon/cpu.c
  10 * Copyright (C) 2009 Wind River Systems,
  11 *   written by Ralf Baechle <ralf@linux-mips.org>
  12 */
  13#include <linux/init.h>
  14#include <linux/sched.h>
  15#include <linux/notifier.h>
  16#include <linux/ptrace.h>
  17#include <linux/uaccess.h>
  18#include <linux/sched/signal.h>
  19
  20#include <asm/fpu.h>
  21#include <asm/cop2.h>
  22#include <asm/inst.h>
  23#include <asm/branch.h>
  24#include <asm/current.h>
  25#include <asm/mipsregs.h>
  26#include <asm/unaligned-emul.h>
  27
  28static int loongson_cu2_call(struct notifier_block *nfb, unsigned long action,
  29        void *data)
  30{
  31        unsigned int res, fpu_owned;
  32        unsigned long ra, value, value_next;
  33        union mips_instruction insn;
  34        int fr = !test_thread_flag(TIF_32BIT_FPREGS);
  35        struct pt_regs *regs = (struct pt_regs *)data;
  36        void __user *addr = (void __user *)regs->cp0_badvaddr;
  37        unsigned int __user *pc = (unsigned int __user *)exception_epc(regs);
  38
  39        ra = regs->regs[31];
  40        __get_user(insn.word, pc);
  41
  42        switch (action) {
  43        case CU2_EXCEPTION:
  44                preempt_disable();
  45                fpu_owned = __is_fpu_owner();
  46                if (!fr)
  47                        set_c0_status(ST0_CU1 | ST0_CU2);
  48                else
  49                        set_c0_status(ST0_CU1 | ST0_CU2 | ST0_FR);
  50                enable_fpu_hazard();
  51                KSTK_STATUS(current) |= (ST0_CU1 | ST0_CU2);
  52                if (fr)
  53                        KSTK_STATUS(current) |= ST0_FR;
  54                else
  55                        KSTK_STATUS(current) &= ~ST0_FR;
  56                /* If FPU is owned, we needn't init or restore fp */
  57                if (!fpu_owned) {
  58                        set_thread_flag(TIF_USEDFPU);
  59                        init_fp_ctx(current);
  60                        _restore_fp(current);
  61                }
  62                preempt_enable();
  63
  64                return NOTIFY_STOP;     /* Don't call default notifier */
  65
  66        case CU2_LWC2_OP:
  67                if (insn.loongson3_lswc2_format.ls == 0)
  68                        goto sigbus;
  69
  70                if (insn.loongson3_lswc2_format.fr == 0) {      /* gslq */
  71                        if (!access_ok(addr, 16))
  72                                goto sigbus;
  73
  74                        LoadDW(addr, value, res);
  75                        if (res)
  76                                goto fault;
  77
  78                        LoadDW(addr + 8, value_next, res);
  79                        if (res)
  80                                goto fault;
  81
  82                        regs->regs[insn.loongson3_lswc2_format.rt] = value;
  83                        regs->regs[insn.loongson3_lswc2_format.rq] = value_next;
  84                        compute_return_epc(regs);
  85                } else {                                        /* gslqc1 */
  86                        if (!access_ok(addr, 16))
  87                                goto sigbus;
  88
  89                        lose_fpu(1);
  90                        LoadDW(addr, value, res);
  91                        if (res)
  92                                goto fault;
  93
  94                        LoadDW(addr + 8, value_next, res);
  95                        if (res)
  96                                goto fault;
  97
  98                        set_fpr64(&current->thread.fpu.fpr[insn.loongson3_lswc2_format.rt], 0, value);
  99                        set_fpr64(&current->thread.fpu.fpr[insn.loongson3_lswc2_format.rq], 0, value_next);
 100                        compute_return_epc(regs);
 101                        own_fpu(1);
 102                }
 103                return NOTIFY_STOP;     /* Don't call default notifier */
 104
 105        case CU2_SWC2_OP:
 106                if (insn.loongson3_lswc2_format.ls == 0)
 107                        goto sigbus;
 108
 109                if (insn.loongson3_lswc2_format.fr == 0) {      /* gssq */
 110                        if (!access_ok(addr, 16))
 111                                goto sigbus;
 112
 113                        /* write upper 8 bytes first */
 114                        value_next = regs->regs[insn.loongson3_lswc2_format.rq];
 115
 116                        StoreDW(addr + 8, value_next, res);
 117                        if (res)
 118                                goto fault;
 119                        value = regs->regs[insn.loongson3_lswc2_format.rt];
 120
 121                        StoreDW(addr, value, res);
 122                        if (res)
 123                                goto fault;
 124
 125                        compute_return_epc(regs);
 126                } else {                                        /* gssqc1 */
 127                        if (!access_ok(addr, 16))
 128                                goto sigbus;
 129
 130                        lose_fpu(1);
 131                        value_next = get_fpr64(&current->thread.fpu.fpr[insn.loongson3_lswc2_format.rq], 0);
 132
 133                        StoreDW(addr + 8, value_next, res);
 134                        if (res)
 135                                goto fault;
 136
 137                        value = get_fpr64(&current->thread.fpu.fpr[insn.loongson3_lswc2_format.rt], 0);
 138
 139                        StoreDW(addr, value, res);
 140                        if (res)
 141                                goto fault;
 142
 143                        compute_return_epc(regs);
 144                        own_fpu(1);
 145                }
 146                return NOTIFY_STOP;     /* Don't call default notifier */
 147
 148        case CU2_LDC2_OP:
 149                switch (insn.loongson3_lsdc2_format.opcode1) {
 150                /*
 151                 * Loongson-3 overridden ldc2 instructions.
 152                 * opcode1              instruction
 153                 *   0x1          gslhx: load 2 bytes to GPR
 154                 *   0x2          gslwx: load 4 bytes to GPR
 155                 *   0x3          gsldx: load 8 bytes to GPR
 156                 *   0x6          gslwxc1: load 4 bytes to FPR
 157                 *   0x7          gsldxc1: load 8 bytes to FPR
 158                 */
 159                case 0x1:
 160                        if (!access_ok(addr, 2))
 161                                goto sigbus;
 162
 163                        LoadHW(addr, value, res);
 164                        if (res)
 165                                goto fault;
 166
 167                        compute_return_epc(regs);
 168                        regs->regs[insn.loongson3_lsdc2_format.rt] = value;
 169                        break;
 170                case 0x2:
 171                        if (!access_ok(addr, 4))
 172                                goto sigbus;
 173
 174                        LoadW(addr, value, res);
 175                        if (res)
 176                                goto fault;
 177
 178                        compute_return_epc(regs);
 179                        regs->regs[insn.loongson3_lsdc2_format.rt] = value;
 180                        break;
 181                case 0x3:
 182                        if (!access_ok(addr, 8))
 183                                goto sigbus;
 184
 185                        LoadDW(addr, value, res);
 186                        if (res)
 187                                goto fault;
 188
 189                        compute_return_epc(regs);
 190                        regs->regs[insn.loongson3_lsdc2_format.rt] = value;
 191                        break;
 192                case 0x6:
 193                        die_if_kernel("Unaligned FP access in kernel code", regs);
 194                        BUG_ON(!used_math());
 195                        if (!access_ok(addr, 4))
 196                                goto sigbus;
 197
 198                        lose_fpu(1);
 199                        LoadW(addr, value, res);
 200                        if (res)
 201                                goto fault;
 202
 203                        set_fpr64(&current->thread.fpu.fpr[insn.loongson3_lsdc2_format.rt], 0, value);
 204                        compute_return_epc(regs);
 205                        own_fpu(1);
 206
 207                        break;
 208                case 0x7:
 209                        die_if_kernel("Unaligned FP access in kernel code", regs);
 210                        BUG_ON(!used_math());
 211                        if (!access_ok(addr, 8))
 212                                goto sigbus;
 213
 214                        lose_fpu(1);
 215                        LoadDW(addr, value, res);
 216                        if (res)
 217                                goto fault;
 218
 219                        set_fpr64(&current->thread.fpu.fpr[insn.loongson3_lsdc2_format.rt], 0, value);
 220                        compute_return_epc(regs);
 221                        own_fpu(1);
 222                        break;
 223
 224                }
 225                return NOTIFY_STOP;     /* Don't call default notifier */
 226
 227        case CU2_SDC2_OP:
 228                switch (insn.loongson3_lsdc2_format.opcode1) {
 229                /*
 230                 * Loongson-3 overridden sdc2 instructions.
 231                 * opcode1              instruction
 232                 *   0x1          gsshx: store 2 bytes from GPR
 233                 *   0x2          gsswx: store 4 bytes from GPR
 234                 *   0x3          gssdx: store 8 bytes from GPR
 235                 *   0x6          gsswxc1: store 4 bytes from FPR
 236                 *   0x7          gssdxc1: store 8 bytes from FPR
 237                 */
 238                case 0x1:
 239                        if (!access_ok(addr, 2))
 240                                goto sigbus;
 241
 242                        compute_return_epc(regs);
 243                        value = regs->regs[insn.loongson3_lsdc2_format.rt];
 244
 245                        StoreHW(addr, value, res);
 246                        if (res)
 247                                goto fault;
 248
 249                        break;
 250                case 0x2:
 251                        if (!access_ok(addr, 4))
 252                                goto sigbus;
 253
 254                        compute_return_epc(regs);
 255                        value = regs->regs[insn.loongson3_lsdc2_format.rt];
 256
 257                        StoreW(addr, value, res);
 258                        if (res)
 259                                goto fault;
 260
 261                        break;
 262                case 0x3:
 263                        if (!access_ok(addr, 8))
 264                                goto sigbus;
 265
 266                        compute_return_epc(regs);
 267                        value = regs->regs[insn.loongson3_lsdc2_format.rt];
 268
 269                        StoreDW(addr, value, res);
 270                        if (res)
 271                                goto fault;
 272
 273                        break;
 274
 275                case 0x6:
 276                        die_if_kernel("Unaligned FP access in kernel code", regs);
 277                        BUG_ON(!used_math());
 278
 279                        if (!access_ok(addr, 4))
 280                                goto sigbus;
 281
 282                        lose_fpu(1);
 283                        value = get_fpr64(&current->thread.fpu.fpr[insn.loongson3_lsdc2_format.rt], 0);
 284
 285                        StoreW(addr, value, res);
 286                        if (res)
 287                                goto fault;
 288
 289                        compute_return_epc(regs);
 290                        own_fpu(1);
 291
 292                        break;
 293                case 0x7:
 294                        die_if_kernel("Unaligned FP access in kernel code", regs);
 295                        BUG_ON(!used_math());
 296
 297                        if (!access_ok(addr, 8))
 298                                goto sigbus;
 299
 300                        lose_fpu(1);
 301                        value = get_fpr64(&current->thread.fpu.fpr[insn.loongson3_lsdc2_format.rt], 0);
 302
 303                        StoreDW(addr, value, res);
 304                        if (res)
 305                                goto fault;
 306
 307                        compute_return_epc(regs);
 308                        own_fpu(1);
 309
 310                        break;
 311                }
 312                return NOTIFY_STOP;     /* Don't call default notifier */
 313        }
 314
 315        return NOTIFY_OK;               /* Let default notifier send signals */
 316
 317fault:
 318        /* roll back jump/branch */
 319        regs->regs[31] = ra;
 320        regs->cp0_epc = (unsigned long)pc;
 321        /* Did we have an exception handler installed? */
 322        if (fixup_exception(regs))
 323                return NOTIFY_STOP;     /* Don't call default notifier */
 324
 325        die_if_kernel("Unhandled kernel unaligned access", regs);
 326        force_sig(SIGSEGV);
 327
 328        return NOTIFY_STOP;     /* Don't call default notifier */
 329
 330sigbus:
 331        die_if_kernel("Unhandled kernel unaligned access", regs);
 332        force_sig(SIGBUS);
 333
 334        return NOTIFY_STOP;     /* Don't call default notifier */
 335}
 336
 337static int __init loongson_cu2_setup(void)
 338{
 339        return cu2_notifier(loongson_cu2_call, 0);
 340}
 341early_initcall(loongson_cu2_setup);
 342