Regenerate header with properly component offsets.

2 files changed, 55 insertions, 363 deletions

diff --git a/libs/MII/include/bcm5719_MII.h b/libs/MII/include/bcm5719_MII.h
index 9e75839..065c14f 100644
--- a/libs/MII/include/bcm5719_MII.h
+++ b/libs/MII/include/bcm5719_MII.h
@@ -203,40 +203,28 @@ typedef register_container RegMIIControl_t {
     {
         /** @brief constructor for @ref MII_t.Control. */
         r16.setName("Control");
-        r16.setComponentOffset(0x0);
         bits.UnidirectionalMode_GPHYonly_.setBaseRegister(&r16);
         bits.UnidirectionalMode_GPHYonly_.setName("UnidirectionalMode_GPHYonly_");
-        bits.UnidirectionalMode_GPHYonly_.setComponentOffset(0x0);
         bits.SpeedSelectMSB.setBaseRegister(&r16);
         bits.SpeedSelectMSB.setName("SpeedSelectMSB");
-        bits.SpeedSelectMSB.setComponentOffset(0x0);
         bits.CollisionTestMode.setBaseRegister(&r16);
         bits.CollisionTestMode.setName("CollisionTestMode");
-        bits.CollisionTestMode.setComponentOffset(0x0);
         bits.FullDuplexMode.setBaseRegister(&r16);
         bits.FullDuplexMode.setName("FullDuplexMode");
-        bits.FullDuplexMode.setComponentOffset(0x0);
         bits.RestartAutonegotiation.setBaseRegister(&r16);
         bits.RestartAutonegotiation.setName("RestartAutonegotiation");
-        bits.RestartAutonegotiation.setComponentOffset(0x0);
         bits.Isolate_GPHYonly_.setBaseRegister(&r16);
         bits.Isolate_GPHYonly_.setName("Isolate_GPHYonly_");
-        bits.Isolate_GPHYonly_.setComponentOffset(0x0);
         bits.PowerDown.setBaseRegister(&r16);
         bits.PowerDown.setName("PowerDown");
-        bits.PowerDown.setComponentOffset(0x0);
         bits.AutoNegotiationEnable.setBaseRegister(&r16);
         bits.AutoNegotiationEnable.setName("AutoNegotiationEnable");
-        bits.AutoNegotiationEnable.setComponentOffset(0x0);
         bits.SpeedSelectLSB.setBaseRegister(&r16);
         bits.SpeedSelectLSB.setName("SpeedSelectLSB");
-        bits.SpeedSelectLSB.setComponentOffset(0x0);
         bits.LoopbackMode.setBaseRegister(&r16);
         bits.LoopbackMode.setName("LoopbackMode");
-        bits.LoopbackMode.setComponentOffset(0x0);
         bits.Reset.setBaseRegister(&r16);
         bits.Reset.setName("Reset");
-        bits.Reset.setComponentOffset(0x0);
     }
     RegMIIControl_t& operator=(const RegMIIControl_t& other)
     {
@@ -399,55 +387,38 @@ typedef register_container RegMIIStatus_t {
     {
         /** @brief constructor for @ref MII_t.Status. */
         r16.setName("Status");
-        r16.setComponentOffset(0x1);
         bits.ExtendedCapabilitiesSupported.setBaseRegister(&r16);
         bits.ExtendedCapabilitiesSupported.setName("ExtendedCapabilitiesSupported");
-        bits.ExtendedCapabilitiesSupported.setComponentOffset(0x1);
         bits.JabberDetected.setBaseRegister(&r16);
         bits.JabberDetected.setName("JabberDetected");
-        bits.JabberDetected.setComponentOffset(0x1);
         bits.LinkOK.setBaseRegister(&r16);
         bits.LinkOK.setName("LinkOK");
-        bits.LinkOK.setComponentOffset(0x1);
         bits.AutoNegotiationCapable.setBaseRegister(&r16);
         bits.AutoNegotiationCapable.setName("AutoNegotiationCapable");
-        bits.AutoNegotiationCapable.setComponentOffset(0x1);
         bits.RemoteFaultDetected.setBaseRegister(&r16);
         bits.RemoteFaultDetected.setName("RemoteFaultDetected");
-        bits.RemoteFaultDetected.setComponentOffset(0x1);
         bits.AutoNegotiationComplete.setBaseRegister(&r16);
         bits.AutoNegotiationComplete.setName("AutoNegotiationComplete");
-        bits.AutoNegotiationComplete.setComponentOffset(0x1);
         bits.MFPreambleSuppression.setBaseRegister(&r16);
         bits.MFPreambleSuppression.setName("MFPreambleSuppression");
-        bits.MFPreambleSuppression.setComponentOffset(0x1);
         bits.UnidirectionalCapable_GPHYonly_.setBaseRegister(&r16);
         bits.UnidirectionalCapable_GPHYonly_.setName("UnidirectionalCapable_GPHYonly_");
-        bits.UnidirectionalCapable_GPHYonly_.setComponentOffset(0x1);
         bits.ExtendedStatusSupported.setBaseRegister(&r16);
         bits.ExtendedStatusSupported.setName("ExtendedStatusSupported");
-        bits.ExtendedStatusSupported.setComponentOffset(0x1);
         bits._100BASE_T2HalfDuplexCapable.setBaseRegister(&r16);
         bits._100BASE_T2HalfDuplexCapable.setName("_100BASE_T2HalfDuplexCapable");
-        bits._100BASE_T2HalfDuplexCapable.setComponentOffset(0x1);
         bits._100BASE_T2FullDuplexCapable.setBaseRegister(&r16);
         bits._100BASE_T2FullDuplexCapable.setName("_100BASE_T2FullDuplexCapable");
-        bits._100BASE_T2FullDuplexCapable.setComponentOffset(0x1);
         bits._10BASE_THalfDuplexCapable.setBaseRegister(&r16);
         bits._10BASE_THalfDuplexCapable.setName("_10BASE_THalfDuplexCapable");
-        bits._10BASE_THalfDuplexCapable.setComponentOffset(0x1);
         bits._10BASE_TFullDuplexCapable.setBaseRegister(&r16);
         bits._10BASE_TFullDuplexCapable.setName("_10BASE_TFullDuplexCapable");
-        bits._10BASE_TFullDuplexCapable.setComponentOffset(0x1);
         bits._100BASE_XHalfDuplexCapable.setBaseRegister(&r16);
         bits._100BASE_XHalfDuplexCapable.setName("_100BASE_XHalfDuplexCapable");
-        bits._100BASE_XHalfDuplexCapable.setComponentOffset(0x1);
         bits._100BASE_XFullDuplexCapable.setBaseRegister(&r16);
         bits._100BASE_XFullDuplexCapable.setName("_100BASE_XFullDuplexCapable");
-        bits._100BASE_XFullDuplexCapable.setComponentOffset(0x1);
         bits._100BASE_T4Capable.setBaseRegister(&r16);
         bits._100BASE_T4Capable.setName("_100BASE_T4Capable");
-        bits._100BASE_T4Capable.setComponentOffset(0x1);
     }
     RegMIIStatus_t& operator=(const RegMIIStatus_t& other)
     {
@@ -490,10 +461,8 @@ typedef register_container RegMIIPhyIdHigh_t {
     {
         /** @brief constructor for @ref MII_t.PhyIdHigh. */
         r16.setName("PhyIdHigh");
-        r16.setComponentOffset(0x2);
         bits.OUIHigh.setBaseRegister(&r16);
         bits.OUIHigh.setName("OUIHigh");
-        bits.OUIHigh.setComponentOffset(0x2);
     }
     RegMIIPhyIdHigh_t& operator=(const RegMIIPhyIdHigh_t& other)
     {
@@ -552,16 +521,12 @@ typedef register_container RegMIIPhyIdLow_t {
     {
         /** @brief constructor for @ref MII_t.PhyIdLow. */
         r16.setName("PhyIdLow");
-        r16.setComponentOffset(0x3);
         bits.Revision.setBaseRegister(&r16);
         bits.Revision.setName("Revision");
-        bits.Revision.setComponentOffset(0x3);
         bits.Model.setBaseRegister(&r16);
         bits.Model.setName("Model");
-        bits.Model.setComponentOffset(0x3);
         bits.OUILow.setBaseRegister(&r16);
         bits.OUILow.setName("OUILow");
-        bits.OUILow.setComponentOffset(0x3);
     }
     RegMIIPhyIdLow_t& operator=(const RegMIIPhyIdLow_t& other)
     {
@@ -686,37 +651,26 @@ typedef register_container RegMIIAutonegotiationAdvertisement_t {
     {
         /** @brief constructor for @ref MII_t.AutonegotiationAdvertisement. */
         r16.setName("AutonegotiationAdvertisement");
-        r16.setComponentOffset(0x4);
         bits.ProtocolSelect.setBaseRegister(&r16);
         bits.ProtocolSelect.setName("ProtocolSelect");
-        bits.ProtocolSelect.setComponentOffset(0x4);
         bits._10BASE_THalfDuplexCapable.setBaseRegister(&r16);
         bits._10BASE_THalfDuplexCapable.setName("_10BASE_THalfDuplexCapable");
-        bits._10BASE_THalfDuplexCapable.setComponentOffset(0x4);
         bits._10BASE_TFullDuplexCapable.setBaseRegister(&r16);
         bits._10BASE_TFullDuplexCapable.setName("_10BASE_TFullDuplexCapable");
-        bits._10BASE_TFullDuplexCapable.setComponentOffset(0x4);
         bits._100BASE_TXHalfDuplexCapable.setBaseRegister(&r16);
         bits._100BASE_TXHalfDuplexCapable.setName("_100BASE_TXHalfDuplexCapable");
-        bits._100BASE_TXHalfDuplexCapable.setComponentOffset(0x4);
         bits._100BASE_TXFullDuplexCapable.setBaseRegister(&r16);
         bits._100BASE_TXFullDuplexCapable.setName("_100BASE_TXFullDuplexCapable");
-        bits._100BASE_TXFullDuplexCapable.setComponentOffset(0x4);
         bits._100BASE_T4Capable.setBaseRegister(&r16);
         bits._100BASE_T4Capable.setName("_100BASE_T4Capable");
-        bits._100BASE_T4Capable.setComponentOffset(0x4);
         bits.PauseCapable.setBaseRegister(&r16);
         bits.PauseCapable.setName("PauseCapable");
-        bits.PauseCapable.setComponentOffset(0x4);
         bits.AsymmetricPauseCapable.setBaseRegister(&r16);
         bits.AsymmetricPauseCapable.setName("AsymmetricPauseCapable");
-        bits.AsymmetricPauseCapable.setComponentOffset(0x4);
         bits.RemoteFault.setBaseRegister(&r16);
         bits.RemoteFault.setName("RemoteFault");
-        bits.RemoteFault.setComponentOffset(0x4);
         bits.NextPage.setBaseRegister(&r16);
         bits.NextPage.setName("NextPage");
-        bits.NextPage.setComponentOffset(0x4);
     }
     RegMIIAutonegotiationAdvertisement_t& operator=(const RegMIIAutonegotiationAdvertisement_t& other)
     {
@@ -843,40 +797,28 @@ typedef register_container RegMIIAutonegotiationLinkPartnerAbilityBasePage_t {
     {
         /** @brief constructor for @ref MII_t.AutonegotiationLinkPartnerAbilityBasePage. */
         r16.setName("AutonegotiationLinkPartnerAbilityBasePage");
-        r16.setComponentOffset(0x5);
         bits.ProtocolSelector.setBaseRegister(&r16);
         bits.ProtocolSelector.setName("ProtocolSelector");
-        bits.ProtocolSelector.setComponentOffset(0x5);
         bits._10BASE_THalfDuplexCapable.setBaseRegister(&r16);
         bits._10BASE_THalfDuplexCapable.setName("_10BASE_THalfDuplexCapable");
-        bits._10BASE_THalfDuplexCapable.setComponentOffset(0x5);
         bits._10BASE_TFullDuplexCapable.setBaseRegister(&r16);
         bits._10BASE_TFullDuplexCapable.setName("_10BASE_TFullDuplexCapable");
-        bits._10BASE_TFullDuplexCapable.setComponentOffset(0x5);
         bits._100BASE_TXHalfDuplexCapable.setBaseRegister(&r16);
         bits._100BASE_TXHalfDuplexCapable.setName("_100BASE_TXHalfDuplexCapable");
-        bits._100BASE_TXHalfDuplexCapable.setComponentOffset(0x5);
         bits._100BASE_TXFullDuplexCapable.setBaseRegister(&r16);
         bits._100BASE_TXFullDuplexCapable.setName("_100BASE_TXFullDuplexCapable");
-        bits._100BASE_TXFullDuplexCapable.setComponentOffset(0x5);
         bits._100BASE_T4Capable.setBaseRegister(&r16);
         bits._100BASE_T4Capable.setName("_100BASE_T4Capable");
-        bits._100BASE_T4Capable.setComponentOffset(0x5);
         bits.PauseCapable.setBaseRegister(&r16);
         bits.PauseCapable.setName("PauseCapable");
-        bits.PauseCapable.setComponentOffset(0x5);
         bits.AsymmetricPauseCapable.setBaseRegister(&r16);
         bits.AsymmetricPauseCapable.setName("AsymmetricPauseCapable");
-        bits.AsymmetricPauseCapable.setComponentOffset(0x5);
         bits.RemoteFault.setBaseRegister(&r16);
         bits.RemoteFault.setName("RemoteFault");
-        bits.RemoteFault.setComponentOffset(0x5);
         bits.Acknowledge.setBaseRegister(&r16);
         bits.Acknowledge.setName("Acknowledge");
-        bits.Acknowledge.setComponentOffset(0x5);
         bits.NextPage.setBaseRegister(&r16);
         bits.NextPage.setName("NextPage");
-        bits.NextPage.setComponentOffset(0x5);
     }
     RegMIIAutonegotiationLinkPartnerAbilityBasePage_t& operator=(const RegMIIAutonegotiationLinkPartnerAbilityBasePage_t& other)
     {
@@ -978,28 +920,20 @@ typedef register_container RegMIIAutonegotiationExpansion_t {
     {
         /** @brief constructor for @ref MII_t.AutonegotiationExpansion. */
         r16.setName("AutonegotiationExpansion");
-        r16.setComponentOffset(0x6);
         bits.LinkPartnerAutonegotiationCapable.setBaseRegister(&r16);
         bits.LinkPartnerAutonegotiationCapable.setName("LinkPartnerAutonegotiationCapable");
-        bits.LinkPartnerAutonegotiationCapable.setComponentOffset(0x6);
         bits.PageReceived.setBaseRegister(&r16);
         bits.PageReceived.setName("PageReceived");
-        bits.PageReceived.setComponentOffset(0x6);
         bits.NextPageCapable.setBaseRegister(&r16);
         bits.NextPageCapable.setName("NextPageCapable");
-        bits.NextPageCapable.setComponentOffset(0x6);
         bits.LinkPartnerNextPageCapable.setBaseRegister(&r16);
         bits.LinkPartnerNextPageCapable.setName("LinkPartnerNextPageCapable");
-        bits.LinkPartnerNextPageCapable.setComponentOffset(0x6);
         bits.ParallelDetectionFault.setBaseRegister(&r16);
         bits.ParallelDetectionFault.setName("ParallelDetectionFault");
-        bits.ParallelDetectionFault.setComponentOffset(0x6);
         bits.NextPageReceiveLocation.setBaseRegister(&r16);
         bits.NextPageReceiveLocation.setName("NextPageReceiveLocation");
-        bits.NextPageReceiveLocation.setComponentOffset(0x6);
         bits.NextPageReceiveLocationCapable.setBaseRegister(&r16);
         bits.NextPageReceiveLocationCapable.setName("NextPageReceiveLocationCapable");
-        bits.NextPageReceiveLocationCapable.setComponentOffset(0x6);
     }
     RegMIIAutonegotiationExpansion_t& operator=(const RegMIIAutonegotiationExpansion_t& other)
     {
@@ -1078,22 +1012,16 @@ typedef register_container RegMIIAutonegotiationNextPageTransmit_t {
     {
         /** @brief constructor for @ref MII_t.AutonegotiationNextPageTransmit. */
         r16.setName("AutonegotiationNextPageTransmit");
-        r16.setComponentOffset(0x7);
         bits.CodeField.setBaseRegister(&r16);
         bits.CodeField.setName("CodeField");
-        bits.CodeField.setComponentOffset(0x7);
         bits.Toggle.setBaseRegister(&r16);
         bits.Toggle.setName("Toggle");
-        bits.Toggle.setComponentOffset(0x7);
         bits.Acknowledge2.setBaseRegister(&r16);
         bits.Acknowledge2.setName("Acknowledge2");
-        bits.Acknowledge2.setComponentOffset(0x7);
         bits.MessagePage.setBaseRegister(&r16);
         bits.MessagePage.setName("MessagePage");
-        bits.MessagePage.setComponentOffset(0x7);
         bits.NextPage.setBaseRegister(&r16);
         bits.NextPage.setName("NextPage");
-        bits.NextPage.setComponentOffset(0x7);
     }
     RegMIIAutonegotiationNextPageTransmit_t& operator=(const RegMIIAutonegotiationNextPageTransmit_t& other)
     {
@@ -1176,25 +1104,18 @@ typedef register_container RegMIIAutonegotiationLinkPartnerAbilityNextPage_t {
     {
         /** @brief constructor for @ref MII_t.AutonegotiationLinkPartnerAbilityNextPage. */
         r16.setName("AutonegotiationLinkPartnerAbilityNextPage");
-        r16.setComponentOffset(0x8);
         bits.CodeField.setBaseRegister(&r16);
         bits.CodeField.setName("CodeField");
-        bits.CodeField.setComponentOffset(0x8);
         bits.Toggle2.setBaseRegister(&r16);
         bits.Toggle2.setName("Toggle2");
-        bits.Toggle2.setComponentOffset(0x8);
         bits.Acknowledge2.setBaseRegister(&r16);
         bits.Acknowledge2.setName("Acknowledge2");
-        bits.Acknowledge2.setComponentOffset(0x8);
         bits.MessagePage.setBaseRegister(&r16);
         bits.MessagePage.setName("MessagePage");
-        bits.MessagePage.setComponentOffset(0x8);
         bits.Acknowledge3.setBaseRegister(&r16);
         bits.Acknowledge3.setName("Acknowledge3");
-        bits.Acknowledge3.setComponentOffset(0x8);
         bits.NextPage.setBaseRegister(&r16);
         bits.NextPage.setName("NextPage");
-        bits.NextPage.setComponentOffset(0x8);
     }
     RegMIIAutonegotiationLinkPartnerAbilityNextPage_t& operator=(const RegMIIAutonegotiationLinkPartnerAbilityNextPage_t& other)
     {
@@ -1281,25 +1202,18 @@ typedef register_container RegMII1000baseTControl_t {
     {
         /** @brief constructor for @ref MII_t.1000baseTControl. */
         r16.setName("1000baseTControl");
-        r16.setComponentOffset(0x9);
         bits.Advertise1000BASE_THalfDuplex.setBaseRegister(&r16);
         bits.Advertise1000BASE_THalfDuplex.setName("Advertise1000BASE_THalfDuplex");
-        bits.Advertise1000BASE_THalfDuplex.setComponentOffset(0x9);
         bits.Advertise1000BASE_TFullDuplex.setBaseRegister(&r16);
         bits.Advertise1000BASE_TFullDuplex.setName("Advertise1000BASE_TFullDuplex");
-        bits.Advertise1000BASE_TFullDuplex.setComponentOffset(0x9);
         bits.RepeaterDTE.setBaseRegister(&r16);
         bits.RepeaterDTE.setName("RepeaterDTE");
-        bits.RepeaterDTE.setComponentOffset(0x9);
         bits.MasterSlaveConfigValue.setBaseRegister(&r16);
         bits.MasterSlaveConfigValue.setName("MasterSlaveConfigValue");
-        bits.MasterSlaveConfigValue.setComponentOffset(0x9);
         bits.MasterSlaveConfigEnable.setBaseRegister(&r16);
         bits.MasterSlaveConfigEnable.setName("MasterSlaveConfigEnable");
-        bits.MasterSlaveConfigEnable.setComponentOffset(0x9);
         bits.TestMode.setBaseRegister(&r16);
         bits.TestMode.setName("TestMode");
-        bits.TestMode.setComponentOffset(0x9);
     }
     RegMII1000baseTControl_t& operator=(const RegMII1000baseTControl_t& other)
     {
@@ -1394,28 +1308,20 @@ typedef register_container RegMII1000baseTStatus_t {
     {
         /** @brief constructor for @ref MII_t.1000baseTStatus. */
         r16.setName("1000baseTStatus");
-        r16.setComponentOffset(0xa);
         bits.IdleErrorCount.setBaseRegister(&r16);
         bits.IdleErrorCount.setName("IdleErrorCount");
-        bits.IdleErrorCount.setComponentOffset(0xa);
         bits.LinkPartner1000BASE_THalfDuplexCapable.setBaseRegister(&r16);
         bits.LinkPartner1000BASE_THalfDuplexCapable.setName("LinkPartner1000BASE_THalfDuplexCapable");
-        bits.LinkPartner1000BASE_THalfDuplexCapable.setComponentOffset(0xa);
         bits.LinkPartner1000BASE_TFullDuplexCapable.setBaseRegister(&r16);
         bits.LinkPartner1000BASE_TFullDuplexCapable.setName("LinkPartner1000BASE_TFullDuplexCapable");
-        bits.LinkPartner1000BASE_TFullDuplexCapable.setComponentOffset(0xa);
         bits.RemoteReceiverStatus.setBaseRegister(&r16);
         bits.RemoteReceiverStatus.setName("RemoteReceiverStatus");
-        bits.RemoteReceiverStatus.setComponentOffset(0xa);
         bits.LocalReceiverStatus.setBaseRegister(&r16);
         bits.LocalReceiverStatus.setName("LocalReceiverStatus");
-        bits.LocalReceiverStatus.setComponentOffset(0xa);
         bits.MasterSlaveConfigResolution.setBaseRegister(&r16);
         bits.MasterSlaveConfigResolution.setName("MasterSlaveConfigResolution");
-        bits.MasterSlaveConfigResolution.setComponentOffset(0xa);
         bits.MasterSlaveConfigFault.setBaseRegister(&r16);
         bits.MasterSlaveConfigFault.setName("MasterSlaveConfigFault");
-        bits.MasterSlaveConfigFault.setComponentOffset(0xa);
     }
     RegMII1000baseTStatus_t& operator=(const RegMII1000baseTStatus_t& other)
     {
@@ -1482,16 +1388,12 @@ typedef register_container RegMIIBroadreachLreAccess_t {
     {
         /** @brief constructor for @ref MII_t.BroadreachLreAccess. */
         r16.setName("BroadreachLreAccess");
-        r16.setComponentOffset(0xe);
         bits.LRERegisterAccessStatus.setBaseRegister(&r16);
         bits.LRERegisterAccessStatus.setName("LRERegisterAccessStatus");
-        bits.LRERegisterAccessStatus.setComponentOffset(0xe);
         bits.LRERegisterOverrideValue.setBaseRegister(&r16);
         bits.LRERegisterOverrideValue.setName("LRERegisterOverrideValue");
-        bits.LRERegisterOverrideValue.setComponentOffset(0xe);
         bits.EnableLRERegisterAccessOverride.setBaseRegister(&r16);
         bits.EnableLRERegisterAccessOverride.setName("EnableLRERegisterAccessOverride");
-        bits.EnableLRERegisterAccessOverride.setComponentOffset(0xe);
     }
     RegMIIBroadreachLreAccess_t& operator=(const RegMIIBroadreachLreAccess_t& other)
     {
@@ -1558,16 +1460,12 @@ typedef register_container RegMIIIeeeExtendedStatus_t {
     {
         /** @brief constructor for @ref MII_t.IeeeExtendedStatus. */
         r16.setName("IeeeExtendedStatus");
-        r16.setComponentOffset(0xf);
         bits._1000BASE_THalfDuplexCapable.setBaseRegister(&r16);
         bits._1000BASE_THalfDuplexCapable.setName("_1000BASE_THalfDuplexCapable");
-        bits._1000BASE_THalfDuplexCapable.setComponentOffset(0xf);
         bits._1000BASE_TFullDuplexCapable.setBaseRegister(&r16);
         bits._1000BASE_TFullDuplexCapable.setName("_1000BASE_TFullDuplexCapable");
-        bits._1000BASE_TFullDuplexCapable.setComponentOffset(0xf);
         bits._1000BASE_XHalfDuplexCapable.setBaseRegister(&r16);
         bits._1000BASE_XHalfDuplexCapable.setName("_1000BASE_XHalfDuplexCapable");
-        bits._1000BASE_XHalfDuplexCapable.setComponentOffset(0xf);
     }
     RegMIIIeeeExtendedStatus_t& operator=(const RegMIIIeeeExtendedStatus_t& other)
     {
@@ -1730,55 +1628,38 @@ typedef register_container RegMIIPhyExtendedControl_t {
     {
         /** @brief constructor for @ref MII_t.PhyExtendedControl. */
         r16.setName("PhyExtendedControl");
-        r16.setComponentOffset(0x10);
         bits.GMII_DIV_RGMIIFIFOElasticityLSB.setBaseRegister(&r16);
         bits.GMII_DIV_RGMIIFIFOElasticityLSB.setName("GMII_DIV_RGMIIFIFOElasticityLSB");
-        bits.GMII_DIV_RGMIIFIFOElasticityLSB.setComponentOffset(0x10);
         bits.UnidirectionalEnable.setBaseRegister(&r16);
         bits.UnidirectionalEnable.setName("UnidirectionalEnable");
-        bits.UnidirectionalEnable.setComponentOffset(0x10);
         bits.BlockTXENMode.setBaseRegister(&r16);
         bits.BlockTXENMode.setName("BlockTXENMode");
-        bits.BlockTXENMode.setComponentOffset(0x10);
         bits.ForceLEDsOff.setBaseRegister(&r16);
         bits.ForceLEDsOff.setName("ForceLEDsOff");
-        bits.ForceLEDsOff.setComponentOffset(0x10);
         bits.ForceLEDsOn.setBaseRegister(&r16);
         bits.ForceLEDsOn.setName("ForceLEDsOn");
-        bits.ForceLEDsOn.setComponentOffset(0x10);
         bits.EnableLEDTrafficMode.setBaseRegister(&r16);
         bits.EnableLEDTrafficMode.setName("EnableLEDTrafficMode");
-        bits.EnableLEDTrafficMode.setComponentOffset(0x10);
         bits.ResetScrambler.setBaseRegister(&r16);
         bits.ResetScrambler.setName("ResetScrambler");
-        bits.ResetScrambler.setComponentOffset(0x10);
         bits.BypassAlignment.setBaseRegister(&r16);
         bits.BypassAlignment.setName("BypassAlignment");
-        bits.BypassAlignment.setComponentOffset(0x10);
         bits.BypassNRZI_DIV_MLT3.setBaseRegister(&r16);
         bits.BypassNRZI_DIV_MLT3.setName("BypassNRZI_DIV_MLT3");
-        bits.BypassNRZI_DIV_MLT3.setComponentOffset(0x10);
         bits.BypassScrambler.setBaseRegister(&r16);
         bits.BypassScrambler.setName("BypassScrambler");
-        bits.BypassScrambler.setComponentOffset(0x10);
         bits.BypassEncoder.setBaseRegister(&r16);
         bits.BypassEncoder.setName("BypassEncoder");
-        bits.BypassEncoder.setComponentOffset(0x10);
         bits.ForceInterrupt.setBaseRegister(&r16);
         bits.ForceInterrupt.setName("ForceInterrupt");
-        bits.ForceInterrupt.setComponentOffset(0x10);
         bits.InterruptDisable.setBaseRegister(&r16);
         bits.InterruptDisable.setName("InterruptDisable");
-        bits.InterruptDisable.setComponentOffset(0x10);
         bits.TransmitDisable.setBaseRegister(&r16);
         bits.TransmitDisable.setName("TransmitDisable");
-        bits.TransmitDisable.setComponentOffset(0x10);
         bits.DisableAutomaticMDICrossover.setBaseRegister(&r16);
         bits.DisableAutomaticMDICrossover.setName("DisableAutomaticMDICrossover");
-        bits.DisableAutomaticMDICrossover.setComponentOffset(0x10);
         bits.MAC_DIV_PHYInterfaceMode.setBaseRegister(&r16);
         bits.MAC_DIV_PHYInterfaceMode.setName("MAC_DIV_PHYInterfaceMode");
-        bits.MAC_DIV_PHYInterfaceMode.setComponentOffset(0x10);
     }
     RegMIIPhyExtendedControl_t& operator=(const RegMIIPhyExtendedControl_t& other)
     {
@@ -1941,55 +1822,38 @@ typedef register_container RegMIIPhyExtendedStatus_t {
     {
         /** @brief constructor for @ref MII_t.PhyExtendedStatus. */
         r16.setName("PhyExtendedStatus");
-        r16.setComponentOffset(0x11);
         bits.MLT3CodeErrorDetected.setBaseRegister(&r16);
         bits.MLT3CodeErrorDetected.setName("MLT3CodeErrorDetected");
-        bits.MLT3CodeErrorDetected.setComponentOffset(0x11);
         bits.LockErrorDetected.setBaseRegister(&r16);
         bits.LockErrorDetected.setName("LockErrorDetected");
-        bits.LockErrorDetected.setComponentOffset(0x11);
         bits.TransmitErrorDetected.setBaseRegister(&r16);
         bits.TransmitErrorDetected.setName("TransmitErrorDetected");
-        bits.TransmitErrorDetected.setComponentOffset(0x11);
         bits.ReceiveErrorDetected.setBaseRegister(&r16);
         bits.ReceiveErrorDetected.setName("ReceiveErrorDetected");
-        bits.ReceiveErrorDetected.setComponentOffset(0x11);
         bits.BadESDDetected.setBaseRegister(&r16);
         bits.BadESDDetected.setName("BadESDDetected");
-        bits.BadESDDetected.setComponentOffset(0x11);
         bits.BadSSDDetected.setBaseRegister(&r16);
         bits.BadSSDDetected.setName("BadSSDDetected");
-        bits.BadSSDDetected.setComponentOffset(0x11);
         bits.CarrierExtensionErrorDetected.setBaseRegister(&r16);
         bits.CarrierExtensionErrorDetected.setName("CarrierExtensionErrorDetected");
-        bits.CarrierExtensionErrorDetected.setComponentOffset(0x11);
         bits.CRCErrorDetected.setBaseRegister(&r16);
         bits.CRCErrorDetected.setName("CRCErrorDetected");
-        bits.CRCErrorDetected.setComponentOffset(0x11);
         bits.LinkStatus.setBaseRegister(&r16);
         bits.LinkStatus.setName("LinkStatus");
-        bits.LinkStatus.setComponentOffset(0x11);
         bits.Locked.setBaseRegister(&r16);
         bits.Locked.setName("Locked");
-        bits.Locked.setComponentOffset(0x11);
         bits.LocalReceiverStatus.setBaseRegister(&r16);
         bits.LocalReceiverStatus.setName("LocalReceiverStatus");
-        bits.LocalReceiverStatus.setComponentOffset(0x11);
         bits.RemoteReceiverStatus.setBaseRegister(&r16);
         bits.RemoteReceiverStatus.setName("RemoteReceiverStatus");
-        bits.RemoteReceiverStatus.setComponentOffset(0x11);
         bits.InterruptStatus.setBaseRegister(&r16);
         bits.InterruptStatus.setName("InterruptStatus");
-        bits.InterruptStatus.setComponentOffset(0x11);
         bits.MDICrossoverState.setBaseRegister(&r16);
         bits.MDICrossoverState.setName("MDICrossoverState");
-        bits.MDICrossoverState.setComponentOffset(0x11);
         bits.WirespeedDowngrade.setBaseRegister(&r16);
         bits.WirespeedDowngrade.setName("WirespeedDowngrade");
-        bits.WirespeedDowngrade.setComponentOffset(0x11);
         bits.AutonegotiationBasePageSelectorFieldMismatch.setBaseRegister(&r16);
         bits.AutonegotiationBasePageSelectorFieldMismatch.setName("AutonegotiationBasePageSelectorFieldMismatch");
-        bits.AutonegotiationBasePageSelectorFieldMismatch.setComponentOffset(0x11);
     }
     RegMIIPhyExtendedStatus_t& operator=(const RegMIIPhyExtendedStatus_t& other)
     {
@@ -2032,10 +1896,8 @@ typedef register_container RegMIIReceiveErrorCounter_t {
     {
         /** @brief constructor for @ref MII_t.ReceiveErrorCounter. */
         r16.setName("ReceiveErrorCounter");
-        r16.setComponentOffset(0x12);
         bits.ReceiveErrorCounter.setBaseRegister(&r16);
         bits.ReceiveErrorCounter.setName("ReceiveErrorCounter");
-        bits.ReceiveErrorCounter.setComponentOffset(0x12);
     }
     RegMIIReceiveErrorCounter_t& operator=(const RegMIIReceiveErrorCounter_t& other)
     {
@@ -2086,13 +1948,10 @@ typedef register_container RegMIIFalseCarrierSenseCounter_t {
     {
         /** @brief constructor for @ref MII_t.FalseCarrierSenseCounter. */
         r16.setName("FalseCarrierSenseCounter");
-        r16.setComponentOffset(0x13);
         bits.FalseCarrierSenseCounter.setBaseRegister(&r16);
         bits.FalseCarrierSenseCounter.setName("FalseCarrierSenseCounter");
-        bits.FalseCarrierSenseCounter.setComponentOffset(0x13);
         bits.SERDESBERCounter.setBaseRegister(&r16);
         bits.SERDESBERCounter.setName("SERDESBERCounter");
-        bits.SERDESBERCounter.setComponentOffset(0x13);
     }
     RegMIIFalseCarrierSenseCounter_t& operator=(const RegMIIFalseCarrierSenseCounter_t& other)
     {
@@ -2143,13 +2002,10 @@ typedef register_container RegMIILocalRemoteReceiverNotOkCounter_t {
     {
         /** @brief constructor for @ref MII_t.LocalRemoteReceiverNotOkCounter. */
         r16.setName("LocalRemoteReceiverNotOkCounter");
-        r16.setComponentOffset(0x14);
         bits.RemoteReceiverNotOKCounter.setBaseRegister(&r16);
         bits.RemoteReceiverNotOKCounter.setName("RemoteReceiverNotOKCounter");
-        bits.RemoteReceiverNotOKCounter.setComponentOffset(0x14);
         bits.LocalReceiverNotOKCounter.setBaseRegister(&r16);
         bits.LocalReceiverNotOKCounter.setName("LocalReceiverNotOKCounter");
-        bits.LocalReceiverNotOKCounter.setComponentOffset(0x14);
     }
     RegMIILocalRemoteReceiverNotOkCounter_t& operator=(const RegMIILocalRemoteReceiverNotOkCounter_t& other)
     {
@@ -2268,37 +2124,26 @@ typedef register_container RegMIIAuxiliaryControl_t {
     {
         /** @brief constructor for @ref MII_t.AuxiliaryControl. */
         r16.setName("AuxiliaryControl");
-        r16.setComponentOffset(0x18);
         bits.ShadowRegisterSelector.setBaseRegister(&r16);
         bits.ShadowRegisterSelector.setName("ShadowRegisterSelector");
-        bits.ShadowRegisterSelector.setComponentOffset(0x18);
         bits.DiagnosticMode.setBaseRegister(&r16);
         bits.DiagnosticMode.setName("DiagnosticMode");
-        bits.DiagnosticMode.setComponentOffset(0x18);
         bits.DisableInversePRF.setBaseRegister(&r16);
         bits.DisableInversePRF.setName("DisableInversePRF");
-        bits.DisableInversePRF.setComponentOffset(0x18);
         bits.DisablePartialResponseFilter.setBaseRegister(&r16);
         bits.DisablePartialResponseFilter.setName("DisablePartialResponseFilter");
-        bits.DisablePartialResponseFilter.setComponentOffset(0x18);
         bits.ReceiveSlicing.setBaseRegister(&r16);
         bits.ReceiveSlicing.setName("ReceiveSlicing");
-        bits.ReceiveSlicing.setComponentOffset(0x18);
         bits.Transmit6dBCoding.setBaseRegister(&r16);
         bits.Transmit6dBCoding.setName("Transmit6dBCoding");
-        bits.Transmit6dBCoding.setComponentOffset(0x18);
         bits.EnableSM_DSPClock.setBaseRegister(&r16);
         bits.EnableSM_DSPClock.setName("EnableSM_DSPClock");
-        bits.EnableSM_DSPClock.setComponentOffset(0x18);
         bits.EdgerateControl.setBaseRegister(&r16);
         bits.EdgerateControl.setName("EdgerateControl");
-        bits.EdgerateControl.setComponentOffset(0x18);
         bits.ExtendedPacketLength.setBaseRegister(&r16);
         bits.ExtendedPacketLength.setName("ExtendedPacketLength");
-        bits.ExtendedPacketLength.setComponentOffset(0x18);
         bits.ExternalLoopback.setBaseRegister(&r16);
         bits.ExternalLoopback.setName("ExternalLoopback");
-        bits.ExternalLoopback.setComponentOffset(0x18);
     }
     RegMIIAuxiliaryControl_t& operator=(const RegMIIAuxiliaryControl_t& other)
     {
@@ -2445,49 +2290,34 @@ typedef register_container RegMIIAuxiliaryStatusSummary_t {
     {
         /** @brief constructor for @ref MII_t.AuxiliaryStatusSummary. */
         r16.setName("AuxiliaryStatusSummary");
-        r16.setComponentOffset(0x19);
         bits.PauseResolution_TransmitDirection.setBaseRegister(&r16);
         bits.PauseResolution_TransmitDirection.setName("PauseResolution_TransmitDirection");
-        bits.PauseResolution_TransmitDirection.setComponentOffset(0x19);
         bits.PauseResolution_ReceiveDirection.setBaseRegister(&r16);
         bits.PauseResolution_ReceiveDirection.setName("PauseResolution_ReceiveDirection");
-        bits.PauseResolution_ReceiveDirection.setComponentOffset(0x19);
         bits.LinkStatus.setBaseRegister(&r16);
         bits.LinkStatus.setName("LinkStatus");
-        bits.LinkStatus.setComponentOffset(0x19);
         bits.LinkPartnerNextPageCapable.setBaseRegister(&r16);
         bits.LinkPartnerNextPageCapable.setName("LinkPartnerNextPageCapable");
-        bits.LinkPartnerNextPageCapable.setComponentOffset(0x19);
         bits.LinkPartnerAutonegotiationCapable.setBaseRegister(&r16);
         bits.LinkPartnerAutonegotiationCapable.setName("LinkPartnerAutonegotiationCapable");
-        bits.LinkPartnerAutonegotiationCapable.setComponentOffset(0x19);
         bits.PageReceived.setBaseRegister(&r16);
         bits.PageReceived.setName("PageReceived");
-        bits.PageReceived.setComponentOffset(0x19);
         bits.RemoteFault.setBaseRegister(&r16);
         bits.RemoteFault.setName("RemoteFault");
-        bits.RemoteFault.setComponentOffset(0x19);
         bits.ParallelDetectionFault.setBaseRegister(&r16);
         bits.ParallelDetectionFault.setName("ParallelDetectionFault");
-        bits.ParallelDetectionFault.setComponentOffset(0x19);
         bits.AutonegotiationHCD.setBaseRegister(&r16);
         bits.AutonegotiationHCD.setName("AutonegotiationHCD");
-        bits.AutonegotiationHCD.setComponentOffset(0x19);
         bits.AutonegotiationNextPageWait.setBaseRegister(&r16);
         bits.AutonegotiationNextPageWait.setName("AutonegotiationNextPageWait");
-        bits.AutonegotiationNextPageWait.setComponentOffset(0x19);
         bits.AutonegotiationAbilityDetect.setBaseRegister(&r16);
         bits.AutonegotiationAbilityDetect.setName("AutonegotiationAbilityDetect");
-        bits.AutonegotiationAbilityDetect.setComponentOffset(0x19);
         bits.AutonegotiationACKDetect.setBaseRegister(&r16);
         bits.AutonegotiationACKDetect.setName("AutonegotiationACKDetect");
-        bits.AutonegotiationACKDetect.setComponentOffset(0x19);
         bits.AutonegotiationCompleteACK.setBaseRegister(&r16);
         bits.AutonegotiationCompleteACK.setName("AutonegotiationCompleteACK");
-        bits.AutonegotiationCompleteACK.setComponentOffset(0x19);
         bits.AutonegotiationComplete.setBaseRegister(&r16);
         bits.AutonegotiationComplete.setName("AutonegotiationComplete");
-        bits.AutonegotiationComplete.setComponentOffset(0x19);
     }
     RegMIIAuxiliaryStatusSummary_t& operator=(const RegMIIAuxiliaryStatusSummary_t& other)
     {
@@ -2646,52 +2476,36 @@ typedef register_container RegMIIInterruptStatus_t {
     {
         /** @brief constructor for @ref MII_t.InterruptStatus. */
         r16.setName("InterruptStatus");
-        r16.setComponentOffset(0x1a);
         bits.CRCError.setBaseRegister(&r16);
         bits.CRCError.setName("CRCError");
-        bits.CRCError.setComponentOffset(0x1a);
         bits.LinkStatusChange.setBaseRegister(&r16);
         bits.LinkStatusChange.setName("LinkStatusChange");
-        bits.LinkStatusChange.setComponentOffset(0x1a);
         bits.LinkSpeedChange.setBaseRegister(&r16);
         bits.LinkSpeedChange.setName("LinkSpeedChange");
-        bits.LinkSpeedChange.setComponentOffset(0x1a);
         bits.DuplexModeChange.setBaseRegister(&r16);
         bits.DuplexModeChange.setName("DuplexModeChange");
-        bits.DuplexModeChange.setComponentOffset(0x1a);
         bits.LocalReceiverStatusChange.setBaseRegister(&r16);
         bits.LocalReceiverStatusChange.setName("LocalReceiverStatusChange");
-        bits.LocalReceiverStatusChange.setComponentOffset(0x1a);
         bits.RemoteReceiverStatusChange.setBaseRegister(&r16);
         bits.RemoteReceiverStatusChange.setName("RemoteReceiverStatusChange");
-        bits.RemoteReceiverStatusChange.setComponentOffset(0x1a);
         bits.ScramblerSyncError.setBaseRegister(&r16);
         bits.ScramblerSyncError.setName("ScramblerSyncError");
-        bits.ScramblerSyncError.setComponentOffset(0x1a);
         bits.NegotiatedUnsupportedHCD.setBaseRegister(&r16);
         bits.NegotiatedUnsupportedHCD.setName("NegotiatedUnsupportedHCD");
-        bits.NegotiatedUnsupportedHCD.setComponentOffset(0x1a);
         bits.NoHCD.setBaseRegister(&r16);
         bits.NoHCD.setName("NoHCD");
-        bits.NoHCD.setComponentOffset(0x1a);
         bits.HCDNoLink.setBaseRegister(&r16);
         bits.HCDNoLink.setName("HCDNoLink");
-        bits.HCDNoLink.setComponentOffset(0x1a);
         bits.AutonegotiationPageRX.setBaseRegister(&r16);
         bits.AutonegotiationPageRX.setName("AutonegotiationPageRX");
-        bits.AutonegotiationPageRX.setComponentOffset(0x1a);
         bits.ExceededLowCounterThreshold.setBaseRegister(&r16);
         bits.ExceededLowCounterThreshold.setName("ExceededLowCounterThreshold");
-        bits.ExceededLowCounterThreshold.setComponentOffset(0x1a);
         bits.MDIXStatusChange.setBaseRegister(&r16);
         bits.MDIXStatusChange.setName("MDIXStatusChange");
-        bits.MDIXStatusChange.setComponentOffset(0x1a);
         bits.IllegalPairSwap.setBaseRegister(&r16);
         bits.IllegalPairSwap.setName("IllegalPairSwap");
-        bits.IllegalPairSwap.setComponentOffset(0x1a);
         bits.IPStatusChange.setBaseRegister(&r16);
         bits.IPStatusChange.setName("IPStatusChange");
-        bits.IPStatusChange.setComponentOffset(0x1a);
     }
     RegMIIInterruptStatus_t& operator=(const RegMIIInterruptStatus_t& other)
     {
@@ -2734,10 +2548,8 @@ typedef register_container RegMIIInterruptMask_t {
     {
         /** @brief constructor for @ref MII_t.InterruptMask. */
         r16.setName("InterruptMask");
-        r16.setComponentOffset(0x1b);
         bits.InterruptMaskVector.setBaseRegister(&r16);
         bits.InterruptMaskVector.setName("InterruptMaskVector");
-        bits.InterruptMaskVector.setComponentOffset(0x1b);
     }
     RegMIIInterruptMask_t& operator=(const RegMIIInterruptMask_t& other)
     {
@@ -2800,16 +2612,12 @@ typedef register_container RegMIICabletronLed_t {
     {
         /** @brief constructor for @ref MII_t.CabletronLed. */
         r16.setName("CabletronLed");
-        r16.setComponentOffset(0x1c);
         bits.CabletronLED.setBaseRegister(&r16);
         bits.CabletronLED.setName("CabletronLED");
-        bits.CabletronLED.setComponentOffset(0x1c);
         bits.ShadowRegisterSelector.setBaseRegister(&r16);
         bits.ShadowRegisterSelector.setName("ShadowRegisterSelector");
-        bits.ShadowRegisterSelector.setComponentOffset(0x1c);
         bits.WriteEnable.setBaseRegister(&r16);
         bits.WriteEnable.setName("WriteEnable");
-        bits.WriteEnable.setComponentOffset(0x1c);
     }
     RegMIICabletronLed_t& operator=(const RegMIICabletronLed_t& other)
     {
@@ -2948,46 +2756,32 @@ typedef register_container RegMIITest1_t {
     {
         /** @brief constructor for @ref MII_t.Test1. */
         r16.setName("Test1");
-        r16.setComponentOffset(0x1e);
         bits.MainDACTrim.setBaseRegister(&r16);
         bits.MainDACTrim.setName("MainDACTrim");
-        bits.MainDACTrim.setComponentOffset(0x1e);
         bits.MainDACEnableSoftwareTrimSetting.setBaseRegister(&r16);
         bits.MainDACEnableSoftwareTrimSetting.setName("MainDACEnableSoftwareTrimSetting");
-        bits.MainDACEnableSoftwareTrimSetting.setComponentOffset(0x1e);
         bits.DisablePolarityEncode.setBaseRegister(&r16);
         bits.DisablePolarityEncode.setName("DisablePolarityEncode");
-        bits.DisablePolarityEncode.setComponentOffset(0x1e);
         bits.ReceiveWatchdogTimerDisable.setBaseRegister(&r16);
         bits.ReceiveWatchdogTimerDisable.setName("ReceiveWatchdogTimerDisable");
-        bits.ReceiveWatchdogTimerDisable.setComponentOffset(0x1e);
         bits.ManualSwapMDIState.setBaseRegister(&r16);
         bits.ManualSwapMDIState.setName("ManualSwapMDIState");
-        bits.ManualSwapMDIState.setComponentOffset(0x1e);
         bits.FastTimers.setBaseRegister(&r16);
         bits.FastTimers.setName("FastTimers");
-        bits.FastTimers.setComponentOffset(0x1e);
         bits.ExternalLink.setBaseRegister(&r16);
         bits.ExternalLink.setName("ExternalLink");
-        bits.ExternalLink.setComponentOffset(0x1e);
         bits.ScramblerTest.setBaseRegister(&r16);
         bits.ScramblerTest.setName("ScramblerTest");
-        bits.ScramblerTest.setComponentOffset(0x1e);
         bits.ForceLock.setBaseRegister(&r16);
         bits.ForceLock.setName("ForceLock");
-        bits.ForceLock.setComponentOffset(0x1e);
         bits.ForceLink.setBaseRegister(&r16);
         bits.ForceLink.setName("ForceLink");
-        bits.ForceLink.setComponentOffset(0x1e);
         bits.CounterTestMode.setBaseRegister(&r16);
         bits.CounterTestMode.setName("CounterTestMode");
-        bits.CounterTestMode.setComponentOffset(0x1e);
         bits.TransmitErrorCodeVisibility.setBaseRegister(&r16);
         bits.TransmitErrorCodeVisibility.setName("TransmitErrorCodeVisibility");
-        bits.TransmitErrorCodeVisibility.setComponentOffset(0x1e);
         bits.CRCErrorCountVisibility.setBaseRegister(&r16);
         bits.CRCErrorCountVisibility.setName("CRCErrorCountVisibility");
-        bits.CRCErrorCountVisibility.setComponentOffset(0x1e);
     }
     RegMIITest1_t& operator=(const RegMIITest1_t& other)
     {
@@ -3013,7 +2807,6 @@ typedef register_container RegMIIBlockSelect_t {
     {
         /** @brief constructor for @ref MII_t.BlockSelect. */
         r16.setName("BlockSelect");
-        r16.setComponentOffset(0x1f);
     }
     RegMIIBlockSelect_t& operator=(const RegMIIBlockSelect_t& other)
     {
@@ -3160,49 +2953,34 @@ typedef register_container RegMII10baseT_t {
     {
         /** @brief constructor for @ref MII_t.10baseT. */
         r16.setName("10baseT");
-        r16.setComponentOffset(0x118);
         bits.ShadowRegisterSelector.setBaseRegister(&r16);
         bits.ShadowRegisterSelector.setName("ShadowRegisterSelector");
-        bits.ShadowRegisterSelector.setComponentOffset(0x118);
         bits._10Base_TPolarityErrorCountMax.setBaseRegister(&r16);
         bits._10Base_TPolarityErrorCountMax.setName("_10Base_TPolarityErrorCountMax");
-        bits._10Base_TPolarityErrorCountMax.setComponentOffset(0x118);
         bits._10Base_TNoDribble.setBaseRegister(&r16);
         bits._10Base_TNoDribble.setName("_10Base_TNoDribble");
-        bits._10Base_TNoDribble.setComponentOffset(0x118);
         bits.SQEEnableMode.setBaseRegister(&r16);
         bits.SQEEnableMode.setName("SQEEnableMode");
-        bits.SQEEnableMode.setComponentOffset(0x118);
         bits._10BTEchoMode.setBaseRegister(&r16);
         bits._10BTEchoMode.setName("_10BTEchoMode");
-        bits._10BTEchoMode.setComponentOffset(0x118);
         bits._10Base_TSignalDetectThreshold.setBaseRegister(&r16);
         bits._10Base_TSignalDetectThreshold.setName("_10Base_TSignalDetectThreshold");
-        bits._10Base_TSignalDetectThreshold.setComponentOffset(0x118);
         bits._10Base_TSignalDetectAutoswitch.setBaseRegister(&r16);
         bits._10Base_TSignalDetectAutoswitch.setName("_10Base_TSignalDetectAutoswitch");
-        bits._10Base_TSignalDetectAutoswitch.setComponentOffset(0x118);
         bits.JabberDisable.setBaseRegister(&r16);
         bits.JabberDisable.setName("JabberDisable");
-        bits.JabberDisable.setComponentOffset(0x118);
         bits.ClassA_DIV_BLineDriverSelect.setBaseRegister(&r16);
         bits.ClassA_DIV_BLineDriverSelect.setName("ClassA_DIV_BLineDriverSelect");
-        bits.ClassA_DIV_BLineDriverSelect.setComponentOffset(0x118);
         bits._10BTTXCInvertMode.setBaseRegister(&r16);
         bits._10BTTXCInvertMode.setName("_10BTTXCInvertMode");
-        bits._10BTTXCInvertMode.setComponentOffset(0x118);
         bits.BlockRXDVExtension.setBaseRegister(&r16);
         bits.BlockRXDVExtension.setName("BlockRXDVExtension");
-        bits.BlockRXDVExtension.setComponentOffset(0x118);
         bits.PolarityError.setBaseRegister(&r16);
         bits.PolarityError.setName("PolarityError");
-        bits.PolarityError.setComponentOffset(0x118);
         bits.EOFError.setBaseRegister(&r16);
         bits.EOFError.setName("EOFError");
-        bits.EOFError.setComponentOffset(0x118);
         bits.ManchesterCodeError.setBaseRegister(&r16);
         bits.ManchesterCodeError.setName("ManchesterCodeError");
-        bits.ManchesterCodeError.setComponentOffset(0x118);
     }
     RegMII10baseT_t& operator=(const RegMII10baseT_t& other)
     {
@@ -3265,16 +3043,12 @@ typedef register_container RegMIIDllSelection_t {
     {
         /** @brief constructor for @ref MII_t.DllSelection. */
         r16.setName("DllSelection");
-        r16.setComponentOffset(0x11c);
         bits.HighQualityClockTestMode.setBaseRegister(&r16);
         bits.HighQualityClockTestMode.setName("HighQualityClockTestMode");
-        bits.HighQualityClockTestMode.setComponentOffset(0x11c);
         bits.ShadowRegisterSelector.setBaseRegister(&r16);
         bits.ShadowRegisterSelector.setName("ShadowRegisterSelector");
-        bits.ShadowRegisterSelector.setComponentOffset(0x11c);
         bits.WriteEnable.setBaseRegister(&r16);
         bits.WriteEnable.setName("WriteEnable");
-        bits.WriteEnable.setComponentOffset(0x11c);
     }
     RegMIIDllSelection_t& operator=(const RegMIIDllSelection_t& other)
     {
@@ -3337,13 +3111,10 @@ typedef register_container RegMIIPowerAndMiiControl_t {
     {
         /** @brief constructor for @ref MII_t.PowerAndMiiControl. */
         r16.setName("PowerAndMiiControl");
-        r16.setComponentOffset(0x218);
         bits.ShadowRegisterSelector.setBaseRegister(&r16);
         bits.ShadowRegisterSelector.setName("ShadowRegisterSelector");
-        bits.ShadowRegisterSelector.setComponentOffset(0x218);
         bits.SuperIsolate.setBaseRegister(&r16);
         bits.SuperIsolate.setName("SuperIsolate");
-        bits.SuperIsolate.setComponentOffset(0x218);
     }
     RegMIIPowerAndMiiControl_t& operator=(const RegMIIPowerAndMiiControl_t& other)
     {
@@ -3470,40 +3241,28 @@ typedef register_container RegMIISpareControl1_t {
     {
         /** @brief constructor for @ref MII_t.SpareControl1. */
         r16.setName("SpareControl1");
-        r16.setComponentOffset(0x21c);
         bits.LinkLEDMode.setBaseRegister(&r16);
         bits.LinkLEDMode.setName("LinkLEDMode");
-        bits.LinkLEDMode.setComponentOffset(0x21c);
         bits.LostTokenFixDisable.setBaseRegister(&r16);
         bits.LostTokenFixDisable.setName("LostTokenFixDisable");
-        bits.LostTokenFixDisable.setComponentOffset(0x21c);
         bits.BicolorLinkSpeedLEDMode.setBaseRegister(&r16);
         bits.BicolorLinkSpeedLEDMode.setName("BicolorLinkSpeedLEDMode");
-        bits.BicolorLinkSpeedLEDMode.setComponentOffset(0x21c);
         bits._100FXModeCopperPath.setBaseRegister(&r16);
         bits._100FXModeCopperPath.setName("_100FXModeCopperPath");
-        bits._100FXModeCopperPath.setComponentOffset(0x21c);
         bits.UseFilteredSD.setBaseRegister(&r16);
         bits.UseFilteredSD.setName("UseFilteredSD");
-        bits.UseFilteredSD.setComponentOffset(0x21c);
         bits.CFC_INITFILTEREnable.setBaseRegister(&r16);
         bits.CFC_INITFILTEREnable.setName("CFC_INITFILTEREnable");
-        bits.CFC_INITFILTEREnable.setComponentOffset(0x21c);
         bits.InvertSDPin.setBaseRegister(&r16);
         bits.InvertSDPin.setName("InvertSDPin");
-        bits.InvertSDPin.setComponentOffset(0x21c);
         bits.ForceSDOn.setBaseRegister(&r16);
         bits.ForceSDOn.setName("ForceSDOn");
-        bits.ForceSDOn.setComponentOffset(0x21c);
         bits.SDStatus.setBaseRegister(&r16);
         bits.SDStatus.setName("SDStatus");
-        bits.SDStatus.setComponentOffset(0x21c);
         bits.ShadowRegisterSelector.setBaseRegister(&r16);
         bits.ShadowRegisterSelector.setName("ShadowRegisterSelector");
-        bits.ShadowRegisterSelector.setComponentOffset(0x21c);
         bits.WriteEnable.setBaseRegister(&r16);
         bits.WriteEnable.setName("WriteEnable");
-        bits.WriteEnable.setComponentOffset(0x21c);
     }
     RegMIISpareControl1_t& operator=(const RegMIISpareControl1_t& other)
     {
@@ -3594,28 +3353,20 @@ typedef register_container RegMIIClockAlignmentControl_t {
     {
         /** @brief constructor for @ref MII_t.ClockAlignmentControl. */
         r16.setName("ClockAlignmentControl");
-        r16.setComponentOffset(0x31c);
         bits.DelayLineSelector.setBaseRegister(&r16);
         bits.DelayLineSelector.setName("DelayLineSelector");
-        bits.DelayLineSelector.setComponentOffset(0x31c);
         bits.DelayValue.setBaseRegister(&r16);
         bits.DelayValue.setName("DelayValue");
-        bits.DelayValue.setComponentOffset(0x31c);
         bits.RXCLKAlignmentStrobe.setBaseRegister(&r16);
         bits.RXCLKAlignmentStrobe.setName("RXCLKAlignmentStrobe");
-        bits.RXCLKAlignmentStrobe.setComponentOffset(0x31c);
         bits.GMIIClockAlignmentStrobe.setBaseRegister(&r16);
         bits.GMIIClockAlignmentStrobe.setName("GMIIClockAlignmentStrobe");
-        bits.GMIIClockAlignmentStrobe.setComponentOffset(0x31c);
         bits.GTXCLKDelayBypassDisable.setBaseRegister(&r16);
         bits.GTXCLKDelayBypassDisable.setName("GTXCLKDelayBypassDisable");
-        bits.GTXCLKDelayBypassDisable.setComponentOffset(0x31c);
         bits.ShadowRegisterSelector.setBaseRegister(&r16);
         bits.ShadowRegisterSelector.setName("ShadowRegisterSelector");
-        bits.ShadowRegisterSelector.setComponentOffset(0x31c);
         bits.WriteEnable.setBaseRegister(&r16);
         bits.WriteEnable.setName("WriteEnable");
-        bits.WriteEnable.setComponentOffset(0x31c);
     }
     RegMIIClockAlignmentControl_t& operator=(const RegMIIClockAlignmentControl_t& other)
     {
@@ -3738,37 +3489,26 @@ typedef register_container RegMIIMiscTest1_t {
     {
         /** @brief constructor for @ref MII_t.MiscTest1. */
         r16.setName("MiscTest1");
-        r16.setComponentOffset(0x418);
         bits.ShadowRegisterSelector.setBaseRegister(&r16);
         bits.ShadowRegisterSelector.setName("ShadowRegisterSelector");
-        bits.ShadowRegisterSelector.setComponentOffset(0x418);
         bits.Halfout.setBaseRegister(&r16);
         bits.Halfout.setName("Halfout");
-        bits.Halfout.setComponentOffset(0x418);
         bits.SwapRXMDIX.setBaseRegister(&r16);
         bits.SwapRXMDIX.setName("SwapRXMDIX");
-        bits.SwapRXMDIX.setComponentOffset(0x418);
         bits._10BTBypassCRS.setBaseRegister(&r16);
         bits._10BTBypassCRS.setName("_10BTBypassCRS");
-        bits._10BTBypassCRS.setComponentOffset(0x418);
         bits._10BTBypassADC.setBaseRegister(&r16);
         bits._10BTBypassADC.setName("_10BTBypassADC");
-        bits._10BTBypassADC.setComponentOffset(0x418);
         bits._10BTClockResetEnable.setBaseRegister(&r16);
         bits._10BTClockResetEnable.setName("_10BTClockResetEnable");
-        bits._10BTClockResetEnable.setComponentOffset(0x418);
         bits._10BTIdleBypass.setBaseRegister(&r16);
         bits._10BTIdleBypass.setName("_10BTIdleBypass");
-        bits._10BTIdleBypass.setComponentOffset(0x418);
         bits._10BTPolarityBypass.setBaseRegister(&r16);
         bits._10BTPolarityBypass.setName("_10BTPolarityBypass");
-        bits._10BTPolarityBypass.setComponentOffset(0x418);
         bits._10BTWakeup.setBaseRegister(&r16);
         bits._10BTWakeup.setName("_10BTWakeup");
-        bits._10BTWakeup.setComponentOffset(0x418);
         bits.RemoteLoopbackTristate.setBaseRegister(&r16);
         bits.RemoteLoopbackTristate.setName("RemoteLoopbackTristate");
-        bits.RemoteLoopbackTristate.setComponentOffset(0x418);
     }
     RegMIIMiscTest1_t& operator=(const RegMIIMiscTest1_t& other)
     {
@@ -3879,34 +3619,24 @@ typedef register_container RegMIISpareControl2_t {
     {
         /** @brief constructor for @ref MII_t.SpareControl2. */
         r16.setName("SpareControl2");
-        r16.setComponentOffset(0x41c);
         bits.TestOnByte7_0.setBaseRegister(&r16);
         bits.TestOnByte7_0.setName("TestOnByte7_0");
-        bits.TestOnByte7_0.setComponentOffset(0x41c);
         bits.EnergyDetectOnIntrPin.setBaseRegister(&r16);
         bits.EnergyDetectOnIntrPin.setName("EnergyDetectOnIntrPin");
-        bits.EnergyDetectOnIntrPin.setComponentOffset(0x41c);
         bits.WirespeedRetryLimit.setBaseRegister(&r16);
         bits.WirespeedRetryLimit.setName("WirespeedRetryLimit");
-        bits.WirespeedRetryLimit.setComponentOffset(0x41c);
         bits.EnableTXCRXCTristate.setBaseRegister(&r16);
         bits.EnableTXCRXCTristate.setName("EnableTXCRXCTristate");
-        bits.EnableTXCRXCTristate.setComponentOffset(0x41c);
         bits.DisablePHYA2.setBaseRegister(&r16);
         bits.DisablePHYA2.setName("DisablePHYA2");
-        bits.DisablePHYA2.setComponentOffset(0x41c);
         bits.SelectTPOUT_RXD.setBaseRegister(&r16);
         bits.SelectTPOUT_RXD.setName("SelectTPOUT_RXD");
-        bits.SelectTPOUT_RXD.setComponentOffset(0x41c);
         bits.WirespeedRetryDisable.setBaseRegister(&r16);
         bits.WirespeedRetryDisable.setName("WirespeedRetryDisable");
-        bits.WirespeedRetryDisable.setComponentOffset(0x41c);
         bits.ShadowRegisterSelector.setBaseRegister(&r16);
         bits.ShadowRegisterSelector.setName("ShadowRegisterSelector");
-        bits.ShadowRegisterSelector.setComponentOffset(0x41c);
         bits.WriteEnable.setBaseRegister(&r16);
         bits.WriteEnable.setName("WriteEnable");
-        bits.WriteEnable.setComponentOffset(0x41c);
     }
     RegMIISpareControl2_t& operator=(const RegMIISpareControl2_t& other)
     {
@@ -4041,43 +3771,30 @@ typedef register_container RegMIIMiscTest2_t {
     {
         /** @brief constructor for @ref MII_t.MiscTest2. */
         r16.setName("MiscTest2");
-        r16.setComponentOffset(0x518);
         bits.ShadowRegisterSelector.setBaseRegister(&r16);
         bits.ShadowRegisterSelector.setName("ShadowRegisterSelector");
-        bits.ShadowRegisterSelector.setComponentOffset(0x518);
         bits.EnPWRDNTDAC.setBaseRegister(&r16);
         bits.EnPWRDNTDAC.setName("EnPWRDNTDAC");
-        bits.EnPWRDNTDAC.setComponentOffset(0x518);
         bits.Enableforce_mdix.setBaseRegister(&r16);
         bits.Enableforce_mdix.setName("Enableforce_mdix");
-        bits.Enableforce_mdix.setComponentOffset(0x518);
         bits.EnableECasNEXT.setBaseRegister(&r16);
         bits.EnableECasNEXT.setName("EnableECasNEXT");
-        bits.EnableECasNEXT.setComponentOffset(0x518);
         bits.OldPCSEncodingTX.setBaseRegister(&r16);
         bits.OldPCSEncodingTX.setName("OldPCSEncodingTX");
-        bits.OldPCSEncodingTX.setComponentOffset(0x518);
         bits.OldPCSEncodingRX.setBaseRegister(&r16);
         bits.OldPCSEncodingRX.setName("OldPCSEncodingRX");
-        bits.OldPCSEncodingRX.setComponentOffset(0x518);
         bits.DisableAutoEncodingCorrection.setBaseRegister(&r16);
         bits.DisableAutoEncodingCorrection.setName("DisableAutoEncodingCorrection");
-        bits.DisableAutoEncodingCorrection.setComponentOffset(0x518);
         bits.ENCErrorScale.setBaseRegister(&r16);
         bits.ENCErrorScale.setName("ENCErrorScale");
-        bits.ENCErrorScale.setComponentOffset(0x518);
         bits.ClassA_DIV_BEnable.setBaseRegister(&r16);
         bits.ClassA_DIV_BEnable.setName("ClassA_DIV_BEnable");
-        bits.ClassA_DIV_BEnable.setComponentOffset(0x518);
         bits.ClassA_DIV_BDVTEnable.setBaseRegister(&r16);
         bits.ClassA_DIV_BDVTEnable.setName("ClassA_DIV_BDVTEnable");
-        bits.ClassA_DIV_BDVTEnable.setComponentOffset(0x518);
         bits.ADCFIFOTXFix.setBaseRegister(&r16);
         bits.ADCFIFOTXFix.setName("ADCFIFOTXFix");
-        bits.ADCFIFOTXFix.setComponentOffset(0x518);
         bits.CopperEnergyDetectOverride.setBaseRegister(&r16);
         bits.CopperEnergyDetectOverride.setName("CopperEnergyDetectOverride");
-        bits.CopperEnergyDetectOverride.setComponentOffset(0x518);
     }
     RegMIIMiscTest2_t& operator=(const RegMIIMiscTest2_t& other)
     {
@@ -4208,43 +3925,30 @@ typedef register_container RegMIISpareControl3_t {
     {
         /** @brief constructor for @ref MII_t.SpareControl3. */
         r16.setName("SpareControl3");
-        r16.setComponentOffset(0x51c);
         bits.CLK125OutputEnable.setBaseRegister(&r16);
         bits.CLK125OutputEnable.setName("CLK125OutputEnable");
-        bits.CLK125OutputEnable.setComponentOffset(0x51c);
         bits.Auto_PowerDownDLLOffDisable.setBaseRegister(&r16);
         bits.Auto_PowerDownDLLOffDisable.setName("Auto_PowerDownDLLOffDisable");
-        bits.Auto_PowerDownDLLOffDisable.setComponentOffset(0x51c);
         bits.SIGDETDeassertTimerLengthen.setBaseRegister(&r16);
         bits.SIGDETDeassertTimerLengthen.setName("SIGDETDeassertTimerLengthen");
-        bits.SIGDETDeassertTimerLengthen.setComponentOffset(0x51c);
         bits.DisableLowPowerTOBase_TLinkMode.setBaseRegister(&r16);
         bits.DisableLowPowerTOBase_TLinkMode.setName("DisableLowPowerTOBase_TLinkMode");
-        bits.DisableLowPowerTOBase_TLinkMode.setComponentOffset(0x51c);
         bits.LowPowerENCDisable.setBaseRegister(&r16);
         bits.LowPowerENCDisable.setName("LowPowerENCDisable");
-        bits.LowPowerENCDisable.setComponentOffset(0x51c);
         bits.EnergyDetectChangeMuxSelect.setBaseRegister(&r16);
         bits.EnergyDetectChangeMuxSelect.setName("EnergyDetectChangeMuxSelect");
-        bits.EnergyDetectChangeMuxSelect.setComponentOffset(0x51c);
         bits.TXCOffEnable.setBaseRegister(&r16);
         bits.TXCOffEnable.setName("TXCOffEnable");
-        bits.TXCOffEnable.setComponentOffset(0x51c);
         bits._10BTCarrierRejectFilterEnable.setBaseRegister(&r16);
         bits._10BTCarrierRejectFilterEnable.setName("_10BTCarrierRejectFilterEnable");
-        bits._10BTCarrierRejectFilterEnable.setComponentOffset(0x51c);
         bits.TXCRXCDisableDuringAutoPowerDown.setBaseRegister(&r16);
         bits.TXCRXCDisableDuringAutoPowerDown.setName("TXCRXCDisableDuringAutoPowerDown");
-        bits.TXCRXCDisableDuringAutoPowerDown.setComponentOffset(0x51c);
         bits.DLLLockEnableDuringAutoPowerDown.setBaseRegister(&r16);
         bits.DLLLockEnableDuringAutoPowerDown.setName("DLLLockEnableDuringAutoPowerDown");
-        bits.DLLLockEnableDuringAutoPowerDown.setComponentOffset(0x51c);
         bits.ShadowRegisterSelector.setBaseRegister(&r16);
         bits.ShadowRegisterSelector.setName("ShadowRegisterSelector");
-        bits.ShadowRegisterSelector.setComponentOffset(0x51c);
         bits.WriteEnable.setBaseRegister(&r16);
         bits.WriteEnable.setName("WriteEnable");
-        bits.WriteEnable.setComponentOffset(0x51c);
     }
     RegMIISpareControl3_t& operator=(const RegMIISpareControl3_t& other)
     {
@@ -4375,43 +4079,30 @@ typedef register_container RegMIIMiscellaneousControl_t {
     {
         /** @brief constructor for @ref MII_t.MiscellaneousControl. */
         r16.setName("MiscellaneousControl");
-        r16.setComponentOffset(0x718);
         bits.ShadowRegisterSelector.setBaseRegister(&r16);
         bits.ShadowRegisterSelector.setName("ShadowRegisterSelector");
-        bits.ShadowRegisterSelector.setComponentOffset(0x718);
         bits.MDIOAllPhySelect.setBaseRegister(&r16);
         bits.MDIOAllPhySelect.setName("MDIOAllPhySelect");
-        bits.MDIOAllPhySelect.setComponentOffset(0x718);
         bits.WirespeedEnable.setBaseRegister(&r16);
         bits.WirespeedEnable.setName("WirespeedEnable");
-        bits.WirespeedEnable.setComponentOffset(0x718);
         bits.RGMIIOut_Of_BandStatusDisable.setBaseRegister(&r16);
         bits.RGMIIOut_Of_BandStatusDisable.setName("RGMIIOut_Of_BandStatusDisable");
-        bits.RGMIIOut_Of_BandStatusDisable.setComponentOffset(0x718);
         bits.RGMIIRXERMode.setBaseRegister(&r16);
         bits.RGMIIRXERMode.setName("RGMIIRXERMode");
-        bits.RGMIIRXERMode.setComponentOffset(0x718);
         bits.RGMIIMode.setBaseRegister(&r16);
         bits.RGMIIMode.setName("RGMIIMode");
-        bits.RGMIIMode.setComponentOffset(0x718);
         bits.RGMIITimingMode.setBaseRegister(&r16);
         bits.RGMIITimingMode.setName("RGMIITimingMode");
-        bits.RGMIITimingMode.setComponentOffset(0x718);
         bits.ForceAutoMDIXMode.setBaseRegister(&r16);
         bits.ForceAutoMDIXMode.setName("ForceAutoMDIXMode");
-        bits.ForceAutoMDIXMode.setComponentOffset(0x718);
         bits.BypassWirespeedTimer.setBaseRegister(&r16);
         bits.BypassWirespeedTimer.setName("BypassWirespeedTimer");
-        bits.BypassWirespeedTimer.setComponentOffset(0x718);
         bits.PacketCounterMode.setBaseRegister(&r16);
         bits.PacketCounterMode.setName("PacketCounterMode");
-        bits.PacketCounterMode.setComponentOffset(0x718);
         bits.ShadowRegisterReadSelector.setBaseRegister(&r16);
         bits.ShadowRegisterReadSelector.setName("ShadowRegisterReadSelector");
-        bits.ShadowRegisterReadSelector.setComponentOffset(0x718);
         bits.WriteEnable.setBaseRegister(&r16);
         bits.WriteEnable.setName("WriteEnable");
-        bits.WriteEnable.setComponentOffset(0x718);
     }
     RegMIIMiscellaneousControl_t& operator=(const RegMIIMiscellaneousControl_t& other)
     {
@@ -4422,7 +4113,7 @@ typedef register_container RegMIIMiscellaneousControl_t {
 } RegMIIMiscellaneousControl_t;
 
 /** @brief Component definition for @ref MII. */
-typedef struct {
+typedef struct MII_t {
     /** @brief  */
     RegMIIControl_t Control;
 
@@ -4568,6 +4259,44 @@ typedef struct {
     RegMIIMiscellaneousControl_t MiscellaneousControl;
 
 #ifdef CXX_SIMULATOR
+    MII_t()
+    {
+        Control.r16.setComponentOffset(0x0);
+        Status.r16.setComponentOffset(0x1);
+        PhyIdHigh.r16.setComponentOffset(0x2);
+        PhyIdLow.r16.setComponentOffset(0x3);
+        AutonegotiationAdvertisement.r16.setComponentOffset(0x4);
+        AutonegotiationLinkPartnerAbilityBasePage.r16.setComponentOffset(0x5);
+        AutonegotiationExpansion.r16.setComponentOffset(0x6);
+        AutonegotiationNextPageTransmit.r16.setComponentOffset(0x7);
+        AutonegotiationLinkPartnerAbilityNextPage.r16.setComponentOffset(0x8);
+        _1000baseTControl.r16.setComponentOffset(0x9);
+        _1000baseTStatus.r16.setComponentOffset(0xa);
+        BroadreachLreAccess.r16.setComponentOffset(0xe);
+        IeeeExtendedStatus.r16.setComponentOffset(0xf);
+        PhyExtendedControl.r16.setComponentOffset(0x10);
+        PhyExtendedStatus.r16.setComponentOffset(0x11);
+        ReceiveErrorCounter.r16.setComponentOffset(0x12);
+        FalseCarrierSenseCounter.r16.setComponentOffset(0x13);
+        LocalRemoteReceiverNotOkCounter.r16.setComponentOffset(0x14);
+        AuxiliaryControl.r16.setComponentOffset(0x18);
+        AuxiliaryStatusSummary.r16.setComponentOffset(0x19);
+        InterruptStatus.r16.setComponentOffset(0x1a);
+        InterruptMask.r16.setComponentOffset(0x1b);
+        CabletronLed.r16.setComponentOffset(0x1c);
+        Test1.r16.setComponentOffset(0x1e);
+        BlockSelect.r16.setComponentOffset(0x1f);
+        _10baseT.r16.setComponentOffset(0x118);
+        DllSelection.r16.setComponentOffset(0x11c);
+        PowerAndMiiControl.r16.setComponentOffset(0x218);
+        SpareControl1.r16.setComponentOffset(0x21c);
+        ClockAlignmentControl.r16.setComponentOffset(0x31c);
+        MiscTest1.r16.setComponentOffset(0x418);
+        SpareControl2.r16.setComponentOffset(0x41c);
+        MiscTest2.r16.setComponentOffset(0x518);
+        SpareControl3.r16.setComponentOffset(0x51c);
+        MiscellaneousControl.r16.setComponentOffset(0x718);
+    }
     typedef uint32_t (*callback_t)(uint32_t, uint32_t, void*);
     callback_t mIndexReadCallback;
     void* mIndexReadCallbackArgs;
diff --git a/libs/NVRam/bcm5719_NVM.h b/libs/NVRam/bcm5719_NVM.h
index 928a62e..056e20d 100644
--- a/libs/NVRam/bcm5719_NVM.h
+++ b/libs/NVRam/bcm5719_NVM.h
@@ -182,31 +182,22 @@ typedef register_container RegNVMCommand_t {
     {
         /** @brief constructor for @ref NVM_t.Command. */
         r32.setName("Command");
-        r32.setComponentOffset(0x0);
         bits.Done.setBaseRegister(&r32);
         bits.Done.setName("Done");
-        bits.Done.setComponentOffset(0x0);
         bits.Doit.setBaseRegister(&r32);
         bits.Doit.setName("Doit");
-        bits.Doit.setComponentOffset(0x0);
         bits.Wr.setBaseRegister(&r32);
         bits.Wr.setName("Wr");
-        bits.Wr.setComponentOffset(0x0);
         bits.Erase.setBaseRegister(&r32);
         bits.Erase.setName("Erase");
-        bits.Erase.setComponentOffset(0x0);
         bits.First.setBaseRegister(&r32);
         bits.First.setName("First");
-        bits.First.setComponentOffset(0x0);
         bits.Last.setBaseRegister(&r32);
         bits.Last.setName("Last");
-        bits.Last.setComponentOffset(0x0);
         bits.WriteEnableCommand.setBaseRegister(&r32);
         bits.WriteEnableCommand.setName("WriteEnableCommand");
-        bits.WriteEnableCommand.setComponentOffset(0x0);
         bits.WriteDisableCommand.setBaseRegister(&r32);
         bits.WriteDisableCommand.setName("WriteDisableCommand");
-        bits.WriteDisableCommand.setComponentOffset(0x0);
     }
     RegNVMCommand_t& operator=(const RegNVMCommand_t& other)
     {
@@ -232,7 +223,6 @@ typedef register_container RegNVMWrite_t {
     {
         /** @brief constructor for @ref NVM_t.Write. */
         r32.setName("Write");
-        r32.setComponentOffset(0x8);
     }
     RegNVMWrite_t& operator=(const RegNVMWrite_t& other)
     {
@@ -258,7 +248,6 @@ typedef register_container RegNVMAddr_t {
     {
         /** @brief constructor for @ref NVM_t.Addr. */
         r32.setName("Addr");
-        r32.setComponentOffset(0xc);
     }
     RegNVMAddr_t& operator=(const RegNVMAddr_t& other)
     {
@@ -284,7 +273,6 @@ typedef register_container RegNVMRead_t {
     {
         /** @brief constructor for @ref NVM_t.Read. */
         r32.setName("Read");
-        r32.setComponentOffset(0x10);
     }
     RegNVMRead_t& operator=(const RegNVMRead_t& other)
     {
@@ -390,25 +378,18 @@ typedef register_container RegNVMNvmCfg1_t {
     {
         /** @brief constructor for @ref NVM_t.NvmCfg1. */
         r32.setName("NvmCfg1");
-        r32.setComponentOffset(0x14);
         bits.FlashMode.setBaseRegister(&r32);
         bits.FlashMode.setName("FlashMode");
-        bits.FlashMode.setComponentOffset(0x14);
         bits.BufferMode.setBaseRegister(&r32);
         bits.BufferMode.setName("BufferMode");
-        bits.BufferMode.setComponentOffset(0x14);
         bits.SPICLKDIV.setBaseRegister(&r32);
         bits.SPICLKDIV.setName("SPICLKDIV");
-        bits.SPICLKDIV.setComponentOffset(0x14);
         bits.ProtectMode.setBaseRegister(&r32);
         bits.ProtectMode.setName("ProtectMode");
-        bits.ProtectMode.setComponentOffset(0x14);
         bits.FlashSize.setBaseRegister(&r32);
         bits.FlashSize.setName("FlashSize");
-        bits.FlashSize.setComponentOffset(0x14);
         bits.PageSize.setBaseRegister(&r32);
         bits.PageSize.setName("PageSize");
-        bits.PageSize.setComponentOffset(0x14);
     }
     RegNVMNvmCfg1_t& operator=(const RegNVMNvmCfg1_t& other)
     {
@@ -467,13 +448,10 @@ typedef register_container RegNVMNvmCfg2_t {
     {
         /** @brief constructor for @ref NVM_t.NvmCfg2. */
         r32.setName("NvmCfg2");
-        r32.setComponentOffset(0x18);
         bits.EraseCommand.setBaseRegister(&r32);
         bits.EraseCommand.setName("EraseCommand");
-        bits.EraseCommand.setComponentOffset(0x18);
         bits.StatusCommand.setBaseRegister(&r32);
         bits.StatusCommand.setName("StatusCommand");
-        bits.StatusCommand.setComponentOffset(0x18);
     }
     RegNVMNvmCfg2_t& operator=(const RegNVMNvmCfg2_t& other)
     {
@@ -532,13 +510,10 @@ typedef register_container RegNVMNvmCfg3_t {
     {
         /** @brief constructor for @ref NVM_t.NvmCfg3. */
         r32.setName("NvmCfg3");
-        r32.setComponentOffset(0x1c);
         bits.WriteCommand.setBaseRegister(&r32);
         bits.WriteCommand.setName("WriteCommand");
-        bits.WriteCommand.setComponentOffset(0x1c);
         bits.ReadCommand.setBaseRegister(&r32);
         bits.ReadCommand.setName("ReadCommand");
-        bits.ReadCommand.setComponentOffset(0x1c);
     }
     RegNVMNvmCfg3_t& operator=(const RegNVMNvmCfg3_t& other)
     {
@@ -673,43 +648,30 @@ typedef register_container RegNVMSoftwareArbitration_t {
     {
         /** @brief constructor for @ref NVM_t.SoftwareArbitration. */
         r32.setName("SoftwareArbitration");
-        r32.setComponentOffset(0x20);
         bits.ReqSet0.setBaseRegister(&r32);
         bits.ReqSet0.setName("ReqSet0");
-        bits.ReqSet0.setComponentOffset(0x20);
         bits.ReqSet1.setBaseRegister(&r32);
         bits.ReqSet1.setName("ReqSet1");
-        bits.ReqSet1.setComponentOffset(0x20);
         bits.ReqSet2.setBaseRegister(&r32);
         bits.ReqSet2.setName("ReqSet2");
-        bits.ReqSet2.setComponentOffset(0x20);
         bits.ReqSet3.setBaseRegister(&r32);
         bits.ReqSet3.setName("ReqSet3");
-        bits.ReqSet3.setComponentOffset(0x20);
         bits.ReqClr0.setBaseRegister(&r32);
         bits.ReqClr0.setName("ReqClr0");
-        bits.ReqClr0.setComponentOffset(0x20);
         bits.ReqClr1.setBaseRegister(&r32);
         bits.ReqClr1.setName("ReqClr1");
-        bits.ReqClr1.setComponentOffset(0x20);
         bits.ReqClr2.setBaseRegister(&r32);
         bits.ReqClr2.setName("ReqClr2");
-        bits.ReqClr2.setComponentOffset(0x20);
         bits.ReqClr3.setBaseRegister(&r32);
         bits.ReqClr3.setName("ReqClr3");
-        bits.ReqClr3.setComponentOffset(0x20);
         bits.ArbWon0.setBaseRegister(&r32);
         bits.ArbWon0.setName("ArbWon0");
-        bits.ArbWon0.setComponentOffset(0x20);
         bits.ArbWon1.setBaseRegister(&r32);
         bits.ArbWon1.setName("ArbWon1");
-        bits.ArbWon1.setComponentOffset(0x20);
         bits.ArbWon2.setBaseRegister(&r32);
         bits.ArbWon2.setName("ArbWon2");
-        bits.ArbWon2.setComponentOffset(0x20);
         bits.ArbWon3.setBaseRegister(&r32);
         bits.ArbWon3.setName("ArbWon3");
-        bits.ArbWon3.setComponentOffset(0x20);
     }
     RegNVMSoftwareArbitration_t& operator=(const RegNVMSoftwareArbitration_t& other)
     {
@@ -764,13 +726,10 @@ typedef register_container RegNVMAccess_t {
     {
         /** @brief constructor for @ref NVM_t.Access. */
         r32.setName("Access");
-        r32.setComponentOffset(0x24);
         bits.Enable.setBaseRegister(&r32);
         bits.Enable.setName("Enable");
-        bits.Enable.setComponentOffset(0x24);
         bits.WriteEnable.setBaseRegister(&r32);
         bits.WriteEnable.setName("WriteEnable");
-        bits.WriteEnable.setComponentOffset(0x24);
     }
     RegNVMAccess_t& operator=(const RegNVMAccess_t& other)
     {
@@ -825,13 +784,10 @@ typedef register_container RegNVMNvmWrite1_t {
     {
         /** @brief constructor for @ref NVM_t.NvmWrite1. */
         r32.setName("NvmWrite1");
-        r32.setComponentOffset(0x28);
         bits.WriteEnableCommand.setBaseRegister(&r32);
         bits.WriteEnableCommand.setName("WriteEnableCommand");
-        bits.WriteEnableCommand.setComponentOffset(0x28);
         bits.WriteDisableCommand.setBaseRegister(&r32);
         bits.WriteDisableCommand.setName("WriteDisableCommand");
-        bits.WriteDisableCommand.setComponentOffset(0x28);
     }
     RegNVMNvmWrite1_t& operator=(const RegNVMNvmWrite1_t& other)
     {
@@ -874,10 +830,8 @@ typedef register_container RegNVMArbitrationWatchdog_t {
     {
         /** @brief constructor for @ref NVM_t.ArbitrationWatchdog. */
         r32.setName("ArbitrationWatchdog");
-        r32.setComponentOffset(0x2c);
         bits.reserved.setBaseRegister(&r32);
         bits.reserved.setName("reserved");
-        bits.reserved.setComponentOffset(0x2c);
     }
     RegNVMArbitrationWatchdog_t& operator=(const RegNVMArbitrationWatchdog_t& other)
     {
@@ -978,22 +932,16 @@ typedef register_container RegNVMAutoSenseStatus_t {
     {
         /** @brief constructor for @ref NVM_t.AutoSenseStatus. */
         r32.setName("AutoSenseStatus");
-        r32.setComponentOffset(0x38);
         bits.AutoConfigBusy.setBaseRegister(&r32);
         bits.AutoConfigBusy.setName("AutoConfigBusy");
-        bits.AutoConfigBusy.setComponentOffset(0x38);
         bits.AutoConfigEnable.setBaseRegister(&r32);
         bits.AutoConfigEnable.setName("AutoConfigEnable");
-        bits.AutoConfigEnable.setComponentOffset(0x38);
         bits.AutoConfigSuccessful.setBaseRegister(&r32);
         bits.AutoConfigSuccessful.setName("AutoConfigSuccessful");
-        bits.AutoConfigSuccessful.setComponentOffset(0x38);
         bits.AutoConfigState.setBaseRegister(&r32);
         bits.AutoConfigState.setName("AutoConfigState");
-        bits.AutoConfigState.setComponentOffset(0x38);
         bits.AutoDetectedDeviceID.setBaseRegister(&r32);
         bits.AutoDetectedDeviceID.setName("AutoDetectedDeviceID");
-        bits.AutoDetectedDeviceID.setComponentOffset(0x38);
     }
     RegNVMAutoSenseStatus_t& operator=(const RegNVMAutoSenseStatus_t& other)
     {
@@ -1004,7 +952,7 @@ typedef register_container RegNVMAutoSenseStatus_t {
 } RegNVMAutoSenseStatus_t;
 
 /** @brief Component definition for @ref NVM. */
-typedef struct {
+typedef struct NVM_t {
     /** @brief  */
     RegNVMCommand_t Command;
 
@@ -1048,6 +996,21 @@ typedef struct {
     RegNVMAutoSenseStatus_t AutoSenseStatus;
 
 #ifdef CXX_SIMULATOR
+    NVM_t()
+    {
+        Command.r32.setComponentOffset(0x0);
+        Write.r32.setComponentOffset(0x8);
+        Addr.r32.setComponentOffset(0xc);
+        Read.r32.setComponentOffset(0x10);
+        NvmCfg1.r32.setComponentOffset(0x14);
+        NvmCfg2.r32.setComponentOffset(0x18);
+        NvmCfg3.r32.setComponentOffset(0x1c);
+        SoftwareArbitration.r32.setComponentOffset(0x20);
+        Access.r32.setComponentOffset(0x24);
+        NvmWrite1.r32.setComponentOffset(0x28);
+        ArbitrationWatchdog.r32.setComponentOffset(0x2c);
+        AutoSenseStatus.r32.setComponentOffset(0x38);
+    }
     typedef uint32_t (*callback_t)(uint32_t, uint32_t, void*);
     callback_t mIndexReadCallback;
     void* mIndexReadCallbackArgs;