pch_gbe: convert pr_* to netdev_*

We may use nice macros to prefix our messages with proper device name.

Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

6 files changed, 250 insertions, 164 deletions

diff --git a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe.h b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe.h
index 7fb7e178c74e..7779036690cc 100644
--- a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe.h
+++ b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe.h
@@ -633,6 +633,8 @@ struct pch_gbe_adapter {
         struct pci_dev *ptp_pdev;
 };
 
+#define pch_gbe_hw_to_adapter(hw)       container_of(hw, struct pch_gbe_adapter, hw)
+
 extern const char pch_driver_version[];
 
 /* pch_gbe_main.c */
diff --git a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_api.c b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_api.c
index 82e72b21a8fb..ff3ad70935a6 100644
--- a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_api.c
+++ b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_api.c
@@ -71,7 +71,9 @@ static s32 pch_gbe_plat_init_hw(struct pch_gbe_hw *hw)
 
         ret_val = pch_gbe_phy_get_id(hw);
         if (ret_val) {
-                pr_err("pch_gbe_phy_get_id error\n");
+                struct pch_gbe_adapter *adapter = pch_gbe_hw_to_adapter(hw);
+
+                netdev_err(adapter->netdev, "pch_gbe_phy_get_id error\n");
                 return ret_val;
         }
         pch_gbe_phy_init_setting(hw);
@@ -116,7 +118,9 @@ static void pch_gbe_plat_init_function_pointers(struct pch_gbe_hw *hw)
 s32 pch_gbe_hal_setup_init_funcs(struct pch_gbe_hw *hw)
 {
         if (!hw->reg) {
-                pr_err("ERROR: Registers not mapped\n");
+                struct pch_gbe_adapter *adapter = pch_gbe_hw_to_adapter(hw);
+
+                netdev_err(adapter->netdev, "ERROR: Registers not mapped\n");
                 return -ENOSYS;
         }
         pch_gbe_plat_init_function_pointers(hw);
@@ -129,10 +133,13 @@ s32 pch_gbe_hal_setup_init_funcs(struct pch_gbe_hw *hw)
  */
 void pch_gbe_hal_get_bus_info(struct pch_gbe_hw *hw)
 {
-        if (!hw->func->get_bus_info)
-                pr_err("ERROR: configuration\n");
-        else
-                hw->func->get_bus_info(hw);
+        if (!hw->func->get_bus_info) {
+                struct pch_gbe_adapter *adapter = pch_gbe_hw_to_adapter(hw);
+
+                netdev_err(adapter->netdev, "ERROR: configuration\n");
+                return;
+        }
+        hw->func->get_bus_info(hw);
 }
 
 /**
@@ -145,7 +152,9 @@ void pch_gbe_hal_get_bus_info(struct pch_gbe_hw *hw)
 s32 pch_gbe_hal_init_hw(struct pch_gbe_hw *hw)
 {
         if (!hw->func->init_hw) {
-                pr_err("ERROR: configuration\n");
+                struct pch_gbe_adapter *adapter = pch_gbe_hw_to_adapter(hw);
+
+                netdev_err(adapter->netdev, "ERROR: configuration\n");
                 return -ENOSYS;
         }
         return hw->func->init_hw(hw);
@@ -191,10 +200,13 @@ s32 pch_gbe_hal_write_phy_reg(struct pch_gbe_hw *hw, u32 offset,
  */
 void pch_gbe_hal_phy_hw_reset(struct pch_gbe_hw *hw)
 {
-        if (!hw->func->reset_phy)
-                pr_err("ERROR: configuration\n");
-        else
-                hw->func->reset_phy(hw);
+        if (!hw->func->reset_phy) {
+                struct pch_gbe_adapter *adapter = pch_gbe_hw_to_adapter(hw);
+
+                netdev_err(adapter->netdev, "ERROR: configuration\n");
+                return;
+        }
+        hw->func->reset_phy(hw);
 }
 
 /**
@@ -203,10 +215,13 @@ void pch_gbe_hal_phy_hw_reset(struct pch_gbe_hw *hw)
  */
 void pch_gbe_hal_phy_sw_reset(struct pch_gbe_hw *hw)
 {
-        if (!hw->func->sw_reset_phy)
-                pr_err("ERROR: configuration\n");
-        else
-                hw->func->sw_reset_phy(hw);
+        if (!hw->func->sw_reset_phy) {
+                struct pch_gbe_adapter *adapter = pch_gbe_hw_to_adapter(hw);
+
+                netdev_err(adapter->netdev, "ERROR: configuration\n");
+                return;
+        }
+        hw->func->sw_reset_phy(hw);
 }
 
 /**
@@ -219,7 +234,9 @@ void pch_gbe_hal_phy_sw_reset(struct pch_gbe_hw *hw)
 s32 pch_gbe_hal_read_mac_addr(struct pch_gbe_hw *hw)
 {
         if (!hw->func->read_mac_addr) {
-                pr_err("ERROR: configuration\n");
+                struct pch_gbe_adapter *adapter = pch_gbe_hw_to_adapter(hw);
+
+                netdev_err(adapter->netdev, "ERROR: configuration\n");
                 return -ENOSYS;
         }
         return hw->func->read_mac_addr(hw);
diff --git a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_ethtool.c b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_ethtool.c
index 24b787be6062..1129db0cdf82 100644
--- a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_ethtool.c
+++ b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_ethtool.c
@@ -122,7 +122,7 @@ static int pch_gbe_set_settings(struct net_device *netdev,
         }
         ret = mii_ethtool_sset(&adapter->mii, ecmd);
         if (ret) {
-                pr_err("Error: mii_ethtool_sset\n");
+                netdev_err(netdev, "Error: mii_ethtool_sset\n");
                 return ret;
         }
         hw->mac.link_speed = speed;
diff --git a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c
index 16d5ffac1981..97db56393197 100644
--- a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c
+++ b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c
@@ -300,6 +300,7 @@ static inline void pch_gbe_mac_load_mac_addr(struct pch_gbe_hw *hw)
  */
 s32 pch_gbe_mac_read_mac_addr(struct pch_gbe_hw *hw)
 {
+        struct pch_gbe_adapter *adapter = pch_gbe_hw_to_adapter(hw);
         u32  adr1a, adr1b;
 
         adr1a = ioread32(&hw->reg->mac_adr[0].high);
@@ -312,7 +313,7 @@ s32 pch_gbe_mac_read_mac_addr(struct pch_gbe_hw *hw)
         hw->mac.addr[4] = (u8)(adr1b & 0xFF);
         hw->mac.addr[5] = (u8)((adr1b >> 8) & 0xFF);
 
-        pr_debug("hw->mac.addr : %pM\n", hw->mac.addr);
+        netdev_dbg(adapter->netdev, "hw->mac.addr : %pM\n", hw->mac.addr);
         return 0;
 }
 
@@ -324,6 +325,7 @@ s32 pch_gbe_mac_read_mac_addr(struct pch_gbe_hw *hw)
 static void pch_gbe_wait_clr_bit(void *reg, u32 bit)
 {
         u32 tmp;
+
         /* wait busy */
         tmp = 1000;
         while ((ioread32(reg) & bit) && --tmp)
@@ -340,9 +342,10 @@ static void pch_gbe_wait_clr_bit(void *reg, u32 bit)
  */
 static void pch_gbe_mac_mar_set(struct pch_gbe_hw *hw, u8 * addr, u32 index)
 {
+        struct pch_gbe_adapter *adapter = pch_gbe_hw_to_adapter(hw);
         u32 mar_low, mar_high, adrmask;
 
-        pr_debug("index : 0x%x\n", index);
+        netdev_dbg(adapter->netdev, "index : 0x%x\n", index);
 
         /*
          * HW expects these in little endian so we reverse the byte order
@@ -468,10 +471,11 @@ static void pch_gbe_mac_mc_addr_list_update(struct pch_gbe_hw *hw,
  */
 s32 pch_gbe_mac_force_mac_fc(struct pch_gbe_hw *hw)
 {
+        struct pch_gbe_adapter *adapter = pch_gbe_hw_to_adapter(hw);
         struct pch_gbe_mac_info *mac = &hw->mac;
         u32 rx_fctrl;
 
-        pr_debug("mac->fc = %u\n", mac->fc);
+        netdev_dbg(adapter->netdev, "mac->fc = %u\n", mac->fc);
 
         rx_fctrl = ioread32(&hw->reg->RX_FCTRL);
 
@@ -493,14 +497,16 @@ s32 pch_gbe_mac_force_mac_fc(struct pch_gbe_hw *hw)
                 mac->tx_fc_enable = true;
                 break;
         default:
-                pr_err("Flow control param set incorrectly\n");
+                netdev_err(adapter->netdev,
+                           "Flow control param set incorrectly\n");
                 return -EINVAL;
         }
         if (mac->link_duplex == DUPLEX_HALF)
                 rx_fctrl &= ~PCH_GBE_FL_CTRL_EN;
         iowrite32(rx_fctrl, &hw->reg->RX_FCTRL);
-        pr_debug("RX_FCTRL reg : 0x%08x  mac->tx_fc_enable : %d\n",
-                 ioread32(&hw->reg->RX_FCTRL), mac->tx_fc_enable);
+        netdev_dbg(adapter->netdev,
+                   "RX_FCTRL reg : 0x%08x  mac->tx_fc_enable : %d\n",
+                   ioread32(&hw->reg->RX_FCTRL), mac->tx_fc_enable);
         return 0;
 }
 
@@ -511,10 +517,11 @@ s32 pch_gbe_mac_force_mac_fc(struct pch_gbe_hw *hw)
  */
 static void pch_gbe_mac_set_wol_event(struct pch_gbe_hw *hw, u32 wu_evt)
 {
+        struct pch_gbe_adapter *adapter = pch_gbe_hw_to_adapter(hw);
         u32 addr_mask;
 
-        pr_debug("wu_evt : 0x%08x  ADDR_MASK reg : 0x%08x\n",
-                 wu_evt, ioread32(&hw->reg->ADDR_MASK));
+        netdev_dbg(adapter->netdev, "wu_evt : 0x%08x  ADDR_MASK reg : 0x%08x\n",
+                   wu_evt, ioread32(&hw->reg->ADDR_MASK));
 
         if (wu_evt) {
                 /* Set Wake-On-Lan address mask */
@@ -546,6 +553,7 @@ static void pch_gbe_mac_set_wol_event(struct pch_gbe_hw *hw, u32 wu_evt)
 u16 pch_gbe_mac_ctrl_miim(struct pch_gbe_hw *hw, u32 addr, u32 dir, u32 reg,
                         u16 data)
 {
+        struct pch_gbe_adapter *adapter = pch_gbe_hw_to_adapter(hw);
         u32 data_out = 0;
         unsigned int i;
         unsigned long flags;
@@ -558,7 +566,7 @@ u16 pch_gbe_mac_ctrl_miim(struct pch_gbe_hw *hw, u32 addr, u32 dir, u32 reg,
                 udelay(20);
         }
         if (i == 0) {
-                pr_err("pch-gbe.miim won't go Ready\n");
+                netdev_err(adapter->netdev, "pch-gbe.miim won't go Ready\n");
                 spin_unlock_irqrestore(&hw->miim_lock, flags);
                 return 0;       /* No way to indicate timeout error */
         }
@@ -573,9 +581,9 @@ u16 pch_gbe_mac_ctrl_miim(struct pch_gbe_hw *hw, u32 addr, u32 dir, u32 reg,
         }
         spin_unlock_irqrestore(&hw->miim_lock, flags);
 
-        pr_debug("PHY %s: reg=%d, data=0x%04X\n",
-                 dir == PCH_GBE_MIIM_OPER_READ ? "READ" : "WRITE", reg,
-                 dir == PCH_GBE_MIIM_OPER_READ ? data_out : data);
+        netdev_dbg(adapter->netdev, "PHY %s: reg=%d, data=0x%04X\n",
+                   dir == PCH_GBE_MIIM_OPER_READ ? "READ" : "WRITE", reg,
+                   dir == PCH_GBE_MIIM_OPER_READ ? data_out : data);
         return (u16) data_out;
 }
 
@@ -585,6 +593,7 @@ u16 pch_gbe_mac_ctrl_miim(struct pch_gbe_hw *hw, u32 addr, u32 dir, u32 reg,
  */
 static void pch_gbe_mac_set_pause_packet(struct pch_gbe_hw *hw)
 {
+        struct pch_gbe_adapter *adapter = pch_gbe_hw_to_adapter(hw);
         unsigned long tmp2, tmp3;
 
         /* Set Pause packet */
@@ -606,10 +615,13 @@ static void pch_gbe_mac_set_pause_packet(struct pch_gbe_hw *hw)
         /* Transmit Pause Packet */
         iowrite32(PCH_GBE_PS_PKT_RQ, &hw->reg->PAUSE_REQ);
 
-        pr_debug("PAUSE_PKT1-5 reg : 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
-                 ioread32(&hw->reg->PAUSE_PKT1), ioread32(&hw->reg->PAUSE_PKT2),
-                 ioread32(&hw->reg->PAUSE_PKT3), ioread32(&hw->reg->PAUSE_PKT4),
-                 ioread32(&hw->reg->PAUSE_PKT5));
+        netdev_dbg(adapter->netdev,
+                   "PAUSE_PKT1-5 reg : 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
+                   ioread32(&hw->reg->PAUSE_PKT1),
+                   ioread32(&hw->reg->PAUSE_PKT2),
+                   ioread32(&hw->reg->PAUSE_PKT3),
+                   ioread32(&hw->reg->PAUSE_PKT4),
+                   ioread32(&hw->reg->PAUSE_PKT5));
 
         return;
 }
@@ -669,7 +681,7 @@ static int pch_gbe_init_phy(struct pch_gbe_adapter *adapter)
                         break;
         }
         adapter->hw.phy.addr = adapter->mii.phy_id;
-        pr_debug("phy_addr = %d\n", adapter->mii.phy_id);
+        netdev_dbg(netdev, "phy_addr = %d\n", adapter->mii.phy_id);
         if (addr == 32)
                 return -EAGAIN;
         /* Selected the phy and isolate the rest */
@@ -758,13 +770,15 @@ void pch_gbe_reinit_locked(struct pch_gbe_adapter *adapter)
  */
 void pch_gbe_reset(struct pch_gbe_adapter *adapter)
 {
+        struct net_device *netdev = adapter->netdev;
+
         pch_gbe_mac_reset_hw(&adapter->hw);
         /* reprogram multicast address register after reset */
-        pch_gbe_set_multi(adapter->netdev);
+        pch_gbe_set_multi(netdev);
         /* Setup the receive address. */
         pch_gbe_mac_init_rx_addrs(&adapter->hw, PCH_GBE_MAR_ENTRIES);
         if (pch_gbe_hal_init_hw(&adapter->hw))
-                pr_err("Hardware Error\n");
+                netdev_err(netdev, "Hardware Error\n");
 }
 
 /**
@@ -778,7 +792,7 @@ static void pch_gbe_free_irq(struct pch_gbe_adapter *adapter)
         free_irq(adapter->pdev->irq, netdev);
         if (adapter->have_msi) {
                 pci_disable_msi(adapter->pdev);
-                pr_debug("call pci_disable_msi\n");
+                netdev_dbg(netdev, "call pci_disable_msi\n");
         }
 }
 
@@ -795,7 +809,8 @@ static void pch_gbe_irq_disable(struct pch_gbe_adapter *adapter)
         ioread32(&hw->reg->INT_ST);
         synchronize_irq(adapter->pdev->irq);
 
-        pr_debug("INT_EN reg : 0x%08x\n", ioread32(&hw->reg->INT_EN));
+        netdev_dbg(adapter->netdev, "INT_EN reg : 0x%08x\n",
+                   ioread32(&hw->reg->INT_EN));
 }
 
 /**
@@ -809,7 +824,8 @@ static void pch_gbe_irq_enable(struct pch_gbe_adapter *adapter)
         if (likely(atomic_dec_and_test(&adapter->irq_sem)))
                 iowrite32(PCH_GBE_INT_ENABLE_MASK, &hw->reg->INT_EN);
         ioread32(&hw->reg->INT_ST);
-        pr_debug("INT_EN reg : 0x%08x\n", ioread32(&hw->reg->INT_EN));
+        netdev_dbg(adapter->netdev, "INT_EN reg : 0x%08x\n",
+                   ioread32(&hw->reg->INT_EN));
 }
 
 
@@ -846,9 +862,9 @@ static void pch_gbe_configure_tx(struct pch_gbe_adapter *adapter)
         struct pch_gbe_hw *hw = &adapter->hw;
         u32 tdba, tdlen, dctrl;
 
-        pr_debug("dma addr = 0x%08llx  size = 0x%08x\n",
-                 (unsigned long long)adapter->tx_ring->dma,
-                 adapter->tx_ring->size);
+        netdev_dbg(adapter->netdev, "dma addr = 0x%08llx  size = 0x%08x\n",
+                   (unsigned long long)adapter->tx_ring->dma,
+                   adapter->tx_ring->size);
 
         /* Setup the HW Tx Head and Tail descriptor pointers */
         tdba = adapter->tx_ring->dma;
@@ -894,9 +910,9 @@ static void pch_gbe_configure_rx(struct pch_gbe_adapter *adapter)
         struct pch_gbe_hw *hw = &adapter->hw;
         u32 rdba, rdlen, rxdma;
 
-        pr_debug("dma adr = 0x%08llx  size = 0x%08x\n",
-                 (unsigned long long)adapter->rx_ring->dma,
-                 adapter->rx_ring->size);
+        netdev_dbg(adapter->netdev, "dma adr = 0x%08llx  size = 0x%08x\n",
+                   (unsigned long long)adapter->rx_ring->dma,
+                   adapter->rx_ring->size);
 
         pch_gbe_mac_force_mac_fc(hw);
 
@@ -907,9 +923,10 @@ static void pch_gbe_configure_rx(struct pch_gbe_adapter *adapter)
         rxdma &= ~PCH_GBE_RX_DMA_EN;
         iowrite32(rxdma, &hw->reg->DMA_CTRL);
 
-        pr_debug("MAC_RX_EN reg = 0x%08x  DMA_CTRL reg = 0x%08x\n",
-                 ioread32(&hw->reg->MAC_RX_EN),
-                 ioread32(&hw->reg->DMA_CTRL));
+        netdev_dbg(adapter->netdev,
+                   "MAC_RX_EN reg = 0x%08x  DMA_CTRL reg = 0x%08x\n",
+                   ioread32(&hw->reg->MAC_RX_EN),
+                   ioread32(&hw->reg->DMA_CTRL));
 
         /* Setup the HW Rx Head and Tail Descriptor Pointers and
          * the Base and Length of the Rx Descriptor Ring */
@@ -977,7 +994,8 @@ static void pch_gbe_clean_tx_ring(struct pch_gbe_adapter *adapter,
                 buffer_info = &tx_ring->buffer_info[i];
                 pch_gbe_unmap_and_free_tx_resource(adapter, buffer_info);
         }
-        pr_debug("call pch_gbe_unmap_and_free_tx_resource() %d count\n", i);
+        netdev_dbg(adapter->netdev,
+                   "call pch_gbe_unmap_and_free_tx_resource() %d count\n", i);
 
         size = (unsigned long)sizeof(struct pch_gbe_buffer) * tx_ring->count;
         memset(tx_ring->buffer_info, 0, size);
@@ -1009,7 +1027,8 @@ pch_gbe_clean_rx_ring(struct pch_gbe_adapter *adapter,
                 buffer_info = &rx_ring->buffer_info[i];
                 pch_gbe_unmap_and_free_rx_resource(adapter, buffer_info);
         }
-        pr_debug("call pch_gbe_unmap_and_free_rx_resource() %d count\n", i);
+        netdev_dbg(adapter->netdev,
+                   "call pch_gbe_unmap_and_free_rx_resource() %d count\n", i);
         size = (unsigned long)sizeof(struct pch_gbe_buffer) * rx_ring->count;
         memset(rx_ring->buffer_info, 0, size);
 
@@ -1087,7 +1106,7 @@ static void pch_gbe_watchdog(unsigned long data)
         struct net_device *netdev = adapter->netdev;
         struct pch_gbe_hw *hw = &adapter->hw;
 
-        pr_debug("right now = %ld\n", jiffies);
+        netdev_dbg(netdev, "right now = %ld\n", jiffies);
 
         pch_gbe_update_stats(adapter);
         if ((mii_link_ok(&adapter->mii)) && (!netif_carrier_ok(netdev))) {
@@ -1095,7 +1114,7 @@ static void pch_gbe_watchdog(unsigned long data)
                 netdev->tx_queue_len = adapter->tx_queue_len;
                 /* mii library handles link maintenance tasks */
                 if (mii_ethtool_gset(&adapter->mii, &cmd)) {
-                        pr_err("ethtool get setting Error\n");
+                        netdev_err(netdev, "ethtool get setting Error\n");
                         mod_timer(&adapter->watchdog_timer,
                                   round_jiffies(jiffies +
                                                 PCH_GBE_WATCHDOG_PERIOD));
@@ -1213,7 +1232,7 @@ static void pch_gbe_tx_queue(struct pch_gbe_adapter *adapter,
                                           buffer_info->length,
                                           DMA_TO_DEVICE);
         if (dma_mapping_error(&adapter->pdev->dev, buffer_info->dma)) {
-                pr_err("TX DMA map failed\n");
+                netdev_err(adapter->netdev, "TX DMA map failed\n");
                 buffer_info->dma = 0;
                 buffer_info->time_stamp = 0;
                 tx_ring->next_to_use = ring_num;
@@ -1333,13 +1352,13 @@ static irqreturn_t pch_gbe_intr(int irq, void *data)
         /* When request status is no interruption factor */
         if (unlikely(!int_st))
                 return IRQ_NONE;        /* Not our interrupt. End processing. */
-        pr_debug("%s occur int_st = 0x%08x\n", __func__, int_st);
+        netdev_dbg(netdev, "%s occur int_st = 0x%08x\n", __func__, int_st);
         if (int_st & PCH_GBE_INT_RX_FRAME_ERR)
                 adapter->stats.intr_rx_frame_err_count++;
         if (int_st & PCH_GBE_INT_RX_FIFO_ERR)
                 if (!adapter->rx_stop_flag) {
                         adapter->stats.intr_rx_fifo_err_count++;
-                        pr_debug("Rx fifo over run\n");
+                        netdev_dbg(netdev, "Rx fifo over run\n");
                         adapter->rx_stop_flag = true;
                         int_en = ioread32(&hw->reg->INT_EN);
                         iowrite32((int_en & ~PCH_GBE_INT_RX_FIFO_ERR),
@@ -1359,7 +1378,7 @@ static irqreturn_t pch_gbe_intr(int irq, void *data)
         /* When Rx descriptor is empty  */
         if ((int_st & PCH_GBE_INT_RX_DSC_EMP)) {
                 adapter->stats.intr_rx_dsc_empty_count++;
-                pr_debug("Rx descriptor is empty\n");
+                netdev_dbg(netdev, "Rx descriptor is empty\n");
                 int_en = ioread32(&hw->reg->INT_EN);
                 iowrite32((int_en & ~PCH_GBE_INT_RX_DSC_EMP), &hw->reg->INT_EN);
                 if (hw->mac.tx_fc_enable) {
@@ -1382,8 +1401,8 @@ static irqreturn_t pch_gbe_intr(int irq, void *data)
                         __napi_schedule(&adapter->napi);
                 }
         }
-        pr_debug("return = 0x%08x  INT_EN reg = 0x%08x\n",
-                 IRQ_HANDLED, ioread32(&hw->reg->INT_EN));
+        netdev_dbg(netdev, "return = 0x%08x  INT_EN reg = 0x%08x\n",
+                   IRQ_HANDLED, ioread32(&hw->reg->INT_EN));
         return IRQ_HANDLED;
 }
 
@@ -1437,9 +1456,10 @@ pch_gbe_alloc_rx_buffers(struct pch_gbe_adapter *adapter,
                 rx_desc->buffer_addr = (buffer_info->dma);
                 rx_desc->gbec_status = DSC_INIT16;
 
-                pr_debug("i = %d  buffer_info->dma = 0x08%llx  buffer_info->length = 0x%x\n",
-                         i, (unsigned long long)buffer_info->dma,
-                         buffer_info->length);
+                netdev_dbg(netdev,
+                           "i = %d  buffer_info->dma = 0x08%llx  buffer_info->length = 0x%x\n",
+                           i, (unsigned long long)buffer_info->dma,
+                           buffer_info->length);
 
                 if (unlikely(++i == rx_ring->count))
                         i = 0;
@@ -1531,12 +1551,13 @@ pch_gbe_clean_tx(struct pch_gbe_adapter *adapter,
         bool cleaned = false;
         int unused, thresh;
 
-        pr_debug("next_to_clean : %d\n", tx_ring->next_to_clean);
+        netdev_dbg(adapter->netdev, "next_to_clean : %d\n",
+                   tx_ring->next_to_clean);
 
         i = tx_ring->next_to_clean;
         tx_desc = PCH_GBE_TX_DESC(*tx_ring, i);
-        pr_debug("gbec_status:0x%04x  dma_status:0x%04x\n",
-                 tx_desc->gbec_status, tx_desc->dma_status);
+        netdev_dbg(adapter->netdev, "gbec_status:0x%04x  dma_status:0x%04x\n",
+                   tx_desc->gbec_status, tx_desc->dma_status);
 
         unused = PCH_GBE_DESC_UNUSED(tx_ring);
         thresh = tx_ring->count - PCH_GBE_TX_WEIGHT;
@@ -1544,8 +1565,10 @@ pch_gbe_clean_tx(struct pch_gbe_adapter *adapter,
         {  /* current marked clean, tx queue filling up, do extra clean */
                 int j, k;
                 if (unused < 8) {  /* tx queue nearly full */
-                        pr_debug("clean_tx: transmit queue warning (%x,%x) unused=%d\n",
-                                tx_ring->next_to_clean,tx_ring->next_to_use,unused);
+                        netdev_dbg(adapter->netdev,
+                                   "clean_tx: transmit queue warning (%x,%x) unused=%d\n",
+                                   tx_ring->next_to_clean, tx_ring->next_to_use,
+                                   unused);
                 }
 
                 /* current marked clean, scan for more that need cleaning. */
@@ -1557,49 +1580,56 @@ pch_gbe_clean_tx(struct pch_gbe_adapter *adapter,
                         if (++k >= tx_ring->count) k = 0;  /*increment, wrap*/
                 }
                 if (j < PCH_GBE_TX_WEIGHT) {
-                        pr_debug("clean_tx: unused=%d loops=%d found tx_desc[%x,%x:%x].gbec_status=%04x\n",
-                                unused,j, i,k, tx_ring->next_to_use, tx_desc->gbec_status);
+                        netdev_dbg(adapter->netdev,
+                                   "clean_tx: unused=%d loops=%d found tx_desc[%x,%x:%x].gbec_status=%04x\n",
+                                   unused, j, i, k, tx_ring->next_to_use,
+                                   tx_desc->gbec_status);
                         i = k;  /*found one to clean, usu gbec_status==2000.*/
                 }
         }
 
         while ((tx_desc->gbec_status & DSC_INIT16) == 0x0000) {
-                pr_debug("gbec_status:0x%04x\n", tx_desc->gbec_status);
+                netdev_dbg(adapter->netdev, "gbec_status:0x%04x\n",
+                           tx_desc->gbec_status);
                 buffer_info = &tx_ring->buffer_info[i];
                 skb = buffer_info->skb;
                 cleaned = true;
 
                 if ((tx_desc->gbec_status & PCH_GBE_TXD_GMAC_STAT_ABT)) {
                         adapter->stats.tx_aborted_errors++;
-                        pr_err("Transfer Abort Error\n");
+                        netdev_err(adapter->netdev, "Transfer Abort Error\n");
                 } else if ((tx_desc->gbec_status & PCH_GBE_TXD_GMAC_STAT_CRSER)
                           ) {
                         adapter->stats.tx_carrier_errors++;
-                        pr_err("Transfer Carrier Sense Error\n");
+                        netdev_err(adapter->netdev,
+                                   "Transfer Carrier Sense Error\n");
                 } else if ((tx_desc->gbec_status & PCH_GBE_TXD_GMAC_STAT_EXCOL)
                           ) {
                         adapter->stats.tx_aborted_errors++;
-                        pr_err("Transfer Collision Abort Error\n");
+                        netdev_err(adapter->netdev,
+                                   "Transfer Collision Abort Error\n");
                 } else if ((tx_desc->gbec_status &
                             (PCH_GBE_TXD_GMAC_STAT_SNGCOL |
                              PCH_GBE_TXD_GMAC_STAT_MLTCOL))) {
                         adapter->stats.collisions++;
                         adapter->stats.tx_packets++;
                         adapter->stats.tx_bytes += skb->len;
-                        pr_debug("Transfer Collision\n");
+                        netdev_dbg(adapter->netdev, "Transfer Collision\n");
                 } else if ((tx_desc->gbec_status & PCH_GBE_TXD_GMAC_STAT_CMPLT)
                           ) {
                         adapter->stats.tx_packets++;
                         adapter->stats.tx_bytes += skb->len;
                 }
                 if (buffer_info->mapped) {
-                        pr_debug("unmap buffer_info->dma : %d\n", i);
+                        netdev_dbg(adapter->netdev,
+                                   "unmap buffer_info->dma : %d\n", i);
                         dma_unmap_single(&adapter->pdev->dev, buffer_info->dma,
                                          buffer_info->length, DMA_TO_DEVICE);
                         buffer_info->mapped = false;
                 }
                 if (buffer_info->skb) {
-                        pr_debug("trim buffer_info->skb : %d\n", i);
+                        netdev_dbg(adapter->netdev,
+                                   "trim buffer_info->skb : %d\n", i);
                         skb_trim(buffer_info->skb, 0);
                 }
                 tx_desc->gbec_status = DSC_INIT16;
@@ -1613,8 +1643,9 @@ pch_gbe_clean_tx(struct pch_gbe_adapter *adapter,
                         break;
                 }
         }
-        pr_debug("called pch_gbe_unmap_and_free_tx_resource() %d count\n",
-                 cleaned_count);
+        netdev_dbg(adapter->netdev,
+                   "called pch_gbe_unmap_and_free_tx_resource() %d count\n",
+                   cleaned_count);
         if (cleaned_count > 0)  { /*skip this if nothing cleaned*/
                 /* Recover from running out of Tx resources in xmit_frame */
                 spin_lock(&tx_ring->tx_lock);
@@ -1622,12 +1653,13 @@ pch_gbe_clean_tx(struct pch_gbe_adapter *adapter,
                 {
                         netif_wake_queue(adapter->netdev);
                         adapter->stats.tx_restart_count++;
-                        pr_debug("Tx wake queue\n");
+                        netdev_dbg(adapter->netdev, "Tx wake queue\n");
                 }
 
                 tx_ring->next_to_clean = i;
 
-                pr_debug("next_to_clean : %d\n", tx_ring->next_to_clean);
+                netdev_dbg(adapter->netdev, "next_to_clean : %d\n",
+                           tx_ring->next_to_clean);
                 spin_unlock(&tx_ring->tx_lock);
         }
         return cleaned;
@@ -1684,22 +1716,22 @@ pch_gbe_clean_rx(struct pch_gbe_adapter *adapter,
                                    buffer_info->length, DMA_FROM_DEVICE);
                 buffer_info->mapped = false;
 
-                pr_debug("RxDecNo = 0x%04x  Status[DMA:0x%02x GBE:0x%04x "
-                         "TCP:0x%08x]  BufInf = 0x%p\n",
-                         i, dma_status, gbec_status, tcp_ip_status,
-                         buffer_info);
+                netdev_dbg(netdev,
+                           "RxDecNo = 0x%04x  Status[DMA:0x%02x GBE:0x%04x TCP:0x%08x]  BufInf = 0x%p\n",
+                           i, dma_status, gbec_status, tcp_ip_status,
+                           buffer_info);
                 /* Error check */
                 if (unlikely(gbec_status & PCH_GBE_RXD_GMAC_STAT_NOTOCTAL)) {
                         adapter->stats.rx_frame_errors++;
-                        pr_err("Receive Not Octal Error\n");
+                        netdev_err(netdev, "Receive Not Octal Error\n");
                 } else if (unlikely(gbec_status &
                                 PCH_GBE_RXD_GMAC_STAT_NBLERR)) {
                         adapter->stats.rx_frame_errors++;
-                        pr_err("Receive Nibble Error\n");
+                        netdev_err(netdev, "Receive Nibble Error\n");
                 } else if (unlikely(gbec_status &
                                 PCH_GBE_RXD_GMAC_STAT_CRCERR)) {
                         adapter->stats.rx_crc_errors++;
-                        pr_err("Receive CRC Error\n");
+                        netdev_err(netdev, "Receive CRC Error\n");
                 } else {
                         /* get receive length */
                         /* length convert[-3], length includes FCS length */
@@ -1730,8 +1762,9 @@ pch_gbe_clean_rx(struct pch_gbe_adapter *adapter,
 
                         napi_gro_receive(&adapter->napi, skb);
                         (*work_done)++;
-                        pr_debug("Receive skb->ip_summed: %d length: %d\n",
-                                 skb->ip_summed, length);
+                        netdev_dbg(netdev,
+                                   "Receive skb->ip_summed: %d length: %d\n",
+                                   skb->ip_summed, length);
                 }
                 /* return some buffers to hardware, one at a time is too slow */
                 if (unlikely(cleaned_count >= PCH_GBE_RX_BUFFER_WRITE)) {
@@ -1787,10 +1820,10 @@ int pch_gbe_setup_tx_resources(struct pch_gbe_adapter *adapter,
                 tx_desc = PCH_GBE_TX_DESC(*tx_ring, desNo);
                 tx_desc->gbec_status = DSC_INIT16;
         }
-        pr_debug("tx_ring->desc = 0x%p  tx_ring->dma = 0x%08llx\n"
-                 "next_to_clean = 0x%08x  next_to_use = 0x%08x\n",
-                 tx_ring->desc, (unsigned long long)tx_ring->dma,
-                 tx_ring->next_to_clean, tx_ring->next_to_use);
+        netdev_dbg(adapter->netdev,
+                   "tx_ring->desc = 0x%p  tx_ring->dma = 0x%08llx next_to_clean = 0x%08x  next_to_use = 0x%08x\n",
+                   tx_ring->desc, (unsigned long long)tx_ring->dma,
+                   tx_ring->next_to_clean, tx_ring->next_to_use);
         return 0;
 }
 
@@ -1829,10 +1862,10 @@ int pch_gbe_setup_rx_resources(struct pch_gbe_adapter *adapter,
                 rx_desc = PCH_GBE_RX_DESC(*rx_ring, desNo);
                 rx_desc->gbec_status = DSC_INIT16;
         }
-        pr_debug("rx_ring->desc = 0x%p  rx_ring->dma = 0x%08llx "
-                 "next_to_clean = 0x%08x  next_to_use = 0x%08x\n",
-                 rx_ring->desc, (unsigned long long)rx_ring->dma,
-                 rx_ring->next_to_clean, rx_ring->next_to_use);
+        netdev_dbg(adapter->netdev,
+                   "rx_ring->desc = 0x%p  rx_ring->dma = 0x%08llx next_to_clean = 0x%08x  next_to_use = 0x%08x\n",
+                   rx_ring->desc, (unsigned long long)rx_ring->dma,
+                   rx_ring->next_to_clean, rx_ring->next_to_use);
         return 0;
 }
 
@@ -1886,9 +1919,9 @@ static int pch_gbe_request_irq(struct pch_gbe_adapter *adapter)
         flags = IRQF_SHARED;
         adapter->have_msi = false;
         err = pci_enable_msi(adapter->pdev);
-        pr_debug("call pci_enable_msi\n");
+        netdev_dbg(netdev, "call pci_enable_msi\n");
         if (err) {
-                pr_debug("call pci_enable_msi - Error: %d\n", err);
+                netdev_dbg(netdev, "call pci_enable_msi - Error: %d\n", err);
         } else {
                 flags = 0;
                 adapter->have_msi = true;
@@ -1896,9 +1929,11 @@ static int pch_gbe_request_irq(struct pch_gbe_adapter *adapter)
         err = request_irq(adapter->pdev->irq, &pch_gbe_intr,
                           flags, netdev->name, netdev);
         if (err)
-                pr_err("Unable to allocate interrupt Error: %d\n", err);
-        pr_debug("adapter->have_msi : %d  flags : 0x%04x  return : 0x%04x\n",
-                 adapter->have_msi, flags, err);
+                netdev_err(netdev, "Unable to allocate interrupt Error: %d\n",
+                           err);
+        netdev_dbg(netdev,
+                   "adapter->have_msi : %d  flags : 0x%04x  return : 0x%04x\n",
+                   adapter->have_msi, flags, err);
         return err;
 }
 
@@ -1919,7 +1954,7 @@ int pch_gbe_up(struct pch_gbe_adapter *adapter)
 
         /* Ensure we have a valid MAC */
         if (!is_valid_ether_addr(adapter->hw.mac.addr)) {
-                pr_err("Error: Invalid MAC address\n");
+                netdev_err(netdev, "Error: Invalid MAC address\n");
                 goto out;
         }
 
@@ -1933,12 +1968,14 @@ int pch_gbe_up(struct pch_gbe_adapter *adapter)
 
         err = pch_gbe_request_irq(adapter);
         if (err) {
-                pr_err("Error: can't bring device up - irq request failed\n");
+                netdev_err(netdev,
+                           "Error: can't bring device up - irq request failed\n");
                 goto out;
         }
         err = pch_gbe_alloc_rx_buffers_pool(adapter, rx_ring, rx_ring->count);
         if (err) {
-                pr_err("Error: can't bring device up - alloc rx buffers pool failed\n");
+                netdev_err(netdev,
+                           "Error: can't bring device up - alloc rx buffers pool failed\n");
                 goto freeirq;
         }
         pch_gbe_alloc_tx_buffers(adapter, tx_ring);
@@ -2015,11 +2052,11 @@ static int pch_gbe_sw_init(struct pch_gbe_adapter *adapter)
 
         /* Initialize the hardware-specific values */
         if (pch_gbe_hal_setup_init_funcs(hw)) {
-                pr_err("Hardware Initialization Failure\n");
+                netdev_err(netdev, "Hardware Initialization Failure\n");
                 return -EIO;
         }
         if (pch_gbe_alloc_queues(adapter)) {
-                pr_err("Unable to allocate memory for queues\n");
+                netdev_err(netdev, "Unable to allocate memory for queues\n");
                 return -ENOMEM;
         }
         spin_lock_init(&adapter->hw.miim_lock);
@@ -2030,9 +2067,10 @@ static int pch_gbe_sw_init(struct pch_gbe_adapter *adapter)
 
         pch_gbe_init_stats(adapter);
 
-        pr_debug("rx_buffer_len : %d  mac.min_frame_size : %d  mac.max_frame_size : %d\n",
-                 (u32) adapter->rx_buffer_len,
-                 hw->mac.min_frame_size, hw->mac.max_frame_size);
+        netdev_dbg(netdev,
+                   "rx_buffer_len : %d  mac.min_frame_size : %d  mac.max_frame_size : %d\n",
+                   (u32) adapter->rx_buffer_len,
+                   hw->mac.min_frame_size, hw->mac.max_frame_size);
         return 0;
 }
 
@@ -2061,7 +2099,7 @@ static int pch_gbe_open(struct net_device *netdev)
         err = pch_gbe_up(adapter);
         if (err)
                 goto err_up;
-        pr_debug("Success End\n");
+        netdev_dbg(netdev, "Success End\n");
         return 0;
 
 err_up:
@@ -2072,7 +2110,7 @@ err_setup_rx:
         pch_gbe_free_tx_resources(adapter, adapter->tx_ring);
 err_setup_tx:
         pch_gbe_reset(adapter);
-        pr_err("Error End\n");
+        netdev_err(netdev, "Error End\n");
         return err;
 }
 
@@ -2116,8 +2154,9 @@ static int pch_gbe_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
         if (unlikely(!PCH_GBE_DESC_UNUSED(tx_ring))) {
                 netif_stop_queue(netdev);
                 spin_unlock_irqrestore(&tx_ring->tx_lock, flags);
-                pr_debug("Return : BUSY  next_to use : 0x%08x  next_to clean : 0x%08x\n",
-                         tx_ring->next_to_use, tx_ring->next_to_clean);
+                netdev_dbg(netdev,
+                           "Return : BUSY  next_to use : 0x%08x  next_to clean : 0x%08x\n",
+                           tx_ring->next_to_use, tx_ring->next_to_clean);
                 return NETDEV_TX_BUSY;
         }
 
@@ -2152,7 +2191,7 @@ static void pch_gbe_set_multi(struct net_device *netdev)
         int i;
         int mc_count;
 
-        pr_debug("netdev->flags : 0x%08x\n", netdev->flags);
+        netdev_dbg(netdev, "netdev->flags : 0x%08x\n", netdev->flags);
 
         /* Check for Promiscuous and All Multicast modes */
         rctl = ioread32(&hw->reg->RX_MODE);
@@ -2192,7 +2231,8 @@ static void pch_gbe_set_multi(struct net_device *netdev)
                                         PCH_GBE_MAR_ENTRIES);
         kfree(mta_list);
 
-        pr_debug("RX_MODE reg(check bit31,30 ADD,MLT) : 0x%08x  netdev->mc_count : 0x%08x\n",
+        netdev_dbg(netdev,
+                 "RX_MODE reg(check bit31,30 ADD,MLT) : 0x%08x  netdev->mc_count : 0x%08x\n",
                  ioread32(&hw->reg->RX_MODE), mc_count);
 }
 
@@ -2218,12 +2258,12 @@ static int pch_gbe_set_mac(struct net_device *netdev, void *addr)
                 pch_gbe_mac_mar_set(&adapter->hw, adapter->hw.mac.addr, 0);
                 ret_val = 0;
         }
-        pr_debug("ret_val : 0x%08x\n", ret_val);
-        pr_debug("dev_addr : %pM\n", netdev->dev_addr);
-        pr_debug("mac_addr : %pM\n", adapter->hw.mac.addr);
-        pr_debug("MAC_ADR1AB reg : 0x%08x 0x%08x\n",
-                 ioread32(&adapter->hw.reg->mac_adr[0].high),
-                 ioread32(&adapter->hw.reg->mac_adr[0].low));
+        netdev_dbg(netdev, "ret_val : 0x%08x\n", ret_val);
+        netdev_dbg(netdev, "dev_addr : %pM\n", netdev->dev_addr);
+        netdev_dbg(netdev, "mac_addr : %pM\n", adapter->hw.mac.addr);
+        netdev_dbg(netdev, "MAC_ADR1AB reg : 0x%08x 0x%08x\n",
+                   ioread32(&adapter->hw.reg->mac_adr[0].high),
+                   ioread32(&adapter->hw.reg->mac_adr[0].low));
         return ret_val;
 }
 
@@ -2245,7 +2285,7 @@ static int pch_gbe_change_mtu(struct net_device *netdev, int new_mtu)
         max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN;
         if ((max_frame < ETH_ZLEN + ETH_FCS_LEN) ||
                 (max_frame > PCH_GBE_MAX_JUMBO_FRAME_SIZE)) {
-                pr_err("Invalid MTU setting\n");
+                netdev_err(netdev, "Invalid MTU setting\n");
                 return -EINVAL;
         }
         if (max_frame <= PCH_GBE_FRAME_SIZE_2048)
@@ -2274,9 +2314,10 @@ static int pch_gbe_change_mtu(struct net_device *netdev, int new_mtu)
                 adapter->hw.mac.max_frame_size = max_frame;
         }
 
-        pr_debug("max_frame : %d  rx_buffer_len : %d  mtu : %d  max_frame_size : %d\n",
-                 max_frame, (u32) adapter->rx_buffer_len, netdev->mtu,
-                 adapter->hw.mac.max_frame_size);
+        netdev_dbg(netdev,
+                   "max_frame : %d  rx_buffer_len : %d  mtu : %d  max_frame_size : %d\n",
+                   max_frame, (u32) adapter->rx_buffer_len, netdev->mtu,
+                   adapter->hw.mac.max_frame_size);
         return 0;
 }
 
@@ -2317,7 +2358,7 @@ static int pch_gbe_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
 {
         struct pch_gbe_adapter *adapter = netdev_priv(netdev);
 
-        pr_debug("cmd : 0x%04x\n", cmd);
+        netdev_dbg(netdev, "cmd : 0x%04x\n", cmd);
 
         if (cmd == SIOCSHWTSTAMP)
                 return hwtstamp_ioctl(netdev, ifr, cmd);
@@ -2354,7 +2395,7 @@ static int pch_gbe_napi_poll(struct napi_struct *napi, int budget)
         bool poll_end_flag = false;
         bool cleaned = false;
 
-        pr_debug("budget : %d\n", budget);
+        netdev_dbg(adapter->netdev, "budget : %d\n", budget);
 
         pch_gbe_clean_rx(adapter, adapter->rx_ring, &work_done, budget);
         cleaned = pch_gbe_clean_tx(adapter, adapter->tx_ring);
@@ -2377,8 +2418,9 @@ static int pch_gbe_napi_poll(struct napi_struct *napi, int budget)
                 pch_gbe_enable_dma_rx(&adapter->hw);
         }
 
-        pr_debug("poll_end_flag : %d  work_done : %d  budget : %d\n",
-                 poll_end_flag, work_done, budget);
+        netdev_dbg(adapter->netdev,
+                   "poll_end_flag : %d  work_done : %d  budget : %d\n",
+                   poll_end_flag, work_done, budget);
 
         return work_done;
 }
@@ -2435,7 +2477,7 @@ static pci_ers_result_t pch_gbe_io_slot_reset(struct pci_dev *pdev)
         struct pch_gbe_hw *hw = &adapter->hw;
 
         if (pci_enable_device(pdev)) {
-                pr_err("Cannot re-enable PCI device after reset\n");
+                netdev_err(netdev, "Cannot re-enable PCI device after reset\n");
                 return PCI_ERS_RESULT_DISCONNECT;
         }
         pci_set_master(pdev);
@@ -2455,7 +2497,8 @@ static void pch_gbe_io_resume(struct pci_dev *pdev)
 
         if (netif_running(netdev)) {
                 if (pch_gbe_up(adapter)) {
-                        pr_debug("can't bring device back up after reset\n");
+                        netdev_dbg(netdev,
+                                   "can't bring device back up after reset\n");
                         return;
                 }
         }
@@ -2509,7 +2552,7 @@ static int pch_gbe_resume(struct device *device)
 
         err = pci_enable_device(pdev);
         if (err) {
-                pr_err("Cannot enable PCI device from suspend\n");
+                netdev_err(netdev, "Cannot enable PCI device from suspend\n");
                 return err;
         }
         pci_set_master(pdev);
@@ -2609,7 +2652,7 @@ static int pch_gbe_probe(struct pci_dev *pdev,
         adapter->ptp_pdev = pci_get_bus_and_slot(adapter->pdev->bus->number,
                                                PCI_DEVFN(12, 4));
         if (ptp_filter_init(ptp_filter, ARRAY_SIZE(ptp_filter))) {
-                pr_err("Bad ptp filter\n");
+                dev_err(&pdev->dev, "Bad ptp filter\n");
                 return -EINVAL;
         }
 
diff --git a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_param.c b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_param.c
index 8653c3b81f84..cf7c9b3a255b 100644
--- a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_param.c
+++ b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_param.c
@@ -237,16 +237,17 @@ static int pch_gbe_validate_option(int *value,
         case enable_option:
                 switch (*value) {
                 case OPTION_ENABLED:
-                        pr_debug("%s Enabled\n", opt->name);
+                        netdev_dbg(adapter->netdev, "%s Enabled\n", opt->name);
                         return 0;
                 case OPTION_DISABLED:
-                        pr_debug("%s Disabled\n", opt->name);
+                        netdev_dbg(adapter->netdev, "%s Disabled\n", opt->name);
                         return 0;
                 }
                 break;
         case range_option:
                 if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) {
-                        pr_debug("%s set to %i\n", opt->name, *value);
+                        netdev_dbg(adapter->netdev, "%s set to %i\n",
+                                   opt->name, *value);
                         return 0;
                 }
                 break;
@@ -258,7 +259,8 @@ static int pch_gbe_validate_option(int *value,
                         ent = &opt->arg.l.p[i];
                         if (*value == ent->i) {
                                 if (ent->str[0] != '\0')
-                                        pr_debug("%s\n", ent->str);
+                                        netdev_dbg(adapter->netdev, "%s\n",
+                                                   ent->str);
                                 return 0;
                         }
                 }
@@ -268,8 +270,8 @@ static int pch_gbe_validate_option(int *value,
                 BUG();
         }
 
-        pr_debug("Invalid %s value specified (%i) %s\n",
-                 opt->name, *value, opt->err);
+        netdev_dbg(adapter->netdev, "Invalid %s value specified (%i) %s\n",
+                   opt->name, *value, opt->err);
         *value = opt->def;
         return -1;
 }
@@ -318,7 +320,8 @@ static void pch_gbe_check_copper_options(struct pch_gbe_adapter *adapter)
                                          .p = an_list} }
                 };
                 if (speed || dplx) {
-                        pr_debug("AutoNeg specified along with Speed or Duplex, AutoNeg parameter ignored\n");
+                        netdev_dbg(adapter->netdev,
+                                   "AutoNeg specified along with Speed or Duplex, AutoNeg parameter ignored\n");
                         hw->phy.autoneg_advertised = opt.def;
                 } else {
                         int tmp = AutoNeg;
@@ -332,13 +335,16 @@ static void pch_gbe_check_copper_options(struct pch_gbe_adapter *adapter)
         case 0:
                 hw->mac.autoneg = hw->mac.fc_autoneg = 1;
                 if ((speed || dplx))
-                        pr_debug("Speed and duplex autonegotiation enabled\n");
+                        netdev_dbg(adapter->netdev,
+                                   "Speed and duplex autonegotiation enabled\n");
                 hw->mac.link_speed = SPEED_10;
                 hw->mac.link_duplex = DUPLEX_HALF;
                 break;
         case HALF_DUPLEX:
-                pr_debug("Half Duplex specified without Speed\n");
-                pr_debug("Using Autonegotiation at Half Duplex only\n");
+                netdev_dbg(adapter->netdev,
+                           "Half Duplex specified without Speed\n");
+                netdev_dbg(adapter->netdev,
+                           "Using Autonegotiation at Half Duplex only\n");
                 hw->mac.autoneg = hw->mac.fc_autoneg = 1;
                 hw->phy.autoneg_advertised = PHY_ADVERTISE_10_HALF |
                                                 PHY_ADVERTISE_100_HALF;
@@ -346,8 +352,10 @@ static void pch_gbe_check_copper_options(struct pch_gbe_adapter *adapter)
                 hw->mac.link_duplex = DUPLEX_HALF;
                 break;
         case FULL_DUPLEX:
-                pr_debug("Full Duplex specified without Speed\n");
-                pr_debug("Using Autonegotiation at Full Duplex only\n");
+                netdev_dbg(adapter->netdev,
+                           "Full Duplex specified without Speed\n");
+                netdev_dbg(adapter->netdev,
+                           "Using Autonegotiation at Full Duplex only\n");
                 hw->mac.autoneg = hw->mac.fc_autoneg = 1;
                 hw->phy.autoneg_advertised = PHY_ADVERTISE_10_FULL |
                                                 PHY_ADVERTISE_100_FULL |
@@ -356,8 +364,10 @@ static void pch_gbe_check_copper_options(struct pch_gbe_adapter *adapter)
                 hw->mac.link_duplex = DUPLEX_FULL;
                 break;
         case SPEED_10:
-                pr_debug("10 Mbps Speed specified without Duplex\n");
-                pr_debug("Using Autonegotiation at 10 Mbps only\n");
+                netdev_dbg(adapter->netdev,
+                           "10 Mbps Speed specified without Duplex\n");
+                netdev_dbg(adapter->netdev,
+                           "Using Autonegotiation at 10 Mbps only\n");
                 hw->mac.autoneg = hw->mac.fc_autoneg = 1;
                 hw->phy.autoneg_advertised = PHY_ADVERTISE_10_HALF |
                                                 PHY_ADVERTISE_10_FULL;
@@ -365,22 +375,24 @@ static void pch_gbe_check_copper_options(struct pch_gbe_adapter *adapter)
                 hw->mac.link_duplex = DUPLEX_HALF;
                 break;
         case SPEED_10 + HALF_DUPLEX:
-                pr_debug("Forcing to 10 Mbps Half Duplex\n");
+                netdev_dbg(adapter->netdev, "Forcing to 10 Mbps Half Duplex\n");
                 hw->mac.autoneg = hw->mac.fc_autoneg = 0;
                 hw->phy.autoneg_advertised = 0;
                 hw->mac.link_speed = SPEED_10;
                 hw->mac.link_duplex = DUPLEX_HALF;
                 break;
         case SPEED_10 + FULL_DUPLEX:
-                pr_debug("Forcing to 10 Mbps Full Duplex\n");
+                netdev_dbg(adapter->netdev, "Forcing to 10 Mbps Full Duplex\n");
                 hw->mac.autoneg = hw->mac.fc_autoneg = 0;
                 hw->phy.autoneg_advertised = 0;
                 hw->mac.link_speed = SPEED_10;
                 hw->mac.link_duplex = DUPLEX_FULL;
                 break;
         case SPEED_100:
-                pr_debug("100 Mbps Speed specified without Duplex\n");
-                pr_debug("Using Autonegotiation at 100 Mbps only\n");
+                netdev_dbg(adapter->netdev,
+                           "100 Mbps Speed specified without Duplex\n");
+                netdev_dbg(adapter->netdev,
+                           "Using Autonegotiation at 100 Mbps only\n");
                 hw->mac.autoneg = hw->mac.fc_autoneg = 1;
                 hw->phy.autoneg_advertised = PHY_ADVERTISE_100_HALF |
                                                 PHY_ADVERTISE_100_FULL;
@@ -388,28 +400,33 @@ static void pch_gbe_check_copper_options(struct pch_gbe_adapter *adapter)
                 hw->mac.link_duplex = DUPLEX_HALF;
                 break;
         case SPEED_100 + HALF_DUPLEX:
-                pr_debug("Forcing to 100 Mbps Half Duplex\n");
+                netdev_dbg(adapter->netdev,
+                           "Forcing to 100 Mbps Half Duplex\n");
                 hw->mac.autoneg = hw->mac.fc_autoneg = 0;
                 hw->phy.autoneg_advertised = 0;
                 hw->mac.link_speed = SPEED_100;
                 hw->mac.link_duplex = DUPLEX_HALF;
                 break;
         case SPEED_100 + FULL_DUPLEX:
-                pr_debug("Forcing to 100 Mbps Full Duplex\n");
+                netdev_dbg(adapter->netdev,
+                           "Forcing to 100 Mbps Full Duplex\n");
                 hw->mac.autoneg = hw->mac.fc_autoneg = 0;
                 hw->phy.autoneg_advertised = 0;
                 hw->mac.link_speed = SPEED_100;
                 hw->mac.link_duplex = DUPLEX_FULL;
                 break;
         case SPEED_1000:
-                pr_debug("1000 Mbps Speed specified without Duplex\n");
+                netdev_dbg(adapter->netdev,
+                           "1000 Mbps Speed specified without Duplex\n");
                 goto full_duplex_only;
         case SPEED_1000 + HALF_DUPLEX:
-                pr_debug("Half Duplex is not supported at 1000 Mbps\n");
+                netdev_dbg(adapter->netdev,
+                           "Half Duplex is not supported at 1000 Mbps\n");
                 /* fall through */
         case SPEED_1000 + FULL_DUPLEX:
 full_duplex_only:
-                pr_debug("Using Autonegotiation at 1000 Mbps Full Duplex only\n");
+                netdev_dbg(adapter->netdev,
+                           "Using Autonegotiation at 1000 Mbps Full Duplex only\n");
                 hw->mac.autoneg = hw->mac.fc_autoneg = 1;
                 hw->phy.autoneg_advertised = PHY_ADVERTISE_1000_FULL;
                 hw->mac.link_speed = SPEED_1000;
diff --git a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_phy.c b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_phy.c
index b97c6575e018..da079073a6c6 100644
--- a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_phy.c
+++ b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_phy.c
@@ -97,6 +97,7 @@
  */
 s32 pch_gbe_phy_get_id(struct pch_gbe_hw *hw)
 {
+        struct pch_gbe_adapter *adapter = pch_gbe_hw_to_adapter(hw);
         struct pch_gbe_phy_info *phy = &hw->phy;
         s32 ret;
         u16 phy_id1;
@@ -115,8 +116,9 @@ s32 pch_gbe_phy_get_id(struct pch_gbe_hw *hw)
         phy->id = (u32)phy_id1;
         phy->id = ((phy->id << 6) | ((phy_id2 & 0xFC00) >> 10));
         phy->revision = (u32) (phy_id2 & 0x000F);
-        pr_debug("phy->id : 0x%08x  phy->revision : 0x%08x\n",
-                 phy->id, phy->revision);
+        netdev_dbg(adapter->netdev,
+                   "phy->id : 0x%08x  phy->revision : 0x%08x\n",
+                   phy->id, phy->revision);
         return 0;
 }
 
@@ -134,7 +136,10 @@ s32 pch_gbe_phy_read_reg_miic(struct pch_gbe_hw *hw, u32 offset, u16 *data)
         struct pch_gbe_phy_info *phy = &hw->phy;
 
         if (offset > PHY_MAX_REG_ADDRESS) {
-                pr_err("PHY Address %d is out of range\n", offset);
+                struct pch_gbe_adapter *adapter = pch_gbe_hw_to_adapter(hw);
+
+                netdev_err(adapter->netdev, "PHY Address %d is out of range\n",
+                           offset);
                 return -EINVAL;
         }
         *data = pch_gbe_mac_ctrl_miim(hw, phy->addr, PCH_GBE_HAL_MIIM_READ,
@@ -156,7 +161,10 @@ s32 pch_gbe_phy_write_reg_miic(struct pch_gbe_hw *hw, u32 offset, u16 data)
         struct pch_gbe_phy_info *phy = &hw->phy;
 
         if (offset > PHY_MAX_REG_ADDRESS) {
-                pr_err("PHY Address %d is out of range\n", offset);
+                struct pch_gbe_adapter *adapter = pch_gbe_hw_to_adapter(hw);
+
+                netdev_err(adapter->netdev, "PHY Address %d is out of range\n",
+                           offset);
                 return -EINVAL;
         }
         pch_gbe_mac_ctrl_miim(hw, phy->addr, PCH_GBE_HAL_MIIM_WRITE,
@@ -246,15 +254,14 @@ void pch_gbe_phy_set_rgmii(struct pch_gbe_hw *hw)
  */
 void pch_gbe_phy_init_setting(struct pch_gbe_hw *hw)
 {
-        struct pch_gbe_adapter *adapter;
+        struct pch_gbe_adapter *adapter = pch_gbe_hw_to_adapter(hw);
         struct ethtool_cmd     cmd = { .cmd = ETHTOOL_GSET };
         int ret;
         u16 mii_reg;
 
-        adapter = container_of(hw, struct pch_gbe_adapter, hw);
         ret = mii_ethtool_gset(&adapter->mii, &cmd);
         if (ret)
-                pr_err("Error: mii_ethtool_gset\n");
+                netdev_err(adapter->netdev, "Error: mii_ethtool_gset\n");
 
         ethtool_cmd_speed_set(&cmd, hw->mac.link_speed);
         cmd.duplex = hw->mac.link_duplex;
@@ -263,7 +270,7 @@ void pch_gbe_phy_init_setting(struct pch_gbe_hw *hw)
         pch_gbe_phy_write_reg_miic(hw, MII_BMCR, BMCR_RESET);
         ret = mii_ethtool_sset(&adapter->mii, &cmd);
         if (ret)
-                pr_err("Error: mii_ethtool_sset\n");
+                netdev_err(adapter->netdev, "Error: mii_ethtool_sset\n");
 
         pch_gbe_phy_sw_reset(hw);