fmd: fix licensing conflicts

Change-Id: Ib662fba72d3ad0e5260bcc36006fa0dd7158b056
Signed-off-by: Mandy Lavi <mandy.lavi@freescale.com>
Reviewed-on: http://git.am.freescale.net:8181/36405
Tested-by: Review Code-CDREVIEW <CDREVIEW@freescale.com>
Reviewed-by: Nir Erez <nir.erez@freescale.com>
Reviewed-by: Honghua Yin <Hong-Hua.Yin@freescale.com>

14 files changed, 1 insertions, 1257 deletions

diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/HC/hc.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/HC/hc.c
index 5b03cfc..8bc0889 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/HC/hc.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/HC/hc.c
@@ -342,19 +342,6 @@ t_Error FmHcSetFramesDataMemory(t_Handle h_FmHc,
     return FillBufPool(p_FmHc);
 }
 
-#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0))
-t_Error FmHcDumpRegs(t_Handle h_FmHc)
-{
-    t_FmHc  *p_FmHc = (t_FmHc*)h_FmHc;
-
-    SANITY_CHECK_RETURN_ERROR(p_FmHc, E_INVALID_HANDLE);
-    SANITY_CHECK_RETURN_ERROR(p_FmHc->h_HcPortDev, E_INVALID_HANDLE);
-
-    return  FM_PORT_DumpRegs(p_FmHc->h_HcPortDev);
-
-}
-#endif /* (defined(DEBUG_ERRORS) && ... */
-
 void FmHcTxConf(t_Handle h_FmHc, t_DpaaFD *p_Fd)
 {
     t_FmHc      *p_FmHc = (t_FmHc*)h_FmHc;
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/MAC/dtsec.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/MAC/dtsec.c
index d0ed2e7..5ae65f8 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/MAC/dtsec.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/MAC/dtsec.c
@@ -1202,52 +1202,6 @@ static t_Error DtsecSetException(t_Handle h_Dtsec, e_FmMacExceptions exception,
     return E_OK;
 }
 
-/* ........................................................................... */
-
-#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0))
-static t_Error DtsecDumpRegs(t_Handle h_Dtsec)
-{
-    t_Dtsec *p_Dtsec = (t_Dtsec *)h_Dtsec;
-    int i = 0;
-
-    DECLARE_DUMP;
-
-    if (p_Dtsec->p_MemMap)
-    {
-        DUMP_TITLE(p_Dtsec->p_MemMap, ("dTSEC %d: ", p_Dtsec->macId));
-        DUMP_VAR(p_Dtsec->p_MemMap, tsec_id);
-        DUMP_VAR(p_Dtsec->p_MemMap, tsec_id2);
-        DUMP_VAR(p_Dtsec->p_MemMap, ievent);
-        DUMP_VAR(p_Dtsec->p_MemMap, imask);
-        DUMP_VAR(p_Dtsec->p_MemMap, ecntrl);
-        DUMP_VAR(p_Dtsec->p_MemMap, ptv);
-        DUMP_VAR(p_Dtsec->p_MemMap, tmr_ctrl);
-        DUMP_VAR(p_Dtsec->p_MemMap, tmr_pevent);
-        DUMP_VAR(p_Dtsec->p_MemMap, tmr_pemask);
-        DUMP_VAR(p_Dtsec->p_MemMap, tctrl);
-        DUMP_VAR(p_Dtsec->p_MemMap, rctrl);
-        DUMP_VAR(p_Dtsec->p_MemMap, maccfg1);
-        DUMP_VAR(p_Dtsec->p_MemMap, maccfg2);
-        DUMP_VAR(p_Dtsec->p_MemMap, ipgifg);
-        DUMP_VAR(p_Dtsec->p_MemMap, hafdup);
-        DUMP_VAR(p_Dtsec->p_MemMap, maxfrm);
-
-        DUMP_VAR(p_Dtsec->p_MemMap, macstnaddr1);
-        DUMP_VAR(p_Dtsec->p_MemMap, macstnaddr2);
-
-        DUMP_SUBSTRUCT_ARRAY(i, 8)
-        {
-            DUMP_VAR(p_Dtsec->p_MemMap, macaddr[i].exact_match1);
-            DUMP_VAR(p_Dtsec->p_MemMap, macaddr[i].exact_match2);
-        }
-        DUMP_VAR(p_Dtsec->p_MemMap, car1);
-        DUMP_VAR(p_Dtsec->p_MemMap, car2);
-    }
-
-    return E_OK;
-}
-#endif /* (defined(DEBUG_ERRORS) && ... */
-
 
 /*****************************************************************************/
 /*                      dTSEC Init & Free API                                   */
@@ -1447,9 +1401,6 @@ static void InitFmMacControllerDriver(t_FmMacControllerDriver *p_FmMacController
     p_FmMacControllerDriver->f_FM_MAC_MII_WritePhyReg           = DTSEC_MII_WritePhyReg;
     p_FmMacControllerDriver->f_FM_MAC_MII_ReadPhyReg            = DTSEC_MII_ReadPhyReg;
 
-#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0))
-    p_FmMacControllerDriver->f_FM_MAC_DumpRegs                  = DtsecDumpRegs;
-#endif /* (defined(DEBUG_ERRORS) && ... */
 }
 
 
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/MAC/memac.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/MAC/memac.c
index a2b8751..b5aacc9 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/MAC/memac.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/MAC/memac.c
@@ -812,63 +812,6 @@ static uint16_t MemacGetMaxFrameLength(t_Handle h_Memac)
     return fman_memac_get_max_frame_len(p_Memac->p_MemMap);
 }
 
-/* ......................................................................... */
-
-#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0))
-static t_Error MemacDumpRegs(t_Handle h_Memac)
-{
-    t_Memac     *p_Memac = (t_Memac *)h_Memac;
-    int         i = 0;
-
-    DECLARE_DUMP;
-
-    if (p_Memac->p_MemMap)
-    {
-        DUMP_TITLE(p_Memac->p_MemMap, ("mEMAC %d: ", p_Memac->macId));
-        DUMP_VAR(p_Memac->p_MemMap, command_config);
-        DUMP_VAR(p_Memac->p_MemMap, mac_addr0.mac_addr_l);
-        DUMP_VAR(p_Memac->p_MemMap, mac_addr0.mac_addr_u);
-        DUMP_VAR(p_Memac->p_MemMap, maxfrm);
-        DUMP_VAR(p_Memac->p_MemMap, hashtable_ctrl);
-        DUMP_VAR(p_Memac->p_MemMap, ievent);
-        DUMP_VAR(p_Memac->p_MemMap, tx_ipg_length);
-        DUMP_VAR(p_Memac->p_MemMap, imask);
-
-        DUMP_SUBSTRUCT_ARRAY(i, 4)
-        {
-            DUMP_VAR(p_Memac->p_MemMap, pause_quanta[i]);
-        }
-        DUMP_SUBSTRUCT_ARRAY(i, 4)
-        {
-            DUMP_VAR(p_Memac->p_MemMap, pause_thresh[i]);
-        }
-
-        DUMP_VAR(p_Memac->p_MemMap, rx_pause_status);
-
-        DUMP_SUBSTRUCT_ARRAY(i, MEMAC_NUM_OF_PADDRS)
-        {
-            DUMP_VAR(p_Memac->p_MemMap, mac_addr[i].mac_addr_l);
-            DUMP_VAR(p_Memac->p_MemMap, mac_addr[i].mac_addr_u);
-        }
-
-        DUMP_VAR(p_Memac->p_MemMap, lpwake_timer);
-        DUMP_VAR(p_Memac->p_MemMap, sleep_timer);
-        DUMP_VAR(p_Memac->p_MemMap, statn_config);
-        DUMP_VAR(p_Memac->p_MemMap, if_mode);
-        DUMP_VAR(p_Memac->p_MemMap, if_status);
-        DUMP_VAR(p_Memac->p_MemMap, hg_config);
-        DUMP_VAR(p_Memac->p_MemMap, hg_pause_quanta);
-        DUMP_VAR(p_Memac->p_MemMap, hg_pause_thresh);
-        DUMP_VAR(p_Memac->p_MemMap, hgrx_pause_status);
-        DUMP_VAR(p_Memac->p_MemMap, hg_fifos_status);
-        DUMP_VAR(p_Memac->p_MemMap, rhm);
-        DUMP_VAR(p_Memac->p_MemMap, thm);
-    }
-
-    return E_OK;
-}
-#endif /* (defined(DEBUG_ERRORS) && ... */
-
 
 /*****************************************************************************/
 /*                      mEMAC Init & Free API                                   */
@@ -1086,10 +1029,6 @@ static void InitFmMacControllerDriver(t_FmMacControllerDriver *p_FmMacController
 
     p_FmMacControllerDriver->f_FM_MAC_MII_WritePhyReg           = MEMAC_MII_WritePhyReg;
     p_FmMacControllerDriver->f_FM_MAC_MII_ReadPhyReg            = MEMAC_MII_ReadPhyReg;
-
-#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0))
-    p_FmMacControllerDriver->f_FM_MAC_DumpRegs                  = MemacDumpRegs;
-#endif /* (defined(DEBUG_ERRORS) && ... */
 }
 
 
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/MAC/tgec.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/MAC/tgec.c
index 8f39f25..bf12c5d 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/MAC/tgec.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/MAC/tgec.c
@@ -741,50 +741,6 @@ static t_Error TgecTxEccWorkaround(t_Tgec *p_Tgec)
 }
 #endif /* FM_TX_ECC_FRMS_ERRATA_10GMAC_A004 */
 
-/* ......................................................................... */
-
-#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0))
-static t_Error TgecDumpRegs(t_Handle h_Tgec)
-{
-    t_Tgec    *p_Tgec = (t_Tgec *)h_Tgec;
-
-    DECLARE_DUMP;
-
-    if (p_Tgec->p_MemMap)
-    {
-        DUMP_TITLE(p_Tgec->p_MemMap, ("10G MAC %d: ", p_Tgec->macId));
-        DUMP_VAR(p_Tgec->p_MemMap, tgec_id);
-        DUMP_VAR(p_Tgec->p_MemMap, command_config);
-        DUMP_VAR(p_Tgec->p_MemMap, mac_addr_0);
-        DUMP_VAR(p_Tgec->p_MemMap, mac_addr_1);
-        DUMP_VAR(p_Tgec->p_MemMap, maxfrm);
-        DUMP_VAR(p_Tgec->p_MemMap, pause_quant);
-        DUMP_VAR(p_Tgec->p_MemMap, rx_fifo_sections);
-        DUMP_VAR(p_Tgec->p_MemMap, tx_fifo_sections);
-        DUMP_VAR(p_Tgec->p_MemMap, rx_fifo_almost_f_e);
-        DUMP_VAR(p_Tgec->p_MemMap, tx_fifo_almost_f_e);
-        DUMP_VAR(p_Tgec->p_MemMap, hashtable_ctrl);
-        DUMP_VAR(p_Tgec->p_MemMap, mdio_cfg_status);
-        DUMP_VAR(p_Tgec->p_MemMap, mdio_command);
-        DUMP_VAR(p_Tgec->p_MemMap, mdio_data);
-        DUMP_VAR(p_Tgec->p_MemMap, mdio_regaddr);
-        DUMP_VAR(p_Tgec->p_MemMap, status);
-        DUMP_VAR(p_Tgec->p_MemMap, tx_ipg_len);
-        DUMP_VAR(p_Tgec->p_MemMap, mac_addr_2);
-        DUMP_VAR(p_Tgec->p_MemMap, mac_addr_3);
-        DUMP_VAR(p_Tgec->p_MemMap, rx_fifo_ptr_rd);
-        DUMP_VAR(p_Tgec->p_MemMap, rx_fifo_ptr_wr);
-        DUMP_VAR(p_Tgec->p_MemMap, tx_fifo_ptr_rd);
-        DUMP_VAR(p_Tgec->p_MemMap, tx_fifo_ptr_wr);
-        DUMP_VAR(p_Tgec->p_MemMap, imask);
-        DUMP_VAR(p_Tgec->p_MemMap, ievent);
-    }
-
-    return E_OK;
-}
-#endif /* (defined(DEBUG_ERRORS) && ... */
-
-
 /*****************************************************************************/
 /*                      FM Init & Free API                                   */
 /*****************************************************************************/
@@ -960,10 +916,6 @@ static void InitFmMacControllerDriver(t_FmMacControllerDriver *p_FmMacController
 
     p_FmMacControllerDriver->f_FM_MAC_MII_WritePhyReg           = TGEC_MII_WritePhyReg;
     p_FmMacControllerDriver->f_FM_MAC_MII_ReadPhyReg            = TGEC_MII_ReadPhyReg;
-
-#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0))
-    p_FmMacControllerDriver->f_FM_MAC_DumpRegs                  = TgecDumpRegs;
-#endif /* (defined(DEBUG_ERRORS) && ... */
 }
 
 
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_kg.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_kg.c
index dae5575..720da19 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_kg.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_kg.c
@@ -3240,105 +3240,3 @@ t_Error FM_PCD_KgSetDfltValue(t_Handle h_FmPcd, uint8_t valueId, uint32_t value)
         WRITE_UINT32(p_Regs->fmkg_gdv1r,value);
     return E_OK;
 }
-
-#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0))
-t_Error FM_PCD_KgDumpRegs(t_Handle h_FmPcd)
-{
-    t_FmPcd             *p_FmPcd = (t_FmPcd*)h_FmPcd;
-    int                 i = 0, j = 0;
-    uint8_t             hardwarePortId = 0;
-    uint32_t            tmpKgarReg, intFlags;
-    t_Error             err = E_OK;
-
-    DECLARE_DUMP;
-
-    SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE);
-    SANITY_CHECK_RETURN_ERROR(p_FmPcd->p_FmPcdKg, E_INVALID_HANDLE);
-    SANITY_CHECK_RETURN_ERROR(!p_FmPcd->p_FmPcdDriverParam, E_INVALID_STATE);
-    SANITY_CHECK_RETURN_ERROR(((p_FmPcd->guestId == NCSW_MASTER_ID) ||
-                               p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs), E_INVALID_OPERATION);
-
-    DUMP_SUBTITLE(("\n"));
-    DUMP_TITLE(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs, ("FmPcdKgRegs Regs"));
-
-    DUMP_VAR(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs,fmkg_gcr);
-    DUMP_VAR(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs,fmkg_eer);
-    DUMP_VAR(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs,fmkg_eeer);
-    DUMP_VAR(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs,fmkg_seer);
-    DUMP_VAR(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs,fmkg_seeer);
-    DUMP_VAR(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs,fmkg_gsr);
-    DUMP_VAR(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs,fmkg_tpc);
-    DUMP_VAR(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs,fmkg_serc);
-    DUMP_VAR(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs,fmkg_fdor);
-    DUMP_VAR(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs,fmkg_gdv0r);
-    DUMP_VAR(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs,fmkg_gdv1r);
-    DUMP_VAR(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs,fmkg_feer);
-    DUMP_VAR(p_FmPcd->p_FmPcdKg->p_FmPcdKgRegs,fmkg_ar);
-
-    DUMP_SUBTITLE(("\n"));
-    intFlags = KgHwLock(p_FmPcd->p_FmPcdKg);
-    for (j = 0;j<FM_PCD_KG_NUM_OF_SCHEMES;j++)
-    {
-        tmpKgarReg = FmPcdKgBuildReadSchemeActionReg((uint8_t)j);
-        if (WriteKgarWait(p_FmPcd, tmpKgarReg) != E_OK)
-            RETURN_ERROR(MAJOR, E_INVALID_STATE, NO_MSG);
-
-        DUMP_TITLE(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->schemeRegs, ("FmPcdKgIndirectAccessSchemeRegs Scheme %d Regs", j));
-
-        DUMP_VAR(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->schemeRegs,kgse_mode);
-        DUMP_VAR(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->schemeRegs,kgse_ekfc);
-        DUMP_VAR(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->schemeRegs,kgse_ekdv);
-        DUMP_VAR(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->schemeRegs,kgse_bmch);
-        DUMP_VAR(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->schemeRegs,kgse_bmcl);
-        DUMP_VAR(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->schemeRegs,kgse_fqb);
-        DUMP_VAR(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->schemeRegs,kgse_hc);
-        DUMP_VAR(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->schemeRegs,kgse_ppc);
-
-        DUMP_TITLE(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->schemeRegs.kgse_gec, ("kgse_gec"));
-        DUMP_SUBSTRUCT_ARRAY(i, FM_KG_NUM_OF_GENERIC_REGS)
-        {
-            DUMP_MEMORY(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->schemeRegs.kgse_gec[i], sizeof(uint32_t));
-        }
-
-        DUMP_VAR(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->schemeRegs,kgse_spc);
-        DUMP_VAR(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->schemeRegs,kgse_dv0);
-        DUMP_VAR(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->schemeRegs,kgse_dv1);
-        DUMP_VAR(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->schemeRegs,kgse_ccbs);
-        DUMP_VAR(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->schemeRegs,kgse_mv);
-    }
-    DUMP_SUBTITLE(("\n"));
-
-    for (i=0;i<FM_MAX_NUM_OF_PORTS;i++)
-    {
-        SW_PORT_INDX_TO_HW_PORT_ID(hardwarePortId, i);
-
-        tmpKgarReg = FmPcdKgBuildReadPortSchemeBindActionReg(hardwarePortId);
-
-        err = WriteKgarWait(p_FmPcd, tmpKgarReg);
-        if (err)
-            RETURN_ERROR(MINOR, err, NO_MSG);
-
-        DUMP_TITLE(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->portRegs, ("FmPcdKgIndirectAccessPortRegs PCD Port %d regs", hardwarePortId));
-
-        DUMP_VAR(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->portRegs, fmkg_pe_sp);
-        DUMP_VAR(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->portRegs, fmkg_pe_cpp);
-    }
-
-    DUMP_SUBTITLE(("\n"));
-    for (j=0;j<FM_PCD_MAX_NUM_OF_CLS_PLANS/CLS_PLAN_NUM_PER_GRP;j++)
-    {
-        DUMP_TITLE(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->clsPlanRegs, ("FmPcdKgIndirectAccessClsPlanRegs Regs group %d", j));
-        DUMP_TITLE(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->clsPlanRegs.kgcpe, ("kgcpe"));
-
-        tmpKgarReg = ReadClsPlanBlockActionReg((uint8_t)j);
-        err = WriteKgarWait(p_FmPcd, tmpKgarReg);
-        if (err)
-            RETURN_ERROR(MINOR, err, NO_MSG);
-        DUMP_SUBSTRUCT_ARRAY(i, 8)
-            DUMP_MEMORY(&p_FmPcd->p_FmPcdKg->p_IndirectAccessRegs->clsPlanRegs.kgcpe[i], sizeof(uint32_t));
-    }
-    KgHwUnlock(p_FmPcd->p_FmPcdKg, intFlags);
-
-    return E_OK;
-}
-#endif /* (defined(DEBUG_ERRORS) && ... */
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_pcd.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_pcd.c
index 4adf9a1..1534331 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_pcd.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_pcd.c
@@ -1752,41 +1752,6 @@ uint32_t FM_PCD_GetCounter(t_Handle h_FmPcd, e_FmPcdCounters counter)
     return 0;
 }
 
-#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0))
-t_Error FM_PCD_DumpRegs(t_Handle h_FmPcd)
-{
-    t_FmPcd             *p_FmPcd = (t_FmPcd*)h_FmPcd;
-    t_Error             err = E_OK;
-
-    DECLARE_DUMP;
-
-    SANITY_CHECK_RETURN_ERROR(h_FmPcd, E_INVALID_HANDLE);
-    SANITY_CHECK_RETURN_ERROR(!p_FmPcd->p_FmPcdDriverParam, E_INVALID_STATE);
-
-    if (p_FmPcd->p_FmPcdKg)
-        err |= FM_PCD_KgDumpRegs(h_FmPcd);
-    if (p_FmPcd->p_FmPcdPlcr)
-        err |= FM_PCD_PlcrDumpRegs(h_FmPcd);
-    if (p_FmPcd->p_FmPcdPrs)
-        err |= FM_PCD_PrsDumpRegs(h_FmPcd);
-
-    return err;
-}
-
-t_Error FM_PCD_HcDumpRegs(t_Handle h_FmPcd)
-{
-    t_FmPcd             *p_FmPcd = (t_FmPcd*)h_FmPcd;
-
-    DECLARE_DUMP;
-
-    SANITY_CHECK_RETURN_ERROR(h_FmPcd, E_INVALID_HANDLE);
-    SANITY_CHECK_RETURN_ERROR(!p_FmPcd->p_FmPcdDriverParam, E_INVALID_STATE);
-    SANITY_CHECK_RETURN_ERROR(p_FmPcd->h_Hc, E_INVALID_STATE);
-
-    return FmHcDumpRegs(p_FmPcd->h_Hc);
-}
-#endif /* (defined(DEBUG_ERRORS) && ... */
-
 t_Error FM_PCD_SetException(t_Handle h_FmPcd, e_FmPcdExceptions exception, bool enable)
 {
     t_FmPcd         *p_FmPcd = (t_FmPcd*)h_FmPcd;
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_plcr.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_plcr.c
index a28b363..f0f1676 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_plcr.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_plcr.c
@@ -1532,52 +1532,6 @@ t_Error FM_PCD_SetPlcrStatistics(t_Handle h_FmPcd, bool enable)
     return E_OK;
 }
 
-/* ... */
-#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0))
-t_Error FM_PCD_PlcrDumpRegs(t_Handle h_FmPcd)
-{
-    t_FmPcd             *p_FmPcd = (t_FmPcd*)h_FmPcd;
-    int                 i = 0;
-
-    DECLARE_DUMP;
-
-    SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE);
-    SANITY_CHECK_RETURN_ERROR(p_FmPcd->p_FmPcdPlcr, E_INVALID_HANDLE);
-    SANITY_CHECK_RETURN_ERROR(!p_FmPcd->p_FmPcdDriverParam, E_INVALID_STATE);
-    SANITY_CHECK_RETURN_ERROR(((p_FmPcd->guestId == NCSW_MASTER_ID) ||
-                               p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs), E_INVALID_OPERATION);
-
-    DUMP_SUBTITLE(("\n"));
-    DUMP_TITLE(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs, ("FM-PCD policer regs"));
-
-    DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_gcr);
-    DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_gsr);
-    DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_evr);
-    DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_ier);
-    DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_ifr);
-    DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_eevr);
-    DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_eier);
-    DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_eifr);
-    DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_rpcnt);
-    DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_ypcnt);
-    DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_rrpcnt);
-    DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_rypcnt);
-    DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_tpcnt);
-    DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_flmcnt);
-    DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_serc);
-    DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_upcr);
-    DUMP_VAR(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs,fmpl_dpmr);
-
-    DUMP_TITLE(&p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_pmr, ("fmpl_pmr"));
-    DUMP_SUBSTRUCT_ARRAY(i, 63)
-    {
-        DUMP_MEMORY(&p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->fmpl_pmr[i], sizeof(uint32_t));
-    }
-
-    return E_OK;
-}
-#endif /* (defined(DEBUG_ERRORS) && ... */
-
 t_Handle FM_PCD_PlcrProfileSet(t_Handle     h_FmPcd,
                                t_FmPcdPlcrProfileParams *p_ProfileParams)
 {
@@ -1890,54 +1844,3 @@ t_Error FM_PCD_PlcrProfileSetCounter(t_Handle h_Profile, e_FmPcdPlcrProfileCount
 
     return E_OK;
 }
-
-#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0))
-t_Error FM_PCD_PlcrProfileDumpRegs(t_Handle h_Profile)
-{
-    t_FmPcdPlcrProfile                  *p_Profile = (t_FmPcdPlcrProfile*)h_Profile;
-    t_FmPcd                             *p_FmPcd;
-    t_FmPcdPlcrProfileRegs              *p_ProfilesRegs;
-    uint16_t                            profileIndx;
-    uint32_t                            tmpReg, intFlags;
-
-    DECLARE_DUMP;
-
-    SANITY_CHECK_RETURN_ERROR(p_Profile, E_INVALID_HANDLE);
-    p_FmPcd = p_Profile->h_FmPcd;
-    SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE);
-    SANITY_CHECK_RETURN_ERROR(p_FmPcd->p_FmPcdPlcr, E_INVALID_HANDLE);
-
-    profileIndx = p_Profile->absoluteProfileId;
-
-    DUMP_SUBTITLE(("\n"));
-    DUMP_TITLE(p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs, ("FM-PCD policer-profile regs"));
-
-    p_ProfilesRegs = &p_FmPcd->p_FmPcdPlcr->p_FmPcdPlcrRegs->profileRegs;
-
-    tmpReg = FmPcdPlcrBuildReadPlcrActionReg((uint16_t)profileIndx);
-    intFlags = PlcrHwLock(p_FmPcd->p_FmPcdPlcr);
-    WritePar(p_FmPcd, tmpReg);
-
-    DUMP_TITLE(p_ProfilesRegs, ("Profile %d regs", profileIndx));
-
-    DUMP_VAR(p_ProfilesRegs, fmpl_pemode);
-    DUMP_VAR(p_ProfilesRegs, fmpl_pegnia);
-    DUMP_VAR(p_ProfilesRegs, fmpl_peynia);
-    DUMP_VAR(p_ProfilesRegs, fmpl_pernia);
-    DUMP_VAR(p_ProfilesRegs, fmpl_pecir);
-    DUMP_VAR(p_ProfilesRegs, fmpl_pecbs);
-    DUMP_VAR(p_ProfilesRegs, fmpl_pepepir_eir);
-    DUMP_VAR(p_ProfilesRegs, fmpl_pepbs_ebs);
-    DUMP_VAR(p_ProfilesRegs, fmpl_pelts);
-    DUMP_VAR(p_ProfilesRegs, fmpl_pects);
-    DUMP_VAR(p_ProfilesRegs, fmpl_pepts_ets);
-    DUMP_VAR(p_ProfilesRegs, fmpl_pegpc);
-    DUMP_VAR(p_ProfilesRegs, fmpl_peypc);
-    DUMP_VAR(p_ProfilesRegs, fmpl_perpc);
-    DUMP_VAR(p_ProfilesRegs, fmpl_perypc);
-    DUMP_VAR(p_ProfilesRegs, fmpl_perrpc);
-    PlcrHwUnlock(p_FmPcd->p_FmPcdPlcr, intFlags);
-
-    return E_OK;
-}
-#endif /* (defined(DEBUG_ERRORS) && ... */
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_prs.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_prs.c
index e6ac6df..da2fccf 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_prs.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Pcd/fm_prs.c
@@ -418,49 +418,3 @@ t_Error FM_PCD_ConfigPrsMaxCycleLimit(t_Handle h_FmPcd,uint16_t value)
 
     return E_OK;
 }
-
-#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0))
-t_Error FM_PCD_PrsDumpRegs(t_Handle h_FmPcd)
-{
-    t_FmPcd             *p_FmPcd = (t_FmPcd*)h_FmPcd;
-
-    DECLARE_DUMP;
-
-    SANITY_CHECK_RETURN_ERROR(p_FmPcd, E_INVALID_HANDLE);
-    SANITY_CHECK_RETURN_ERROR(p_FmPcd->p_FmPcdPrs, E_INVALID_HANDLE);
-    SANITY_CHECK_RETURN_ERROR(!p_FmPcd->p_FmPcdDriverParam, E_INVALID_STATE);
-    SANITY_CHECK_RETURN_ERROR(((p_FmPcd->guestId == NCSW_MASTER_ID) ||
-                               p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs), E_INVALID_OPERATION);
-
-    DUMP_SUBTITLE(("\n"));
-    DUMP_TITLE(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs, ("FM-PCD parser regs"));
-
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_rpclim);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_rpimac);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,pmeec);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_pevr);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_pever);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_perr);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_perer);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_ppsc);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_pds);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_l2rrs);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_l3rrs);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_l4rrs);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_srrs);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_l2rres);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_l3rres);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_l4rres);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_srres);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_spcs);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_spscs);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_hxscs);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_mrcs);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_mwcs);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_mrscs);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_mwscs);
-    DUMP_VAR(p_FmPcd->p_FmPcdPrs->p_FmPcdPrsRegs,fmpr_fcscs);
-
-    return E_OK;
-}
-#endif /* (defined(DEBUG_ERRORS) && ... */
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Port/fm_port.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Port/fm_port.c
index 56f9f80..379406e 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Port/fm_port.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Port/fm_port.c
@@ -5496,271 +5496,6 @@ t_Error FM_PORT_PcdPrsModifyStartOffset(t_Handle h_FmPort,
     return E_OK;
 }
 
-#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0))
-t_Error FM_PORT_DumpRegs(t_Handle h_FmPort)
-{
-    t_FmPort *p_FmPort = (t_FmPort*)h_FmPort;
-    t_Error err = E_OK;
-    char arr[20];
-    uint8_t flag;
-    int i=0;
-
-    DECLARE_DUMP;
-
-    SANITY_CHECK_RETURN_ERROR(h_FmPort, E_INVALID_HANDLE);
-    SANITY_CHECK_RETURN_ERROR(!p_FmPort->p_FmPortDriverParam, E_INVALID_STATE);
-    SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortQmiRegs, E_INVALID_HANDLE);
-    SANITY_CHECK_RETURN_ERROR(p_FmPort->p_FmPortBmiRegs, E_INVALID_HANDLE);
-
-    memset(arr, 0, sizeof(arr));
-    switch (p_FmPort->portType)
-    {
-        case (e_FM_PORT_TYPE_OH_OFFLINE_PARSING):
-            strcpy(arr, "OFFLINE-PARSING");
-            flag = 0;
-            break;
-        case (e_FM_PORT_TYPE_OH_HOST_COMMAND):
-            strcpy(arr, "HOST-COMMAND");
-            flag = 0;
-            break;
-        case (e_FM_PORT_TYPE_RX):
-            strcpy(arr, "RX");
-            flag = 1;
-            break;
-        case (e_FM_PORT_TYPE_RX_10G):
-            strcpy(arr, "RX-10G");
-            flag = 1;
-            break;
-        case (e_FM_PORT_TYPE_TX):
-            strcpy(arr, "TX");
-            flag = 2;
-            break;
-        case (e_FM_PORT_TYPE_TX_10G):
-            strcpy(arr, "TX-10G");
-            flag = 2;
-            break;
-        default:
-            return ERROR_CODE(E_INVALID_VALUE);
-    }
-
-    DUMP_TITLE(NULL,
-            ("FMan-Port (%s #%d) registers:",
-                    arr, p_FmPort->portId));
-
-    err = FmDumpPortRegs(p_FmPort->h_Fm, p_FmPort->hardwarePortId);
-    if (err)
-        RETURN_ERROR(MAJOR, err, NO_MSG);
-
-    DUMP_TITLE(p_FmPort->p_FmPortBmiRegs, ("Bmi Port Regs"));
-
-    switch (flag)
-    {
-        case (0):
-            DUMP_SUBTITLE(("\n"));
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ocfg);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ost);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_oda);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_oicp);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofdne);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofne);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofca);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofpne);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_opso);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_opp);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_occb);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_oim);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofp);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofed);
-
-            DUMP_TITLE(&(p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_oprai), ("fmbm_oprai"));
-            DUMP_SUBSTRUCT_ARRAY(i, FM_PORT_PRS_RESULT_NUM_OF_WORDS)
-            {
-                DUMP_MEMORY(&(p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_oprai[i]), sizeof(uint32_t));
-            }
-            DUMP_SUBTITLE(("\n"));
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofqid );
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_oefqid);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofsdm );
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofsem );
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofene );
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_orlmts);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_orlmt);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ocmne);
-            {
-    #ifndef FM_NO_OP_OBSERVED_POOLS
-                if (p_FmPort->fmRevInfo.majorRev == 4)
-                {
-                    DUMP_TITLE(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_oebmpi, ("fmbm_oebmpi"));
-
-                    DUMP_SUBSTRUCT_ARRAY(i, FM_PORT_MAX_NUM_OF_OBSERVED_EXT_POOLS)
-                    {
-                        DUMP_MEMORY(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_oebmpi[i], sizeof(uint32_t));
-                    }
-                    DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ocgm);
-                }
-    #endif /* !FM_NO_OP_OBSERVED_POOLS */
-            }
-
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ostc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofrc );
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofdc );
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofledc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofufdc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_offc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofwdc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofldec);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_obdc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_opc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_opcp);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_occn);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_otuc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_oduc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ofuc);
-            DUMP_TITLE(&(p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_odcfg), ("fmbm_odcfg"));
-            DUMP_SUBSTRUCT_ARRAY(i, 3)
-            {
-                DUMP_MEMORY(&(p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs.fmbm_odcfg[i]), sizeof(uint32_t));
-            }
-            DUMP_SUBTITLE(("\n"));
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->ohPortBmiRegs,fmbm_ogpr);
-            break;
-
-        case (1):
-            DUMP_SUBTITLE(("\n"));
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rcfg);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rst);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rda);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfp);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_reth);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfed);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_ricp);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rebm);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfne);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfca);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfpne);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rpso);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rpp);
-
-            DUMP_TITLE(&(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rprai), ("fmbm_rprai"));
-            DUMP_SUBSTRUCT_ARRAY(i, FM_PORT_PRS_RESULT_NUM_OF_WORDS)
-            {
-                DUMP_MEMORY(&(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rprai[i]), sizeof(uint32_t));
-            }
-            DUMP_SUBTITLE(("\n"));
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfqid);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_refqid);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfsdm);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfsem);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfene);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rcmne);
-            DUMP_TITLE(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_ebmpi, ("fmbm_ebmpi"));
-            DUMP_SUBSTRUCT_ARRAY(i, FM_PORT_MAX_NUM_OF_EXT_POOLS)
-            {
-                DUMP_MEMORY(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_ebmpi[i], sizeof(uint32_t));
-            }
-            DUMP_TITLE(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_acnt, ("fmbm_acnt"));
-            DUMP_SUBSTRUCT_ARRAY(i, FM_PORT_MAX_NUM_OF_EXT_POOLS)
-            {
-                DUMP_MEMORY(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_acnt[i], sizeof(uint32_t));
-            }
-            DUMP_TITLE(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rcgm, ("fmbm_rcgm"));
-            DUMP_SUBSTRUCT_ARRAY(i, FM_PORT_NUM_OF_CONGESTION_GRPS/32)
-            {
-                DUMP_MEMORY(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rcgm[i], sizeof(uint32_t));
-            }
-            DUMP_SUBTITLE(("\n"));
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rmpd);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rstc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfrc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfbc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rlfc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rffc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfcd);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfldec);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rodc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rpc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rpcp);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rccn);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rtuc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rrquc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rduc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rfuc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rpac);
-            DUMP_TITLE(&(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rdcfg), ("fmbm_rdcfg"));
-            DUMP_SUBSTRUCT_ARRAY(i, 3)
-            {
-                DUMP_MEMORY(&(p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs.fmbm_rdcfg[i]), sizeof(uint32_t));
-            }
-            DUMP_SUBTITLE(("\n"));
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->rxPortBmiRegs,fmbm_rgpr);
-            break;
-
-        case (2):
-            DUMP_SUBTITLE(("\n"));
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tcfg);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tst);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tda);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfp);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfed);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_ticp);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfdne);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfca);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tcfqid);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfeqid);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfene);
-    #if (DPAA_VERSION >= 11)
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfne);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tcmne);
-    #endif /* (DPAA_VERSION >= 11) */
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_trlmts);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_trlmt);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tstc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfrc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfdc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfledc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfufdc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tbdc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tpc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tpcp);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tccn);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_ttuc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_ttcquc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tduc);
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tfuc);
-            DUMP_TITLE(&(p_FmPort->p_FmPortBmiRegs->txPortBmiRegs.fmbm_tdcfg), ("fmbm_tdcfg"));
-            DUMP_SUBSTRUCT_ARRAY(i, 3)
-            {
-                DUMP_MEMORY(&(p_FmPort->p_FmPortBmiRegs->txPortBmiRegs.fmbm_tdcfg[i]), sizeof(uint32_t));
-            }
-            DUMP_SUBTITLE(("\n"));
-            DUMP_VAR(&p_FmPort->p_FmPortBmiRegs->txPortBmiRegs,fmbm_tgpr);
-            break;
-
-        default:
-        RETURN_ERROR(MAJOR, E_INVALID_STATE, ("Invalid flag"));
-    }
-
-    DUMP_TITLE(p_FmPort->p_FmPortQmiRegs, ("Qmi Port Regs"));
-
-    DUMP_VAR(p_FmPort->p_FmPortQmiRegs,fmqm_pnc);
-    DUMP_VAR(p_FmPort->p_FmPortQmiRegs,fmqm_pns);
-    DUMP_VAR(p_FmPort->p_FmPortQmiRegs,fmqm_pnts);
-    DUMP_VAR(p_FmPort->p_FmPortQmiRegs,fmqm_pnen);
-    DUMP_VAR(p_FmPort->p_FmPortQmiRegs,fmqm_pnetfc);
-
-    if (flag !=1)
-    {
-        DUMP_VAR(&p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs,fmqm_pndn);
-        DUMP_VAR(&p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs,fmqm_pndc);
-        DUMP_VAR(&p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs,fmqm_pndtfc);
-        DUMP_VAR(&p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs,fmqm_pndfdc);
-        DUMP_VAR(&p_FmPort->p_FmPortQmiRegs->nonRxQmiRegs,fmqm_pndcc);
-    }
-
-    return E_OK;
-}
-#endif /* (defined(DEBUG_ERRORS) && ... */
-
 t_Error FM_PORT_AddCongestionGrps(t_Handle h_FmPort,
                                   t_FmPortCongestionGrps *p_CongestionGrps)
 {
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Rtc/fm_rtc.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Rtc/fm_rtc.c
index b0bcf26..727d5c8 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/Rtc/fm_rtc.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/Rtc/fm_rtc.c
@@ -690,52 +690,3 @@ t_Error FM_RTC_DisableInterrupt(t_Handle h_FmRtc, uint32_t events)
 	return E_OK;
 }
 #endif
-
-/*****************************************************************************/
-#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0))
-t_Error FM_RTC_DumpRegs(t_Handle h_FmRtc)
-{
-    t_FmRtc         *p_Rtc = (t_FmRtc *)h_FmRtc;
-    struct rtc_regs   *p_MemMap = p_Rtc->p_MemMap;
-    int             i = 0;
-
-    DECLARE_DUMP;
-
-    if (p_MemMap)
-    {
-
-        DUMP_TITLE(p_MemMap, ("RTC:"));
-        DUMP_VAR(p_MemMap, tmr_id);
-        DUMP_VAR(p_MemMap, tmr_id2);
-        DUMP_VAR(p_MemMap, tmr_ctrl);
-        DUMP_VAR(p_MemMap, tmr_tevent);
-        DUMP_VAR(p_MemMap, tmr_temask);
-        DUMP_VAR(p_MemMap, tmr_cnt_h);
-        DUMP_VAR(p_MemMap, tmr_cnt_l);
-        DUMP_VAR(p_MemMap, tmr_ctrl);
-        DUMP_VAR(p_MemMap, tmr_add);
-        DUMP_VAR(p_MemMap, tmr_acc);
-        DUMP_VAR(p_MemMap, tmr_prsc);
-        DUMP_VAR(p_MemMap, tmr_off_h);
-        DUMP_VAR(p_MemMap, tmr_off_l);
-
-        DUMP_SUBSTRUCT_ARRAY(i, 2)
-        {
-            DUMP_VAR(p_MemMap, tmr_alarm[i].tmr_alarm_h);
-            DUMP_VAR(p_MemMap, tmr_alarm[i].tmr_alarm_l);
-        }
-        DUMP_SUBSTRUCT_ARRAY(i, 2)
-        {
-            DUMP_VAR(p_MemMap, tmr_fiper[i]);
-            DUMP_VAR(p_MemMap, tmr_fiper[i]);
-        }
-        DUMP_SUBSTRUCT_ARRAY(i, 2)
-        {
-            DUMP_VAR(p_MemMap, tmr_etts[i].tmr_etts_l);
-            DUMP_VAR(p_MemMap, tmr_etts[i].tmr_etts_l);
-        }
-    }
-
-    return E_OK;
-}
-#endif /* (defined(DEBUG_ERRORS) && ... */
diff --git a/drivers/net/ethernet/freescale/fman/Peripherals/FM/fm.c b/drivers/net/ethernet/freescale/fman/Peripherals/FM/fm.c
index fe05428..a1083a0 100644
--- a/drivers/net/ethernet/freescale/fman/Peripherals/FM/fm.c
+++ b/drivers/net/ethernet/freescale/fman/Peripherals/FM/fm.c
@@ -5084,139 +5084,6 @@ t_Error FM_CtrlMonGetCounters(t_Handle h_Fm, uint8_t fmCtrlIndex, t_FmCtrlMon *p
     return E_OK;
 }
 
-#if (defined(DEBUG_ERRORS) && (DEBUG_ERRORS > 0))
-t_Error FM_DumpRegs(t_Handle h_Fm)
-{
-    t_Fm            *p_Fm = (t_Fm *)h_Fm;
-    uint8_t         i,j = 0;
-    DECLARE_DUMP;
-    SANITY_CHECK_RETURN_ERROR(p_Fm, E_INVALID_HANDLE);
-    SANITY_CHECK_RETURN_ERROR(!p_Fm->p_FmDriverParam, E_INVALID_STATE);
-    SANITY_CHECK_RETURN_ERROR(((p_Fm->guestId == NCSW_MASTER_ID) ||
-                               p_Fm->baseAddr), E_INVALID_OPERATION);
-
-    DUMP_SUBTITLE(("\n"));
-
-    DUMP_TITLE(p_Fm->p_FmFpmRegs, ("FM-FPM Regs"));
-
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fmfp_tnc);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fmfp_prc);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fmfp_brkc);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fmfp_mxd);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fmfp_dist1);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fmfp_dist2);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fm_epi);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fm_rie);
-
-    DUMP_TITLE(&p_Fm->p_FmFpmRegs->fmfp_fcev, ("fmfp_fcev"));
-    DUMP_SUBSTRUCT_ARRAY(i, 4)
-    {
-        DUMP_MEMORY(&p_Fm->p_FmFpmRegs->fmfp_fcev[i], sizeof(uint32_t));
-    }
-
-    DUMP_TITLE(&p_Fm->p_FmFpmRegs->fmfp_cee, ("fmfp_cee"));
-    DUMP_SUBSTRUCT_ARRAY(i, 4)
-    {
-        DUMP_MEMORY(&p_Fm->p_FmFpmRegs->fmfp_cee[i], sizeof(uint32_t));
-    }
-
-    DUMP_SUBTITLE(("\n"));
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fmfp_tsc1);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fmfp_tsc2);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fmfp_tsp);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fmfp_tsf);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fm_rcr);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fmfp_extc);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fmfp_ext1);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fmfp_ext2);
-
-    DUMP_SUBTITLE(("\n"));
-    WRITE_UINT32(p_Fm->p_FmFpmRegs->fmfp_dra, 0);
-    CORE_MemoryBarrier();
-    for (j=0; j<128; j++)
-    {
-        DUMP_TITLE(j, ("fmfp_dra"));
-        DUMP_SUBSTRUCT_ARRAY(i, 4)
-        {
-            DUMP_MEMORY(&p_Fm->p_FmFpmRegs->fmfp_drd[i], sizeof(uint32_t));
-        }
-        DUMP_TITLE(j, ("fmfp_ts"));
-        DUMP_MEMORY(&p_Fm->p_FmFpmRegs->fmfp_ts[j], sizeof(uint32_t));
-    }
-
-    DUMP_SUBTITLE(("\n"));
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fm_ip_rev_1);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fm_ip_rev_2);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fm_rstc);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fm_cld);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fm_npi);
-    DUMP_VAR(p_Fm->p_FmFpmRegs,fmfp_ee);
-
-    DUMP_TITLE(&p_Fm->p_FmFpmRegs->fmfp_cev, ("fmfp_cev"));
-    DUMP_SUBSTRUCT_ARRAY(i, 4)
-    {
-        DUMP_MEMORY(&p_Fm->p_FmFpmRegs->fmfp_cev[i], sizeof(uint32_t));
-    }
-
-    DUMP_TITLE(&p_Fm->p_FmFpmRegs->fmfp_ps, ("fmfp_ps"));
-    DUMP_SUBSTRUCT_ARRAY(i, 64)
-    {
-        DUMP_MEMORY(&p_Fm->p_FmFpmRegs->fmfp_ps[i], sizeof(uint32_t));
-    }
-
-    DUMP_TITLE(p_Fm->p_FmDmaRegs, ("FM-DMA Regs"));
-    DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmsr);
-    DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmemsr);
-    DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmmr);
-    DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmtr);
-    DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmhy);
-    DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmsetr);
-    DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmtah);
-    DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmtal);
-    DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmtcid);
-    DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmra);
-    DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmrd);
-    DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmwcr);
-    DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmebcr);
-    DUMP_VAR(p_Fm->p_FmDmaRegs,fmdmdcr);
-
-    DUMP_TITLE(&p_Fm->p_FmDmaRegs->fmdmplr, ("fmdmplr"));
-
-    DUMP_SUBSTRUCT_ARRAY(i, FM_MAX_NUM_OF_HW_PORT_IDS/2)
-    {
-        DUMP_MEMORY(&p_Fm->p_FmDmaRegs->fmdmplr[i], sizeof(uint32_t));
-    }
-
-    DUMP_TITLE(p_Fm->p_FmBmiRegs, ("FM-BMI COMMON Regs"));
-    DUMP_VAR(p_Fm->p_FmBmiRegs,fmbm_init);
-    DUMP_VAR(p_Fm->p_FmBmiRegs,fmbm_cfg1);
-    DUMP_VAR(p_Fm->p_FmBmiRegs,fmbm_cfg2);
-    DUMP_VAR(p_Fm->p_FmBmiRegs,fmbm_ievr);
-    DUMP_VAR(p_Fm->p_FmBmiRegs,fmbm_ier);
-
-    DUMP_TITLE(&p_Fm->p_FmBmiRegs->fmbm_arb, ("fmbm_arb"));
-    DUMP_SUBSTRUCT_ARRAY(i, 8)
-    {
-        DUMP_MEMORY(&p_Fm->p_FmBmiRegs->fmbm_arb[i], sizeof(uint32_t));
-    }
-
-    DUMP_TITLE(p_Fm->p_FmQmiRegs, ("FM-QMI COMMON Regs"));
-    DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_gc);
-    DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_eie);
-    DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_eien);
-    DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_eif);
-    DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_ie);
-    DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_ien);
-    DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_if);
-    DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_gs);
-    DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_etfc);
-    DUMP_VAR(p_Fm->p_FmQmiRegs,fmqm_tapc);
-
-    return E_OK;
-}
-#endif /* (defined(DEBUG_ERRORS) && ... */
-
-
 
 /****************************************************/
 /*       Hidden-DEBUG Only API                      */
diff --git a/drivers/net/ethernet/freescale/fman/inc/ctype_ext.h b/drivers/net/ethernet/freescale/fman/inc/ctype_ext.h
deleted file mode 100644
index e3d5d8d..0000000
--- a/drivers/net/ethernet/freescale/fman/inc/ctype_ext.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * Copyright 2008-2012 Freescale Semiconductor Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of Freescale Semiconductor nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- *
- * ALTERNATIVELY, this software may be distributed under the terms of the
- * GNU General Public License ("GPL") as published by the Free Software
- * Foundation, either version 2 of that License or (at your option) any
- * later version.
- *
- * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-
-#ifndef __CTYPE_EXT_H
-#define __CTYPE_EXT_H
-
-
-#if defined(NCSW_LINUX) && defined(__KERNEL__)
-/*
- * NOTE! This ctype does not handle EOF like the standard C
- * library is required to.
- */
-
-#define _U    0x01    /* upper */
-#define _L    0x02    /* lower */
-#define _D    0x04    /* digit */
-#define _C    0x08    /* cntrl */
-#define _P    0x10    /* punct */
-#define _S    0x20    /* white space (space/lf/tab) */
-#define _X    0x40    /* hex digit */
-#define _SP   0x80    /* hard space (0x20) */
-
-extern unsigned char _ctype[];
-
-#define __ismask(x) (_ctype[(int)(unsigned char)(x)])
-
-#define isalnum(c)    ((__ismask(c)&(_U|_L|_D)) != 0)
-#define isalpha(c)    ((__ismask(c)&(_U|_L)) != 0)
-#define iscntrl(c)    ((__ismask(c)&(_C)) != 0)
-#define isdigit(c)    ((__ismask(c)&(_D)) != 0)
-#define isgraph(c)    ((__ismask(c)&(_P|_U|_L|_D)) != 0)
-#define islower(c)    ((__ismask(c)&(_L)) != 0)
-#define isprint(c)    ((__ismask(c)&(_P|_U|_L|_D|_SP)) != 0)
-#define ispunct(c)    ((__ismask(c)&(_P)) != 0)
-#define isspace(c)    ((__ismask(c)&(_S)) != 0)
-#define isupper(c)    ((__ismask(c)&(_U)) != 0)
-#define isxdigit(c)   ((__ismask(c)&(_D|_X)) != 0)
-
-#define isascii(c) (((unsigned char)(c))<=0x7f)
-#define toascii(c) (((unsigned char)(c))&0x7f)
-
-static __inline__ unsigned char __tolower(unsigned char c)
-{
-    if (isupper(c))
-        c -= 'A'-'a';
-    return c;
-}
-
-static __inline__ unsigned char __toupper(unsigned char c)
-{
-    if (islower(c))
-        c -= 'a'-'A';
-    return c;
-}
-
-#define tolower(c) __tolower(c)
-#define toupper(c) __toupper(c)
-
-#else
-#include <ctype.h>
-#endif /* defined(NCSW_LINUX) && defined(__KERNEL__) */
-
-
-#endif /* __CTYPE_EXT_H */
diff --git a/drivers/net/ethernet/freescale/fman/src/xx/Makefile b/drivers/net/ethernet/freescale/fman/src/xx/Makefile
index 7199b57..3d832a4 100644
--- a/drivers/net/ethernet/freescale/fman/src/xx/Makefile
+++ b/drivers/net/ethernet/freescale/fman/src/xx/Makefile
@@ -8,5 +8,5 @@ include $(srctree)/drivers/net/ethernet/freescale/fman/ncsw_config.mk
 
 obj-y		+= fsl-ncsw-xx.o
 
-fsl-ncsw-xx-objs	:=   xx_linux.o  stdlib.o \
+fsl-ncsw-xx-objs	:=   xx_linux.o \
 				module_strings.o
diff --git a/drivers/net/ethernet/freescale/fman/src/xx/stdlib.c b/drivers/net/ethernet/freescale/fman/src/xx/stdlib.c
deleted file mode 100644
index 851bcf1..0000000
--- a/drivers/net/ethernet/freescale/fman/src/xx/stdlib.c
+++ /dev/null
@@ -1,264 +0,0 @@
-/*
- * Copyright 2008-2012 Freescale Semiconductor Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of Freescale Semiconductor nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- *
- * ALTERNATIVELY, this software may be distributed under the terms of the
- * GNU General Public License ("GPL") as published by the Free Software
- * Foundation, either version 2 of that License or (at your option) any
- * later version.
- *
- * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*------------------------------------------------------*/
-/*                                                      */
-/* File: stdlib.c                                       */
-/*                                                      */
-/* Description:                                         */
-/*    Standard library routines (externals)             */
-/*                                                      */
-/* Modifications:                                       */
-/* ==============                                       */
-/*                                                      */
-/*------------------------------------------------------*/
-#include "stdlib_ext.h"
-#include "stdarg_ext.h"
-#include "ctype_ext.h"
-#include "string_ext.h"
-#include "std_ext.h"
-#include "xx_ext.h"
-
-
-#ifdef MODULE
-/**
- * strtoul - convert a string to an uint32_t
- * @cp: The start of the string
- * @endp: A pointer to the end of the parsed string will be placed here
- * @base: The number base to use
- */
-uint32_t strtoul(const char *cp,char **endp,uint32_t base)
-{
-    uint32_t result = 0,value;
-
-    if (!base) {
-        base = 10;
-        if (*cp == '0') {
-            base = 8;
-            cp++;
-            if ((*cp == 'x') && isxdigit(cp[1])) {
-                cp++;
-                base = 16;
-            }
-        }
-    }
-    while (isxdigit(*cp) &&
-           (value = (uint32_t)(isdigit(*cp) ? *cp-'0' : toupper((uint8_t)(*cp))-'A'+10)) < base) {
-        result = result*base + value;
-        cp++;
-    }
-    if (endp)
-        *endp = (char *)cp;
-    return result;
-}
-
-/**
- * strtol - convert a string to a int32_t
- * @cp: The start of the string
- * @endp: A pointer to the end of the parsed string will be placed here
- * @base: The number base to use
- */
-long strtol(const char *cp,char **endp,uint32_t base)
-{
-    if(*cp=='-')
-        return (long)(-strtoul(cp+1,endp,base));
-    return (long)strtoul(cp,endp,base);
-}
-
-/**
- * strtoull - convert a string to an uint64_t
- * @cp: The start of the string
- * @endp: A pointer to the end of the parsed string will be placed here
- * @base: The number base to use
- */
-uint64_t strtoull(const char *cp,char **endp,uint32_t base)
-{
-    uint64_t result = 0,value;
-
-    if (!base) {
-        base = 10;
-        if (*cp == '0') {
-            base = 8;
-            cp++;
-            if ((*cp == 'x') && isxdigit(cp[1])) {
-                cp++;
-                base = 16;
-            }
-        }
-    }
-    while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp-'0' : (islower(*cp)
-        ? toupper((uint8_t)(*cp)) : *cp)-'A'+10) < base) {
-        result = result*base + value;
-        cp++;
-    }
-    if (endp)
-        *endp = (char *)cp;
-    return result;
-}
-
-/**
- * strtoll - convert a string to a int64
- * @cp: The start of the string
- * @endp: A pointer to the end of the parsed string will be placed here
- * @base: The number base to use
- */
-long long strtoll(const char *cp,char **endp,uint32_t base)
-{
-    if(*cp=='-')
-        return (long long)(-strtoull(cp+1,endp,base));
-    return (long long)(strtoull(cp,endp,base));
-}
-
-/**
- * atoi - convert a string to a int
- * @s: The start of the string
- */
-int atoi(const char *s)
-{
-    int i=0;
-    const char **tmp_s = &s;
-
-    while (isdigit(**tmp_s))
-        i = i*10 + *((*tmp_s)++) - '0';
-    return i;
-}
-
-/**
- * strlen - Find the length of a string
- * @s: The string to be sized
- */
-size_t strlen(const char * s)
-{
-    const char *sc;
-
-    for (sc = s; *sc != '\0'; ++sc)
-        /* nothing */;
-
-    return sc - s;
-}
-
-/**
- * strnlen - Find the length of a length-limited string
- * @s: The string to be sized
- * @count: The maximum number of bytes to search
- */
-size_t strnlen(const char * s, size_t count)
-{
-    const char *sc;
-
-    for (sc = s; count-- && *sc != '\0'; ++sc)
-        /* nothing */;
-
-    return sc - s;
-}
-
-/**
- * strcpy - Copy a %NUL terminated string
- * @dest: Where to copy the string to
- * @src: Where to copy the string from
- */
-char * strcpy(char * dest,const char *src)
-{
-    char *tmp = dest;
-
-    while ((*dest++ = *src++) != '\0')
-        /* nothing */;
-
-    return tmp;
-}
-#endif /* MODULE */
-
-/**
- * strtok - Split a string into tokens
- * @s: The string to be searched
- * @ct: The characters to search for
- *
- * WARNING: strtok is deprecated, use strsep instead.
- */
-char *___strtok;
-
-char * strtok(char * s,const char * ct)
-{
-    char *sbegin, *send;
-
-    sbegin  = s ? s : ___strtok;
-    if (!sbegin) {
-        return NULL;
-    }
-    sbegin += strspn(sbegin,ct);
-    if (*sbegin == '\0') {
-        ___strtok = NULL;
-        return( NULL );
-    }
-    send = strpbrk( sbegin, ct);
-    if (send && *send != '\0')
-        *send++ = '\0';
-    ___strtok = send;
-    return (sbegin);
-}
-
-
-#ifdef MODULE
-/**
- * strncpy - Copy a length-limited, %NUL-terminated string
- * @dest: Where to copy the string to
- * @src: Where to copy the string from
- * @count: The maximum number of bytes to copy
- *
- * Note that unlike userspace strncpy, this does not %NUL-pad the buffer.
- * However, the result is not %NUL-terminated if the source exceeds
- * @count bytes.
- */
-char * strncpy(char * dest,const char *src,size_t count)
-{
-    char *tmp = dest;
-
-    while (count-- && (*dest++ = *src++) != '\0')
-        /* nothing */;
-
-    return tmp;
-}
-
-/**
- * vsprintf - Format a string and place it in a buffer
- * @buf: The buffer to place the result into
- * @fmt: The format string to use
- * @args: Arguments for the format string
- *
- * Call this function if you are already dealing with a va_list.
- * You probably want sprintf instead.
- */
-int vsprintf(char *buf, const char *fmt, va_list args)
-{
-    return vsnprintf(buf, INT32_MAX, fmt, args);
-}
-#endif /* MODULE */