tree 4379827366fc36fce07c4d5177bcb9019207424b
parent 42f15054b178efe9a4d1c8a4e0c203d1aa4aad01
author Patrick Georgi <patrick@coreboot.org> 1696615028 +0200
committer Patrick Georgi <patrick@coreboot.org> 1697026141 +0000

Kconfig: Bring HEAP_SIZE to a common, large value

We have a tiny HEAP_SIZE by default, except when we don't, and
mainboards that override it, or not.

Since memory isn't exactly at a premium these days, and unused heap
doesn't cost anything extra, just crank it up to the highest value
we have in the tree by default and remove all overrides.

Change-Id: I918a6c58c02496e8074e5fba06e38d9cfd691020
Signed-off-by: Patrick Georgi <patrick@coreboot.org>
Reviewed-on: https://review.coreboot.org/c/coreboot/+/78270
Reviewed-by: Subrata Banik <subratabanik@google.com>
Reviewed-by: Werner Zeh <werner.zeh@siemens.com>
Reviewed-by: Kyösti Mälkki <kyosti.malkki@gmail.com>
Reviewed-by: Julius Werner <jwerner@chromium.org>
Tested-by: build bot (Jenkins) <no-reply@coreboot.org>
