diff --git a/extensions/openpower-pels/pel.cpp b/extensions/openpower-pels/pel.cpp
index eb1a368..157af5a 100644
--- a/extensions/openpower-pels/pel.cpp
+++ b/extensions/openpower-pels/pel.cpp
@@ -3,6 +3,7 @@
 #include "bcd_time.hpp"
 #include "log_id.hpp"
 #include "section_factory.hpp"
+#include "src.hpp"
 #include "stream.hpp"
 
 #include <phosphor-logging/log.hpp>
@@ -14,15 +15,19 @@
 namespace message = openpower::pels::message;
 
 PEL::PEL(const message::Entry& entry, uint32_t obmcLogID, uint64_t timestamp,
-         phosphor::logging::Entry::Level severity)
+         phosphor::logging::Entry::Level severity,
+         const AdditionalData& additionalData)
 {
     _ph = std::make_unique<PrivateHeader>(entry.componentID, obmcLogID,
                                           timestamp);
     _uh = std::make_unique<UserHeader>(entry, severity);
 
-    // Add future sections here and update the count
+    auto src = std::make_unique<SRC>(entry, additionalData);
+    _optionalSections.push_back(std::move(src));
 
-    _ph->sectionCount() = 2;
+    // Add future sections here
+
+    _ph->sectionCount() = 2 + _optionalSections.size();
 }
 
 PEL::PEL(std::vector<uint8_t>& data) : PEL(data, 0)
@@ -111,5 +116,20 @@
     return pelData;
 }
 
+std::optional<SRC*> PEL::primarySRC() const
+{
+    auto src = std::find_if(
+        _optionalSections.begin(), _optionalSections.end(), [](auto& section) {
+            return section->header().id ==
+                   static_cast<uint16_t>(SectionID::primarySRC);
+        });
+    if (src != _optionalSections.end())
+    {
+        return static_cast<SRC*>(src->get());
+    }
+
+    return std::nullopt;
+}
+
 } // namespace pels
 } // namespace openpower
diff --git a/extensions/openpower-pels/pel.hpp b/extensions/openpower-pels/pel.hpp
index 0c35e3e..9f34b62 100644
--- a/extensions/openpower-pels/pel.hpp
+++ b/extensions/openpower-pels/pel.hpp
@@ -3,6 +3,7 @@
 #include "additional_data.hpp"
 #include "private_header.hpp"
 #include "registry.hpp"
+#include "src.hpp"
 #include "user_header.hpp"
 
 #include <memory>
@@ -31,15 +32,10 @@
  *
  * This class represents all sections with objects.
  *
- * The available constructors are:
- * - PEL(std::vector<uint8_t>& data) - build this object out of a fully
- *   formed flattened PEL.
- *
- * - PEL(const openpower::pels::message::Entry& entry,
- *       uint32_t obmcLogID,
- *       uint64_t timestamp,
- *       phosphor::logging::Entry::Level severity)
- *      - build this object from an OpenBMC event log.
+ * The class can be constructed:
+ * - From a full formed flattened PEL.
+ * - From scratch based on an OpenBMC event and its corresponding PEL message
+ *   registry entry.
  *
  * The data() method allows one to retrieve the PEL as a vector<uint8_t>.  This
  * is the format in which it is stored and transmitted.
@@ -88,9 +84,11 @@
      * @param[in] obmcLogID - ID of corresponding OpenBMC event log
      * @param[in] timestamp - Timestamp from the event log
      * @param[in] severity - Severity from the event log
+     * @param[in] additionalData - The AdditionalData contents
      */
     PEL(const openpower::pels::message::Entry& entry, uint32_t obmcLogID,
-        uint64_t timestamp, phosphor::logging::Entry::Level severity);
+        uint64_t timestamp, phosphor::logging::Entry::Level severity,
+        const AdditionalData& additionalData);
 
     /**
      * @brief Convenience function to return the log ID field from the
@@ -168,6 +166,16 @@
     }
 
     /**
+     * @brief Gives access to the primary SRC's section class
+     *
+     * This is technically an optional section, so the return
+     * value is an std::optional<SRC*>.
+     *
+     * @return std::optional<SRC*> - the SRC section object
+     */
+    std::optional<SRC*> primarySRC() const;
+
+    /**
      * @brief Returns the optional sections, which is everything but
      *        the Private and User Headers.
      *
diff --git a/extensions/openpower-pels/src.cpp b/extensions/openpower-pels/src.cpp
index 7fd7b0e..a79df8d 100644
--- a/extensions/openpower-pels/src.cpp
+++ b/extensions/openpower-pels/src.cpp
@@ -60,6 +60,86 @@
     }
 }
 
+SRC::SRC(const message::Entry& regEntry, const AdditionalData& additionalData)
+{
+    _header.id = static_cast<uint16_t>(SectionID::primarySRC);
+    _header.version = srcSectionVersion;
+    _header.subType = srcSectionSubtype;
+    _header.componentID = regEntry.componentID;
+
+    _version = srcVersion;
+
+    _flags = 0;
+    if (regEntry.src.powerFault.value_or(false))
+    {
+        _flags |= powerFaultEvent;
+    }
+
+    _reserved1B = 0;
+
+    _wordCount = numSRCHexDataWords + 1;
+
+    _reserved2B = 0;
+
+    // There are multiple fields encoded in the hex data words.
+    std::for_each(_hexData.begin(), _hexData.end(),
+                  [](auto& word) { word = 0; });
+    setBMCFormat();
+    setBMCPosition();
+    // Partition dump status and partition boot type always 0 for BMC errors.
+    //
+    // TODO: Fill in other fields that aren't available yet.
+
+    // Fill in the last 4 words from the AdditionalData property contents.
+    setUserDefinedHexWords(regEntry, additionalData);
+
+    _asciiString = std::make_unique<src::AsciiString>(regEntry);
+
+    // TODO: add callouts using the Callouts object
+
+    _size = baseSRCSize;
+    _size += _callouts ? _callouts->flattenedSize() : 0;
+    _header.size = Section::flattenedSize() + _size;
+
+    _valid = true;
+}
+
+void SRC::setUserDefinedHexWords(const message::Entry& regEntry,
+                                 const AdditionalData& ad)
+{
+    if (!regEntry.src.hexwordADFields)
+    {
+        return;
+    }
+
+    // Save the AdditionalData value corresponding to the
+    // adName key in _hexData[wordNum].
+    for (const auto& [wordNum, adName] : *regEntry.src.hexwordADFields)
+    {
+        // Can only set words 6 - 9
+        if (!isUserDefinedWord(wordNum))
+        {
+            log<level::WARNING>("SRC user data word out of range",
+                                entry("WORD_NUM=%d", wordNum),
+                                entry("ERROR_NAME=%s", regEntry.name.c_str()));
+            continue;
+        }
+
+        auto value = ad.getValue(adName);
+        if (value)
+        {
+            _hexData[getWordIndexFromWordNum(wordNum)] =
+                std::strtoul(value.value().c_str(), nullptr, 0);
+        }
+        else
+        {
+            log<level::WARNING>("Source for user data SRC word not found",
+                                entry("ADDITIONALDATA_KEY=%s", adName.c_str()),
+                                entry("ERROR_NAME=%s", regEntry.name.c_str()));
+        }
+    }
+}
+
 void SRC::validate()
 {
     bool failed = false;
@@ -73,10 +153,9 @@
     }
 
     // Check the version in the SRC, not in the header
-    if (_version != srcSectionVersion)
+    if (_version != srcVersion)
     {
-        log<level::ERR>("Invalid SRC section version",
-                        entry("VERSION=0x%X", _version));
+        log<level::ERR>("Invalid SRC version", entry("VERSION=0x%X", _version));
         failed = true;
     }
 
diff --git a/extensions/openpower-pels/src.hpp b/extensions/openpower-pels/src.hpp
index 365f12b..ab29c0b 100644
--- a/extensions/openpower-pels/src.hpp
+++ b/extensions/openpower-pels/src.hpp
@@ -4,6 +4,7 @@
 #include "ascii_string.hpp"
 #include "callouts.hpp"
 #include "pel_types.hpp"
+#include "registry.hpp"
 #include "section.hpp"
 #include "stream.hpp"
 
@@ -12,8 +13,13 @@
 namespace pels
 {
 
+constexpr uint8_t srcSectionVersion = 0x01;
+constexpr uint8_t srcSectionSubtype = 0x01;
 constexpr size_t numSRCHexDataWords = 8;
-constexpr uint8_t srcSectionVersion = 0x02;
+constexpr uint8_t srcVersion = 0x02;
+constexpr uint8_t bmcSRCFormat = 0x55;
+constexpr uint8_t primaryBMCPosition = 0x10;
+constexpr size_t baseSRCSize = 72;
 
 /**
  * @class SRC
@@ -38,7 +44,8 @@
   public:
     enum HeaderFlags
     {
-        additionalSections = 0x01
+        additionalSections = 0x01,
+        powerFaultEvent = 0x02
     };
 
     SRC() = delete;
@@ -58,6 +65,19 @@
     explicit SRC(Stream& pel);
 
     /**
+     * @brief Constructor
+     *
+     * Creates the section with data from the PEL message registry entry for
+     * this error, along with the AdditionalData property contents from the
+     * corresponding event log.
+     *
+     * @param[in] regEntry - The message registry entry for this event log
+     * @param[in] additionalData - The AdditionalData properties in this event
+     *                             log
+     */
+    SRC(const message::Entry& regEntry, const AdditionalData& additionalData);
+
+    /**
      * @brief Flatten the section into the stream
      *
      * @param[in] stream - The stream to write to
@@ -140,13 +160,15 @@
         return _callouts;
     }
 
-  private:
     /**
-     * @brief Fills in the object from the stream data
+     * @brief Returns the size of this section when flattened into a PEL
      *
-     * @param[in] stream - The stream to read from
+     * @return size_t - the size of the section
      */
-    void unflatten(Stream& stream);
+    size_t flattenedSize() const
+    {
+        return _header.size;
+    }
 
     /**
      * @brief Says if this SRC has additional subsections in it
@@ -157,7 +179,98 @@
      */
     inline bool hasAdditionalSections() const
     {
-        return _flags & static_cast<uint8_t>(HeaderFlags::additionalSections);
+        return _flags & additionalSections;
+    }
+
+    /**
+     * @brief Indicates if this event log is for a power fault.
+     *
+     * This comes from a field in the message registry for BMC
+     * generated PELs.
+     *
+     * @return bool
+     */
+    inline bool isPowerFaultEvent() const
+    {
+        return _flags & powerFaultEvent;
+    }
+
+  private:
+    /**
+     * @brief Fills in the user defined hex words from the
+     *        AdditionalData fields.
+     *
+     * When creating this section from a message registry entry,
+     * that entry has a field that says which AdditionalData property
+     * fields to use to fill in the user defined hex data words 6-9
+     * (which correspond to hexData words 4-7).
+     *
+     * For example, given that AdditionalData is a map of string keys
+     * to string values, find the AdditionalData value for AdditionalData
+     * key X, convert it to a uint32_t, and save it in user data word Y.
+     *
+     * @param[in] regEntry - The message registry entry for the error
+     * @param[in] additionalData - The AdditionalData map
+     */
+    void setUserDefinedHexWords(const message::Entry& regEntry,
+                                const AdditionalData& additionalData);
+    /**
+     * @brief Fills in the object from the stream data
+     *
+     * @param[in] stream - The stream to read from
+     */
+    void unflatten(Stream& stream);
+
+    /**
+     * @brief Get the _hexData[] index to use based on the corresponding
+     *        SRC word number.
+     *
+     * Converts the specification nomenclature to this data structure.
+     * See the _hexData documentation below for more information.
+     *
+     * @param[in] wordNum - The SRC word number, as defined by the spec.
+     *
+     * @return size_t The corresponding index into _hexData.
+     */
+    inline size_t getWordIndexFromWordNum(size_t wordNum) const
+    {
+        assert(wordNum >= 2 && wordNum <= 9);
+        return wordNum - 2;
+    }
+
+    /**
+     * @brief Says if the word number is in the range of user defined words.
+     *
+     * This is only used for BMC generated SRCs, where words 6 - 9 are the
+     * user defined ones, meaning that setUserDefinedHexWords() will be
+     * used to fill them in based on the contents of the OpenBMC event log.
+     *
+     * @param[in] wordNum - The SRC word number, as defined by the spec.
+     *
+     * @return bool - If this word number can be filled in by the creator.
+     */
+    inline bool isUserDefinedWord(size_t wordNum) const
+    {
+        return (wordNum >= 6) && (wordNum <= 9);
+    }
+
+    /**
+     * @brief Sets the SRC format byte in the hex word data.
+     */
+    inline void setBMCFormat()
+    {
+        _hexData[0] |= bmcSRCFormat;
+    }
+
+    /**
+     * @brief Sets the hex word field that specifies which BMC
+     *        (primary vs backup) created the error.
+     *
+     * Can be hardcoded until there are systems with redundant BMCs.
+     */
+    inline void setBMCPosition()
+    {
+        _hexData[1] |= primaryBMCPosition;
     }
 
     /**