diff --git a/src/northbridge/intel/haswell/raminit.h b/src/northbridge/intel/haswell/raminit.h
index 6efea3e..ff95a45 100644
--- a/src/northbridge/intel/haswell/raminit.h
+++ b/src/northbridge/intel/haswell/raminit.h
@@ -6,15 +6,19 @@
 #include <stdint.h>
 #include "pei_data.h"
 
+#define SPD_MEMORY_DOWN	0xff
+
+struct spd_info {
+	uint8_t addresses[4];
+	unsigned int spd_index;
+};
+
 /* Mainboard-specific USB configuration */
 extern const struct usb2_port_setting mainboard_usb2_ports[MAX_USB2_PORTS];
 extern const struct usb3_port_setting mainboard_usb3_ports[MAX_USB3_PORTS];
 
-/* Optional function to copy SPD data for on-board memory */
-void copy_spd(struct pei_data *peid);
-
 /* Mainboard callback to fill in the SPD addresses in MRC format */
-void mb_get_spd_map(uint8_t spd_map[4]);
+void mb_get_spd_map(struct spd_info *spdi);
 
 void sdram_initialize(struct pei_data *pei_data);
 void setup_sdram_meminfo(struct pei_data *pei_data);
