tree 09a7617650f9927f42a5ec2b537f510daf17cadc
parent 7c38e1e8bc47c2842b23c565a35f8d959428ec3c
author Martin Roth <martinroth@google.com> 1448578692 -0700
committer Martin Roth <martinroth@google.com> 1449424007 +0100

intel/fsp_rangeley: change non-existent config options to #defines

Kconfig symbols CONFIG_ACPI_INCLUDE_PMIO and CONFIG_ACPI_INCLUDE_GPIO
were never added to the coreboot codebase when the Rangeley code was
brought in from Sage.  These symbols disabled ACPI code that was unused
because it caused dmesg warnings due to conflicts with drivers trying to
claim the same addresses as the ACPI code.  Because it could be used on
some other platforms, it was left in instead of being completely
removed.

- Change the Kconfig symbol names to simple #defines in the mainboard
code.
- Add the #defines along with comments to the reference platform.
- Hook everything together in dsdt.asl
- Update new mainboard littleplains the same way.

Change-Id: I1f62157c6e447ea9b7207699572930e4711fc3e0
Signed-off-by: Martin Roth <martinroth@google.com>
Reviewed-on: https://review.coreboot.org/12552
Reviewed-by: David Guckian <david.guckian@intel.com>
Tested-by: build bot (Jenkins)
