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