diff --git a/extensions/openpower-pels/registry.cpp b/extensions/openpower-pels/registry.cpp
index 22cdc27..c8f10d7 100644
--- a/extensions/openpower-pels/registry.cpp
+++ b/extensions/openpower-pels/registry.cpp
@@ -406,6 +406,7 @@
     RegistryCallout callout;
 
     callout.priority = "high";
+    callout.useInventoryLocCode = false;
 
     if (json.contains("Priority"))
     {
@@ -431,6 +432,11 @@
             json["SymbolicFRUTrusted"].get<std::string>();
     }
 
+    if (json.contains("UseInventoryLocCode"))
+    {
+        callout.useInventoryLocCode = json["UseInventoryLocCode"].get<bool>();
+    }
+
     return callout;
 }
 
diff --git a/extensions/openpower-pels/registry.hpp b/extensions/openpower-pels/registry.hpp
index 673e2c2..7a13b58 100644
--- a/extensions/openpower-pels/registry.hpp
+++ b/extensions/openpower-pels/registry.hpp
@@ -195,6 +195,7 @@
     std::string procedure;
     std::string symbolicFRU;
     std::string symbolicFRUTrusted;
+    bool useInventoryLocCode;
 };
 
 /**
diff --git a/extensions/openpower-pels/registry/README.md b/extensions/openpower-pels/registry/README.md
index f1c90f9..89d4578 100644
--- a/extensions/openpower-pels/registry/README.md
+++ b/extensions/openpower-pels/registry/README.md
@@ -377,6 +377,29 @@
 - Symbolic FRU: symbolic_fru
 - Procedure: maint_procedure
 
+#### Symbolic FRU callouts with dynamic trusted location codes
+
+A special case is when one wants to use a symbolic FRU callout with a trusted
+location code, but the location code to use isn\'t known until runtime. This
+means it can\'t be specified using the 'LocCode' key in the registry.
+
+In this case, one should use the 'SymbolicFRUTrusted' key along with the
+'UseInventoryLocCode' key, and then pass in the inventory item that has the
+desired location code using the 'CALLOUT_INVENTORY_PATH' entry inside of the
+AdditionalData property.  The code will then look up the location code for that
+passed in inventory FRU and place it in the symbolic FRU callout.  The normal
+FRU callout with that inventory item will not be created.  The symbolic FRU
+must be the first callout in the registry for this to work.
+
+```
+{
+
+    "Priority": "high",
+    "SymbolicFRUTrusted": "AIR_MOVR",
+    "UseInventoryLocCode": true
+}
+```
+
 ## Modifying and Testing
 
 The general process for adding new entries to the message registry is:
diff --git a/extensions/openpower-pels/registry/schema/schema.json b/extensions/openpower-pels/registry/schema/schema.json
index 50c2d2d..e122db4 100644
--- a/extensions/openpower-pels/registry/schema/schema.json
+++ b/extensions/openpower-pels/registry/schema/schema.json
@@ -454,6 +454,12 @@
             "enum": ["no_vpd_for_fru", "bmc_code"]
         },
 
+        "useInventoryLocCode":
+        {
+            "description": "Used along with SymbolicFRUTrusted to specify that the location code to use with the symbolic FRU is to be taken from the passed in CALLOUT_INVENTORY_PATH callout rather than being specified with LocCode.",
+            "type": "boolean"
+        },
+
         "calloutList":
         {
             "description": "The list of FRU callouts to add to a PEL.  If just LocCode is specified, it is a normal hardware FRU callout.  If Procedure is specified, it is a procedure callout.  If SymbolicFRU or SymbolicFRUTrusted are specified, it is a Symbolic FRU callout.  SymbolicFRUTrusted also requires LocCode.",
@@ -467,7 +473,8 @@
                     "LocCode": {"$ref": "#/definitions/locationCode" },
                     "SymbolicFRU": {"$ref": "#/definitions/symbolicFRU" },
                     "SymbolicFRUTrusted": {"$ref": "#/definitions/symbolicFRUTrusted" },
-                    "Procedure": {"$ref": "#/definitions/procedure" }
+                    "Procedure": {"$ref": "#/definitions/procedure" },
+                    "UseInventoryLocCode": {"$ref": "#/definitions/useInventoryLocCode" }
                 },
                 "additionalProperties": false,
                 "required": ["Priority"],
@@ -480,7 +487,8 @@
                             { "required": ["LocCode"] },
                             { "not": { "required": ["SymbolicFRU"] }},
                             { "not": { "required": ["SymbolicFRUTrusted"] }},
-                            { "not": { "required": ["Procedure"] }}
+                            { "not": { "required": ["Procedure"] }},
+                            { "not": { "required": ["UseInventoryLocCode"] }}
                         ]
                     },
                     {
@@ -489,16 +497,28 @@
                         [
                             { "required": ["SymbolicFRU"] },
                             { "not": { "required": ["SymbolicFRUTrusted"] }},
-                            { "not": { "required": ["Procedure"] }}
+                            { "not": { "required": ["Procedure"] }},
+                            { "not": { "required": ["UseInventoryLocCode"] }}
                         ]
                     },
 
                     {
                         "allOf":
                         [
-                            { "required": ["SymbolicFRUTrusted", "LocationCode"] },
+                            { "required": ["SymbolicFRUTrusted", "LocCode"] },
                             { "not": { "required": ["SymbolicFRU"] }},
-                            { "not": { "required": ["Procedure"] }}
+                            { "not": { "required": ["Procedure"] }},
+                            { "not": { "required": ["UseInventoryLocCode"] }}
+                        ]
+                    },
+
+                    {
+                        "allOf":
+                        [
+                            { "required": ["SymbolicFRUTrusted", "UseInventoryLocCode"] },
+                            { "not": { "required": ["SymbolicFRU"] }},
+                            { "not": { "required": ["Procedure"] }},
+                            { "not": { "required": ["LocCode"] }}
                         ]
                     },
 
@@ -508,7 +528,8 @@
                             { "required": ["Procedure"] },
                             { "not": { "required": ["SymbolicFRU"] }},
                             { "not": { "required": ["SymbolicFRUTrusted"] }},
-                            { "not": { "required": ["LocCode"] }}
+                            { "not": { "required": ["LocCode"] }},
+                            { "not": { "required": ["UseInventoryLocCode"] }}
                         ]
                     }
                 ]
diff --git a/extensions/openpower-pels/src.cpp b/extensions/openpower-pels/src.cpp
index 0915a24..3fd62e8 100644
--- a/extensions/openpower-pels/src.cpp
+++ b/extensions/openpower-pels/src.cpp
@@ -744,18 +744,28 @@
                       const nlohmann::json& jsonCallouts,
                       const DataInterfaceBase& dataIface)
 {
+    auto registryCallouts =
+        getRegistryCallouts(regEntry, additionalData, dataIface);
+
     auto item = additionalData.getValue("CALLOUT_INVENTORY_PATH");
-    if (item)
+
+    // If the first registry callout says to use the passed in inventory
+    // path to get the location code for a symbolic FRU callout with a
+    // trusted location code, then do not add the inventory path as a
+    // normal FRU callout.
+    bool useInvForSymbolicFRULocCode =
+        !registryCallouts.empty() && registryCallouts[0].useInventoryLocCode &&
+        !registryCallouts[0].symbolicFRUTrusted.empty();
+
+    if (item && !useInvForSymbolicFRULocCode)
     {
         addInventoryCallout(*item, std::nullopt, std::nullopt, dataIface);
     }
 
     addDevicePathCallouts(additionalData, dataIface);
 
-    if (regEntry.callouts)
-    {
-        addRegistryCallouts(regEntry, additionalData, dataIface);
-    }
+    addRegistryCallouts(registryCallouts, dataIface,
+                        (useInvForSymbolicFRULocCode) ? item : std::nullopt);
 
     if (!jsonCallouts.empty())
     {
@@ -822,20 +832,49 @@
     _callouts->addCallout(std::move(callout));
 }
 
-void SRC::addRegistryCallouts(const message::Entry& regEntry,
-                              const AdditionalData& additionalData,
-                              const DataInterfaceBase& dataIface)
+std::vector<message::RegistryCallout>
+    SRC::getRegistryCallouts(const message::Entry& regEntry,
+                             const AdditionalData& additionalData,
+                             const DataInterfaceBase& dataIface)
+{
+    std::vector<message::RegistryCallout> registryCallouts;
+
+    if (regEntry.callouts)
+    {
+        try
+        {
+            auto systemNames = dataIface.getSystemNames();
+
+            registryCallouts = message::Registry::getCallouts(
+                regEntry.callouts.value(), systemNames, additionalData);
+        }
+        catch (const std::exception& e)
+        {
+            addDebugData(fmt::format(
+                "Error parsing PEL message registry callout JSON: {}",
+                e.what()));
+        }
+    }
+
+    return registryCallouts;
+}
+
+void SRC::addRegistryCallouts(
+    const std::vector<message::RegistryCallout>& callouts,
+    const DataInterfaceBase& dataIface,
+    std::optional<std::string> trustedSymbolicFRUInvPath)
 {
     try
     {
-        auto systemNames = dataIface.getSystemNames();
-
-        auto regCallouts = message::Registry::getCallouts(
-            regEntry.callouts.value(), systemNames, additionalData);
-
-        for (const auto& regCallout : regCallouts)
+        for (const auto& callout : callouts)
         {
-            addRegistryCallout(regCallout, dataIface);
+            addRegistryCallout(callout, dataIface, trustedSymbolicFRUInvPath);
+
+            // Only the first callout gets the inventory path
+            if (trustedSymbolicFRUInvPath)
+            {
+                trustedSymbolicFRUInvPath = std::nullopt;
+            }
         }
     }
     catch (std::exception& e)
@@ -846,8 +885,10 @@
     }
 }
 
-void SRC::addRegistryCallout(const message::RegistryCallout& regCallout,
-                             const DataInterfaceBase& dataIface)
+void SRC::addRegistryCallout(
+    const message::RegistryCallout& regCallout,
+    const DataInterfaceBase& dataIface,
+    const std::optional<std::string>& trustedSymbolicFRUInvPath)
 {
     std::unique_ptr<src::Callout> callout;
     auto locCode = regCallout.locCode;
@@ -891,6 +932,22 @@
     {
         // Symbolic FRU with trusted location code callout
 
+        // Use the location code from the inventory path if there is one.
+        if (trustedSymbolicFRUInvPath)
+        {
+            try
+            {
+                locCode = dataIface.getLocationCode(*trustedSymbolicFRUInvPath);
+            }
+            catch (const std::exception& e)
+            {
+                addDebugData(
+                    fmt::format("Could not get location code for {}: {}",
+                                *trustedSymbolicFRUInvPath, e.what()));
+                locCode.clear();
+            }
+        }
+
         // The registry wants it to be trusted, but that requires a valid
         // location code for it to actually be.
         callout = std::make_unique<src::Callout>(
diff --git a/extensions/openpower-pels/src.hpp b/extensions/openpower-pels/src.hpp
index 264fab2..5363864 100644
--- a/extensions/openpower-pels/src.hpp
+++ b/extensions/openpower-pels/src.hpp
@@ -414,24 +414,52 @@
                             const std::vector<src::MRU::MRUCallout>& mrus = {});
 
     /**
-     * @brief Adds FRU callouts based on the registry entry JSON
-     *       for this error.
+     * @brief Returns the callouts to use from the registry entry.
+     *
      * @param[in] regEntry - The message registry entry for the error
-     * @param[in] additionalData - The AdditionalData values
+     * @param[in] additionalData - The AdditionalData property
      * @param[in] dataIface - The DataInterface object
      */
-    void addRegistryCallouts(const message::Entry& regEntry,
-                             const AdditionalData& additionalData,
-                             const DataInterfaceBase& dataIface);
+    std::vector<message::RegistryCallout>
+        getRegistryCallouts(const message::Entry& regEntry,
+                            const AdditionalData& additionalData,
+                            const DataInterfaceBase& dataIface);
+
+    /**
+     * @brief Adds the FRU callouts from the list of registry callouts
+     *        passed in to the SRC.
+     *
+     * The last parameter is used only in a special case when the first
+     * callout is a symbolic FRU with a trusted location code.  See the
+     * addRegistryCallout documentation.
+     *
+     * @param[in] callouts - The message registry callouts to add
+     * @param[in] dataIface - The DataInterface object
+     * @param[in] trustedSymbolicFRUInvPath - The optional inventory path used
+     *                                        in the symbolic FRU case.
+     */
+    void addRegistryCallouts(
+        const std::vector<message::RegistryCallout>& callouts,
+        const DataInterfaceBase& dataIface,
+        std::optional<std::string> trustedSymbolicFRUInvPath);
 
     /**
      * @brief Adds a single FRU callout from the message registry.
      *
+     * If the last parameter is filled in, and the registry callout is a
+     * symbolic FRU callout with a trusted location code, and it has the
+     * 'useInventoryLocCode' member set to true, then the location code of
+     * that inventory item will be what is used for that trusted location code.
+     *
      * @param[in] callout - The registry callout structure
      * @param[in] dataIface - The DataInterface object
+     * @param[in] trustedSymbolicFRUInvPath - The optional inventory path used
+     *                                        in the symbolic FRU case.
      */
-    void addRegistryCallout(const message::RegistryCallout& callout,
-                            const DataInterfaceBase& dataIface);
+    void addRegistryCallout(
+        const message::RegistryCallout& callout,
+        const DataInterfaceBase& dataIface,
+        const std::optional<std::string>& trustedSymbolicFRUInvPath);
 
     /**
      * @brief Creates the Callouts object _callouts