powerpc/powernv: Fix endianness problems in EEH

EEH information fetched from OPAL need fix before using in LE environment.
To be included in sparse's endian check, declare them as __beXX and
access them by accessors.

Cc: Gavin Shan <gwshan@linux.vnet.ibm.com>

Signed-off-by: Guo Chao <yan@linux.vnet.ibm.com>
Acked-by: Gavin Shan <gwshan@linux.vnet.ibm.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>

2 files changed, 69 insertions, 48 deletions

diff --git a/arch/powerpc/platforms/powernv/eeh-ioda.c b/arch/powerpc/platforms/powernv/eeh-ioda.c
index 753f08e36dfa..e0d6a3a213e2 100644
--- a/arch/powerpc/platforms/powernv/eeh-ioda.c
+++ b/arch/powerpc/platforms/powernv/eeh-ioda.c
@@ -267,7 +267,7 @@ static int ioda_eeh_get_state(struct eeh_pe *pe)
 {
         s64 ret = 0;
         u8 fstate;
-        u16 pcierr;
+        __be16 pcierr;
         u32 pe_no;
         int result;
         struct pci_controller *hose = pe->phb;
@@ -316,7 +316,7 @@ static int ioda_eeh_get_state(struct eeh_pe *pe)
                 result = 0;
                 result &= ~EEH_STATE_RESET_ACTIVE;
 
-                if (pcierr != OPAL_EEH_PHB_ERROR) {
+                if (be16_to_cpu(pcierr) != OPAL_EEH_PHB_ERROR) {
                         result |= EEH_STATE_MMIO_ACTIVE;
                         result |= EEH_STATE_DMA_ACTIVE;
                         result |= EEH_STATE_MMIO_ENABLED;
@@ -706,8 +706,8 @@ static int ioda_eeh_next_error(struct eeh_pe **pe)
         struct pci_controller *hose;
         struct pnv_phb *phb;
         struct eeh_pe *phb_pe;
-        u64 frozen_pe_no;
-        u16 err_type, severity;
+        __be64 frozen_pe_no;
+        __be16 err_type, severity;
         long rc;
         int ret = EEH_NEXT_ERR_NONE;
 
@@ -742,8 +742,8 @@ static int ioda_eeh_next_error(struct eeh_pe **pe)
                 }
 
                 /* If the PHB doesn't have error, stop processing */
-                if (err_type == OPAL_EEH_NO_ERROR ||
-                    severity == OPAL_EEH_SEV_NO_ERROR) {
+                if (be16_to_cpu(err_type) == OPAL_EEH_NO_ERROR ||
+                    be16_to_cpu(severity) == OPAL_EEH_SEV_NO_ERROR) {
                         pr_devel("%s: No error found on PHB#%x\n",
                                  __func__, hose->global_number);
                         continue;
@@ -755,14 +755,14 @@ static int ioda_eeh_next_error(struct eeh_pe **pe)
                  * specific PHB.
                  */
                 pr_devel("%s: Error (%d, %d, %llu) on PHB#%x\n",
-                         __func__, err_type, severity,
-                         frozen_pe_no, hose->global_number);
-                switch (err_type) {
+                         __func__, be16_to_cpu(err_type), be16_to_cpu(severity),
+                         be64_to_cpu(frozen_pe_no), hose->global_number);
+                switch (be16_to_cpu(err_type)) {
                 case OPAL_EEH_IOC_ERROR:
-                        if (severity == OPAL_EEH_SEV_IOC_DEAD) {
+                        if (be16_to_cpu(severity) == OPAL_EEH_SEV_IOC_DEAD) {
                                 pr_err("EEH: dead IOC detected\n");
                                 ret = EEH_NEXT_ERR_DEAD_IOC;
-                        } else if (severity == OPAL_EEH_SEV_INF) {
+                        } else if (be16_to_cpu(severity) == OPAL_EEH_SEV_INF) {
                                 pr_info("EEH: IOC informative error "
                                         "detected\n");
                                 ioda_eeh_hub_diag(hose);
@@ -771,17 +771,18 @@ static int ioda_eeh_next_error(struct eeh_pe **pe)
 
                         break;
                 case OPAL_EEH_PHB_ERROR:
-                        if (severity == OPAL_EEH_SEV_PHB_DEAD) {
+                        if (be16_to_cpu(severity) == OPAL_EEH_SEV_PHB_DEAD) {
                                 *pe = phb_pe;
                                 pr_err("EEH: dead PHB#%x detected\n",
                                         hose->global_number);
                                 ret = EEH_NEXT_ERR_DEAD_PHB;
-                        } else if (severity == OPAL_EEH_SEV_PHB_FENCED) {
+                        } else if (be16_to_cpu(severity) ==
+                                                OPAL_EEH_SEV_PHB_FENCED) {
                                 *pe = phb_pe;
                                 pr_err("EEH: fenced PHB#%x detected\n",
                                         hose->global_number);
                                 ret = EEH_NEXT_ERR_FENCED_PHB;
-                        } else if (severity == OPAL_EEH_SEV_INF) {
+                        } else if (be16_to_cpu(severity) == OPAL_EEH_SEV_INF) {
                                 pr_info("EEH: PHB#%x informative error "
                                         "detected\n",
                                         hose->global_number);
@@ -801,12 +802,13 @@ static int ioda_eeh_next_error(struct eeh_pe **pe)
                          * progress with recovery. We needn't report
                          * it again.
                          */
-                        if (ioda_eeh_get_pe(hose, frozen_pe_no, pe)) {
+                        if (ioda_eeh_get_pe(hose,
+                                        be64_to_cpu(frozen_pe_no), pe)) {
                                 *pe = phb_pe;
                                 pr_err("EEH: Escalated fenced PHB#%x "
                                        "detected for PE#%llx\n",
                                         hose->global_number,
-                                        frozen_pe_no);
+                                        be64_to_cpu(frozen_pe_no));
                                 ret = EEH_NEXT_ERR_FENCED_PHB;
                         } else if ((*pe)->state & EEH_PE_ISOLATED) {
                                 ret = EEH_NEXT_ERR_NONE;
@@ -819,7 +821,7 @@ static int ioda_eeh_next_error(struct eeh_pe **pe)
                         break;
                 default:
                         pr_warn("%s: Unexpected error type %d\n",
-                                __func__, err_type);
+                                __func__, be16_to_cpu(err_type));
                 }
 
                 /*
diff --git a/arch/powerpc/platforms/powernv/pci.c b/arch/powerpc/platforms/powernv/pci.c
index eefbfcc3fd8c..f91a4e5d872e 100644
--- a/arch/powerpc/platforms/powernv/pci.c
+++ b/arch/powerpc/platforms/powernv/pci.c
@@ -206,72 +206,91 @@ static void pnv_pci_dump_phb3_diag_data(struct pci_controller *hose,
 
         data = (struct OpalIoPhb3ErrorData*)common;
         pr_info("PHB3 PHB#%d Diag-data (Version: %d)\n",
-                hose->global_number, common->version);
+                hose->global_number, be32_to_cpu(common->version));
         if (data->brdgCtl)
                 pr_info("brdgCtl:     %08x\n",
-                        data->brdgCtl);
+                        be32_to_cpu(data->brdgCtl));
         if (data->portStatusReg || data->rootCmplxStatus ||
             data->busAgentStatus)
                 pr_info("UtlSts:      %08x %08x %08x\n",
-                        data->portStatusReg, data->rootCmplxStatus,
-                        data->busAgentStatus);
+                        be32_to_cpu(data->portStatusReg),
+                        be32_to_cpu(data->rootCmplxStatus),
+                        be32_to_cpu(data->busAgentStatus));
         if (data->deviceStatus || data->slotStatus   ||
             data->linkStatus   || data->devCmdStatus ||
             data->devSecStatus)
                 pr_info("RootSts:     %08x %08x %08x %08x %08x\n",
-                        data->deviceStatus, data->slotStatus,
-                        data->linkStatus, data->devCmdStatus,
-                        data->devSecStatus);
+                        be32_to_cpu(data->deviceStatus),
+                        be32_to_cpu(data->slotStatus),
+                        be32_to_cpu(data->linkStatus),
+                        be32_to_cpu(data->devCmdStatus),
+                        be32_to_cpu(data->devSecStatus));
         if (data->rootErrorStatus || data->uncorrErrorStatus ||
             data->corrErrorStatus)
                 pr_info("RootErrSts:  %08x %08x %08x\n",
-                        data->rootErrorStatus, data->uncorrErrorStatus,
-                        data->corrErrorStatus);
+                        be32_to_cpu(data->rootErrorStatus),
+                        be32_to_cpu(data->uncorrErrorStatus),
+                        be32_to_cpu(data->corrErrorStatus));
         if (data->tlpHdr1 || data->tlpHdr2 ||
             data->tlpHdr3 || data->tlpHdr4)
                 pr_info("RootErrLog:  %08x %08x %08x %08x\n",
-                        data->tlpHdr1, data->tlpHdr2,
-                        data->tlpHdr3, data->tlpHdr4);
+                        be32_to_cpu(data->tlpHdr1),
+                        be32_to_cpu(data->tlpHdr2),
+                        be32_to_cpu(data->tlpHdr3),
+                        be32_to_cpu(data->tlpHdr4));
         if (data->sourceId || data->errorClass ||
             data->correlator)
                 pr_info("RootErrLog1: %08x %016llx %016llx\n",
-                        data->sourceId, data->errorClass,
-                        data->correlator);
+                        be32_to_cpu(data->sourceId),
+                        be64_to_cpu(data->errorClass),
+                        be64_to_cpu(data->correlator));
         if (data->nFir)
                 pr_info("nFir:        %016llx %016llx %016llx\n",
-                        data->nFir, data->nFirMask,
-                        data->nFirWOF);
+                        be64_to_cpu(data->nFir),
+                        be64_to_cpu(data->nFirMask),
+                        be64_to_cpu(data->nFirWOF));
         if (data->phbPlssr || data->phbCsr)
                 pr_info("PhbSts:      %016llx %016llx\n",
-                        data->phbPlssr, data->phbCsr);
+                        be64_to_cpu(data->phbPlssr),
+                        be64_to_cpu(data->phbCsr));
         if (data->lemFir)
                 pr_info("Lem:         %016llx %016llx %016llx\n",
-                        data->lemFir, data->lemErrorMask,
-                        data->lemWOF);
+                        be64_to_cpu(data->lemFir),
+                        be64_to_cpu(data->lemErrorMask),
+                        be64_to_cpu(data->lemWOF));
         if (data->phbErrorStatus)
                 pr_info("PhbErr:      %016llx %016llx %016llx %016llx\n",
-                        data->phbErrorStatus, data->phbFirstErrorStatus,
-                        data->phbErrorLog0, data->phbErrorLog1);
+                        be64_to_cpu(data->phbErrorStatus),
+                        be64_to_cpu(data->phbFirstErrorStatus),
+                        be64_to_cpu(data->phbErrorLog0),
+                        be64_to_cpu(data->phbErrorLog1));
         if (data->mmioErrorStatus)
                 pr_info("OutErr:      %016llx %016llx %016llx %016llx\n",
-                        data->mmioErrorStatus, data->mmioFirstErrorStatus,
-                        data->mmioErrorLog0, data->mmioErrorLog1);
+                        be64_to_cpu(data->mmioErrorStatus),
+                        be64_to_cpu(data->mmioFirstErrorStatus),
+                        be64_to_cpu(data->mmioErrorLog0),
+                        be64_to_cpu(data->mmioErrorLog1));
         if (data->dma0ErrorStatus)
                 pr_info("InAErr:      %016llx %016llx %016llx %016llx\n",
-                        data->dma0ErrorStatus, data->dma0FirstErrorStatus,
-                        data->dma0ErrorLog0, data->dma0ErrorLog1);
+                        be64_to_cpu(data->dma0ErrorStatus),
+                        be64_to_cpu(data->dma0FirstErrorStatus),
+                        be64_to_cpu(data->dma0ErrorLog0),
+                        be64_to_cpu(data->dma0ErrorLog1));
         if (data->dma1ErrorStatus)
                 pr_info("InBErr:      %016llx %016llx %016llx %016llx\n",
-                        data->dma1ErrorStatus, data->dma1FirstErrorStatus,
-                        data->dma1ErrorLog0, data->dma1ErrorLog1);
+                        be64_to_cpu(data->dma1ErrorStatus),
+                        be64_to_cpu(data->dma1FirstErrorStatus),
+                        be64_to_cpu(data->dma1ErrorLog0),
+                        be64_to_cpu(data->dma1ErrorLog1));
 
         for (i = 0; i < OPAL_PHB3_NUM_PEST_REGS; i++) {
-                if ((data->pestA[i] >> 63) == 0 &&
-                    (data->pestB[i] >> 63) == 0)
+                if ((be64_to_cpu(data->pestA[i]) >> 63) == 0 &&
+                    (be64_to_cpu(data->pestB[i]) >> 63) == 0)
                         continue;
 
                 pr_info("PE[%3d] A/B: %016llx %016llx\n",
-                        i, data->pestA[i], data->pestB[i]);
+                                i, be64_to_cpu(data->pestA[i]),
+                                be64_to_cpu(data->pestB[i]));
         }
 }
 
@@ -284,7 +303,7 @@ void pnv_pci_dump_phb_diag_data(struct pci_controller *hose,
                 return;
 
         common = (struct OpalIoPhbErrorCommon *)log_buff;
-        switch (common->ioType) {
+        switch (be32_to_cpu(common->ioType)) {
         case OPAL_PHB_ERROR_DATA_TYPE_P7IOC:
                 pnv_pci_dump_p7ioc_diag_data(hose, common);
                 break;
@@ -293,7 +312,7 @@ void pnv_pci_dump_phb_diag_data(struct pci_controller *hose,
                 break;
         default:
                 pr_warn("%s: Unrecognized ioType %d\n",
-                        __func__, common->ioType);
+                        __func__, be32_to_cpu(common->ioType));
         }
 }