rollback: Replace interrupt_{disable,enable} with irq_{lock,unlock}

Replace interrupt_* functions with their irq_* counterparts since we are
going to use rollback regions in Zephyr.

Zephyr EC shim doesn't provide interrupt_disable() and
interrupt_enable() functions. Instead, irq_lock() and irq_unlock()
functions, used in Zephyr, are implemented in EC and compiled when
building Cros EC (without Zephyr). These functions are wrappers for old
interrupt_disable() and interrupt_enable() functions.

BUG=b:277029648
BRANCH=none
TEST=make BOARD=bloonchipper
TEST=./test/run_device_tests.py -b bloonchipper -t rollback.*
     Test "rollback_region0": PASSED
     Test "rollback_region1": PASSED
     Test "rollback_entropy": PASSED

Change-Id: I4899985cfc50aff65b0daebeb139520ff72c6af4
Signed-off-by: Patryk Duda <pdk@semihalf.com>
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/4403576
Tested-by: Patryk Duda <patrykd@google.com>
Reviewed-by: Tom Hughes <tomhughes@chromium.org>
Commit-Queue: Patryk Duda <patrykd@google.com>

1 files changed, 16 insertions, 9 deletions

diff --git a/common/rollback.c b/common/rollback.c
index 4b7d2f7106..e530397af1 100644
--- a/common/rollback.c
+++ b/common/rollback.c
@@ -49,19 +49,24 @@ static int get_rollback_offset(int region)
  * When MPU is available, read rollback with interrupts disabled, to minimize
  * time protection is left open.
  */
-static void lock_rollback(void)
+static void lock_rollback(uint32_t key)
 {
 #ifdef CONFIG_ROLLBACK_MPU_PROTECT
 	mpu_lock_rollback(1);
-	interrupt_enable();
+	irq_unlock(key);
 #endif
 }
 
-static void unlock_rollback(void)
+static uint32_t unlock_rollback(void)
 {
 #ifdef CONFIG_ROLLBACK_MPU_PROTECT
-	interrupt_disable();
+	uint32_t key;
+
+	key = irq_lock();
 	mpu_lock_rollback(0);
+	return key;
+#else
+	return 0;
 #endif
 }
 
@@ -76,13 +81,14 @@ int read_rollback(int region, struct rollback_data *data)
 {
 	int offset;
 	int ret = EC_SUCCESS;
+	uint32_t key;
 
 	offset = get_rollback_offset(region);
 
-	unlock_rollback();
+	key = unlock_rollback();
 	if (crec_flash_read(offset, sizeof(*data), (char *)data))
 		ret = EC_ERROR_UNKNOWN;
-	lock_rollback();
+	lock_rollback(key);
 
 	return ret;
 }
@@ -251,6 +257,7 @@ static int rollback_update(int32_t next_min_version, const uint8_t *entropy,
 	struct rollback_data *data = (struct rollback_data *)block;
 	BUILD_ASSERT(sizeof(block) >= sizeof(*data));
 	int erase_size, offset, region, ret;
+	uint32_t key;
 
 	if (crec_flash_get_protect() & EC_FLASH_PROTECT_ROLLBACK_NOW) {
 		ret = EC_ERROR_ACCESS_DENIED;
@@ -322,15 +329,15 @@ static int rollback_update(int32_t next_min_version, const uint8_t *entropy,
 		goto out;
 	}
 
-	unlock_rollback();
+	key = unlock_rollback();
 	if (crec_flash_erase(offset, erase_size)) {
 		ret = EC_ERROR_UNKNOWN;
-		lock_rollback();
+		lock_rollback(key);
 		goto out;
 	}
 
 	ret = crec_flash_write(offset, sizeof(block), block);
-	lock_rollback();
+	lock_rollback(key);
 
 out:
 	clear_rollback(data);