1 files changed, 73 insertions, 94 deletions

diff --git a/arch/sparc64/kernel/pci_schizo.c b/arch/sparc64/kernel/pci_schizo.c
index c30856541bb4..45d9dba1ba11 100644
--- a/arch/sparc64/kernel/pci_schizo.c
+++ b/arch/sparc64/kernel/pci_schizo.c
@@ -15,6 +15,7 @@
 #include <asm/irq.h>
 #include <asm/pstate.h>
 #include <asm/prom.h>
+#include <asm/upa.h>
 
 #include "pci_impl.h"
 #include "iommu_common.h"
@@ -22,25 +23,6 @@
 #define DRIVER_NAME     "schizo"
 #define PFX             DRIVER_NAME ": "
 
-/* All SCHIZO registers are 64-bits.  The following accessor
- * routines are how they are accessed.  The REG parameter
- * is a physical address.
- */
-#define schizo_read(__reg) \
-({      u64 __ret; \
-        __asm__ __volatile__("ldxa [%1] %2, %0" \
-                             : "=r" (__ret) \
-                             : "r" (__reg), "i" (ASI_PHYS_BYPASS_EC_E) \
-                             : "memory"); \
-        __ret; \
-})
-#define schizo_write(__reg, __val) \
-        __asm__ __volatile__("stxa %0, [%1] %2" \
-                             : /* no outputs */ \
-                             : "r" (__val), "r" (__reg), \
-                               "i" (ASI_PHYS_BYPASS_EC_E) \
-                             : "memory")
-
 /* This is a convention that at least Excalibur and Merlin
  * follow.  I suppose the SCHIZO used in Starcat and friends
  * will do similar.
@@ -164,25 +146,25 @@ static void __schizo_check_stc_error_pbm(struct pci_pbm_info *pbm,
          * invalidating it before it has a chance to reach
          * main memory.
          */
-        control = schizo_read(strbuf->strbuf_control);
-        schizo_write(strbuf->strbuf_control,
-                     (control | SCHIZO_STRBUF_CTRL_DENAB));
+        control = upa_readq(strbuf->strbuf_control);
+        upa_writeq((control | SCHIZO_STRBUF_CTRL_DENAB),
+                   strbuf->strbuf_control);
         for (i = 0; i < 128; i++) {
                 unsigned long val;
 
-                val = schizo_read(err_base + (i * 8UL));
-                schizo_write(err_base + (i * 8UL), 0UL);
+                val = upa_readq(err_base + (i * 8UL));
+                upa_writeq(0UL, err_base + (i * 8UL));
                 stc_error_buf[i] = val;
         }
         for (i = 0; i < 16; i++) {
-                stc_tag_buf[i] = schizo_read(tag_base + (i * 8UL));
-                stc_line_buf[i] = schizo_read(line_base + (i * 8UL));
-                schizo_write(tag_base + (i * 8UL), 0UL);
-                schizo_write(line_base + (i * 8UL), 0UL);
+                stc_tag_buf[i] = upa_readq(tag_base + (i * 8UL));
+                stc_line_buf[i] = upa_readq(line_base + (i * 8UL));
+                upa_writeq(0UL, tag_base + (i * 8UL));
+                upa_writeq(0UL, line_base + (i * 8UL));
         }
 
         /* OK, state is logged, exit diagnostic mode. */
-        schizo_write(strbuf->strbuf_control, control);
+        upa_writeq(control, strbuf->strbuf_control);
 
         for (i = 0; i < 16; i++) {
                 int j, saw_error, first, last;
@@ -259,14 +241,14 @@ static void schizo_check_iommu_error_pbm(struct pci_pbm_info *pbm,
         int i;
 
         spin_lock_irqsave(&iommu->lock, flags);
-        control = schizo_read(iommu->iommu_control);
+        control = upa_readq(iommu->iommu_control);
         if (control & SCHIZO_IOMMU_CTRL_XLTEERR) {
                 unsigned long base;
                 char *type_string;
 
                 /* Clear the error encountered bit. */
                 control &= ~SCHIZO_IOMMU_CTRL_XLTEERR;
-                schizo_write(iommu->iommu_control, control);
+                upa_writeq(control, iommu->iommu_control);
 
                 switch((control & SCHIZO_IOMMU_CTRL_XLTESTAT) >> 25UL) {
                 case 0:
@@ -296,24 +278,24 @@ static void schizo_check_iommu_error_pbm(struct pci_pbm_info *pbm,
                  * get as much diagnostic information to the
                  * console as we can.
                  */
-                schizo_write(iommu->iommu_control,
-                             control | SCHIZO_IOMMU_CTRL_DENAB);
+                upa_writeq(control | SCHIZO_IOMMU_CTRL_DENAB,
+                           iommu->iommu_control);
 
                 base = pbm->pbm_regs;
 
                 for (i = 0; i < 16; i++) {
                         iommu_tag[i] =
-                                schizo_read(base + SCHIZO_IOMMU_TAG + (i * 8UL));
+                                upa_readq(base + SCHIZO_IOMMU_TAG + (i * 8UL));
                         iommu_data[i] =
-                                schizo_read(base + SCHIZO_IOMMU_DATA + (i * 8UL));
+                                upa_readq(base + SCHIZO_IOMMU_DATA + (i * 8UL));
 
                         /* Now clear out the entry. */
-                        schizo_write(base + SCHIZO_IOMMU_TAG + (i * 8UL), 0);
-                        schizo_write(base + SCHIZO_IOMMU_DATA + (i * 8UL), 0);
+                        upa_writeq(0, base + SCHIZO_IOMMU_TAG + (i * 8UL));
+                        upa_writeq(0, base + SCHIZO_IOMMU_DATA + (i * 8UL));
                 }
 
                 /* Leave diagnostic mode. */
-                schizo_write(iommu->iommu_control, control);
+                upa_writeq(control, iommu->iommu_control);
 
                 for (i = 0; i < 16; i++) {
                         unsigned long tag, data;
@@ -394,7 +376,7 @@ static irqreturn_t schizo_ue_intr(int irq, void *dev_id)
         int reported, limit;
 
         /* Latch uncorrectable error status. */
-        afar = schizo_read(afar_reg);
+        afar = upa_readq(afar_reg);
 
         /* If either of the error pending bits are set in the
          * AFSR, the error status is being actively updated by
@@ -402,7 +384,7 @@ static irqreturn_t schizo_ue_intr(int irq, void *dev_id)
          */
         limit = 1000;
         do {
-                afsr = schizo_read(afsr_reg);
+                afsr = upa_readq(afsr_reg);
         } while ((afsr & SCHIZO_UEAFSR_ERRPNDG) != 0 && --limit);
 
         /* Clear the primary/secondary error status bits. */
@@ -411,7 +393,7 @@ static irqreturn_t schizo_ue_intr(int irq, void *dev_id)
                  SCHIZO_UEAFSR_SPIO | SCHIZO_UEAFSR_SDMA);
         if (!error_bits)
                 return IRQ_NONE;
-        schizo_write(afsr_reg, error_bits);
+        upa_writeq(error_bits, afsr_reg);
 
         /* Log the error. */
         printk("%s: Uncorrectable Error, primary error type[%s]\n",
@@ -482,7 +464,7 @@ static irqreturn_t schizo_ce_intr(int irq, void *dev_id)
         int reported, limit;
 
         /* Latch error status. */
-        afar = schizo_read(afar_reg);
+        afar = upa_readq(afar_reg);
 
         /* If either of the error pending bits are set in the
          * AFSR, the error status is being actively updated by
@@ -490,7 +472,7 @@ static irqreturn_t schizo_ce_intr(int irq, void *dev_id)
          */
         limit = 1000;
         do {
-                afsr = schizo_read(afsr_reg);
+                afsr = upa_readq(afsr_reg);
         } while ((afsr & SCHIZO_UEAFSR_ERRPNDG) != 0 && --limit);
 
         /* Clear primary/secondary error status bits. */
@@ -499,7 +481,7 @@ static irqreturn_t schizo_ce_intr(int irq, void *dev_id)
                  SCHIZO_CEAFSR_SPIO | SCHIZO_CEAFSR_SDMA);
         if (!error_bits)
                 return IRQ_NONE;
-        schizo_write(afsr_reg, error_bits);
+        upa_writeq(error_bits, afsr_reg);
 
         /* Log the error. */
         printk("%s: Correctable Error, primary error type[%s]\n",
@@ -601,7 +583,7 @@ static irqreturn_t schizo_pcierr_intr_other(struct pci_pbm_info *pbm)
         u16 stat;
 
         csr_reg = pbm->pbm_regs + SCHIZO_PCI_CTRL;
-        csr = schizo_read(csr_reg);
+        csr = upa_readq(csr_reg);
         csr_error_bits =
                 csr & (SCHIZO_PCICTRL_BUS_UNUS |
                        SCHIZO_PCICTRL_TTO_ERR |
@@ -611,7 +593,7 @@ static irqreturn_t schizo_pcierr_intr_other(struct pci_pbm_info *pbm)
                        SCHIZO_PCICTRL_SERR);
         if (csr_error_bits) {
                 /* Clear the errors.  */
-                schizo_write(csr_reg, csr);
+                upa_writeq(csr, csr_reg);
 
                 /* Log 'em.  */
                 if (csr_error_bits & SCHIZO_PCICTRL_BUS_UNUS)
@@ -661,8 +643,8 @@ static irqreturn_t schizo_pcierr_intr(int irq, void *dev_id)
         afar_reg = base + SCHIZO_PCI_AFAR;
 
         /* Latch error status. */
-        afar = schizo_read(afar_reg);
-        afsr = schizo_read(afsr_reg);
+        afar = upa_readq(afar_reg);
+        afsr = upa_readq(afsr_reg);
 
         /* Clear primary/secondary error status bits. */
         error_bits = afsr &
@@ -674,7 +656,7 @@ static irqreturn_t schizo_pcierr_intr(int irq, void *dev_id)
                  SCHIZO_PCIAFSR_STTO | SCHIZO_PCIAFSR_SUNUS);
         if (!error_bits)
                 return schizo_pcierr_intr_other(pbm);
-        schizo_write(afsr_reg, error_bits);
+        upa_writeq(error_bits, afsr_reg);
 
         /* Log the error. */
         printk("%s: PCI Error, primary error type[%s]\n",
@@ -807,9 +789,9 @@ static irqreturn_t schizo_safarierr_intr(int irq, void *dev_id)
         struct pci_pbm_info *pbm = dev_id;
         u64 errlog;
 
-        errlog = schizo_read(pbm->controller_regs + SCHIZO_SAFARI_ERRLOG);
-        schizo_write(pbm->controller_regs + SCHIZO_SAFARI_ERRLOG,
-                     errlog & ~(SAFARI_ERRLOG_ERROUT));
+        errlog = upa_readq(pbm->controller_regs + SCHIZO_SAFARI_ERRLOG);
+        upa_writeq(errlog & ~(SAFARI_ERRLOG_ERROUT),
+                   pbm->controller_regs + SCHIZO_SAFARI_ERRLOG);
 
         if (!(errlog & BUS_ERROR_UNMAP)) {
                 printk("%s: Unexpected Safari/JBUS error interrupt, errlog[%016lx]\n",
@@ -909,10 +891,9 @@ static void tomatillo_register_error_handlers(struct pci_pbm_info *pbm)
         }
 
         /* Enable UE and CE interrupts for controller. */
-        schizo_write(pbm->controller_regs + SCHIZO_ECC_CTRL,
-                     (SCHIZO_ECCCTRL_EE |
-                      SCHIZO_ECCCTRL_UE |
-                      SCHIZO_ECCCTRL_CE));
+        upa_writeq((SCHIZO_ECCCTRL_EE |
+                    SCHIZO_ECCCTRL_UE |
+                    SCHIZO_ECCCTRL_CE), pbm->controller_regs + SCHIZO_ECC_CTRL);
 
         /* Enable PCI Error interrupts and clear error
          * bits.
@@ -925,10 +906,10 @@ static void tomatillo_register_error_handlers(struct pci_pbm_info *pbm)
 
         err_no_mask = SCHIZO_PCICTRL_DTO_ERR;
 
-        tmp = schizo_read(pbm->pbm_regs + SCHIZO_PCI_CTRL);
+        tmp = upa_readq(pbm->pbm_regs + SCHIZO_PCI_CTRL);
         tmp |= err_mask;
         tmp &= ~err_no_mask;
-        schizo_write(pbm->pbm_regs + SCHIZO_PCI_CTRL, tmp);
+        upa_writeq(tmp, pbm->pbm_regs + SCHIZO_PCI_CTRL);
 
         err_mask = (SCHIZO_PCIAFSR_PMA | SCHIZO_PCIAFSR_PTA |
                     SCHIZO_PCIAFSR_PRTRY | SCHIZO_PCIAFSR_PPERR |
@@ -937,7 +918,7 @@ static void tomatillo_register_error_handlers(struct pci_pbm_info *pbm)
                     SCHIZO_PCIAFSR_SRTRY | SCHIZO_PCIAFSR_SPERR |
                     SCHIZO_PCIAFSR_STTO);
 
-        schizo_write(pbm->pbm_regs + SCHIZO_PCI_AFSR, err_mask);
+        upa_writeq(err_mask, pbm->pbm_regs + SCHIZO_PCI_AFSR);
 
         err_mask = (BUS_ERROR_BADCMD | BUS_ERROR_SNOOP_GR |
                     BUS_ERROR_SNOOP_PCI | BUS_ERROR_SNOOP_RD |
@@ -949,11 +930,11 @@ static void tomatillo_register_error_handlers(struct pci_pbm_info *pbm)
                     BUS_ERROR_APERR | BUS_ERROR_UNMAP |
                     BUS_ERROR_BUSERR | BUS_ERROR_TIMEOUT);
 
-        schizo_write(pbm->controller_regs + SCHIZO_SAFARI_ERRCTRL,
-                     (SCHIZO_SAFERRCTRL_EN | err_mask));
+        upa_writeq((SCHIZO_SAFERRCTRL_EN | err_mask),
+                   pbm->controller_regs + SCHIZO_SAFARI_ERRCTRL);
 
-        schizo_write(pbm->controller_regs + SCHIZO_SAFARI_IRQCTRL,
-                     (SCHIZO_SAFIRQCTRL_EN | (BUS_ERROR_UNMAP)));
+        upa_writeq((SCHIZO_SAFIRQCTRL_EN | (BUS_ERROR_UNMAP)),
+                   pbm->controller_regs + SCHIZO_SAFARI_IRQCTRL);
 }
 
 static void schizo_register_error_handlers(struct pci_pbm_info *pbm)
@@ -1005,10 +986,9 @@ static void schizo_register_error_handlers(struct pci_pbm_info *pbm)
         }
 
         /* Enable UE and CE interrupts for controller. */
-        schizo_write(pbm->controller_regs + SCHIZO_ECC_CTRL,
-                     (SCHIZO_ECCCTRL_EE |
-                      SCHIZO_ECCCTRL_UE |
-                      SCHIZO_ECCCTRL_CE));
+        upa_writeq((SCHIZO_ECCCTRL_EE |
+                    SCHIZO_ECCCTRL_UE |
+                    SCHIZO_ECCCTRL_CE), pbm->controller_regs + SCHIZO_ECC_CTRL);
 
         err_mask = (SCHIZO_PCICTRL_BUS_UNUS |
                     SCHIZO_PCICTRL_ESLCK |
@@ -1024,18 +1004,18 @@ static void schizo_register_error_handlers(struct pci_pbm_info *pbm)
         /* Enable PCI Error interrupts and clear error
          * bits for each PBM.
          */
-        tmp = schizo_read(pbm->pbm_regs + SCHIZO_PCI_CTRL);
+        tmp = upa_readq(pbm->pbm_regs + SCHIZO_PCI_CTRL);
         tmp |= err_mask;
         tmp &= ~err_no_mask;
-        schizo_write(pbm->pbm_regs + SCHIZO_PCI_CTRL, tmp);
+        upa_writeq(tmp, pbm->pbm_regs + SCHIZO_PCI_CTRL);
 
-        schizo_write(pbm->pbm_regs + SCHIZO_PCI_AFSR,
-                     (SCHIZO_PCIAFSR_PMA | SCHIZO_PCIAFSR_PTA |
-                      SCHIZO_PCIAFSR_PRTRY | SCHIZO_PCIAFSR_PPERR |
-                      SCHIZO_PCIAFSR_PTTO | SCHIZO_PCIAFSR_PUNUS |
-                      SCHIZO_PCIAFSR_SMA | SCHIZO_PCIAFSR_STA |
-                      SCHIZO_PCIAFSR_SRTRY | SCHIZO_PCIAFSR_SPERR |
-                      SCHIZO_PCIAFSR_STTO | SCHIZO_PCIAFSR_SUNUS));
+        upa_writeq((SCHIZO_PCIAFSR_PMA | SCHIZO_PCIAFSR_PTA |
+                    SCHIZO_PCIAFSR_PRTRY | SCHIZO_PCIAFSR_PPERR |
+                    SCHIZO_PCIAFSR_PTTO | SCHIZO_PCIAFSR_PUNUS |
+                    SCHIZO_PCIAFSR_SMA | SCHIZO_PCIAFSR_STA |
+                    SCHIZO_PCIAFSR_SRTRY | SCHIZO_PCIAFSR_SPERR |
+                    SCHIZO_PCIAFSR_STTO | SCHIZO_PCIAFSR_SUNUS),
+                   pbm->pbm_regs + SCHIZO_PCI_AFSR);
 
         /* Make all Safari error conditions fatal except unmapped
          * errors which we make generate interrupts.
@@ -1062,8 +1042,8 @@ static void schizo_register_error_handlers(struct pci_pbm_info *pbm)
                       BUS_ERROR_CPU0PS | BUS_ERROR_CPU0PB);
 #endif
 
-        schizo_write(pbm->controller_regs + SCHIZO_SAFARI_ERRCTRL,
-                     (SCHIZO_SAFERRCTRL_EN | err_mask));
+        upa_writeq((SCHIZO_SAFERRCTRL_EN | err_mask),
+                   pbm->controller_regs + SCHIZO_SAFARI_ERRCTRL);
 }
 
 static void pbm_config_busmastering(struct pci_pbm_info *pbm)
@@ -1133,12 +1113,12 @@ static void schizo_pbm_strbuf_init(struct pci_pbm_info *pbm)
          * streaming buffer and leave the rerun-disable
          * setting however OBP set it.
          */
-        control = schizo_read(pbm->stc.strbuf_control);
+        control = upa_readq(pbm->stc.strbuf_control);
         control &= ~(SCHIZO_STRBUF_CTRL_LPTR |
                      SCHIZO_STRBUF_CTRL_LENAB |
                      SCHIZO_STRBUF_CTRL_DENAB);
         control |= SCHIZO_STRBUF_CTRL_ENAB;
-        schizo_write(pbm->stc.strbuf_control, control);
+        upa_writeq(control, pbm->stc.strbuf_control);
 
         pbm->stc.strbuf_enabled = 1;
 }
@@ -1199,15 +1179,15 @@ static int schizo_pbm_iommu_init(struct pci_pbm_info *pbm)
         /*
          * Invalidate TLB Entries.
          */
-        control = schizo_read(iommu->iommu_control);
+        control = upa_readq(iommu->iommu_control);
         control |= SCHIZO_IOMMU_CTRL_DENAB;
-        schizo_write(iommu->iommu_control, control);
+        upa_writeq(control, iommu->iommu_control);
 
         tagbase = SCHIZO_IOMMU_TAG, database = SCHIZO_IOMMU_DATA;
 
         for (i = 0; i < 16; i++) {
-                schizo_write(pbm->pbm_regs + tagbase + (i * 8UL), 0);
-                schizo_write(pbm->pbm_regs + database + (i * 8UL), 0);
+                upa_writeq(0, pbm->pbm_regs + tagbase + (i * 8UL));
+                upa_writeq(0, pbm->pbm_regs + database + (i * 8UL));
         }
 
         /* Leave diag mode enabled for full-flushing done
@@ -1220,9 +1200,9 @@ static int schizo_pbm_iommu_init(struct pci_pbm_info *pbm)
                 return err;
         }
 
-        schizo_write(iommu->iommu_tsbbase, __pa(iommu->page_table));
+        upa_writeq(__pa(iommu->page_table), iommu->iommu_tsbbase);
 
-        control = schizo_read(iommu->iommu_control);
+        control = upa_readq(iommu->iommu_control);
         control &= ~(SCHIZO_IOMMU_CTRL_TSBSZ | SCHIZO_IOMMU_CTRL_TBWSZ);
         switch (tsbsize) {
         case 64:
@@ -1234,7 +1214,7 @@ static int schizo_pbm_iommu_init(struct pci_pbm_info *pbm)
         }
 
         control |= SCHIZO_IOMMU_CTRL_ENAB;
-        schizo_write(iommu->iommu_control, control);
+        upa_writeq(control, iommu->iommu_control);
 
         return 0;
 }
@@ -1277,9 +1257,9 @@ static void schizo_pbm_hw_init(struct pci_pbm_info *pbm)
 {
         u64 tmp;
 
-        schizo_write(pbm->pbm_regs + SCHIZO_PCI_IRQ_RETRY, 5);
+        upa_writeq(5, pbm->pbm_regs + SCHIZO_PCI_IRQ_RETRY);
 
-        tmp = schizo_read(pbm->pbm_regs + SCHIZO_PCI_CTRL);
+        tmp = upa_readq(pbm->pbm_regs + SCHIZO_PCI_CTRL);
 
         /* Enable arbiter for all PCI slots.  */
         tmp |= 0xff;
@@ -1304,13 +1284,13 @@ static void schizo_pbm_hw_init(struct pci_pbm_info *pbm)
                         SCHIZO_PCICTRL_RDO_PREF |
                         SCHIZO_PCICTRL_RDL_PREF);
 
-        schizo_write(pbm->pbm_regs + SCHIZO_PCI_CTRL, tmp);
+        upa_writeq(tmp, pbm->pbm_regs + SCHIZO_PCI_CTRL);
 
-        tmp = schizo_read(pbm->pbm_regs + SCHIZO_PCI_DIAG);
+        tmp = upa_readq(pbm->pbm_regs + SCHIZO_PCI_DIAG);
         tmp &= ~(SCHIZO_PCIDIAG_D_RTRYARB |
                  SCHIZO_PCIDIAG_D_RETRY |
                  SCHIZO_PCIDIAG_D_INTSYNC);
-        schizo_write(pbm->pbm_regs + SCHIZO_PCI_DIAG, tmp);
+        upa_writeq(tmp, pbm->pbm_regs + SCHIZO_PCI_DIAG);
 
         if (pbm->chip_type == PBM_CHIP_TYPE_TOMATILLO) {
                 /* Clear prefetch lengths to workaround a bug in
@@ -1322,8 +1302,7 @@ static void schizo_pbm_hw_init(struct pci_pbm_info *pbm)
                        TOMATILLO_IOC_RDONE_CPENAB |
                        TOMATILLO_IOC_RDLINE_CPENAB);
 
-                schizo_write(pbm->pbm_regs + TOMATILLO_PCI_IOC_CSR,
-                             tmp);
+                upa_writeq(tmp, pbm->pbm_regs + TOMATILLO_PCI_IOC_CSR);
         }
 }