fsp: endian conversions

Reviewed-by: Vasant Hegde <hegdevasant@linux.vnet.ibm.com>
Signed-off-by: Nicholas Piggin <npiggin@gmail.com>
Signed-off-by: Oliver O'Halloran <oohall@gmail.com>

5 files changed, 98 insertions, 47 deletions

diff --git a/platforms/ibm-fsp/common.c b/platforms/ibm-fsp/common.c
index c288bff..b58b073 100644
--- a/platforms/ibm-fsp/common.c
+++ b/platforms/ibm-fsp/common.c
@@ -238,7 +238,7 @@ int64_t ibm_fsp_cec_power_down(uint64_t request)
 }
 
 int64_t ibm_fsp_sensor_read(uint32_t sensor_hndl, int token,
-				uint64_t *sensor_data)
+				__be64 *sensor_data)
 {
 	return fsp_opal_read_sensor(sensor_hndl, token, sensor_data);
 }
diff --git a/platforms/ibm-fsp/firenze-pci.c b/platforms/ibm-fsp/firenze-pci.c
index da49672..6d5aab1 100644
--- a/platforms/ibm-fsp/firenze-pci.c
+++ b/platforms/ibm-fsp/firenze-pci.c
@@ -94,22 +94,22 @@ struct firenze_pci_slot_fixup_info {
 };
 
 struct firenze_pci_inv {
-	uint32_t	hw_proc_id;
-	uint16_t	slot_idx;
-	uint16_t	reserved;
-	uint16_t	vendor_id;
-	uint16_t	device_id;
-	uint16_t	subsys_vendor_id;
-	uint16_t	subsys_device_id;
-};
+	__be32		hw_proc_id;
+	__be16		slot_idx;
+	__be16		reserved;
+	__be16		vendor_id;
+	__be16		device_id;
+	__be16		subsys_vendor_id;
+	__be16		subsys_device_id;
+} __packed;
 
 struct firenze_pci_inv_data {
-	uint32_t                version;	/* currently 1 */
-	uint32_t                num_entries;
-	uint32_t                entry_size;
-	uint32_t                entry_offset;
+	__be32			version;	/* currently 1 */
+	__be32			num_entries;
+	__be32			entry_size;
+	__be32			entry_offset;
 	struct firenze_pci_inv	entries[];
-};
+} __packed;
 
 /*
  * Note: According to Tuleta system workbook, I didn't figure
@@ -159,6 +159,8 @@ static void firenze_pci_add_inventory(struct phb *phb,
 	struct proc_chip *chip;
 	size_t size;
 	bool need_init = false;
+	u32 num_entries;
+	u16 tmp16;
 
 	/*
 	 * Do we need to add that to the FSP inventory for power
@@ -191,7 +193,7 @@ static void firenze_pci_add_inventory(struct phb *phb,
 
 	/* Check if we need to do some (Re)allocation */
 	if (!firenze_inv_data ||
-            firenze_inv_data->num_entries == firenze_inv_cnt) {
+            be32_to_cpu(firenze_inv_data->num_entries) == firenze_inv_cnt) {
 		need_init = !firenze_inv_data;
 
 		/* (Re)allocate the block to the new size */
@@ -203,16 +205,18 @@ static void firenze_pci_add_inventory(struct phb *phb,
 
 	/* Initialize the header for a new inventory */
 	if (need_init) {
-		firenze_inv_data->version = 1;
+		firenze_inv_data->version = cpu_to_be32(1);
 		firenze_inv_data->num_entries = 0;
 		firenze_inv_data->entry_size =
-			sizeof(struct firenze_pci_inv);
+			cpu_to_be32(sizeof(struct firenze_pci_inv));
 		firenze_inv_data->entry_offset =
-			offsetof(struct firenze_pci_inv_data, entries);
+			cpu_to_be32(offsetof(struct firenze_pci_inv_data, entries));
 	}
 
 	/* Append slot entry */
-	entry = &firenze_inv_data->entries[firenze_inv_data->num_entries++];
+	num_entries = be32_to_cpu(firenze_inv_data->num_entries);
+	firenze_inv_data->num_entries = cpu_to_be32(num_entries + 1);
+	entry = &firenze_inv_data->entries[num_entries];
 	chip = get_chip(dt_get_chip_id(phb->dt_node));
 	if (!chip) {
 		/**
@@ -227,36 +231,38 @@ static void firenze_pci_add_inventory(struct phb *phb,
                 return;
 	}
 
-	entry->hw_proc_id = chip->pcid;
+	entry->hw_proc_id = cpu_to_be32(chip->pcid);
 	entry->reserved = 0;
 	if (pd->parent &&
 	    pd->parent->slot &&
 	    pd->parent->slot->data) {
 		lxvpd_slot = pd->parent->slot->data;
-		entry->slot_idx = lxvpd_slot->slot_index;
+		entry->slot_idx = cpu_to_be16(lxvpd_slot->slot_index);
 	}
 
-	pci_cfg_read16(phb, pd->bdfn, PCI_CFG_VENDOR_ID, &entry->vendor_id);
-	pci_cfg_read16(phb, pd->bdfn, PCI_CFG_DEVICE_ID, &entry->device_id);
+	pci_cfg_read16(phb, pd->bdfn, PCI_CFG_VENDOR_ID, &tmp16);
+	entry->vendor_id = cpu_to_be16(tmp16);
+	pci_cfg_read16(phb, pd->bdfn, PCI_CFG_DEVICE_ID, &tmp16);
+	entry->device_id = cpu_to_be16(tmp16);
         if (pd->is_bridge) {
                 int64_t ssvc = pci_find_cap(phb, pd->bdfn,
 					    PCI_CFG_CAP_ID_SUBSYS_VID);
 		if (ssvc <= 0) {
-			entry->subsys_vendor_id = 0xffff;
-			entry->subsys_device_id = 0xffff;
+			entry->subsys_vendor_id = cpu_to_be16(0xffff);
+			entry->subsys_device_id = cpu_to_be16(0xffff);
 		} else {
 			pci_cfg_read16(phb, pd->bdfn,
-				       ssvc + PCICAP_SUBSYS_VID_VENDOR,
-				       &entry->subsys_vendor_id);
+				       ssvc + PCICAP_SUBSYS_VID_VENDOR, &tmp16);
+			entry->subsys_vendor_id = cpu_to_be16(tmp16);
 			pci_cfg_read16(phb, pd->bdfn,
-				       ssvc + PCICAP_SUBSYS_VID_DEVICE,
-				       &entry->subsys_device_id);
+				       ssvc + PCICAP_SUBSYS_VID_DEVICE, &tmp16);
+			entry->subsys_device_id = cpu_to_be16(tmp16);
 		}
         } else {
-		pci_cfg_read16(phb, pd->bdfn, PCI_CFG_SUBSYS_VENDOR_ID,
-			       &entry->subsys_vendor_id);
-		pci_cfg_read16(phb, pd->bdfn, PCI_CFG_SUBSYS_ID,
-			       &entry->subsys_device_id);
+		pci_cfg_read16(phb, pd->bdfn, PCI_CFG_SUBSYS_VENDOR_ID, &tmp16);
+		entry->subsys_vendor_id = cpu_to_be16(tmp16);
+		pci_cfg_read16(phb, pd->bdfn, PCI_CFG_SUBSYS_ID, &tmp16);
+		entry->subsys_device_id = cpu_to_be16(tmp16);
 	}
 }
 
@@ -272,13 +278,16 @@ static void firenze_dump_pci_inventory(void)
 	prlog(PR_INFO, "Dumping Firenze PCI inventory\n");
 	prlog(PR_INFO, "HWP SLT VDID DVID SVID SDID\n");
 	prlog(PR_INFO, "---------------------------\n");
-	for (i = 0; i < firenze_inv_data->num_entries; i++) {
+	for (i = 0; i < be32_to_cpu(firenze_inv_data->num_entries); i++) {
 		e = &firenze_inv_data->entries[i];
 
 		prlog(PR_INFO, "%03d %03d %04x %04x %04x %04x\n",
-				 e->hw_proc_id, e->slot_idx,
-				 e->vendor_id, e->device_id,
-				 e->subsys_vendor_id, e->subsys_device_id);
+				 be32_to_cpu(e->hw_proc_id),
+				 be16_to_cpu(e->slot_idx),
+				 be16_to_cpu(e->vendor_id),
+				 be16_to_cpu(e->device_id),
+				 be16_to_cpu(e->subsys_vendor_id),
+				 be16_to_cpu(e->subsys_device_id));
 	}
 #endif /* FIRENZE_PCI_INVENTORY_DUMP */
 }
@@ -293,14 +302,14 @@ void firenze_pci_send_inventory(void)
 
 	/* Dump the inventory */
 	prlog(PR_INFO, "Sending %d inventory to FSP\n",
-	      firenze_inv_data->num_entries);
+	      be32_to_cpu(firenze_inv_data->num_entries));
 	firenze_dump_pci_inventory();
 
 	/* Memory location for inventory */
         base = (uint64_t)firenze_inv_data;
-        end = base +
-	      sizeof(struct firenze_pci_inv_data) +
-	      firenze_inv_data->num_entries * firenze_inv_data->entry_size;
+        end = base + sizeof(struct firenze_pci_inv_data) +
+			be32_to_cpu(firenze_inv_data->num_entries) *
+			be32_to_cpu(firenze_inv_data->entry_size);
 	abase = base & ~0xffful;
 	aend = (end + 0xffful) & ~0xffful;
 	offset = PSI_DMA_PCIE_INVENTORY + (base & 0xfff);
diff --git a/platforms/ibm-fsp/hostservices.c b/platforms/ibm-fsp/hostservices.c
index ab4c900..d93c4f6 100644
--- a/platforms/ibm-fsp/hostservices.c
+++ b/platforms/ibm-fsp/hostservices.c
@@ -873,8 +873,8 @@ static bool hservice_hbrt_msg_notify(uint32_t cmd_sub_mod, struct fsp_msg *msg)
 
 	prlog(PR_TRACE, "HBRT: FSP - HBRT message generated\n");
 
-	tce_token = msg->data.words[1];
-	len = msg->data.words[2];
+	tce_token = fsp_msg_get_data_word(msg, 1);
+	len = fsp_msg_get_data_word(msg, 2);
 	buf = fsp_inbound_buf_from_tce(tce_token);
 	if (!buf) {
 		prlog(PR_DEBUG, "HBRT: Invalid inbound data\n");
diff --git a/platforms/ibm-fsp/lxvpd.c b/platforms/ibm-fsp/lxvpd.c
index bdebc44..81cb612 100644
--- a/platforms/ibm-fsp/lxvpd.c
+++ b/platforms/ibm-fsp/lxvpd.c
@@ -275,7 +275,7 @@ void lxvpd_process_slot_entries(struct phb *phb,
 	const void *lxvpd;
 	const uint8_t *pr_rec, *pr_end, *sm;
 	size_t lxvpd_size, pr_size;
-	const uint16_t *mf = NULL;
+	const beint16_t *mf = NULL;
 	char record[5] = "PR00";
 	uint8_t mf_sz, sm_sz;
 	bool found = false;
@@ -317,8 +317,8 @@ void lxvpd_process_slot_entries(struct phb *phb,
 			return;
 		}
 
-		prlog(PR_DEBUG, "Found 0x%04x map...\n", *mf);
-		switch (*mf) {
+		prlog(PR_DEBUG, "Found 0x%04x map...\n", be16_to_cpu(*mf));
+		switch (be16_to_cpu(*mf)) {
 		case 0x1004:
 			lxvpd_parse_1004_map(phb, sm + 1, sm_sz - 1, slot_size);
 			found = true;
diff --git a/platforms/ibm-fsp/lxvpd.h b/platforms/ibm-fsp/lxvpd.h
index bc9daf5..46acf67 100644
--- a/platforms/ibm-fsp/lxvpd.h
+++ b/platforms/ibm-fsp/lxvpd.h
@@ -14,32 +14,54 @@ struct slot_p0 {
 	union {
 		uint8_t     byte;
 		struct {
+#if HAVE_BIG_ENDIAN
 			uint8_t     pluggable:1;
 			uint8_t     pluggable_location:3;
 			uint8_t     power_ctl:1;
 			uint8_t     rsvd_5:1;
 			uint8_t     upstream_port:1;
 			uint8_t     alt_load_source:1;
+#else
+			uint8_t     alt_load_source:1;
+			uint8_t     upstream_port:1;
+			uint8_t     rsvd_5:1;
+			uint8_t     power_ctl:1;
+			uint8_t     pluggable_location:3;
+			uint8_t     pluggable:1;
+#endif
 		};
 	};
 };
 
 struct slot_p1 {
+#if HAVE_BIG_ENDIAN
 	uint8_t     rsvd_0:1;
 	uint8_t     wired_lanes:3;
 	uint8_t     rsvd_4:4;
+#else
+	uint8_t     rsvd_4:4;
+	uint8_t     wired_lanes:3;
+	uint8_t     rsvd_0:1;
+#endif
 };
 
 struct slot_p2 {
+#if HAVE_BIG_ENDIAN
 	uint8_t     rsvd_0:1;
 	uint8_t     bus_clock:3;
 	uint8_t     connector_type:4;
+#else
+	uint8_t     connector_type:4;
+	uint8_t     bus_clock:3;
+	uint8_t     rsvd_0:1;
+#endif
 };
 
 struct slot_p3 {
 	union {
 		uint8_t     byte;
 		struct {
+#if HAVE_BIG_ENDIAN
 			uint8_t    height:1;
 			uint8_t    length:1;
 			uint8_t    left_mech:1;
@@ -48,6 +70,16 @@ struct slot_p3 {
 			uint8_t    pow_led_fsp:1;
 			uint8_t    attn_led_kvm:1;
 			uint8_t    attn_led_fsp:1;
+#else
+			uint8_t    attn_led_fsp:1;
+			uint8_t    attn_led_kvm:1;
+			uint8_t    pow_led_fsp:1;
+			uint8_t    pow_led_kvm:1;
+			uint8_t    right_mech:1;
+			uint8_t    left_mech:1;
+			uint8_t    length:1;
+			uint8_t    height:1;
+#endif
 		};
 	};
 };
@@ -57,7 +89,7 @@ struct pci_slot_entry_1004 {
 	uint8_t               sba;
 	uint8_t               phb_or_slot_type;
 	char                  label[3];
-	uint16_t              bis;
+	__be16                bis;
 	struct slot_p0        p0;
 	struct slot_p1        p1;
 	struct slot_p2        p2;
@@ -73,13 +105,23 @@ struct pci_slot_entry_1005 {
 	union {
 		uint8_t    pba;
 		struct {
+#if HAVE_BIG_ENDIAN
 			uint8_t    switch_id:4;
 			uint8_t    vswitch_id:4;
+#else
+			uint8_t    vswitch_id:4;
+			uint8_t    switch_id:4;
+#endif
 		};
 	};
 	uint8_t               switch_device_id;
+#if HAVE_BIG_ENDIAN
 	uint8_t               slot_type:4;
 	uint8_t               phb_id:4;
+#else
+	uint8_t               phb_id:4;
+	uint8_t               slot_type:4;
+#endif
 	char                  label[8];
 	uint8_t               rsvd_11[4];
 	struct slot_p0        p0;