src/soc/intel/common/mrc_cache.c - coreboot - Gitiles

 /*
  * This file is part of the coreboot project.
  *
  * Copyright (C) 2014 Google Inc.
  *
  * 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 <string.h>
 #include <bootstate.h>
 #include <console/console.h>
 #include <cbmem.h>
 #include <fmap.h>
 #include <ip_checksum.h>
 #include <vboot/vboot_common.h>

 #include "mrc_cache.h"
 #include "nvm.h"

 #define MRC_DATA_ALIGN           0x1000
 #define MRC_DATA_SIGNATURE       (('M'<<0)|('R'<<8)|('C'<<16)|('D'<<24))

 /* The mrc_data_region describes the larger non-volatile area to store
  * mrc_saved_data objects.*/
 struct mrc_data_region {
 	void *base;
 	uint32_t size;
 };

 /* common code */
 static int mrc_cache_get_region(struct mrc_data_region *region)
 {
 	bool located_by_fmap = true;
 	struct region_device rdev;

 	if (fmap_locate_area_as_rdev("RW_MRC_CACHE", &rdev))
 		located_by_fmap =  false;

 	/* CHROMEOS builds must get their MRC cache from FMAP. */
 	if (IS_ENABLED(CONFIG_CHROMEOS) && !located_by_fmap)
 		return -1;

 	if (located_by_fmap) {
 		region->size = region_device_sz(&rdev);
 		region->base = rdev_mmap_full(&rdev);

 		if (region->base == NULL)
 			return -1;
 	} else {
 		region->base = (void *)CONFIG_MRC_SETTINGS_CACHE_BASE;
 		region->size = CONFIG_MRC_SETTINGS_CACHE_SIZE;
 	}

 	return 0;
 }

 static int mrc_cache_in_region(const struct mrc_data_region *region,
                                const struct mrc_saved_data *cache)
 {
 	uintptr_t region_end;
 	uintptr_t cache_end;

 	if ((uintptr_t)cache < (uintptr_t)region->base)
 		return 0;

 	region_end = (uintptr_t)region->base;
 	region_end += region->size;

 	if ((uintptr_t)cache >= region_end)
 		return 0;

 	if ((sizeof(*cache) + (uintptr_t)cache) >= region_end)
 		return 0;

 	cache_end = (uintptr_t)cache;
 	cache_end += cache->size + sizeof(*cache);

 	if (cache_end > region_end)
 		return 0;

 	return 1;
 }

 static int mrc_cache_valid(const struct mrc_data_region *region,
                            const struct mrc_saved_data *cache)
 {
 	uint32_t checksum;

 	if (cache->signature != MRC_DATA_SIGNATURE)
 		return 0;

 	if (cache->size > region->size)
 		return 0;

 	checksum = compute_ip_checksum((void *)&cache->data[0], cache->size);

 	if (cache->checksum != checksum)
 		return 0;

 	return 1;
 }

 static const struct mrc_saved_data *
 next_cache_block(const struct mrc_saved_data *cache)
 {
 	uintptr_t next = (uintptr_t)cache;

 	next += ALIGN(cache->size + sizeof(*cache), MRC_DATA_ALIGN);

 	return (const struct mrc_saved_data *)next;
 }

 /* Locate the most recently saved MRC data. */
 static int __mrc_cache_get_current(const struct mrc_data_region *region,
                                    const struct mrc_saved_data **cache,
                                    uint32_t version)
 {
 	const struct mrc_saved_data *msd;
 	const struct mrc_saved_data *verified_cache;
 	int slot = 0;

 	msd = region->base;

 	verified_cache = NULL;

 	while (mrc_cache_in_region(region, msd) &&
 	       mrc_cache_valid(region, msd)) {
 		verified_cache = msd;
 		msd = next_cache_block(msd);
 		slot++;
 	}

 	/*
 	 * Update pointer to the most recently saved MRC data before returning
 	 * any error. This ensures that the caller can use next available slot
 	 * if required.
 	 */
 	*cache = verified_cache;

 	if (verified_cache == NULL)
 		return -1;

 	if (verified_cache->version != version) {
 		printk(BIOS_DEBUG, "MRC cache version mismatch: %x vs %x\n",
 			verified_cache->version, version);
 		return -1;
 	}

 	printk(BIOS_DEBUG, "MRC cache slot %d @ %p\n", slot-1, verified_cache);

 	return 0;
 }

 int mrc_cache_get_current_with_version(const struct mrc_saved_data **cache,
 					uint32_t version)
 {
 	struct mrc_data_region region;

 	if (mrc_cache_get_region(&region) < 0)
 		return -1;

 	return __mrc_cache_get_current(&region, cache, version);
 }

 int mrc_cache_get_current(const struct mrc_saved_data **cache)
 {
 	return mrc_cache_get_current_with_version(cache, 0);
 }
 /* Fill in mrc_saved_data structure with payload. */
 static void mrc_cache_fill(struct mrc_saved_data *cache, const void *data,
                            size_t size, uint32_t version)
 {
 	cache->signature = MRC_DATA_SIGNATURE;
 	cache->size = size;
 	cache->version = version;
 	memcpy(&cache->data[0], data, size);
 	cache->checksum = compute_ip_checksum((void *)&cache->data[0],
 	                                      cache->size);
 }

 int mrc_cache_stash_data_with_version(const void *data, size_t size,
 					uint32_t version)
 {
 	int cbmem_size;
 	struct mrc_saved_data *cache;

 	cbmem_size = sizeof(*cache) + ALIGN(size, 16);

 	cache = cbmem_add(CBMEM_ID_MRCDATA, cbmem_size);

 	if (cache == NULL) {
 		printk(BIOS_ERR, "No space in cbmem for MRC data.\n");
 		return -1;
 	}

 	/* Clear alignment padding bytes at end of data. */
 	memset(&cache->data[size], 0, cbmem_size - size - sizeof(*cache));

 	printk(BIOS_DEBUG, "Relocate MRC DATA from %p to %p (%zu bytes)\n",
 	       data, cache, size);

 	mrc_cache_fill(cache, data, size, version);

 	return 0;
 }

 int mrc_cache_stash_data(const void *data, size_t size)
 {
 	return mrc_cache_stash_data_with_version(data, size, 0);
 }

 static int mrc_slot_valid(const struct mrc_data_region *region,
                           const struct mrc_saved_data *slot,
                           const struct mrc_saved_data *to_save)
 {
 	uintptr_t region_begin;
 	uintptr_t region_end;
 	uintptr_t slot_end;
 	uintptr_t slot_begin;
 	uint32_t size;

 	region_begin = (uintptr_t)region->base;
 	region_end = region_begin + region->size;
 	slot_begin = (uintptr_t)slot;
 	size = to_save->size + sizeof(*to_save);
 	slot_end = slot_begin + size;

 	if (slot_begin < region_begin || slot_begin >= region_end)
 		return 0;

 	if (size > region->size)
 		return 0;

 	if (slot_end > region_end || slot_end < region_begin)
 		return 0;

 	if (!nvm_is_erased(slot, size))
 		return 0;

 	return 1;
 }

 static const struct mrc_saved_data *
 mrc_cache_next_slot(const struct mrc_data_region *region,
                     const struct mrc_saved_data *current_slot)
 {
 	const struct mrc_saved_data *next_slot;

 	if (current_slot == NULL) {
 		next_slot = region->base;
 	} else {
 		next_slot = next_cache_block(current_slot);
 	}

 	return next_slot;
 }

 /* Protect RW_MRC_CACHE region with a Protected Range Register */
 static int protect_mrc_cache(const struct mrc_data_region *region)
 {
 #if IS_ENABLED(CONFIG_MRC_SETTINGS_PROTECT)
 	if (nvm_is_write_protected() <= 0) {
 		printk(BIOS_INFO, "NOT enabling PRR for RW_MRC_CACHE region\n");
 		return 1;
 	}

 	if (nvm_protect(region->base, region->size) < 0) {
 		printk(BIOS_ERR, "ERROR setting PRR for RW_MRC_CACHE region\n");
 		return -1;
 	}

 	printk(BIOS_INFO, "Enabled Protected Range on RW_MRC_CACHE region\n");
 #endif
 	return 0;
 }

 static void update_mrc_cache(void *unused)
 {
 	const struct mrc_saved_data *current_boot;
 	const struct mrc_saved_data *current_saved;
 	const struct mrc_saved_data *next_slot;
 	struct mrc_data_region region;

 	printk(BIOS_DEBUG, "Updating MRC cache data.\n");

 	current_boot = cbmem_find(CBMEM_ID_MRCDATA);
 	if (!current_boot) {
 		printk(BIOS_ERR, "No MRC cache in cbmem.\n");
 		return;
 	}

 	if (mrc_cache_get_region(&region)) {
 		printk(BIOS_ERR, "Could not obtain MRC cache region.\n");
 		return;
 	}

 	if (!mrc_cache_valid(&region, current_boot)) {
 		printk(BIOS_ERR, "MRC cache data in cbmem invalid.\n");
 		return;
 	}

 	current_saved = NULL;

 	if (!__mrc_cache_get_current(&region, &current_saved,
 					current_boot->version)) {
 		if (current_saved->size == current_boot->size &&
 		    !memcmp(&current_saved->data[0], &current_boot->data[0],
 		            current_saved->size)) {
 			printk(BIOS_DEBUG, "MRC cache up to date.\n");
 			protect_mrc_cache(&region);
 			return;
 		}
 	}

 	next_slot = mrc_cache_next_slot(&region, current_saved);

 	if (!mrc_slot_valid(&region, next_slot, current_boot)) {
 		printk(BIOS_DEBUG, "Slot @ %p is invalid.\n", next_slot);
 		if (!nvm_is_erased(region.base, region.size)) {
 			if (nvm_erase(region.base, region.size) < 0) {
 				printk(BIOS_DEBUG, "Failure erasing region.\n");
 				return;
 			}
 		}
 		next_slot = region.base;
 	}

 	if (nvm_write((void *)next_slot, current_boot,
 	               current_boot->size + sizeof(*current_boot))) {
 		printk(BIOS_DEBUG, "Failure writing MRC cache to %p.\n",
 		       next_slot);
 	}
 	protect_mrc_cache(&region);
 }

 BOOT_STATE_INIT_ENTRY(BS_WRITE_TABLES, BS_ON_ENTRY, update_mrc_cache, NULL);
	/*
	* This file is part of the coreboot project.
	*
	* Copyright (C) 2014 Google Inc.
	*
	* 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 <string.h>
	#include <bootstate.h>
	#include <console/console.h>
	#include <cbmem.h>
	#include <fmap.h>
	#include <ip_checksum.h>
	#include <vboot/vboot_common.h>

	#include "mrc_cache.h"
	#include "nvm.h"

	#define MRC_DATA_ALIGN 0x1000
	#define MRC_DATA_SIGNATURE (('M'<<0)\|('R'<<8)\|('C'<<16)\|('D'<<24))

	/* The mrc_data_region describes the larger non-volatile area to store
	* mrc_saved_data objects.*/
	struct mrc_data_region {
	void *base;
	uint32_t size;
	};

	/* common code */
	static int mrc_cache_get_region(struct mrc_data_region *region)
	{
	bool located_by_fmap = true;
	struct region_device rdev;

	if (fmap_locate_area_as_rdev("RW_MRC_CACHE", &rdev))
	located_by_fmap = false;

	/* CHROMEOS builds must get their MRC cache from FMAP. */
	if (IS_ENABLED(CONFIG_CHROMEOS) && !located_by_fmap)
	return -1;

	if (located_by_fmap) {
	region->size = region_device_sz(&rdev);
	region->base = rdev_mmap_full(&rdev);

	if (region->base == NULL)
	return -1;
	} else {
	region->base = (void *)CONFIG_MRC_SETTINGS_CACHE_BASE;
	region->size = CONFIG_MRC_SETTINGS_CACHE_SIZE;
	}

	return 0;
	}

	static int mrc_cache_in_region(const struct mrc_data_region *region,
	const struct mrc_saved_data *cache)
	{
	uintptr_t region_end;
	uintptr_t cache_end;

	if ((uintptr_t)cache < (uintptr_t)region->base)
	return 0;

	region_end = (uintptr_t)region->base;
	region_end += region->size;

	if ((uintptr_t)cache >= region_end)
	return 0;

	if ((sizeof(*cache) + (uintptr_t)cache) >= region_end)
	return 0;

	cache_end = (uintptr_t)cache;
	cache_end += cache->size + sizeof(*cache);

	if (cache_end > region_end)
	return 0;

	return 1;
	}

	static int mrc_cache_valid(const struct mrc_data_region *region,
	const struct mrc_saved_data *cache)
	{
	uint32_t checksum;

	if (cache->signature != MRC_DATA_SIGNATURE)
	return 0;

	if (cache->size > region->size)
	return 0;

	checksum = compute_ip_checksum((void *)&cache->data[0], cache->size);

	if (cache->checksum != checksum)
	return 0;

	return 1;
	}

	static const struct mrc_saved_data *
	next_cache_block(const struct mrc_saved_data *cache)
	{
	uintptr_t next = (uintptr_t)cache;

	next += ALIGN(cache->size + sizeof(*cache), MRC_DATA_ALIGN);

	return (const struct mrc_saved_data *)next;
	}

	/* Locate the most recently saved MRC data. */
	static int __mrc_cache_get_current(const struct mrc_data_region *region,
	const struct mrc_saved_data **cache,
	uint32_t version)
	{
	const struct mrc_saved_data *msd;
	const struct mrc_saved_data *verified_cache;
	int slot = 0;

	msd = region->base;

	verified_cache = NULL;

	while (mrc_cache_in_region(region, msd) &&
	mrc_cache_valid(region, msd)) {
	verified_cache = msd;
	msd = next_cache_block(msd);
	slot++;
	}

	/*
	* Update pointer to the most recently saved MRC data before returning
	* any error. This ensures that the caller can use next available slot
	* if required.
	*/
	*cache = verified_cache;

	if (verified_cache == NULL)
	return -1;

	if (verified_cache->version != version) {
	printk(BIOS_DEBUG, "MRC cache version mismatch: %x vs %x\n",
	verified_cache->version, version);
	return -1;
	}

	printk(BIOS_DEBUG, "MRC cache slot %d @ %p\n", slot-1, verified_cache);

	return 0;
	}

	int mrc_cache_get_current_with_version(const struct mrc_saved_data **cache,
	uint32_t version)
	{
	struct mrc_data_region region;

	if (mrc_cache_get_region(&region) < 0)
	return -1;

	return __mrc_cache_get_current(&region, cache, version);
	}

	int mrc_cache_get_current(const struct mrc_saved_data **cache)
	{
	return mrc_cache_get_current_with_version(cache, 0);
	}
	/* Fill in mrc_saved_data structure with payload. */
	static void mrc_cache_fill(struct mrc_saved_data cache, const void data,
	size_t size, uint32_t version)
	{
	cache->signature = MRC_DATA_SIGNATURE;
	cache->size = size;
	cache->version = version;
	memcpy(&cache->data[0], data, size);
	cache->checksum = compute_ip_checksum((void *)&cache->data[0],
	cache->size);
	}

	int mrc_cache_stash_data_with_version(const void *data, size_t size,
	uint32_t version)
	{
	int cbmem_size;
	struct mrc_saved_data *cache;

	cbmem_size = sizeof(*cache) + ALIGN(size, 16);

	cache = cbmem_add(CBMEM_ID_MRCDATA, cbmem_size);

	if (cache == NULL) {
	printk(BIOS_ERR, "No space in cbmem for MRC data.\n");
	return -1;
	}

	/* Clear alignment padding bytes at end of data. */
	memset(&cache->data[size], 0, cbmem_size - size - sizeof(*cache));

	printk(BIOS_DEBUG, "Relocate MRC DATA from %p to %p (%zu bytes)\n",
	data, cache, size);

	mrc_cache_fill(cache, data, size, version);

	return 0;
	}

	int mrc_cache_stash_data(const void *data, size_t size)
	{
	return mrc_cache_stash_data_with_version(data, size, 0);
	}

	static int mrc_slot_valid(const struct mrc_data_region *region,
	const struct mrc_saved_data *slot,
	const struct mrc_saved_data *to_save)
	{
	uintptr_t region_begin;
	uintptr_t region_end;
	uintptr_t slot_end;
	uintptr_t slot_begin;
	uint32_t size;

	region_begin = (uintptr_t)region->base;
	region_end = region_begin + region->size;
	slot_begin = (uintptr_t)slot;
	size = to_save->size + sizeof(*to_save);
	slot_end = slot_begin + size;

	if (slot_begin < region_begin \|\| slot_begin >= region_end)
	return 0;

	if (size > region->size)
	return 0;

	if (slot_end > region_end \|\| slot_end < region_begin)
	return 0;

	if (!nvm_is_erased(slot, size))
	return 0;

	return 1;
	}

	static const struct mrc_saved_data *
	mrc_cache_next_slot(const struct mrc_data_region *region,
	const struct mrc_saved_data *current_slot)
	{
	const struct mrc_saved_data *next_slot;

	if (current_slot == NULL) {
	next_slot = region->base;
	} else {
	next_slot = next_cache_block(current_slot);
	}

	return next_slot;
	}

	/* Protect RW_MRC_CACHE region with a Protected Range Register */
	static int protect_mrc_cache(const struct mrc_data_region *region)
	{
	#if IS_ENABLED(CONFIG_MRC_SETTINGS_PROTECT)
	if (nvm_is_write_protected() <= 0) {
	printk(BIOS_INFO, "NOT enabling PRR for RW_MRC_CACHE region\n");
	return 1;
	}

	if (nvm_protect(region->base, region->size) < 0) {
	printk(BIOS_ERR, "ERROR setting PRR for RW_MRC_CACHE region\n");
	return -1;
	}

	printk(BIOS_INFO, "Enabled Protected Range on RW_MRC_CACHE region\n");
	#endif
	return 0;
	}

	static void update_mrc_cache(void *unused)
	{
	const struct mrc_saved_data *current_boot;
	const struct mrc_saved_data *current_saved;
	const struct mrc_saved_data *next_slot;
	struct mrc_data_region region;

	printk(BIOS_DEBUG, "Updating MRC cache data.\n");

	current_boot = cbmem_find(CBMEM_ID_MRCDATA);
	if (!current_boot) {
	printk(BIOS_ERR, "No MRC cache in cbmem.\n");
	return;
	}

	if (mrc_cache_get_region(&region)) {
	printk(BIOS_ERR, "Could not obtain MRC cache region.\n");
	return;
	}

	if (!mrc_cache_valid(&region, current_boot)) {
	printk(BIOS_ERR, "MRC cache data in cbmem invalid.\n");
	return;
	}

	current_saved = NULL;

	if (!__mrc_cache_get_current(&region, &current_saved,
	current_boot->version)) {
	if (current_saved->size == current_boot->size &&
	!memcmp(&current_saved->data[0], &current_boot->data[0],
	current_saved->size)) {
	printk(BIOS_DEBUG, "MRC cache up to date.\n");
	protect_mrc_cache(&region);
	return;
	}
	}

	next_slot = mrc_cache_next_slot(&region, current_saved);

	if (!mrc_slot_valid(&region, next_slot, current_boot)) {
	printk(BIOS_DEBUG, "Slot @ %p is invalid.\n", next_slot);
	if (!nvm_is_erased(region.base, region.size)) {
	if (nvm_erase(region.base, region.size) < 0) {
	printk(BIOS_DEBUG, "Failure erasing region.\n");
	return;
	}
	}
	next_slot = region.base;
	}

	if (nvm_write((void *)next_slot, current_boot,
	current_boot->size + sizeof(*current_boot))) {
	printk(BIOS_DEBUG, "Failure writing MRC cache to %p.\n",
	next_slot);
	}
	protect_mrc_cache(&region);
	}

	BOOT_STATE_INIT_ENTRY(BS_WRITE_TABLES, BS_ON_ENTRY, update_mrc_cache, NULL);