tree c47ff0d4f762a96d014b2fce3820912b23d1624b
parent 1db6e2aa197bd8f8ed702f77d6a1e09267af71ee
author Patrick Georgi <patrick@georgi-clan.de> 1335812770 +0200
committer Patrick Georgi <patrick@georgi-clan.de> 1335823767 +0200

Add Kconfig options to handle the blobs repository

One option to allow using the repo (defaults to no),
one to let boards state that they require it in the
current configuration.

The build system checks out the repo if allowed, and
fails if the repo is requested by the configuration
but not desired by the user.

Change-Id: If71d80b329cf528aa467fcb0b4d9d7c7434aab27
Signed-off-by: Patrick Georgi <patrick@georgi-clan.de>
Reviewed-on: http://review.coreboot.org/957
Reviewed-by: Stefan Reinauer <stefan.reinauer@coreboot.org>
Tested-by: build bot (Jenkins)
