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(¤t->thread.fpu.fpr[insn.loongson3_lswc2_format.rt], 0, value); 99 set_fpr64(¤t->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(¤t->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(¤t->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(¤t->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(¤t->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(¤t->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(¤t->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