1 /* 2 * arm co-processors 3 * CP15 (system control) is the one that gets used the most in practice. 4 */ 5 #include "u.h" 6 #include "../port/lib.h" 7 #include "mem.h" 8 #include "dat.h" 9 #include "fns.h" 10 #include "io.h" 11 12 #include "arm.h" 13 14 #define MAP2PCSPACE(va, pc) ((uintptr)(va) & ~KSEGM | (pc) & KSEGM) 15 16 enum { 17 /* alternates: 0xe12fff1e BX (R14); last e is R14 */ 18 /* 0xe28ef000 B 0(R14); second e is R14 (ken) */ 19 Retinst = 0xe1a0f00e, /* MOVW R14, R15 */ 20 21 Fpproc = 10, /* for vfp 3+; also 11 for doubles */ 22 }; 23 24 void 25 cpwr(int cp, int op1, int crn, int crm, int op2, ulong val) 26 { 27 int s; 28 volatile ulong instr[2]; 29 void *pcaddr; 30 void (*fp)(ulong); 31 32 s = splhi(); 33 op1 &= 7; 34 op2 &= 7; 35 crn &= 017; 36 crm &= 017; 37 cp &= 017; 38 /* MCR. Rt will be R0. */ 39 instr[0] = 0xee000010 | 40 op1 << 21 | crn << 16 | cp << 8 | op2 << 5 | crm; 41 instr[1] = Retinst; 42 coherence(); 43 44 pcaddr = (void *)MAP2PCSPACE(instr, getcallerpc(&cp)); 45 cachedwbse(pcaddr, sizeof instr); 46 cacheiinv(); 47 48 fp = (void (*)(ulong))pcaddr; 49 (*fp)(val); 50 coherence(); 51 splx(s); 52 } 53 54 void 55 cpwrsc(int op1, int crn, int crm, int op2, ulong val) 56 { 57 cpwr(CpSC, op1, crn, crm, op2, val); 58 } 59 60 ulong 61 cprd(int cp, int op1, int crn, int crm, int op2) 62 { 63 int s; 64 ulong res; 65 volatile ulong instr[2]; 66 void *pcaddr; 67 ulong (*fp)(void); 68 69 s = splhi(); 70 op1 &= 7; 71 op2 &= 7; 72 crn &= 017; 73 crm &= 017; 74 /* 75 * MRC. return value will be in R0, which is convenient. 76 * Rt will be R0. 77 */ 78 instr[0] = 0xee100010 | 79 op1 << 21 | crn << 16 | cp << 8 | op2 << 5 | crm; 80 instr[1] = Retinst; 81 coherence(); 82 83 pcaddr = (void *)MAP2PCSPACE(instr, getcallerpc(&cp)); 84 cachedwbse(pcaddr, sizeof instr); 85 cacheiinv(); 86 87 fp = (ulong (*)(void))pcaddr; 88 res = (*fp)(); 89 splx(s); 90 return res; 91 } 92 93 ulong 94 cprdsc(int op1, int crn, int crm, int op2) 95 { 96 return cprd(CpSC, op1, crn, crm, op2); 97 } 98 99 /* floating point */ 100 101 ulong 102 fprd(int fpreg) 103 { 104 int s; 105 ulong res; 106 volatile ulong instr[2]; 107 void *pcaddr; 108 ulong (*fp)(void); 109 110 s = splhi(); 111 fpreg &= 017; 112 /* 113 * VMRS. return value will be in R0, which is convenient. 114 * Rt will be R0. 115 */ 116 instr[0] = 0xeef00010 | fpreg << 16 | 0 << 12 | Fpproc << 8; 117 instr[1] = Retinst; 118 coherence(); 119 120 pcaddr = (void *)MAP2PCSPACE(instr, getcallerpc(&fpreg)); 121 cachedwbse(pcaddr, sizeof instr); 122 cacheiinv(); 123 124 fp = (ulong (*)(void))pcaddr; 125 res = (*fp)(); 126 splx(s); 127 return res; 128 } 129 130 void 131 fpwr(int fpreg, ulong val) 132 { 133 int s; 134 volatile ulong instr[2]; 135 void *pcaddr; 136 void (*fp)(ulong); 137 138 s = splhi(); 139 fpreg &= 017; 140 /* VMSR. Rt will be R0. */ 141 instr[0] = 0xeee00010 | fpreg << 16 | 0 << 12 | Fpproc << 8; 142 instr[1] = Retinst; 143 coherence(); 144 145 pcaddr = (void *)MAP2PCSPACE(instr, getcallerpc(&fpreg)); 146 cachedwbse(pcaddr, sizeof instr); 147 cacheiinv(); 148 149 fp = (void (*)(ulong))pcaddr; 150 (*fp)(val); 151 coherence(); 152 splx(s); 153 } 154