lib: Rewrite qemu-armv7 ramdetect

* Move armv7 RAM dection to a common place
* Enable it for all emulated platforms
* Use 32bit probe values and restore memory even on failure
* Use the new logic on the following boards:
** qemu-armv7
** qemu-riscv

Tested on qemu-system-riscv:
Fixes kernel panic due to wrong memory limits reported.

Change-Id: I37386c6a95bfc3b7b25aeae32c6e14cff9913513
Signed-off-by: Patrick Rudolph <patrick.rudolph@9elements.com>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/33934
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
Reviewed-by: Angel Pons <th3fanbus@gmail.com>

src/include/ramdetect.h

@@ -1,12 +1,9 @@
 /*
  * This file is part of the coreboot project.
  *
- * Copyright (C) 2016 Vladimir Serbinenko <phcoder@gmail.com>
- *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 or, at your option, any later
+ * the Free Software Foundation; version 2 of the License.
- * version of the License.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -14,10 +11,12 @@
  * GNU General Public License for more details.
  */
 
-#ifndef QEMU_ARMV7_MAINBOARD_H
+/*
-#define QEMU_ARMV7_MAINBOARD_H
+ * Probe an area if it's read/writable.
-
+ * Primary use case is the detection of DRAM amount on emulators.
-/* Returns RAM size in mebibytes.  */
+ *
-int probe_ramsize(void);
+ * @param dram_start Physical address of DRAM start
-
+ * @param probe_size Maximum size in MiB to probe for
-#endif
+ * @return The detected DRAM size in MiB
+ */
+size_t probe_ramsize(const uintptr_t dram_start, const size_t probe_size);

src/lib/Makefile.inc

@@ -65,6 +65,7 @@ verstage-$(CONFIG_CONSOLE_CBMEM) += cbmem_console.c
 verstage-$(CONFIG_GENERIC_UDELAY) += timer.c
 verstage-$(CONFIG_GENERIC_GPIO_LIB) += gpio.c
 
+romstage-$(CONFIG_VENDOR_EMULATION) += ramdetect.c
 romstage-y += prog_loaders.c
 romstage-y += prog_ops.c
 romstage-y += memchr.c
@@ -105,6 +106,7 @@ endif
 
 romstage-$(CONFIG_GENERIC_UDELAY) += timer.c
 
+ramstage-$(CONFIG_VENDOR_EMULATION) += ramdetect.c
 ramstage-y += prog_loaders.c
 ramstage-y += prog_ops.c
 ramstage-y += hardwaremain.c
@@ -155,6 +157,7 @@ ramstage-y += cbmem_common.c
 ramstage-y += imd_cbmem.c
 ramstage-y += imd.c
 
+postcar-$(CONFIG_VENDOR_EMULATION) += ramdetect.c
 postcar-y += cbmem_common.c
 postcar-$(CONFIG_CONSOLE_CBMEM) += cbmem_console.c
 postcar-y += imd_cbmem.c

src/lib/ramdetect.c

@@ -0,0 +1,78 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <types.h>
+#include <symbols.h>
+#include <device/mmio.h>
+#include <ramdetect.h>
+#include <console/console.h>
+
+#define OVERLAP(a, b, s, e) ((b) > (s) && (a) < (e))
+
+static int probe_mb(const uintptr_t dram_start, const uintptr_t size)
+{
+	uintptr_t addr = dram_start + (size * MiB) - sizeof(uint32_t);
+	static const uint32_t patterns[] = {
+		0x55aa55aa,
+		0x12345678
+	};
+	void *ptr = (void *) addr;
+	size_t i;
+
+	/* Don't accidentally clober oneself. */
+	if (OVERLAP(addr, addr + sizeof(uint32_t), (uintptr_t)_program, (uintptr_t) _eprogram))
+		return 1;
+
+	uint32_t old = read32(ptr);
+	for (i = 0; i < ARRAY_SIZE(patterns); i++) {
+		write32(ptr, patterns[i]);
+		if (read32(ptr) != patterns[i])
+			break;
+	}
+
+	write32(ptr, old);
+	return i == ARRAY_SIZE(patterns);
+}
+
+/* - 20 as probe_size is in MiB, - 1 as i is signed */
+#define MAX_ADDRESSABLE_SPACE (sizeof(size_t) * 8 - 20 - 1)
+
+/* Probe an area if it's read/writable. */
+size_t probe_ramsize(const uintptr_t dram_start, const size_t probe_size)
+{
+	ssize_t i;
+	size_t msb = 0;
+	size_t discovered = 0;
+
+	static size_t saved_result;
+	if (saved_result)
+		return saved_result;
+
+	/* Find the MSB + 1. */
+	size_t tmp = probe_size;
+	do {
+		msb++;
+	} while (tmp >>= 1);
+
+	/* Limit search to accessible address space */
+	msb = MIN(msb, MAX_ADDRESSABLE_SPACE);
+
+	/* Compact binary search.  */
+	for (i = msb; i >= 0; i--)
+		if (probe_mb(dram_start, (discovered | (1ULL << i))))
+			discovered |= (1ULL << i);
+
+	saved_result = discovered;
+	printk(BIOS_DEBUG, "RAMDETECT: Found %zu MiB RAM\n", discovered);
+	return discovered;
+}

src/mainboard/emulation/qemu-armv7/Kconfig

@@ -53,4 +53,8 @@ config MAINBOARD_VENDOR
 	string
 	default "ARM Ltd."
 
+config DRAM_SIZE_MB
+	int
+	default 1024
+
 endif #  BOARD_EMULATION_QEMU_ARMV7

src/mainboard/emulation/qemu-armv7/cbmem.c

@@ -11,55 +11,11 @@
  * GNU General Public License for more details.
  */
 
-#include <stddef.h>
 #include <cbmem.h>
 #include <symbols.h>
-#include <device/mmio.h>
+#include <ramdetect.h>
-#include "mainboard.h"
-
-#define PATTERN1 0x55
-#define PATTERN2 0xaa
-
-/* Returns 1 if mebibyte mb is present and 0 otherwise.  */
-static int probe_mb(int mb)
-{
-	char *ptr = (char *) 0x60000000 + (mb << 20) + 0xfffff;
-	char old;
-	if (ptr < (char *) &_eprogram) {
-		/* Don't probe below _end to avoid accidentally clobering
-		   oneself.  */
-		return 1;
-	}
-
-	old = read8(ptr);
-	write8(ptr, PATTERN1);
-	if (read8(ptr) != PATTERN1)
-		return 0;
-	write8(ptr, PATTERN2);
-	if (read8(ptr) != PATTERN2)
-		return 0;
-	write8(ptr, old);
-	return 1;
-}
-
-int probe_ramsize(void)
-{
-	int i;
-	int discovered = 0;
-	static int saved_result;
-	if (saved_result)
-		return saved_result;
-	/* Compact binary search.  */
-	/* 1 GiB is the largest supported RAM by this machine.  */
-	for (i = 9; i >= 0; i--)
-		if (probe_mb(discovered | (1 << i)))
-			discovered |= (1 << i);
-	discovered++;
-	saved_result = discovered;
-	return discovered;
-}
 
 void *cbmem_top(void)
 {
-	return _dram + (probe_ramsize() << 20);
+	return _dram + (probe_ramsize((uintptr_t)_dram, CONFIG_DRAM_SIZE_MB) * MiB);
 }

src/mainboard/emulation/qemu-armv7/mainboard.c

@@ -18,9 +18,10 @@
 #include <device/device.h>
 #include <cbmem.h>
 #include <halt.h>
-#include "mainboard.h"
 #include <edid.h>
 #include <device/mmio.h>
+#include <ramdetect.h>
+#include <symbols.h>
 
 static void init_gfx(void)
 {
@@ -57,7 +58,7 @@ static void mainboard_enable(struct device *dev)
 		halt();
 	}
 
-	discovered = probe_ramsize();
+	discovered = probe_ramsize((uintptr_t)_dram, CONFIG_DRAM_SIZE_MB);
 	printk(BIOS_DEBUG, "%d MiB of RAM discovered\n", discovered);
 	ram_resource(dev, 0, 0x60000000 >> 10, discovered << 10);
 	cbmem_recovery(0);

src/mainboard/emulation/qemu-riscv/mainboard.c

@@ -17,15 +17,19 @@
 #include <device/device.h>
 #include <cbmem.h>
 #include <symbols.h>
+#include <ramdetect.h>
 
 static void mainboard_enable(struct device *dev)
 {
+	size_t dram_mb_detected;
 
 	if (!dev) {
 		die("No dev0; die\n");
 	}
 
-	ram_resource(dev, 0, (uintptr_t)_dram / KiB, CONFIG_DRAM_SIZE_MB * KiB);
+	dram_mb_detected = probe_ramsize((uintptr_t)_dram, CONFIG_DRAM_SIZE_MB);
+	ram_resource(dev, 0, (uintptr_t)_dram / KiB, dram_mb_detected / KiB);
+
 	cbmem_recovery(0);
 }
 

src/soc/ucb/riscv/cbmem.c

@@ -12,16 +12,10 @@
  */
 
 #include <cbmem.h>
+#include <symbols.h>
+#include <ramdetect.h>
 
 void *cbmem_top(void)
 {
-	uintptr_t base;
+	return _dram + (probe_ramsize((uintptr_t)_dram, CONFIG_DRAM_SIZE_MB) * MiB);
-	size_t size;
-
-	/* Use dummy values until we can query the memory size again */
-	//query_mem(configstring(), &base, &size);
-	base = 0x80000000;
-	size = 128 * MiB;
-
-	return (void *)(base + size);
 }