diff --git a/hw/ip/lc_ctrl/data/lc_ctrl_state.hjson b/hw/ip/lc_ctrl/data/lc_ctrl_state.hjson
index ad0d611..5550320 100644
--- a/hw/ip/lc_ctrl/data/lc_ctrl_state.hjson
+++ b/hw/ip/lc_ctrl/data/lc_ctrl_state.hjson
@@ -37,4 +37,17 @@
     min_hw       : 5,
     max_hw       : 17,
     min_hd       : 5
+
+    // LC token size in bit
+    token_size   : 128
+    tokens       : [
+        {
+            name:  "AllZeroToken"
+            value: "0x0"
+        }
+        {
+            name:  "RndCnstRawUnlockToken"
+            value: "<random>"
+        }
+    ]
 }
diff --git a/hw/ip/lc_ctrl/rtl/lc_ctrl_state_pkg.sv.tpl b/hw/ip/lc_ctrl/rtl/lc_ctrl_state_pkg.sv.tpl
index b7977a1..9ea44f4 100644
--- a/hw/ip/lc_ctrl/rtl/lc_ctrl_state_pkg.sv.tpl
+++ b/hw/ip/lc_ctrl/rtl/lc_ctrl_state_pkg.sv.tpl
@@ -13,6 +13,11 @@
 data_width = lc_st_enc.config['secded']['data_width']
 ecc_width  = lc_st_enc.config['secded']['ecc_width']
 %>
+
+  /////////////////////////////////////////////
+  // Life cycle manufacturing state encoding //
+  /////////////////////////////////////////////
+
   // These values have been generated such that they are incrementally writeable with respect
   // to the ECC polynomial specified. The values are used to define the life cycle manufacturing
   // state and transition counter encoding in lc_ctrl_pkg.sv.
@@ -56,4 +61,14 @@
 
 % endfor
 
+  ///////////////////////////////////////////
+  // Hashed RAW unlock and all-zero tokens //
+  ///////////////////////////////////////////
+<% token_size = lc_st_enc.config['token_size'] %>
+% for token in lc_st_enc.config['tokens']:
+  parameter logic [${token_size-1}:0] ${token['name']} = {
+    ${"{0:}'h{1:0X}".format(token_size, token['value'])}
+  };
+% endfor
+
 endpackage : lc_ctrl_state_pkg
diff --git a/hw/ip/otp_ctrl/data/otp_ctrl.hjson.tpl b/hw/ip/otp_ctrl/data/otp_ctrl.hjson.tpl
index eb8eebe..4885a6f 100644
--- a/hw/ip/otp_ctrl/data/otp_ctrl.hjson.tpl
+++ b/hw/ip/otp_ctrl/data/otp_ctrl.hjson.tpl
@@ -72,30 +72,6 @@
       randcount: "40",
       randtype:  "perm", // random permutation for randcount elements
     }
-    { name:      "RndCnstKey",
-      desc:      "Compile-time random scrambling keys",
-      type:      "otp_ctrl_pkg::key_array_t"
-      randcount: "384",  // 3*128
-      randtype:  "data", // randomize randcount databits
-    }
-    { name:      "RndCnstDigestConst",
-      desc:      "Compile-time random digest constant",
-      type:      "otp_ctrl_pkg::digest_const_array_t"
-      randcount: "640",  // 5*128
-      randtype:  "data", // randomize randcount databits
-    }
-    { name:      "RndCnstDigestIV",
-      desc:      "Compile-time random digest IV",
-      type:      "otp_ctrl_pkg::digest_iv_array_t"
-      randcount: "320",  // 5*64
-      randtype:  "data", // randomize randcount databits
-    }
-    { name:      "RndCnstRawUnlockToken",
-      desc:      "Compile-time random value for RAW unlock token.",
-      type:      "lc_ctrl_pkg::lc_token_t"
-      randcount: "128",
-      randtype:  "data", // randomize randcount databits
-    }
     // Normal parameters
     { name: "NumSramKeyReqSlots",
       desc: "Number of key slots",
diff --git a/hw/ip/otp_ctrl/data/otp_ctrl_mmap.hjson b/hw/ip/otp_ctrl/data/otp_ctrl_mmap.hjson
index c785172..ed13db6 100644
--- a/hw/ip/otp_ctrl/data/otp_ctrl_mmap.hjson
+++ b/hw/ip/otp_ctrl/data/otp_ctrl_mmap.hjson
@@ -22,6 +22,58 @@
         width: "2", // bytes
         depth: "1024"
     }
+
+    // Definition of scrambling and digest constants and keys.
+    scrambling: {
+        key_size:  "16",
+        iv_size:   "8",
+        cnst_size: "16",
+        keys: [
+            {
+                name:  "Secret0Key",
+                value: "<random>",
+            }
+            {
+                name:  "Secret1Key",
+                value: "<random>",
+            }
+            {
+                name:  "Secret2Key",
+                value: "<random>",
+            }
+        ]
+        digests: [
+            // This is the consistency digest used by all partitions.
+            {
+                name:       "CnstyDigest",
+                iv_value:   "<random>",
+                cnst_value: "<random>",
+            }
+            // The other digest configurations below are used for
+            // key derivation and token hashing.
+            {
+                name:       "LcRawDigest",
+                iv_value:   "<random>",
+                cnst_value: "<random>",
+            }
+            {
+                name:       "FlashDataKey",
+                iv_value:   "<random>",
+                cnst_value: "<random>",
+            }
+            {
+                name:       "FlashAddrKey",
+                iv_value:   "<random>",
+                cnst_value: "<random>",
+            }
+            {
+                name:       "SramDataKey",
+                iv_value:   "<random>",
+                cnst_value: "<random>",
+            }
+        ]
+    }
+
     // The enumeration order below defines the address map of the OTP controller,
     // if the offsets are not defined explicitly via the "offset" key.
     // Note that the digest items are added automatically to the address map.
@@ -89,7 +141,7 @@
                     // Default value to be output in case partition has not
                     // initialized or is in error state. If not specified,
                     // a value of '0 will be used.
-                    inv_default: "{256{1'b1}}",
+                    inv_default: "<random>",
                 }
                 {
                     name: "HW_CFG_CONTENT",
@@ -118,12 +170,12 @@
                     // This will generate a random default to be output in
                     // case partition has not initialized or is in error state.
                     // If not specified, a value of '0 will be used.
-                    rand_inv_default: "True",
+                    inv_default: "<random>",
                     size: "16"
                 }
                 {
                     name: "TEST_EXIT_TOKEN",
-                    rand_inv_default: "True",
+                    inv_default: "<random>",
                     size: "16"
                 }
             ],
@@ -144,17 +196,17 @@
             items: [
                 {
                     name: "FLASH_ADDR_KEY_SEED",
-                    rand_inv_default: "True",
+                    inv_default: "<random>",
                     size: "32"
                 }
                 {
                     name: "FLASH_DATA_KEY_SEED",
-                    rand_inv_default: "True",
+                    inv_default: "<random>",
                     size: "32"
                 }
                 {
                     name: "SRAM_DATA_KEY_SEED",
-                    rand_inv_default: "True",
+                    inv_default: "<random>",
                     size: "16"
                 }
             ],
@@ -176,17 +228,17 @@
             items: [
                 {
                     name: "RMA_TOKEN",
-                    rand_inv_default: "True",
+                    inv_default: "<random>",
                     size: "16"
                 }
                 {
                     name: "CREATOR_ROOT_KEY_SHARE0",
-                    rand_inv_default: "True",
+                    inv_default: "<random>",
                     size: "32"
                 }
                 {
                     name: "CREATOR_ROOT_KEY_SHARE1",
-                    rand_inv_default: "True",
+                    inv_default: "<random>",
                     size: "32"
                 }
             ],
diff --git a/hw/ip/otp_ctrl/rtl/otp_ctrl_part_pkg.sv.tpl b/hw/ip/otp_ctrl/rtl/otp_ctrl_part_pkg.sv.tpl
index 8b0c72e..84f823a 100644
--- a/hw/ip/otp_ctrl/rtl/otp_ctrl_part_pkg.sv.tpl
+++ b/hw/ip/otp_ctrl/rtl/otp_ctrl_part_pkg.sv.tpl
@@ -10,21 +10,113 @@
 //
 <%
   def PascalCase(inp):
+    # if input is in snake case format
+    # or ALLCAPS
     oup = ''
-    upper = True
-    for k in inp.lower():
-      if k == '_':
-        upper = True
-      else:
-        oup += k.upper() if upper else k
-        upper = False
+    if '_' in inp or inp == inp.upper():
+      upper = True
+      for k in inp:
+        if k == '_':
+          upper = True
+        else:
+          oup += k.upper() if upper else k.lower()
+          upper = False
+    # assume its a possibly PascalCased string.
+    # just make sure the first char is capitalized.
+    else:
+      oup = inp[0].upper()
+      if len(inp) > 1:
+        oup += inp[1:]
+
     return oup
+
 %>
 package otp_ctrl_part_pkg;
 
+  import prim_util_pkg::vbits;
   import otp_ctrl_reg_pkg::*;
   import otp_ctrl_pkg::*;
 
+  ////////////////////////////////////
+  // Scrambling Constants and Types //
+  ////////////////////////////////////
+
+  parameter int NumScrmblKeys = ${len(otp_mmap.config["scrambling"]["keys"])};
+  parameter int NumDigestSets = ${len(otp_mmap.config["scrambling"]["digests"])};
+  parameter int ConstSelWidth = (NumScrmblKeys > NumDigestSets) ?
+                                vbits(NumScrmblKeys) :
+                                vbits(NumDigestSets);
+
+  typedef enum logic [ConstSelWidth-1:0] {
+    StandardMode,
+    ChainedMode
+  } digest_mode_e;
+
+  typedef logic [NumScrmblKeys-1:0][ScrmblKeyWidth-1:0] key_array_t;
+  typedef logic [NumDigestSets-1:0][ScrmblKeyWidth-1:0] digest_const_array_t;
+  typedef logic [NumDigestSets-1:0][ScrmblBlockWidth-1:0] digest_iv_array_t;
+
+  typedef enum logic [ConstSelWidth-1:0] {
+% for key in otp_mmap.config["scrambling"]["keys"]:
+    ${PascalCase(key["name"])}${"" if loop.last else ","}
+% endfor
+  } key_sel_e;
+
+  typedef enum logic [ConstSelWidth-1:0] {
+% for dig in otp_mmap.config["scrambling"]["digests"]:
+    ${PascalCase(dig["name"])}${"" if loop.last else ","}
+% endfor
+  } digest_sel_e;
+
+  parameter key_array_t RndCnstKey = {
+% for key in otp_mmap.config["scrambling"]["keys"][::-1]:
+    ${"{0:}'h{1:0X}".format(otp_mmap.config["scrambling"]["key_size"] * 8, key["value"])}${"" if loop.last else ","}
+% endfor
+  };
+
+  // Note: digest set 0 is used for computing the partition digests. Constants at
+  // higher indices are used to compute the scrambling keys.
+  parameter digest_const_array_t RndCnstDigestConst = {
+% for dig in otp_mmap.config["scrambling"]["digests"][::-1]:
+    ${"{0:}'h{1:0X}".format(otp_mmap.config["scrambling"]["cnst_size"] * 8, dig["cnst_value"])}${"" if loop.last else ","}
+% endfor
+  };
+
+  parameter digest_iv_array_t RndCnstDigestIV = {
+% for dig in otp_mmap.config["scrambling"]["digests"][::-1]:
+    ${"{0:}'h{1:0X}".format(otp_mmap.config["scrambling"]["iv_size"] * 8, dig["iv_value"])}${"" if loop.last else ","}
+% endfor
+  };
+
+
+  /////////////////////////////////////
+  // Typedefs for Partition Metadata //
+  /////////////////////////////////////
+
+  typedef enum logic [1:0] {
+    Unbuffered,
+    Buffered,
+    LifeCycle
+  } part_variant_e;
+
+  typedef struct packed {
+    part_variant_e variant;
+    // Offset and size within the OTP array, in Bytes.
+    logic [OtpByteAddrWidth-1:0] offset;
+    logic [OtpByteAddrWidth-1:0] size;
+    // Key index to use for scrambling.
+    key_sel_e key_sel;
+    // Attributes
+    logic secret;     // Whether the partition is secret (and hence scrambled)
+    logic hw_digest;  // Whether the partition has a hardware digest
+    logic write_lock; // Whether the partition is write lockable (via digest)
+    logic read_lock;  // Whether the partition is read lockable (via digest)
+  } part_info_t;
+
+  ////////////////////////
+  // Partition Metadata //
+  ////////////////////////
+
   localparam part_info_t PartInfo [NumPart] = '{
 % for part in otp_mmap.config["partitions"]:
     // ${part["name"]}
@@ -77,9 +169,8 @@
   % for k, part in enumerate(otp_mmap.config["partitions"][::-1]):
     ${int(part["size"])*8}'({
     % for item in part["items"][::-1]:
-      ${item["inv_default"]}${("\n    })," if k < len(otp_mmap.config["partitions"])-1 else "\n    })});") if loop.last else ","}
+      ${"{}'h{:0X}".format(item["size"] * 8, item["inv_default"])}${("\n    })," if k < len(otp_mmap.config["partitions"])-1 else "\n    })});") if loop.last else ","}
     % endfor
   % endfor
 
-
 endpackage : otp_ctrl_part_pkg
diff --git a/util/design/lib/LcStEnc.py b/util/design/lib/LcStEnc.py
index 9b92ea2..3526153 100644
--- a/util/design/lib/LcStEnc.py
+++ b/util/design/lib/LcStEnc.py
@@ -6,9 +6,10 @@
 """
 import logging as log
 import random
+from collections import OrderedDict
 
 from lib.common import (check_int, ecc_encode, get_hd, hd_histogram,
-                        is_valid_codeword, scatter_bits)
+                        is_valid_codeword, scatter_bits, random_or_hexvalue)
 
 
 def _is_incremental_codeword(word1, word2):
@@ -153,6 +154,10 @@
             log.error('Missing secded configuration')
             exit(1)
 
+        if 'tokens' not in config:
+            log.error('Missing token configuration')
+            exit(1)
+
         config['secded'].setdefault('data_width', 0)
         config['secded'].setdefault('ecc_width', 0)
         config['secded'].setdefault('ecc_matrix', [[]])
@@ -162,6 +167,7 @@
         config.setdefault('min_hw', 0)
         config.setdefault('max_hw', 0)
         config.setdefault('min_hd', 0)
+        config.setdefault('token_size', 128)
 
         config['seed'] = check_int(config['seed'])
 
@@ -178,6 +184,7 @@
         config['min_hw'] = check_int(config['min_hw'])
         config['max_hw'] = check_int(config['max_hw'])
         config['min_hd'] = check_int(config['min_hd'])
+        config['token_size'] = check_int(config['token_size'])
 
         total_width = config['secded']['data_width'] + config['secded'][
             'ecc_width']
@@ -206,6 +213,18 @@
 
         log.info('')
 
+        hashed_tokens = []
+        for token in config['tokens']:
+            random_or_hexvalue(token, 'value', config['token_size'])
+            hashed_token = OrderedDict()
+            hashed_token['name'] = token['name'] + 'Hashed'
+            # TODO: plug in PRESENT-based hashing algo or KMAC
+            hashed_token['value'] = token['value']
+            hashed_tokens.append(hashed_token)
+
+        config['tokens'] += hashed_tokens
+
+        print(config['tokens'])
         self.config = config
 
         # Re-initialize with seed to make results reproducible.
diff --git a/util/design/lib/OtpMemMap.py b/util/design/lib/OtpMemMap.py
index 0601481..ab5731a 100644
--- a/util/design/lib/OtpMemMap.py
+++ b/util/design/lib/OtpMemMap.py
@@ -11,12 +11,211 @@
 from math import ceil, log2
 
 from tabulate import tabulate
-from lib.common import check_bool, check_int
+from lib.common import check_bool, check_int, random_or_hexvalue
 
 DIGEST_SUFFIX = "_DIGEST"
 DIGEST_SIZE = 8
 
 
+def _validate_otp(otp):
+    '''Validate OTP entry'''
+    otp.setdefault("depth", "1024")
+    otp.setdefault("width", "2")
+    otp["depth"] = check_int(otp["depth"])
+    otp["width"] = check_int(otp["width"])
+    otp["size"] = otp["depth"] * otp["width"]
+    otp["addr_width"] = ceil(log2(check_int(otp["depth"])))
+    otp["byte_addr_width"] = ceil(log2(otp["size"]))
+
+
+def _validate_scrambling(scr):
+    '''Validate SCrambling entry'''
+    scr.setdefault("key_size", "16")
+    scr.setdefault("iv_size", "8")
+    scr.setdefault("cnst_size", "16")
+    scr["key_size"] = check_int(scr["key_size"])
+    scr["iv_size"] = check_int(scr["iv_size"])
+    scr["cnst_size"] = check_int(scr["cnst_size"])
+
+    if "keys" not in scr:
+        log.error("Missing key configuration.")
+        exit(1)
+    if "digests" not in scr:
+        log.error("Missing digest configuration.")
+        exit(1)
+
+    for key in scr["keys"]:
+        key.setdefault("name", "unknown_key_name")
+        key.setdefault("value", "<random>")
+        random_or_hexvalue(key, "value", scr["key_size"] * 8)
+
+    for dig in scr["digests"]:
+        dig.setdefault("name", "unknown_key_name")
+        dig.setdefault("iv_value", "<random>")
+        dig.setdefault("cnst_value", "<random>")
+        random_or_hexvalue(dig, "iv_value", scr["iv_size"] * 8)
+        random_or_hexvalue(dig, "cnst_value", scr["cnst_size"] * 8)
+
+
+def _validate_part(part, offset, key_names):
+    '''Validates a partition within the OTP memory map'''
+    part.setdefault("offset", offset)
+    part.setdefault("name", "unknown_name")
+    part.setdefault("variant", "Unbuffered")
+    part.setdefault("size", "0")
+    part.setdefault("secret", "false")
+    part.setdefault("sw_digest", "false")
+    part.setdefault("hw_digest", "false")
+    part.setdefault("write_lock", "none")
+    part.setdefault("read_lock", "none")
+    part.setdefault("key_sel", "NoKey")
+    log.info("Partition {} at offset {} with size {}".format(
+        part["name"], part["offset"], part["size"]))
+
+    # Make sure these are boolean types (simplifies the mako templates)
+    part["secret"] = check_bool(part["secret"])
+    part["sw_digest"] = check_bool(part["sw_digest"])
+    part["hw_digest"] = check_bool(part["hw_digest"])
+    part["bkout_type"] = check_bool(part["bkout_type"])
+
+    # Make sure this has integer type.
+    part["size"] = check_int(part["size"])
+
+    # basic checks
+    if part["variant"] not in ["Unbuffered", "Buffered", "LifeCycle"]:
+        log.error("Invalid partition type {}".format(part["variant"]))
+        exit(1)
+
+    if part["key_sel"] not in (["NoKey"] + key_names):
+        log.error("Invalid key sel {}".format(part["key_sel"]))
+        exit(1)
+
+    if check_bool(part["secret"]) and part["key_sel"] == "NoKey":
+        log.error(
+            "A secret partition needs a key select value other than NoKey"
+        )
+        exit(1)
+
+    if part["write_lock"].lower() not in ["digest", "csr", "none"]:
+        log.error("Invalid value for write_lock")
+        exit(1)
+
+    if part["read_lock"].lower() not in ["digest", "csr", "none"]:
+        log.error("Invalid value for read_lock")
+        exit(1)
+
+    if part["sw_digest"] and part["hw_digest"]:
+        log.error(
+            "Partition cannot support both a SW and a HW digest at the same time."
+        )
+        exit(1)
+
+    if part["variant"] == "Unbuffered" and not part["sw_digest"]:
+        log.error(
+            "Unbuffered partitions without digest are not supported at the moment."
+        )
+        exit(1)
+
+    if not part["sw_digest"] and not part["hw_digest"]:
+        if part["write_lock"].lower(
+        ) == "digest" or part["read_lock"].lower() == "digest":
+            log.error(
+                "A partition can only be write/read lockable if it has a hw or sw digest."
+            )
+            exit(1)
+
+    if check_int(part["offset"]) % 8:
+        log.error("Partition offset must be 64bit aligned")
+        exit(1)
+
+    if check_int(part["size"]) % 8:
+        log.error("Partition size must be 64bit aligned")
+        exit(1)
+
+    if len(part["items"]) == 0:
+        log.warning("Partition does not contain any items.")
+
+
+def _validate_item(item, offset):
+    '''Validates an item within a partition'''
+    item.setdefault("name", "unknown_name")
+    item.setdefault("size", "0")
+    item.setdefault("isdigest", "false")
+    item.setdefault("offset", offset)
+
+    # Make sure this has integer type.
+    item["size"] = check_int(item["size"])
+
+    # Generate random constant to be used when partition has
+    # not been initialized yet or when it is in error state.
+    random_or_hexvalue(item, "inv_default", check_int(item["size"]) * 8)
+
+
+def _validate_mmap(config):
+    '''Validate the memory map configuration'''
+
+    # Get valid key names.
+    key_names = []
+    for key in config["scrambling"]["keys"]:
+        key_names.append(key["name"])
+
+    offset = 0
+    num_part = 0
+    for part in config["partitions"]:
+        num_part += 1
+        _validate_part(part, offset, key_names)
+
+        # Loop over items within a partition
+        for item in part["items"]:
+            _validate_item(item, offset)
+            log.info("> Item {} at offset {} with size {}".format(
+                item["name"], offset, item["size"]))
+            offset += check_int(item["size"])
+
+        # Place digest at the end of a partition.
+        if part["sw_digest"] or part["hw_digest"]:
+            part["items"].append({
+                "name":
+                part["name"] + DIGEST_SUFFIX,
+                "size":
+                DIGEST_SIZE,
+                "offset":
+                check_int(part["offset"]) + check_int(part["size"]) -
+                DIGEST_SIZE,
+                "isdigest":
+                "True",
+                "inv_default": "<random>"
+            })
+            # Randomize the digest default.
+            random_or_hexvalue(part["items"][-1], "inv_default", DIGEST_SIZE * 8)
+
+            log.info("> Adding digest {} at offset {} with size {}".format(
+                part["name"] + DIGEST_SUFFIX, offset, DIGEST_SIZE))
+            offset += DIGEST_SIZE
+
+        # check offsets and size
+        if offset > check_int(part["offset"]) + check_int(part["size"]):
+            log.error("Not enough space in partitition "
+                      "{} to accommodate all items. Bytes available "
+                      "= {}, bytes requested = {}".format(
+                          part["name"], part["size"],
+                          offset - part["offset"]))
+            exit(1)
+
+        offset = check_int(part["offset"]) + check_int(part["size"])
+
+    if offset > config["otp"]["size"]:
+        log.error(
+            "OTP is not big enough to store all partitions. "
+            "Bytes available {}, bytes required {}",
+            config["otp"]["size"], offset)
+        exit(1)
+
+    log.info("Total number of partitions: {}".format(num_part))
+    log.info("Bytes available in OTP: {}".format(config["otp"]["size"]))
+    log.info("Bytes required for partitions: {}".format(offset))
+
+
 class OtpMemMap():
 
     # This holds the config dict.
@@ -37,154 +236,22 @@
         # Initialize RNG.
         random.seed(int(config['seed']))
 
-        offset = 0
-        num_part = 0
-        for part in config["partitions"]:
-            num_part += 1
-            # Defaults
-            part.setdefault("offset", offset)
-            part.setdefault("name", "unknown_name")
-            part.setdefault("variant", "Unbuffered")
-            part.setdefault("size", "0")
-            part.setdefault("secret", "false")
-            part.setdefault("sw_digest", "false")
-            part.setdefault("hw_digest", "false")
-            part.setdefault("write_lock", "none")
-            part.setdefault("read_lock", "none")
-            part.setdefault("key_sel", "NoKey")
-            log.info("Partition {} at offset {} with size {}".format(
-                part["name"], part["offset"], part["size"]))
-
-            # make sure these are boolean types (simplifies the mako templates)
-            part["secret"] = check_bool(part["secret"])
-            part["sw_digest"] = check_bool(part["sw_digest"])
-            part["hw_digest"] = check_bool(part["hw_digest"])
-            part["bkout_type"] = check_bool(part["bkout_type"])
-
-            # basic checks
-            if part["variant"] not in ["Unbuffered", "Buffered", "LifeCycle"]:
-                log.error("Invalid partition type {}".format(part["variant"]))
-                exit(1)
-
-            if part["key_sel"] not in [
-                    "NoKey", "Secret0Key", "Secret1Key", "Secret2Key"
-            ]:
-                log.error("Invalid key sel {}".format(part["key_sel"]))
-                exit(1)
-
-            if check_bool(part["secret"]) and part["key_sel"] == "NoKey":
-                log.error(
-                    "A secret partition needs a key select value other than NoKey"
-                )
-                exit(1)
-
-            if part["write_lock"].lower() not in ["digest", "csr", "none"]:
-                log.error("Invalid value for write_lock")
-                exit(1)
-
-            if part["read_lock"].lower() not in ["digest", "csr", "none"]:
-                log.error("Invalid value for read_lock")
-                exit(1)
-
-            if part["sw_digest"] and part["hw_digest"]:
-                log.error(
-                    "Partition cannot support both a SW and a HW digest at the same time."
-                )
-                exit(1)
-
-            if part["variant"] == "Unbuffered" and not part["sw_digest"]:
-                log.error(
-                    "Unbuffered partitions without digest are not supported at the moment."
-                )
-                exit(1)
-
-            if not part["sw_digest"] and not part["hw_digest"]:
-                if part["write_lock"].lower(
-                ) == "digest" or part["read_lock"].lower() == "digest":
-                    log.error(
-                        "A partition can only be write/read lockable if it has a hw or sw digest."
-                    )
-                    exit(1)
-
-            if check_int(part["offset"]) % 8:
-                log.error("Partition offset must be 64bit aligned")
-                exit(1)
-
-            if check_int(part["size"]) % 8:
-                log.error("Partition size must be 64bit aligned")
-                exit(1)
-
-            # Loop over items within a partition
-            for item in part["items"]:
-                item.setdefault("name", "unknown_name")
-                item.setdefault("size", "0")
-                item.setdefault("isdigest", "false")
-                item.setdefault("offset", offset)
-                # Generate random constant to be used when partition has
-                # not been initialized yet or when it is in error state.
-                if check_bool(item.setdefault("rand_inv_default", "false")):
-                    inv_default = random.getrandbits(
-                        check_int(item["size"]) * 8)
-                else:
-                    inv_default = 0
-                item.setdefault(
-                    "inv_default", "{}'h{:0X}".format(
-                        check_int(item["size"]) * 8, inv_default))
-                log.info("> Item {} at offset {} with size {}".format(
-                    item["name"], offset, item["size"]))
-                offset += check_int(item["size"])
-
-            # Place digest at the end of a partition.
-            if part["sw_digest"] or part["hw_digest"]:
-                part["items"].append({
-                    "name":
-                    part["name"] + DIGEST_SUFFIX,
-                    "size":
-                    DIGEST_SIZE,
-                    "offset":
-                    check_int(part["offset"]) + check_int(part["size"]) -
-                    DIGEST_SIZE,
-                    "isdigest":
-                    "True",
-                    "inv_default":
-                    "{256{1'b1}}"
-                })
-
-                log.info("> Adding digest {} at offset {} with size {}".format(
-                    part["name"] + DIGEST_SUFFIX, offset, DIGEST_SIZE))
-                offset += DIGEST_SIZE
-
-            if len(part["items"]) == 0:
-                log.warning("Partition does not contain any items.")
-
-            # check offsets and size
-            if offset > check_int(part["offset"]) + check_int(part["size"]):
-                log.error("Not enough space in partitition "
-                          "{} to accommodate all items. Bytes available "
-                          "= {}, bytes requested = {}".format(
-                              part["name"], part["size"],
-                              offset - part["offset"]))
-                exit(1)
-
-            offset = check_int(part["offset"]) + check_int(part["size"])
-
-        otp_size = check_int(config["otp"]["depth"]) * check_int(
-            config["otp"]["width"])
-        config["otp"]["size"] = otp_size
-        config["otp"]["addr_width"] = ceil(
-            log2(check_int(config["otp"]["depth"])))
-        config["otp"]["byte_addr_width"] = ceil(log2(check_int(otp_size)))
-
-        if offset > otp_size:
-            log.error(
-                "OTP is not big enough to store all partitions. "
-                "Bytes available {}, bytes required {}",
-                otp_size, offset)
+        if "otp" not in config:
+            log.error("Missing otp configuration.")
+            exit(1)
+        if "scrambling" not in config:
+            log.error("Missing scrambling configuration.")
+            exit(1)
+        if "partitions" not in config:
+            log.error("Missing partition configuration.")
             exit(1)
 
-        log.info("Total number of partitions: {}".format(num_part))
-        log.info("Bytes available in OTP: {}".format(otp_size))
-        log.info("Bytes required for partitions: {}".format(offset))
+        # Validate OTP info.
+        _validate_otp(config["otp"])
+        # Validate scrambling info.
+        _validate_scrambling(config["scrambling"])
+        # Validate memory map.
+        _validate_mmap(config)
 
         self.config = config
 
@@ -192,7 +259,6 @@
         log.info('Successfully parsed and translated OTP memory map.')
         log.info('')
 
-
     def create_partitions_table(self):
         header = [
             "Partition", "Secret", "Buffered", "WR Lockable", "RD Lockable",
diff --git a/util/design/lib/common.py b/util/design/lib/common.py
index 0d12e92..20e2ba9 100644
--- a/util/design/lib/common.py
+++ b/util/design/lib/common.py
@@ -203,4 +203,27 @@
             scatterword += bits[j]
             j += 1
 
-    return scatterword
\ No newline at end of file
+    return scatterword
+
+
+def random_or_hexvalue(dict_obj, key, num_bits):
+    '''Convert hex value at "key" to an integer or draw a random number.'''
+
+    # Initialize to default if this key does not exist.
+    dict_obj.setdefault(key, '0x0')
+
+    # Generate a random number of requested size in this case.
+    if dict_obj[key] == '<random>':
+        dict_obj[key] = random.getrandbits(num_bits)
+    # Otherwise attempt to convert this number to an int.
+    # Check that the range is correct.
+    else:
+        try:
+            dict_obj[key] = int(dict_obj[key], 16)
+            if dict_obj[key] >= 2**num_bits:
+                log.error('Value is out of range.')
+                exit(1)
+        except ValueError:
+            log.error('Invalid value "{}". Must be hex or "<random>".'
+                      .format(dict_obj[key]))
+            exit(1)