diff --git a/control/json/actions/mapped_floor.cpp b/control/json/actions/mapped_floor.cpp
index c2b78c3..b84de15 100644
--- a/control/json/actions/mapped_floor.cpp
+++ b/control/json/actions/mapped_floor.cpp
@@ -31,6 +31,27 @@
 
 using json = nlohmann::json;
 
+template <typename T>
+uint64_t addFloorOffset(uint64_t floor, T offset, const std::string& actionName)
+{
+    if constexpr (!std::is_arithmetic_v<T>)
+    {
+        throw std::runtime_error("Invalid variant type in addFloorOffset");
+    }
+
+    auto newFloor = static_cast<T>(floor) + offset;
+    if (newFloor < 0)
+    {
+        log<level::ERR>(
+            fmt::format("{}: Floor offset of {} resulted in negative floor",
+                        actionName, offset)
+                .c_str());
+        return floor;
+    }
+
+    return static_cast<uint64_t>(newFloor);
+}
+
 MappedFloor::MappedFloor(const json& jsonObj,
                          const std::vector<Group>& groups) :
     ActionBase(jsonObj, groups)
@@ -87,6 +108,12 @@
         FanFloors ff;
         ff.keyValue = getJsonValue(floors["key"]);
 
+        if (floors.contains("floor_offset_parameter"))
+        {
+            ff.offsetParameter =
+                floors["floor_offset_parameter"].get<std::string>();
+        }
+
         for (const auto& groupEntry : floors["floors"])
         {
             if ((!groupEntry.contains("group") &&
@@ -321,6 +348,11 @@
             }
         }
 
+        if (newFloor)
+        {
+            *newFloor = applyFloorOffset(*newFloor, floorTable.offsetParameter);
+        }
+
         // Valid key value for this entry, so done
         break;
     }
@@ -335,4 +367,38 @@
     }
 }
 
+uint64_t MappedFloor::applyFloorOffset(uint64_t floor,
+                                       const std::string& offsetParameter) const
+{
+    if (!offsetParameter.empty())
+    {
+        auto offset = Manager::getParameter(offsetParameter);
+        if (offset)
+        {
+            if (std::holds_alternative<int32_t>(*offset))
+            {
+                return addFloorOffset(floor, std::get<int32_t>(*offset),
+                                      getUniqueName());
+            }
+            else if (std::holds_alternative<int64_t>(*offset))
+            {
+                return addFloorOffset(floor, std::get<int64_t>(*offset),
+                                      getUniqueName());
+            }
+            else if (std::holds_alternative<double>(*offset))
+            {
+                return addFloorOffset(floor, std::get<double>(*offset),
+                                      getUniqueName());
+            }
+            else
+            {
+                throw std::runtime_error(
+                    "Invalid data type in floor offset parameter ");
+            }
+        }
+    }
+
+    return floor;
+}
+
 } // namespace phosphor::fan::control::json
diff --git a/control/json/actions/mapped_floor.hpp b/control/json/actions/mapped_floor.hpp
index 3edbf3d..fa0e302 100644
--- a/control/json/actions/mapped_floor.hpp
+++ b/control/json/actions/mapped_floor.hpp
@@ -37,6 +37,7 @@
  *    "fan_floors": [
  *        {
  *        "key": 27,
+ *        "floor_offset_parameter": "floor_27_offset",
  *        "floors": [
  *          {
  *            "group": "altitude",
@@ -83,8 +84,10 @@
  *     another group to check.  In this case, 'power_mode'.  Repeat the above
  *     step.
  *   - After all the group compares are done, choose the largest floor value
- *     to set the fan floor to.  If any group check results doesn't end in
- *     a match being found, then the default floor will be set.
+ *     to set the fan floor to, but first apply the floor offset provided
+ *     by the parameter in the 'floor_offset_parameter' field, if it present.
+ *   - If any group check results doesn't end in a match being found, then
+ *     the default floor will be set.
  *
  * Cases where the default floor will be set:
  *  - A table entry can't be found based on a key group's value.
@@ -150,6 +153,23 @@
     void setFloorTable(const json& jsonObj);
 
     /**
+     * @brief Applies the offset in offsetParameter to the
+     *        value passed in.
+     *
+     * If offsetParameter is empty then no offset will be
+     * applied.
+     *
+     * Note: The offset may be negative.
+     *
+     * @param[in] floor - The floor to apply offset to
+     * @param[in] offsetParameter - The floor offset parameter
+     *
+     * @return uint64_t - The new floor value
+     */
+    uint64_t applyFloorOffset(uint64_t floor,
+                              const std::string& offsetParameter) const;
+
+    /**
      * @brief Determines the maximum value of the property specified
      *        for the group of all members in the group.
      *
@@ -192,6 +212,7 @@
     struct FanFloors
     {
         PropertyVariantType keyValue;
+        std::string offsetParameter;
         std::vector<FloorGroup> floorGroups;
     };