sim/testsuite/sim/bfin/se_usermode_protviol.S

   1 //Original:/proj/frio/dv/testcases/seq/se_usermode_protviol/se_usermode_protviol.dsp
   2 // Description: User mode "Illegal Use Supervsor Resource" Exceptions
   3 # mach: bfin
   4 # sim: --environment operating
   5
   6 #include "test.h"
   7 .include "testutils.inc"
   8 start
   9
  10 //
  11 // Constants and Defines
  12 //
  13
  14 include(gen_int.inc)
  15 include(selfcheck.inc)
  16 include(std.inc)
  17 include(mmrs.inc)
  18 include(symtable.inc)
  19
  20 #ifndef STACKSIZE
  21 #define STACKSIZE 0x100   // change for how much stack you need
  22 #endif
  23 #ifndef ITABLE
  24 #define ITABLE 0xF0000000
  25 #endif
  26
  27 GEN_INT_INIT(ITABLE) // set location for interrupt table
  28
  29 //
  30 // Reset/Bootstrap Code
  31 //   (Here we should set the processor operating modes, initialize registers,
  32 //    etc.)
  33 //
  34
  35 BOOT:
  36 INIT_R_REGS(0);     // initialize general purpose regs
  37
  38 INIT_P_REGS(0);     // initialize the pointers
  39
  40 INIT_I_REGS(0);     // initialize the dsp address regs
  41 INIT_M_REGS(0);
  42 INIT_L_REGS(0);
  43 INIT_B_REGS(0);
  44
  45 CLI R1;           // inhibit events during MMR writes
  46
  47 LD32_LABEL(sp, USTACK);   // setup the user stack pointer
  48 USP = SP;
  49
  50 LD32_LABEL(sp, KSTACK);   // setup the kernel stack pointer
  51 FP = SP;        // and frame pointer
  52
  53 LD32(p0, EVT0);      // Setup Event Vectors and Handlers
  54
  55     P0 += 4;            // EVT0 not used (Emulation)
  56
  57     P0 += 4;            // EVT1 not used (Reset)
  58
  59 LD32_LABEL(r0, NHANDLE);  // NMI Handler (Int2)
  60     [ P0 ++ ] = R0;
  61
  62 LD32_LABEL(r0, XHANDLE);  // Exception Handler (Int3)
  63     [ P0 ++ ] = R0;
  64
  65     P0 += 4;            // EVT4 not used (Global Interrupt Enable)
  66
  67 LD32_LABEL(r0, HWHANDLE); // HW Error Handler (Int5)
  68     [ P0 ++ ] = R0;
  69
  70 LD32_LABEL(r0, THANDLE);  // Timer Handler (Int6)
  71     [ P0 ++ ] = R0;
  72
  73 LD32_LABEL(r0, I7HANDLE); // IVG7 Handler
  74     [ P0 ++ ] = R0;
  75
  76 LD32_LABEL(r0, I8HANDLE); // IVG8 Handler
  77     [ P0 ++ ] = R0;
  78
  79 LD32_LABEL(r0, I9HANDLE); // IVG9 Handler
  80     [ P0 ++ ] = R0;
  81
  82 LD32_LABEL(r0, I10HANDLE);// IVG10 Handler
  83     [ P0 ++ ] = R0;
  84
  85 LD32_LABEL(r0, I11HANDLE);// IVG11 Handler
  86     [ P0 ++ ] = R0;
  87
  88 LD32_LABEL(r0, I12HANDLE);// IVG12 Handler
  89     [ P0 ++ ] = R0;
  90
  91 LD32_LABEL(r0, I13HANDLE);// IVG13 Handler
  92     [ P0 ++ ] = R0;
  93
  94 LD32_LABEL(r0, I14HANDLE);// IVG14 Handler
  95     [ P0 ++ ] = R0;
  96
  97 LD32_LABEL(r0, I15HANDLE);// IVG15 Handler
  98     [ P0 ++ ] = R0;
  99
 100 LD32(p0, EVT_OVERRIDE);
 101     R0 = 0;
 102     [ P0 ++ ] = R0;
 103
 104     R1 = -1;     // Change this to mask interrupts (*)
 105 CSYNC;       // wait for MMR writes to finish
 106 STI R1;      // sync and reenable events (implicit write to IMASK)
 107
 108 DUMMY:
 109
 110     R0 = 0 (Z);
 111
 112 LT0 = r0;       // set loop counters to something deterministic
 113 LB0 = r0;
 114 LC0 = r0;
 115 LT1 = r0;
 116 LB1 = r0;
 117 LC1 = r0;
 118
 119 ASTAT = r0;     // reset other internal regs
 120 SYSCFG = r0;
 121 RETS = r0;      // prevent X's breaking LINK instruction
 122
 123 RETI = r0;      // prevent Xs later on
 124 RETX = r0;
 125 RETN = r0;
 126 RETE = r0;
 127
 128
 129 // The following code sets up the test for running in USER mode
 130
 131 LD32_LABEL(r0, STARTUSER);// One gets to user mode by doing a
 132                         // ReturnFromInterrupt (RTI)
 133 RETI = r0;      // We need to load the return address
 134
 135 // Comment the following line for a USER Mode test
 136
 137 //    JUMP    STARTSUP;   // jump to code start for SUPERVISOR mode
 138
 139 RTI;
 140
 141 STARTSUP:
 142 LD32_LABEL(p1, BEGIN);
 143
 144 LD32(p0, EVT15);
 145
 146 CLI R1;   // inhibit events during write to MMR
 147     [ P0 ] = P1;  // IVG15 (General) handler (Int 15) load with start
 148 CSYNC;      // wait for it
 149 STI R1;     // reenable events with proper imask
 150
 151 RAISE 15;       // after we RTI, INT 15 should be taken
 152
 153 RTI;
 154
 155 //
 156 // The Main Program
 157 //
 158
 159 STARTUSER:
 160
 161 LD32_LABEL(sp, USTACK);   // setup the user stack pointer
 162 FP = SP;
 163 LINK 0;     // change for how much stack frame space you need.
 164
 165 JUMP BEGIN;
 166
 167 //*********************************************************************
 168
 169 BEGIN:
 170
 171                 // COMMENT the following line for USER MODE tests
 172 //    [--sp] = RETI;  // enable interrupts in supervisor mode
 173
 174     R0 = 0;
 175     R1 = -1;
 176
 177 // the following instructions should EXCEPT
 178     R6 = 0x2E;      // EXCAUSE 0x2E means Illegal Use Supervidor Resource
 179
 180 RAISE 15;
 181 CLI R0;
 182 STI r0;
 183 //    TESTSET (p0);  // now allowed in user mode
 184 r5 += 1;
 185 //    IDLE;          // works in user mode
 186
 187 USP = r1;
 188 SEQSTAT = r1;
 189 SYSCFG = r1;
 190 RETI = r1;
 191 RETX = r1;
 192 RETN = r1;
 193 RETE = r1;
 194
 195     R2 = USP;
 196     R2 = SEQSTAT;
 197     R2 = SYSCFG;
 198     R2 = RETI;
 199     R2 = RETX;
 200     R2 = RETN;
 201     R2 = RETE;
 202
 203     [ -- SP ] = USP;
 204     [ -- SP ] = SEQSTAT;
 205     [ -- SP ] = SYSCFG;
 206     [ -- SP ] = RETI;
 207     [ -- SP ] = RETX;
 208     [ -- SP ] = RETN;
 209     [ -- SP ] = RETE;
 210
 211 SEQSTAT = [sp++];
 212 SYSCFG = [sp++];
 213 RETI = [sp++];
 214 RETX = [sp++];
 215 RETN = [sp++];
 216 RETE = [sp++];
 217
 218 RTX;
 219 RTN;
 220 RTI;
 221 RTE;
 222
 223     R6 = 0x22;      // EXCAUSE 0x22 means Illegal Insn Combination
 224 USP = [sp++];
 225
 226 CHECK_INIT_DEF(p0); //CHECK_INIT(p0, 0xFF7FFFFC);
 227                     // Xhandler counts all EXCAUSE = 0x2B;
 228 CHECKREG(r5, 36); // count of all IF protection violations.
 229
 230 END:
 231 dbg_pass;            // End the test
 232
 233 //*********************************************************************
 234
 235 //
 236 // Handlers for Events
 237 //
 238
 239 NHANDLE:            // NMI Handler 2
 240 RTN;
 241
 242 XHANDLE:            // Exception Handler 3
 243     [ -- SP ] = ASTAT; // save what we damage
 244     [ -- SP ] = ( R7:6 );
 245     R7 = SEQSTAT;
 246     R7 <<= 26;
 247     R7 >>= 26;      // only want EXCAUSE
 248 CC = r7 == r6;
 249 IF CC JUMP IFETCHPROTVIOL;   // If EXCAUSE != 0x2E then leave
 250
 251 dbg_fail;       // if the EXCAUSE is wrong the test will infinite loop
 252
 253 IFETCHPROTVIOL:
 254     R7 = RETX;      // Fix up return address
 255     R7 += 2;        // skip instruction
 256 RETX = r7;      // and put back in RETX
 257
 258     R5 += 1;        // Count
 259
 260 OUT:
 261     ( R7:6 ) = [ SP ++ ];
 262 ASTAT = [sp++];
 263 RTX;
 264
 265 HWHANDLE:           // HW Error Handler 5
 266 RTI;
 267
 268 THANDLE:            // Timer Handler 6
 269 RTI;
 270
 271 I7HANDLE:           // IVG 7 Handler
 272 RTI;
 273
 274 I8HANDLE:           // IVG 8 Handler
 275 RTI;
 276
 277 I9HANDLE:           // IVG 9 Handler
 278 RTI;
 279
 280 I10HANDLE:          // IVG 10 Handler
 281 RTI;
 282
 283 I11HANDLE:          // IVG 11 Handler
 284 RTI;
 285
 286 I12HANDLE:          // IVG 12 Handler
 287 RTI;
 288
 289 I13HANDLE:          // IVG 13 Handler
 290 RTI;
 291
 292 I14HANDLE:          // IVG 14 Handler
 293 RTI;
 294
 295 I15HANDLE:          // IVG 15 Handler
 296 RTI;
 297
 298
 299     // padding for the icache
 300
 301 EXCPT 0; EXCPT 0; EXCPT 0; EXCPT 0; EXCPT 0; EXCPT 0; EXCPT 0;
 302
 303 //
 304 // Data Segment
 305 //
 306
 307 .data
 308 DATA:
 309     .space (0x10);
 310
 311 // Stack Segments (Both Kernel and User)
 312
 313     .space (STACKSIZE);
 314 KSTACK:
 315
 316     .space (STACKSIZE);
 317 USTACK: