SAFE public projects git trees. - safe/jmp/linux-2.6/blob - arch/alpha/kernel/core_cia.c

   1 /*
   2  *      linux/arch/alpha/kernel/core_cia.c
   3  *
   4  * Written by David A Rusling (david.rusling@reo.mts.dec.com).
   5  * December 1995.
   6  *
   7  *      Copyright (C) 1995  David A Rusling
   8  *      Copyright (C) 1997, 1998  Jay Estabrook
   9  *      Copyright (C) 1998, 1999, 2000  Richard Henderson
  10  *
  11  * Code common to all CIA core logic chips.
  12  */
  13
  14 #define __EXTERN_INLINE inline
  15 #include <asm/io.h>
  16 #include <asm/core_cia.h>
  17 #undef __EXTERN_INLINE
  18
  19 #include <linux/types.h>
  20 #include <linux/pci.h>
  21 #include <linux/sched.h>
  22 #include <linux/init.h>
  23 #include <linux/bootmem.h>
  24
  25 #include <asm/ptrace.h>
  26
  27 #include "proto.h"
  28 #include "pci_impl.h"
  29
  30
  31 /*
  32  * NOTE: Herein lie back-to-back mb instructions.  They are magic.
  33  * One plausible explanation is that the i/o controller does not properly
  34  * handle the system transaction.  Another involves timing.  Ho hum.
  35  */
  36
  37 #define DEBUG_CONFIG 0
  38 #if DEBUG_CONFIG
  39 # define DBGC(args)     printk args
  40 #else
  41 # define DBGC(args)
  42 #endif
  43
  44 #define vip     volatile int  *
  45
  46 /*
  47  * Given a bus, device, and function number, compute resulting
  48  * configuration space address.  It is therefore not safe to have
  49  * concurrent invocations to configuration space access routines, but
  50  * there really shouldn't be any need for this.
  51  *
  52  * Type 0:
  53  *
  54  *  3 3|3 3 2 2|2 2 2 2|2 2 2 2|1 1 1 1|1 1 1 1|1 1
  55  *  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
  56  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  57  * | | |D|D|D|D|D|D|D|D|D|D|D|D|D|D|D|D|D|D|D|D|D|F|F|F|R|R|R|R|R|R|0|0|
  58  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  59  *
  60  *      31:11   Device select bit.
  61  *      10:8    Function number
  62  *       7:2    Register number
  63  *
  64  * Type 1:
  65  *
  66  *  3 3|3 3 2 2|2 2 2 2|2 2 2 2|1 1 1 1|1 1 1 1|1 1
  67  *  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
  68  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  69  * | | | | | | | | | | |B|B|B|B|B|B|B|B|D|D|D|D|D|F|F|F|R|R|R|R|R|R|0|1|
  70  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  71  *
  72  *      31:24   reserved
  73  *      23:16   bus number (8 bits = 128 possible buses)
  74  *      15:11   Device number (5 bits)
  75  *      10:8    function number
  76  *       7:2    register number
  77  *
  78  * Notes:
  79  *      The function number selects which function of a multi-function device
  80  *      (e.g., SCSI and Ethernet).
  81  *
  82  *      The register selects a DWORD (32 bit) register offset.  Hence it
  83  *      doesn't get shifted by 2 bits as we want to "drop" the bottom two
  84  *      bits.
  85  */
  86
  87 static int
  88 mk_conf_addr(struct pci_bus *bus_dev, unsigned int device_fn, int where,
  89              unsigned long *pci_addr, unsigned char *type1)
  90 {
  91         u8 bus = bus_dev->number;
  92
  93         *type1 = (bus != 0);
  94         *pci_addr = (bus << 16) | (device_fn << 8) | where;
  95
  96         DBGC(("mk_conf_addr(bus=%d ,device_fn=0x%x, where=0x%x,"
  97               " returning address 0x%p\n"
  98               bus, device_fn, where, *pci_addr));
  99
 100         return 0;
 101 }
 102
 103 static unsigned int
 104 conf_read(unsigned long addr, unsigned char type1)
 105 {
 106         unsigned long flags;
 107         int stat0, value;
 108         int cia_cfg = 0;
 109
 110         DBGC(("conf_read(addr=0x%lx, type1=%d) ", addr, type1));
 111         local_irq_save(flags);
 112
 113         /* Reset status register to avoid losing errors.  */
 114         stat0 = *(vip)CIA_IOC_CIA_ERR;
 115         *(vip)CIA_IOC_CIA_ERR = stat0;
 116         mb();
 117         *(vip)CIA_IOC_CIA_ERR; /* re-read to force write */
 118
 119         /* If Type1 access, must set CIA CFG. */
 120         if (type1) {
 121                 cia_cfg = *(vip)CIA_IOC_CFG;
 122                 *(vip)CIA_IOC_CFG = (cia_cfg & ~3) | 1;
 123                 mb();
 124                 *(vip)CIA_IOC_CFG;
 125         }
 126
 127         mb();
 128         draina();
 129         mcheck_expected(0) = 1;
 130         mcheck_taken(0) = 0;
 131         mb();
 132
 133         /* Access configuration space.  */
 134         value = *(vip)addr;
 135         mb();
 136         mb();  /* magic */
 137         if (mcheck_taken(0)) {
 138                 mcheck_taken(0) = 0;
 139                 value = 0xffffffff;
 140                 mb();
 141         }
 142         mcheck_expected(0) = 0;
 143         mb();
 144
 145         /* If Type1 access, must reset IOC CFG so normal IO space ops work.  */
 146         if (type1) {
 147                 *(vip)CIA_IOC_CFG = cia_cfg;
 148                 mb();
 149                 *(vip)CIA_IOC_CFG;
 150         }
 151
 152         local_irq_restore(flags);
 153         DBGC(("done\n"));
 154
 155         return value;
 156 }
 157
 158 static void
 159 conf_write(unsigned long addr, unsigned int value, unsigned char type1)
 160 {
 161         unsigned long flags;
 162         int stat0, cia_cfg = 0;
 163
 164         DBGC(("conf_write(addr=0x%lx, type1=%d) ", addr, type1));
 165         local_irq_save(flags);
 166
 167         /* Reset status register to avoid losing errors.  */
 168         stat0 = *(vip)CIA_IOC_CIA_ERR;
 169         *(vip)CIA_IOC_CIA_ERR = stat0;
 170         mb();
 171         *(vip)CIA_IOC_CIA_ERR; /* re-read to force write */
 172
 173         /* If Type1 access, must set CIA CFG.  */
 174         if (type1) {
 175                 cia_cfg = *(vip)CIA_IOC_CFG;
 176                 *(vip)CIA_IOC_CFG = (cia_cfg & ~3) | 1;
 177                 mb();
 178                 *(vip)CIA_IOC_CFG;
 179         }
 180
 181         mb();
 182         draina();
 183         mcheck_expected(0) = 1;
 184         mcheck_taken(0) = 0;
 185         mb();
 186
 187         /* Access configuration space.  */
 188         *(vip)addr = value;
 189         mb();
 190         *(vip)addr; /* read back to force the write */
 191
 192         mcheck_expected(0) = 0;
 193         mb();
 194
 195         /* If Type1 access, must reset IOC CFG so normal IO space ops work.  */
 196         if (type1) {
 197                 *(vip)CIA_IOC_CFG = cia_cfg;
 198                 mb();
 199                 *(vip)CIA_IOC_CFG;
 200         }
 201
 202         local_irq_restore(flags);
 203         DBGC(("done\n"));
 204 }
 205
 206 static int
 207 cia_read_config(struct pci_bus *bus, unsigned int devfn, int where, int size,
 208                 u32 *value)
 209 {
 210         unsigned long addr, pci_addr;
 211         long mask;
 212         unsigned char type1;
 213         int shift;
 214
 215         if (mk_conf_addr(bus, devfn, where, &pci_addr, &type1))
 216                 return PCIBIOS_DEVICE_NOT_FOUND;
 217
 218         mask = (size - 1) * 8;
 219         shift = (where & 3) * 8;
 220         addr = (pci_addr << 5) + mask + CIA_CONF;
 221         *value = conf_read(addr, type1) >> (shift);
 222         return PCIBIOS_SUCCESSFUL;
 223 }
 224
 225 static int
 226 cia_write_config(struct pci_bus *bus, unsigned int devfn, int where, int size,
 227                  u32 value)
 228 {
 229         unsigned long addr, pci_addr;
 230         long mask;
 231         unsigned char type1;
 232
 233         if (mk_conf_addr(bus, devfn, where, &pci_addr, &type1))
 234                 return PCIBIOS_DEVICE_NOT_FOUND;
 235
 236         mask = (size - 1) * 8;
 237         addr = (pci_addr << 5) + mask + CIA_CONF;
 238         conf_write(addr, value << ((where & 3) * 8), type1);
 239         return PCIBIOS_SUCCESSFUL;
 240 }
 241
 242 struct pci_ops cia_pci_ops =
 243 {
 244         .read =         cia_read_config,
 245         .write =        cia_write_config,
 246 };
 247 \f
 248 /*
 249  * CIA Pass 1 and PYXIS Pass 1 and 2 have a broken scatter-gather tlb.
 250  * It cannot be invalidated.  Rather than hard code the pass numbers,
 251  * actually try the tbia to see if it works.
 252  */
 253
 254 void
 255 cia_pci_tbi(struct pci_controller *hose, dma_addr_t start, dma_addr_t end)
 256 {
 257         wmb();
 258         *(vip)CIA_IOC_PCI_TBIA = 3;     /* Flush all locked and unlocked.  */
 259         mb();
 260         *(vip)CIA_IOC_PCI_TBIA;
 261 }
 262
 263 /*
 264  * On PYXIS, even if the tbia works, we cannot use it. It effectively locks
 265  * the chip (as well as direct write to the tag registers) if there is a
 266  * SG DMA operation in progress. This is true at least for PYXIS rev. 1,
 267  * so always use the method below.
 268  */
 269 /*
 270  * This is the method NT and NetBSD use.
 271  *
 272  * Allocate mappings, and put the chip into DMA loopback mode to read a
 273  * garbage page.  This works by causing TLB misses, causing old entries to
 274  * be purged to make room for the new entries coming in for the garbage page.
 275  */
 276
 277 #define CIA_BROKEN_TBIA_BASE    0x30000000
 278 #define CIA_BROKEN_TBIA_SIZE    1024
 279
 280 /* Always called with interrupts disabled */
 281 void
 282 cia_pci_tbi_try2(struct pci_controller *hose,
 283                  dma_addr_t start, dma_addr_t end)
 284 {
 285         void __iomem *bus_addr;
 286         int ctrl;
 287
 288         /* Put the chip into PCI loopback mode.  */
 289         mb();
 290         ctrl = *(vip)CIA_IOC_CIA_CTRL;
 291         *(vip)CIA_IOC_CIA_CTRL = ctrl | CIA_CTRL_PCI_LOOP_EN;
 292         mb();
 293         *(vip)CIA_IOC_CIA_CTRL;
 294         mb();
 295
 296         /* Read from PCI dense memory space at TBI_ADDR, skipping 32k on
 297            each read.  This forces SG TLB misses.  NetBSD claims that the
 298            TLB entries are not quite LRU, meaning that we need to read more
 299            times than there are actual tags.  The 2117x docs claim strict
 300            round-robin.  Oh well, we've come this far...  */
 301         /* Even better - as seen on the PYXIS rev 1 the TLB tags 0-3 can
 302            be filled by the TLB misses *only once* after being invalidated
 303            (by tbia or direct write). Next misses won't update them even
 304            though the lock bits are cleared. Tags 4-7 are "quite LRU" though,
 305            so use them and read at window 3 base exactly 4 times. Reading
 306            more sometimes makes the chip crazy.  -ink */
 307
 308         bus_addr = cia_ioremap(CIA_BROKEN_TBIA_BASE, 32768 * 4);
 309
 310         cia_readl(bus_addr + 0x00000);
 311         cia_readl(bus_addr + 0x08000);
 312         cia_readl(bus_addr + 0x10000);
 313         cia_readl(bus_addr + 0x18000);
 314
 315         cia_iounmap(bus_addr);
 316
 317         /* Restore normal PCI operation.  */
 318         mb();
 319         *(vip)CIA_IOC_CIA_CTRL = ctrl;
 320         mb();
 321         *(vip)CIA_IOC_CIA_CTRL;
 322         mb();
 323 }
 324
 325 static inline void
 326 cia_prepare_tbia_workaround(int window)
 327 {
 328         unsigned long *ppte, pte;
 329         long i;
 330
 331         /* Use minimal 1K map. */
 332         ppte = __alloc_bootmem(CIA_BROKEN_TBIA_SIZE, 32768, 0);
 333         pte = (virt_to_phys(ppte) >> (PAGE_SHIFT - 1)) | 1;
 334
 335         for (i = 0; i < CIA_BROKEN_TBIA_SIZE / sizeof(unsigned long); ++i)
 336                 ppte[i] = pte;
 337
 338         *(vip)CIA_IOC_PCI_Wn_BASE(window) = CIA_BROKEN_TBIA_BASE | 3;
 339         *(vip)CIA_IOC_PCI_Wn_MASK(window)
 340           = (CIA_BROKEN_TBIA_SIZE*1024 - 1) & 0xfff00000;
 341         *(vip)CIA_IOC_PCI_Tn_BASE(window) = virt_to_phys(ppte) >> 2;
 342 }
 343
 344 static void __init
 345 verify_tb_operation(void)
 346 {
 347         static int page[PAGE_SIZE/4]
 348                 __attribute__((aligned(PAGE_SIZE)))
 349                 __initdata = { 0 };
 350
 351         struct pci_iommu_arena *arena = pci_isa_hose->sg_isa;
 352         int ctrl, addr0, tag0, pte0, data0;
 353         int temp, use_tbia_try2 = 0;
 354         void __iomem *bus_addr;
 355
 356         /* pyxis -- tbia is broken */
 357         if (pci_isa_hose->dense_io_base)
 358                 use_tbia_try2 = 1;
 359
 360         /* Put the chip into PCI loopback mode.  */
 361         mb();
 362         ctrl = *(vip)CIA_IOC_CIA_CTRL;
 363         *(vip)CIA_IOC_CIA_CTRL = ctrl | CIA_CTRL_PCI_LOOP_EN;
 364         mb();
 365         *(vip)CIA_IOC_CIA_CTRL;
 366         mb();
 367
 368         /* Write a valid entry directly into the TLB registers.  */
 369
 370         addr0 = arena->dma_base;
 371         tag0 = addr0 | 1;
 372         pte0 = (virt_to_phys(page) >> (PAGE_SHIFT - 1)) | 1;
 373
 374         *(vip)CIA_IOC_TB_TAGn(0) = tag0;
 375         *(vip)CIA_IOC_TB_TAGn(1) = 0;
 376         *(vip)CIA_IOC_TB_TAGn(2) = 0;
 377         *(vip)CIA_IOC_TB_TAGn(3) = 0;
 378         *(vip)CIA_IOC_TB_TAGn(4) = 0;
 379         *(vip)CIA_IOC_TB_TAGn(5) = 0;
 380         *(vip)CIA_IOC_TB_TAGn(6) = 0;
 381         *(vip)CIA_IOC_TB_TAGn(7) = 0;
 382         *(vip)CIA_IOC_TBn_PAGEm(0,0) = pte0;
 383         *(vip)CIA_IOC_TBn_PAGEm(0,1) = 0;
 384         *(vip)CIA_IOC_TBn_PAGEm(0,2) = 0;
 385         *(vip)CIA_IOC_TBn_PAGEm(0,3) = 0;
 386         mb();
 387
 388         /* Get a usable bus address */
 389         bus_addr = cia_ioremap(addr0, 8*PAGE_SIZE);
 390
 391         /* First, verify we can read back what we've written.  If
 392            this fails, we can't be sure of any of the other testing
 393            we're going to do, so bail.  */
 394         /* ??? Actually, we could do the work with machine checks.
 395            By passing this register update test, we pretty much
 396            guarantee that cia_pci_tbi_try1 works.  If this test
 397            fails, cia_pci_tbi_try2 might still work.  */
 398
 399         temp = *(vip)CIA_IOC_TB_TAGn(0);
 400         if (temp != tag0) {
 401                 printk("pci: failed tb register update test "
 402                        "(tag0 %#x != %#x)\n", temp, tag0);
 403                 goto failed;
 404         }
 405         temp = *(vip)CIA_IOC_TB_TAGn(1);
 406         if (temp != 0) {
 407                 printk("pci: failed tb register update test "
 408                        "(tag1 %#x != 0)\n", temp);
 409                 goto failed;
 410         }
 411         temp = *(vip)CIA_IOC_TBn_PAGEm(0,0);
 412         if (temp != pte0) {
 413                 printk("pci: failed tb register update test "
 414                        "(pte0 %#x != %#x)\n", temp, pte0);
 415                 goto failed;
 416         }
 417         printk("pci: passed tb register update test\n");
 418
 419         /* Second, verify we can actually do I/O through this entry.  */
 420
 421         data0 = 0xdeadbeef;
 422         page[0] = data0;
 423         mcheck_expected(0) = 1;
 424         mcheck_taken(0) = 0;
 425         mb();
 426         temp = cia_readl(bus_addr);
 427         mb();
 428         mcheck_expected(0) = 0;
 429         mb();
 430         if (mcheck_taken(0)) {
 431                 printk("pci: failed sg loopback i/o read test (mcheck)\n");
 432                 goto failed;
 433         }
 434         if (temp != data0) {
 435                 printk("pci: failed sg loopback i/o read test "
 436                        "(%#x != %#x)\n", temp, data0);
 437                 goto failed;
 438         }
 439         printk("pci: passed sg loopback i/o read test\n");
 440
 441         /* Third, try to invalidate the TLB.  */
 442
 443         if (! use_tbia_try2) {
 444                 cia_pci_tbi(arena->hose, 0, -1);
 445                 temp = *(vip)CIA_IOC_TB_TAGn(0);
 446                 if (temp & 1) {
 447                         use_tbia_try2 = 1;
 448                         printk("pci: failed tbia test; workaround available\n");
 449                 } else {
 450                         printk("pci: passed tbia test\n");
 451                 }
 452         }
 453
 454         /* Fourth, verify the TLB snoops the EV5's caches when
 455            doing a tlb fill.  */
 456
 457         data0 = 0x5adda15e;
 458         page[0] = data0;
 459         arena->ptes[4] = pte0;
 460         mcheck_expected(0) = 1;
 461         mcheck_taken(0) = 0;
 462         mb();
 463         temp = cia_readl(bus_addr + 4*PAGE_SIZE);
 464         mb();
 465         mcheck_expected(0) = 0;
 466         mb();
 467         if (mcheck_taken(0)) {
 468                 printk("pci: failed pte write cache snoop test (mcheck)\n");
 469                 goto failed;
 470         }
 471         if (temp != data0) {
 472                 printk("pci: failed pte write cache snoop test "
 473                        "(%#x != %#x)\n", temp, data0);
 474                 goto failed;
 475         }
 476         printk("pci: passed pte write cache snoop test\n");
 477
 478         /* Fifth, verify that a previously invalid PTE entry gets
 479            filled from the page table.  */
 480
 481         data0 = 0xabcdef12;
 482         page[0] = data0;
 483         arena->ptes[5] = pte0;
 484         mcheck_expected(0) = 1;
 485         mcheck_taken(0) = 0;
 486         mb();
 487         temp = cia_readl(bus_addr + 5*PAGE_SIZE);
 488         mb();
 489         mcheck_expected(0) = 0;
 490         mb();
 491         if (mcheck_taken(0)) {
 492                 printk("pci: failed valid tag invalid pte reload test "
 493                        "(mcheck; workaround available)\n");
 494                 /* Work around this bug by aligning new allocations
 495                    on 4 page boundaries.  */
 496                 arena->align_entry = 4;
 497         } else if (temp != data0) {
 498                 printk("pci: failed valid tag invalid pte reload test "
 499                        "(%#x != %#x)\n", temp, data0);
 500                 goto failed;
 501         } else {
 502                 printk("pci: passed valid tag invalid pte reload test\n");
 503         }
 504
 505         /* Sixth, verify machine checks are working.  Test invalid
 506            pte under the same valid tag as we used above.  */
 507
 508         mcheck_expected(0) = 1;
 509         mcheck_taken(0) = 0;
 510         mb();
 511         temp = cia_readl(bus_addr + 6*PAGE_SIZE);
 512         mb();
 513         mcheck_expected(0) = 0;
 514         mb();
 515         printk("pci: %s pci machine check test\n",
 516                mcheck_taken(0) ? "passed" : "failed");
 517
 518         /* Clean up after the tests.  */
 519         arena->ptes[4] = 0;
 520         arena->ptes[5] = 0;
 521
 522         if (use_tbia_try2) {
 523                 alpha_mv.mv_pci_tbi = cia_pci_tbi_try2;
 524
 525                 /* Tags 0-3 must be disabled if we use this workaraund. */
 526                 wmb();
 527                 *(vip)CIA_IOC_TB_TAGn(0) = 2;
 528                 *(vip)CIA_IOC_TB_TAGn(1) = 2;
 529                 *(vip)CIA_IOC_TB_TAGn(2) = 2;
 530                 *(vip)CIA_IOC_TB_TAGn(3) = 2;
 531
 532                 printk("pci: tbia workaround enabled\n");
 533         }
 534         alpha_mv.mv_pci_tbi(arena->hose, 0, -1);
 535
 536 exit:
 537         /* unmap the bus addr */
 538         cia_iounmap(bus_addr);
 539
 540         /* Restore normal PCI operation.  */
 541         mb();
 542         *(vip)CIA_IOC_CIA_CTRL = ctrl;
 543         mb();
 544         *(vip)CIA_IOC_CIA_CTRL;
 545         mb();
 546         return;
 547
 548 failed:
 549         printk("pci: disabling sg translation window\n");
 550         *(vip)CIA_IOC_PCI_W0_BASE = 0;
 551         *(vip)CIA_IOC_PCI_W1_BASE = 0;
 552         pci_isa_hose->sg_isa = NULL;
 553         alpha_mv.mv_pci_tbi = NULL;
 554         goto exit;
 555 }
 556 \f
 557 #if defined(ALPHA_RESTORE_SRM_SETUP)
 558 /* Save CIA configuration data as the console had it set up.  */
 559 struct
 560 {
 561     unsigned int hae_mem;
 562     unsigned int hae_io;
 563     unsigned int pci_dac_offset;
 564     unsigned int err_mask;
 565     unsigned int cia_ctrl;
 566     unsigned int cia_cnfg;
 567     struct {
 568         unsigned int w_base;
 569         unsigned int w_mask;
 570         unsigned int t_base;
 571     } window[4];
 572 } saved_config __attribute((common));
 573
 574 void
 575 cia_save_srm_settings(int is_pyxis)
 576 {
 577         int i;
 578
 579         /* Save some important registers. */
 580         saved_config.err_mask       = *(vip)CIA_IOC_ERR_MASK;
 581         saved_config.cia_ctrl       = *(vip)CIA_IOC_CIA_CTRL;
 582         saved_config.hae_mem        = *(vip)CIA_IOC_HAE_MEM;
 583         saved_config.hae_io         = *(vip)CIA_IOC_HAE_IO;
 584         saved_config.pci_dac_offset = *(vip)CIA_IOC_PCI_W_DAC;
 585
 586         if (is_pyxis)
 587             saved_config.cia_cnfg   = *(vip)CIA_IOC_CIA_CNFG;
 588         else
 589             saved_config.cia_cnfg   = 0;
 590
 591         /* Save DMA windows configuration. */
 592         for (i = 0; i < 4; i++) {
 593             saved_config.window[i].w_base = *(vip)CIA_IOC_PCI_Wn_BASE(i);
 594             saved_config.window[i].w_mask = *(vip)CIA_IOC_PCI_Wn_MASK(i);
 595             saved_config.window[i].t_base = *(vip)CIA_IOC_PCI_Tn_BASE(i);
 596         }
 597         mb();
 598 }
 599
 600 void
 601 cia_restore_srm_settings(void)
 602 {
 603         int i;
 604
 605         for (i = 0; i < 4; i++) {
 606             *(vip)CIA_IOC_PCI_Wn_BASE(i) = saved_config.window[i].w_base;
 607             *(vip)CIA_IOC_PCI_Wn_MASK(i) = saved_config.window[i].w_mask;
 608             *(vip)CIA_IOC_PCI_Tn_BASE(i) = saved_config.window[i].t_base;
 609         }
 610
 611         *(vip)CIA_IOC_HAE_MEM   = saved_config.hae_mem;
 612         *(vip)CIA_IOC_HAE_IO    = saved_config.hae_io;
 613         *(vip)CIA_IOC_PCI_W_DAC = saved_config.pci_dac_offset;
 614         *(vip)CIA_IOC_ERR_MASK  = saved_config.err_mask;
 615         *(vip)CIA_IOC_CIA_CTRL  = saved_config.cia_ctrl;
 616
 617         if (saved_config.cia_cnfg) /* Must be pyxis. */
 618             *(vip)CIA_IOC_CIA_CNFG  = saved_config.cia_cnfg;
 619
 620         mb();
 621 }
 622 #else /* ALPHA_RESTORE_SRM_SETUP */
 623 #define cia_save_srm_settings(p)        do {} while (0)
 624 #define cia_restore_srm_settings()      do {} while (0)
 625 #endif /* ALPHA_RESTORE_SRM_SETUP */
 626
 627 \f
 628 static void __init
 629 do_init_arch(int is_pyxis)
 630 {
 631         struct pci_controller *hose;
 632         int temp, cia_rev, tbia_window;
 633
 634         cia_rev = *(vip)CIA_IOC_CIA_REV & CIA_REV_MASK;
 635         printk("pci: cia revision %d%s\n",
 636                cia_rev, is_pyxis ? " (pyxis)" : "");
 637
 638         if (alpha_using_srm)
 639                 cia_save_srm_settings(is_pyxis);
 640
 641         /* Set up error reporting.  */
 642         temp = *(vip)CIA_IOC_ERR_MASK;
 643         temp &= ~(CIA_ERR_CPU_PE | CIA_ERR_MEM_NEM | CIA_ERR_PA_PTE_INV
 644                   | CIA_ERR_RCVD_MAS_ABT | CIA_ERR_RCVD_TAR_ABT);
 645         *(vip)CIA_IOC_ERR_MASK = temp;
 646
 647         /* Clear all currently pending errors.  */
 648         temp = *(vip)CIA_IOC_CIA_ERR;
 649         *(vip)CIA_IOC_CIA_ERR = temp;
 650
 651         /* Turn on mchecks.  */
 652         temp = *(vip)CIA_IOC_CIA_CTRL;
 653         temp |= CIA_CTRL_FILL_ERR_EN | CIA_CTRL_MCHK_ERR_EN;
 654         *(vip)CIA_IOC_CIA_CTRL = temp;
 655
 656         /* Clear the CFG register, which gets used for PCI config space
 657            accesses.  That is the way we want to use it, and we do not
 658            want to depend on what ARC or SRM might have left behind.  */
 659         *(vip)CIA_IOC_CFG = 0;
 660
 661         /* Zero the HAEs.  */
 662         *(vip)CIA_IOC_HAE_MEM = 0;
 663         *(vip)CIA_IOC_HAE_IO = 0;
 664
 665         /* For PYXIS, we always use BWX bus and i/o accesses.  To that end,
 666            make sure they're enabled on the controller.  At the same time,
 667            enable the monster window.  */
 668         if (is_pyxis) {
 669                 temp = *(vip)CIA_IOC_CIA_CNFG;
 670                 temp |= CIA_CNFG_IOA_BWEN | CIA_CNFG_PCI_MWEN;
 671                 *(vip)CIA_IOC_CIA_CNFG = temp;
 672         }
 673
 674         /* Synchronize with all previous changes.  */
 675         mb();
 676         *(vip)CIA_IOC_CIA_REV;
 677
 678         /*
 679          * Create our single hose.
 680          */
 681
 682         pci_isa_hose = hose = alloc_pci_controller();
 683         hose->io_space = &ioport_resource;
 684         hose->mem_space = &iomem_resource;
 685         hose->index = 0;
 686
 687         if (! is_pyxis) {
 688                 struct resource *hae_mem = alloc_resource();
 689                 hose->mem_space = hae_mem;
 690
 691                 hae_mem->start = 0;
 692                 hae_mem->end = CIA_MEM_R1_MASK;
 693                 hae_mem->name = pci_hae0_name;
 694                 hae_mem->flags = IORESOURCE_MEM;
 695
 696                 if (request_resource(&iomem_resource, hae_mem) < 0)
 697                         printk(KERN_ERR "Failed to request HAE_MEM\n");
 698
 699                 hose->sparse_mem_base = CIA_SPARSE_MEM - IDENT_ADDR;
 700                 hose->dense_mem_base = CIA_DENSE_MEM - IDENT_ADDR;
 701                 hose->sparse_io_base = CIA_IO - IDENT_ADDR;
 702                 hose->dense_io_base = 0;
 703         } else {
 704                 hose->sparse_mem_base = 0;
 705                 hose->dense_mem_base = CIA_BW_MEM - IDENT_ADDR;
 706                 hose->sparse_io_base = 0;
 707                 hose->dense_io_base = CIA_BW_IO - IDENT_ADDR;
 708         }
 709
 710         /*
 711          * Set up the PCI to main memory translation windows.
 712          *
 713          * Window 0 is S/G 8MB at 8MB (for isa)
 714          * Window 1 is S/G 1MB at 768MB (for tbia) (unused for CIA rev 1)
 715          * Window 2 is direct access 2GB at 2GB
 716          * Window 3 is DAC access 4GB at 8GB (or S/G for tbia if CIA rev 1)
 717          *
 718          * ??? NetBSD hints that page tables must be aligned to 32K,
 719          * possibly due to a hardware bug.  This is over-aligned
 720          * from the 8K alignment one would expect for an 8MB window.
 721          * No description of what revisions affected.
 722          */
 723
 724         hose->sg_pci = NULL;
 725         hose->sg_isa = iommu_arena_new(hose, 0x00800000, 0x00800000, 32768);
 726
 727         __direct_map_base = 0x80000000;
 728         __direct_map_size = 0x80000000;
 729
 730         *(vip)CIA_IOC_PCI_W0_BASE = hose->sg_isa->dma_base | 3;
 731         *(vip)CIA_IOC_PCI_W0_MASK = (hose->sg_isa->size - 1) & 0xfff00000;
 732         *(vip)CIA_IOC_PCI_T0_BASE = virt_to_phys(hose->sg_isa->ptes) >> 2;
 733
 734         *(vip)CIA_IOC_PCI_W2_BASE = __direct_map_base | 1;
 735         *(vip)CIA_IOC_PCI_W2_MASK = (__direct_map_size - 1) & 0xfff00000;
 736         *(vip)CIA_IOC_PCI_T2_BASE = 0 >> 2;
 737
 738         /* On PYXIS we have the monster window, selected by bit 40, so
 739            there is no need for window3 to be enabled.
 740
 741            On CIA, we don't have true arbitrary addressing -- bits <39:32>
 742            are compared against W_DAC.  We can, however, directly map 4GB,
 743            which is better than before.  However, due to assumptions made
 744            elsewhere, we should not claim that we support DAC unless that
 745            4GB covers all of physical memory.
 746
 747            On CIA rev 1, apparently W1 and W2 can't be used for SG.
 748            At least, there are reports that it doesn't work for Alcor.
 749            In that case, we have no choice but to use W3 for the TBIA
 750            workaround, which means we can't use DAC at all. */
 751
 752         tbia_window = 1;
 753         if (is_pyxis) {
 754                 *(vip)CIA_IOC_PCI_W3_BASE = 0;
 755         } else if (cia_rev == 1) {
 756                 *(vip)CIA_IOC_PCI_W1_BASE = 0;
 757                 tbia_window = 3;
 758         } else if (max_low_pfn > (0x100000000UL >> PAGE_SHIFT)) {
 759                 *(vip)CIA_IOC_PCI_W3_BASE = 0;
 760         } else {
 761                 *(vip)CIA_IOC_PCI_W3_BASE = 0x00000000 | 1 | 8;
 762                 *(vip)CIA_IOC_PCI_W3_MASK = 0xfff00000;
 763                 *(vip)CIA_IOC_PCI_T3_BASE = 0 >> 2;
 764
 765                 alpha_mv.pci_dac_offset = 0x200000000UL;
 766                 *(vip)CIA_IOC_PCI_W_DAC = alpha_mv.pci_dac_offset >> 32;
 767         }
 768
 769         /* Prepare workaround for apparently broken tbia. */
 770         cia_prepare_tbia_workaround(tbia_window);
 771 }
 772
 773 void __init
 774 cia_init_arch(void)
 775 {
 776         do_init_arch(0);
 777 }
 778
 779 void __init
 780 pyxis_init_arch(void)
 781 {
 782         /* On pyxis machines we can precisely calculate the
 783            CPU clock frequency using pyxis real time counter.
 784            It's especially useful for SX164 with broken RTC.
 785
 786            Both CPU and chipset are driven by the single 16.666M
 787            or 16.667M crystal oscillator. PYXIS_RT_COUNT clock is
 788            66.66 MHz. -ink */
 789
 790         unsigned int cc0, cc1;
 791         unsigned long pyxis_cc;
 792
 793         __asm__ __volatile__ ("rpcc %0" : "=r"(cc0));
 794         pyxis_cc = *(vulp)PYXIS_RT_COUNT;
 795         do { } while(*(vulp)PYXIS_RT_COUNT - pyxis_cc < 4096);
 796         __asm__ __volatile__ ("rpcc %0" : "=r"(cc1));
 797         cc1 -= cc0;
 798         hwrpb->cycle_freq = ((cc1 >> 11) * 100000000UL) / 3;
 799         hwrpb_update_checksum(hwrpb);
 800
 801         do_init_arch(1);
 802 }
 803
 804 void
 805 cia_kill_arch(int mode)
 806 {
 807         if (alpha_using_srm)
 808                 cia_restore_srm_settings();
 809 }
 810
 811 void __init
 812 cia_init_pci(void)
 813 {
 814         /* Must delay this from init_arch, as we need machine checks.  */
 815         verify_tb_operation();
 816         common_init_pci();
 817 }
 818
 819 static inline void
 820 cia_pci_clr_err(void)
 821 {
 822         int jd;
 823
 824         jd = *(vip)CIA_IOC_CIA_ERR;
 825         *(vip)CIA_IOC_CIA_ERR = jd;
 826         mb();
 827         *(vip)CIA_IOC_CIA_ERR;          /* re-read to force write.  */
 828 }
 829
 830 #ifdef CONFIG_VERBOSE_MCHECK
 831 static void
 832 cia_decode_pci_error(struct el_CIA_sysdata_mcheck *cia, const char *msg)
 833 {
 834         static const char * const pci_cmd_desc[16] = {
 835                 "Interrupt Acknowledge", "Special Cycle", "I/O Read",
 836                 "I/O Write", "Reserved 0x4", "Reserved 0x5", "Memory Read",
 837                 "Memory Write", "Reserved 0x8", "Reserved 0x9",
 838                 "Configuration Read", "Configuration Write",
 839                 "Memory Read Multiple", "Dual Address Cycle",
 840                 "Memory Read Line", "Memory Write and Invalidate"
 841         };
 842
 843         if (cia->cia_err & (CIA_ERR_COR_ERR
 844                             | CIA_ERR_UN_COR_ERR
 845                             | CIA_ERR_MEM_NEM
 846                             | CIA_ERR_PA_PTE_INV)) {
 847                 static const char * const window_desc[6] = {
 848                         "No window active", "Window 0 hit", "Window 1 hit",
 849                         "Window 2 hit", "Window 3 hit", "Monster window hit"
 850                 };
 851
 852                 const char *window;
 853                 const char *cmd;
 854                 unsigned long addr, tmp;
 855                 int lock, dac;
 856
 857                 cmd = pci_cmd_desc[cia->pci_err0 & 0x7];
 858                 lock = (cia->pci_err0 >> 4) & 1;
 859                 dac = (cia->pci_err0 >> 5) & 1;
 860
 861                 tmp = (cia->pci_err0 >> 8) & 0x1F;
 862                 tmp = ffs(tmp);
 863                 window = window_desc[tmp];
 864
 865                 addr = cia->pci_err1;
 866                 if (dac) {
 867                         tmp = *(vip)CIA_IOC_PCI_W_DAC & 0xFFUL;
 868                         addr |= tmp << 32;
 869                 }
 870
 871                 printk(KERN_CRIT "CIA machine check: %s\n", msg);
 872                 printk(KERN_CRIT "  DMA command: %s\n", cmd);
 873                 printk(KERN_CRIT "  PCI address: %#010lx\n", addr);
 874                 printk(KERN_CRIT "  %s, Lock: %d, DAC: %d\n",
 875                        window, lock, dac);
 876         } else if (cia->cia_err & (CIA_ERR_PERR
 877                                    | CIA_ERR_PCI_ADDR_PE
 878                                    | CIA_ERR_RCVD_MAS_ABT
 879                                    | CIA_ERR_RCVD_TAR_ABT
 880                                    | CIA_ERR_IOA_TIMEOUT)) {
 881                 static const char * const master_st_desc[16] = {
 882                         "Idle", "Drive bus", "Address step cycle",
 883                         "Address cycle", "Data cycle", "Last read data cycle",
 884                         "Last write data cycle", "Read stop cycle",
 885                         "Write stop cycle", "Read turnaround cycle",
 886                         "Write turnaround cycle", "Reserved 0xB",
 887                         "Reserved 0xC", "Reserved 0xD", "Reserved 0xE",
 888                         "Unknown state"
 889                 };
 890                 static const char * const target_st_desc[16] = {
 891                         "Idle", "Busy", "Read data cycle", "Write data cycle",
 892                         "Read stop cycle", "Write stop cycle",
 893                         "Read turnaround cycle", "Write turnaround cycle",
 894                         "Read wait cycle", "Write wait cycle",
 895                         "Reserved 0xA", "Reserved 0xB", "Reserved 0xC",
 896                         "Reserved 0xD", "Reserved 0xE", "Unknown state"
 897                 };
 898
 899                 const char *cmd;
 900                 const char *master, *target;
 901                 unsigned long addr, tmp;
 902                 int dac;
 903
 904                 master = master_st_desc[(cia->pci_err0 >> 16) & 0xF];
 905                 target = target_st_desc[(cia->pci_err0 >> 20) & 0xF];
 906                 cmd = pci_cmd_desc[(cia->pci_err0 >> 24) & 0xF];
 907                 dac = (cia->pci_err0 >> 28) & 1;
 908
 909                 addr = cia->pci_err2;
 910                 if (dac) {
 911                         tmp = *(volatile int *)CIA_IOC_PCI_W_DAC & 0xFFUL;
 912                         addr |= tmp << 32;
 913                 }
 914
 915                 printk(KERN_CRIT "CIA machine check: %s\n", msg);
 916                 printk(KERN_CRIT "  PCI command: %s\n", cmd);
 917                 printk(KERN_CRIT "  Master state: %s, Target state: %s\n",
 918                        master, target);
 919                 printk(KERN_CRIT "  PCI address: %#010lx, DAC: %d\n",
 920                        addr, dac);
 921         } else {
 922                 printk(KERN_CRIT "CIA machine check: %s\n", msg);
 923                 printk(KERN_CRIT "  Unknown PCI error\n");
 924                 printk(KERN_CRIT "  PCI_ERR0 = %#08lx", cia->pci_err0);
 925                 printk(KERN_CRIT "  PCI_ERR1 = %#08lx", cia->pci_err1);
 926                 printk(KERN_CRIT "  PCI_ERR2 = %#08lx", cia->pci_err2);
 927         }
 928 }
 929
 930 static void
 931 cia_decode_mem_error(struct el_CIA_sysdata_mcheck *cia, const char *msg)
 932 {
 933         unsigned long mem_port_addr;
 934         unsigned long mem_port_mask;
 935         const char *mem_port_cmd;
 936         const char *seq_state;
 937         const char *set_select;
 938         unsigned long tmp;
 939
 940         /* If this is a DMA command, also decode the PCI bits.  */
 941         if ((cia->mem_err1 >> 20) & 1)
 942                 cia_decode_pci_error(cia, msg);
 943         else
 944                 printk(KERN_CRIT "CIA machine check: %s\n", msg);
 945
 946         mem_port_addr = cia->mem_err0 & 0xfffffff0;
 947         mem_port_addr |= (cia->mem_err1 & 0x83UL) << 32;
 948
 949         mem_port_mask = (cia->mem_err1 >> 12) & 0xF;
 950
 951         tmp = (cia->mem_err1 >> 8) & 0xF;
 952         tmp |= ((cia->mem_err1 >> 20) & 1) << 4;
 953         if ((tmp & 0x1E) == 0x06)
 954                 mem_port_cmd = "WRITE BLOCK or WRITE BLOCK LOCK";
 955         else if ((tmp & 0x1C) == 0x08)
 956                 mem_port_cmd = "READ MISS or READ MISS MODIFY";
 957         else if (tmp == 0x1C)
 958                 mem_port_cmd = "BC VICTIM";
 959         else if ((tmp & 0x1E) == 0x0E)
 960                 mem_port_cmd = "READ MISS MODIFY";
 961         else if ((tmp & 0x1C) == 0x18)
 962                 mem_port_cmd = "DMA READ or DMA READ MODIFY";
 963         else if ((tmp & 0x1E) == 0x12)
 964                 mem_port_cmd = "DMA WRITE";
 965         else
 966                 mem_port_cmd = "Unknown";
 967
 968         tmp = (cia->mem_err1 >> 16) & 0xF;
 969         switch (tmp) {
 970         case 0x0:
 971                 seq_state = "Idle";
 972                 break;
 973         case 0x1:
 974                 seq_state = "DMA READ or DMA WRITE";
 975                 break;
 976         case 0x2: case 0x3:
 977                 seq_state = "READ MISS (or READ MISS MODIFY) with victim";
 978                 break;
 979         case 0x4: case 0x5: case 0x6:
 980                 seq_state = "READ MISS (or READ MISS MODIFY) with no victim";
 981                 break;
 982         case 0x8: case 0x9: case 0xB:
 983                 seq_state = "Refresh";
 984                 break;
 985         case 0xC:
 986                 seq_state = "Idle, waiting for DMA pending read";
 987                 break;
 988         case 0xE: case 0xF:
 989                 seq_state = "Idle, ras precharge";
 990                 break;
 991         default:
 992                 seq_state = "Unknown";
 993                 break;
 994         }
 995
 996         tmp = (cia->mem_err1 >> 24) & 0x1F;
 997         switch (tmp) {
 998         case 0x00: set_select = "Set 0 selected"; break;
 999         case 0x01: set_select = "Set 1 selected"; break;
1000         case 0x02: set_select = "Set 2 selected"; break;
1001         case 0x03: set_select = "Set 3 selected"; break;
1002         case 0x04: set_select = "Set 4 selected"; break;
1003         case 0x05: set_select = "Set 5 selected"; break;
1004         case 0x06: set_select = "Set 6 selected"; break;
1005         case 0x07: set_select = "Set 7 selected"; break;
1006         case 0x08: set_select = "Set 8 selected"; break;
1007         case 0x09: set_select = "Set 9 selected"; break;
1008         case 0x0A: set_select = "Set A selected"; break;
1009         case 0x0B: set_select = "Set B selected"; break;
1010         case 0x0C: set_select = "Set C selected"; break;
1011         case 0x0D: set_select = "Set D selected"; break;
1012         case 0x0E: set_select = "Set E selected"; break;
1013         case 0x0F: set_select = "Set F selected"; break;
1014         case 0x10: set_select = "No set selected"; break;
1015         case 0x1F: set_select = "Refresh cycle"; break;
1016         default:   set_select = "Unknown"; break;
1017         }
1018
1019         printk(KERN_CRIT "  Memory port command: %s\n", mem_port_cmd);
1020         printk(KERN_CRIT "  Memory port address: %#010lx, mask: %#lx\n",
1021                mem_port_addr, mem_port_mask);
1022         printk(KERN_CRIT "  Memory sequencer state: %s\n", seq_state);
1023         printk(KERN_CRIT "  Memory set: %s\n", set_select);
1024 }
1025
1026 static void
1027 cia_decode_ecc_error(struct el_CIA_sysdata_mcheck *cia, const char *msg)
1028 {
1029         long syn;
1030         long i;
1031         const char *fmt;
1032
1033         cia_decode_mem_error(cia, msg);
1034
1035         syn = cia->cia_syn & 0xff;
1036         if (syn == (syn & -syn)) {
1037                 fmt = KERN_CRIT "  ECC syndrome %#x -- check bit %d\n";
1038                 i = ffs(syn) - 1;
1039         } else {
1040                 static unsigned char const data_bit[64] = {
1041                         0xCE, 0xCB, 0xD3, 0xD5,
1042                         0xD6, 0xD9, 0xDA, 0xDC,
1043                         0x23, 0x25, 0x26, 0x29,
1044                         0x2A, 0x2C, 0x31, 0x34,
1045                         0x0E, 0x0B, 0x13, 0x15,
1046                         0x16, 0x19, 0x1A, 0x1C,
1047                         0xE3, 0xE5, 0xE6, 0xE9,
1048                         0xEA, 0xEC, 0xF1, 0xF4,
1049                         0x4F, 0x4A, 0x52, 0x54,
1050                         0x57, 0x58, 0x5B, 0x5D,
1051                         0xA2, 0xA4, 0xA7, 0xA8,
1052                         0xAB, 0xAD, 0xB0, 0xB5,
1053                         0x8F, 0x8A, 0x92, 0x94,
1054                         0x97, 0x98, 0x9B, 0x9D,
1055                         0x62, 0x64, 0x67, 0x68,
1056                         0x6B, 0x6D, 0x70, 0x75
1057                 };
1058
1059                 for (i = 0; i < 64; ++i)
1060                         if (data_bit[i] == syn)
1061                                 break;
1062
1063                 if (i < 64)
1064                         fmt = KERN_CRIT "  ECC syndrome %#x -- data bit %d\n";
1065                 else
1066                         fmt = KERN_CRIT "  ECC syndrome %#x -- unknown bit\n";
1067         }
1068
1069         printk (fmt, syn, i);
1070 }
1071
1072 static void
1073 cia_decode_parity_error(struct el_CIA_sysdata_mcheck *cia)
1074 {
1075         static const char * const cmd_desc[16] = {
1076                 "NOP", "LOCK", "FETCH", "FETCH_M", "MEMORY BARRIER",
1077                 "SET DIRTY", "WRITE BLOCK", "WRITE BLOCK LOCK",
1078                 "READ MISS0", "READ MISS1", "READ MISS MOD0",
1079                 "READ MISS MOD1", "BCACHE VICTIM", "Spare",
1080                 "READ MISS MOD STC0", "READ MISS MOD STC1"
1081         };
1082
1083         unsigned long addr;
1084         unsigned long mask;
1085         const char *cmd;
1086         int par;
1087
1088         addr = cia->cpu_err0 & 0xfffffff0;
1089         addr |= (cia->cpu_err1 & 0x83UL) << 32;
1090         cmd = cmd_desc[(cia->cpu_err1 >> 8) & 0xF];
1091         mask = (cia->cpu_err1 >> 12) & 0xF;
1092         par = (cia->cpu_err1 >> 21) & 1;
1093
1094         printk(KERN_CRIT "CIA machine check: System bus parity error\n");
1095         printk(KERN_CRIT "  Command: %s, Parity bit: %d\n", cmd, par);
1096         printk(KERN_CRIT "  Address: %#010lx, Mask: %#lx\n", addr, mask);
1097 }
1098 #endif /* CONFIG_VERBOSE_MCHECK */
1099
1100
1101 static int
1102 cia_decode_mchk(unsigned long la_ptr)
1103 {
1104         struct el_common *com;
1105         struct el_CIA_sysdata_mcheck *cia;
1106
1107         com = (void *)la_ptr;
1108         cia = (void *)(la_ptr + com->sys_offset);
1109
1110         if ((cia->cia_err & CIA_ERR_VALID) == 0)
1111                 return 0;
1112
1113 #ifdef CONFIG_VERBOSE_MCHECK
1114         if (!alpha_verbose_mcheck)
1115                 return 1;
1116
1117         switch (ffs(cia->cia_err & 0xfff) - 1) {
1118         case 0: /* CIA_ERR_COR_ERR */
1119                 cia_decode_ecc_error(cia, "Corrected ECC error");
1120                 break;
1121         case 1: /* CIA_ERR_UN_COR_ERR */
1122                 cia_decode_ecc_error(cia, "Uncorrected ECC error");
1123                 break;
1124         case 2: /* CIA_ERR_CPU_PE */
1125                 cia_decode_parity_error(cia);
1126                 break;
1127         case 3: /* CIA_ERR_MEM_NEM */
1128                 cia_decode_mem_error(cia, "Access to nonexistent memory");
1129                 break;
1130         case 4: /* CIA_ERR_PCI_SERR */
1131                 cia_decode_pci_error(cia, "PCI bus system error");
1132                 break;
1133         case 5: /* CIA_ERR_PERR */
1134                 cia_decode_pci_error(cia, "PCI data parity error");
1135                 break;
1136         case 6: /* CIA_ERR_PCI_ADDR_PE */
1137                 cia_decode_pci_error(cia, "PCI address parity error");
1138                 break;
1139         case 7: /* CIA_ERR_RCVD_MAS_ABT */
1140                 cia_decode_pci_error(cia, "PCI master abort");
1141                 break;
1142         case 8: /* CIA_ERR_RCVD_TAR_ABT */
1143                 cia_decode_pci_error(cia, "PCI target abort");
1144                 break;
1145         case 9: /* CIA_ERR_PA_PTE_INV */
1146                 cia_decode_pci_error(cia, "PCI invalid PTE");
1147                 break;
1148         case 10: /* CIA_ERR_FROM_WRT_ERR */
1149                 cia_decode_mem_error(cia, "Write to flash ROM attempted");
1150                 break;
1151         case 11: /* CIA_ERR_IOA_TIMEOUT */
1152                 cia_decode_pci_error(cia, "I/O timeout");
1153                 break;
1154         }
1155
1156         if (cia->cia_err & CIA_ERR_LOST_CORR_ERR)
1157                 printk(KERN_CRIT "CIA lost machine check: "
1158                        "Correctable ECC error\n");
1159         if (cia->cia_err & CIA_ERR_LOST_UN_CORR_ERR)
1160                 printk(KERN_CRIT "CIA lost machine check: "
1161                        "Uncorrectable ECC error\n");
1162         if (cia->cia_err & CIA_ERR_LOST_CPU_PE)
1163                 printk(KERN_CRIT "CIA lost machine check: "
1164                        "System bus parity error\n");
1165         if (cia->cia_err & CIA_ERR_LOST_MEM_NEM)
1166                 printk(KERN_CRIT "CIA lost machine check: "
1167                        "Access to nonexistent memory\n");
1168         if (cia->cia_err & CIA_ERR_LOST_PERR)
1169                 printk(KERN_CRIT "CIA lost machine check: "
1170                        "PCI data parity error\n");
1171         if (cia->cia_err & CIA_ERR_LOST_PCI_ADDR_PE)
1172                 printk(KERN_CRIT "CIA lost machine check: "
1173                        "PCI address parity error\n");
1174         if (cia->cia_err & CIA_ERR_LOST_RCVD_MAS_ABT)
1175                 printk(KERN_CRIT "CIA lost machine check: "
1176                        "PCI master abort\n");
1177         if (cia->cia_err & CIA_ERR_LOST_RCVD_TAR_ABT)
1178                 printk(KERN_CRIT "CIA lost machine check: "
1179                        "PCI target abort\n");
1180         if (cia->cia_err & CIA_ERR_LOST_PA_PTE_INV)
1181                 printk(KERN_CRIT "CIA lost machine check: "
1182                        "PCI invalid PTE\n");
1183         if (cia->cia_err & CIA_ERR_LOST_FROM_WRT_ERR)
1184                 printk(KERN_CRIT "CIA lost machine check: "
1185                        "Write to flash ROM attempted\n");
1186         if (cia->cia_err & CIA_ERR_LOST_IOA_TIMEOUT)
1187                 printk(KERN_CRIT "CIA lost machine check: "
1188                        "I/O timeout\n");
1189 #endif /* CONFIG_VERBOSE_MCHECK */
1190
1191         return 1;
1192 }
1193
1194 void
1195 cia_machine_check(unsigned long vector, unsigned long la_ptr,
1196                   struct pt_regs * regs)
1197 {
1198         int expected;
1199
1200         /* Clear the error before any reporting.  */
1201         mb();
1202         mb();  /* magic */
1203         draina();
1204         cia_pci_clr_err();
1205         wrmces(rdmces());       /* reset machine check pending flag.  */
1206         mb();
1207
1208         expected = mcheck_expected(0);
1209         if (!expected && vector == 0x660)
1210                 expected = cia_decode_mchk(la_ptr);
1211         process_mcheck_info(vector, la_ptr, regs, "CIA", expected);
1212 }