1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * linux/arch/alpha/kernel/core_lca.c 4 * 5 * Written by David Mosberger (davidm@cs.arizona.edu) with some code 6 * taken from Dave Rusling's (david.rusling@reo.mts.dec.com) 32-bit 7 * bios code. 8 * 9 * Code common to all LCA core logic chips. 10 */ 11 12 #define __EXTERN_INLINE inline 13 #include <asm/io.h> 14 #include <asm/core_lca.h> 15 #undef __EXTERN_INLINE 16 17 #include <linux/types.h> 18 #include <linux/pci.h> 19 #include <linux/init.h> 20 #include <linux/tty.h> 21 22 #include <asm/ptrace.h> 23 #include <asm/irq_regs.h> 24 #include <asm/smp.h> 25 26 #include "proto.h" 27 #include "pci_impl.h" 28 29 30 /* 31 * BIOS32-style PCI interface: 32 */ 33 34 /* 35 * Machine check reasons. Defined according to PALcode sources 36 * (osf.h and platform.h). 37 */ 38 #define MCHK_K_TPERR 0x0080 39 #define MCHK_K_TCPERR 0x0082 40 #define MCHK_K_HERR 0x0084 41 #define MCHK_K_ECC_C 0x0086 42 #define MCHK_K_ECC_NC 0x0088 43 #define MCHK_K_UNKNOWN 0x008A 44 #define MCHK_K_CACKSOFT 0x008C 45 #define MCHK_K_BUGCHECK 0x008E 46 #define MCHK_K_OS_BUGCHECK 0x0090 47 #define MCHK_K_DCPERR 0x0092 48 #define MCHK_K_ICPERR 0x0094 49 50 51 /* 52 * Platform-specific machine-check reasons: 53 */ 54 #define MCHK_K_SIO_SERR 0x204 /* all platforms so far */ 55 #define MCHK_K_SIO_IOCHK 0x206 /* all platforms so far */ 56 #define MCHK_K_DCSR 0x208 /* all but Noname */ 57 58 59 /* 60 * Given a bus, device, and function number, compute resulting 61 * configuration space address and setup the LCA_IOC_CONF register 62 * accordingly. It is therefore not safe to have concurrent 63 * invocations to configuration space access routines, but there 64 * really shouldn't be any need for this. 65 * 66 * Type 0: 67 * 68 * 3 3|3 3 2 2|2 2 2 2|2 2 2 2|1 1 1 1|1 1 1 1|1 1 69 * 3 2|1 0 9 8|7 6 5 4|3 2 1 0|9 8 7 6|5 4 3 2|1 0 9 8|7 6 5 4|3 2 1 0 70 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 71 * | | | | | | | | | | | | | | | | | | | | | | | |F|F|F|R|R|R|R|R|R|0|0| 72 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 73 * 74 * 31:11 Device select bit. 75 * 10:8 Function number 76 * 7:2 Register number 77 * 78 * Type 1: 79 * 80 * 3 3|3 3 2 2|2 2 2 2|2 2 2 2|1 1 1 1|1 1 1 1|1 1 81 * 3 2|1 0 9 8|7 6 5 4|3 2 1 0|9 8 7 6|5 4 3 2|1 0 9 8|7 6 5 4|3 2 1 0 82 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 83 * | | | | | | | | | | |B|B|B|B|B|B|B|B|D|D|D|D|D|F|F|F|R|R|R|R|R|R|0|1| 84 * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 85 * 86 * 31:24 reserved 87 * 23:16 bus number (8 bits = 128 possible buses) 88 * 15:11 Device number (5 bits) 89 * 10:8 function number 90 * 7:2 register number 91 * 92 * Notes: 93 * The function number selects which function of a multi-function device 94 * (e.g., SCSI and Ethernet). 95 * 96 * The register selects a DWORD (32 bit) register offset. Hence it 97 * doesn't get shifted by 2 bits as we want to "drop" the bottom two 98 * bits. 99 */ 100 101 static int 102 mk_conf_addr(struct pci_bus *pbus, unsigned int device_fn, int where, 103 unsigned long *pci_addr) 104 { 105 unsigned long addr; 106 u8 bus = pbus->number; 107 108 if (bus == 0) { 109 int device = device_fn >> 3; 110 int func = device_fn & 0x7; 111 112 /* Type 0 configuration cycle. */ 113 114 if (device > 12) { 115 return -1; 116 } 117 118 *(vulp)LCA_IOC_CONF = 0; 119 addr = (1 << (11 + device)) | (func << 8) | where; 120 } else { 121 /* Type 1 configuration cycle. */ 122 *(vulp)LCA_IOC_CONF = 1; 123 addr = (bus << 16) | (device_fn << 8) | where; 124 } 125 *pci_addr = addr; 126 return 0; 127 } 128 129 static unsigned int 130 conf_read(unsigned long addr) 131 { 132 unsigned long flags, code, stat0; 133 unsigned int value; 134 135 local_irq_save(flags); 136 137 /* Reset status register to avoid losing errors. */ 138 stat0 = *(vulp)LCA_IOC_STAT0; 139 *(vulp)LCA_IOC_STAT0 = stat0; 140 mb(); 141 142 /* Access configuration space. */ 143 value = *(vuip)addr; 144 draina(); 145 146 stat0 = *(vulp)LCA_IOC_STAT0; 147 if (stat0 & LCA_IOC_STAT0_ERR) { 148 code = ((stat0 >> LCA_IOC_STAT0_CODE_SHIFT) 149 & LCA_IOC_STAT0_CODE_MASK); 150 if (code != 1) { 151 printk("lca.c:conf_read: got stat0=%lx\n", stat0); 152 } 153 154 /* Reset error status. */ 155 *(vulp)LCA_IOC_STAT0 = stat0; 156 mb(); 157 158 /* Reset machine check. */ 159 wrmces(0x7); 160 161 value = 0xffffffff; 162 } 163 local_irq_restore(flags); 164 return value; 165 } 166 167 static void 168 conf_write(unsigned long addr, unsigned int value) 169 { 170 unsigned long flags, code, stat0; 171 172 local_irq_save(flags); /* avoid getting hit by machine check */ 173 174 /* Reset status register to avoid losing errors. */ 175 stat0 = *(vulp)LCA_IOC_STAT0; 176 *(vulp)LCA_IOC_STAT0 = stat0; 177 mb(); 178 179 /* Access configuration space. */ 180 *(vuip)addr = value; 181 draina(); 182 183 stat0 = *(vulp)LCA_IOC_STAT0; 184 if (stat0 & LCA_IOC_STAT0_ERR) { 185 code = ((stat0 >> LCA_IOC_STAT0_CODE_SHIFT) 186 & LCA_IOC_STAT0_CODE_MASK); 187 if (code != 1) { 188 printk("lca.c:conf_write: got stat0=%lx\n", stat0); 189 } 190 191 /* Reset error status. */ 192 *(vulp)LCA_IOC_STAT0 = stat0; 193 mb(); 194 195 /* Reset machine check. */ 196 wrmces(0x7); 197 } 198 local_irq_restore(flags); 199 } 200 201 static int 202 lca_read_config(struct pci_bus *bus, unsigned int devfn, int where, 203 int size, u32 *value) 204 { 205 unsigned long addr, pci_addr; 206 long mask; 207 int shift; 208 209 if (mk_conf_addr(bus, devfn, where, &pci_addr)) 210 return PCIBIOS_DEVICE_NOT_FOUND; 211 212 shift = (where & 3) * 8; 213 mask = (size - 1) * 8; 214 addr = (pci_addr << 5) + mask + LCA_CONF; 215 *value = conf_read(addr) >> (shift); 216 return PCIBIOS_SUCCESSFUL; 217 } 218 219 static int 220 lca_write_config(struct pci_bus *bus, unsigned int devfn, int where, int size, 221 u32 value) 222 { 223 unsigned long addr, pci_addr; 224 long mask; 225 226 if (mk_conf_addr(bus, devfn, where, &pci_addr)) 227 return PCIBIOS_DEVICE_NOT_FOUND; 228 229 mask = (size - 1) * 8; 230 addr = (pci_addr << 5) + mask + LCA_CONF; 231 conf_write(addr, value << ((where & 3) * 8)); 232 return PCIBIOS_SUCCESSFUL; 233 } 234 235 struct pci_ops lca_pci_ops = 236 { 237 .read = lca_read_config, 238 .write = lca_write_config, 239 }; 240 241 void 242 lca_pci_tbi(struct pci_controller *hose, dma_addr_t start, dma_addr_t end) 243 { 244 wmb(); 245 *(vulp)LCA_IOC_TBIA = 0; 246 mb(); 247 } 248 249 void __init 250 lca_init_arch(void) 251 { 252 struct pci_controller *hose; 253 254 /* 255 * Create our single hose. 256 */ 257 258 pci_isa_hose = hose = alloc_pci_controller(); 259 hose->io_space = &ioport_resource; 260 hose->mem_space = &iomem_resource; 261 hose->index = 0; 262 263 hose->sparse_mem_base = LCA_SPARSE_MEM - IDENT_ADDR; 264 hose->dense_mem_base = LCA_DENSE_MEM - IDENT_ADDR; 265 hose->sparse_io_base = LCA_IO - IDENT_ADDR; 266 hose->dense_io_base = 0; 267 268 /* 269 * Set up the PCI to main memory translation windows. 270 * 271 * Mimic the SRM settings for the direct-map window. 272 * Window 0 is scatter-gather 8MB at 8MB (for isa). 273 * Window 1 is direct access 1GB at 1GB. 274 * 275 * Note that we do not try to save any of the DMA window CSRs 276 * before setting them, since we cannot read those CSRs on LCA. 277 */ 278 hose->sg_isa = iommu_arena_new(hose, 0x00800000, 0x00800000, 0); 279 hose->sg_pci = NULL; 280 __direct_map_base = 0x40000000; 281 __direct_map_size = 0x40000000; 282 283 *(vulp)LCA_IOC_W_BASE0 = hose->sg_isa->dma_base | (3UL << 32); 284 *(vulp)LCA_IOC_W_MASK0 = (hose->sg_isa->size - 1) & 0xfff00000; 285 *(vulp)LCA_IOC_T_BASE0 = virt_to_phys(hose->sg_isa->ptes); 286 287 *(vulp)LCA_IOC_W_BASE1 = __direct_map_base | (2UL << 32); 288 *(vulp)LCA_IOC_W_MASK1 = (__direct_map_size - 1) & 0xfff00000; 289 *(vulp)LCA_IOC_T_BASE1 = 0; 290 291 *(vulp)LCA_IOC_TB_ENA = 0x80; 292 293 lca_pci_tbi(hose, 0, -1); 294 295 /* 296 * Disable PCI parity for now. The NCR53c810 chip has 297 * troubles meeting the PCI spec which results in 298 * data parity errors. 299 */ 300 *(vulp)LCA_IOC_PAR_DIS = 1UL<<5; 301 302 /* 303 * Finally, set up for restoring the correct HAE if using SRM. 304 * Again, since we cannot read many of the CSRs on the LCA, 305 * one of which happens to be the HAE, we save the value that 306 * the SRM will expect... 307 */ 308 if (alpha_using_srm) 309 srm_hae = 0x80000000UL; 310 } 311 312 /* 313 * Constants used during machine-check handling. I suppose these 314 * could be moved into lca.h but I don't see much reason why anybody 315 * else would want to use them. 316 */ 317 318 #define ESR_EAV (1UL<< 0) /* error address valid */ 319 #define ESR_CEE (1UL<< 1) /* correctable error */ 320 #define ESR_UEE (1UL<< 2) /* uncorrectable error */ 321 #define ESR_WRE (1UL<< 3) /* write-error */ 322 #define ESR_SOR (1UL<< 4) /* error source */ 323 #define ESR_CTE (1UL<< 7) /* cache-tag error */ 324 #define ESR_MSE (1UL<< 9) /* multiple soft errors */ 325 #define ESR_MHE (1UL<<10) /* multiple hard errors */ 326 #define ESR_NXM (1UL<<12) /* non-existent memory */ 327 328 #define IOC_ERR ( 1<<4) /* ioc logs an error */ 329 #define IOC_CMD_SHIFT 0 330 #define IOC_CMD (0xf<<IOC_CMD_SHIFT) 331 #define IOC_CODE_SHIFT 8 332 #define IOC_CODE (0xf<<IOC_CODE_SHIFT) 333 #define IOC_LOST ( 1<<5) 334 #define IOC_P_NBR ((__u32) ~((1<<13) - 1)) 335 336 static void 337 mem_error(unsigned long esr, unsigned long ear) 338 { 339 printk(" %s %s error to %s occurred at address %x\n", 340 ((esr & ESR_CEE) ? "Correctable" : 341 (esr & ESR_UEE) ? "Uncorrectable" : "A"), 342 (esr & ESR_WRE) ? "write" : "read", 343 (esr & ESR_SOR) ? "memory" : "b-cache", 344 (unsigned) (ear & 0x1ffffff8)); 345 if (esr & ESR_CTE) { 346 printk(" A b-cache tag parity error was detected.\n"); 347 } 348 if (esr & ESR_MSE) { 349 printk(" Several other correctable errors occurred.\n"); 350 } 351 if (esr & ESR_MHE) { 352 printk(" Several other uncorrectable errors occurred.\n"); 353 } 354 if (esr & ESR_NXM) { 355 printk(" Attempted to access non-existent memory.\n"); 356 } 357 } 358 359 static void 360 ioc_error(__u32 stat0, __u32 stat1) 361 { 362 static const char * const pci_cmd[] = { 363 "Interrupt Acknowledge", "Special", "I/O Read", "I/O Write", 364 "Rsvd 1", "Rsvd 2", "Memory Read", "Memory Write", "Rsvd3", 365 "Rsvd4", "Configuration Read", "Configuration Write", 366 "Memory Read Multiple", "Dual Address", "Memory Read Line", 367 "Memory Write and Invalidate" 368 }; 369 static const char * const err_name[] = { 370 "exceeded retry limit", "no device", "bad data parity", 371 "target abort", "bad address parity", "page table read error", 372 "invalid page", "data error" 373 }; 374 unsigned code = (stat0 & IOC_CODE) >> IOC_CODE_SHIFT; 375 unsigned cmd = (stat0 & IOC_CMD) >> IOC_CMD_SHIFT; 376 377 printk(" %s initiated PCI %s cycle to address %x" 378 " failed due to %s.\n", 379 code > 3 ? "PCI" : "CPU", pci_cmd[cmd], stat1, err_name[code]); 380 381 if (code == 5 || code == 6) { 382 printk(" (Error occurred at PCI memory address %x.)\n", 383 (stat0 & ~IOC_P_NBR)); 384 } 385 if (stat0 & IOC_LOST) { 386 printk(" Other PCI errors occurred simultaneously.\n"); 387 } 388 } 389 390 void 391 lca_machine_check(unsigned long vector, unsigned long la_ptr) 392 { 393 const char * reason; 394 union el_lca el; 395 396 el.c = (struct el_common *) la_ptr; 397 398 wrmces(rdmces()); /* reset machine check pending flag */ 399 400 printk(KERN_CRIT "LCA machine check: vector=%#lx pc=%#lx code=%#x\n", 401 vector, get_irq_regs()->pc, (unsigned int) el.c->code); 402 403 /* 404 * The first quadword after the common header always seems to 405 * be the machine check reason---don't know why this isn't 406 * part of the common header instead. In the case of a long 407 * logout frame, the upper 32 bits is the machine check 408 * revision level, which we ignore for now. 409 */ 410 switch ((unsigned int) el.c->code) { 411 case MCHK_K_TPERR: reason = "tag parity error"; break; 412 case MCHK_K_TCPERR: reason = "tag control parity error"; break; 413 case MCHK_K_HERR: reason = "access to non-existent memory"; break; 414 case MCHK_K_ECC_C: reason = "correctable ECC error"; break; 415 case MCHK_K_ECC_NC: reason = "non-correctable ECC error"; break; 416 case MCHK_K_CACKSOFT: reason = "MCHK_K_CACKSOFT"; break; 417 case MCHK_K_BUGCHECK: reason = "illegal exception in PAL mode"; break; 418 case MCHK_K_OS_BUGCHECK: reason = "callsys in kernel mode"; break; 419 case MCHK_K_DCPERR: reason = "d-cache parity error"; break; 420 case MCHK_K_ICPERR: reason = "i-cache parity error"; break; 421 case MCHK_K_SIO_SERR: reason = "SIO SERR occurred on PCI bus"; break; 422 case MCHK_K_SIO_IOCHK: reason = "SIO IOCHK occurred on ISA bus"; break; 423 case MCHK_K_DCSR: reason = "MCHK_K_DCSR"; break; 424 case MCHK_K_UNKNOWN: 425 default: reason = "unknown"; break; 426 } 427 428 switch (el.c->size) { 429 case sizeof(struct el_lca_mcheck_short): 430 printk(KERN_CRIT 431 " Reason: %s (short frame%s, dc_stat=%#lx):\n", 432 reason, el.c->retry ? ", retryable" : "", 433 el.s->dc_stat); 434 if (el.s->esr & ESR_EAV) { 435 mem_error(el.s->esr, el.s->ear); 436 } 437 if (el.s->ioc_stat0 & IOC_ERR) { 438 ioc_error(el.s->ioc_stat0, el.s->ioc_stat1); 439 } 440 break; 441 442 case sizeof(struct el_lca_mcheck_long): 443 printk(KERN_CRIT " Reason: %s (long frame%s):\n", 444 reason, el.c->retry ? ", retryable" : ""); 445 printk(KERN_CRIT 446 " reason: %#lx exc_addr: %#lx dc_stat: %#lx\n", 447 el.l->pt[0], el.l->exc_addr, el.l->dc_stat); 448 printk(KERN_CRIT " car: %#lx\n", el.l->car); 449 if (el.l->esr & ESR_EAV) { 450 mem_error(el.l->esr, el.l->ear); 451 } 452 if (el.l->ioc_stat0 & IOC_ERR) { 453 ioc_error(el.l->ioc_stat0, el.l->ioc_stat1); 454 } 455 break; 456 457 default: 458 printk(KERN_CRIT " Unknown errorlog size %d\n", el.c->size); 459 } 460 461 /* Dump the logout area to give all info. */ 462 #ifdef CONFIG_VERBOSE_MCHECK 463 if (alpha_verbose_mcheck > 1) { 464 unsigned long * ptr = (unsigned long *) la_ptr; 465 long i; 466 for (i = 0; i < el.c->size / sizeof(long); i += 2) { 467 printk(KERN_CRIT " +%8lx %016lx %016lx\n", 468 i*sizeof(long), ptr[i], ptr[i+1]); 469 } 470 } 471 #endif /* CONFIG_VERBOSE_MCHECK */ 472 } 473 474 /* 475 * The following routines are needed to support the SPEED changing 476 * necessary to successfully manage the thermal problem on the AlphaBook1. 477 */ 478 479 void 480 lca_clock_print(void) 481 { 482 long pmr_reg; 483 484 pmr_reg = LCA_READ_PMR; 485 486 printk("Status of clock control:\n"); 487 printk("\tPrimary clock divisor\t0x%lx\n", LCA_GET_PRIMARY(pmr_reg)); 488 printk("\tOverride clock divisor\t0x%lx\n", LCA_GET_OVERRIDE(pmr_reg)); 489 printk("\tInterrupt override is %s\n", 490 (pmr_reg & LCA_PMR_INTO) ? "on" : "off"); 491 printk("\tDMA override is %s\n", 492 (pmr_reg & LCA_PMR_DMAO) ? "on" : "off"); 493 494 } 495 496 int 497 lca_get_clock(void) 498 { 499 long pmr_reg; 500 501 pmr_reg = LCA_READ_PMR; 502 return(LCA_GET_PRIMARY(pmr_reg)); 503 504 } 505 506 void 507 lca_clock_fiddle(int divisor) 508 { 509 long pmr_reg; 510 511 pmr_reg = LCA_READ_PMR; 512 LCA_SET_PRIMARY_CLOCK(pmr_reg, divisor); 513 /* lca_norm_clock = divisor; */ 514 LCA_WRITE_PMR(pmr_reg); 515 mb(); 516 } 517