| 1 |
// SPDX-License-Identifier: GPL-2.0-or-later |
| 2 |
/* |
| 3 |
* Copyright (C) 2001,2002,2003 Broadcom Corporation |
| 4 |
*/ |
| 5 |
#include <linux/sched.h> |
| 6 |
#include <asm/mipsregs.h> |
| 7 |
#include <asm/sibyte/sb1250.h> |
| 8 |
#include <asm/sibyte/sb1250_regs.h> |
| 9 |
|
| 10 |
#if !defined(CONFIG_SIBYTE_BUS_WATCHER) || defined(CONFIG_SIBYTE_BW_TRACE) |
| 11 |
#include <asm/io.h> |
| 12 |
#include <asm/sibyte/sb1250_scd.h> |
| 13 |
#endif |
| 14 |
|
| 15 |
/* |
| 16 |
* We'd like to dump the L2_ECC_TAG register on errors, but errata make |
| 17 |
* that unsafe... So for now we don't. (BCM1250/BCM112x erratum SOC-48.) |
| 18 |
*/ |
| 19 |
#undef DUMP_L2_ECC_TAG_ON_ERROR |
| 20 |
|
| 21 |
/* SB1 definitions */ |
| 22 |
|
| 23 |
/* XXX should come from config1 XXX */ |
| 24 |
#define SB1_CACHE_INDEX_MASK 0x1fe0 |
| 25 |
|
| 26 |
#define CP0_ERRCTL_RECOVERABLE (1 << 31) |
| 27 |
#define CP0_ERRCTL_DCACHE (1 << 30) |
| 28 |
#define CP0_ERRCTL_ICACHE (1 << 29) |
| 29 |
#define CP0_ERRCTL_MULTIBUS (1 << 23) |
| 30 |
#define CP0_ERRCTL_MC_TLB (1 << 15) |
| 31 |
#define CP0_ERRCTL_MC_TIMEOUT (1 << 14) |
| 32 |
|
| 33 |
#define CP0_CERRI_TAG_PARITY (1 << 29) |
| 34 |
#define CP0_CERRI_DATA_PARITY (1 << 28) |
| 35 |
#define CP0_CERRI_EXTERNAL (1 << 26) |
| 36 |
|
| 37 |
#define CP0_CERRI_IDX_VALID(c) (!((c) & CP0_CERRI_EXTERNAL)) |
| 38 |
#define CP0_CERRI_DATA (CP0_CERRI_DATA_PARITY) |
| 39 |
|
| 40 |
#define CP0_CERRD_MULTIPLE (1 << 31) |
| 41 |
#define CP0_CERRD_TAG_STATE (1 << 30) |
| 42 |
#define CP0_CERRD_TAG_ADDRESS (1 << 29) |
| 43 |
#define CP0_CERRD_DATA_SBE (1 << 28) |
| 44 |
#define CP0_CERRD_DATA_DBE (1 << 27) |
| 45 |
#define CP0_CERRD_EXTERNAL (1 << 26) |
| 46 |
#define CP0_CERRD_LOAD (1 << 25) |
| 47 |
#define CP0_CERRD_STORE (1 << 24) |
| 48 |
#define CP0_CERRD_FILLWB (1 << 23) |
| 49 |
#define CP0_CERRD_COHERENCY (1 << 22) |
| 50 |
#define CP0_CERRD_DUPTAG (1 << 21) |
| 51 |
|
| 52 |
#define CP0_CERRD_DPA_VALID(c) (!((c) & CP0_CERRD_EXTERNAL)) |
| 53 |
#define CP0_CERRD_IDX_VALID(c) \ |
| 54 |
(((c) & (CP0_CERRD_LOAD | CP0_CERRD_STORE)) ? (!((c) & CP0_CERRD_EXTERNAL)) : 0) |
| 55 |
#define CP0_CERRD_CAUSES \ |
| 56 |
(CP0_CERRD_LOAD | CP0_CERRD_STORE | CP0_CERRD_FILLWB | CP0_CERRD_COHERENCY | CP0_CERRD_DUPTAG) |
| 57 |
#define CP0_CERRD_TYPES \ |
| 58 |
(CP0_CERRD_TAG_STATE | CP0_CERRD_TAG_ADDRESS | CP0_CERRD_DATA_SBE | CP0_CERRD_DATA_DBE | CP0_CERRD_EXTERNAL) |
| 59 |
#define CP0_CERRD_DATA (CP0_CERRD_DATA_SBE | CP0_CERRD_DATA_DBE) |
| 60 |
|
| 61 |
static uint32_t extract_ic(unsigned short addr, int data); |
| 62 |
static uint32_t extract_dc(unsigned short addr, int data); |
| 63 |
|
| 64 |
static inline void breakout_errctl(unsigned int val) |
| 65 |
{ |
| 66 |
if (val & CP0_ERRCTL_RECOVERABLE) |
| 67 |
printk(" recoverable"); |
| 68 |
if (val & CP0_ERRCTL_DCACHE) |
| 69 |
printk(" dcache"); |
| 70 |
if (val & CP0_ERRCTL_ICACHE) |
| 71 |
printk(" icache"); |
| 72 |
if (val & CP0_ERRCTL_MULTIBUS) |
| 73 |
printk(" multiple-buserr"); |
| 74 |
printk("\n"); |
| 75 |
} |
| 76 |
|
| 77 |
static inline void breakout_cerri(unsigned int val) |
| 78 |
{ |
| 79 |
if (val & CP0_CERRI_TAG_PARITY) |
| 80 |
printk(" tag-parity"); |
| 81 |
if (val & CP0_CERRI_DATA_PARITY) |
| 82 |
printk(" data-parity"); |
| 83 |
if (val & CP0_CERRI_EXTERNAL) |
| 84 |
printk(" external"); |
| 85 |
printk("\n"); |
| 86 |
} |
| 87 |
|
| 88 |
static inline void breakout_cerrd(unsigned int val) |
| 89 |
{ |
| 90 |
switch (val & CP0_CERRD_CAUSES) { |
| 91 |
case CP0_CERRD_LOAD: |
| 92 |
printk(" load,"); |
| 93 |
break; |
| 94 |
case CP0_CERRD_STORE: |
| 95 |
printk(" store,"); |
| 96 |
break; |
| 97 |
case CP0_CERRD_FILLWB: |
| 98 |
printk(" fill/wb,"); |
| 99 |
break; |
| 100 |
case CP0_CERRD_COHERENCY: |
| 101 |
printk(" coherency,"); |
| 102 |
break; |
| 103 |
case CP0_CERRD_DUPTAG: |
| 104 |
printk(" duptags,"); |
| 105 |
break; |
| 106 |
default: |
| 107 |
printk(" NO CAUSE,"); |
| 108 |
break; |
| 109 |
} |
| 110 |
if (!(val & CP0_CERRD_TYPES)) |
| 111 |
printk(" NO TYPE"); |
| 112 |
else { |
| 113 |
if (val & CP0_CERRD_MULTIPLE) |
| 114 |
printk(" multi-err"); |
| 115 |
if (val & CP0_CERRD_TAG_STATE) |
| 116 |
printk(" tag-state"); |
| 117 |
if (val & CP0_CERRD_TAG_ADDRESS) |
| 118 |
printk(" tag-address"); |
| 119 |
if (val & CP0_CERRD_DATA_SBE) |
| 120 |
printk(" data-SBE"); |
| 121 |
if (val & CP0_CERRD_DATA_DBE) |
| 122 |
printk(" data-DBE"); |
| 123 |
if (val & CP0_CERRD_EXTERNAL) |
| 124 |
printk(" external"); |
| 125 |
} |
| 126 |
printk("\n"); |
| 127 |
} |
| 128 |
|
| 129 |
#ifndef CONFIG_SIBYTE_BUS_WATCHER |
| 130 |
|
| 131 |
static void check_bus_watcher(void) |
| 132 |
{ |
| 133 |
uint32_t status, l2_err, memio_err; |
| 134 |
#ifdef DUMP_L2_ECC_TAG_ON_ERROR |
| 135 |
uint64_t l2_tag; |
| 136 |
#endif |
| 137 |
|
| 138 |
/* Destructive read, clears register and interrupt */ |
| 139 |
status = csr_in32(IOADDR(A_SCD_BUS_ERR_STATUS)); |
| 140 |
/* Bit 31 is always on, but there's no #define for that */ |
| 141 |
if (status & ~(1UL << 31)) { |
| 142 |
l2_err = csr_in32(IOADDR(A_BUS_L2_ERRORS)); |
| 143 |
#ifdef DUMP_L2_ECC_TAG_ON_ERROR |
| 144 |
l2_tag = in64(IOADDR(A_L2_ECC_TAG)); |
| 145 |
#endif |
| 146 |
memio_err = csr_in32(IOADDR(A_BUS_MEM_IO_ERRORS)); |
| 147 |
printk("Bus watcher error counters: %08x %08x\n", l2_err, memio_err); |
| 148 |
printk("\nLast recorded signature:\n"); |
| 149 |
printk("Request %02x from %d, answered by %d with Dcode %d\n", |
| 150 |
(unsigned int)(G_SCD_BERR_TID(status) & 0x3f), |
| 151 |
(int)(G_SCD_BERR_TID(status) >> 6), |
| 152 |
(int)G_SCD_BERR_RID(status), |
| 153 |
(int)G_SCD_BERR_DCODE(status)); |
| 154 |
#ifdef DUMP_L2_ECC_TAG_ON_ERROR |
| 155 |
printk("Last L2 tag w/ bad ECC: %016llx\n", l2_tag); |
| 156 |
#endif |
| 157 |
} else { |
| 158 |
printk("Bus watcher indicates no error\n"); |
| 159 |
} |
| 160 |
} |
| 161 |
#else |
| 162 |
extern void check_bus_watcher(void); |
| 163 |
#endif |
| 164 |
|
| 165 |
asmlinkage void sb1_cache_error(void) |
| 166 |
{ |
| 167 |
uint32_t errctl, cerr_i, cerr_d, dpalo, dpahi, eepc, res; |
| 168 |
unsigned long long cerr_dpa; |
| 169 |
|
| 170 |
#ifdef CONFIG_SIBYTE_BW_TRACE |
| 171 |
/* Freeze the trace buffer now */ |
| 172 |
csr_out32(M_SCD_TRACE_CFG_FREEZE, IOADDR(A_SCD_TRACE_CFG)); |
| 173 |
printk("Trace buffer frozen\n"); |
| 174 |
#endif |
| 175 |
|
| 176 |
printk("Cache error exception on CPU %x:\n", |
| 177 |
(read_c0_prid() >> 25) & 0x7); |
| 178 |
|
| 179 |
__asm__ __volatile__ ( |
| 180 |
" .set push\n\t" |
| 181 |
" .set mips64\n\t" |
| 182 |
" .set noat\n\t" |
| 183 |
" mfc0 %0, $26\n\t" |
| 184 |
" mfc0 %1, $27\n\t" |
| 185 |
" mfc0 %2, $27, 1\n\t" |
| 186 |
" dmfc0 $1, $27, 3\n\t" |
| 187 |
" dsrl32 %3, $1, 0 \n\t" |
| 188 |
" sll %4, $1, 0 \n\t" |
| 189 |
" mfc0 %5, $30\n\t" |
| 190 |
" .set pop" |
| 191 |
: "=r" (errctl), "=r" (cerr_i), "=r" (cerr_d), |
| 192 |
"=r" (dpahi), "=r" (dpalo), "=r" (eepc)); |
| 193 |
|
| 194 |
cerr_dpa = (((uint64_t)dpahi) << 32) | dpalo; |
| 195 |
printk(" c0_errorepc == %08x\n", eepc); |
| 196 |
printk(" c0_errctl == %08x", errctl); |
| 197 |
breakout_errctl(errctl); |
| 198 |
if (errctl & CP0_ERRCTL_ICACHE) { |
| 199 |
printk(" c0_cerr_i == %08x", cerr_i); |
| 200 |
breakout_cerri(cerr_i); |
| 201 |
if (CP0_CERRI_IDX_VALID(cerr_i)) { |
| 202 |
/* Check index of EPC, allowing for delay slot */ |
| 203 |
if (((eepc & SB1_CACHE_INDEX_MASK) != (cerr_i & SB1_CACHE_INDEX_MASK)) && |
| 204 |
((eepc & SB1_CACHE_INDEX_MASK) != ((cerr_i & SB1_CACHE_INDEX_MASK) - 4))) |
| 205 |
printk(" cerr_i idx doesn't match eepc\n"); |
| 206 |
else { |
| 207 |
res = extract_ic(cerr_i & SB1_CACHE_INDEX_MASK, |
| 208 |
(cerr_i & CP0_CERRI_DATA) != 0); |
| 209 |
if (!(res & cerr_i)) |
| 210 |
printk("...didn't see indicated icache problem\n"); |
| 211 |
} |
| 212 |
} |
| 213 |
} |
| 214 |
if (errctl & CP0_ERRCTL_DCACHE) { |
| 215 |
printk(" c0_cerr_d == %08x", cerr_d); |
| 216 |
breakout_cerrd(cerr_d); |
| 217 |
if (CP0_CERRD_DPA_VALID(cerr_d)) { |
| 218 |
printk(" c0_cerr_dpa == %010llx\n", cerr_dpa); |
| 219 |
if (!CP0_CERRD_IDX_VALID(cerr_d)) { |
| 220 |
res = extract_dc(cerr_dpa & SB1_CACHE_INDEX_MASK, |
| 221 |
(cerr_d & CP0_CERRD_DATA) != 0); |
| 222 |
if (!(res & cerr_d)) |
| 223 |
printk("...didn't see indicated dcache problem\n"); |
| 224 |
} else { |
| 225 |
if ((cerr_dpa & SB1_CACHE_INDEX_MASK) != (cerr_d & SB1_CACHE_INDEX_MASK)) |
| 226 |
printk(" cerr_d idx doesn't match cerr_dpa\n"); |
| 227 |
else { |
| 228 |
res = extract_dc(cerr_d & SB1_CACHE_INDEX_MASK, |
| 229 |
(cerr_d & CP0_CERRD_DATA) != 0); |
| 230 |
if (!(res & cerr_d)) |
| 231 |
printk("...didn't see indicated problem\n"); |
| 232 |
} |
| 233 |
} |
| 234 |
} |
| 235 |
} |
| 236 |
|
| 237 |
check_bus_watcher(); |
| 238 |
|
| 239 |
/* |
| 240 |
* Calling panic() when a fatal cache error occurs scrambles the |
| 241 |
* state of the system (and the cache), making it difficult to |
| 242 |
* investigate after the fact. However, if you just stall the CPU, |
| 243 |
* the other CPU may keep on running, which is typically very |
| 244 |
* undesirable. |
| 245 |
*/ |
| 246 |
#ifdef CONFIG_SB1_CERR_STALL |
| 247 |
while (1) |
| 248 |
; |
| 249 |
#else |
| 250 |
panic("unhandled cache error"); |
| 251 |
#endif |
| 252 |
} |
| 253 |
|
| 254 |
|
| 255 |
/* Parity lookup table. */ |
| 256 |
static const uint8_t parity[256] = { |
| 257 |
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, |
| 258 |
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, |
| 259 |
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, |
| 260 |
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, |
| 261 |
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, |
| 262 |
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, |
| 263 |
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, |
| 264 |
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, |
| 265 |
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, |
| 266 |
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, |
| 267 |
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, |
| 268 |
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, |
| 269 |
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, |
| 270 |
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, |
| 271 |
1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, |
| 272 |
0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 |
| 273 |
}; |
| 274 |
|
| 275 |
/* Masks to select bits for Hamming parity, mask_72_64[i] for bit[i] */ |
| 276 |
static const uint64_t mask_72_64[8] = { |
| 277 |
0x0738C808099264FFULL, |
| 278 |
0x38C808099264FF07ULL, |
| 279 |
0xC808099264FF0738ULL, |
| 280 |
0x08099264FF0738C8ULL, |
| 281 |
0x099264FF0738C808ULL, |
| 282 |
0x9264FF0738C80809ULL, |
| 283 |
0x64FF0738C8080992ULL, |
| 284 |
0xFF0738C808099264ULL |
| 285 |
}; |
| 286 |
|
| 287 |
/* Calculate the parity on a range of bits */ |
| 288 |
static char range_parity(uint64_t dword, int max, int min) |
| 289 |
{ |
| 290 |
char parity = 0; |
| 291 |
int i; |
| 292 |
dword >>= min; |
| 293 |
for (i=max-min; i>=0; i--) { |
| 294 |
if (dword & 0x1) |
| 295 |
parity = !parity; |
| 296 |
dword >>= 1; |
| 297 |
} |
| 298 |
return parity; |
| 299 |
} |
| 300 |
|
| 301 |
/* Calculate the 4-bit even byte-parity for an instruction */ |
| 302 |
static unsigned char inst_parity(uint32_t word) |
| 303 |
{ |
| 304 |
int i, j; |
| 305 |
char parity = 0; |
| 306 |
for (j=0; j<4; j++) { |
| 307 |
char byte_parity = 0; |
| 308 |
for (i=0; i<8; i++) { |
| 309 |
if (word & 0x80000000) |
| 310 |
byte_parity = !byte_parity; |
| 311 |
word <<= 1; |
| 312 |
} |
| 313 |
parity <<= 1; |
| 314 |
parity |= byte_parity; |
| 315 |
} |
| 316 |
return parity; |
| 317 |
} |
| 318 |
|
| 319 |
static uint32_t extract_ic(unsigned short addr, int data) |
| 320 |
{ |
| 321 |
unsigned short way; |
| 322 |
int valid; |
| 323 |
uint32_t taghi, taglolo, taglohi; |
| 324 |
unsigned long long taglo, va; |
| 325 |
uint64_t tlo_tmp; |
| 326 |
uint8_t lru; |
| 327 |
int res = 0; |
| 328 |
|
| 329 |
printk("Icache index 0x%04x ", addr); |
| 330 |
for (way = 0; way < 4; way++) { |
| 331 |
/* Index-load-tag-I */ |
| 332 |
__asm__ __volatile__ ( |
| 333 |
" .set push \n\t" |
| 334 |
" .set noreorder \n\t" |
| 335 |
" .set mips64 \n\t" |
| 336 |
" .set noat \n\t" |
| 337 |
" cache 4, 0(%3) \n\t" |
| 338 |
" mfc0 %0, $29 \n\t" |
| 339 |
" dmfc0 $1, $28 \n\t" |
| 340 |
" dsrl32 %1, $1, 0 \n\t" |
| 341 |
" sll %2, $1, 0 \n\t" |
| 342 |
" .set pop" |
| 343 |
: "=r" (taghi), "=r" (taglohi), "=r" (taglolo) |
| 344 |
: "r" ((way << 13) | addr)); |
| 345 |
|
| 346 |
taglo = ((unsigned long long)taglohi << 32) | taglolo; |
| 347 |
if (way == 0) { |
| 348 |
lru = (taghi >> 14) & 0xff; |
| 349 |
printk("[Bank %d Set 0x%02x] LRU > %d %d %d %d > MRU\n", |
| 350 |
((addr >> 5) & 0x3), /* bank */ |
| 351 |
((addr >> 7) & 0x3f), /* index */ |
| 352 |
(lru & 0x3), |
| 353 |
((lru >> 2) & 0x3), |
| 354 |
((lru >> 4) & 0x3), |
| 355 |
((lru >> 6) & 0x3)); |
| 356 |
} |
| 357 |
va = (taglo & 0xC0000FFFFFFFE000ULL) | addr; |
| 358 |
if ((taglo & (1 << 31)) && (((taglo >> 62) & 0x3) == 3)) |
| 359 |
va |= 0x3FFFF00000000000ULL; |
| 360 |
valid = ((taghi >> 29) & 1); |
| 361 |
if (valid) { |
| 362 |
tlo_tmp = taglo & 0xfff3ff; |
| 363 |
if (((taglo >> 10) & 1) ^ range_parity(tlo_tmp, 23, 0)) { |
| 364 |
printk(" ** bad parity in VTag0/G/ASID\n"); |
| 365 |
res |= CP0_CERRI_TAG_PARITY; |
| 366 |
} |
| 367 |
if (((taglo >> 11) & 1) ^ range_parity(taglo, 63, 24)) { |
| 368 |
printk(" ** bad parity in R/VTag1\n"); |
| 369 |
res |= CP0_CERRI_TAG_PARITY; |
| 370 |
} |
| 371 |
} |
| 372 |
if (valid ^ ((taghi >> 27) & 1)) { |
| 373 |
printk(" ** bad parity for valid bit\n"); |
| 374 |
res |= CP0_CERRI_TAG_PARITY; |
| 375 |
} |
| 376 |
printk(" %d [VA %016llx] [Vld? %d] raw tags: %08X-%016llX\n", |
| 377 |
way, va, valid, taghi, taglo); |
| 378 |
|
| 379 |
if (data) { |
| 380 |
uint32_t datahi, insta, instb; |
| 381 |
uint8_t predecode; |
| 382 |
int offset; |
| 383 |
|
| 384 |
/* (hit all banks and ways) */ |
| 385 |
for (offset = 0; offset < 4; offset++) { |
| 386 |
/* Index-load-data-I */ |
| 387 |
__asm__ __volatile__ ( |
| 388 |
" .set push\n\t" |
| 389 |
" .set noreorder\n\t" |
| 390 |
" .set mips64\n\t" |
| 391 |
" .set noat\n\t" |
| 392 |
" cache 6, 0(%3) \n\t" |
| 393 |
" mfc0 %0, $29, 1\n\t" |
| 394 |
" dmfc0 $1, $28, 1\n\t" |
| 395 |
" dsrl32 %1, $1, 0 \n\t" |
| 396 |
" sll %2, $1, 0 \n\t" |
| 397 |
" .set pop \n" |
| 398 |
: "=r" (datahi), "=r" (insta), "=r" (instb) |
| 399 |
: "r" ((way << 13) | addr | (offset << 3))); |
| 400 |
predecode = (datahi >> 8) & 0xff; |
| 401 |
if (((datahi >> 16) & 1) != (uint32_t)range_parity(predecode, 7, 0)) { |
| 402 |
printk(" ** bad parity in predecode\n"); |
| 403 |
res |= CP0_CERRI_DATA_PARITY; |
| 404 |
} |
| 405 |
/* XXXKW should/could check predecode bits themselves */ |
| 406 |
if (((datahi >> 4) & 0xf) ^ inst_parity(insta)) { |
| 407 |
printk(" ** bad parity in instruction a\n"); |
| 408 |
res |= CP0_CERRI_DATA_PARITY; |
| 409 |
} |
| 410 |
if ((datahi & 0xf) ^ inst_parity(instb)) { |
| 411 |
printk(" ** bad parity in instruction b\n"); |
| 412 |
res |= CP0_CERRI_DATA_PARITY; |
| 413 |
} |
| 414 |
printk(" %05X-%08X%08X", datahi, insta, instb); |
| 415 |
} |
| 416 |
printk("\n"); |
| 417 |
} |
| 418 |
} |
| 419 |
return res; |
| 420 |
} |
| 421 |
|
| 422 |
/* Compute the ECC for a data doubleword */ |
| 423 |
static uint8_t dc_ecc(uint64_t dword) |
| 424 |
{ |
| 425 |
uint64_t t; |
| 426 |
uint32_t w; |
| 427 |
uint8_t p; |
| 428 |
int i; |
| 429 |
|
| 430 |
p = 0; |
| 431 |
for (i = 7; i >= 0; i--) |
| 432 |
{ |
| 433 |
p <<= 1; |
| 434 |
t = dword & mask_72_64[i]; |
| 435 |
w = (uint32_t)(t >> 32); |
| 436 |
p ^= (parity[w>>24] ^ parity[(w>>16) & 0xFF] |
| 437 |
^ parity[(w>>8) & 0xFF] ^ parity[w & 0xFF]); |
| 438 |
w = (uint32_t)(t & 0xFFFFFFFF); |
| 439 |
p ^= (parity[w>>24] ^ parity[(w>>16) & 0xFF] |
| 440 |
^ parity[(w>>8) & 0xFF] ^ parity[w & 0xFF]); |
| 441 |
} |
| 442 |
return p; |
| 443 |
} |
| 444 |
|
| 445 |
struct dc_state { |
| 446 |
unsigned char val; |
| 447 |
char *name; |
| 448 |
}; |
| 449 |
|
| 450 |
static struct dc_state dc_states[] = { |
| 451 |
{ 0x00, "INVALID" }, |
| 452 |
{ 0x0f, "COH-SHD" }, |
| 453 |
{ 0x13, "NCO-E-C" }, |
| 454 |
{ 0x19, "NCO-E-D" }, |
| 455 |
{ 0x16, "COH-E-C" }, |
| 456 |
{ 0x1c, "COH-E-D" }, |
| 457 |
{ 0xff, "*ERROR*" } |
| 458 |
}; |
| 459 |
|
| 460 |
#define DC_TAG_VALID(state) \ |
| 461 |
(((state) == 0x0) || ((state) == 0xf) || ((state) == 0x13) || \ |
| 462 |
((state) == 0x19) || ((state) == 0x16) || ((state) == 0x1c)) |
| 463 |
|
| 464 |
static char *dc_state_str(unsigned char state) |
| 465 |
{ |
| 466 |
struct dc_state *dsc = dc_states; |
| 467 |
while (dsc->val != 0xff) { |
| 468 |
if (dsc->val == state) |
| 469 |
break; |
| 470 |
dsc++; |
| 471 |
} |
| 472 |
return dsc->name; |
| 473 |
} |
| 474 |
|
| 475 |
static uint32_t extract_dc(unsigned short addr, int data) |
| 476 |
{ |
| 477 |
int valid, way; |
| 478 |
unsigned char state; |
| 479 |
uint32_t taghi, taglolo, taglohi; |
| 480 |
unsigned long long taglo, pa; |
| 481 |
uint8_t ecc, lru; |
| 482 |
int res = 0; |
| 483 |
|
| 484 |
printk("Dcache index 0x%04x ", addr); |
| 485 |
for (way = 0; way < 4; way++) { |
| 486 |
__asm__ __volatile__ ( |
| 487 |
" .set push\n\t" |
| 488 |
" .set noreorder\n\t" |
| 489 |
" .set mips64\n\t" |
| 490 |
" .set noat\n\t" |
| 491 |
" cache 5, 0(%3)\n\t" /* Index-load-tag-D */ |
| 492 |
" mfc0 %0, $29, 2\n\t" |
| 493 |
" dmfc0 $1, $28, 2\n\t" |
| 494 |
" dsrl32 %1, $1, 0\n\t" |
| 495 |
" sll %2, $1, 0\n\t" |
| 496 |
" .set pop" |
| 497 |
: "=r" (taghi), "=r" (taglohi), "=r" (taglolo) |
| 498 |
: "r" ((way << 13) | addr)); |
| 499 |
|
| 500 |
taglo = ((unsigned long long)taglohi << 32) | taglolo; |
| 501 |
pa = (taglo & 0xFFFFFFE000ULL) | addr; |
| 502 |
if (way == 0) { |
| 503 |
lru = (taghi >> 14) & 0xff; |
| 504 |
printk("[Bank %d Set 0x%02x] LRU > %d %d %d %d > MRU\n", |
| 505 |
((addr >> 11) & 0x2) | ((addr >> 5) & 1), /* bank */ |
| 506 |
((addr >> 6) & 0x3f), /* index */ |
| 507 |
(lru & 0x3), |
| 508 |
((lru >> 2) & 0x3), |
| 509 |
((lru >> 4) & 0x3), |
| 510 |
((lru >> 6) & 0x3)); |
| 511 |
} |
| 512 |
state = (taghi >> 25) & 0x1f; |
| 513 |
valid = DC_TAG_VALID(state); |
| 514 |
printk(" %d [PA %010llx] [state %s (%02x)] raw tags: %08X-%016llX\n", |
| 515 |
way, pa, dc_state_str(state), state, taghi, taglo); |
| 516 |
if (valid) { |
| 517 |
if (((taglo >> 11) & 1) ^ range_parity(taglo, 39, 26)) { |
| 518 |
printk(" ** bad parity in PTag1\n"); |
| 519 |
res |= CP0_CERRD_TAG_ADDRESS; |
| 520 |
} |
| 521 |
if (((taglo >> 10) & 1) ^ range_parity(taglo, 25, 13)) { |
| 522 |
printk(" ** bad parity in PTag0\n"); |
| 523 |
res |= CP0_CERRD_TAG_ADDRESS; |
| 524 |
} |
| 525 |
} else { |
| 526 |
res |= CP0_CERRD_TAG_STATE; |
| 527 |
} |
| 528 |
|
| 529 |
if (data) { |
| 530 |
uint32_t datalohi, datalolo, datahi; |
| 531 |
unsigned long long datalo; |
| 532 |
int offset; |
| 533 |
char bad_ecc = 0; |
| 534 |
|
| 535 |
for (offset = 0; offset < 4; offset++) { |
| 536 |
/* Index-load-data-D */ |
| 537 |
__asm__ __volatile__ ( |
| 538 |
" .set push\n\t" |
| 539 |
" .set noreorder\n\t" |
| 540 |
" .set mips64\n\t" |
| 541 |
" .set noat\n\t" |
| 542 |
" cache 7, 0(%3)\n\t" /* Index-load-data-D */ |
| 543 |
" mfc0 %0, $29, 3\n\t" |
| 544 |
" dmfc0 $1, $28, 3\n\t" |
| 545 |
" dsrl32 %1, $1, 0 \n\t" |
| 546 |
" sll %2, $1, 0 \n\t" |
| 547 |
" .set pop" |
| 548 |
: "=r" (datahi), "=r" (datalohi), "=r" (datalolo) |
| 549 |
: "r" ((way << 13) | addr | (offset << 3))); |
| 550 |
datalo = ((unsigned long long)datalohi << 32) | datalolo; |
| 551 |
ecc = dc_ecc(datalo); |
| 552 |
if (ecc != datahi) { |
| 553 |
int bits; |
| 554 |
bad_ecc |= 1 << (3-offset); |
| 555 |
ecc ^= datahi; |
| 556 |
bits = hweight8(ecc); |
| 557 |
res |= (bits == 1) ? CP0_CERRD_DATA_SBE : CP0_CERRD_DATA_DBE; |
| 558 |
} |
| 559 |
printk(" %02X-%016llX", datahi, datalo); |
| 560 |
} |
| 561 |
printk("\n"); |
| 562 |
if (bad_ecc) |
| 563 |
printk(" dwords w/ bad ECC: %d %d %d %d\n", |
| 564 |
!!(bad_ecc & 8), !!(bad_ecc & 4), |
| 565 |
!!(bad_ecc & 2), !!(bad_ecc & 1)); |
| 566 |
} |
| 567 |
} |
| 568 |
return res; |
| 569 |
} |