rem: DEBUGOUT("Flow Control = TX PAUSE frames only.\r\n");
add: HW_DEBUGOUT("Flow Control = TX PAUSE frames only.");
context: em_config_fc_after_link_up(struct em_hw *hw){    int32_t ret_val;    uint16_t mii_status_reg;    uint16_t mii_nway_adv_reg;    uint16_t mii_nway_lp_ability_reg;    uint16_t speed;    uint16_t duplex;    DEBUGFUNC("em_config_fc_after_link_up");    /* Check for the case where we have fiber media and auto-neg failed     * so we had to force link.  In this case, we need to force the     * configuration of the MAC to match the "fc" parameter.     */    if(((hw->media_type == em_media_type_fiber) && (hw->autoneg_failed)) ||       ((hw->media_type == em_media_type_internal_serdes) && (hw->autoneg_failed)) ||       ((hw->media_type == em_media_type_copper) && (!hw->autoneg))) {        if((ret_val = em_force_mac_fc(hw))) {            DEBUGOUT("Error forcing flow control settings\n");            return ret_val;        }    }    /* Check for the case where we have copper media and auto-neg is     * enabled.  In this case, we need to check and see if Auto-Neg     * has completed, and if so, how the PHY and link partner has     * flow control configured.     */    if((hw->media_type == em_media_type_copper) && hw->autoneg) {        /* Read the MII Status Register and check to see if AutoNeg         * has completed.  We read this twice because this reg has         * some "sticky" (latched) bits.         */        if((ret_val = em_read_phy_reg(hw, PHY_STATUS, &mii_status_reg)))            return ret_val;        if((ret_val = em_read_phy_reg(hw, PHY_STATUS, &mii_status_reg)))            return ret_val;        if(mii_status_reg & MII_SR_AUTONEG_COMPLETE) {            /* The AutoNeg process has completed, so we now need to             * read both the Auto Negotiation Advertisement Register             * (Address 4) and the Auto_Negotiation Base Page Ability             * Register (Address 5) to determine how flow control was             * negotiated.             */            if((ret_val = em_read_phy_reg(hw, PHY_AUTONEG_ADV,                                             &mii_nway_adv_reg)))                return ret_val;            if((ret_val = em_read_phy_reg(hw, PHY_LP_ABILITY,                                             &mii_nway_lp_ability_reg)))                return ret_val;            /* Two bits in the Auto Negotiation Advertisement Register             * (Address 4) and two bits in the Auto Negotiation Base             * Page Ability Register (Address 5) determine flow control             * for both the PHY and the link partner.  The following             * table, taken out of the IEEE 802.3ab/D6.0 dated March 25,             * 1999, describes these PAUSE resolution bits and how flow             * control is determined based upon these settings.             * NOTE:  DC = Don't Care             *             *   LOCAL DEVICE  |   LINK PARTNER             * PAUSE | ASM_DIR | PAUSE | ASM_DIR | NIC Resolution             *-------|---------|-------|---------|--------------------             *   0   |    0    |  DC   |   DC    | em_fc_none             *   0   |    1    |   0   |   DC    | em_fc_none             *   0   |    1    |   1   |    0    | em_fc_none             *   0   |    1    |   1   |    1    | em_fc_tx_pause             *   1   |    0    |   0   |   DC    | em_fc_none             *   1   |   DC    |   1   |   DC    | em_fc_full             *   1   |    1    |   0   |    0    | em_fc_none             *   1   |    1    |   0   |    1    | em_fc_rx_pause             *             */            /* Are both PAUSE bits set to 1?  If so, this implies             * Symmetric Flow Control is enabled at both ends.  The             * ASM_DIR bits are irrelevant per the spec.             *             * For Symmetric Flow Control:             *             *   LOCAL DEVICE  |   LINK PARTNER             * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result             *-------|---------|-------|---------|--------------------             *   1   |   DC    |   1   |   DC    | em_fc_full             *             */            if((mii_nway_adv_reg & NWAY_AR_PAUSE) &&               (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE)) {                /* Now we need to check if the user selected RX ONLY                 * of pause frames.  In this case, we had to advertise                 * FULL flow control because we could not advertise RX                 * ONLY. Hence, we must now check to see if we need to                 * turn OFF  the TRANSMISSION of PAUSE frames.                 */                if(hw->original_fc == em_fc_full) {                    hw->fc = em_fc_full;                    DEBUGOUT("Flow Control = FULL.\r\n");                } else {                    hw->fc = em_fc_rx_pause;                    DEBUGOUT("Flow Control = RX PAUSE frames only.\r\n");                }            }            /* For receiving PAUSE frames ONLY.             *             *   LOCAL DEVICE  |   LINK PARTNER             * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result             *-------|---------|-------|---------|--------------------             *   0   |    1    |   1   |    1    | em_fc_tx_pause             *             */            else if(!(mii_nway_adv_reg & NWAY_AR_PAUSE) &&                    (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&                    (mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&                    (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {                hw->fc = em_fc_tx_pause;                DEBUGOUT("Flow Control = TX PAUSE frames only.\r\n");            }            /* For transmitting PAUSE frames ONLY.             *             *   LOCAL DEVICE  |   LINK PARTNER             * PAUSE | ASM_DIR | PAUSE | ASM_DIR | Result             *-------|---------|-------|---------|--------------------             *   1   |    1    |   0   |    1    | em_fc_rx_pause             *             */            else if((mii_nway_adv_reg & NWAY_AR_PAUSE) &&                    (mii_nway_adv_reg & NWAY_AR_ASM_DIR) &&                    !(mii_nway_lp_ability_reg & NWAY_LPAR_PAUSE) &&                    (mii_nway_lp_ability_reg & NWAY_LPAR_ASM_DIR)) {                hw->fc = em_fc_rx_pause;                DEBUGOUT("Flow Control = RX PAUSE frames only.\r\n");            }            /* Per the IEEE spec, at this point flow control should be             * disabled.  However, we want to consider that we could             * be connected to a legacy switch that doesn't advertise             * desired flow control, but can be forced on the link             * partner.  So if we advertised no flow control, that is             * what we will resolve to.  If we advertised some kind of             * receive capability (Rx Pause Only or Full Flow Control)             * and the link partner advertised none, we will configure             * ourselves to enable Rx Flow Control only.  We can do             * this safely for two reasons:  If the link partner really             * didn't want flow control enabled, and we enable Rx, no             * harm done since we won't be receiving any PAUSE frames             * anyway.  If the intent on the link partner was to have             * flow control enabled, then by us enabling RX only, we             * can at least receive pause frames and process them.             * This is a good idea because in most cases, since we are             * predominantly a server NIC, more times than not we will             * be asked to delay transmission of packets than asking             * our link partner to pause transmission of frames.             */            else if((hw->original_fc == em_fc_none ||                     hw->original_fc == em_fc_tx_pause) ||                    hw->fc_strict_ieee) {                hw->fc = em_fc_none;                DEBUGOUT("Flow Control = NONE.\r\n");            } else {                hw->fc = em_fc_rx_pause;                DEBUGOUT("Flow Control = RX PAUSE frames only.\r\n");            }            /* Now we need to do one last check...  If we auto-             * negotiated to HALF DUPLEX, flow control should not be             * enabled per IEEE 802.3 spec.             */            if((ret_val = em_get_speed_and_duplex(hw, &speed, &duplex))) {                DEBUGOUT("Error getting link speed and duplex\n");                return ret_val;            }            if(duplex == HALF_DUPLEX)                hw->fc = em_fc_none;            /* Now we call a subroutine to actually force the MAC             * controller to use the correct flow control settings.             */            if((ret_val = em_force_mac_fc(hw))) {                DEBUGOUT("Error forcing flow control settings\n");                return ret_val;            }        } else {            DEBUGOUT("Copper PHY and Auto Neg has not completed.\r\n");        }    }    return E1000_SUCCESS;}