net/bnx2x: fix logging to include device name
authorRasesh Mody <rasesh.mody@cavium.com>
Sat, 29 Sep 2018 05:42:29 +0000 (05:42 +0000)
committerFerruh Yigit <ferruh.yigit@intel.com>
Thu, 11 Oct 2018 16:53:48 +0000 (18:53 +0200)
Fix PMD logging scheme to include device name in the messages printed.

Fixes: 540a211084a7 ("bnx2x: driver core")
Cc: stable@dpdk.org
Signed-off-by: Rasesh Mody <rasesh.mody@cavium.com>
12 files changed:
drivers/net/bnx2x/bnx2x.c
drivers/net/bnx2x/bnx2x.h
drivers/net/bnx2x/bnx2x_ethdev.c
drivers/net/bnx2x/bnx2x_logs.h
drivers/net/bnx2x/bnx2x_rxtx.c
drivers/net/bnx2x/bnx2x_stats.c
drivers/net/bnx2x/bnx2x_vfpf.c
drivers/net/bnx2x/ecore_init.h
drivers/net/bnx2x/ecore_init_ops.h
drivers/net/bnx2x/ecore_sp.c
drivers/net/bnx2x/ecore_sp.h
drivers/net/bnx2x/elink.c

index 4904eaf..93f8586 100644 (file)
@@ -178,13 +178,14 @@ bnx2x_dma_alloc(struct bnx2x_softc *sc, size_t size, struct bnx2x_dma *dma,
                                        SOCKET_ID_ANY,
                                        RTE_MEMZONE_IOVA_CONTIG, align);
        if (z == NULL) {
-               PMD_DRV_LOG(ERR, "DMA alloc failed for %s", msg);
+               PMD_DRV_LOG(ERR, sc, "DMA alloc failed for %s", msg);
                return -ENOMEM;
        }
        dma->paddr = (uint64_t) z->iova;
        dma->vaddr = z->addr;
 
-       PMD_DRV_LOG(DEBUG, "%s: virt=%p phys=%" PRIx64, msg, dma->vaddr, dma->paddr);
+       PMD_DRV_LOG(DEBUG, sc,
+                   "%s: virt=%p phys=%" PRIx64, msg, dma->vaddr, dma->paddr);
 
        return 0;
 }
@@ -197,11 +198,11 @@ static int bnx2x_acquire_hw_lock(struct bnx2x_softc *sc, uint32_t resource)
        uint32_t hw_lock_control_reg;
        int cnt;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        /* validate the resource is within range */
        if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
-               PMD_DRV_LOG(NOTICE,
+               PMD_DRV_LOG(NOTICE, sc,
                            "resource 0x%x > HW_LOCK_MAX_RESOURCE_VALUE",
                            resource);
                return -1;
@@ -217,7 +218,7 @@ static int bnx2x_acquire_hw_lock(struct bnx2x_softc *sc, uint32_t resource)
        /* validate the resource is not already taken */
        lock_status = REG_RD(sc, hw_lock_control_reg);
        if (lock_status & resource_bit) {
-               PMD_DRV_LOG(NOTICE,
+               PMD_DRV_LOG(NOTICE, sc,
                            "resource in use (status 0x%x bit 0x%x)",
                            lock_status, resource_bit);
                return -1;
@@ -233,7 +234,7 @@ static int bnx2x_acquire_hw_lock(struct bnx2x_softc *sc, uint32_t resource)
                DELAY(5000);
        }
 
-       PMD_DRV_LOG(NOTICE, "Resource lock timeout!");
+       PMD_DRV_LOG(NOTICE, sc, "Resource lock timeout!");
        return -1;
 }
 
@@ -244,11 +245,11 @@ static int bnx2x_release_hw_lock(struct bnx2x_softc *sc, uint32_t resource)
        int func = SC_FUNC(sc);
        uint32_t hw_lock_control_reg;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        /* validate the resource is within range */
        if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
-               PMD_DRV_LOG(NOTICE,
+               PMD_DRV_LOG(NOTICE, sc,
                            "resource 0x%x > HW_LOCK_MAX_RESOURCE_VALUE",
                            resource);
                return -1;
@@ -264,7 +265,7 @@ static int bnx2x_release_hw_lock(struct bnx2x_softc *sc, uint32_t resource)
        /* validate the resource is currently taken */
        lock_status = REG_RD(sc, hw_lock_control_reg);
        if (!(lock_status & resource_bit)) {
-               PMD_DRV_LOG(NOTICE,
+               PMD_DRV_LOG(NOTICE, sc,
                            "resource not in use (status 0x%x bit 0x%x)",
                            lock_status, resource_bit);
                return -1;
@@ -366,7 +367,7 @@ bnx2x_issue_dmae_with_comp(struct bnx2x_softc *sc, struct dmae_command *dmae)
                if (!timeout ||
                    (sc->recovery_state != BNX2X_RECOVERY_DONE &&
                     sc->recovery_state != BNX2X_RECOVERY_NIC_LOADING)) {
-                       PMD_DRV_LOG(INFO, "DMAE timeout!");
+                       PMD_DRV_LOG(INFO, sc, "DMAE timeout!");
                        return DMAE_TIMEOUT;
                }
 
@@ -375,7 +376,7 @@ bnx2x_issue_dmae_with_comp(struct bnx2x_softc *sc, struct dmae_command *dmae)
        }
 
        if (*wb_comp & DMAE_PCI_ERR_FLAG) {
-               PMD_DRV_LOG(INFO, "DMAE PCI error!");
+               PMD_DRV_LOG(INFO, sc, "DMAE PCI error!");
                return DMAE_PCI_ERROR;
        }
 
@@ -534,7 +535,7 @@ void
 elink_cb_event_log(__rte_unused struct bnx2x_softc *sc,
                   __rte_unused const elink_log_id_t elink_log_id, ...)
 {
-       PMD_DRV_LOG(DEBUG, "ELINK EVENT LOG (%d)", elink_log_id);
+       PMD_DRV_LOG(DEBUG, sc, "ELINK EVENT LOG (%d)", elink_log_id);
 }
 
 static int bnx2x_set_spio(struct bnx2x_softc *sc, int spio, uint32_t mode)
@@ -543,7 +544,7 @@ static int bnx2x_set_spio(struct bnx2x_softc *sc, int spio, uint32_t mode)
 
        /* Only 2 SPIOs are configurable */
        if ((spio != MISC_SPIO_SPIO4) && (spio != MISC_SPIO_SPIO5)) {
-               PMD_DRV_LOG(NOTICE, "Invalid SPIO 0x%x", spio);
+               PMD_DRV_LOG(NOTICE, sc, "Invalid SPIO 0x%x", spio);
                return -1;
        }
 
@@ -593,7 +594,7 @@ static int bnx2x_gpio_read(struct bnx2x_softc *sc, int gpio_num, uint8_t port)
        uint32_t gpio_reg;
 
        if (gpio_num > MISC_REGISTERS_GPIO_3) {
-               PMD_DRV_LOG(NOTICE, "Invalid GPIO %d", gpio_num);
+               PMD_DRV_LOG(NOTICE, sc, "Invalid GPIO %d", gpio_num);
                return -1;
        }
 
@@ -618,7 +619,7 @@ bnx2x_gpio_write(struct bnx2x_softc *sc, int gpio_num, uint32_t mode, uint8_t po
        uint32_t gpio_reg;
 
        if (gpio_num > MISC_REGISTERS_GPIO_3) {
-               PMD_DRV_LOG(NOTICE, "Invalid GPIO %d", gpio_num);
+               PMD_DRV_LOG(NOTICE, sc, "Invalid GPIO %d", gpio_num);
                return -1;
        }
 
@@ -687,7 +688,8 @@ bnx2x_gpio_mult_write(struct bnx2x_softc *sc, uint8_t pins, uint32_t mode)
                break;
 
        default:
-               PMD_DRV_LOG(NOTICE, "Invalid GPIO mode assignment %d", mode);
+               PMD_DRV_LOG(NOTICE, sc,
+                           "Invalid GPIO mode assignment %d", mode);
                bnx2x_release_hw_lock(sc, HW_LOCK_RESOURCE_GPIO);
                return -1;
        }
@@ -713,7 +715,7 @@ bnx2x_gpio_int_write(struct bnx2x_softc *sc, int gpio_num, uint32_t mode,
        uint32_t gpio_reg;
 
        if (gpio_num > MISC_REGISTERS_GPIO_3) {
-               PMD_DRV_LOG(NOTICE, "Invalid GPIO %d", gpio_num);
+               PMD_DRV_LOG(NOTICE, sc, "Invalid GPIO %d", gpio_num);
                return -1;
        }
 
@@ -790,7 +792,7 @@ elink_cb_fw_command(struct bnx2x_softc *sc, uint32_t command, uint32_t param)
        SHMEM_WR(sc, func_mb[mb_idx].drv_mb_param, param);
        SHMEM_WR(sc, func_mb[mb_idx].drv_mb_header, (command | seq));
 
-       PMD_DRV_LOG(DEBUG,
+       PMD_DRV_LOG(DEBUG, sc,
                    "wrote command 0x%08x to FW MB param 0x%08x",
                    (command | seq), param);
 
@@ -805,7 +807,7 @@ elink_cb_fw_command(struct bnx2x_softc *sc, uint32_t command, uint32_t param)
                rc &= FW_MSG_CODE_MASK;
        } else {
                /* Ruh-roh! */
-               PMD_DRV_LOG(NOTICE, "FW failed to respond!");
+               PMD_DRV_LOG(NOTICE, sc, "FW failed to respond!");
                rc = 0;
        }
 
@@ -1023,12 +1025,12 @@ bnx2x_sp_post(struct bnx2x_softc *sc, int command, int cid, uint32_t data_hi,
 
        if (common) {
                if (!atomic_load_acq_long(&sc->eq_spq_left)) {
-                       PMD_DRV_LOG(INFO, "EQ ring is full!");
+                       PMD_DRV_LOG(INFO, sc, "EQ ring is full!");
                        return -1;
                }
        } else {
                if (!atomic_load_acq_long(&sc->cq_spq_left)) {
-                       PMD_DRV_LOG(INFO, "SPQ ring is full!");
+                       PMD_DRV_LOG(INFO, sc, "SPQ ring is full!");
                        return -1;
                }
        }
@@ -1061,7 +1063,7 @@ bnx2x_sp_post(struct bnx2x_softc *sc, int command, int cid, uint32_t data_hi,
                atomic_subtract_acq_long(&sc->cq_spq_left, 1);
        }
 
-       PMD_DRV_LOG(DEBUG,
+       PMD_DRV_LOG(DEBUG, sc,
                    "SPQE[%x] (%x:%x) (cmd, common?) (%d,%d) hw_cid %x"
                    "data (%x:%x) type(0x%x) left (CQ, EQ) (%lx,%lx)",
                    sc->spq_prod_idx,
@@ -1132,44 +1134,45 @@ bnx2x_sp_event(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp,
        enum ecore_queue_cmd drv_cmd = ECORE_Q_CMD_MAX;
        struct ecore_queue_sp_obj *q_obj = &BNX2X_SP_OBJ(sc, fp).q_obj;
 
-       PMD_DRV_LOG(DEBUG,
+       PMD_DRV_LOG(DEBUG, sc,
                    "fp=%d cid=%d got ramrod #%d state is %x type is %d",
                    fp->index, cid, command, sc->state,
                    rr_cqe->ramrod_cqe.ramrod_type);
 
        switch (command) {
        case (RAMROD_CMD_ID_ETH_CLIENT_UPDATE):
-               PMD_DRV_LOG(DEBUG, "got UPDATE ramrod. CID %d", cid);
+               PMD_DRV_LOG(DEBUG, sc, "got UPDATE ramrod. CID %d", cid);
                drv_cmd = ECORE_Q_CMD_UPDATE;
                break;
 
        case (RAMROD_CMD_ID_ETH_CLIENT_SETUP):
-               PMD_DRV_LOG(DEBUG, "got MULTI[%d] setup ramrod", cid);
+               PMD_DRV_LOG(DEBUG, sc, "got MULTI[%d] setup ramrod", cid);
                drv_cmd = ECORE_Q_CMD_SETUP;
                break;
 
        case (RAMROD_CMD_ID_ETH_TX_QUEUE_SETUP):
-               PMD_DRV_LOG(DEBUG, "got MULTI[%d] tx-only setup ramrod", cid);
+               PMD_DRV_LOG(DEBUG, sc,
+                           "got MULTI[%d] tx-only setup ramrod", cid);
                drv_cmd = ECORE_Q_CMD_SETUP_TX_ONLY;
                break;
 
        case (RAMROD_CMD_ID_ETH_HALT):
-               PMD_DRV_LOG(DEBUG, "got MULTI[%d] halt ramrod", cid);
+               PMD_DRV_LOG(DEBUG, sc, "got MULTI[%d] halt ramrod", cid);
                drv_cmd = ECORE_Q_CMD_HALT;
                break;
 
        case (RAMROD_CMD_ID_ETH_TERMINATE):
-               PMD_DRV_LOG(DEBUG, "got MULTI[%d] teminate ramrod", cid);
+               PMD_DRV_LOG(DEBUG, sc, "got MULTI[%d] teminate ramrod", cid);
                drv_cmd = ECORE_Q_CMD_TERMINATE;
                break;
 
        case (RAMROD_CMD_ID_ETH_EMPTY):
-               PMD_DRV_LOG(DEBUG, "got MULTI[%d] empty ramrod", cid);
+               PMD_DRV_LOG(DEBUG, sc, "got MULTI[%d] empty ramrod", cid);
                drv_cmd = ECORE_Q_CMD_EMPTY;
                break;
 
        default:
-               PMD_DRV_LOG(DEBUG,
+               PMD_DRV_LOG(DEBUG, sc,
                            "ERROR: unexpected MC reply (%d)"
                            "on fp[%d]", command, fp->index);
                return;
@@ -1191,7 +1194,7 @@ bnx2x_sp_event(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp,
 
        atomic_add_acq_long(&sc->cq_spq_left, 1);
 
-       PMD_DRV_LOG(DEBUG, "sc->cq_spq_left 0x%lx",
+       PMD_DRV_LOG(DEBUG, sc, "sc->cq_spq_left 0x%lx",
                    atomic_load_acq_long(&sc->cq_spq_left));
 }
 
@@ -1387,7 +1390,7 @@ bnx2x_del_all_macs(struct bnx2x_softc *sc, struct ecore_vlan_mac_obj *mac_obj,
 
        rc = mac_obj->delete_all(sc, mac_obj, &vlan_mac_flags, &ramrod_flags);
        if (rc < 0)
-               PMD_DRV_LOG(ERR, "Failed to delete MACs (%d)", rc);
+               PMD_DRV_LOG(ERR, sc, "Failed to delete MACs (%d)", rc);
 
        return rc;
 }
@@ -1538,13 +1541,13 @@ static int bnx2x_nic_load_no_mcp(struct bnx2x_softc *sc)
        int path = SC_PATH(sc);
        int port = SC_PORT(sc);
 
-       PMD_DRV_LOG(INFO, "NO MCP - load counts[%d]      %d, %d, %d",
+       PMD_DRV_LOG(INFO, sc, "NO MCP - load counts[%d]      %d, %d, %d",
                    path, load_count[path][0], load_count[path][1],
                    load_count[path][2]);
 
        load_count[path][0]++;
        load_count[path][1 + port]++;
-       PMD_DRV_LOG(INFO, "NO MCP - new load counts[%d]  %d, %d, %d",
+       PMD_DRV_LOG(INFO, sc, "NO MCP - new load counts[%d]  %d, %d, %d",
                    path, load_count[path][0], load_count[path][1],
                    load_count[path][2]);
        if (load_count[path][0] == 1)
@@ -1561,12 +1564,12 @@ static int bnx2x_nic_unload_no_mcp(struct bnx2x_softc *sc)
        int port = SC_PORT(sc);
        int path = SC_PATH(sc);
 
-       PMD_DRV_LOG(INFO, "NO MCP - load counts[%d]      %d, %d, %d",
+       PMD_DRV_LOG(INFO, sc, "NO MCP - load counts[%d]      %d, %d, %d",
                    path, load_count[path][0], load_count[path][1],
                    load_count[path][2]);
        load_count[path][0]--;
        load_count[path][1 + port]--;
-       PMD_DRV_LOG(INFO, "NO MCP - new load counts[%d]  %d, %d, %d",
+       PMD_DRV_LOG(INFO, sc, "NO MCP - new load counts[%d]  %d, %d, %d",
                    path, load_count[path][0], load_count[path][1],
                    load_count[path][2]);
        if (load_count[path][0] == 0) {
@@ -1646,7 +1649,7 @@ static int bnx2x_func_wait_started(struct bnx2x_softc *sc)
                 */
                struct ecore_func_state_params func_params = { NULL };
 
-               PMD_DRV_LOG(NOTICE, "Unexpected function state! "
+               PMD_DRV_LOG(NOTICE, sc, "Unexpected function state! "
                            "Forcing STARTED-->TX_STOPPED-->STARTED");
 
                func_params.f_obj = &sc->func_obj;
@@ -1670,7 +1673,7 @@ static int bnx2x_stop_queue(struct bnx2x_softc *sc, int index)
        struct ecore_queue_state_params q_params = { NULL };
        int rc;
 
-       PMD_DRV_LOG(DEBUG, "stopping queue %d cid %d", index, fp->index);
+       PMD_DRV_LOG(DEBUG, sc, "stopping queue %d cid %d", index, fp->index);
 
        q_params.q_obj = &sc->sp_objs[fp->index].q_obj;
        /* We want to wait for completion in this context */
@@ -1721,7 +1724,7 @@ static uint8_t bnx2x_wait_sp_comp(struct bnx2x_softc *sc, unsigned long mask)
 
        tmp = atomic_load_acq_long(&sc->sp_state);
        if (tmp & mask) {
-               PMD_DRV_LOG(INFO, "Filtering completion timed out: "
+               PMD_DRV_LOG(INFO, sc, "Filtering completion timed out: "
                            "sp_state 0x%lx, mask 0x%lx", tmp, mask);
                return FALSE;
        }
@@ -1747,7 +1750,7 @@ static int bnx2x_func_stop(struct bnx2x_softc *sc)
         */
        rc = ecore_func_state_change(sc, &func_params);
        if (rc) {
-               PMD_DRV_LOG(NOTICE, "FUNC_STOP ramrod failed. "
+               PMD_DRV_LOG(NOTICE, sc, "FUNC_STOP ramrod failed. "
                            "Running a dry transaction");
                bnx2x_set_bit(RAMROD_DRV_CLR_ONLY, &func_params.ramrod_flags);
                return ecore_func_state_change(sc, &func_params);
@@ -1796,14 +1799,16 @@ bnx2x_chip_cleanup(struct bnx2x_softc *sc, uint32_t unload_mode, uint8_t keep_li
        rc = bnx2x_del_all_macs(sc, &sc->sp_objs[0].mac_obj, ECORE_ETH_MAC,
                              FALSE);
        if (rc < 0) {
-               PMD_DRV_LOG(NOTICE, "Failed to delete all ETH MACs (%d)", rc);
+               PMD_DRV_LOG(NOTICE, sc,
+                           "Failed to delete all ETH MACs (%d)", rc);
        }
 
        /* Clean up UC list  */
        rc = bnx2x_del_all_macs(sc, &sc->sp_objs[0].mac_obj, ECORE_UC_LIST_MAC,
                              TRUE);
        if (rc < 0) {
-               PMD_DRV_LOG(NOTICE, "Failed to delete UC MACs list (%d)", rc);
+               PMD_DRV_LOG(NOTICE, sc,
+                           "Failed to delete UC MACs list (%d)", rc);
        }
 
        /* Disable LLH */
@@ -1826,7 +1831,7 @@ bnx2x_chip_cleanup(struct bnx2x_softc *sc, uint32_t unload_mode, uint8_t keep_li
        rparam.mcast_obj = &sc->mcast_obj;
        rc = ecore_config_mcast(sc, &rparam, ECORE_MCAST_CMD_DEL);
        if (rc < 0) {
-               PMD_DRV_LOG(NOTICE,
+               PMD_DRV_LOG(NOTICE, sc,
                            "Failed to send DEL MCAST command (%d)", rc);
        }
 
@@ -1843,7 +1848,7 @@ bnx2x_chip_cleanup(struct bnx2x_softc *sc, uint32_t unload_mode, uint8_t keep_li
         */
        rc = bnx2x_func_wait_started(sc);
        if (rc) {
-               PMD_DRV_LOG(NOTICE, "bnx2x_func_wait_started failed");
+               PMD_DRV_LOG(NOTICE, sc, "bnx2x_func_wait_started failed");
        }
 
        /*
@@ -1861,14 +1866,14 @@ bnx2x_chip_cleanup(struct bnx2x_softc *sc, uint32_t unload_mode, uint8_t keep_li
         * very wrong has happen.
         */
        if (!bnx2x_wait_sp_comp(sc, ~0x0UL)) {
-               PMD_DRV_LOG(NOTICE, "Common slow path ramrods got stuck!");
+               PMD_DRV_LOG(NOTICE, sc, "Common slow path ramrods got stuck!");
        }
 
 unload_error:
 
        rc = bnx2x_func_stop(sc);
        if (rc) {
-               PMD_DRV_LOG(NOTICE, "Function stop failed!");
+               PMD_DRV_LOG(NOTICE, sc, "Function stop failed!");
        }
 
        /* disable HW interrupts */
@@ -1877,7 +1882,7 @@ unload_error:
        /* Reset the chip */
        rc = bnx2x_reset_hw(sc, reset_code);
        if (rc) {
-               PMD_DRV_LOG(NOTICE, "Hardware reset failed");
+               PMD_DRV_LOG(NOTICE, sc, "Hardware reset failed");
        }
 
        /* Report UNLOAD_DONE to MCP */
@@ -1888,7 +1893,7 @@ static void bnx2x_disable_close_the_gate(struct bnx2x_softc *sc)
 {
        uint32_t val;
 
-       PMD_DRV_LOG(DEBUG, "Disabling 'close the gates'");
+       PMD_DRV_LOG(DEBUG, sc, "Disabling 'close the gates'");
 
        val = REG_RD(sc, MISC_REG_AEU_GENERAL_MASK);
        val &= ~(MISC_AEU_GENERAL_MASK_REG_AEU_PXP_CLOSE_MASK |
@@ -1919,7 +1924,7 @@ static void bnx2x_squeeze_objects(struct bnx2x_softc *sc)
        rc = mac_obj->delete_all(sc, &sc->sp_objs->mac_obj, &vlan_mac_flags,
                                 &ramrod_flags);
        if (rc != 0) {
-               PMD_DRV_LOG(NOTICE, "Failed to clean ETH MACs (%d)", rc);
+               PMD_DRV_LOG(NOTICE, sc, "Failed to clean ETH MACs (%d)", rc);
        }
 
        /* Cleanup UC list */
@@ -1927,7 +1932,8 @@ static void bnx2x_squeeze_objects(struct bnx2x_softc *sc)
        bnx2x_set_bit(ECORE_UC_LIST_MAC, &vlan_mac_flags);
        rc = mac_obj->delete_all(sc, mac_obj, &vlan_mac_flags, &ramrod_flags);
        if (rc != 0) {
-               PMD_DRV_LOG(NOTICE, "Failed to clean UC list MACs (%d)", rc);
+               PMD_DRV_LOG(NOTICE, sc,
+                           "Failed to clean UC list MACs (%d)", rc);
        }
 
        /* Now clean mcast object... */
@@ -1938,7 +1944,7 @@ static void bnx2x_squeeze_objects(struct bnx2x_softc *sc)
        /* Add a DEL command... */
        rc = ecore_config_mcast(sc, &rparam, ECORE_MCAST_CMD_DEL);
        if (rc < 0) {
-               PMD_DRV_LOG(NOTICE,
+               PMD_DRV_LOG(NOTICE, sc,
                            "Failed to send DEL MCAST command (%d)", rc);
        }
 
@@ -1947,7 +1953,7 @@ static void bnx2x_squeeze_objects(struct bnx2x_softc *sc)
        rc = ecore_config_mcast(sc, &rparam, ECORE_MCAST_CMD_CONT);
        while (rc != 0) {
                if (rc < 0) {
-                       PMD_DRV_LOG(NOTICE,
+                       PMD_DRV_LOG(NOTICE, sc,
                                    "Failed to clean MCAST object (%d)", rc);
                        return;
                }
@@ -1964,7 +1970,7 @@ bnx2x_nic_unload(struct bnx2x_softc *sc, uint32_t unload_mode, uint8_t keep_link
        uint8_t global = FALSE;
        uint32_t val;
 
-       PMD_DRV_LOG(DEBUG, "Starting NIC unload...");
+       PMD_DRV_LOG(DEBUG, sc, "Starting NIC unload...");
 
        /* mark driver as unloaded in shmem2 */
        if (IS_PF(sc) && SHMEM2_HAS(sc, drv_capabilities_flag)) {
@@ -1988,7 +1994,7 @@ bnx2x_nic_unload(struct bnx2x_softc *sc, uint32_t unload_mode, uint8_t keep_link
                bnx2x_release_leader_lock(sc);
                mb();
 
-               PMD_DRV_LOG(NOTICE, "Can't unload in closed or error state");
+               PMD_DRV_LOG(NOTICE, sc, "Can't unload in closed or error state");
                return -1;
        }
 
@@ -2093,7 +2099,7 @@ bnx2x_nic_unload(struct bnx2x_softc *sc, uint32_t unload_mode, uint8_t keep_link
                bnx2x_disable_close_the_gate(sc);
        }
 
-       PMD_DRV_LOG(DEBUG, "Ended NIC unload");
+       PMD_DRV_LOG(DEBUG, sc, "Ended NIC unload");
 
        return 0;
 }
@@ -2241,7 +2247,7 @@ static void bnx2x_ilt_set_info(struct bnx2x_softc *sc)
        struct ecore_ilt *ilt = sc->ilt;
        uint16_t line = 0;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        ilt->start_line = FUNC_ILT_BASE(SC_FUNC(sc));
 
@@ -2395,7 +2401,7 @@ static int bnx2x_alloc_mem(struct bnx2x_softc *sc)
        bnx2x_alloc_ilt_lines_mem(sc);
 
        if (ecore_ilt_mem_op(sc, ILT_MEMOP_ALLOC)) {
-               PMD_DRV_LOG(NOTICE, "ecore_ilt_mem_op ILT_MEMOP_ALLOC failed");
+               PMD_DRV_LOG(NOTICE, sc, "ecore_ilt_mem_op ILT_MEMOP_ALLOC failed");
                bnx2x_free_mem(sc);
                return -1;
        }
@@ -2598,7 +2604,7 @@ static void bnx2x_set_pf_load(struct bnx2x_softc *sc)
 
        bnx2x_acquire_hw_lock(sc, HW_LOCK_RESOURCE_RECOVERY_REG);
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        val = REG_RD(sc, BNX2X_RECOVERY_GLOB_REG);
 
@@ -2651,14 +2657,14 @@ static uint8_t bnx2x_clear_pf_load(struct bnx2x_softc *sc)
 /* send load requrest to mcp and analyze response */
 static int bnx2x_nic_load_request(struct bnx2x_softc *sc, uint32_t * load_code)
 {
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        /* init fw_seq */
        sc->fw_seq =
            (SHMEM_RD(sc, func_mb[SC_FW_MB_IDX(sc)].drv_mb_header) &
             DRV_MSG_SEQ_NUMBER_MASK);
 
-       PMD_DRV_LOG(DEBUG, "initial fw_seq 0x%04x", sc->fw_seq);
+       PMD_DRV_LOG(DEBUG, sc, "initial fw_seq 0x%04x", sc->fw_seq);
 
 #ifdef BNX2X_PULSE
        /* get the current FW pulse sequence */
@@ -2677,13 +2683,13 @@ static int bnx2x_nic_load_request(struct bnx2x_softc *sc, uint32_t * load_code)
 
        /* if the MCP fails to respond we must abort */
        if (!(*load_code)) {
-               PMD_DRV_LOG(NOTICE, "MCP response failure!");
+               PMD_DRV_LOG(NOTICE, sc, "MCP response failure!");
                return -1;
        }
 
        /* if MCP refused then must abort */
        if ((*load_code) == FW_MSG_CODE_DRV_LOAD_REFUSED) {
-               PMD_DRV_LOG(NOTICE, "MCP refused load request");
+               PMD_DRV_LOG(NOTICE, sc, "MCP refused load request");
                return -1;
        }
 
@@ -2710,12 +2716,12 @@ static int bnx2x_nic_load_analyze_req(struct bnx2x_softc *sc, uint32_t load_code
 
                /* read loaded FW from chip */
                loaded_fw = REG_RD(sc, XSEM_REG_PRAM);
-               PMD_DRV_LOG(DEBUG, "loaded FW 0x%08x / my FW 0x%08x",
+               PMD_DRV_LOG(DEBUG, sc, "loaded FW 0x%08x / my FW 0x%08x",
                            loaded_fw, my_fw);
 
                /* abort nic load if version mismatch */
                if (my_fw != loaded_fw) {
-                       PMD_DRV_LOG(NOTICE,
+                       PMD_DRV_LOG(NOTICE, sc,
                                    "FW 0x%08x already loaded (mine is 0x%08x)",
                                    loaded_fw, my_fw);
                        return -1;
@@ -2730,7 +2736,7 @@ static void bnx2x_nic_load_pmf(struct bnx2x_softc *sc, uint32_t load_code)
 {
        uint32_t ncsi_oem_data_addr;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        if ((load_code == FW_MSG_CODE_DRV_LOAD_COMMON) ||
            (load_code == FW_MSG_CODE_DRV_LOAD_COMMON_CHIP) ||
@@ -2745,7 +2751,7 @@ static void bnx2x_nic_load_pmf(struct bnx2x_softc *sc, uint32_t load_code)
                sc->port.pmf = 0;
        }
 
-       PMD_DRV_LOG(DEBUG, "pmf %d", sc->port.pmf);
+       PMD_DRV_LOG(DEBUG, sc, "pmf %d", sc->port.pmf);
 
        if (load_code == FW_MSG_CODE_DRV_LOAD_COMMON_CHIP) {
                if (SHMEM2_HAS(sc, ncsi_oem_data_addr)) {
@@ -2788,10 +2794,10 @@ static void bnx2x_read_mf_cfg(struct bnx2x_softc *sc)
 
        if (sc->devinfo.mf_info.mf_config[SC_VN(sc)] &
            FUNC_MF_CFG_FUNC_DISABLED) {
-               PMD_DRV_LOG(DEBUG, "mf_cfg function disabled");
+               PMD_DRV_LOG(DEBUG, sc, "mf_cfg function disabled");
                sc->flags |= BNX2X_MF_FUNC_DIS;
        } else {
-               PMD_DRV_LOG(DEBUG, "mf_cfg function enabled");
+               PMD_DRV_LOG(DEBUG, sc, "mf_cfg function enabled");
                sc->flags &= ~BNX2X_MF_FUNC_DIS;
        }
 }
@@ -2812,7 +2818,7 @@ static int bnx2x_acquire_alr(struct bnx2x_softc *sc)
        }
 
        if (!(val & (1L << 31))) {
-               PMD_DRV_LOG(NOTICE, "Cannot acquire MCP access lock register");
+               PMD_DRV_LOG(NOTICE, sc, "Cannot acquire MCP access lock register");
                return -1;
        }
 
@@ -2840,7 +2846,7 @@ static void bnx2x_fan_failure(struct bnx2x_softc *sc)
                 ext_phy_config);
 
        /* log the failure */
-       PMD_DRV_LOG(INFO,
+       PMD_DRV_LOG(INFO, sc,
                    "Fan Failure has caused the driver to shutdown "
                    "the card to prevent permanent damage. "
                    "Please contact OEM Support for assistance");
@@ -2918,7 +2924,7 @@ static void bnx2x_attn_int_asserted(struct bnx2x_softc *sc, uint32_t asserted)
        uint32_t cnt;
 
        if (sc->attn_state & asserted) {
-               PMD_DRV_LOG(ERR, "IGU ERROR attn=0x%08x", asserted);
+               PMD_DRV_LOG(ERR, sc, "IGU ERROR attn=0x%08x", asserted);
        }
 
        bnx2x_acquire_hw_lock(sc, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
@@ -2950,45 +2956,45 @@ static void bnx2x_attn_int_asserted(struct bnx2x_softc *sc, uint32_t asserted)
                }
 
                if (asserted & ATTN_SW_TIMER_4_FUNC) {
-                       PMD_DRV_LOG(DEBUG, "ATTN_SW_TIMER_4_FUNC!");
+                       PMD_DRV_LOG(DEBUG, sc, "ATTN_SW_TIMER_4_FUNC!");
                }
 
                if (asserted & GPIO_2_FUNC) {
-                       PMD_DRV_LOG(DEBUG, "GPIO_2_FUNC!");
+                       PMD_DRV_LOG(DEBUG, sc, "GPIO_2_FUNC!");
                }
 
                if (asserted & GPIO_3_FUNC) {
-                       PMD_DRV_LOG(DEBUG, "GPIO_3_FUNC!");
+                       PMD_DRV_LOG(DEBUG, sc, "GPIO_3_FUNC!");
                }
 
                if (asserted & GPIO_4_FUNC) {
-                       PMD_DRV_LOG(DEBUG, "GPIO_4_FUNC!");
+                       PMD_DRV_LOG(DEBUG, sc, "GPIO_4_FUNC!");
                }
 
                if (port == 0) {
                        if (asserted & ATTN_GENERAL_ATTN_1) {
-                               PMD_DRV_LOG(DEBUG, "ATTN_GENERAL_ATTN_1!");
+                               PMD_DRV_LOG(DEBUG, sc, "ATTN_GENERAL_ATTN_1!");
                                REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_1, 0x0);
                        }
                        if (asserted & ATTN_GENERAL_ATTN_2) {
-                               PMD_DRV_LOG(DEBUG, "ATTN_GENERAL_ATTN_2!");
+                               PMD_DRV_LOG(DEBUG, sc, "ATTN_GENERAL_ATTN_2!");
                                REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_2, 0x0);
                        }
                        if (asserted & ATTN_GENERAL_ATTN_3) {
-                               PMD_DRV_LOG(DEBUG, "ATTN_GENERAL_ATTN_3!");
+                               PMD_DRV_LOG(DEBUG, sc, "ATTN_GENERAL_ATTN_3!");
                                REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_3, 0x0);
                        }
                } else {
                        if (asserted & ATTN_GENERAL_ATTN_4) {
-                               PMD_DRV_LOG(DEBUG, "ATTN_GENERAL_ATTN_4!");
+                               PMD_DRV_LOG(DEBUG, sc, "ATTN_GENERAL_ATTN_4!");
                                REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_4, 0x0);
                        }
                        if (asserted & ATTN_GENERAL_ATTN_5) {
-                               PMD_DRV_LOG(DEBUG, "ATTN_GENERAL_ATTN_5!");
+                               PMD_DRV_LOG(DEBUG, sc, "ATTN_GENERAL_ATTN_5!");
                                REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_5, 0x0);
                        }
                        if (asserted & ATTN_GENERAL_ATTN_6) {
-                               PMD_DRV_LOG(DEBUG, "ATTN_GENERAL_ATTN_6!");
+                               PMD_DRV_LOG(DEBUG, sc, "ATTN_GENERAL_ATTN_6!");
                                REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_6, 0x0);
                        }
                }
@@ -3002,7 +3008,7 @@ static void bnx2x_attn_int_asserted(struct bnx2x_softc *sc, uint32_t asserted)
                reg_addr = (BAR_IGU_INTMEM + IGU_CMD_ATTN_BIT_SET_UPPER * 8);
        }
 
-       PMD_DRV_LOG(DEBUG, "about to mask 0x%08x at %s addr 0x%08x",
+       PMD_DRV_LOG(DEBUG, sc, "about to mask 0x%08x at %s addr 0x%08x",
                    asserted,
                    (sc->devinfo.int_block == INT_BLOCK_HC) ? "HC" : "IGU",
                    reg_addr);
@@ -3024,7 +3030,7 @@ static void bnx2x_attn_int_asserted(struct bnx2x_softc *sc, uint32_t asserted)
                                 && (++cnt < MAX_IGU_ATTN_ACK_TO));
 
                        if (!igu_acked) {
-                               PMD_DRV_LOG(ERR,
+                               PMD_DRV_LOG(ERR, sc,
                                            "Failed to verify IGU ack on time");
                        }
 
@@ -3040,7 +3046,7 @@ static void
 bnx2x_print_next_block(__rte_unused struct bnx2x_softc *sc, __rte_unused int idx,
                     __rte_unused const char *blk)
 {
-       PMD_DRV_LOG(INFO, "%s%s", idx ? ", " : "", blk);
+       PMD_DRV_LOG(INFO, sc, "%s%s", idx ? ", " : "", blk);
 }
 
 static int
@@ -3348,7 +3354,7 @@ bnx2x_parity_attn(struct bnx2x_softc *sc, uint8_t * global, uint8_t print,
            (sig[2] & HW_PRTY_ASSERT_SET_2) ||
            (sig[3] & HW_PRTY_ASSERT_SET_3) ||
            (sig[4] & HW_PRTY_ASSERT_SET_4)) {
-               PMD_DRV_LOG(ERR,
+               PMD_DRV_LOG(ERR, sc,
                            "Parity error: HW block parity attention:"
                            "[0]:0x%08x [1]:0x%08x [2]:0x%08x [3]:0x%08x [4]:0x%08x",
                            (uint32_t) (sig[0] & HW_PRTY_ASSERT_SET_0),
@@ -3358,7 +3364,7 @@ bnx2x_parity_attn(struct bnx2x_softc *sc, uint8_t * global, uint8_t print,
                            (uint32_t) (sig[4] & HW_PRTY_ASSERT_SET_4));
 
                if (print)
-                       PMD_DRV_LOG(INFO, "Parity errors detected in blocks: ");
+                       PMD_DRV_LOG(INFO, sc, "Parity errors detected in blocks: ");
 
                par_num =
                    bnx2x_check_blocks_with_parity0(sc, sig[0] &
@@ -3382,7 +3388,7 @@ bnx2x_parity_attn(struct bnx2x_softc *sc, uint8_t * global, uint8_t print,
                                                  par_num, print);
 
                if (print)
-                       PMD_DRV_LOG(INFO, "");
+                       PMD_DRV_LOG(INFO, sc, "");
 
                return TRUE;
        }
@@ -3414,64 +3420,64 @@ static void bnx2x_attn_int_deasserted4(struct bnx2x_softc *sc, uint32_t attn)
 
        if (attn & AEU_INPUTS_ATTN_BITS_PGLUE_HW_INTERRUPT) {
                val = REG_RD(sc, PGLUE_B_REG_PGLUE_B_INT_STS_CLR);
-               PMD_DRV_LOG(INFO, "ERROR: PGLUE hw attention 0x%08x", val);
+               PMD_DRV_LOG(INFO, sc, "ERROR: PGLUE hw attention 0x%08x", val);
                if (val & PGLUE_B_PGLUE_B_INT_STS_REG_ADDRESS_ERROR)
-                       PMD_DRV_LOG(INFO,
+                       PMD_DRV_LOG(INFO, sc,
                                    "ERROR: PGLUE_B_PGLUE_B_INT_STS_REG_ADDRESS_ERROR");
                if (val & PGLUE_B_PGLUE_B_INT_STS_REG_INCORRECT_RCV_BEHAVIOR)
-                       PMD_DRV_LOG(INFO,
+                       PMD_DRV_LOG(INFO, sc,
                                    "ERROR: PGLUE_B_PGLUE_B_INT_STS_REG_INCORRECT_RCV_BEHAVIOR");
                if (val & PGLUE_B_PGLUE_B_INT_STS_REG_WAS_ERROR_ATTN)
-                       PMD_DRV_LOG(INFO,
+                       PMD_DRV_LOG(INFO, sc,
                                    "ERROR: PGLUE_B_PGLUE_B_INT_STS_REG_WAS_ERROR_ATTN");
                if (val & PGLUE_B_PGLUE_B_INT_STS_REG_VF_LENGTH_VIOLATION_ATTN)
-                       PMD_DRV_LOG(INFO,
+                       PMD_DRV_LOG(INFO, sc,
                                    "ERROR: PGLUE_B_PGLUE_B_INT_STS_REG_VF_LENGTH_VIOLATION_ATTN");
                if (val &
                    PGLUE_B_PGLUE_B_INT_STS_REG_VF_GRC_SPACE_VIOLATION_ATTN)
-                       PMD_DRV_LOG(INFO,
+                       PMD_DRV_LOG(INFO, sc,
                                    "ERROR: PGLUE_B_PGLUE_B_INT_STS_REG_VF_GRC_SPACE_VIOLATION_ATTN");
                if (val &
                    PGLUE_B_PGLUE_B_INT_STS_REG_VF_MSIX_BAR_VIOLATION_ATTN)
-                       PMD_DRV_LOG(INFO,
+                       PMD_DRV_LOG(INFO, sc,
                                    "ERROR: PGLUE_B_PGLUE_B_INT_STS_REG_VF_MSIX_BAR_VIOLATION_ATTN");
                if (val & PGLUE_B_PGLUE_B_INT_STS_REG_TCPL_ERROR_ATTN)
-                       PMD_DRV_LOG(INFO,
+                       PMD_DRV_LOG(INFO, sc,
                                    "ERROR: PGLUE_B_PGLUE_B_INT_STS_REG_TCPL_ERROR_ATTN");
                if (val & PGLUE_B_PGLUE_B_INT_STS_REG_TCPL_IN_TWO_RCBS_ATTN)
-                       PMD_DRV_LOG(INFO,
+                       PMD_DRV_LOG(INFO, sc,
                                    "ERROR: PGLUE_B_PGLUE_B_INT_STS_REG_TCPL_IN_TWO_RCBS_ATTN");
                if (val & PGLUE_B_PGLUE_B_INT_STS_REG_CSSNOOP_FIFO_OVERFLOW)
-                       PMD_DRV_LOG(INFO,
+                       PMD_DRV_LOG(INFO, sc,
                                    "ERROR: PGLUE_B_PGLUE_B_INT_STS_REG_CSSNOOP_FIFO_OVERFLOW");
        }
 
        if (attn & AEU_INPUTS_ATTN_BITS_ATC_HW_INTERRUPT) {
                val = REG_RD(sc, ATC_REG_ATC_INT_STS_CLR);
-               PMD_DRV_LOG(INFO, "ERROR: ATC hw attention 0x%08x", val);
+               PMD_DRV_LOG(INFO, sc, "ERROR: ATC hw attention 0x%08x", val);
                if (val & ATC_ATC_INT_STS_REG_ADDRESS_ERROR)
-                       PMD_DRV_LOG(INFO,
+                       PMD_DRV_LOG(INFO, sc,
                                    "ERROR: ATC_ATC_INT_STS_REG_ADDRESS_ERROR");
                if (val & ATC_ATC_INT_STS_REG_ATC_TCPL_TO_NOT_PEND)
-                       PMD_DRV_LOG(INFO,
+                       PMD_DRV_LOG(INFO, sc,
                                    "ERROR: ATC_ATC_INT_STS_REG_ATC_TCPL_TO_NOT_PEND");
                if (val & ATC_ATC_INT_STS_REG_ATC_GPA_MULTIPLE_HITS)
-                       PMD_DRV_LOG(INFO,
+                       PMD_DRV_LOG(INFO, sc,
                                    "ERROR: ATC_ATC_INT_STS_REG_ATC_GPA_MULTIPLE_HITS");
                if (val & ATC_ATC_INT_STS_REG_ATC_RCPL_TO_EMPTY_CNT)
-                       PMD_DRV_LOG(INFO,
+                       PMD_DRV_LOG(INFO, sc,
                                    "ERROR: ATC_ATC_INT_STS_REG_ATC_RCPL_TO_EMPTY_CNT");
                if (val & ATC_ATC_INT_STS_REG_ATC_TCPL_ERROR)
-                       PMD_DRV_LOG(INFO,
+                       PMD_DRV_LOG(INFO, sc,
                                    "ERROR: ATC_ATC_INT_STS_REG_ATC_TCPL_ERROR");
                if (val & ATC_ATC_INT_STS_REG_ATC_IREQ_LESS_THAN_STU)
-                       PMD_DRV_LOG(INFO,
+                       PMD_DRV_LOG(INFO, sc,
                                    "ERROR: ATC_ATC_INT_STS_REG_ATC_IREQ_LESS_THAN_STU");
        }
 
        if (attn & (AEU_INPUTS_ATTN_BITS_PGLUE_PARITY_ERROR |
                    AEU_INPUTS_ATTN_BITS_ATC_PARITY_ERROR)) {
-               PMD_DRV_LOG(INFO,
+               PMD_DRV_LOG(INFO, sc,
                            "ERROR: FATAL parity attention set4 0x%08x",
                            (uint32_t) (attn &
                                        (AEU_INPUTS_ATTN_BITS_PGLUE_PARITY_ERROR
@@ -3594,11 +3600,11 @@ static void bnx2x_dcc_event(struct bnx2x_softc *sc, uint32_t dcc_event)
  */
                if (sc->devinfo.
                    mf_info.mf_config[SC_VN(sc)] & FUNC_MF_CFG_FUNC_DISABLED) {
-                       PMD_DRV_LOG(DEBUG, "mf_cfg function disabled");
+                       PMD_DRV_LOG(DEBUG, sc, "mf_cfg function disabled");
                        sc->flags |= BNX2X_MF_FUNC_DIS;
                        bnx2x_e1h_disable(sc);
                } else {
-                       PMD_DRV_LOG(DEBUG, "mf_cfg function enabled");
+                       PMD_DRV_LOG(DEBUG, sc, "mf_cfg function enabled");
                        sc->flags &= ~BNX2X_MF_FUNC_DIS;
                        bnx2x_e1h_enable(sc);
                }
@@ -3653,7 +3659,7 @@ static int bnx2x_mc_assert(struct bnx2x_softc *sc)
        last_idx =
            REG_RD8(sc, BAR_XSTRORM_INTMEM + XSTORM_ASSERT_LIST_INDEX_OFFSET);
        if (last_idx)
-               PMD_DRV_LOG(ERR, "XSTORM_ASSERT_LIST_INDEX 0x%x", last_idx);
+               PMD_DRV_LOG(ERR, sc, "XSTORM_ASSERT_LIST_INDEX 0x%x", last_idx);
 
        /* print the asserts */
        for (i = 0; i < STORM_ASSERT_ARRAY_SIZE; i++) {
@@ -3675,7 +3681,7 @@ static int bnx2x_mc_assert(struct bnx2x_softc *sc)
                           12);
 
                if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
-                       PMD_DRV_LOG(ERR,
+                       PMD_DRV_LOG(ERR, sc,
                                    "XSTORM_ASSERT_INDEX 0x%x = 0x%08x 0x%08x 0x%08x 0x%08x",
                                    i, row3, row2, row1, row0);
                        rc++;
@@ -3688,7 +3694,7 @@ static int bnx2x_mc_assert(struct bnx2x_softc *sc)
        last_idx =
            REG_RD8(sc, BAR_TSTRORM_INTMEM + TSTORM_ASSERT_LIST_INDEX_OFFSET);
        if (last_idx) {
-               PMD_DRV_LOG(ERR, "TSTORM_ASSERT_LIST_INDEX 0x%x", last_idx);
+               PMD_DRV_LOG(ERR, sc, "TSTORM_ASSERT_LIST_INDEX 0x%x", last_idx);
        }
 
        /* print the asserts */
@@ -3711,7 +3717,7 @@ static int bnx2x_mc_assert(struct bnx2x_softc *sc)
                           12);
 
                if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
-                       PMD_DRV_LOG(ERR,
+                       PMD_DRV_LOG(ERR, sc,
                                    "TSTORM_ASSERT_INDEX 0x%x = 0x%08x 0x%08x 0x%08x 0x%08x",
                                    i, row3, row2, row1, row0);
                        rc++;
@@ -3724,7 +3730,7 @@ static int bnx2x_mc_assert(struct bnx2x_softc *sc)
        last_idx =
            REG_RD8(sc, BAR_CSTRORM_INTMEM + CSTORM_ASSERT_LIST_INDEX_OFFSET);
        if (last_idx) {
-               PMD_DRV_LOG(ERR, "CSTORM_ASSERT_LIST_INDEX 0x%x", last_idx);
+               PMD_DRV_LOG(ERR, sc, "CSTORM_ASSERT_LIST_INDEX 0x%x", last_idx);
        }
 
        /* print the asserts */
@@ -3747,7 +3753,7 @@ static int bnx2x_mc_assert(struct bnx2x_softc *sc)
                           12);
 
                if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
-                       PMD_DRV_LOG(ERR,
+                       PMD_DRV_LOG(ERR, sc,
                                    "CSTORM_ASSERT_INDEX 0x%x = 0x%08x 0x%08x 0x%08x 0x%08x",
                                    i, row3, row2, row1, row0);
                        rc++;
@@ -3760,7 +3766,7 @@ static int bnx2x_mc_assert(struct bnx2x_softc *sc)
        last_idx =
            REG_RD8(sc, BAR_USTRORM_INTMEM + USTORM_ASSERT_LIST_INDEX_OFFSET);
        if (last_idx) {
-               PMD_DRV_LOG(ERR, "USTORM_ASSERT_LIST_INDEX 0x%x", last_idx);
+               PMD_DRV_LOG(ERR, sc, "USTORM_ASSERT_LIST_INDEX 0x%x", last_idx);
        }
 
        /* print the asserts */
@@ -3783,7 +3789,7 @@ static int bnx2x_mc_assert(struct bnx2x_softc *sc)
                           12);
 
                if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
-                       PMD_DRV_LOG(ERR,
+                       PMD_DRV_LOG(ERR, sc,
                                    "USTORM_ASSERT_INDEX 0x%x = 0x%08x 0x%08x 0x%08x 0x%08x",
                                    i, row3, row2, row1, row0);
                        rc++;
@@ -3848,7 +3854,7 @@ static void bnx2x_attn_int_deasserted3(struct bnx2x_softc *sc, uint32_t attn)
 
                } else if (attn & BNX2X_MC_ASSERT_BITS) {
 
-                       PMD_DRV_LOG(ERR, "MC assert!");
+                       PMD_DRV_LOG(ERR, sc, "MC assert!");
                        bnx2x_mc_assert(sc);
                        REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_10, 0);
                        REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_9, 0);
@@ -3858,24 +3864,24 @@ static void bnx2x_attn_int_deasserted3(struct bnx2x_softc *sc, uint32_t attn)
 
                } else if (attn & BNX2X_MCP_ASSERT) {
 
-                       PMD_DRV_LOG(ERR, "MCP assert!");
+                       PMD_DRV_LOG(ERR, sc, "MCP assert!");
                        REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_11, 0);
 
                } else {
-                       PMD_DRV_LOG(ERR,
+                       PMD_DRV_LOG(ERR, sc,
                                    "Unknown HW assert! (attn 0x%08x)", attn);
                }
        }
 
        if (attn & EVEREST_LATCHED_ATTN_IN_USE_MASK) {
-               PMD_DRV_LOG(ERR, "LATCHED attention 0x%08x (masked)", attn);
+               PMD_DRV_LOG(ERR, sc, "LATCHED attention 0x%08x (masked)", attn);
                if (attn & BNX2X_GRC_TIMEOUT) {
                        val = REG_RD(sc, MISC_REG_GRC_TIMEOUT_ATTN);
-                       PMD_DRV_LOG(ERR, "GRC time-out 0x%08x", val);
+                       PMD_DRV_LOG(ERR, sc, "GRC time-out 0x%08x", val);
                }
                if (attn & BNX2X_GRC_RSV) {
                        val = REG_RD(sc, MISC_REG_GRC_RSV_ATTN);
-                       PMD_DRV_LOG(ERR, "GRC reserved 0x%08x", val);
+                       PMD_DRV_LOG(ERR, sc, "GRC reserved 0x%08x", val);
                }
                REG_WR(sc, MISC_REG_AEU_CLR_LATCH_SIGNAL, 0x7ff);
        }
@@ -3890,24 +3896,24 @@ static void bnx2x_attn_int_deasserted2(struct bnx2x_softc *sc, uint32_t attn)
 
        if (attn & AEU_INPUTS_ATTN_BITS_CFC_HW_INTERRUPT) {
                val = REG_RD(sc, CFC_REG_CFC_INT_STS_CLR);
-               PMD_DRV_LOG(ERR, "CFC hw attention 0x%08x", val);
+               PMD_DRV_LOG(ERR, sc, "CFC hw attention 0x%08x", val);
 /* CFC error attention */
                if (val & 0x2) {
-                       PMD_DRV_LOG(ERR, "FATAL error from CFC");
+                       PMD_DRV_LOG(ERR, sc, "FATAL error from CFC");
                }
        }
 
        if (attn & AEU_INPUTS_ATTN_BITS_PXP_HW_INTERRUPT) {
                val = REG_RD(sc, PXP_REG_PXP_INT_STS_CLR_0);
-               PMD_DRV_LOG(ERR, "PXP hw attention-0 0x%08x", val);
+               PMD_DRV_LOG(ERR, sc, "PXP hw attention-0 0x%08x", val);
 /* RQ_USDMDP_FIFO_OVERFLOW */
                if (val & 0x18000) {
-                       PMD_DRV_LOG(ERR, "FATAL error from PXP");
+                       PMD_DRV_LOG(ERR, sc, "FATAL error from PXP");
                }
 
                if (!CHIP_IS_E1x(sc)) {
                        val = REG_RD(sc, PXP_REG_PXP_INT_STS_CLR_1);
-                       PMD_DRV_LOG(ERR, "PXP hw attention-1 0x%08x", val);
+                       PMD_DRV_LOG(ERR, sc, "PXP hw attention-1 0x%08x", val);
                }
        }
 #define PXP2_EOP_ERROR_BIT  PXP2_PXP2_INT_STS_CLR_0_REG_WR_PGLUE_EOP_ERROR
@@ -3935,7 +3941,7 @@ static void bnx2x_attn_int_deasserted2(struct bnx2x_softc *sc, uint32_t attn)
                                val0 = REG_RD(sc, PXP2_REG_PXP2_INT_STS_CLR_0);
 
                        /* print the register, since no one can restore it */
-                       PMD_DRV_LOG(ERR,
+                       PMD_DRV_LOG(ERR, sc,
                                    "PXP2_REG_PXP2_INT_STS_CLR_0 0x%08x", val0);
 
                        /*
@@ -3943,7 +3949,7 @@ static void bnx2x_attn_int_deasserted2(struct bnx2x_softc *sc, uint32_t attn)
                         * then notify
                         */
                        if (val0 & PXP2_EOP_ERROR_BIT) {
-                               PMD_DRV_LOG(ERR, "PXP2_WR_PGLUE_EOP_ERROR");
+                               PMD_DRV_LOG(ERR, sc, "PXP2_WR_PGLUE_EOP_ERROR");
 
                                /*
                                 * if only PXP2_PXP2_INT_STS_0_REG_WR_PGLUE_EOP_ERROR is
@@ -3964,7 +3970,7 @@ static void bnx2x_attn_int_deasserted2(struct bnx2x_softc *sc, uint32_t attn)
                val &= ~(attn & HW_INTERRUT_ASSERT_SET_2);
                REG_WR(sc, reg_offset, val);
 
-               PMD_DRV_LOG(ERR,
+               PMD_DRV_LOG(ERR, sc,
                            "FATAL HW block attention set2 0x%x",
                            (uint32_t) (attn & HW_INTERRUT_ASSERT_SET_2));
                rte_panic("HW block attention set2");
@@ -3979,10 +3985,10 @@ static void bnx2x_attn_int_deasserted1(struct bnx2x_softc *sc, uint32_t attn)
 
        if (attn & AEU_INPUTS_ATTN_BITS_DOORBELLQ_HW_INTERRUPT) {
                val = REG_RD(sc, DORQ_REG_DORQ_INT_STS_CLR);
-               PMD_DRV_LOG(ERR, "DB hw attention 0x%08x", val);
+               PMD_DRV_LOG(ERR, sc, "DB hw attention 0x%08x", val);
 /* DORQ discard attention */
                if (val & 0x2) {
-                       PMD_DRV_LOG(ERR, "FATAL error from DORQ");
+                       PMD_DRV_LOG(ERR, sc, "FATAL error from DORQ");
                }
        }
 
@@ -3994,7 +4000,7 @@ static void bnx2x_attn_int_deasserted1(struct bnx2x_softc *sc, uint32_t attn)
                val &= ~(attn & HW_INTERRUT_ASSERT_SET_1);
                REG_WR(sc, reg_offset, val);
 
-               PMD_DRV_LOG(ERR,
+               PMD_DRV_LOG(ERR, sc,
                            "FATAL HW block attention set1 0x%08x",
                            (uint32_t) (attn & HW_INTERRUT_ASSERT_SET_1));
                rte_panic("HW block attention set1");
@@ -4015,7 +4021,7 @@ static void bnx2x_attn_int_deasserted0(struct bnx2x_softc *sc, uint32_t attn)
                val &= ~AEU_INPUTS_ATTN_BITS_SPIO5;
                REG_WR(sc, reg_offset, val);
 
-               PMD_DRV_LOG(WARNING, "SPIO5 hw attention");
+               PMD_DRV_LOG(WARNING, sc, "SPIO5 hw attention");
 
 /* Fan failure attention */
                elink_hw_reset_phy(&sc->link_params);
@@ -4105,14 +4111,14 @@ static void bnx2x_attn_int_deasserted(struct bnx2x_softc *sc, uint32_t deasserte
        }
 
        val = ~deasserted;
-       PMD_DRV_LOG(DEBUG,
+       PMD_DRV_LOG(DEBUG, sc,
                    "about to mask 0x%08x at %s addr 0x%08x", val,
                    (sc->devinfo.int_block == INT_BLOCK_HC) ? "HC" : "IGU",
                    reg_addr);
        REG_WR(sc, reg_addr, val);
 
        if (~sc->attn_state & deasserted) {
-               PMD_DRV_LOG(ERR, "IGU error");
+               PMD_DRV_LOG(ERR, sc, "IGU error");
        }
 
        reg_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
@@ -4142,12 +4148,12 @@ static void bnx2x_attn_int(struct bnx2x_softc *sc)
        uint32_t asserted = attn_bits & ~attn_ack & ~attn_state;
        uint32_t deasserted = ~attn_bits & attn_ack & attn_state;
 
-       PMD_DRV_LOG(DEBUG,
+       PMD_DRV_LOG(DEBUG, sc,
                    "attn_bits 0x%08x attn_ack 0x%08x asserted 0x%08x deasserted 0x%08x",
                    attn_bits, attn_ack, asserted, deasserted);
 
        if (~(attn_bits ^ attn_ack) & (attn_bits ^ attn_state)) {
-               PMD_DRV_LOG(ERR, "BAD attention state");
+               PMD_DRV_LOG(ERR, sc, "BAD attention state");
        }
 
        /* handle bits that were raised */
@@ -4204,7 +4210,7 @@ static void bnx2x_handle_mcast_eqe(struct bnx2x_softc *sc)
        if (sc->mcast_obj.check_pending(&sc->mcast_obj)) {
                rc = ecore_config_mcast(sc, &rparam, ECORE_MCAST_CMD_CONT);
                if (rc < 0) {
-                       PMD_DRV_LOG(INFO,
+                       PMD_DRV_LOG(INFO, sc,
                                    "Failed to send pending mcast commands (%d)",
                                    rc);
                }
@@ -4224,17 +4230,17 @@ bnx2x_handle_classification_eqe(struct bnx2x_softc *sc, union event_ring_elem *e
 
        switch (le32toh(elem->message.data.eth_event.echo) >> BNX2X_SWCID_SHIFT) {
        case ECORE_FILTER_MAC_PENDING:
-               PMD_DRV_LOG(DEBUG, "Got SETUP_MAC completions");
+               PMD_DRV_LOG(DEBUG, sc, "Got SETUP_MAC completions");
                vlan_mac_obj = &sc->sp_objs[cid].mac_obj;
                break;
 
        case ECORE_FILTER_MCAST_PENDING:
-               PMD_DRV_LOG(DEBUG, "Got SETUP_MCAST completions");
+               PMD_DRV_LOG(DEBUG, sc, "Got SETUP_MCAST completions");
                bnx2x_handle_mcast_eqe(sc);
                return;
 
        default:
-               PMD_DRV_LOG(NOTICE, "Unsupported classification command: %d",
+               PMD_DRV_LOG(NOTICE, sc, "Unsupported classification command: %d",
                            elem->message.data.eth_event.echo);
                return;
        }
@@ -4242,9 +4248,10 @@ bnx2x_handle_classification_eqe(struct bnx2x_softc *sc, union event_ring_elem *e
        rc = vlan_mac_obj->complete(sc, vlan_mac_obj, elem, &ramrod_flags);
 
        if (rc < 0) {
-               PMD_DRV_LOG(NOTICE, "Failed to schedule new commands (%d)", rc);
+               PMD_DRV_LOG(NOTICE, sc,
+                           "Failed to schedule new commands (%d)", rc);
        } else if (rc > 0) {
-               PMD_DRV_LOG(DEBUG, "Scheduled next pending commands...");
+               PMD_DRV_LOG(DEBUG, sc, "Scheduled next pending commands...");
        }
 }
 
@@ -4308,7 +4315,7 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
 /* handle eq element */
                switch (opcode) {
                case EVENT_RING_OPCODE_STAT_QUERY:
-                       PMD_DEBUG_PERIODIC_LOG(DEBUG, "got statistics completion event %d",
+                       PMD_DEBUG_PERIODIC_LOG(DEBUG, sc, "got statistics completion event %d",
                                    sc->stats_comp++);
                        /* nothing to do with stats comp */
                        goto next_spqe;
@@ -4316,7 +4323,7 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
                case EVENT_RING_OPCODE_CFC_DEL:
                        /* handle according to cid range */
                        /* we may want to verify here that the sc state is HALTING */
-                       PMD_DRV_LOG(DEBUG, "got delete ramrod for MULTI[%d]",
+                       PMD_DRV_LOG(DEBUG, sc, "got delete ramrod for MULTI[%d]",
                                    cid);
                        q_obj = bnx2x_cid_to_q_obj(sc, cid);
                        if (q_obj->complete_cmd(sc, q_obj, ECORE_Q_CMD_CFC_DEL)) {
@@ -4325,14 +4332,14 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
                        goto next_spqe;
 
                case EVENT_RING_OPCODE_STOP_TRAFFIC:
-                       PMD_DRV_LOG(DEBUG, "got STOP TRAFFIC");
+                       PMD_DRV_LOG(DEBUG, sc, "got STOP TRAFFIC");
                        if (f_obj->complete_cmd(sc, f_obj, ECORE_F_CMD_TX_STOP)) {
                                break;
                        }
                        goto next_spqe;
 
                case EVENT_RING_OPCODE_START_TRAFFIC:
-                       PMD_DRV_LOG(DEBUG, "got START TRAFFIC");
+                       PMD_DRV_LOG(DEBUG, sc, "got START TRAFFIC");
                        if (f_obj->complete_cmd
                            (sc, f_obj, ECORE_F_CMD_TX_START)) {
                                break;
@@ -4342,7 +4349,7 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
                case EVENT_RING_OPCODE_FUNCTION_UPDATE:
                        echo = elem->message.data.function_update_event.echo;
                        if (echo == SWITCH_UPDATE) {
-                               PMD_DRV_LOG(DEBUG,
+                               PMD_DRV_LOG(DEBUG, sc,
                                            "got FUNC_SWITCH_UPDATE ramrod");
                                if (f_obj->complete_cmd(sc, f_obj,
                                                        ECORE_F_CMD_SWITCH_UPDATE))
@@ -4350,7 +4357,7 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
                                        break;
                                }
                        } else {
-                               PMD_DRV_LOG(DEBUG,
+                               PMD_DRV_LOG(DEBUG, sc,
                                            "AFEX: ramrod completed FUNCTION_UPDATE");
                                f_obj->complete_cmd(sc, f_obj,
                                                    ECORE_F_CMD_AFEX_UPDATE);
@@ -4366,14 +4373,14 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
                        goto next_spqe;
 
                case EVENT_RING_OPCODE_FUNCTION_START:
-                       PMD_DRV_LOG(DEBUG, "got FUNC_START ramrod");
+                       PMD_DRV_LOG(DEBUG, sc, "got FUNC_START ramrod");
                        if (f_obj->complete_cmd(sc, f_obj, ECORE_F_CMD_START)) {
                                break;
                        }
                        goto next_spqe;
 
                case EVENT_RING_OPCODE_FUNCTION_STOP:
-                       PMD_DRV_LOG(DEBUG, "got FUNC_STOP ramrod");
+                       PMD_DRV_LOG(DEBUG, sc, "got FUNC_STOP ramrod");
                        if (f_obj->complete_cmd(sc, f_obj, ECORE_F_CMD_STOP)) {
                                break;
                        }
@@ -4385,7 +4392,7 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
                case (EVENT_RING_OPCODE_RSS_UPDATE_RULES | BNX2X_STATE_OPENING_WAITING_PORT):
                        cid =
                            elem->message.data.eth_event.echo & BNX2X_SWCID_MASK;
-                       PMD_DRV_LOG(DEBUG, "got RSS_UPDATE ramrod. CID %d",
+                       PMD_DRV_LOG(DEBUG, sc, "got RSS_UPDATE ramrod. CID %d",
                                    cid);
                        rss_raw->clear_pending(rss_raw);
                        break;
@@ -4396,7 +4403,7 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
                case (EVENT_RING_OPCODE_CLASSIFICATION_RULES | BNX2X_STATE_OPEN):
                case (EVENT_RING_OPCODE_CLASSIFICATION_RULES | BNX2X_STATE_DIAG):
                case (EVENT_RING_OPCODE_CLASSIFICATION_RULES | BNX2X_STATE_CLOSING_WAITING_HALT):
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                                    "got (un)set mac ramrod");
                        bnx2x_handle_classification_eqe(sc, elem);
                        break;
@@ -4404,7 +4411,7 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
                case (EVENT_RING_OPCODE_MULTICAST_RULES | BNX2X_STATE_OPEN):
                case (EVENT_RING_OPCODE_MULTICAST_RULES | BNX2X_STATE_DIAG):
                case (EVENT_RING_OPCODE_MULTICAST_RULES | BNX2X_STATE_CLOSING_WAITING_HALT):
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                                    "got mcast ramrod");
                        bnx2x_handle_mcast_eqe(sc);
                        break;
@@ -4412,14 +4419,14 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
                case (EVENT_RING_OPCODE_FILTERS_RULES | BNX2X_STATE_OPEN):
                case (EVENT_RING_OPCODE_FILTERS_RULES | BNX2X_STATE_DIAG):
                case (EVENT_RING_OPCODE_FILTERS_RULES | BNX2X_STATE_CLOSING_WAITING_HALT):
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                                    "got rx_mode ramrod");
                        bnx2x_handle_rx_mode_eqe(sc);
                        break;
 
                default:
                        /* unknown event log error and continue */
-                       PMD_DRV_LOG(INFO, "Unknown EQ event %d, sc->state 0x%x",
+                       PMD_DRV_LOG(INFO, sc, "Unknown EQ event %d, sc->state 0x%x",
                                    elem->message.opcode, sc->state);
                }
 
@@ -4445,12 +4452,16 @@ static int bnx2x_handle_sp_tq(struct bnx2x_softc *sc)
        uint16_t status;
        int rc = 0;
 
+       PMD_DRV_LOG(DEBUG, sc, "---> SP TASK <---");
+
        /* what work needs to be performed? */
        status = bnx2x_update_dsb_idx(sc);
 
+       PMD_DRV_LOG(DEBUG, sc, "dsb status 0x%04x", status);
+
        /* HW attentions */
        if (status & BNX2X_DEF_SB_ATT_IDX) {
-               PMD_DRV_LOG(DEBUG, "---> ATTN INTR <---");
+               PMD_DRV_LOG(DEBUG, sc, "---> ATTN INTR <---");
                bnx2x_attn_int(sc);
                status &= ~BNX2X_DEF_SB_ATT_IDX;
                rc = 1;
@@ -4459,7 +4470,7 @@ static int bnx2x_handle_sp_tq(struct bnx2x_softc *sc)
        /* SP events: STAT_QUERY and others */
        if (status & BNX2X_DEF_SB_IDX) {
 /* handle EQ completions */
-               PMD_DEBUG_PERIODIC_LOG(DEBUG, "---> EQ INTR <---");
+               PMD_DRV_LOG(DEBUG, sc, "---> EQ INTR <---");
                bnx2x_eq_int(sc);
                bnx2x_ack_sb(sc, sc->igu_dsb_id, USTORM_ID,
                           le16toh(sc->def_idx), IGU_INT_NOP, 1);
@@ -4468,7 +4479,7 @@ static int bnx2x_handle_sp_tq(struct bnx2x_softc *sc)
 
        /* if status is non zero then something went wrong */
        if (unlikely(status)) {
-               PMD_DRV_LOG(INFO,
+               PMD_DRV_LOG(INFO, sc,
                            "Got an unknown SP interrupt! (0x%04x)", status);
        }
 
@@ -4484,7 +4495,8 @@ static void bnx2x_handle_fp_tq(struct bnx2x_fastpath *fp, int scan_fp)
        struct bnx2x_softc *sc = fp->sc;
        uint8_t more_rx = FALSE;
 
-       PMD_DRV_LOG(DEBUG, "---> FP TASK QUEUE (%d) <--", fp->index);
+       PMD_DEBUG_PERIODIC_LOG(DEBUG, sc,
+                              "---> FP TASK QUEUE (%d) <--", fp->index);
 
        /* update the fastpath index */
        bnx2x_update_fp_sb_idx(fp);
@@ -4534,7 +4546,7 @@ int bnx2x_intr_legacy(struct bnx2x_softc *sc, int scan_fp)
                return 0;
        }
 
-       PMD_DEBUG_PERIODIC_LOG(DEBUG, "Interrupt status 0x%04x", status);
+       PMD_DEBUG_PERIODIC_LOG(DEBUG, sc, "Interrupt status 0x%04x", status);
        //bnx2x_dump_status_block(sc);
 
        FOR_EACH_ETH_QUEUE(sc, i) {
@@ -4552,7 +4564,7 @@ int bnx2x_intr_legacy(struct bnx2x_softc *sc, int scan_fp)
        }
 
        if (unlikely(status)) {
-               PMD_DRV_LOG(WARNING,
+               PMD_DRV_LOG(WARNING, sc,
                            "Unexpected fastpath status (0x%08x)!", status);
        }
 
@@ -4588,7 +4600,7 @@ static void bnx2x_init_func_obj(struct bnx2x_softc *sc)
 {
        sc->dmae_ready = 0;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        ecore_init_func_obj(sc,
                            &sc->func_obj,
@@ -4604,7 +4616,7 @@ static int bnx2x_init_hw(struct bnx2x_softc *sc, uint32_t load_code)
        struct ecore_func_state_params func_params = { NULL };
        int rc;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        /* prepare the parameters for function state transitions */
        bnx2x_set_bit(RAMROD_COMP_WAIT, &func_params.ramrod_flags);
@@ -5193,7 +5205,7 @@ static void bnx2x_init_internal(struct bnx2x_softc *sc, uint32_t load_code)
                break;
 
        default:
-               PMD_DRV_LOG(NOTICE, "Unknown load_code (0x%x) from MCP",
+               PMD_DRV_LOG(NOTICE, sc, "Unknown load_code (0x%x) from MCP",
                            load_code);
                break;
        }
@@ -5284,7 +5296,7 @@ bnx2x_extract_max_cfg(__rte_unused struct bnx2x_softc *sc, uint32_t mf_cfg)
                            FUNC_MF_CFG_MAX_BW_SHIFT);
 
        if (!max_cfg) {
-               PMD_DRV_LOG(DEBUG,
+               PMD_DRV_LOG(DEBUG, sc,
                            "Max BW configured to 0 - using 100 instead");
                max_cfg = 100;
        }
@@ -5548,7 +5560,7 @@ static void bnx2x_igu_int_enable(struct bnx2x_softc *sc)
 
        val |= IGU_PF_CONF_FUNC_EN;
 
-       PMD_DRV_LOG(DEBUG, "write 0x%x to IGU mode %s",
+       PMD_DRV_LOG(DEBUG, sc, "write 0x%x to IGU mode %s",
                    val, ((msix) ? "MSI-X" : ((msi) ? "MSI" : "INTx")));
 
        REG_WR(sc, IGU_REG_PF_CONFIGURATION, val);
@@ -5596,7 +5608,7 @@ static void bnx2x_hc_int_disable(struct bnx2x_softc *sc)
 
        REG_WR(sc, addr, val);
        if (REG_RD(sc, addr) != val) {
-               PMD_DRV_LOG(ERR, "proper val not read from HC IGU!");
+               PMD_DRV_LOG(ERR, sc, "proper val not read from HC IGU!");
        }
 }
 
@@ -5607,14 +5619,14 @@ static void bnx2x_igu_int_disable(struct bnx2x_softc *sc)
        val &= ~(IGU_PF_CONF_MSI_MSIX_EN |
                 IGU_PF_CONF_INT_LINE_EN | IGU_PF_CONF_ATTN_BIT_EN);
 
-       PMD_DRV_LOG(DEBUG, "write %x to IGU", val);
+       PMD_DRV_LOG(DEBUG, sc, "write %x to IGU", val);
 
        /* flush all outstanding writes */
        mb();
 
        REG_WR(sc, IGU_REG_PF_CONFIGURATION, val);
        if (REG_RD(sc, IGU_REG_PF_CONFIGURATION) != val) {
-               PMD_DRV_LOG(ERR, "proper val not read from IGU!");
+               PMD_DRV_LOG(ERR, sc, "proper val not read from IGU!");
        }
 }
 
@@ -5631,7 +5643,7 @@ static void bnx2x_nic_init(struct bnx2x_softc *sc, int load_code)
 {
        int i;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        for (i = 0; i < sc->num_queues; i++) {
                bnx2x_init_eth_fp(sc, i);
@@ -5761,7 +5773,7 @@ static int bnx2x_set_power_state(struct bnx2x_softc *sc, uint8_t state)
 
        /* If there is no power capability, silently succeed */
        if (!(sc->devinfo.pcie_cap_flags & BNX2X_PM_CAPABLE_FLAG)) {
-               PMD_DRV_LOG(WARNING, "No power capability");
+               PMD_DRV_LOG(WARNING, sc, "No power capability");
                return 0;
        }
 
@@ -5806,7 +5818,7 @@ static int bnx2x_set_power_state(struct bnx2x_softc *sc, uint8_t state)
                break;
 
        default:
-               PMD_DRV_LOG(NOTICE, "Can't support PCI power state = %d",
+               PMD_DRV_LOG(NOTICE, sc, "Can't support PCI power state = %d",
                            state);
                return -1;
        }
@@ -5824,7 +5836,7 @@ static uint8_t bnx2x_trylock_hw_lock(struct bnx2x_softc *sc, uint32_t resource)
 
        /* Validating that the resource is within range */
        if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
-               PMD_DRV_LOG(INFO,
+               PMD_DRV_LOG(INFO, sc,
                            "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)",
                            resource, HW_LOCK_MAX_RESOURCE_VALUE);
                return FALSE;
@@ -5844,7 +5856,7 @@ static uint8_t bnx2x_trylock_hw_lock(struct bnx2x_softc *sc, uint32_t resource)
                return TRUE;
        }
 
-       PMD_DRV_LOG(NOTICE, "Failed to get a resource lock 0x%x", resource);
+       PMD_DRV_LOG(NOTICE, sc, "Failed to get a resource lock 0x%x", resource);
 
        return FALSE;
 }
@@ -5937,7 +5949,7 @@ static int bnx2x_er_poll_igu_vq(struct bnx2x_softc *sc)
        } while (cnt-- > 0);
 
        if (cnt <= 0) {
-               PMD_DRV_LOG(NOTICE, "Still pending IGU requests bits=0x%08x!",
+               PMD_DRV_LOG(NOTICE, sc, "Still pending IGU requests bits=0x%08x!",
                            pend_bits);
                return -1;
        }
@@ -6018,7 +6030,7 @@ static int bnx2x_init_shmem(struct bnx2x_softc *sc)
 
        } while (cnt++ < (MCP_TIMEOUT / MCP_ONE_TIMEOUT));
 
-       PMD_DRV_LOG(NOTICE, "BAD MCP validity signature");
+       PMD_DRV_LOG(NOTICE, sc, "BAD MCP validity signature");
 
        return -1;
 }
@@ -6173,7 +6185,7 @@ static int bnx2x_process_kill(struct bnx2x_softc *sc, uint8_t global)
        } while (cnt-- > 0);
 
        if (cnt <= 0) {
-               PMD_DRV_LOG(NOTICE,
+               PMD_DRV_LOG(NOTICE, sc,
                            "ERROR: Tetris buffer didn't get empty or there "
                            "are still outstanding read requests after 1s! "
                            "sr_cnt=0x%08x, blk_cnt=0x%08x, port_is_idle_0=0x%08x, "
@@ -6246,14 +6258,14 @@ static int bnx2x_leader_reset(struct bnx2x_softc *sc)
                load_code = bnx2x_fw_command(sc, DRV_MSG_CODE_LOAD_REQ,
                                           DRV_MSG_CODE_LOAD_REQ_WITH_LFA);
                if (!load_code) {
-                       PMD_DRV_LOG(NOTICE, "MCP response failure, aborting");
+                       PMD_DRV_LOG(NOTICE, sc, "MCP response failure, aborting");
                        rc = -1;
                        goto exit_leader_reset;
                }
 
                if ((load_code != FW_MSG_CODE_DRV_LOAD_COMMON_CHIP) &&
                    (load_code != FW_MSG_CODE_DRV_LOAD_COMMON)) {
-                       PMD_DRV_LOG(NOTICE,
+                       PMD_DRV_LOG(NOTICE, sc,
                                    "MCP unexpected response, aborting");
                        rc = -1;
                        goto exit_leader_reset2;
@@ -6261,7 +6273,7 @@ static int bnx2x_leader_reset(struct bnx2x_softc *sc)
 
                load_code = bnx2x_fw_command(sc, DRV_MSG_CODE_LOAD_DONE, 0);
                if (!load_code) {
-                       PMD_DRV_LOG(NOTICE, "MCP response failure, aborting");
+                       PMD_DRV_LOG(NOTICE, sc, "MCP response failure, aborting");
                        rc = -1;
                        goto exit_leader_reset2;
                }
@@ -6269,7 +6281,7 @@ static int bnx2x_leader_reset(struct bnx2x_softc *sc)
 
        /* try to recover after the failure */
        if (bnx2x_process_kill(sc, global)) {
-               PMD_DRV_LOG(NOTICE, "Something bad occurred on engine %d!",
+               PMD_DRV_LOG(NOTICE, sc, "Something bad occurred on engine %d!",
                            SC_PATH(sc));
                rc = -1;
                goto exit_leader_reset2;
@@ -6428,12 +6440,12 @@ bnx2x_pf_rx_q_prep(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp,
        /* validate rings have enough entries to cross high thresholds */
        if (sc->dropless_fc &&
            pause->bd_th_hi + FW_PREFETCH_CNT > sc->rx_ring_size) {
-               PMD_DRV_LOG(WARNING, "rx bd ring threshold limit");
+               PMD_DRV_LOG(WARNING, sc, "rx bd ring threshold limit");
        }
 
        if (sc->dropless_fc &&
            pause->rcq_th_hi + FW_PREFETCH_CNT > USABLE_RCQ_ENTRIES(rxq)) {
-               PMD_DRV_LOG(WARNING, "rcq ring threshold limit");
+               PMD_DRV_LOG(WARNING, sc, "rcq ring threshold limit");
        }
 
        pause->pri_map = 1;
@@ -6504,7 +6516,7 @@ bnx2x_setup_queue(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp, uint8_t lea
        struct ecore_queue_setup_params *setup_params = &q_params.params.setup;
        int rc;
 
-       PMD_DRV_LOG(DEBUG, "setting up queue %d", fp->index);
+       PMD_DRV_LOG(DEBUG, sc, "setting up queue %d", fp->index);
 
        bnx2x_ack_sb(sc, fp->igu_sb_id, USTORM_ID, 0, IGU_INT_ENABLE, 0);
 
@@ -6522,11 +6534,11 @@ bnx2x_setup_queue(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp, uint8_t lea
        /* Change the state to INIT */
        rc = ecore_queue_state_change(sc, &q_params);
        if (rc) {
-               PMD_DRV_LOG(NOTICE, "Queue(%d) INIT failed", fp->index);
+               PMD_DRV_LOG(NOTICE, sc, "Queue(%d) INIT failed", fp->index);
                return rc;
        }
 
-       PMD_DRV_LOG(DEBUG, "init complete");
+       PMD_DRV_LOG(DEBUG, sc, "init complete");
 
        /* now move the Queue to the SETUP state */
        memset(setup_params, 0, sizeof(*setup_params));
@@ -6550,7 +6562,7 @@ bnx2x_setup_queue(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp, uint8_t lea
        /* change the state to SETUP */
        rc = ecore_queue_state_change(sc, &q_params);
        if (rc) {
-               PMD_DRV_LOG(NOTICE, "Queue(%d) SETUP failed", fp->index);
+               PMD_DRV_LOG(NOTICE, sc, "Queue(%d) SETUP failed", fp->index);
                return rc;
        }
 
@@ -6678,11 +6690,11 @@ bnx2x_set_mac_one(struct bnx2x_softc *sc, uint8_t * mac,
        rc = ecore_config_vlan_mac(sc, &ramrod_param);
 
        if (rc == ECORE_EXISTS) {
-               PMD_DRV_LOG(INFO, "Failed to schedule ADD operations (EEXIST)");
+               PMD_DRV_LOG(INFO, sc, "Failed to schedule ADD operations (EEXIST)");
 /* do not treat adding same MAC as error */
                rc = 0;
        } else if (rc < 0) {
-               PMD_DRV_LOG(ERR,
+               PMD_DRV_LOG(ERR, sc,
                            "%s MAC failed (%d)", (set ? "Set" : "Delete"), rc);
        }
 
@@ -6693,7 +6705,7 @@ static int bnx2x_set_eth_mac(struct bnx2x_softc *sc, uint8_t set)
 {
        unsigned long ramrod_flags = 0;
 
-       PMD_DRV_LOG(DEBUG, "Adding Ethernet MAC");
+       PMD_DRV_LOG(DEBUG, sc, "Adding Ethernet MAC");
 
        bnx2x_set_bit(RAMROD_COMP_WAIT, &ramrod_flags);
 
@@ -6877,7 +6889,7 @@ static void bnx2x_link_report(struct bnx2x_softc *sc)
 
        if (bnx2x_test_bit(BNX2X_LINK_REPORT_LINK_DOWN,
                         &cur_data.link_report_flags)) {
-               PMD_DRV_LOG(INFO, "NIC Link is Down");
+               PMD_DRV_LOG(INFO, sc, "NIC Link is Down");
        } else {
                __rte_unused const char *duplex;
                __rte_unused const char *flow;
@@ -6917,7 +6929,7 @@ static void bnx2x_link_report(struct bnx2x_softc *sc)
                        flow = "none";
                }
 
-               PMD_DRV_LOG(INFO,
+               PMD_DRV_LOG(INFO, sc,
                            "NIC Link is Up, %d Mbps %s duplex, Flow control: %s",
                            cur_data.line_speed, duplex, flow);
        }
@@ -7058,7 +7070,7 @@ void bnx2x_periodic_callout(struct bnx2x_softc *sc)
 {
        if ((sc->state != BNX2X_STATE_OPEN) ||
            (atomic_load_acq_long(&sc->periodic_flags) == PERIODIC_STOP)) {
-               PMD_DRV_LOG(WARNING, "periodic callout exit (state=0x%x)",
+               PMD_DRV_LOG(INFO, sc, "periodic callout exit (state=0x%x)",
                            sc->state);
                return;
        }
@@ -7095,7 +7107,7 @@ void bnx2x_periodic_callout(struct bnx2x_softc *sc)
                if ((drv_pulse != mcp_pulse) &&
                    (drv_pulse != ((mcp_pulse + 1) & MCP_PULSE_SEQ_MASK))) {
                        /* someone lost a heartbeat... */
-                       PMD_DRV_LOG(ERR,
+                       PMD_DRV_LOG(ERR, sc,
                                    "drv_pulse (0x%x) != mcp_pulse (0x%x)",
                                    drv_pulse, mcp_pulse);
                }
@@ -7111,7 +7123,7 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
        uint32_t load_code = 0;
        int i, rc = 0;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        sc->state = BNX2X_STATE_OPENING_WAITING_LOAD;
 
@@ -7165,7 +7177,7 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
                                goto bnx2x_nic_load_error2;
                        }
                } else {
-                       PMD_DRV_LOG(INFO, "Device has no MCP!");
+                       PMD_DRV_LOG(INFO, sc, "Device has no MCP!");
                        load_code = bnx2x_nic_load_no_mcp(sc);
                }
 
@@ -7177,7 +7189,7 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
 
 /* Initialize HW */
                if (bnx2x_init_hw(sc, load_code) != 0) {
-                       PMD_DRV_LOG(NOTICE, "HW init failed");
+                       PMD_DRV_LOG(NOTICE, sc, "HW init failed");
                        bnx2x_fw_command(sc, DRV_MSG_CODE_LOAD_DONE, 0);
                        sc->state = BNX2X_STATE_CLOSED;
                        rc = -ENXIO;
@@ -7197,7 +7209,7 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
                sc->state = BNX2X_STATE_OPENING_WAITING_PORT;
                rc = bnx2x_func_start(sc);
                if (rc) {
-                       PMD_DRV_LOG(NOTICE, "Function start failed!");
+                       PMD_DRV_LOG(NOTICE, sc, "Function start failed!");
                        bnx2x_fw_command(sc, DRV_MSG_CODE_LOAD_DONE, 0);
                        sc->state = BNX2X_STATE_ERROR;
                        goto bnx2x_nic_load_error3;
@@ -7208,7 +7220,7 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
                        load_code =
                            bnx2x_fw_command(sc, DRV_MSG_CODE_LOAD_DONE, 0);
                        if (!load_code) {
-                               PMD_DRV_LOG(NOTICE,
+                               PMD_DRV_LOG(NOTICE, sc,
                                            "MCP response failure, aborting");
                                sc->state = BNX2X_STATE_ERROR;
                                rc = -ENXIO;
@@ -7219,7 +7231,7 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
 
        rc = bnx2x_setup_leading(sc);
        if (rc) {
-               PMD_DRV_LOG(NOTICE, "Setup leading failed!");
+               PMD_DRV_LOG(NOTICE, sc, "Setup leading failed!");
                sc->state = BNX2X_STATE_ERROR;
                goto bnx2x_nic_load_error3;
        }
@@ -7231,7 +7243,7 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
                        rc = bnx2x_vf_setup_queue(sc, &sc->fp[i], FALSE);
 
                if (rc) {
-                       PMD_DRV_LOG(NOTICE, "Queue(%d) setup failed", i);
+                       PMD_DRV_LOG(NOTICE, sc, "Queue(%d) setup failed", i);
                        sc->state = BNX2X_STATE_ERROR;
                        goto bnx2x_nic_load_error3;
                }
@@ -7239,7 +7251,7 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
 
        rc = bnx2x_init_rss_pf(sc);
        if (rc) {
-               PMD_DRV_LOG(NOTICE, "PF RSS init failed");
+               PMD_DRV_LOG(NOTICE, sc, "PF RSS init failed");
                sc->state = BNX2X_STATE_ERROR;
                goto bnx2x_nic_load_error3;
        }
@@ -7255,7 +7267,7 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
        }
 
        if (rc) {
-               PMD_DRV_LOG(NOTICE, "Setting Ethernet MAC failed");
+               PMD_DRV_LOG(NOTICE, sc, "Setting Ethernet MAC failed");
                sc->state = BNX2X_STATE_ERROR;
                goto bnx2x_nic_load_error3;
        }
@@ -7307,13 +7319,13 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
 
        /* wait for all pending SP commands to complete */
        if (IS_PF(sc) && !bnx2x_wait_sp_comp(sc, ~0x0UL)) {
-               PMD_DRV_LOG(NOTICE, "Timeout waiting for all SPs to complete!");
+               PMD_DRV_LOG(NOTICE, sc, "Timeout waiting for all SPs to complete!");
                bnx2x_periodic_stop(sc);
                bnx2x_nic_unload(sc, UNLOAD_CLOSE, FALSE);
                return -ENXIO;
        }
 
-       PMD_DRV_LOG(DEBUG, "NIC successfully loaded");
+       PMD_DRV_LOG(DEBUG, sc, "NIC successfully loaded");
 
        return 0;
 
@@ -7362,7 +7374,7 @@ int bnx2x_init(struct bnx2x_softc *sc)
 
        /* Check if the driver is still running and bail out if it is. */
        if (sc->state != BNX2X_STATE_CLOSED) {
-               PMD_DRV_LOG(DEBUG, "Init called while driver is running!");
+               PMD_DRV_LOG(DEBUG, sc, "Init called while driver is running!");
                rc = 0;
                goto bnx2x_init_done;
        }
@@ -7400,7 +7412,7 @@ int bnx2x_init(struct bnx2x_softc *sc)
                                     && (!global ||!other_load_status))
                                    && bnx2x_trylock_leader_lock(sc)
                                    && !bnx2x_leader_reset(sc)) {
-                                       PMD_DRV_LOG(INFO,
+                                       PMD_DRV_LOG(INFO, sc,
                                                    "Recovered during init");
                                        break;
                                }
@@ -7410,7 +7422,7 @@ int bnx2x_init(struct bnx2x_softc *sc)
 
                                sc->recovery_state = BNX2X_RECOVERY_FAILED;
 
-                               PMD_DRV_LOG(NOTICE,
+                               PMD_DRV_LOG(NOTICE, sc,
                                            "Recovery flow hasn't properly "
                                            "completed yet, try again later. "
                                            "If you still see this message after a "
@@ -7429,7 +7441,7 @@ int bnx2x_init(struct bnx2x_softc *sc)
 bnx2x_init_done:
 
        if (rc) {
-               PMD_DRV_LOG(NOTICE, "Initialization failed, "
+               PMD_DRV_LOG(NOTICE, sc, "Initialization failed, "
                            "stack notified driver is NOT running!");
        }
 
@@ -7461,7 +7473,7 @@ static void bnx2x_get_function_num(struct bnx2x_softc *sc)
                sc->pfunc_abs = (sc->pfunc_rel | sc->path_id);
        }
 
-       PMD_DRV_LOG(DEBUG,
+       PMD_DRV_LOG(DEBUG, sc,
                    "Relative function %d, Absolute function %d, Path %d",
                    sc->pfunc_rel, sc->pfunc_abs, sc->path_id);
 }
@@ -7498,14 +7510,14 @@ static uint32_t bnx2x_pcie_capability_read(struct bnx2x_softc *sc, int reg)
        /* ensure PCIe capability is enabled */
        caps = pci_find_cap(sc, PCIY_EXPRESS, BNX2X_PCI_CAP);
        if (NULL != caps) {
-               PMD_DRV_LOG(DEBUG, "Found PCIe capability: "
+               PMD_DRV_LOG(DEBUG, sc, "Found PCIe capability: "
                            "id=0x%04X type=0x%04X addr=0x%08X",
                            caps->id, caps->type, caps->addr);
                pci_read(sc, (caps->addr + reg), &ret, 2);
                return ret;
        }
 
-       PMD_DRV_LOG(WARNING, "PCIe capability NOT FOUND!!!");
+       PMD_DRV_LOG(WARNING, sc, "PCIe capability NOT FOUND!!!");
 
        return 0;
 }
@@ -7523,7 +7535,7 @@ static uint8_t bnx2x_is_pcie_pending(struct bnx2x_softc *sc)
 */
 static void bnx2x_probe_pci_caps(struct bnx2x_softc *sc)
 {
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        struct bnx2x_pci_cap *caps;
        uint16_t link_status;
@@ -7532,7 +7544,7 @@ static void bnx2x_probe_pci_caps(struct bnx2x_softc *sc)
        /* check if PCI Power Management is enabled */
        caps = pci_find_cap(sc, PCIY_PMG, BNX2X_PCI_CAP);
        if (NULL != caps) {
-               PMD_DRV_LOG(DEBUG, "Found PM capability: "
+               PMD_DRV_LOG(DEBUG, sc, "Found PM capability: "
                            "id=0x%04X type=0x%04X addr=0x%08X",
                            caps->id, caps->type, caps->addr);
 
@@ -7546,7 +7558,7 @@ static void bnx2x_probe_pci_caps(struct bnx2x_softc *sc)
        sc->devinfo.pcie_link_width =
            ((link_status & PCIM_LINK_STA_WIDTH) >> 4);
 
-       PMD_DRV_LOG(DEBUG, "PCIe link speed=%d width=%d",
+       PMD_DRV_LOG(DEBUG, sc, "PCIe link speed=%d width=%d",
                    sc->devinfo.pcie_link_speed, sc->devinfo.pcie_link_width);
 
        sc->devinfo.pcie_cap_flags |= BNX2X_PCIE_CAPABLE_FLAG;
@@ -7554,7 +7566,7 @@ static void bnx2x_probe_pci_caps(struct bnx2x_softc *sc)
        /* check if MSI capability is enabled */
        caps = pci_find_cap(sc, PCIY_MSI, BNX2X_PCI_CAP);
        if (NULL != caps) {
-               PMD_DRV_LOG(DEBUG, "Found MSI capability at 0x%04x", reg);
+               PMD_DRV_LOG(DEBUG, sc, "Found MSI capability at 0x%04x", reg);
 
                sc->devinfo.pcie_cap_flags |= BNX2X_MSI_CAPABLE_FLAG;
                sc->devinfo.pcie_msi_cap_reg = caps->addr;
@@ -7563,7 +7575,7 @@ static void bnx2x_probe_pci_caps(struct bnx2x_softc *sc)
        /* check if MSI-X capability is enabled */
        caps = pci_find_cap(sc, PCIY_MSIX, BNX2X_PCI_CAP);
        if (NULL != caps) {
-               PMD_DRV_LOG(DEBUG, "Found MSI-X capability at 0x%04x", reg);
+               PMD_DRV_LOG(DEBUG, sc, "Found MSI-X capability at 0x%04x", reg);
 
                sc->devinfo.pcie_cap_flags |= BNX2X_MSIX_CAPABLE_FLAG;
                sc->devinfo.pcie_msix_cap_reg = caps->addr;
@@ -7583,7 +7595,7 @@ static int bnx2x_get_shmem_mf_cfg_info_sd(struct bnx2x_softc *sc)
        mf_info->multi_vnics_mode = 1;
 
        if (!VALID_OVLAN(mf_info->ext_id)) {
-               PMD_DRV_LOG(NOTICE, "Invalid VLAN (%d)", mf_info->ext_id);
+               PMD_DRV_LOG(NOTICE, sc, "Invalid VLAN (%d)", mf_info->ext_id);
                return 1;
        }
 
@@ -7707,14 +7719,14 @@ static int bnx2x_check_valid_mf_cfg(struct bnx2x_softc *sc)
        /* various MF mode sanity checks... */
 
        if (mf_info->mf_config[SC_VN(sc)] & FUNC_MF_CFG_FUNC_HIDE) {
-               PMD_DRV_LOG(NOTICE,
+               PMD_DRV_LOG(NOTICE, sc,
                            "Enumerated function %d is marked as hidden",
                            SC_PORT(sc));
                return 1;
        }
 
        if ((mf_info->vnics_per_port > 1) && !mf_info->multi_vnics_mode) {
-               PMD_DRV_LOG(NOTICE, "vnics_per_port=%d multi_vnics_mode=%d",
+               PMD_DRV_LOG(NOTICE, sc, "vnics_per_port=%d multi_vnics_mode=%d",
                            mf_info->vnics_per_port, mf_info->multi_vnics_mode);
                return 1;
        }
@@ -7722,13 +7734,13 @@ static int bnx2x_check_valid_mf_cfg(struct bnx2x_softc *sc)
        if (mf_info->mf_mode == MULTI_FUNCTION_SD) {
 /* vnic id > 0 must have valid ovlan in switch-dependent mode */
                if ((SC_VN(sc) > 0) && !VALID_OVLAN(OVLAN(sc))) {
-                       PMD_DRV_LOG(NOTICE, "mf_mode=SD vnic_id=%d ovlan=%d",
+                       PMD_DRV_LOG(NOTICE, sc, "mf_mode=SD vnic_id=%d ovlan=%d",
                                    SC_VN(sc), OVLAN(sc));
                        return 1;
                }
 
                if (!VALID_OVLAN(OVLAN(sc)) && mf_info->multi_vnics_mode) {
-                       PMD_DRV_LOG(NOTICE,
+                       PMD_DRV_LOG(NOTICE, sc,
                                    "mf_mode=SD multi_vnics_mode=%d ovlan=%d",
                                    mf_info->multi_vnics_mode, OVLAN(sc));
                        return 1;
@@ -7747,7 +7759,7 @@ static int bnx2x_check_valid_mf_cfg(struct bnx2x_softc *sc)
                              && !VALID_OVLAN(ovlan1))
                             || ((!mf_info->multi_vnics_mode)
                                 && VALID_OVLAN(ovlan1)))) {
-                               PMD_DRV_LOG(NOTICE,
+                               PMD_DRV_LOG(NOTICE, sc,
                                            "mf_mode=SD function %d MF config "
                                            "mismatch, multi_vnics_mode=%d ovlan=%d",
                                            i, mf_info->multi_vnics_mode,
@@ -7771,7 +7783,7 @@ static int bnx2x_check_valid_mf_cfg(struct bnx2x_softc *sc)
                                    && !(mf_cfg2 & FUNC_MF_CFG_FUNC_HIDE)
                                    && VALID_OVLAN(ovlan2)
                                    && (ovlan1 == ovlan2)) {
-                                       PMD_DRV_LOG(NOTICE,
+                                       PMD_DRV_LOG(NOTICE, sc,
                                                    "mf_mode=SD functions %d and %d "
                                                    "have the same ovlan (%d)",
                                                    i, j, ovlan1);
@@ -7801,7 +7813,7 @@ static int bnx2x_get_mf_cfg_info(struct bnx2x_softc *sc)
        }
 
        if (sc->devinfo.mf_cfg_base == SHMEM_MF_CFG_ADDR_NONE) {
-               PMD_DRV_LOG(NOTICE, "Invalid mf_cfg_base!");
+               PMD_DRV_LOG(NOTICE, sc, "Invalid mf_cfg_base!");
                return 1;
        }
 
@@ -7819,7 +7831,7 @@ static int bnx2x_get_mf_cfg_info(struct bnx2x_softc *sc)
                if (mac_upper != FUNC_MF_CFG_UPPERMAC_DEFAULT) {
                        mf_info->mf_mode = MULTI_FUNCTION_SI;
                } else {
-                       PMD_DRV_LOG(NOTICE,
+                       PMD_DRV_LOG(NOTICE, sc,
                                    "Invalid config for Switch Independent mode");
                }
 
@@ -7835,7 +7847,7 @@ static int bnx2x_get_mf_cfg_info(struct bnx2x_softc *sc)
                    FUNC_MF_CFG_E1HOV_TAG_DEFAULT) {
                        mf_info->mf_mode = MULTI_FUNCTION_SD;
                } else {
-                       PMD_DRV_LOG(NOTICE,
+                       PMD_DRV_LOG(NOTICE, sc,
                                    "Invalid config for Switch Dependent mode");
                }
 
@@ -7859,14 +7871,14 @@ static int bnx2x_get_mf_cfg_info(struct bnx2x_softc *sc)
                    (mac_upper != FUNC_MF_CFG_UPPERMAC_DEFAULT)) {
                        mf_info->mf_mode = MULTI_FUNCTION_AFEX;
                } else {
-                       PMD_DRV_LOG(NOTICE, "Invalid config for AFEX mode");
+                       PMD_DRV_LOG(NOTICE, sc, "Invalid config for AFEX mode");
                }
 
                break;
 
        default:
 
-               PMD_DRV_LOG(NOTICE, "Unknown MF mode (0x%08x)",
+               PMD_DRV_LOG(NOTICE, sc, "Unknown MF mode (0x%08x)",
                            (val & SHARED_FEAT_CFG_FORCE_SF_MODE_MASK));
 
                return 1;
@@ -7898,7 +7910,7 @@ static int bnx2x_get_mf_cfg_info(struct bnx2x_softc *sc)
        if (mf_info->mf_mode == SINGLE_FUNCTION) {
 /* invalid MF config */
                if (SC_VN(sc) >= 1) {
-                       PMD_DRV_LOG(NOTICE, "VNIC ID >= 1 in SF mode");
+                       PMD_DRV_LOG(NOTICE, sc, "VNIC ID >= 1 in SF mode");
                        return 1;
                }
 
@@ -7927,7 +7939,7 @@ static int bnx2x_get_mf_cfg_info(struct bnx2x_softc *sc)
 
        default:
 
-               PMD_DRV_LOG(NOTICE, "Get MF config failed (mf_mode=0x%08x)",
+               PMD_DRV_LOG(NOTICE, sc, "Get MF config failed (mf_mode=0x%08x)",
                            mf_info->mf_mode);
                return 1;
        }
@@ -7955,7 +7967,7 @@ static int bnx2x_get_shmem_info(struct bnx2x_softc *sc)
        int port;
        uint32_t mac_hi, mac_lo, val;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        port = SC_PORT(sc);
        mac_hi = mac_lo = 0;
@@ -8029,7 +8041,7 @@ static int bnx2x_get_shmem_info(struct bnx2x_softc *sc)
 
        if ((mac_lo == 0) && (mac_hi == 0)) {
                *sc->mac_addr_str = 0;
-               PMD_DRV_LOG(NOTICE, "No Ethernet address programmed!");
+               PMD_DRV_LOG(NOTICE, sc, "No Ethernet address programmed!");
        } else {
                sc->link_params.mac_addr[0] = (uint8_t) (mac_hi >> 8);
                sc->link_params.mac_addr[1] = (uint8_t) (mac_hi);
@@ -8045,7 +8057,8 @@ static int bnx2x_get_shmem_info(struct bnx2x_softc *sc)
                         sc->link_params.mac_addr[3],
                         sc->link_params.mac_addr[4],
                         sc->link_params.mac_addr[5]);
-               PMD_DRV_LOG(DEBUG, "Ethernet address: %s", sc->mac_addr_str);
+               PMD_DRV_LOG(DEBUG, sc,
+                           "Ethernet address: %s", sc->mac_addr_str);
        }
 
        return 0;
@@ -8060,24 +8073,24 @@ static void bnx2x_media_detect(struct bnx2x_softc *sc)
        case ELINK_ETH_PHY_XFP_FIBER:
        case ELINK_ETH_PHY_KR:
        case ELINK_ETH_PHY_CX4:
-               PMD_DRV_LOG(INFO, "Found 10GBase-CX4 media.");
+               PMD_DRV_LOG(INFO, sc, "Found 10GBase-CX4 media.");
                sc->media = IFM_10G_CX4;
                break;
        case ELINK_ETH_PHY_DA_TWINAX:
-               PMD_DRV_LOG(INFO, "Found 10Gb Twinax media.");
+               PMD_DRV_LOG(INFO, sc, "Found 10Gb Twinax media.");
                sc->media = IFM_10G_TWINAX;
                break;
        case ELINK_ETH_PHY_BASE_T:
-               PMD_DRV_LOG(INFO, "Found 10GBase-T media.");
+               PMD_DRV_LOG(INFO, sc, "Found 10GBase-T media.");
                sc->media = IFM_10G_T;
                break;
        case ELINK_ETH_PHY_NOT_PRESENT:
-               PMD_DRV_LOG(INFO, "Media not present.");
+               PMD_DRV_LOG(INFO, sc, "Media not present.");
                sc->media = 0;
                break;
        case ELINK_ETH_PHY_UNSPECIFIED:
        default:
-               PMD_DRV_LOG(INFO, "Unknown media!");
+               PMD_DRV_LOG(INFO, sc, "Unknown media!");
                sc->media = 0;
                break;
        }
@@ -8140,7 +8153,7 @@ static int bnx2x_get_igu_cam_info(struct bnx2x_softc *sc)
        sc->igu_sb_cnt = min(sc->igu_sb_cnt, igu_sb_cnt);
 
        if (igu_sb_cnt == 0) {
-               PMD_DRV_LOG(ERR, "CAM configuration error");
+               PMD_DRV_LOG(ERR, sc, "CAM configuration error");
                return -1;
        }
 
@@ -8177,7 +8190,7 @@ static int bnx2x_get_device_info(struct bnx2x_softc *sc)
                sc->devinfo.chip_id |= 0x1;
        }
 
-       PMD_DRV_LOG(DEBUG,
+       PMD_DRV_LOG(DEBUG, sc,
                    "chip_id=0x%08x (num=0x%04x rev=0x%01x metal=0x%02x bond=0x%01x)",
                    sc->devinfo.chip_id,
                    ((sc->devinfo.chip_id >> 16) & 0xffff),
@@ -8188,7 +8201,7 @@ static int bnx2x_get_device_info(struct bnx2x_softc *sc)
        val = (REG_RD(sc, 0x2874) & 0x55);
        if ((sc->devinfo.chip_id & 0x1) || (CHIP_IS_E1H(sc) && (val == 0x55))) {
                sc->flags |= BNX2X_ONE_PORT_FLAG;
-               PMD_DRV_LOG(DEBUG, "single port device");
+               PMD_DRV_LOG(DEBUG, sc, "single port device");
        }
 
        /* set the doorbell size */
@@ -8212,7 +8225,7 @@ static int bnx2x_get_device_info(struct bnx2x_softc *sc)
                sc->devinfo.chip_port_mode =
                    (val) ? CHIP_4_PORT_MODE : CHIP_2_PORT_MODE;
 
-               PMD_DRV_LOG(DEBUG, "Port mode = %s", (val) ? "4" : "2");
+               PMD_DRV_LOG(DEBUG, sc, "Port mode = %s", (val) ? "4" : "2");
        }
 
        /* get the function and path info for the device */
@@ -8227,7 +8240,7 @@ static int bnx2x_get_device_info(struct bnx2x_softc *sc)
 
        if (!sc->devinfo.shmem_base) {
 /* this should ONLY prevent upcoming shmem reads */
-               PMD_DRV_LOG(INFO, "MCP not active");
+               PMD_DRV_LOG(INFO, sc, "MCP not active");
                sc->flags |= BNX2X_NO_MCP_FLAG;
                return 0;
        }
@@ -8236,7 +8249,7 @@ static int bnx2x_get_device_info(struct bnx2x_softc *sc)
        val = SHMEM_RD(sc, validity_map[SC_PORT(sc)]);
        if ((val & (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB)) !=
            (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB)) {
-               PMD_DRV_LOG(NOTICE, "Invalid SHMEM validity signature: 0x%08x",
+               PMD_DRV_LOG(NOTICE, sc, "Invalid SHMEM validity signature: 0x%08x",
                            val);
                return 0;
        }
@@ -8249,7 +8262,7 @@ static int bnx2x_get_device_info(struct bnx2x_softc *sc)
                 ((sc->devinfo.bc_ver >> 24) & 0xff),
                 ((sc->devinfo.bc_ver >> 16) & 0xff),
                 ((sc->devinfo.bc_ver >> 8) & 0xff));
-       PMD_DRV_LOG(INFO, "Bootcode version: %s", sc->devinfo.bc_ver_str);
+       PMD_DRV_LOG(INFO, sc, "Bootcode version: %s", sc->devinfo.bc_ver_str);
 
        /* get the bootcode shmem address */
        sc->devinfo.mf_cfg_base = bnx2x_get_shmem_mf_cfg_base(sc);
@@ -8304,7 +8317,7 @@ static int bnx2x_get_device_info(struct bnx2x_softc *sc)
                        }
 
                        if (REG_RD(sc, IGU_REG_RESET_MEMORIES)) {
-                               PMD_DRV_LOG(NOTICE,
+                               PMD_DRV_LOG(NOTICE, sc,
                                            "FORCING IGU Normal Mode failed!!!");
                                bnx2x_release_hw_lock(sc, HW_LOCK_RESOURCE_RESET);
                                return -1;
@@ -8312,10 +8325,10 @@ static int bnx2x_get_device_info(struct bnx2x_softc *sc)
                }
 
                if (val & IGU_BLOCK_CONFIGURATION_REG_BACKWARD_COMP_EN) {
-                       PMD_DRV_LOG(DEBUG, "IGU Backward Compatible Mode");
+                       PMD_DRV_LOG(DEBUG, sc, "IGU Backward Compatible Mode");
                        sc->devinfo.int_block |= INT_BLOCK_MODE_BW_COMP;
                } else {
-                       PMD_DRV_LOG(DEBUG, "IGU Normal Mode");
+                       PMD_DRV_LOG(DEBUG, sc, "IGU Normal Mode");
                }
 
                rc = bnx2x_get_igu_cam_info(sc);
@@ -8389,7 +8402,7 @@ bnx2x_link_settings_supported(struct bnx2x_softc *sc, uint32_t switch_cfg)
        }
 
        if (!(sc->port.supported[0] || sc->port.supported[1])) {
-               PMD_DRV_LOG(ERR,
+               PMD_DRV_LOG(ERR, sc,
                            "Invalid phy config in NVRAM (PHY1=0x%08x PHY2=0x%08x)",
                            SHMEM_RD(sc,
                                     dev_info.port_hw_config
@@ -8415,7 +8428,7 @@ bnx2x_link_settings_supported(struct bnx2x_softc *sc, uint32_t switch_cfg)
                                   NIG_REG_XGXS0_CTRL_PHY_ADDR + port * 0x18);
                        break;
                default:
-                       PMD_DRV_LOG(ERR,
+                       PMD_DRV_LOG(ERR, sc,
                                    "Invalid switch config in"
                                    "link_config=0x%08x",
                                    sc->port.link_config[0]);
@@ -8423,7 +8436,7 @@ bnx2x_link_settings_supported(struct bnx2x_softc *sc, uint32_t switch_cfg)
                }
        }
 
-       PMD_DRV_LOG(INFO, "PHY addr 0x%08x", sc->port.phy_addr);
+       PMD_DRV_LOG(INFO, sc, "PHY addr 0x%08x", sc->port.phy_addr);
 
        /* mask what we support according to speed_cap_mask per configuration */
        for (idx = 0; idx < cfg_size; idx++) {
@@ -8476,7 +8489,7 @@ bnx2x_link_settings_supported(struct bnx2x_softc *sc, uint32_t switch_cfg)
                }
        }
 
-       PMD_DRV_LOG(INFO, "PHY supported 0=0x%08x 1=0x%08x",
+       PMD_DRV_LOG(INFO, sc, "PHY supported 0=0x%08x 1=0x%08x",
                    sc->port.supported[0], sc->port.supported[1]);
 }
 
@@ -8535,7 +8548,7 @@ static void bnx2x_link_settings_requested(struct bnx2x_softc *sc)
                                sc->port.advertising[idx] |=
                                    (ADVERTISED_10baseT_Full | ADVERTISED_TP);
                        } else {
-                               PMD_DRV_LOG(ERR,
+                               PMD_DRV_LOG(ERR, sc,
                                            "Invalid NVRAM config link_config=0x%08x "
                                            "speed_cap_mask=0x%08x",
                                            link_config,
@@ -8555,7 +8568,7 @@ static void bnx2x_link_settings_requested(struct bnx2x_softc *sc)
                                sc->port.advertising[idx] |=
                                    (ADVERTISED_10baseT_Half | ADVERTISED_TP);
                        } else {
-                               PMD_DRV_LOG(ERR,
+                               PMD_DRV_LOG(ERR, sc,
                                            "Invalid NVRAM config link_config=0x%08x "
                                            "speed_cap_mask=0x%08x",
                                            link_config,
@@ -8574,7 +8587,7 @@ static void bnx2x_link_settings_requested(struct bnx2x_softc *sc)
                                sc->port.advertising[idx] |=
                                    (ADVERTISED_100baseT_Full | ADVERTISED_TP);
                        } else {
-                               PMD_DRV_LOG(ERR,
+                               PMD_DRV_LOG(ERR, sc,
                                            "Invalid NVRAM config link_config=0x%08x "
                                            "speed_cap_mask=0x%08x",
                                            link_config,
@@ -8594,7 +8607,7 @@ static void bnx2x_link_settings_requested(struct bnx2x_softc *sc)
                                sc->port.advertising[idx] |=
                                    (ADVERTISED_100baseT_Half | ADVERTISED_TP);
                        } else {
-                               PMD_DRV_LOG(ERR,
+                               PMD_DRV_LOG(ERR, sc,
                                            "Invalid NVRAM config link_config=0x%08x "
                                            "speed_cap_mask=0x%08x",
                                            link_config,
@@ -8612,7 +8625,7 @@ static void bnx2x_link_settings_requested(struct bnx2x_softc *sc)
                                sc->port.advertising[idx] |=
                                    (ADVERTISED_1000baseT_Full | ADVERTISED_TP);
                        } else {
-                               PMD_DRV_LOG(ERR,
+                               PMD_DRV_LOG(ERR, sc,
                                            "Invalid NVRAM config link_config=0x%08x "
                                            "speed_cap_mask=0x%08x",
                                            link_config,
@@ -8630,7 +8643,7 @@ static void bnx2x_link_settings_requested(struct bnx2x_softc *sc)
                                sc->port.advertising[idx] |=
                                    (ADVERTISED_2500baseX_Full | ADVERTISED_TP);
                        } else {
-                               PMD_DRV_LOG(ERR,
+                               PMD_DRV_LOG(ERR, sc,
                                            "Invalid NVRAM config link_config=0x%08x "
                                            "speed_cap_mask=0x%08x",
                                            link_config,
@@ -8649,7 +8662,7 @@ static void bnx2x_link_settings_requested(struct bnx2x_softc *sc)
                                    (ADVERTISED_10000baseT_Full |
                                     ADVERTISED_FIBRE);
                        } else {
-                               PMD_DRV_LOG(ERR,
+                               PMD_DRV_LOG(ERR, sc,
                                            "Invalid NVRAM config link_config=0x%08x "
                                            "speed_cap_mask=0x%08x",
                                            link_config,
@@ -8664,7 +8677,7 @@ static void bnx2x_link_settings_requested(struct bnx2x_softc *sc)
                        break;
 
                default:
-                       PMD_DRV_LOG(ERR,
+                       PMD_DRV_LOG(ERR, sc,
                                    "Invalid NVRAM config link_config=0x%08x "
                                    "speed_cap_mask=0x%08x", link_config,
                                    sc->link_params.speed_cap_mask[idx]);
@@ -8695,7 +8708,7 @@ static void bnx2x_get_phy_info(struct bnx2x_softc *sc)
        uint8_t port = SC_PORT(sc);
        uint32_t eee_mode;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        /* shmem data already read in bnx2x_get_shmem_info() */
 
@@ -8855,7 +8868,7 @@ int bnx2x_alloc_hsi_mem(struct bnx2x_softc *sc)
                snprintf(buf, sizeof(buf), "fp_%d_sb", i);
                if (bnx2x_dma_alloc(sc, sizeof(union bnx2x_host_hc_status_block),
                                  &fp->sb_dma, buf, RTE_CACHE_LINE_SIZE) != 0) {
-                       PMD_DRV_LOG(NOTICE, "Failed to alloc %s", buf);
+                       PMD_DRV_LOG(NOTICE, sc, "Failed to alloc %s", buf);
                        return -1;
                } else {
                        if (CHIP_IS_E2E3(sc)) {
@@ -8945,7 +8958,7 @@ static int bnx2x_prev_mcp_done(struct bnx2x_softc *sc)
        uint32_t rc = bnx2x_fw_command(sc, DRV_MSG_CODE_UNLOAD_DONE,
                                     DRV_MSG_CODE_UNLOAD_SKIP_LINK_RESET);
        if (!rc) {
-               PMD_DRV_LOG(NOTICE, "MCP response failure, aborting");
+               PMD_DRV_LOG(NOTICE, sc, "MCP response failure, aborting");
                return -1;
        }
 
@@ -8977,12 +8990,12 @@ static uint8_t bnx2x_prev_is_path_marked(struct bnx2x_softc *sc)
        tmp = bnx2x_prev_path_get_entry(sc);
        if (tmp) {
                if (tmp->aer) {
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                                    "Path %d/%d/%d was marked by AER",
                                    sc->pcie_bus, sc->pcie_device, SC_PATH(sc));
                } else {
                        rc = TRUE;
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                                    "Path %d/%d/%d was already cleaned from previous drivers",
                                    sc->pcie_bus, sc->pcie_device, SC_PATH(sc));
                }
@@ -9003,11 +9016,11 @@ static int bnx2x_prev_mark_path(struct bnx2x_softc *sc, uint8_t after_undi)
        tmp = bnx2x_prev_path_get_entry(sc);
        if (tmp) {
                if (!tmp->aer) {
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                                    "Re-marking AER in path %d/%d/%d",
                                    sc->pcie_bus, sc->pcie_device, SC_PATH(sc));
                } else {
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                                    "Removing AER indication from path %d/%d/%d",
                                    sc->pcie_bus, sc->pcie_device, SC_PATH(sc));
                        tmp->aer = 0;
@@ -9023,7 +9036,7 @@ static int bnx2x_prev_mark_path(struct bnx2x_softc *sc, uint8_t after_undi)
        tmp = rte_malloc("", sizeof(struct bnx2x_prev_list_node),
                         RTE_CACHE_LINE_SIZE);
        if (!tmp) {
-               PMD_DRV_LOG(NOTICE, "Failed to allocate 'bnx2x_prev_list_node'");
+               PMD_DRV_LOG(NOTICE, sc, "Failed to allocate 'bnx2x_prev_list_node'");
                return -1;
        }
 
@@ -9048,13 +9061,13 @@ static int bnx2x_do_flr(struct bnx2x_softc *sc)
 
        /* only E2 and onwards support FLR */
        if (CHIP_IS_E1x(sc)) {
-               PMD_DRV_LOG(WARNING, "FLR not supported in E1H");
+               PMD_DRV_LOG(WARNING, sc, "FLR not supported in E1H");
                return -1;
        }
 
        /* only bootcode REQ_BC_VER_4_INITIATE_FLR and onwards support flr */
        if (sc->devinfo.bc_ver < REQ_BC_VER_4_INITIATE_FLR) {
-               PMD_DRV_LOG(WARNING,
+               PMD_DRV_LOG(WARNING, sc,
                            "FLR not supported by BC_VER: 0x%08x",
                            sc->devinfo.bc_ver);
                return -1;
@@ -9071,7 +9084,7 @@ static int bnx2x_do_flr(struct bnx2x_softc *sc)
                }
        }
 
-       PMD_DRV_LOG(NOTICE, "PCIE transaction is not cleared, "
+       PMD_DRV_LOG(NOTICE, sc, "PCIE transaction is not cleared, "
                    "proceeding with reset anyway");
 
 clear:
@@ -9219,7 +9232,7 @@ static int bnx2x_prev_unload_common(struct bnx2x_softc *sc)
                if (reset_reg & MISC_REGISTERS_RESET_REG_1_RST_DORQ) {
                        tmp_reg = REG_RD(sc, DORQ_REG_NORM_CID_OFST);
                        if (tmp_reg == 0x7) {
-                               PMD_DRV_LOG(DEBUG, "UNDI previously loaded");
+                               PMD_DRV_LOG(DEBUG, sc, "UNDI previously loaded");
                                prev_undi = TRUE;
                                /* clear the UNDI indication */
                                REG_WR(sc, DORQ_REG_NORM_CID_OFST, 0);
@@ -9238,7 +9251,7 @@ static int bnx2x_prev_unload_common(struct bnx2x_softc *sc)
                                break;
                        }
 
-                       PMD_DRV_LOG(DEBUG, "BRB still has 0x%08x", tmp_reg);
+                       PMD_DRV_LOG(DEBUG, sc, "BRB still has 0x%08x", tmp_reg);
 
                        /* reset timer as long as BRB actually gets emptied */
                        if (prev_brb > tmp_reg) {
@@ -9256,7 +9269,7 @@ static int bnx2x_prev_unload_common(struct bnx2x_softc *sc)
                }
 
                if (!timer_count) {
-                       PMD_DRV_LOG(NOTICE, "Failed to empty BRB");
+                       PMD_DRV_LOG(NOTICE, sc, "Failed to empty BRB");
                }
        }
 
@@ -9311,7 +9324,7 @@ static int bnx2x_prev_unload_uncommon(struct bnx2x_softc *sc)
                return 0;
        }
 
-       PMD_DRV_LOG(INFO, "Could not FLR");
+       PMD_DRV_LOG(INFO, sc, "Could not FLR");
 
        /* Close the MCP request, return failure */
        rc = bnx2x_prev_mcp_done(sc);
@@ -9358,7 +9371,7 @@ static int bnx2x_prev_unload(struct bnx2x_softc *sc)
                /* Lock MCP using an unload request */
                fw = bnx2x_fw_command(sc, DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS, 0);
                if (!fw) {
-                       PMD_DRV_LOG(NOTICE, "MCP response failure, aborting");
+                       PMD_DRV_LOG(NOTICE, sc, "MCP response failure, aborting");
                        rc = -1;
                        break;
                }
@@ -9378,7 +9391,7 @@ static int bnx2x_prev_unload(struct bnx2x_softc *sc)
        } while (--time_counter);
 
        if (!time_counter || rc) {
-               PMD_DRV_LOG(NOTICE, "Failed to unload previous driver!");
+               PMD_DRV_LOG(NOTICE, sc, "Failed to unload previous driver!");
                rc = -1;
        }
 
@@ -9395,7 +9408,7 @@ bnx2x_dcbx_set_state(struct bnx2x_softc *sc, uint8_t dcb_on, uint32_t dcbx_enabl
                sc->dcb_state = FALSE;
                sc->dcbx_enabled = BNX2X_DCBX_ENABLED_INVALID;
        }
-       PMD_DRV_LOG(DEBUG,
+       PMD_DRV_LOG(DEBUG, sc,
                    "DCB state [%s:%s]",
                    dcb_on ? "ON" : "OFF",
                    (dcbx_enabled == BNX2X_DCBX_ENABLED_OFF) ? "user-mode" :
@@ -9428,7 +9441,7 @@ static void bnx2x_init_multi_cos(struct bnx2x_softc *sc)
                if (cos < sc->max_cos) {
                        sc->prio_to_cos[pri] = cos;
                } else {
-                       PMD_DRV_LOG(WARNING,
+                       PMD_DRV_LOG(WARNING, sc,
                                    "Invalid COS %d for priority %d "
                                    "(max COS is %d), setting to 0", cos, pri,
                                    (sc->max_cos - 1));
@@ -9449,7 +9462,7 @@ static int bnx2x_pci_get_caps(struct bnx2x_softc *sc)
        cap = sc->pci_caps = rte_zmalloc("caps", sizeof(struct bnx2x_pci_cap),
                                         RTE_CACHE_LINE_SIZE);
        if (!cap) {
-               PMD_DRV_LOG(NOTICE, "Failed to allocate memory");
+               PMD_DRV_LOG(NOTICE, sc, "Failed to allocate memory");
                return -ENOMEM;
        }
 
@@ -9460,7 +9473,7 @@ static int bnx2x_pci_get_caps(struct bnx2x_softc *sc)
        pci_read(sc, PCIR_STATUS, &status, 2);
        if (!(status & PCIM_STATUS_CAPPRESENT)) {
 #endif
-               PMD_DRV_LOG(NOTICE, "PCIe capability reading failed");
+               PMD_DRV_LOG(NOTICE, sc, "PCIe capability reading failed");
                return -1;
        }
 
@@ -9480,7 +9493,7 @@ static int bnx2x_pci_get_caps(struct bnx2x_softc *sc)
                                        sizeof(struct bnx2x_pci_cap),
                                        RTE_CACHE_LINE_SIZE);
                if (!cap->next) {
-                       PMD_DRV_LOG(NOTICE, "Failed to allocate memory");
+                       PMD_DRV_LOG(NOTICE, sc, "Failed to allocate memory");
                        return -ENOMEM;
                }
                cap = cap->next;
@@ -9516,25 +9529,25 @@ void bnx2x_load_firmware(struct bnx2x_softc *sc)
                ? FW_NAME_57711 : FW_NAME_57810;
        f = open(fwname, O_RDONLY);
        if (f < 0) {
-               PMD_DRV_LOG(NOTICE, "Can't open firmware file");
+               PMD_DRV_LOG(NOTICE, sc, "Can't open firmware file");
                return;
        }
 
        if (fstat(f, &st) < 0) {
-               PMD_DRV_LOG(NOTICE, "Can't stat firmware file");
+               PMD_DRV_LOG(NOTICE, sc, "Can't stat firmware file");
                close(f);
                return;
        }
 
        sc->firmware = rte_zmalloc("bnx2x_fw", st.st_size, RTE_CACHE_LINE_SIZE);
        if (!sc->firmware) {
-               PMD_DRV_LOG(NOTICE, "Can't allocate memory for firmware");
+               PMD_DRV_LOG(NOTICE, sc, "Can't allocate memory for firmware");
                close(f);
                return;
        }
 
        if (read(f, sc->firmware, st.st_size) != st.st_size) {
-               PMD_DRV_LOG(NOTICE, "Can't read firmware data");
+               PMD_DRV_LOG(NOTICE, sc, "Can't read firmware data");
                close(f);
                return;
        }
@@ -9542,10 +9555,11 @@ void bnx2x_load_firmware(struct bnx2x_softc *sc)
 
        sc->fw_len = st.st_size;
        if (sc->fw_len < FW_HEADER_LEN) {
-               PMD_DRV_LOG(NOTICE, "Invalid fw size: %" PRIu64, sc->fw_len);
+               PMD_DRV_LOG(NOTICE, sc,
+                           "Invalid fw size: %" PRIu64, sc->fw_len);
                return;
        }
-       PMD_DRV_LOG(DEBUG, "fw_len = %" PRIu64, sc->fw_len);
+       PMD_DRV_LOG(DEBUG, sc, "fw_len = %" PRIu64, sc->fw_len);
 }
 
 static void
@@ -9612,11 +9626,11 @@ int bnx2x_attach(struct bnx2x_softc *sc)
 {
        int rc;
 
-       PMD_DRV_LOG(DEBUG, "Starting attach...");
+       PMD_DRV_LOG(DEBUG, sc, "Starting attach...");
 
        rc = bnx2x_pci_get_caps(sc);
        if (rc) {
-               PMD_DRV_LOG(NOTICE, "PCIe caps reading was failed");
+               PMD_DRV_LOG(NOTICE, sc, "PCIe caps reading was failed");
                return rc;
        }
 
@@ -9655,7 +9669,7 @@ int bnx2x_attach(struct bnx2x_softc *sc)
 
                /* get device info and set params */
                if (bnx2x_get_device_info(sc) != 0) {
-                       PMD_DRV_LOG(NOTICE, "getting device info");
+                       PMD_DRV_LOG(NOTICE, sc, "getting device info");
                        return -ENXIO;
                }
 
@@ -9754,7 +9768,7 @@ bnx2x_igu_clear_sb_gen(struct bnx2x_softc *sc, uint8_t func, uint8_t idu_sb_id,
 
        mb();
 
-       PMD_DRV_LOG(DEBUG, "write 0x%08x to IGU(via GRC) addr 0x%x",
+       PMD_DRV_LOG(DEBUG, sc, "write 0x%08x to IGU(via GRC) addr 0x%x",
                    ctl, igu_addr_ctl);
        REG_WR(sc, igu_addr_ctl, ctl);
 
@@ -9766,7 +9780,7 @@ bnx2x_igu_clear_sb_gen(struct bnx2x_softc *sc, uint8_t func, uint8_t idu_sb_id,
        }
 
        if (!(REG_RD(sc, igu_addr_ack) & sb_bit)) {
-               PMD_DRV_LOG(DEBUG,
+               PMD_DRV_LOG(DEBUG, sc,
                            "Unable to finish IGU cleanup: "
                            "idu_sb_id %d offset %d bit %d (cnt %d)",
                            idu_sb_id, idu_sb_id / 32, idu_sb_id % 32, cnt);
@@ -9786,7 +9800,7 @@ static void bnx2x_reset_common(struct bnx2x_softc *sc)
 {
        uint32_t val = 0x1400;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        /* reset_common */
        REG_WR(sc, (GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR),
@@ -9995,7 +10009,8 @@ static int bnx2x_init_hw_common(struct bnx2x_softc *sc)
        uint8_t abs_func_id;
        uint32_t val;
 
-       PMD_DRV_LOG(DEBUG, "starting common init for func %d", SC_ABS_FUNC(sc));
+       PMD_DRV_LOG(DEBUG, sc,
+                   "starting common init for func %d", SC_ABS_FUNC(sc));
 
        /*
         * take the RESET lock to protect undi_unload flow from accessing
@@ -10078,12 +10093,12 @@ static int bnx2x_init_hw_common(struct bnx2x_softc *sc)
 
        val = REG_RD(sc, PXP2_REG_RQ_CFG_DONE);
        if (val != 1) {
-               PMD_DRV_LOG(NOTICE, "PXP2 CFG failed");
+               PMD_DRV_LOG(NOTICE, sc, "PXP2 CFG failed");
                return -1;
        }
        val = REG_RD(sc, PXP2_REG_RD_INIT_DONE);
        if (val != 1) {
-               PMD_DRV_LOG(NOTICE, "PXP2 RD_INIT failed");
+               PMD_DRV_LOG(NOTICE, sc, "PXP2 RD_INIT failed");
                return -1;
        }
 
@@ -10205,7 +10220,7 @@ static int bnx2x_init_hw_common(struct bnx2x_softc *sc)
                } while (factor-- && (val != 1));
 
                if (val != 1) {
-                       PMD_DRV_LOG(NOTICE, "ATC_INIT failed");
+                       PMD_DRV_LOG(NOTICE, sc, "ATC_INIT failed");
                        return -1;
                }
        }
@@ -10343,7 +10358,7 @@ static int bnx2x_init_hw_common(struct bnx2x_softc *sc)
 
        if (sizeof(union cdu_context) != 1024) {
 /* we currently assume that a context is 1024 bytes */
-               PMD_DRV_LOG(NOTICE,
+               PMD_DRV_LOG(NOTICE, sc,
                            "please adjust the size of cdu_context(%ld)",
                            (long)sizeof(union cdu_context));
        }
@@ -10405,17 +10420,17 @@ static int bnx2x_init_hw_common(struct bnx2x_softc *sc)
        /* finish CFC init */
        val = reg_poll(sc, CFC_REG_LL_INIT_DONE, 1, 100, 10);
        if (val != 1) {
-               PMD_DRV_LOG(NOTICE, "CFC LL_INIT failed");
+               PMD_DRV_LOG(NOTICE, sc, "CFC LL_INIT failed");
                return -1;
        }
        val = reg_poll(sc, CFC_REG_AC_INIT_DONE, 1, 100, 10);
        if (val != 1) {
-               PMD_DRV_LOG(NOTICE, "CFC AC_INIT failed");
+               PMD_DRV_LOG(NOTICE, sc, "CFC AC_INIT failed");
                return -1;
        }
        val = reg_poll(sc, CFC_REG_CAM_INIT_DONE, 1, 100, 10);
        if (val != 1) {
-               PMD_DRV_LOG(NOTICE, "CFC CAM_INIT failed");
+               PMD_DRV_LOG(NOTICE, sc, "CFC CAM_INIT failed");
                return -1;
        }
        REG_WR(sc, CFC_REG_DEBUG0, 0);
@@ -10468,7 +10483,7 @@ static int bnx2x_init_hw_port(struct bnx2x_softc *sc)
        uint32_t low, high;
        uint32_t val;
 
-       PMD_DRV_LOG(DEBUG, "starting port init for port %d", port);
+       PMD_DRV_LOG(DEBUG, sc, "starting port init for port %d", port);
 
        REG_WR(sc, NIG_REG_MASK_INTERRUPT_PORT0 + port * 4, 0);
 
@@ -10695,7 +10710,7 @@ bnx2x_flr_clnup_poll_hw_counter(struct bnx2x_softc *sc, uint32_t reg,
        uint32_t val = bnx2x_flr_clnup_reg_poll(sc, reg, 0, poll_cnt);
 
        if (val != 0) {
-               PMD_DRV_LOG(NOTICE, "%s usage count=%d", msg, val);
+               PMD_DRV_LOG(NOTICE, sc, "%s usage count=%d", msg, val);
                return -1;
        }
 
@@ -10787,7 +10802,7 @@ bnx2x_send_final_clnup(struct bnx2x_softc *sc, uint8_t clnup_func,
        int ret = 0;
 
        if (REG_RD(sc, comp_addr)) {
-               PMD_DRV_LOG(NOTICE,
+               PMD_DRV_LOG(NOTICE, sc,
                            "Cleanup complete was not 0 before sending");
                return -1;
        }
@@ -10800,8 +10815,8 @@ bnx2x_send_final_clnup(struct bnx2x_softc *sc, uint8_t clnup_func,
        REG_WR(sc, XSDM_REG_OPERATION_GEN, op_gen_command);
 
        if (bnx2x_flr_clnup_reg_poll(sc, comp_addr, 1, poll_cnt) != 1) {
-               PMD_DRV_LOG(NOTICE, "FW final cleanup did not succeed");
-               PMD_DRV_LOG(DEBUG, "At timeout completion address contained %x",
+               PMD_DRV_LOG(NOTICE, sc, "FW final cleanup did not succeed");
+               PMD_DRV_LOG(DEBUG, sc, "At timeout completion address contained %x",
                            (REG_RD(sc, comp_addr)));
                rte_panic("FLR cleanup failed");
                return -1;
@@ -10917,28 +10932,30 @@ static void bnx2x_hw_enable_status(struct bnx2x_softc *sc)
        __rte_unused uint32_t val;
 
        val = REG_RD(sc, CFC_REG_WEAK_ENABLE_PF);
-       PMD_DRV_LOG(DEBUG, "CFC_REG_WEAK_ENABLE_PF is 0x%x", val);
+       PMD_DRV_LOG(DEBUG, sc, "CFC_REG_WEAK_ENABLE_PF is 0x%x", val);
 
        val = REG_RD(sc, PBF_REG_DISABLE_PF);
-       PMD_DRV_LOG(DEBUG, "PBF_REG_DISABLE_PF is 0x%x", val);
+       PMD_DRV_LOG(DEBUG, sc, "PBF_REG_DISABLE_PF is 0x%x", val);
 
        val = REG_RD(sc, IGU_REG_PCI_PF_MSI_EN);
-       PMD_DRV_LOG(DEBUG, "IGU_REG_PCI_PF_MSI_EN is 0x%x", val);
+       PMD_DRV_LOG(DEBUG, sc, "IGU_REG_PCI_PF_MSI_EN is 0x%x", val);
 
        val = REG_RD(sc, IGU_REG_PCI_PF_MSIX_EN);
-       PMD_DRV_LOG(DEBUG, "IGU_REG_PCI_PF_MSIX_EN is 0x%x", val);
+       PMD_DRV_LOG(DEBUG, sc, "IGU_REG_PCI_PF_MSIX_EN is 0x%x", val);
 
        val = REG_RD(sc, IGU_REG_PCI_PF_MSIX_FUNC_MASK);
-       PMD_DRV_LOG(DEBUG, "IGU_REG_PCI_PF_MSIX_FUNC_MASK is 0x%x", val);
+       PMD_DRV_LOG(DEBUG, sc, "IGU_REG_PCI_PF_MSIX_FUNC_MASK is 0x%x", val);
 
        val = REG_RD(sc, PGLUE_B_REG_SHADOW_BME_PF_7_0_CLR);
-       PMD_DRV_LOG(DEBUG, "PGLUE_B_REG_SHADOW_BME_PF_7_0_CLR is 0x%x", val);
+       PMD_DRV_LOG(DEBUG, sc,
+                   "PGLUE_B_REG_SHADOW_BME_PF_7_0_CLR is 0x%x", val);
 
        val = REG_RD(sc, PGLUE_B_REG_FLR_REQUEST_PF_7_0_CLR);
-       PMD_DRV_LOG(DEBUG, "PGLUE_B_REG_FLR_REQUEST_PF_7_0_CLR is 0x%x", val);
+       PMD_DRV_LOG(DEBUG, sc,
+                   "PGLUE_B_REG_FLR_REQUEST_PF_7_0_CLR is 0x%x", val);
 
        val = REG_RD(sc, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER);
-       PMD_DRV_LOG(DEBUG, "PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER is 0x%x",
+       PMD_DRV_LOG(DEBUG, sc, "PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER is 0x%x",
                    val);
 }
 
@@ -10982,7 +10999,7 @@ static int bnx2x_pf_flr_clnup(struct bnx2x_softc *sc)
 
        /* Verify no pending pci transactions */
        if (bnx2x_is_pcie_pending(sc)) {
-               PMD_DRV_LOG(NOTICE, "PCIE Transactions still pending");
+               PMD_DRV_LOG(NOTICE, sc, "PCIE Transactions still pending");
        }
 
        /* Debug */
@@ -11009,13 +11026,13 @@ static int bnx2x_init_hw_func(struct bnx2x_softc *sc)
        int main_mem_width, rc;
        uint32_t i;
 
-       PMD_DRV_LOG(DEBUG, "starting func init for func %d", func);
+       PMD_DRV_LOG(DEBUG, sc, "starting func init for func %d", func);
 
        /* FLR cleanup */
        if (!CHIP_IS_E1x(sc)) {
                rc = bnx2x_pf_flr_clnup(sc);
                if (rc) {
-                       PMD_DRV_LOG(NOTICE, "FLR cleanup failed!");
+                       PMD_DRV_LOG(NOTICE, sc, "FLR cleanup failed!");
                        return rc;
                }
        }
@@ -11262,7 +11279,7 @@ static int bnx2x_init_hw_func(struct bnx2x_softc *sc)
 
                val = REG_RD(sc, main_mem_prty_clr);
                if (val) {
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                                    "Parity errors in HC block during function init (0x%x)!",
                                    val);
                }
@@ -11300,7 +11317,7 @@ static void bnx2x_link_reset(struct bnx2x_softc *sc)
                elink_lfa_reset(&sc->link_params, &sc->link_vars);
        } else {
                if (!CHIP_REV_IS_SLOW(sc)) {
-                       PMD_DRV_LOG(WARNING,
+                       PMD_DRV_LOG(WARNING, sc,
                                    "Bootcode is missing - cannot reset link");
                }
        }
@@ -11330,7 +11347,7 @@ static void bnx2x_reset_port(struct bnx2x_softc *sc)
        /* Check for BRB port occupancy */
        val = REG_RD(sc, BRB1_REG_PORT_NUM_OCC_BLOCKS_0 + port * 4);
        if (val) {
-               PMD_DRV_LOG(DEBUG,
+               PMD_DRV_LOG(DEBUG, sc,
                            "BRB1 is not empty, %d blocks are occupied", val);
        }
 }
@@ -11524,10 +11541,10 @@ static int ecore_gunzip(struct bnx2x_softc *sc, const uint8_t * zbuf, int len)
        int ret;
        int data_begin = cut_gzip_prefix(zbuf, len);
 
-       PMD_DRV_LOG(DEBUG, "ecore_gunzip %d", len);
+       PMD_DRV_LOG(DEBUG, sc, "ecore_gunzip %d", len);
 
        if (data_begin <= 0) {
-               PMD_DRV_LOG(NOTICE, "bad gzip prefix");
+               PMD_DRV_LOG(NOTICE, sc, "bad gzip prefix");
                return -1;
        }
 
@@ -11539,19 +11556,19 @@ static int ecore_gunzip(struct bnx2x_softc *sc, const uint8_t * zbuf, int len)
 
        ret = inflateInit2(&zlib_stream, -MAX_WBITS);
        if (ret != Z_OK) {
-               PMD_DRV_LOG(NOTICE, "zlib inflateInit2 error");
+               PMD_DRV_LOG(NOTICE, sc, "zlib inflateInit2 error");
                return ret;
        }
 
        ret = inflate(&zlib_stream, Z_FINISH);
        if ((ret != Z_STREAM_END) && (ret != Z_OK)) {
-               PMD_DRV_LOG(NOTICE, "zlib inflate error: %d %s", ret,
+               PMD_DRV_LOG(NOTICE, sc, "zlib inflate error: %d %s", ret,
                            zlib_stream.msg);
        }
 
        sc->gz_outlen = zlib_stream.total_out;
        if (sc->gz_outlen & 0x3) {
-               PMD_DRV_LOG(NOTICE, "firmware is not aligned. gz_outlen == %d",
+               PMD_DRV_LOG(NOTICE, sc, "firmware is not aligned. gz_outlen == %d",
                            sc->gz_outlen);
        }
        sc->gz_outlen >>= 2;
@@ -11670,7 +11687,7 @@ void bnx2x_print_adapter_info(struct bnx2x_softc *sc)
        int i = 0;
        __rte_unused uint32_t ext_phy_type;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
        if (sc->link_vars.phy_flags & PHY_XGXS_FLAG)
                ext_phy_type = ELINK_XGXS_EXT_PHY_TYPE(REG_RD(sc,
                                                              sc->
@@ -11689,97 +11706,102 @@ void bnx2x_print_adapter_info(struct bnx2x_softc *sc)
                                                                         dev_info.port_hw_config
                                                                         [0].external_phy_config)));
 
-       PMD_INIT_LOG(DEBUG, "\n\n===================================\n");
+       PMD_DRV_LOG(INFO, sc, "\n\n===================================\n");
        /* Hardware chip info. */
-       PMD_INIT_LOG(DEBUG, "%12s : %#08x", "ASIC", sc->devinfo.chip_id);
-       PMD_INIT_LOG(DEBUG, "%12s : %c%d", "Rev", (CHIP_REV(sc) >> 12) + 'A',
+       PMD_DRV_LOG(INFO, sc, "%12s : %#08x", "ASIC", sc->devinfo.chip_id);
+       PMD_DRV_LOG(INFO, sc, "%12s : %c%d", "Rev", (CHIP_REV(sc) >> 12) + 'A',
                     (CHIP_METAL(sc) >> 4));
 
        /* Bus info. */
-       PMD_INIT_LOG(DEBUG, "%12s : %d, ", "Bus PCIe", sc->devinfo.pcie_link_width);
+       PMD_DRV_LOG(INFO, sc,
+                   "%12s : %d, ", "Bus PCIe", sc->devinfo.pcie_link_width);
        switch (sc->devinfo.pcie_link_speed) {
        case 1:
-               PMD_INIT_LOG(DEBUG, "%23s", "2.5 Gbps");
+               PMD_DRV_LOG(INFO, sc, "%23s", "2.5 Gbps");
                break;
        case 2:
-               PMD_INIT_LOG(DEBUG, "%21s", "5 Gbps");
+               PMD_DRV_LOG(INFO, sc, "%21s", "5 Gbps");
                break;
        case 4:
-               PMD_INIT_LOG(DEBUG, "%21s", "8 Gbps");
+               PMD_DRV_LOG(INFO, sc, "%21s", "8 Gbps");
                break;
        default:
-               PMD_INIT_LOG(DEBUG, "%33s", "Unknown link speed");
+               PMD_DRV_LOG(INFO, sc, "%33s", "Unknown link speed");
        }
 
        /* Device features. */
-       PMD_INIT_LOG(DEBUG, "%12s : ", "Flags");
+       PMD_DRV_LOG(INFO, sc, "%12s : ", "Flags");
 
        /* Miscellaneous flags. */
        if (sc->devinfo.pcie_cap_flags & BNX2X_MSI_CAPABLE_FLAG) {
-               PMD_INIT_LOG(DEBUG, "%18s", "MSI");
+               PMD_DRV_LOG(INFO, sc, "%18s", "MSI");
                i++;
        }
 
        if (sc->devinfo.pcie_cap_flags & BNX2X_MSIX_CAPABLE_FLAG) {
                if (i > 0)
-                       PMD_INIT_LOG(DEBUG, "|");
-               PMD_INIT_LOG(DEBUG, "%20s", "MSI-X");
+                       PMD_DRV_LOG(INFO, sc, "|");
+               PMD_DRV_LOG(INFO, sc, "%20s", "MSI-X");
                i++;
        }
 
        if (IS_PF(sc)) {
-               PMD_INIT_LOG(DEBUG, "%12s : ", "Queues");
+               PMD_DRV_LOG(INFO, sc, "%12s : ", "Queues");
                switch (sc->sp->rss_rdata.rss_mode) {
                case ETH_RSS_MODE_DISABLED:
-                       PMD_INIT_LOG(DEBUG, "%19s", "None");
+                       PMD_DRV_LOG(INFO, sc, "%19s", "None");
                        break;
                case ETH_RSS_MODE_REGULAR:
-                       PMD_INIT_LOG(DEBUG, "%18s : %d", "RSS", sc->num_queues);
+                       PMD_DRV_LOG(INFO, sc,
+                                   "%18s : %d", "RSS", sc->num_queues);
                        break;
                default:
-                       PMD_INIT_LOG(DEBUG, "%22s", "Unknown");
+                       PMD_DRV_LOG(INFO, sc, "%22s", "Unknown");
                        break;
                }
        }
 
        /* RTE and Driver versions */
-       PMD_INIT_LOG(DEBUG, "%12s : %s", "DPDK",
-                    rte_version());
-       PMD_INIT_LOG(DEBUG, "%12s : %s", "Driver",
-                    bnx2x_pmd_version());
+       PMD_DRV_LOG(INFO, sc, "%12s : %s", "DPDK",
+                       rte_version());
+       PMD_DRV_LOG(INFO, sc, "%12s : %s", "Driver",
+                       bnx2x_pmd_version());
 
        /* Firmware versions and device features. */
-       PMD_INIT_LOG(DEBUG, "%12s : %d.%d.%d",
+       PMD_DRV_LOG(INFO, sc, "%12s : %d.%d.%d",
                     "Firmware",
                     BNX2X_5710_FW_MAJOR_VERSION,
                     BNX2X_5710_FW_MINOR_VERSION,
                     BNX2X_5710_FW_REVISION_VERSION);
-       PMD_INIT_LOG(DEBUG, "%12s : %s",
+       PMD_DRV_LOG(INFO, sc, "%12s : %s",
                     "Bootcode", sc->devinfo.bc_ver_str);
 
-       PMD_INIT_LOG(DEBUG, "\n\n===================================\n");
-       PMD_INIT_LOG(DEBUG, "%12s : %u", "Bnx2x Func", sc->pcie_func);
-       PMD_INIT_LOG(DEBUG, "%12s : %s", "Bnx2x Flags", get_bnx2x_flags(sc->flags));
-       PMD_INIT_LOG(DEBUG, "%12s : %s", "DMAE Is",
+       PMD_DRV_LOG(INFO, sc, "\n\n===================================\n");
+       PMD_DRV_LOG(INFO, sc, "%12s : %u", "Bnx2x Func", sc->pcie_func);
+       PMD_DRV_LOG(INFO, sc,
+                   "%12s : %s", "Bnx2x Flags", get_bnx2x_flags(sc->flags));
+       PMD_DRV_LOG(INFO, sc, "%12s : %s", "DMAE Is",
                     (sc->dmae_ready ? "Ready" : "Not Ready"));
-       PMD_INIT_LOG(DEBUG, "%12s : %s", "OVLAN", (OVLAN(sc) ? "YES" : "NO"));
-       PMD_INIT_LOG(DEBUG, "%12s : %s", "MF", (IS_MF(sc) ? "YES" : "NO"));
-       PMD_INIT_LOG(DEBUG, "%12s : %u", "MTU", sc->mtu);
-       PMD_INIT_LOG(DEBUG, "%12s : %s", "PHY Type", get_ext_phy_type(ext_phy_type));
-       PMD_INIT_LOG(DEBUG, "%12s : %x:%x:%x:%x:%x:%x", "MAC Addr",
+       PMD_DRV_LOG(INFO, sc, "%12s : %s", "OVLAN", (OVLAN(sc) ? "YES" : "NO"));
+       PMD_DRV_LOG(INFO, sc, "%12s : %s", "MF", (IS_MF(sc) ? "YES" : "NO"));
+       PMD_DRV_LOG(INFO, sc, "%12s : %u", "MTU", sc->mtu);
+       PMD_DRV_LOG(INFO, sc,
+                   "%12s : %s", "PHY Type", get_ext_phy_type(ext_phy_type));
+       PMD_DRV_LOG(INFO, sc, "%12s : %x:%x:%x:%x:%x:%x", "MAC Addr",
                        sc->link_params.mac_addr[0],
                        sc->link_params.mac_addr[1],
                        sc->link_params.mac_addr[2],
                        sc->link_params.mac_addr[3],
                        sc->link_params.mac_addr[4],
                        sc->link_params.mac_addr[5]);
-       PMD_INIT_LOG(DEBUG, "%12s : %s", "RX Mode", get_rx_mode(sc->rx_mode));
-       PMD_INIT_LOG(DEBUG, "%12s : %s", "State", get_state(sc->state));
+       PMD_DRV_LOG(INFO, sc, "%12s : %s", "RX Mode", get_rx_mode(sc->rx_mode));
+       PMD_DRV_LOG(INFO, sc, "%12s : %s", "State", get_state(sc->state));
        if (sc->recovery_state)
-               PMD_INIT_LOG(DEBUG, "%12s : %s", "Recovery",
+               PMD_DRV_LOG(INFO, sc, "%12s : %s", "Recovery",
                             get_recovery_state(sc->recovery_state));
-       PMD_INIT_LOG(DEBUG, "%12s : CQ = %lx,  EQ = %lx", "SPQ Left",
+       PMD_DRV_LOG(INFO, sc, "%12s : CQ = %lx,  EQ = %lx", "SPQ Left",
                     sc->cq_spq_left, sc->eq_spq_left);
-       PMD_INIT_LOG(DEBUG, "%12s : %x", "Switch", sc->link_params.switch_cfg);
-       PMD_INIT_LOG(DEBUG, "\n\n===================================\n");
+       PMD_DRV_LOG(INFO, sc,
+                   "%12s : %x", "Switch", sc->link_params.switch_cfg);
+       PMD_DRV_LOG(INFO, sc, "\n\n===================================\n");
 }
index 0f6024f..2d545f5 100644 (file)
@@ -803,6 +803,10 @@ struct bnx2x_mf_info {
 
 /* Device information data structure. */
 struct bnx2x_devinfo {
+#if 1
+#define NAME_SIZE 128
+       char name[NAME_SIZE];
+#endif
        /* PCIe info */
        uint16_t vendor_id;
        uint16_t device_id;
@@ -1418,7 +1422,7 @@ struct bnx2x_func_init_params {
 static inline void
 bnx2x_reg_write8(struct bnx2x_softc *sc, size_t offset, uint8_t val)
 {
-       PMD_DEBUG_PERIODIC_LOG(DEBUG, "offset=0x%08lx val=0x%02x",
+       PMD_DEBUG_PERIODIC_LOG(DEBUG, sc, "offset=0x%08lx val=0x%02x",
                               (unsigned long)offset, val);
        rte_write8(val, ((uint8_t *)sc->bar[BAR0].base_addr + offset));
 }
@@ -1428,10 +1432,10 @@ bnx2x_reg_write16(struct bnx2x_softc *sc, size_t offset, uint16_t val)
 {
 #ifdef RTE_LIBRTE_BNX2X_DEBUG_PERIODIC
        if ((offset % 2) != 0)
-               PMD_DRV_LOG(NOTICE, "Unaligned 16-bit write to 0x%08lx",
+               PMD_DRV_LOG(NOTICE, sc, "Unaligned 16-bit write to 0x%08lx",
                            (unsigned long)offset);
 #endif
-       PMD_DEBUG_PERIODIC_LOG(DEBUG, "offset=0x%08lx val=0x%04x",
+       PMD_DEBUG_PERIODIC_LOG(DEBUG, sc, "offset=0x%08lx val=0x%04x",
                               (unsigned long)offset, val);
        rte_write16(val, ((uint8_t *)sc->bar[BAR0].base_addr + offset));
 
@@ -1442,11 +1446,11 @@ bnx2x_reg_write32(struct bnx2x_softc *sc, size_t offset, uint32_t val)
 {
 #ifdef RTE_LIBRTE_BNX2X_DEBUG_PERIODIC
        if ((offset % 4) != 0)
-               PMD_DRV_LOG(NOTICE, "Unaligned 32-bit write to 0x%08lx",
+               PMD_DRV_LOG(NOTICE, sc, "Unaligned 32-bit write to 0x%08lx",
                            (unsigned long)offset);
 #endif
 
-       PMD_DEBUG_PERIODIC_LOG(DEBUG, "offset=0x%08lx val=0x%08x",
+       PMD_DEBUG_PERIODIC_LOG(DEBUG, sc, "offset=0x%08lx val=0x%08x",
                               (unsigned long)offset, val);
        rte_write32(val, ((uint8_t *)sc->bar[BAR0].base_addr + offset));
 }
@@ -1457,7 +1461,7 @@ bnx2x_reg_read8(struct bnx2x_softc *sc, size_t offset)
        uint8_t val;
 
        val = rte_read8((uint8_t *)sc->bar[BAR0].base_addr + offset);
-       PMD_DEBUG_PERIODIC_LOG(DEBUG, "offset=0x%08lx val=0x%02x",
+       PMD_DEBUG_PERIODIC_LOG(DEBUG, sc, "offset=0x%08lx val=0x%02x",
                               (unsigned long)offset, val);
 
        return val;
@@ -1470,12 +1474,12 @@ bnx2x_reg_read16(struct bnx2x_softc *sc, size_t offset)
 
 #ifdef RTE_LIBRTE_BNX2X_DEBUG_PERIODIC
        if ((offset % 2) != 0)
-               PMD_DRV_LOG(NOTICE, "Unaligned 16-bit read from 0x%08lx",
+               PMD_DRV_LOG(NOTICE, sc, "Unaligned 16-bit read from 0x%08lx",
                            (unsigned long)offset);
 #endif
 
        val = rte_read16(((uint8_t *)sc->bar[BAR0].base_addr + offset));
-       PMD_DEBUG_PERIODIC_LOG(DEBUG, "offset=0x%08lx val=0x%08x",
+       PMD_DEBUG_PERIODIC_LOG(DEBUG, sc, "offset=0x%08lx val=0x%08x",
                               (unsigned long)offset, val);
 
        return val;
@@ -1488,12 +1492,12 @@ bnx2x_reg_read32(struct bnx2x_softc *sc, size_t offset)
 
 #ifdef RTE_LIBRTE_BNX2X_DEBUG_PERIODIC
        if ((offset % 4) != 0)
-               PMD_DRV_LOG(NOTICE, "Unaligned 32-bit read from 0x%08lx",
+               PMD_DRV_LOG(NOTICE, sc, "Unaligned 32-bit read from 0x%08lx",
                            (unsigned long)offset);
 #endif
 
        val = rte_read32(((uint8_t *)sc->bar[BAR0].base_addr + offset));
-       PMD_DEBUG_PERIODIC_LOG(DEBUG, "offset=0x%08lx val=0x%08x",
+       PMD_DEBUG_PERIODIC_LOG(DEBUG, sc, "offset=0x%08lx val=0x%08x",
                               (unsigned long)offset, val);
 
        return val;
@@ -1970,7 +1974,7 @@ bnx2x_set_rx_mode(struct bnx2x_softc *sc)
                        bnx2x_vf_set_rx_mode(sc);
                }
        } else {
-               PMD_DRV_LOG(NOTICE, "Card is not ready to change mode");
+               PMD_DRV_LOG(NOTICE, sc, "Card is not ready to change mode");
        }
 }
 
@@ -1978,7 +1982,7 @@ static inline int pci_read(struct bnx2x_softc *sc, size_t addr,
                           void *val, uint8_t size)
 {
        if (rte_pci_read_config(sc->pci_dev, val, size, addr) <= 0) {
-               PMD_DRV_LOG(ERR, "Can't read from PCI config space");
+               PMD_DRV_LOG(ERR, sc, "Can't read from PCI config space");
                return ENXIO;
        }
 
@@ -1991,7 +1995,7 @@ static inline int pci_write_word(struct bnx2x_softc *sc, size_t addr, off_t val)
 
        if (rte_pci_write_config(sc->pci_dev, &val16,
                                     sizeof(val16), addr) <= 0) {
-               PMD_DRV_LOG(ERR, "Can't write to PCI config space");
+               PMD_DRV_LOG(ERR, sc, "Can't write to PCI config space");
                return ENXIO;
        }
 
@@ -2003,7 +2007,7 @@ static inline int pci_write_long(struct bnx2x_softc *sc, size_t addr, off_t val)
        uint32_t val32 = val;
        if (rte_pci_write_config(sc->pci_dev, &val32,
                                     sizeof(val32), addr) <= 0) {
-               PMD_DRV_LOG(ERR, "Can't write to PCI config space");
+               PMD_DRV_LOG(ERR, sc, "Can't write to PCI config space");
                return ENXIO;
        }
 
index 575271a..ae2e60a 100644 (file)
@@ -85,7 +85,7 @@ bnx2x_link_update(struct rte_eth_dev *dev)
        struct bnx2x_softc *sc = dev->data->dev_private;
        struct rte_eth_link link;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        bnx2x_link_status_update(sc);
        memset(&link, 0, sizeof(link));
@@ -129,7 +129,7 @@ bnx2x_interrupt_handler(void *param)
        struct rte_eth_dev *dev = (struct rte_eth_dev *)param;
        struct bnx2x_softc *sc = dev->data->dev_private;
 
-       PMD_DEBUG_PERIODIC_LOG(INFO, "Interrupt handled");
+       PMD_DEBUG_PERIODIC_LOG(INFO, sc, "Interrupt handled");
 
        bnx2x_interrupt_action(dev);
        rte_intr_enable(&sc->pci_dev->intr_handle);
@@ -147,8 +147,8 @@ static void bnx2x_periodic_start(void *param)
                ret = rte_eal_alarm_set(BNX2X_SP_TIMER_PERIOD,
                                        bnx2x_periodic_start, (void *)dev);
                if (ret) {
-                       PMD_DRV_LOG(ERR, "Unable to start periodic"
-                                        " timer rc %d", ret);
+                       PMD_DRV_LOG(ERR, sc, "Unable to start periodic"
+                                            " timer rc %d", ret);
                        assert(false && "Unable to start periodic timer");
                }
        }
@@ -176,34 +176,34 @@ bnx2x_dev_configure(struct rte_eth_dev *dev)
 
        int mp_ncpus = sysconf(_SC_NPROCESSORS_CONF);
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        if (rxmode->offloads & DEV_RX_OFFLOAD_JUMBO_FRAME)
                sc->mtu = dev->data->dev_conf.rxmode.max_rx_pkt_len;
 
        if (dev->data->nb_tx_queues > dev->data->nb_rx_queues) {
-               PMD_DRV_LOG(ERR, "The number of TX queues is greater than number of RX queues");
+               PMD_DRV_LOG(ERR, sc, "The number of TX queues is greater than number of RX queues");
                return -EINVAL;
        }
 
        sc->num_queues = MAX(dev->data->nb_rx_queues, dev->data->nb_tx_queues);
        if (sc->num_queues > mp_ncpus) {
-               PMD_DRV_LOG(ERR, "The number of queues is more than number of CPUs");
+               PMD_DRV_LOG(ERR, sc, "The number of queues is more than number of CPUs");
                return -EINVAL;
        }
 
-       PMD_DRV_LOG(DEBUG, "num_queues=%d, mtu=%d",
+       PMD_DRV_LOG(DEBUG, sc, "num_queues=%d, mtu=%d",
                       sc->num_queues, sc->mtu);
 
        /* allocate ilt */
        if (bnx2x_alloc_ilt_mem(sc) != 0) {
-               PMD_DRV_LOG(ERR, "bnx2x_alloc_ilt_mem was failed");
+               PMD_DRV_LOG(ERR, sc, "bnx2x_alloc_ilt_mem was failed");
                return -ENXIO;
        }
 
        /* allocate the host hardware/software hsi structures */
        if (bnx2x_alloc_hsi_mem(sc) != 0) {
-               PMD_DRV_LOG(ERR, "bnx2x_alloc_hsi_mem was failed");
+               PMD_DRV_LOG(ERR, sc, "bnx2x_alloc_hsi_mem was failed");
                bnx2x_free_ilt_mem(sc);
                return -ENXIO;
        }
@@ -217,7 +217,7 @@ bnx2x_dev_start(struct rte_eth_dev *dev)
        struct bnx2x_softc *sc = dev->data->dev_private;
        int ret = 0;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        /* start the periodic callout */
        if (sc->periodic_flags & PERIODIC_STOP)
@@ -225,7 +225,7 @@ bnx2x_dev_start(struct rte_eth_dev *dev)
 
        ret = bnx2x_init(sc);
        if (ret) {
-               PMD_DRV_LOG(DEBUG, "bnx2x_init failed (%d)", ret);
+               PMD_DRV_LOG(DEBUG, sc, "bnx2x_init failed (%d)", ret);
                return -1;
        }
 
@@ -234,12 +234,12 @@ bnx2x_dev_start(struct rte_eth_dev *dev)
                                bnx2x_interrupt_handler, (void *)dev);
 
                if (rte_intr_enable(&sc->pci_dev->intr_handle))
-                       PMD_DRV_LOG(ERR, "rte_intr_enable failed");
+                       PMD_DRV_LOG(ERR, sc, "rte_intr_enable failed");
        }
 
        ret = bnx2x_dev_rx_init(dev);
        if (ret != 0) {
-               PMD_DRV_LOG(DEBUG, "bnx2x_dev_rx_init returned error code");
+               PMD_DRV_LOG(DEBUG, sc, "bnx2x_dev_rx_init returned error code");
                return -3;
        }
 
@@ -255,7 +255,7 @@ bnx2x_dev_stop(struct rte_eth_dev *dev)
        struct bnx2x_softc *sc = dev->data->dev_private;
        int ret = 0;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        if (IS_PF(sc)) {
                rte_intr_disable(&sc->pci_dev->intr_handle);
@@ -268,7 +268,7 @@ bnx2x_dev_stop(struct rte_eth_dev *dev)
 
        ret = bnx2x_nic_unload(sc, UNLOAD_NORMAL, FALSE);
        if (ret) {
-               PMD_DRV_LOG(DEBUG, "bnx2x_nic_unload failed (%d)", ret);
+               PMD_DRV_LOG(DEBUG, sc, "bnx2x_nic_unload failed (%d)", ret);
                return;
        }
 
@@ -280,7 +280,7 @@ bnx2x_dev_close(struct rte_eth_dev *dev)
 {
        struct bnx2x_softc *sc = dev->data->dev_private;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        if (IS_VF(sc))
                bnx2x_vf_close(sc);
@@ -300,7 +300,7 @@ bnx2x_promisc_enable(struct rte_eth_dev *dev)
 {
        struct bnx2x_softc *sc = dev->data->dev_private;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
        sc->rx_mode = BNX2X_RX_MODE_PROMISC;
        if (rte_eth_allmulticast_get(dev->data->port_id) == 1)
                sc->rx_mode = BNX2X_RX_MODE_ALLMULTI_PROMISC;
@@ -312,7 +312,7 @@ bnx2x_promisc_disable(struct rte_eth_dev *dev)
 {
        struct bnx2x_softc *sc = dev->data->dev_private;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
        sc->rx_mode = BNX2X_RX_MODE_NORMAL;
        if (rte_eth_allmulticast_get(dev->data->port_id) == 1)
                sc->rx_mode = BNX2X_RX_MODE_ALLMULTI;
@@ -324,7 +324,7 @@ bnx2x_dev_allmulticast_enable(struct rte_eth_dev *dev)
 {
        struct bnx2x_softc *sc = dev->data->dev_private;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
        sc->rx_mode = BNX2X_RX_MODE_ALLMULTI;
        if (rte_eth_promiscuous_get(dev->data->port_id) == 1)
                sc->rx_mode = BNX2X_RX_MODE_ALLMULTI_PROMISC;
@@ -336,7 +336,7 @@ bnx2x_dev_allmulticast_disable(struct rte_eth_dev *dev)
 {
        struct bnx2x_softc *sc = dev->data->dev_private;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
        sc->rx_mode = BNX2X_RX_MODE_NORMAL;
        if (rte_eth_promiscuous_get(dev->data->port_id) == 1)
                sc->rx_mode = BNX2X_RX_MODE_PROMISC;
@@ -346,7 +346,9 @@ bnx2x_dev_allmulticast_disable(struct rte_eth_dev *dev)
 static int
 bnx2x_dev_link_update(struct rte_eth_dev *dev, __rte_unused int wait_to_complete)
 {
-       PMD_INIT_FUNC_TRACE();
+       struct bnx2x_softc *sc = dev->data->dev_private;
+
+       PMD_INIT_FUNC_TRACE(sc);
 
        return bnx2x_link_update(dev);
 }
@@ -361,7 +363,7 @@ bnx2xvf_dev_link_update(struct rte_eth_dev *dev, __rte_unused int wait_to_comple
 
        bnx2x_check_bull(sc);
        if (sc->old_bulletin.valid_bitmap & (1 << CHANNEL_DOWN)) {
-               PMD_DRV_LOG(ERR, "PF indicated channel is down."
+               PMD_DRV_LOG(ERR, sc, "PF indicated channel is down."
                                "VF device is no longer operational");
                dev->data->dev_link.link_status = ETH_LINK_DOWN;
        }
@@ -377,7 +379,7 @@ bnx2x_dev_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats)
        uint64_t brb_drops;
        uint64_t brb_truncates;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        bnx2x_stats_handle(sc, STATS_EVENT_UPDATE);
 
@@ -568,27 +570,35 @@ bnx2x_common_dev_init(struct rte_eth_dev *eth_dev, int is_vf)
 {
        int ret = 0;
        struct rte_pci_device *pci_dev;
+       struct rte_pci_addr pci_addr;
        struct bnx2x_softc *sc;
 
-       PMD_INIT_FUNC_TRACE();
+       /* Extract key data structures */
+       sc = eth_dev->data->dev_private;
+       pci_dev = RTE_DEV_TO_PCI(eth_dev->device);
+       pci_addr = pci_dev->addr;
+
+       snprintf(sc->devinfo.name, NAME_SIZE, PCI_SHORT_PRI_FMT ":dpdk-port-%u",
+                pci_addr.bus, pci_addr.devid, pci_addr.function,
+                eth_dev->data->port_id);
+
+       PMD_INIT_FUNC_TRACE(sc);
 
        eth_dev->dev_ops = is_vf ? &bnx2xvf_eth_dev_ops : &bnx2x_eth_dev_ops;
-       pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 
        rte_eth_copy_pci_info(eth_dev, pci_dev);
 
-       sc = eth_dev->data->dev_private;
        sc->pcie_bus    = pci_dev->addr.bus;
        sc->pcie_device = pci_dev->addr.devid;
 
-       if (is_vf)
-               sc->flags = BNX2X_IS_VF_FLAG;
-
        sc->devinfo.vendor_id    = pci_dev->id.vendor_id;
        sc->devinfo.device_id    = pci_dev->id.device_id;
        sc->devinfo.subvendor_id = pci_dev->id.subsystem_vendor_id;
        sc->devinfo.subdevice_id = pci_dev->id.subsystem_device_id;
 
+       if (is_vf)
+               sc->flags = BNX2X_IS_VF_FLAG;
+
        sc->pcie_func = pci_dev->addr.function;
        sc->bar[BAR0].base_addr = (void *)pci_dev->mem_resource[0].addr;
        if (is_vf)
@@ -616,7 +626,7 @@ bnx2x_common_dev_init(struct rte_eth_dev *eth_dev, int is_vf)
        sc->pci_dev = pci_dev;
        ret = bnx2x_attach(sc);
        if (ret) {
-               PMD_DRV_LOG(ERR, "bnx2x_attach failed (%d)", ret);
+               PMD_DRV_LOG(ERR, sc, "bnx2x_attach failed (%d)", ret);
                return ret;
        }
 
@@ -625,21 +635,21 @@ bnx2x_common_dev_init(struct rte_eth_dev *eth_dev, int is_vf)
                ret = rte_eal_alarm_set(BNX2X_SP_TIMER_PERIOD,
                                        bnx2x_periodic_start, (void *)eth_dev);
                if (ret) {
-                       PMD_DRV_LOG(ERR, "Unable to start periodic"
-                                         " timer rc %d", ret);
+                       PMD_DRV_LOG(ERR, sc, "Unable to start periodic"
+                                            " timer rc %d", ret);
                        return -EINVAL;
                }
        }
 
        eth_dev->data->mac_addrs = (struct ether_addr *)sc->link_params.mac_addr;
 
-       PMD_DRV_LOG(INFO, "pcie_bus=%d, pcie_device=%d",
+       PMD_DRV_LOG(INFO, sc, "pcie_bus=%d, pcie_device=%d",
                        sc->pcie_bus, sc->pcie_device);
-       PMD_DRV_LOG(INFO, "bar0.addr=%p, bar1.addr=%p",
+       PMD_DRV_LOG(INFO, sc, "bar0.addr=%p, bar1.addr=%p",
                        sc->bar[BAR0].base_addr, sc->bar[BAR1].base_addr);
-       PMD_DRV_LOG(INFO, "port=%d, path=%d, vnic=%d, func=%d",
+       PMD_DRV_LOG(INFO, sc, "port=%d, path=%d, vnic=%d, func=%d",
                        PORT_ID(sc), PATH_ID(sc), VNIC_ID(sc), FUNC_ID(sc));
-       PMD_DRV_LOG(INFO, "portID=%d vendorID=0x%x deviceID=0x%x",
+       PMD_DRV_LOG(INFO, sc, "portID=%d vendorID=0x%x deviceID=0x%x",
                        eth_dev->data->port_id, pci_dev->id.vendor_id, pci_dev->id.device_id);
 
        if (IS_VF(sc)) {
@@ -679,14 +689,16 @@ out:
 static int
 eth_bnx2x_dev_init(struct rte_eth_dev *eth_dev)
 {
-       PMD_INIT_FUNC_TRACE();
+       struct bnx2x_softc *sc = eth_dev->data->dev_private;
+       PMD_INIT_FUNC_TRACE(sc);
        return bnx2x_common_dev_init(eth_dev, 0);
 }
 
 static int
 eth_bnx2xvf_dev_init(struct rte_eth_dev *eth_dev)
 {
-       PMD_INIT_FUNC_TRACE();
+       struct bnx2x_softc *sc = eth_dev->data->dev_private;
+       PMD_INIT_FUNC_TRACE(sc);
        return bnx2x_common_dev_init(eth_dev, 1);
 }
 
index 9e232a9..753bccd 100644 (file)
@@ -9,11 +9,11 @@
 #define _PMD_LOGS_H_
 
 extern int bnx2x_logtype_init;
-#define PMD_INIT_LOG(level, fmt, args...) \
-       rte_log(RTE_LOG_ ## level, bnx2x_logtype_init, \
-               "%s(): " fmt "\n", __func__, ##args)
+#define PMD_INIT_LOG(level, sc, fmt, args...) \
+       RTE_LOG(level, PMD, \
+       "[bnx2x_pmd: %s] %s() " fmt "\n", (sc)->devinfo.name, __func__, ##args)
 
-#define PMD_INIT_FUNC_TRACE() PMD_INIT_LOG(DEBUG, " >>")
+#define PMD_INIT_FUNC_TRACE(sc) PMD_INIT_LOG(DEBUG, sc, " >>")
 
 #ifdef RTE_LIBRTE_BNX2X_DEBUG_RX
 #define PMD_RX_LOG(level, fmt, args...) \
@@ -37,18 +37,19 @@ extern int bnx2x_logtype_init;
 #endif
 
 extern int bnx2x_logtype_driver;
-#define PMD_DRV_LOG_RAW(level, fmt, args...) \
-       rte_log(RTE_LOG_ ## level, bnx2x_logtype_driver, \
-               "%s(): " fmt, __func__, ## args)
+#define PMD_DRV_LOG_RAW(level, sc, fmt, args...) \
+       RTE_LOG(level, PMD, "[%s:%d(%s)] " fmt, __func__, __LINE__, \
+               (sc)->devinfo.name ? (sc)->devinfo.name : "", ## args)
 
-#define PMD_DRV_LOG(level, fmt, args...) \
-       PMD_DRV_LOG_RAW(level, fmt "\n", ## args)
+#define PMD_DRV_LOG(level, sc, fmt, args...) \
+       PMD_DRV_LOG_RAW(level, sc, fmt "\n", ## args)
 
 #ifdef RTE_LIBRTE_BNX2X_DEBUG_PERIODIC
-#define PMD_DEBUG_PERIODIC_LOG(level, fmt, args...) \
-       RTE_LOG(level, PMD, "%s(): " fmt "\n", __func__, ## args)
+#define PMD_DEBUG_PERIODIC_LOG(level, sc, fmt, args...) \
+       RTE_LOG(level, PMD, "%s(%s): " fmt "\n", __func__, \
+               (sc)->devinfo.name ? (sc)->devinfo.name : "", ## args)
 #else
-#define PMD_DEBUG_PERIODIC_LOG(level, fmt, args...) do { } while(0)
+#define PMD_DEBUG_PERIODIC_LOG(level, sc, fmt, args...) do { } while (0)
 #endif
 
 #endif /* _PMD_LOGS_H_ */
index d9a4127..589735e 100644 (file)
@@ -76,7 +76,7 @@ bnx2x_dev_rx_queue_setup(struct rte_eth_dev *dev,
        rxq = rte_zmalloc_socket("ethdev RX queue", sizeof(struct bnx2x_rx_queue),
                                 RTE_CACHE_LINE_SIZE, socket_id);
        if (NULL == rxq) {
-               PMD_INIT_LOG(ERR, "rte_zmalloc for rxq failed!");
+               PMD_DRV_LOG(ERR, sc, "rte_zmalloc for rxq failed!");
                return -ENOMEM;
        }
        rxq->sc = sc;
@@ -92,7 +92,7 @@ bnx2x_dev_rx_queue_setup(struct rte_eth_dev *dev,
        sc->rx_ring_size = USABLE_RX_BD(rxq);
        rxq->nb_cq_pages = RCQ_BD_PAGES(rxq);
 
-       PMD_INIT_LOG(DEBUG, "fp[%02d] req_bd=%u, usable_bd=%lu, "
+       PMD_DRV_LOG(DEBUG, sc, "fp[%02d] req_bd=%u, usable_bd=%lu, "
                       "total_bd=%lu, rx_pages=%u, cq_pages=%u",
                       queue_idx, nb_desc, (unsigned long)USABLE_RX_BD(rxq),
                       (unsigned long)TOTAL_RX_BD(rxq), rxq->nb_rx_pages,
@@ -275,7 +275,7 @@ bnx2x_dev_tx_queue_setup(struct rte_eth_dev *dev,
        txq->tx_free_thresh = min(txq->tx_free_thresh,
                                  txq->nb_tx_desc - BDS_PER_TX_PKT);
 
-       PMD_INIT_LOG(DEBUG, "fp[%02d] req_bd=%u, thresh=%u, usable_bd=%lu, "
+       PMD_DRV_LOG(DEBUG, sc, "fp[%02d] req_bd=%u, thresh=%u, usable_bd=%lu, "
                     "total_bd=%lu, tx_pages=%u",
                     queue_idx, nb_desc, txq->tx_free_thresh,
                     (unsigned long)USABLE_TX_BD(txq),
@@ -301,7 +301,7 @@ bnx2x_dev_tx_queue_setup(struct rte_eth_dev *dev,
                return -ENOMEM;
        }
 
-       /* PMD_DRV_LOG(DEBUG, "sw_ring=%p hw_ring=%p dma_addr=0x%"PRIx64,
+       /* PMD_DRV_LOG(DEBUG, sc, "sw_ring=%p hw_ring=%p dma_addr=0x%"PRIx64,
           txq->sw_ring, txq->tx_ring, txq->tx_ring_phys_addr); */
 
        /* Link TX pages */
@@ -310,7 +310,9 @@ bnx2x_dev_tx_queue_setup(struct rte_eth_dev *dev,
                busaddr = txq->tx_ring_phys_addr + BNX2X_PAGE_SIZE * (i % txq->nb_tx_pages);
                tx_n_bd->addr_hi = rte_cpu_to_le_32(U64_HI(busaddr));
                tx_n_bd->addr_lo = rte_cpu_to_le_32(U64_LO(busaddr));
-               /* PMD_DRV_LOG(DEBUG, "link tx page %lu", (TOTAL_TX_BD_PER_PAGE * i - 1)); */
+               /* PMD_DRV_LOG(DEBUG, sc, "link tx page %lu",
+                *          (TOTAL_TX_BD_PER_PAGE * i - 1));
+                */
        }
 
        txq->queue_id = queue_idx;
@@ -461,9 +463,10 @@ bnx2x_dev_rx_init(struct rte_eth_dev *dev)
 void
 bnx2x_dev_clear_queues(struct rte_eth_dev *dev)
 {
+       struct bnx2x_softc *sc = dev->data->dev_private;
        uint8_t i;
 
-       PMD_INIT_FUNC_TRACE();
+       PMD_INIT_FUNC_TRACE(sc);
 
        for (i = 0; i < dev->data->nb_tx_queues; i++) {
                struct bnx2x_tx_queue *txq = dev->data->tx_queues[i];
index edc86cc..1cd9725 100644 (file)
@@ -82,7 +82,7 @@ bnx2x_storm_stats_post(struct bnx2x_softc *sc)
                sc->fw_stats_req->hdr.drv_stats_counter =
                        htole16(sc->stats_counter++);
 
-               PMD_DEBUG_PERIODIC_LOG(DEBUG,
+               PMD_DEBUG_PERIODIC_LOG(DEBUG, sc,
                                "sending statistics ramrod %d",
                                le16toh(sc->fw_stats_req->hdr.drv_stats_counter));
 
@@ -154,7 +154,7 @@ bnx2x_stats_comp(struct bnx2x_softc *sc)
 
        while (*stats_comp != DMAE_COMP_VAL) {
                if (!cnt) {
-                       PMD_DRV_LOG(ERR, "Timeout waiting for stats finished");
+                       PMD_DRV_LOG(ERR, sc, "Timeout waiting for stats finished");
                        break;
                }
 
@@ -189,7 +189,7 @@ bnx2x_stats_pmf_update(struct bnx2x_softc *sc)
        }
        /* sanity */
        if (!sc->port.pmf || !sc->port.port_stx) {
-               PMD_DRV_LOG(ERR, "BUG!");
+               PMD_DRV_LOG(ERR, sc, "BUG!");
                return;
        }
 
@@ -239,7 +239,7 @@ bnx2x_port_stats_init(struct bnx2x_softc *sc)
 
     /* sanity */
     if (!sc->link_vars.link_up || !sc->port.pmf) {
-       PMD_DRV_LOG(ERR, "BUG!");
+       PMD_DRV_LOG(ERR, sc, "BUG!");
        return;
     }
 
@@ -463,7 +463,7 @@ bnx2x_func_stats_init(struct bnx2x_softc *sc)
 
     /* sanity */
     if (!sc->func_stx) {
-       PMD_DRV_LOG(ERR, "BUG!");
+       PMD_DRV_LOG(ERR, sc, "BUG!");
        return;
     }
 
@@ -797,12 +797,12 @@ bnx2x_hw_stats_update(struct bnx2x_softc *sc)
        break;
 
     case ELINK_MAC_TYPE_NONE: /* unreached */
-       PMD_DRV_LOG(DEBUG,
+       PMD_DRV_LOG(DEBUG, sc,
              "stats updated by DMAE but no MAC active");
        return -1;
 
     default: /* unreached */
-       PMD_DRV_LOG(ERR, "stats update failed, unknown MAC type");
+       PMD_DRV_LOG(ERR, sc, "stats update failed, unknown MAC type");
     }
 
     ADD_EXTEND_64(pstats->brb_drop_hi, pstats->brb_drop_lo,
@@ -837,7 +837,7 @@ bnx2x_hw_stats_update(struct bnx2x_softc *sc)
        nig_timer_max = SHMEM_RD(sc, port_mb[SC_PORT(sc)].stat_nig_timer);
        if (nig_timer_max != estats->nig_timer_max) {
            estats->nig_timer_max = nig_timer_max;
-           PMD_DRV_LOG(ERR, "invalid NIG timer max (%u)",
+           PMD_DRV_LOG(ERR, sc, "invalid NIG timer max (%u)",
                  estats->nig_timer_max);
        }
     }
@@ -859,7 +859,7 @@ bnx2x_storm_stats_validate_counters(struct bnx2x_softc *sc)
 
     /* are storm stats valid? */
     if (le16toh(counters->xstats_counter) != cur_stats_counter) {
-       PMD_DRV_LOG(DEBUG,
+       PMD_DRV_LOG(DEBUG, sc,
              "stats not updated by xstorm, "
              "counter 0x%x != stats_counter 0x%x",
              le16toh(counters->xstats_counter), sc->stats_counter);
@@ -867,7 +867,7 @@ bnx2x_storm_stats_validate_counters(struct bnx2x_softc *sc)
     }
 
     if (le16toh(counters->ustats_counter) != cur_stats_counter) {
-       PMD_DRV_LOG(DEBUG,
+       PMD_DRV_LOG(DEBUG, sc,
              "stats not updated by ustorm, "
              "counter 0x%x != stats_counter 0x%x",
              le16toh(counters->ustats_counter), sc->stats_counter);
@@ -875,7 +875,7 @@ bnx2x_storm_stats_validate_counters(struct bnx2x_softc *sc)
     }
 
     if (le16toh(counters->cstats_counter) != cur_stats_counter) {
-       PMD_DRV_LOG(DEBUG,
+       PMD_DRV_LOG(DEBUG, sc,
              "stats not updated by cstorm, "
              "counter 0x%x != stats_counter 0x%x",
              le16toh(counters->cstats_counter), sc->stats_counter);
@@ -883,7 +883,7 @@ bnx2x_storm_stats_validate_counters(struct bnx2x_softc *sc)
     }
 
     if (le16toh(counters->tstats_counter) != cur_stats_counter) {
-       PMD_DRV_LOG(DEBUG,
+       PMD_DRV_LOG(DEBUG, sc,
              "stats not updated by tstorm, "
              "counter 0x%x != stats_counter 0x%x",
              le16toh(counters->tstats_counter), sc->stats_counter);
@@ -929,12 +929,13 @@ bnx2x_storm_stats_update(struct bnx2x_softc *sc)
 
                uint32_t diff;
 
-               /* PMD_DRV_LOG(DEBUG,
+               /* PMD_DRV_LOG(DEBUG, sc,
                                "queue[%d]: ucast_sent 0x%x bcast_sent 0x%x mcast_sent 0x%x",
                                i, xclient->ucast_pkts_sent, xclient->bcast_pkts_sent,
                                xclient->mcast_pkts_sent);
 
-               PMD_DRV_LOG(DEBUG, "---------------"); */
+               PMD_DRV_LOG(DEBUG, sc, "---------------");
+                */
 
                UPDATE_QSTAT(tclient->rcv_bcast_bytes,
                                total_broadcast_bytes_received);
@@ -1288,7 +1289,7 @@ void bnx2x_stats_handle(struct bnx2x_softc *sc, enum bnx2x_stats_event event)
        bnx2x_stats_stm[state][event].action(sc);
 
        if (event != STATS_EVENT_UPDATE) {
-               PMD_DRV_LOG(DEBUG,
+               PMD_DRV_LOG(DEBUG, sc,
                                "state %d -> event %d -> state %d",
                                state, event, sc->stats_state);
        }
@@ -1302,7 +1303,7 @@ bnx2x_port_stats_base_init(struct bnx2x_softc *sc)
 
     /* sanity */
     if (!sc->port.pmf || !sc->port.port_stx) {
-       PMD_DRV_LOG(ERR, "BUG!");
+       PMD_DRV_LOG(ERR, sc, "BUG!");
        return;
     }
 
@@ -1474,7 +1475,7 @@ bnx2x_stats_init(struct bnx2x_softc *sc)
                sc->func_stx = 0;
        }
 
-       PMD_DRV_LOG(DEBUG, "port_stx 0x%x func_stx 0x%x",
+       PMD_DRV_LOG(DEBUG, sc, "port_stx 0x%x func_stx 0x%x",
                        sc->port.port_stx, sc->func_stx);
 
        /* pmf should retrieve port statistics from SP on a non-init*/
index 50099d4..048bf12 100644 (file)
@@ -37,12 +37,12 @@ bnx2x_check_bull(struct bnx2x_softc *sc)
                        if (bull->crc == bnx2x_vf_crc(bull))
                                break;
 
-                       PMD_DRV_LOG(ERR, "bad crc on bulletin board. contained %x computed %x",
+                       PMD_DRV_LOG(ERR, sc, "bad crc on bulletin board. contained %x computed %x",
                                        bull->crc, bnx2x_vf_crc(bull));
                        ++tries;
                }
                if (tries == BNX2X_VF_BULLETIN_TRIES) {
-                       PMD_DRV_LOG(ERR, "pf to vf bulletin board crc was wrong %d consecutive times. Aborting",
+                       PMD_DRV_LOG(ERR, sc, "pf to vf bulletin board crc was wrong %d consecutive times. Aborting",
                                        tries);
                        return FALSE;
                }
@@ -82,7 +82,7 @@ bnx2x_vf_prep(struct bnx2x_softc *sc, struct vf_first_tlv *first_tlv,
 
        rte_spinlock_lock(&sc->vf2pf_lock);
 
-       PMD_DRV_LOG(DEBUG, "Preparing %d tlv for sending", type);
+       PMD_DRV_LOG(DEBUG, sc, "Preparing %d tlv for sending", type);
 
        memset(mbox, 0, sizeof(struct bnx2x_vf_mbx_msg));
 
@@ -97,7 +97,7 @@ static void
 bnx2x_vf_finalize(struct bnx2x_softc *sc,
                  __rte_unused struct vf_first_tlv *first_tlv)
 {
-       PMD_DRV_LOG(DEBUG, "done sending [%d] tlv over vf pf channel",
+       PMD_DRV_LOG(DEBUG, sc, "done sending [%d] tlv over vf pf channel",
                    first_tlv->tl.type);
 
        rte_spinlock_unlock(&sc->vf2pf_lock);
@@ -116,14 +116,14 @@ bnx2x_do_req4pf(struct bnx2x_softc *sc, rte_iova_t phys_addr)
        uint8_t i;
 
        if (*status) {
-               PMD_DRV_LOG(ERR, "status should be zero before message"
+               PMD_DRV_LOG(ERR, sc, "status should be zero before message"
                                 " to pf was sent");
                return -EINVAL;
        }
 
        bnx2x_check_bull(sc);
        if (sc->old_bulletin.valid_bitmap & (1 << CHANNEL_DOWN)) {
-               PMD_DRV_LOG(ERR, "channel is down. Aborting message sending");
+               PMD_DRV_LOG(ERR, sc, "channel is down. Aborting message sending");
                return -EINVAL;
        }
 
@@ -143,11 +143,11 @@ bnx2x_do_req4pf(struct bnx2x_softc *sc, rte_iova_t phys_addr)
        }
 
        if (!*status) {
-               PMD_DRV_LOG(ERR, "Response from PF timed out");
+               PMD_DRV_LOG(ERR, sc, "Response from PF timed out");
                return -EAGAIN;
        }
 
-       PMD_DRV_LOG(DEBUG, "Response from PF was received");
+       PMD_DRV_LOG(DEBUG, sc, "Response from PF was received");
        return 0;
 }
 
@@ -195,7 +195,7 @@ int bnx2x_loop_obtain_resources(struct bnx2x_softc *sc)
        int rc;
 
        do {
-               PMD_DRV_LOG(DEBUG, "trying to get resources");
+               PMD_DRV_LOG(DEBUG, sc, "trying to get resources");
 
                rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
                if (rc)
@@ -207,11 +207,11 @@ int bnx2x_loop_obtain_resources(struct bnx2x_softc *sc)
 
                /* check PF to request acceptance */
                if (sc_resp->status == BNX2X_VF_STATUS_SUCCESS) {
-                       PMD_DRV_LOG(DEBUG, "resources obtained successfully");
+                       PMD_DRV_LOG(DEBUG, sc, "resources obtained successfully");
                        res_obtained = true;
                } else if (sc_resp->status == BNX2X_VF_STATUS_NO_RESOURCES &&
                           tries < BNX2X_VF_OBTAIN_MAX_TRIES) {
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                           "PF cannot allocate requested amount of resources");
 
                        res_query = &sc->vf2pf_mbox->query[0].acquire.res_query;
@@ -227,7 +227,7 @@ int bnx2x_loop_obtain_resources(struct bnx2x_softc *sc)
 
                        memset(&sc->vf2pf_mbox->resp, 0, sizeof(union resp_tlvs));
                } else {
-                       PMD_DRV_LOG(ERR, "Failed to get the requested "
+                       PMD_DRV_LOG(ERR, sc, "Failed to get the requested "
                                         "amount of resources: %d.",
                                         sc_resp->status);
                        return -EINVAL;
@@ -296,7 +296,7 @@ int bnx2x_vf_get_resources(struct bnx2x_softc *sc, uint8_t tx_count, uint8_t rx_
        sc->doorbell_size = sc_resp.db_size;
        sc->flags |= BNX2X_NO_WOL_FLAG | BNX2X_NO_ISCSI_OOO_FLAG | BNX2X_NO_ISCSI_FLAG | BNX2X_NO_FCOE_FLAG;
 
-       PMD_DRV_LOG(DEBUG, "status block count = %d, base status block = %x",
+       PMD_DRV_LOG(DEBUG, sc, "status block count = %d, base status block = %x",
                sc->igu_sb_cnt, sc->igu_base_sb);
        strncpy(sc->fw_ver, sc_resp.fw_ver, sizeof(sc->fw_ver));
 
@@ -333,7 +333,7 @@ bnx2x_vf_close(struct bnx2x_softc *sc)
 
                rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
                if (rc || reply->status != BNX2X_VF_STATUS_SUCCESS)
-                       PMD_DRV_LOG(ERR, "Failed to release VF");
+                       PMD_DRV_LOG(ERR, sc, "Failed to release VF");
 
                bnx2x_vf_finalize(sc, &query->first_tlv);
        }
@@ -367,12 +367,12 @@ bnx2x_vf_init(struct bnx2x_softc *sc)
        if (rc)
                goto out;
        if (reply->status != BNX2X_VF_STATUS_SUCCESS) {
-               PMD_DRV_LOG(ERR, "Failed to init VF");
+               PMD_DRV_LOG(ERR, sc, "Failed to init VF");
                rc = -EINVAL;
                goto out;
        }
 
-       PMD_DRV_LOG(DEBUG, "VF was initialized");
+       PMD_DRV_LOG(DEBUG, sc, "VF was initialized");
 out:
        bnx2x_vf_finalize(sc, &query->first_tlv);
        return rc;
@@ -403,7 +403,7 @@ bnx2x_vf_unload(struct bnx2x_softc *sc)
 
                        rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
                        if (rc || reply->status != BNX2X_VF_STATUS_SUCCESS)
-                               PMD_DRV_LOG(ERR,
+                               PMD_DRV_LOG(ERR, sc,
                                            "Bad reply for vf_q %d teardown", i);
 
                        bnx2x_vf_finalize(sc, &query_op->first_tlv);
@@ -423,7 +423,7 @@ bnx2x_vf_unload(struct bnx2x_softc *sc)
 
                rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
                if (rc || reply->status != BNX2X_VF_STATUS_SUCCESS)
-                       PMD_DRV_LOG(ERR,
+                       PMD_DRV_LOG(ERR, sc,
                                    "Bad reply from PF for close message");
 
                bnx2x_vf_finalize(sc, &query->first_tlv);
@@ -450,7 +450,7 @@ bnx2x_vf_rx_q_prep(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp,
 
        rxq = sc->rx_queues[fp->index];
        if (!rxq) {
-               PMD_DRV_LOG(ERR, "RX queue %d is NULL", fp->index);
+               PMD_DRV_LOG(ERR, sc, "RX queue %d is NULL", fp->index);
                return;
        }
 
@@ -474,7 +474,7 @@ bnx2x_vf_tx_q_prep(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp,
 
        txq = sc->tx_queues[fp->index];
        if (!txq) {
-               PMD_DRV_LOG(ERR, "TX queue %d is NULL", fp->index);
+               PMD_DRV_LOG(ERR, sc, "TX queue %d is NULL", fp->index);
                return;
        }
 
@@ -511,7 +511,7 @@ bnx2x_vf_setup_queue(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp, int lead
        if (rc)
                goto out;
        if (reply->status != BNX2X_VF_STATUS_SUCCESS) {
-               PMD_DRV_LOG(ERR, "Failed to setup VF queue[%d]",
+               PMD_DRV_LOG(ERR, sc, "Failed to setup VF queue[%d]",
                                 fp->index);
                rc = -EINVAL;
        }
@@ -566,7 +566,7 @@ bnx2x_vf_set_mac(struct bnx2x_softc *sc, int set)
        }
 
        if (BNX2X_VF_STATUS_SUCCESS != reply->status) {
-               PMD_DRV_LOG(ERR, "Bad reply from PF for SET MAC message: %d",
+               PMD_DRV_LOG(ERR, sc, "Bad reply from PF for SET MAC message: %d",
                                reply->status);
                rc = -EINVAL;
        }
@@ -608,7 +608,7 @@ bnx2x_vf_config_rss(struct bnx2x_softc *sc,
                goto out;
 
        if (reply->status != BNX2X_VF_STATUS_SUCCESS) {
-               PMD_DRV_LOG(ERR, "Failed to configure RSS");
+               PMD_DRV_LOG(ERR, sc, "Failed to configure RSS");
                rc = -EINVAL;
        }
 out:
@@ -652,7 +652,7 @@ bnx2x_vf_set_rx_mode(struct bnx2x_softc *sc)
                query->rx_mask |= VFPF_RX_MASK_ACCEPT_BROADCAST;
                break;
        default:
-               PMD_DRV_LOG(ERR, "BAD rx mode (%d)", sc->rx_mode);
+               PMD_DRV_LOG(ERR, sc, "BAD rx mode (%d)", sc->rx_mode);
                rc = -EINVAL;
                goto out;
        }
@@ -666,7 +666,7 @@ bnx2x_vf_set_rx_mode(struct bnx2x_softc *sc)
                goto out;
 
        if (reply->status != BNX2X_VF_STATUS_SUCCESS) {
-               PMD_DRV_LOG(ERR, "Failed to set RX mode");
+               PMD_DRV_LOG(ERR, sc, "Failed to set RX mode");
                rc = -EINVAL;
        }
 
index f2de07e..97dfe69 100644 (file)
@@ -741,7 +741,7 @@ static inline void ecore_disable_blocks_parity(struct bnx2x_softc *sc)
                if (dis_mask) {
                        REG_WR(sc, ecore_blocks_parity_data[i].mask_addr,
                               dis_mask);
-                       ECORE_MSG("Setting parity mask "
+                       ECORE_MSG(sc, "Setting parity mask "
                                                 "for %s to\t\t0x%x",
                                    ecore_blocks_parity_data[i].name, dis_mask);
                }
@@ -776,7 +776,7 @@ static inline void ecore_clear_blocks_parity(struct bnx2x_softc *sc)
                        reg_val = REG_RD(sc, ecore_blocks_parity_data[i].
                                         sts_clr_addr);
                        if (reg_val & reg_mask)
-                               ECORE_MSG("Parity errors in %s: 0x%x",
+                               ECORE_MSG(sc, "Parity errors in %s: 0x%x",
                                           ecore_blocks_parity_data[i].name,
                                           reg_val & reg_mask);
                }
@@ -785,7 +785,7 @@ static inline void ecore_clear_blocks_parity(struct bnx2x_softc *sc)
        /* Check if there were parity attentions in MCP */
        reg_val = REG_RD(sc, MISC_REG_AEU_AFTER_INVERT_4_MCP);
        if (reg_val & mcp_aeu_bits)
-               ECORE_MSG("Parity error in MCP: 0x%x",
+               ECORE_MSG(sc, "Parity error in MCP: 0x%x",
                           reg_val & mcp_aeu_bits);
 
        /* Clear parity attentions in MCP:
index 2b003af..733ad1a 100644 (file)
@@ -424,20 +424,20 @@ static void ecore_init_pxp_arb(struct bnx2x_softc *sc, int r_order,
        uint32_t val, i;
 
        if (r_order > MAX_RD_ORD) {
-               ECORE_MSG("read order of %d  order adjusted to %d",
+               ECORE_MSG(sc, "read order of %d  order adjusted to %d",
                           r_order, MAX_RD_ORD);
                r_order = MAX_RD_ORD;
        }
        if (w_order > MAX_WR_ORD) {
-               ECORE_MSG("write order of %d  order adjusted to %d",
+               ECORE_MSG(sc, "write order of %d  order adjusted to %d",
                           w_order, MAX_WR_ORD);
                w_order = MAX_WR_ORD;
        }
        if (CHIP_REV_IS_FPGA(sc)) {
-               ECORE_MSG("write order adjusted to 1 for FPGA");
+               ECORE_MSG(sc, "write order adjusted to 1 for FPGA");
                w_order = 0;
        }
-       ECORE_MSG("read order %d  write order %d", r_order, w_order);
+       ECORE_MSG(sc, "read order %d  write order %d", r_order, w_order);
 
        for (i = 0; i < NUM_RD_Q-1; i++) {
                REG_WR(sc, read_arb_addr[i].l, read_arb_data[i][r_order].l);
index 0c8685c..ab730ab 100644 (file)
@@ -53,14 +53,14 @@ ecore_exe_queue_init(struct bnx2x_softc *sc __rte_unused,
        o->execute = exec;
        o->get = get;
 
-       ECORE_MSG("Setup the execution queue with the chunk length of %d",
+       ECORE_MSG(sc, "Setup the execution queue with the chunk length of %d",
                  exe_len);
 }
 
 static void ecore_exe_queue_free_elem(struct bnx2x_softc *sc __rte_unused,
                                      struct ecore_exeq_elem *elem)
 {
-       ECORE_MSG("Deleting an exe_queue element");
+       ECORE_MSG(sc, "Deleting an exe_queue element");
        ECORE_FREE(sc, elem, sizeof(*elem));
 }
 
@@ -106,7 +106,7 @@ static int ecore_exe_queue_add(struct bnx2x_softc *sc,
                /* Check if this request is ok */
                rc = o->validate(sc, o->owner, elem);
                if (rc) {
-                       ECORE_MSG("Preamble failed: %d", rc);
+                       ECORE_MSG(sc, "Preamble failed: %d", rc);
                        goto free_and_exit;
                }
        }
@@ -176,8 +176,8 @@ static int ecore_exe_queue_step(struct bnx2x_softc *sc,
         */
        if (!ECORE_LIST_IS_EMPTY(&o->pending_comp)) {
                if (ECORE_TEST_BIT(RAMROD_DRV_CLR_ONLY, ramrod_flags)) {
-                       ECORE_MSG
-                           ("RAMROD_DRV_CLR_ONLY requested: resetting a pending_comp list");
+                       ECORE_MSG(sc,
+                                 "RAMROD_DRV_CLR_ONLY requested: resetting a pending_comp list");
                        __ecore_exe_queue_reset_pending(sc, o);
                } else {
                        return ECORE_PENDING;
@@ -240,7 +240,7 @@ static struct ecore_exeq_elem *ecore_exe_queue_alloc_elem(struct
                                                          bnx2x_softc *sc
                                                          __rte_unused)
 {
-       ECORE_MSG("Allocating a new exe_queue element");
+       ECORE_MSG(sc, "Allocating a new exe_queue element");
        return ECORE_ZALLOC(sizeof(struct ecore_exeq_elem), GFP_ATOMIC, sc);
 }
 
@@ -290,14 +290,14 @@ static int ecore_state_wait(struct bnx2x_softc *sc, int state,
        if (CHIP_REV_IS_EMUL(sc))
                cnt *= 20;
 
-       ECORE_MSG("waiting for state to become %d", state);
+       ECORE_MSG(sc, "waiting for state to become %d", state);
 
        ECORE_MIGHT_SLEEP();
        while (cnt--) {
                bnx2x_intr_legacy(sc, 1);
                if (!ECORE_TEST_BIT(state, pstate)) {
 #ifdef ECORE_STOP_ON_ERROR
-                       ECORE_MSG("exit  (cnt %d)", 5000 - cnt);
+                       ECORE_MSG(sc, "exit  (cnt %d)", 5000 - cnt);
 #endif
                        return ECORE_SUCCESS;
                }
@@ -309,7 +309,7 @@ static int ecore_state_wait(struct bnx2x_softc *sc, int state,
        }
 
        /* timeout! */
-       PMD_DRV_LOG(ERR, "timeout waiting for state %d", state);
+       PMD_DRV_LOG(ERR, sc, "timeout waiting for state %d", state);
 #ifdef ECORE_STOP_ON_ERROR
        ecore_panic();
 #endif
@@ -370,11 +370,11 @@ static int __ecore_vlan_mac_h_write_trylock(struct bnx2x_softc *sc __rte_unused,
                                            struct ecore_vlan_mac_obj *o)
 {
        if (o->head_reader) {
-               ECORE_MSG("vlan_mac_lock writer - There are readers; Busy");
+               ECORE_MSG(sc, "vlan_mac_lock writer - There are readers; Busy");
                return ECORE_BUSY;
        }
 
-       ECORE_MSG("vlan_mac_lock writer - Taken");
+       ECORE_MSG(sc, "vlan_mac_lock writer - Taken");
        return ECORE_SUCCESS;
 }
 
@@ -394,13 +394,13 @@ static void __ecore_vlan_mac_h_exec_pending(struct bnx2x_softc *sc,
        int rc;
        unsigned long ramrod_flags = o->saved_ramrod_flags;
 
-       ECORE_MSG("vlan_mac_lock execute pending command with ramrod flags %lu",
+       ECORE_MSG(sc, "vlan_mac_lock execute pending command with ramrod flags %lu",
                  ramrod_flags);
        o->head_exe_request = FALSE;
        o->saved_ramrod_flags = 0;
        rc = ecore_exe_queue_step(sc, &o->exe_queue, &ramrod_flags);
        if (rc != ECORE_SUCCESS) {
-               PMD_DRV_LOG(ERR,
+               PMD_DRV_LOG(ERR, sc,
                            "execution of pending commands failed with rc %d",
                            rc);
 #ifdef ECORE_STOP_ON_ERROR
@@ -425,7 +425,7 @@ static void __ecore_vlan_mac_h_pend(struct bnx2x_softc *sc __rte_unused,
 {
        o->head_exe_request = TRUE;
        o->saved_ramrod_flags = ramrod_flags;
-       ECORE_MSG("Placing pending execution with ramrod flags %lu",
+       ECORE_MSG(sc, "Placing pending execution with ramrod flags %lu",
                  ramrod_flags);
 }
 
@@ -446,8 +446,8 @@ static void __ecore_vlan_mac_h_write_unlock(struct bnx2x_softc *sc,
         * executed. If so, execute again. [Ad infinitum]
         */
        while (o->head_exe_request) {
-               ECORE_MSG
-                   ("vlan_mac_lock - writer release encountered a pending request");
+               ECORE_MSG(sc,
+                         "vlan_mac_lock - writer release encountered a pending request");
                __ecore_vlan_mac_h_exec_pending(sc, o);
        }
 }
@@ -483,7 +483,8 @@ static int __ecore_vlan_mac_h_read_lock(struct bnx2x_softc *sc __rte_unused,
 {
        /* If we got here, we're holding lock --> no WRITER exists */
        o->head_reader++;
-       ECORE_MSG("vlan_mac_lock - locked reader - number %d", o->head_reader);
+       ECORE_MSG(sc,
+                 "vlan_mac_lock - locked reader - number %d", o->head_reader);
 
        return ECORE_SUCCESS;
 }
@@ -522,14 +523,14 @@ static void __ecore_vlan_mac_h_read_unlock(struct bnx2x_softc *sc,
                                           struct ecore_vlan_mac_obj *o)
 {
        if (!o->head_reader) {
-               PMD_DRV_LOG(ERR,
+               PMD_DRV_LOG(ERR, sc,
                            "Need to release vlan mac reader lock, but lock isn't taken");
 #ifdef ECORE_STOP_ON_ERROR
                ecore_panic();
 #endif
        } else {
                o->head_reader--;
-               PMD_DRV_LOG(INFO,
+               PMD_DRV_LOG(INFO, sc,
                            "vlan_mac_lock - decreased readers to %d",
                            o->head_reader);
        }
@@ -538,7 +539,7 @@ static void __ecore_vlan_mac_h_read_unlock(struct bnx2x_softc *sc,
         * was last - if so we need to execute the command.
         */
        if (!o->head_reader && o->head_exe_request) {
-               PMD_DRV_LOG(INFO,
+               PMD_DRV_LOG(INFO, sc,
                            "vlan_mac_lock - reader release encountered a pending request");
 
                /* Writer release will do the trick */
@@ -581,10 +582,10 @@ static int ecore_get_n_elements(struct bnx2x_softc *sc,
        uint8_t *next = base;
        int counter = 0, read_lock;
 
-       ECORE_MSG("get_n_elements - taking vlan_mac_lock (reader)");
+       ECORE_MSG(sc, "get_n_elements - taking vlan_mac_lock (reader)");
        read_lock = ecore_vlan_mac_h_read_lock(sc, o);
        if (read_lock != ECORE_SUCCESS)
-               PMD_DRV_LOG(ERR,
+               PMD_DRV_LOG(ERR, sc,
                            "get_n_elements failed to get vlan mac reader lock; Access without lock");
 
        /* traverse list */
@@ -593,15 +594,15 @@ static int ecore_get_n_elements(struct bnx2x_softc *sc,
                if (counter < n) {
                        ECORE_MEMCPY(next, &pos->u, size);
                        counter++;
-                       ECORE_MSG
-                           ("copied element number %d to address %p element was:",
+                           ECORE_MSG
+                           (sc, "copied element number %d to address %p element was:",
                             counter, next);
                        next += stride + size;
                }
        }
 
        if (read_lock == ECORE_SUCCESS) {
-               ECORE_MSG("get_n_elements - releasing vlan_mac_lock (reader)");
+               ECORE_MSG(sc, "get_n_elements - releasing vlan_mac_lock (reader)");
                ecore_vlan_mac_h_read_unlock(sc, o);
        }
 
@@ -615,7 +616,7 @@ static int ecore_check_mac_add(struct bnx2x_softc *sc __rte_unused,
 {
        struct ecore_vlan_mac_registry_elem *pos;
 
-       ECORE_MSG("Checking MAC %02x:%02x:%02x:%02x:%02x:%02x for ADD command",
+       ECORE_MSG(sc, "Checking MAC %02x:%02x:%02x:%02x:%02x:%02x for ADD command",
                  data->mac.mac[0], data->mac.mac[1], data->mac.mac[2],
                  data->mac.mac[3], data->mac.mac[4], data->mac.mac[5]);
 
@@ -644,7 +645,7 @@ static struct ecore_vlan_mac_registry_elem *ecore_check_mac_del(struct bnx2x_sof
 {
        struct ecore_vlan_mac_registry_elem *pos;
 
-       ECORE_MSG("Checking MAC %02x:%02x:%02x:%02x:%02x:%02x for DEL command",
+       ECORE_MSG(sc, "Checking MAC %02x:%02x:%02x:%02x:%02x:%02x for DEL command",
                  data->mac.mac[0], data->mac.mac[1], data->mac.mac[2],
                  data->mac.mac[3], data->mac.mac[4], data->mac.mac[5]);
 
@@ -722,7 +723,7 @@ static void ecore_set_mac_in_nig(struct bnx2x_softc *sc,
        if (index > ECORE_LLH_CAM_MAX_PF_LINE)
                return;
 
-       ECORE_MSG("Going to %s LLH configuration at entry %d",
+       ECORE_MSG(sc, "Going to %s LLH configuration at entry %d",
                  (add ? "ADD" : "DELETE"), index);
 
        if (add) {
@@ -838,7 +839,7 @@ static void ecore_set_one_mac_e2(struct bnx2x_softc *sc,
        ecore_vlan_mac_set_cmd_hdr_e2(o, add, CLASSIFY_RULE_OPCODE_MAC,
                                      &rule_entry->mac.header);
 
-       ECORE_MSG("About to %s MAC %02x:%02x:%02x:%02x:%02x:%02x for Queue %d",
+       ECORE_MSG(sc, "About to %s MAC %02x:%02x:%02x:%02x:%02x:%02x for Queue %d",
                  (add ? "add" : "delete"), mac[0], mac[1], mac[2], mac[3],
                  mac[4], mac[5], raw->cl_id);
 
@@ -943,7 +944,7 @@ static void ecore_vlan_mac_set_rdata_e1x(struct bnx2x_softc *sc
        ecore_vlan_mac_set_cfg_entry_e1x(o, add, opcode, mac, vlan_id,
                                         cfg_entry);
 
-       ECORE_MSG("%s MAC %02x:%02x:%02x:%02x:%02x:%02x CLID %d CAM offset %d",
+       ECORE_MSG(sc, "%s MAC %02x:%02x:%02x:%02x:%02x:%02x CLID %d CAM offset %d",
                  (add ? "setting" : "clearing"),
                  mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
                  o->raw.cl_id, cam_offset);
@@ -1088,8 +1089,8 @@ static int ecore_validate_vlan_mac_add(struct bnx2x_softc *sc,
        /* Check the registry */
        rc = o->check_add(sc, o, &elem->cmd_data.vlan_mac.u);
        if (rc) {
-               ECORE_MSG
-                   ("ADD command is not allowed considering current registry state.");
+               ECORE_MSG(sc,
+                         "ADD command is not allowed considering current registry state.");
                return rc;
        }
 
@@ -1097,7 +1098,7 @@ static int ecore_validate_vlan_mac_add(struct bnx2x_softc *sc,
         * MAC/VLAN/VLAN-MAC. Return an error if there is.
         */
        if (exeq->get(exeq, elem)) {
-               ECORE_MSG("There is a pending ADD command already");
+               ECORE_MSG(sc, "There is a pending ADD command already");
                return ECORE_EXISTS;
        }
 
@@ -1136,8 +1137,8 @@ static int ecore_validate_vlan_mac_del(struct bnx2x_softc *sc,
         */
        pos = o->check_del(sc, o, &elem->cmd_data.vlan_mac.u);
        if (!pos) {
-               ECORE_MSG
-                   ("DEL command is not allowed considering current registry state");
+               ECORE_MSG(sc,
+                         "DEL command is not allowed considering current registry state");
                return ECORE_EXISTS;
        }
 
@@ -1149,13 +1150,13 @@ static int ecore_validate_vlan_mac_del(struct bnx2x_softc *sc,
        /* Check for MOVE commands */
        query_elem.cmd_data.vlan_mac.cmd = ECORE_VLAN_MAC_MOVE;
        if (exeq->get(exeq, &query_elem)) {
-               PMD_DRV_LOG(ERR, "There is a pending MOVE command already");
+               PMD_DRV_LOG(ERR, sc, "There is a pending MOVE command already");
                return ECORE_INVAL;
        }
 
        /* Check for DEL commands */
        if (exeq->get(exeq, elem)) {
-               ECORE_MSG("There is a pending DEL command already");
+               ECORE_MSG(sc, "There is a pending DEL command already");
                return ECORE_EXISTS;
        }
 
@@ -1163,7 +1164,7 @@ static int ecore_validate_vlan_mac_del(struct bnx2x_softc *sc,
        if (!(ECORE_TEST_BIT(ECORE_DONT_CONSUME_CAM_CREDIT,
                             &elem->cmd_data.vlan_mac.vlan_mac_flags) ||
              o->put_credit(o))) {
-               PMD_DRV_LOG(ERR, "Failed to return a credit");
+               PMD_DRV_LOG(ERR, sc, "Failed to return a credit");
                return ECORE_INVAL;
        }
 
@@ -1196,8 +1197,8 @@ static int ecore_validate_vlan_mac_move(struct bnx2x_softc *sc,
         * state.
         */
        if (!src_o->check_move(sc, src_o, dest_o, &elem->cmd_data.vlan_mac.u)) {
-               ECORE_MSG
-                   ("MOVE command is not allowed considering current registry state");
+               ECORE_MSG(sc,
+                         "MOVE command is not allowed considering current registry state");
                return ECORE_INVAL;
        }
 
@@ -1210,21 +1211,21 @@ static int ecore_validate_vlan_mac_move(struct bnx2x_softc *sc,
        /* Check DEL on source */
        query_elem.cmd_data.vlan_mac.cmd = ECORE_VLAN_MAC_DEL;
        if (src_exeq->get(src_exeq, &query_elem)) {
-               PMD_DRV_LOG(ERR,
+               PMD_DRV_LOG(ERR, sc,
                            "There is a pending DEL command on the source queue already");
                return ECORE_INVAL;
        }
 
        /* Check MOVE on source */
        if (src_exeq->get(src_exeq, elem)) {
-               ECORE_MSG("There is a pending MOVE command already");
+               ECORE_MSG(sc, "There is a pending MOVE command already");
                return ECORE_EXISTS;
        }
 
        /* Check ADD on destination */
        query_elem.cmd_data.vlan_mac.cmd = ECORE_VLAN_MAC_ADD;
        if (dest_exeq->get(dest_exeq, &query_elem)) {
-               PMD_DRV_LOG(ERR,
+               PMD_DRV_LOG(ERR, sc,
                            "There is a pending ADD command on the destination queue already");
                return ECORE_INVAL;
        }
@@ -1329,7 +1330,7 @@ static int __ecore_vlan_mac_execute_step(struct bnx2x_softc *sc,
 
        ECORE_SPIN_LOCK_BH(&o->exe_queue.lock);
 
-       ECORE_MSG("vlan_mac_execute_step - trying to take writer lock");
+       ECORE_MSG(sc, "vlan_mac_execute_step - trying to take writer lock");
        rc = __ecore_vlan_mac_h_write_trylock(sc, o);
 
        if (rc != ECORE_SUCCESS) {
@@ -1426,17 +1427,17 @@ static int ecore_optimize_vlan_mac(struct bnx2x_softc *sc,
                                    &pos->cmd_data.vlan_mac.vlan_mac_flags)) {
                        if ((query.cmd_data.vlan_mac.cmd ==
                             ECORE_VLAN_MAC_ADD) && !o->put_credit(o)) {
-                               PMD_DRV_LOG(ERR,
+                               PMD_DRV_LOG(ERR, sc,
                                            "Failed to return the credit for the optimized ADD command");
                                return ECORE_INVAL;
                        } else if (!o->get_credit(o)) { /* VLAN_MAC_DEL */
-                               PMD_DRV_LOG(ERR,
+                               PMD_DRV_LOG(ERR, sc,
                                            "Failed to recover the credit from the optimized DEL command");
                                return ECORE_INVAL;
                        }
                }
 
-               ECORE_MSG("Optimizing %s command",
+               ECORE_MSG(sc, "Optimizing %s command",
                          (elem->cmd_data.vlan_mac.cmd == ECORE_VLAN_MAC_ADD) ?
                          "ADD" : "DEL");
 
@@ -1486,7 +1487,7 @@ static int ecore_vlan_mac_get_registry_elem(struct bnx2x_softc *sc,
                        return ECORE_INVAL;
                }
 
-               ECORE_MSG("Got cam offset %d", reg_elem->cam_offset);
+               ECORE_MSG(sc, "Got cam offset %d", reg_elem->cam_offset);
 
                /* Set a VLAN-MAC data */
                ECORE_MEMCPY(&reg_elem->u, &elem->cmd_data.vlan_mac.u,
@@ -1695,8 +1696,8 @@ int ecore_config_vlan_mac(struct bnx2x_softc *sc,
                rc = ECORE_PENDING;
 
        if (ECORE_TEST_BIT(RAMROD_DRV_CLR_ONLY, ramrod_flags)) {
-               ECORE_MSG
-                   ("RAMROD_DRV_CLR_ONLY requested: clearing a pending bit.");
+               ECORE_MSG(sc,
+                         "RAMROD_DRV_CLR_ONLY requested: clearing a pending bit.");
                raw->clear_pending(raw);
        }
 
@@ -1775,7 +1776,7 @@ static int ecore_vlan_mac_del_all(struct bnx2x_softc *sc,
                    *vlan_mac_flags) {
                        rc = exeq->remove(sc, exeq->owner, exeq_pos);
                        if (rc) {
-                               PMD_DRV_LOG(ERR, "Failed to remove command");
+                               PMD_DRV_LOG(ERR, sc, "Failed to remove command");
                                ECORE_SPIN_UNLOCK_BH(&exeq->lock);
                                return rc;
                        }
@@ -1800,7 +1801,7 @@ static int ecore_vlan_mac_del_all(struct bnx2x_softc *sc,
        ECORE_CLEAR_BIT_NA(RAMROD_EXEC, &p.ramrod_flags);
        ECORE_CLEAR_BIT_NA(RAMROD_CONT, &p.ramrod_flags);
 
-       ECORE_MSG("vlan_mac_del_all -- taking vlan_mac_lock (reader)");
+       ECORE_MSG(sc, "vlan_mac_del_all -- taking vlan_mac_lock (reader)");
        read_lock = ecore_vlan_mac_h_read_lock(sc, o);
        if (read_lock != ECORE_SUCCESS)
                return read_lock;
@@ -1812,7 +1813,7 @@ static int ecore_vlan_mac_del_all(struct bnx2x_softc *sc,
                        ECORE_MEMCPY(&p.user_req.u, &pos->u, sizeof(pos->u));
                        rc = ecore_config_vlan_mac(sc, &p);
                        if (rc < 0) {
-                               PMD_DRV_LOG(ERR,
+                               PMD_DRV_LOG(ERR, sc,
                                            "Failed to add a new DEL command");
                                ecore_vlan_mac_h_read_unlock(sc, o);
                                return rc;
@@ -1820,7 +1821,7 @@ static int ecore_vlan_mac_del_all(struct bnx2x_softc *sc,
                }
        }
 
-       ECORE_MSG("vlan_mac_del_all -- releasing vlan_mac_lock (reader)");
+       ECORE_MSG(sc, "vlan_mac_del_all -- releasing vlan_mac_lock (reader)");
        ecore_vlan_mac_h_read_unlock(sc, o);
 
        p.ramrod_flags = *ramrod_flags;
@@ -2007,7 +2008,7 @@ static int ecore_set_rx_mode_e1x(struct bnx2x_softc *sc,
            mac_filters->unmatched_unicast | mask :
            mac_filters->unmatched_unicast & ~mask;
 
-       ECORE_MSG("drop_ucast 0x%xdrop_mcast 0x%x accp_ucast 0x%x"
+       ECORE_MSG(sc, "drop_ucast 0x%xdrop_mcast 0x%x accp_ucast 0x%x"
                  "accp_mcast 0x%xaccp_bcast 0x%x",
                  mac_filters->ucast_drop_all, mac_filters->mcast_drop_all,
                  mac_filters->ucast_accept_all, mac_filters->mcast_accept_all,
@@ -2153,8 +2154,8 @@ static int ecore_set_rx_mode_e2(struct bnx2x_softc *sc,
         */
        ecore_rx_mode_set_rdata_hdr_e2(p->cid, &data->header, rule_idx);
 
-       ECORE_MSG
-           ("About to configure %d rules, rx_accept_flags 0x%lx, tx_accept_flags 0x%lx",
+           ECORE_MSG
+           (sc, "About to configure %d rules, rx_accept_flags 0x%lx, tx_accept_flags 0x%lx",
             data->header.rule_cnt, p->rx_accept_flags, p->tx_accept_flags);
 
        /* No need for an explicit memory barrier here as long we would
@@ -2207,7 +2208,7 @@ int ecore_config_rx_mode(struct bnx2x_softc *sc,
                                return rc;
                }
        } else {
-               ECORE_MSG("ERROR: config_rx_mode is NULL");
+               ECORE_MSG(sc, "ERROR: config_rx_mode is NULL");
                return -1;
        }
 
@@ -2288,7 +2289,7 @@ static int ecore_mcast_enqueue_cmd(struct bnx2x_softc *sc __rte_unused,
        if (!new_cmd)
                return ECORE_NOMEM;
 
-       ECORE_MSG("About to enqueue a new %d command. macs_list_len=%d",
+       ECORE_MSG(sc, "About to enqueue a new %d command. macs_list_len=%d",
                  cmd, macs_list_len);
 
        ECORE_LIST_INIT(&new_cmd->data.macs_head);
@@ -2324,7 +2325,7 @@ static int ecore_mcast_enqueue_cmd(struct bnx2x_softc *sc __rte_unused,
 
        default:
                ECORE_FREE(sc, new_cmd, total_sz);
-               PMD_DRV_LOG(ERR, "Unknown command: %d", cmd);
+               PMD_DRV_LOG(ERR, sc, "Unknown command: %d", cmd);
                return ECORE_INVAL;
        }
 
@@ -2436,11 +2437,11 @@ static void ecore_mcast_set_one_rule_e2(struct bnx2x_softc *sc __rte_unused,
                break;
 
        default:
-               PMD_DRV_LOG(ERR, "Unknown command: %d", cmd);
+               PMD_DRV_LOG(ERR, sc, "Unknown command: %d", cmd);
                return;
        }
 
-       ECORE_MSG("%s bin %d",
+       ECORE_MSG(sc, "%s bin %d",
                  ((rx_tx_add_flag & ETH_MULTICAST_RULES_CMD_IS_ADD) ?
                   "Setting" : "Clearing"), bin);
 
@@ -2475,7 +2476,7 @@ static int ecore_mcast_handle_restore_cmd_e2(struct bnx2x_softc *sc,
 
                cnt++;
 
-               ECORE_MSG("About to configure a bin %d", cur_bin);
+               ECORE_MSG(sc, "About to configure a bin %d", cur_bin);
 
                /* Break if we reached the maximum number
                 * of rules.
@@ -2507,8 +2508,8 @@ static void ecore_mcast_hdl_pending_add_e2(struct bnx2x_softc *sc,
 
                cnt++;
 
-               ECORE_MSG
-                   ("About to configure %02x:%02x:%02x:%02x:%02x:%02x mcast MAC",
+                   ECORE_MSG
+                   (sc, "About to configure %02x:%02x:%02x:%02x:%02x:%02x mcast MAC",
                     pmac_pos->mac[0], pmac_pos->mac[1], pmac_pos->mac[2],
                     pmac_pos->mac[3], pmac_pos->mac[4], pmac_pos->mac[5]);
 
@@ -2543,7 +2544,7 @@ static void ecore_mcast_hdl_pending_del_e2(struct bnx2x_softc *sc,
 
                cmd_pos->data.macs_num--;
 
-               ECORE_MSG("Deleting MAC. %d left,cnt is %d",
+               ECORE_MSG(sc, "Deleting MAC. %d left,cnt is %d",
                          cmd_pos->data.macs_num, cnt);
 
                /* Break if we reached the maximum
@@ -2602,7 +2603,8 @@ static int ecore_mcast_handle_pending_cmds_e2(struct bnx2x_softc *sc, struct
                        break;
 
                default:
-                       PMD_DRV_LOG(ERR, "Unknown command: %d", cmd_pos->type);
+                       PMD_DRV_LOG(ERR, sc,
+                                   "Unknown command: %d", cmd_pos->type);
                        return ECORE_INVAL;
                }
 
@@ -2639,8 +2641,8 @@ static void ecore_mcast_hdl_add(struct bnx2x_softc *sc,
 
                cnt++;
 
-               ECORE_MSG
-                   ("About to configure %02x:%02x:%02x:%02x:%02x:%02x mcast MAC",
+                   ECORE_MSG
+                   (sc, "About to configure %02x:%02x:%02x:%02x:%02x:%02x mcast MAC",
                     mlist_pos->mac[0], mlist_pos->mac[1], mlist_pos->mac[2],
                     mlist_pos->mac[3], mlist_pos->mac[4], mlist_pos->mac[5]);
        }
@@ -2660,7 +2662,8 @@ static void ecore_mcast_hdl_del(struct bnx2x_softc *sc,
 
                cnt++;
 
-               ECORE_MSG("Deleting MAC. %d left", p->mcast_list_len - i - 1);
+               ECORE_MSG(sc,
+                         "Deleting MAC. %d left", p->mcast_list_len - i - 1);
        }
 
        *line_idx = cnt;
@@ -2686,7 +2689,7 @@ static int ecore_mcast_handle_current_cmd(struct bnx2x_softc *sc, struct
        struct ecore_mcast_obj *o = p->mcast_obj;
        int cnt = start_cnt;
 
-       ECORE_MSG("p->mcast_list_len=%d", p->mcast_list_len);
+       ECORE_MSG(sc, "p->mcast_list_len=%d", p->mcast_list_len);
 
        switch (cmd) {
        case ECORE_MCAST_CMD_ADD:
@@ -2702,7 +2705,7 @@ static int ecore_mcast_handle_current_cmd(struct bnx2x_softc *sc, struct
                break;
 
        default:
-               PMD_DRV_LOG(ERR, "Unknown command: %d", cmd);
+               PMD_DRV_LOG(ERR, sc, "Unknown command: %d", cmd);
                return ECORE_INVAL;
        }
 
@@ -2747,7 +2750,7 @@ static int ecore_mcast_validate_e2(__rte_unused struct bnx2x_softc *sc,
                break;
 
        default:
-               PMD_DRV_LOG(ERR, "Unknown command: %d", cmd);
+               PMD_DRV_LOG(ERR, sc, "Unknown command: %d", cmd);
                return ECORE_INVAL;
        }
 
@@ -2933,8 +2936,8 @@ static void ecore_mcast_hdl_add_e1h(struct bnx2x_softc *sc __rte_unused,
                bit = ecore_mcast_bin_from_mac(mlist_pos->mac);
                ECORE_57711_SET_MC_FILTER(mc_filter, bit);
 
-               ECORE_MSG
-                   ("About to configure %02x:%02x:%02x:%02x:%02x:%02x mcast MAC, bin %d",
+                   ECORE_MSG
+                   (sc, "About to configure %02x:%02x:%02x:%02x:%02x:%02x mcast MAC, bin %d",
                     mlist_pos->mac[0], mlist_pos->mac[1], mlist_pos->mac[2],
                     mlist_pos->mac[3], mlist_pos->mac[4], mlist_pos->mac[5],
                     bit);
@@ -2954,7 +2957,7 @@ static void ecore_mcast_hdl_restore_e1h(struct bnx2x_softc *sc
        for (bit = ecore_mcast_get_next_bin(o, 0);
             bit >= 0; bit = ecore_mcast_get_next_bin(o, bit + 1)) {
                ECORE_57711_SET_MC_FILTER(mc_filter, bit);
-               ECORE_MSG("About to set bin %d", bit);
+               ECORE_MSG(sc, "About to set bin %d", bit);
        }
 }
 
@@ -2985,7 +2988,7 @@ static int ecore_mcast_setup_e1h(struct bnx2x_softc *sc,
                        break;
 
                case ECORE_MCAST_CMD_DEL:
-                       ECORE_MSG("Invalidating multicast MACs configuration");
+                       ECORE_MSG(sc, "Invalidating multicast MACs configuration");
 
                        /* clear the registry */
                        ECORE_MEMSET(o->registry.aprox_match.vec, 0,
@@ -2997,7 +3000,7 @@ static int ecore_mcast_setup_e1h(struct bnx2x_softc *sc,
                        break;
 
                default:
-                       PMD_DRV_LOG(ERR, "Unknown command: %d", cmd);
+                       PMD_DRV_LOG(ERR, sc, "Unknown command: %d", cmd);
                        return ECORE_INVAL;
                }
 
@@ -3048,8 +3051,8 @@ int ecore_config_mcast(struct bnx2x_softc *sc,
        if ((!p->mcast_list_len) && (!o->check_sched(o)))
                return ECORE_SUCCESS;
 
-       ECORE_MSG
-           ("o->total_pending_num=%d p->mcast_list_len=%d o->max_cmd_len=%d",
+           ECORE_MSG
+           (sc, "o->total_pending_num=%d p->mcast_list_len=%d o->max_cmd_len=%d",
             o->total_pending_num, p->mcast_list_len, o->max_cmd_len);
 
        /* Enqueue the current command to the pending list if we can't complete
@@ -3478,7 +3481,7 @@ static int ecore_setup_rss(struct bnx2x_softc *sc,
 
        ECORE_MEMSET(data, 0, sizeof(*data));
 
-       ECORE_MSG("Configuring RSS");
+       ECORE_MSG(sc, "Configuring RSS");
 
        /* Set an echo field */
        data->echo = ECORE_CPU_TO_LE32((r->cid & ECORE_SWCID_MASK) |
@@ -3492,7 +3495,7 @@ static int ecore_setup_rss(struct bnx2x_softc *sc,
 
        data->rss_mode = rss_mode;
 
-       ECORE_MSG("rss_mode=%d", rss_mode);
+       ECORE_MSG(sc, "rss_mode=%d", rss_mode);
 
        /* RSS capabilities */
        if (ECORE_TEST_BIT(ECORE_RSS_IPV4, &p->rss_flags))
@@ -3532,7 +3535,7 @@ static int ecore_setup_rss(struct bnx2x_softc *sc,
        /* RSS engine ID */
        data->rss_engine_id = o->engine_id;
 
-       ECORE_MSG("rss_engine_id=%d", data->rss_engine_id);
+       ECORE_MSG(sc, "rss_engine_id=%d", data->rss_engine_id);
 
        /* Indirection table */
        ECORE_MEMCPY(data->indirection_table, p->ind_table,
@@ -3627,15 +3630,15 @@ int ecore_queue_state_change(struct bnx2x_softc *sc,
        /* Check that the requested transition is legal */
        rc = o->check_transition(sc, o, params);
        if (rc) {
-               PMD_DRV_LOG(ERR, "check transition returned an error. rc %d",
+               PMD_DRV_LOG(ERR, sc, "check transition returned an error. rc %d",
                            rc);
                return ECORE_INVAL;
        }
 
        /* Set "pending" bit */
-       ECORE_MSG("pending bit was=%lx", o->pending);
+       ECORE_MSG(sc, "pending bit was=%lx", o->pending);
        pending_bit = o->set_pending(o, params);
-       ECORE_MSG("pending bit now=%lx", o->pending);
+       ECORE_MSG(sc, "pending bit now=%lx", o->pending);
 
        /* Don't send a command if only driver cleanup was requested */
        if (ECORE_TEST_BIT(RAMROD_DRV_CLR_ONLY, &params->ramrod_flags))
@@ -3702,7 +3705,7 @@ static int ecore_queue_comp_cmd(struct bnx2x_softc *sc __rte_unused,
        unsigned long cur_pending = o->pending;
 
        if (!ECORE_TEST_AND_CLEAR_BIT(cmd, &cur_pending)) {
-               PMD_DRV_LOG(ERR,
+               PMD_DRV_LOG(ERR, sc,
                            "Bad MC reply %d for queue %d in state %d pending 0x%lx, next_state %d",
                            cmd, o->cids[ECORE_PRIMARY_CID_INDEX], o->state,
                            cur_pending, o->next_state);
@@ -3713,15 +3716,15 @@ static int ecore_queue_comp_cmd(struct bnx2x_softc *sc __rte_unused,
                /* >= because tx only must always be smaller than cos since the
                 * primary connection supports COS 0
                 */
-               PMD_DRV_LOG(ERR,
+               PMD_DRV_LOG(ERR, sc,
                            "illegal value for next tx_only: %d. max cos was %d",
                            o->next_tx_only, o->max_cos);
 
-       ECORE_MSG("Completing command %d for queue %d, setting state to %d",
+       ECORE_MSG(sc, "Completing command %d for queue %d, setting state to %d",
                  cmd, o->cids[ECORE_PRIMARY_CID_INDEX], o->next_state);
 
        if (o->next_tx_only)    /* print num tx-only if any exist */
-               ECORE_MSG("primary cid %d: num tx-only cons %d",
+               ECORE_MSG(sc, "primary cid %d: num tx-only cons %d",
                          o->cids[ECORE_PRIMARY_CID_INDEX], o->next_tx_only);
 
        o->state = o->next_state;
@@ -3782,7 +3785,7 @@ static void ecore_q_fill_init_general_data(struct bnx2x_softc *sc __rte_unused,
            ECORE_TEST_BIT(ECORE_Q_FLG_FCOE, flags) ?
            LLFC_TRAFFIC_TYPE_FCOE : LLFC_TRAFFIC_TYPE_NW;
 
-       ECORE_MSG("flags: active %d, cos %d, stats en %d",
+       ECORE_MSG(sc, "flags: active %d, cos %d, stats en %d",
                  gen_data->activate_flg, gen_data->cos,
                  gen_data->statistics_en_flg);
 }
@@ -3923,7 +3926,7 @@ static void ecore_q_fill_setup_tx_only(struct bnx2x_softc *sc, struct ecore_queu
        ecore_q_fill_init_tx_data(&cmd_params->params.tx_only.txq_params,
                                  &data->tx, &cmd_params->params.tx_only.flags);
 
-       ECORE_MSG("cid %d, tx bd page lo %x hi %x",
+       ECORE_MSG(sc, "cid %d, tx bd page lo %x hi %x",
                  cmd_params->q_obj->cids[0],
                  data->tx.tx_bd_page_base.lo, data->tx.tx_bd_page_base.hi);
 }
@@ -3973,9 +3976,9 @@ static int ecore_q_init(struct bnx2x_softc *sc,
 
        /* Set CDU context validation values */
        for (cos = 0; cos < o->max_cos; cos++) {
-               ECORE_MSG("setting context validation. cid %d, cos %d",
+               ECORE_MSG(sc, "setting context validation. cid %d, cos %d",
                          o->cids[cos], cos);
-               ECORE_MSG("context pointer %p", init->cxts[cos]);
+               ECORE_MSG(sc, "context pointer %p", init->cxts[cos]);
                ECORE_SET_CTX_VALIDATION(sc, init->cxts[cos], o->cids[cos]);
        }
 
@@ -4059,15 +4062,15 @@ static int ecore_q_send_setup_tx_only(struct bnx2x_softc *sc, struct ecore_queue
 
        if (ECORE_TEST_BIT(ECORE_Q_TYPE_FWD, &o->type))
                ramrod = RAMROD_CMD_ID_ETH_FORWARD_SETUP;
-       ECORE_MSG("sending forward tx-only ramrod");
+       ECORE_MSG(sc, "sending forward tx-only ramrod");
 
        if (cid_index >= o->max_cos) {
-               PMD_DRV_LOG(ERR, "queue[%d]: cid_index (%d) is out of range",
+               PMD_DRV_LOG(ERR, sc, "queue[%d]: cid_index (%d) is out of range",
                            o->cl_id, cid_index);
                return ECORE_INVAL;
        }
 
-       ECORE_MSG("parameters received: cos: %d sp-id: %d",
+       ECORE_MSG(sc, "parameters received: cos: %d sp-id: %d",
                  tx_only_params->gen_params.cos,
                  tx_only_params->gen_params.spcl_id);
 
@@ -4077,8 +4080,8 @@ static int ecore_q_send_setup_tx_only(struct bnx2x_softc *sc, struct ecore_queue
        /* Fill the ramrod data */
        ecore_q_fill_setup_tx_only(sc, params, rdata);
 
-       ECORE_MSG
-           ("sending tx-only ramrod: cid %d, client-id %d, sp-client id %d, cos %d",
+           ECORE_MSG
+           (sc, "sending tx-only ramrod: cid %d, client-id %d, sp-client id %d, cos %d",
             o->cids[cid_index], rdata->general.client_id,
             rdata->general.sp_client_id, rdata->general.cos);
 
@@ -4173,7 +4176,7 @@ static int ecore_q_send_update(struct bnx2x_softc *sc,
        uint8_t cid_index = update_params->cid_index;
 
        if (cid_index >= o->max_cos) {
-               PMD_DRV_LOG(ERR, "queue[%d]: cid_index (%d) is out of range",
+               PMD_DRV_LOG(ERR, sc, "queue[%d]: cid_index (%d) is out of range",
                            o->cl_id, cid_index);
                return ECORE_INVAL;
        }
@@ -4267,7 +4270,7 @@ static int ecore_q_send_cfc_del(struct bnx2x_softc *sc,
        uint8_t cid_idx = params->params.cfc_del.cid_index;
 
        if (cid_idx >= o->max_cos) {
-               PMD_DRV_LOG(ERR, "queue[%d]: cid_index (%d) is out of range",
+               PMD_DRV_LOG(ERR, sc, "queue[%d]: cid_index (%d) is out of range",
                            o->cl_id, cid_idx);
                return ECORE_INVAL;
        }
@@ -4283,7 +4286,7 @@ static int ecore_q_send_terminate(struct bnx2x_softc *sc, struct ecore_queue_sta
        uint8_t cid_index = params->params.terminate.cid_index;
 
        if (cid_index >= o->max_cos) {
-               PMD_DRV_LOG(ERR, "queue[%d]: cid_index (%d) is out of range",
+               PMD_DRV_LOG(ERR, sc, "queue[%d]: cid_index (%d) is out of range",
                            o->cl_id, cid_index);
                return ECORE_INVAL;
        }
@@ -4327,7 +4330,7 @@ static int ecore_queue_send_cmd_cmn(struct bnx2x_softc *sc, struct ecore_queue_s
        case ECORE_Q_CMD_EMPTY:
                return ecore_q_send_empty(sc, params);
        default:
-               PMD_DRV_LOG(ERR, "Unknown command: %d", params->cmd);
+               PMD_DRV_LOG(ERR, sc, "Unknown command: %d", params->cmd);
                return ECORE_INVAL;
        }
 }
@@ -4350,7 +4353,7 @@ static int ecore_queue_send_cmd_e1x(struct bnx2x_softc *sc,
        case ECORE_Q_CMD_EMPTY:
                return ecore_queue_send_cmd_cmn(sc, params);
        default:
-               PMD_DRV_LOG(ERR, "Unknown command: %d", params->cmd);
+               PMD_DRV_LOG(ERR, sc, "Unknown command: %d", params->cmd);
                return ECORE_INVAL;
        }
 }
@@ -4373,7 +4376,7 @@ static int ecore_queue_send_cmd_e2(struct bnx2x_softc *sc,
        case ECORE_Q_CMD_EMPTY:
                return ecore_queue_send_cmd_cmn(sc, params);
        default:
-               PMD_DRV_LOG(ERR, "Unknown command: %d", params->cmd);
+               PMD_DRV_LOG(ERR, sc, "Unknown command: %d", params->cmd);
                return ECORE_INVAL;
        }
 }
@@ -4416,7 +4419,7 @@ static int ecore_queue_chk_transition(struct bnx2x_softc *sc __rte_unused,
         * the previous one.
         */
        if (o->pending) {
-               PMD_DRV_LOG(ERR, "Blocking transition since pending was %lx",
+               PMD_DRV_LOG(ERR, sc, "Blocking transition since pending was %lx",
                            o->pending);
                return ECORE_BUSY;
        }
@@ -4543,19 +4546,19 @@ static int ecore_queue_chk_transition(struct bnx2x_softc *sc __rte_unused,
 
                break;
        default:
-               PMD_DRV_LOG(ERR, "Illegal state: %d", state);
+               PMD_DRV_LOG(ERR, sc, "Illegal state: %d", state);
        }
 
        /* Transition is assured */
        if (next_state != ECORE_Q_STATE_MAX) {
-               ECORE_MSG("Good state transition: %d(%d)->%d",
+               ECORE_MSG(sc, "Good state transition: %d(%d)->%d",
                          state, cmd, next_state);
                o->next_state = next_state;
                o->next_tx_only = next_tx_only;
                return ECORE_SUCCESS;
        }
 
-       ECORE_MSG("Bad state transition request: %d %d", state, cmd);
+       ECORE_MSG(sc, "Bad state transition request: %d %d", state, cmd);
 
        return ECORE_INVAL;
 }
@@ -4606,18 +4609,18 @@ static int ecore_queue_chk_fwd_transition(struct bnx2x_softc *sc __rte_unused,
 
                break;
        default:
-               PMD_DRV_LOG(ERR, "Illegal state: %d", state);
+               PMD_DRV_LOG(ERR, sc, "Illegal state: %d", state);
        }
 
        /* Transition is assured */
        if (next_state != ECORE_Q_STATE_MAX) {
-               ECORE_MSG("Good state transition: %d(%d)->%d",
+               ECORE_MSG(sc, "Good state transition: %d(%d)->%d",
                          state, cmd, next_state);
                o->next_state = next_state;
                return ECORE_SUCCESS;
        }
 
-       ECORE_MSG("Bad state transition request: %d %d", state, cmd);
+       ECORE_MSG(sc, "Bad state transition request: %d %d", state, cmd);
        return ECORE_INVAL;
 }
 
@@ -4697,14 +4700,14 @@ ecore_func_state_change_comp(struct bnx2x_softc *sc __rte_unused,
        unsigned long cur_pending = o->pending;
 
        if (!ECORE_TEST_AND_CLEAR_BIT(cmd, &cur_pending)) {
-               PMD_DRV_LOG(ERR,
+               PMD_DRV_LOG(ERR, sc,
                            "Bad MC reply %d for func %d in state %d pending 0x%lx, next_state %d",
                            cmd, ECORE_FUNC_ID(sc), o->state, cur_pending,
                            o->next_state);
                return ECORE_INVAL;
        }
 
-       ECORE_MSG("Completing command %d for func %d, setting state to %d",
+       ECORE_MSG(sc, "Completing command %d for func %d, setting state to %d",
                  cmd, ECORE_FUNC_ID(sc), o->next_state);
 
        o->state = o->next_state;
@@ -4827,18 +4830,19 @@ static int ecore_func_chk_transition(struct bnx2x_softc *sc __rte_unused,
 
                break;
        default:
-               PMD_DRV_LOG(ERR, "Unknown state: %d", state);
+               PMD_DRV_LOG(ERR, sc, "Unknown state: %d", state);
        }
 
        /* Transition is assured */
        if (next_state != ECORE_F_STATE_MAX) {
-               ECORE_MSG("Good function state transition: %d(%d)->%d",
+               ECORE_MSG(sc, "Good function state transition: %d(%d)->%d",
                          state, cmd, next_state);
                o->next_state = next_state;
                return ECORE_SUCCESS;
        }
 
-       ECORE_MSG("Bad function state transition request: %d %d", state, cmd);
+       ECORE_MSG(sc,
+                 "Bad function state transition request: %d %d", state, cmd);
 
        return ECORE_INVAL;
 }
@@ -4928,13 +4932,13 @@ static int ecore_func_hw_init(struct bnx2x_softc *sc,
        const struct ecore_func_sp_drv_ops *drv = o->drv;
        int rc = 0;
 
-       ECORE_MSG("function %d  load_code %x",
+       ECORE_MSG(sc, "function %d  load_code %x",
                  ECORE_ABS_FUNC_ID(sc), load_code);
 
        /* Prepare FW */
        rc = drv->init_fw(sc);
        if (rc) {
-               PMD_DRV_LOG(ERR, "Error loading firmware");
+               PMD_DRV_LOG(ERR, sc, "Error loading firmware");
                goto init_err;
        }
 
@@ -4965,7 +4969,7 @@ static int ecore_func_hw_init(struct bnx2x_softc *sc,
 
                break;
        default:
-               PMD_DRV_LOG(ERR, "Unknown load_code (0x%x) from MCP",
+               PMD_DRV_LOG(ERR, sc, "Unknown load_code (0x%x) from MCP",
                            load_code);
                rc = ECORE_INVAL;
        }
@@ -5041,7 +5045,7 @@ static int ecore_func_hw_reset(struct bnx2x_softc *sc,
        struct ecore_func_sp_obj *o = params->f_obj;
        const struct ecore_func_sp_drv_ops *drv = o->drv;
 
-       ECORE_MSG("function %d  reset_phase %x", ECORE_ABS_FUNC_ID(sc),
+       ECORE_MSG(sc, "function %d  reset_phase %x", ECORE_ABS_FUNC_ID(sc),
                  reset_phase);
 
        switch (reset_phase) {
@@ -5055,7 +5059,7 @@ static int ecore_func_hw_reset(struct bnx2x_softc *sc,
                ecore_func_reset_func(sc, drv);
                break;
        default:
-               PMD_DRV_LOG(ERR, "Unknown reset_phase (0x%x) from MCP",
+               PMD_DRV_LOG(ERR, sc, "Unknown reset_phase (0x%x) from MCP",
                            reset_phase);
                break;
        }
@@ -5146,7 +5150,7 @@ static int ecore_func_send_afex_update(struct bnx2x_softc *sc, struct ecore_func
         *  read and we will have to put a full memory barrier there
         *  (inside ecore_sp_post()).
         */
-       ECORE_MSG("afex: sending func_update vif_id 0x%x dvlan 0x%x prio 0x%x",
+       ECORE_MSG(sc, "afex: sending func_update vif_id 0x%x dvlan 0x%x prio 0x%x",
                  rdata->vif_id,
                  rdata->afex_default_vlan, rdata->allowed_priorities);
 
@@ -5184,8 +5188,8 @@ inline int ecore_func_send_afex_viflists(struct bnx2x_softc *sc,
         *  (inside ecore_sp_post()).
         */
 
-       ECORE_MSG
-           ("afex: ramrod lists, cmd 0x%x index 0x%x func_bit_map 0x%x func_to_clr 0x%x",
+           ECORE_MSG
+           (sc, "afex: ramrod lists, cmd 0x%x index 0x%x func_bit_map 0x%x func_to_clr 0x%x",
             rdata->afex_vif_list_command, rdata->vif_list_index,
             rdata->func_bit_map, rdata->func_to_clear);
 
@@ -5256,7 +5260,7 @@ static int ecore_func_send_cmd(struct bnx2x_softc *sc,
        case ECORE_F_CMD_SWITCH_UPDATE:
                return ecore_func_send_switch_update(sc, params);
        default:
-               PMD_DRV_LOG(ERR, "Unknown command: %d", params->cmd);
+               PMD_DRV_LOG(ERR, sc, "Unknown command: %d", params->cmd);
                return ECORE_INVAL;
        }
 }
@@ -5317,7 +5321,7 @@ int ecore_func_state_change(struct bnx2x_softc *sc,
                }
                if (rc == ECORE_BUSY) {
                        ECORE_MUTEX_UNLOCK(&o->one_pending_mutex);
-                       PMD_DRV_LOG(ERR,
+                       PMD_DRV_LOG(ERR, sc,
                                    "timeout waiting for previous ramrod completion");
                        return rc;
                }
index 6b65a49..f295bf5 100644 (file)
@@ -215,8 +215,8 @@ ECORE_CRC32_LE(uint32_t seed, uint8_t *mac, uint32_t len)
     } while (0)
 
 
-#define ECORE_MSG(m, ...) \
-       PMD_DRV_LOG(DEBUG, m, ##__VA_ARGS__)
+#define ECORE_MSG(sc, m, ...) \
+       PMD_DRV_LOG(DEBUG, sc, m, ##__VA_ARGS__)
 
 typedef struct _ecore_list_entry_t
 {
index b63fd23..1f94476 100644 (file)
@@ -942,7 +942,7 @@ static int elink_check_lfa(struct elink_params *params)
         * to verify DCC bit is cleared in any case!
         */
        if (additional_config & NO_LFA_DUE_TO_DCC_MASK) {
-               PMD_DRV_LOG(DEBUG, "No LFA due to DCC flap after clp exit");
+               PMD_DRV_LOG(DEBUG, sc, "No LFA due to DCC flap after clp exit");
                REG_WR(sc, params->lfa_base +
                       offsetof(struct shmem_lfa, additional_config),
                       additional_config & ~NO_LFA_DUE_TO_DCC_MASK);
@@ -983,7 +983,7 @@ static int elink_check_lfa(struct elink_params *params)
                           offsetof(struct shmem_lfa, req_duplex));
        req_val = params->req_duplex[0] | (params->req_duplex[1] << 16);
        if ((saved_val & lfa_mask) != (req_val & lfa_mask)) {
-               PMD_DRV_LOG(INFO, "Duplex mismatch %x vs. %x",
+               PMD_DRV_LOG(INFO, sc, "Duplex mismatch %x vs. %x",
                            (saved_val & lfa_mask), (req_val & lfa_mask));
                return LFA_DUPLEX_MISMATCH;
        }
@@ -992,7 +992,7 @@ static int elink_check_lfa(struct elink_params *params)
                           offsetof(struct shmem_lfa, req_flow_ctrl));
        req_val = params->req_flow_ctrl[0] | (params->req_flow_ctrl[1] << 16);
        if ((saved_val & lfa_mask) != (req_val & lfa_mask)) {
-               PMD_DRV_LOG(DEBUG, "Flow control mismatch %x vs. %x",
+               PMD_DRV_LOG(DEBUG, sc, "Flow control mismatch %x vs. %x",
                            (saved_val & lfa_mask), (req_val & lfa_mask));
                return LFA_FLOW_CTRL_MISMATCH;
        }
@@ -1001,7 +1001,7 @@ static int elink_check_lfa(struct elink_params *params)
                           offsetof(struct shmem_lfa, req_line_speed));
        req_val = params->req_line_speed[0] | (params->req_line_speed[1] << 16);
        if ((saved_val & lfa_mask) != (req_val & lfa_mask)) {
-               PMD_DRV_LOG(DEBUG, "Link speed mismatch %x vs. %x",
+               PMD_DRV_LOG(DEBUG, sc, "Link speed mismatch %x vs. %x",
                            (saved_val & lfa_mask), (req_val & lfa_mask));
                return LFA_LINK_SPEED_MISMATCH;
        }
@@ -1012,7 +1012,7 @@ static int elink_check_lfa(struct elink_params *params)
                                                     speed_cap_mask[cfg_idx]));
 
                if (cur_speed_cap_mask != params->speed_cap_mask[cfg_idx]) {
-                       PMD_DRV_LOG(DEBUG, "Speed Cap mismatch %x vs. %x",
+                       PMD_DRV_LOG(DEBUG, sc, "Speed Cap mismatch %x vs. %x",
                                    cur_speed_cap_mask,
                                    params->speed_cap_mask[cfg_idx]);
                        return LFA_SPEED_CAP_MISMATCH;
@@ -1025,7 +1025,7 @@ static int elink_check_lfa(struct elink_params *params)
            REQ_FC_AUTO_ADV_MASK;
 
        if ((uint16_t) cur_req_fc_auto_adv != params->req_fc_auto_adv) {
-               PMD_DRV_LOG(DEBUG, "Flow Ctrl AN mismatch %x vs. %x",
+               PMD_DRV_LOG(DEBUG, sc, "Flow Ctrl AN mismatch %x vs. %x",
                            cur_req_fc_auto_adv, params->req_fc_auto_adv);
                return LFA_FLOW_CTRL_MISMATCH;
        }
@@ -1038,7 +1038,8 @@ static int elink_check_lfa(struct elink_params *params)
             (params->eee_mode & ELINK_EEE_MODE_ENABLE_LPI)) ||
            ((eee_status & SHMEM_EEE_REQUESTED_BIT) ^
             (params->eee_mode & ELINK_EEE_MODE_ADV_LPI))) {
-               PMD_DRV_LOG(DEBUG, "EEE mismatch %x vs. %x", params->eee_mode,
+               PMD_DRV_LOG(DEBUG, sc,
+                           "EEE mismatch %x vs. %x", params->eee_mode,
                            eee_status);
                return LFA_EEE_MISMATCH;
        }
@@ -1057,7 +1058,7 @@ static void elink_get_epio(struct bnx2x_softc *sc, uint32_t epio_pin,
        *en = 0;
        /* Sanity check */
        if (epio_pin > 31) {
-               PMD_DRV_LOG(DEBUG, "Invalid EPIO pin %d to get", epio_pin);
+               PMD_DRV_LOG(DEBUG, sc, "Invalid EPIO pin %d to get", epio_pin);
                return;
        }
 
@@ -1075,10 +1076,10 @@ static void elink_set_epio(struct bnx2x_softc *sc, uint32_t epio_pin, uint32_t e
 
        /* Sanity check */
        if (epio_pin > 31) {
-               PMD_DRV_LOG(DEBUG, "Invalid EPIO pin %d to set", epio_pin);
+               PMD_DRV_LOG(DEBUG, sc, "Invalid EPIO pin %d to set", epio_pin);
                return;
        }
-       PMD_DRV_LOG(DEBUG, "Setting EPIO pin %d to %d", epio_pin, en);
+       PMD_DRV_LOG(DEBUG, sc, "Setting EPIO pin %d to %d", epio_pin, en);
        epio_mask = 1 << epio_pin;
        /* Set this EPIO to output */
        gp_output = REG_RD(sc, MCP_REG_MCPR_GP_OUTPUTS);
@@ -1209,7 +1210,7 @@ static void elink_set_mdio_clk(struct bnx2x_softc *sc, uint32_t emac_base)
        new_mode |= clc_cnt;
        new_mode |= (EMAC_MDIO_MODE_CLAUSE_45);
 
-       PMD_DRV_LOG(DEBUG, "Changing emac_mode from 0x%x to 0x%x",
+       PMD_DRV_LOG(DEBUG, sc, "Changing emac_mode from 0x%x to 0x%x",
                    cur_mode, new_mode);
        REG_WR(sc, emac_base + EMAC_REG_EMAC_MDIO_MODE, new_mode);
        DELAY(40);
@@ -1262,9 +1263,9 @@ static void elink_emac_init(struct elink_params *params)
        timeout = 200;
        do {
                val = REG_RD(sc, emac_base + EMAC_REG_EMAC_MODE);
-               PMD_DRV_LOG(DEBUG, "EMAC reset reg is %u", val);
+               PMD_DRV_LOG(DEBUG, sc, "EMAC reset reg is %u", val);
                if (!timeout) {
-                       PMD_DRV_LOG(DEBUG, "EMAC timeout!");
+                       PMD_DRV_LOG(DEBUG, sc, "EMAC timeout!");
                        return;
                }
                timeout--;
@@ -1327,7 +1328,7 @@ static void elink_umac_enable(struct elink_params *params,
        REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET,
               (MISC_REGISTERS_RESET_REG_2_UMAC0 << params->port));
 
-       PMD_DRV_LOG(DEBUG, "enabling UMAC");
+       PMD_DRV_LOG(DEBUG, sc, "enabling UMAC");
 
        /* This register opens the gate for the UMAC despite its name */
        REG_WR(sc, NIG_REG_EGRESS_EMAC0_PORT + params->port * 4, 1);
@@ -1350,7 +1351,7 @@ static void elink_umac_enable(struct elink_params *params,
                val |= (3 << 2);
                break;
        default:
-               PMD_DRV_LOG(DEBUG, "Invalid speed for UMAC %d",
+               PMD_DRV_LOG(DEBUG, sc, "Invalid speed for UMAC %d",
                            vars->line_speed);
                break;
        }
@@ -1368,7 +1369,7 @@ static void elink_umac_enable(struct elink_params *params,
 
        /* Configure UMAC for EEE */
        if (vars->eee_status & SHMEM_EEE_ADV_STATUS_MASK) {
-               PMD_DRV_LOG(DEBUG, "configured UMAC for EEE");
+               PMD_DRV_LOG(DEBUG, sc, "configured UMAC for EEE");
                REG_WR(sc, umac_base + UMAC_REG_UMAC_EEE_CTRL,
                       UMAC_UMAC_EEE_CTRL_REG_EEE_EN);
                REG_WR(sc, umac_base + UMAC_REG_EEE_WAKE_TIMER, 0x11);
@@ -1426,7 +1427,7 @@ static void elink_xmac_init(struct elink_params *params, uint32_t max_speed)
            is_port4mode &&
            (REG_RD(sc, MISC_REG_RESET_REG_2) &
             MISC_REGISTERS_RESET_REG_2_XMAC)) {
-               PMD_DRV_LOG(DEBUG, "XMAC already out of reset in 4-port mode");
+               PMD_DRV_LOG(DEBUG, sc, "XMAC already out of reset in 4-port mode");
                return;
        }
 
@@ -1438,7 +1439,7 @@ static void elink_xmac_init(struct elink_params *params, uint32_t max_speed)
        REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET,
               MISC_REGISTERS_RESET_REG_2_XMAC);
        if (is_port4mode) {
-               PMD_DRV_LOG(DEBUG, "Init XMAC to 2 ports x 10G per path");
+               PMD_DRV_LOG(DEBUG, sc, "Init XMAC to 2 ports x 10G per path");
 
                /* Set the number of ports on the system side to up to 2 */
                REG_WR(sc, MISC_REG_XMAC_CORE_PORT_MODE, 1);
@@ -1449,12 +1450,12 @@ static void elink_xmac_init(struct elink_params *params, uint32_t max_speed)
                /* Set the number of ports on the system side to 1 */
                REG_WR(sc, MISC_REG_XMAC_CORE_PORT_MODE, 0);
                if (max_speed == ELINK_SPEED_10000) {
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                                    "Init XMAC to 10G x 1 port per path");
                        /* Set the number of ports on the Warp Core to 10G */
                        REG_WR(sc, MISC_REG_XMAC_PHY_PORT_MODE, 3);
                } else {
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                                    "Init XMAC to 20G x 2 ports per path");
                        /* Set the number of ports on the Warp Core to 20G */
                        REG_WR(sc, MISC_REG_XMAC_PHY_PORT_MODE, 1);
@@ -1487,7 +1488,7 @@ static void elink_set_xmac_rxtx(struct elink_params *params, uint8_t en)
                       (pfc_ctrl & ~(1 << 1)));
                REG_WR(sc, xmac_base + XMAC_REG_PFC_CTRL_HI,
                       (pfc_ctrl | (1 << 1)));
-               PMD_DRV_LOG(DEBUG, "Disable XMAC on port %x", port);
+               PMD_DRV_LOG(DEBUG, sc, "Disable XMAC on port %x", port);
                val = REG_RD(sc, xmac_base + XMAC_REG_CTRL);
                if (en)
                        val |= (XMAC_CTRL_REG_TX_EN | XMAC_CTRL_REG_RX_EN);
@@ -1502,7 +1503,7 @@ static elink_status_t elink_xmac_enable(struct elink_params *params,
 {
        uint32_t val, xmac_base;
        struct bnx2x_softc *sc = params->sc;
-       PMD_DRV_LOG(DEBUG, "enabling XMAC");
+       PMD_DRV_LOG(DEBUG, sc, "enabling XMAC");
 
        xmac_base = (params->port) ? GRCBASE_XMAC1 : GRCBASE_XMAC0;
 
@@ -1539,7 +1540,7 @@ static elink_status_t elink_xmac_enable(struct elink_params *params,
        elink_update_pfc_xmac(params, vars);
 
        if (vars->eee_status & SHMEM_EEE_ADV_STATUS_MASK) {
-               PMD_DRV_LOG(DEBUG, "Setting XMAC for EEE");
+               PMD_DRV_LOG(DEBUG, sc, "Setting XMAC for EEE");
                REG_WR(sc, xmac_base + XMAC_REG_EEE_TIMERS_HI, 0x1380008);
                REG_WR(sc, xmac_base + XMAC_REG_EEE_CTRL, 0x1);
        } else {
@@ -1575,7 +1576,7 @@ static elink_status_t elink_emac_enable(struct elink_params *params,
        uint32_t emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
        uint32_t val;
 
-       PMD_DRV_LOG(DEBUG, "enabling EMAC");
+       PMD_DRV_LOG(DEBUG, sc, "enabling EMAC");
 
        /* Disable BMAC */
        REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
@@ -1589,14 +1590,14 @@ static elink_status_t elink_emac_enable(struct elink_params *params,
                                      PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK) >>
                                     PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT);
 
-               PMD_DRV_LOG(DEBUG, "XGXS");
+               PMD_DRV_LOG(DEBUG, sc, "XGXS");
                /* select the master lanes (out of 0-3) */
                REG_WR(sc, NIG_REG_XGXS_LANE_SEL_P0 + port * 4, ser_lane);
                /* select XGXS */
                REG_WR(sc, NIG_REG_XGXS_SERDES0_MODE_SEL + port * 4, 1);
 
        } else {                /* SerDes */
-               PMD_DRV_LOG(DEBUG, "SerDes");
+               PMD_DRV_LOG(DEBUG, sc, "SerDes");
                /* select SerDes */
                REG_WR(sc, NIG_REG_XGXS_SERDES0_MODE_SEL + port * 4, 0);
        }
@@ -1642,7 +1643,7 @@ static elink_status_t elink_emac_enable(struct elink_params *params,
         */
        elink_cb_reg_write(sc, emac_base + EMAC_REG_RX_PFC_MODE, 0);
        if (params->feature_config_flags & ELINK_FEATURE_CONFIG_PFC_ENABLED) {
-               PMD_DRV_LOG(DEBUG, "PFC is enabled");
+               PMD_DRV_LOG(DEBUG, sc, "PFC is enabled");
                /* Enable PFC again */
                elink_cb_reg_write(sc, emac_base + EMAC_REG_RX_PFC_MODE,
                                   EMAC_REG_RX_PFC_MODE_RX_EN |
@@ -1762,7 +1763,7 @@ static void elink_update_pfc_bmac2(struct elink_params *params,
        REG_WR_DMAE(sc, bmac_addr + BIGMAC2_REGISTER_TX_CONTROL, wb_data, 2);
 
        if (params->feature_config_flags & ELINK_FEATURE_CONFIG_PFC_ENABLED) {
-               PMD_DRV_LOG(DEBUG, "PFC is enabled");
+               PMD_DRV_LOG(DEBUG, sc, "PFC is enabled");
                /* Enable PFC RX & TX & STATS and set 8 COS  */
                wb_data[0] = 0x0;
                wb_data[0] |= (1 << 0); /* RX */
@@ -1776,7 +1777,7 @@ static void elink_update_pfc_bmac2(struct elink_params *params,
                /* Clear the force Xon */
                wb_data[0] &= ~(1 << 2);
        } else {
-               PMD_DRV_LOG(DEBUG, "PFC is disabled");
+               PMD_DRV_LOG(DEBUG, sc, "PFC is disabled");
                /* Disable PFC RX & TX & STATS and set 8 COS */
                wb_data[0] = 0x8;
                wb_data[1] = 0;
@@ -1802,7 +1803,7 @@ static void elink_update_pfc_bmac2(struct elink_params *params,
        val = 0x3;              /* Enable RX and TX */
        if (is_lb) {
                val |= 0x4;     /* Local loopback */
-               PMD_DRV_LOG(DEBUG, "enable bmac loopback");
+               PMD_DRV_LOG(DEBUG, sc, "enable bmac loopback");
        }
        /* When PFC enabled, Pass pause frames towards the NIG. */
        if (params->feature_config_flags & ELINK_FEATURE_CONFIG_PFC_ENABLED)
@@ -1896,7 +1897,7 @@ static void elink_update_pfc_nig(struct elink_params *params,
 
        int set_pfc = params->feature_config_flags &
            ELINK_FEATURE_CONFIG_PFC_ENABLED;
-       PMD_DRV_LOG(DEBUG, "updating pfc nig parameters");
+       PMD_DRV_LOG(DEBUG, sc, "updating pfc nig parameters");
 
        /* When NIG_LLH0_XCM_MASK_REG_LLHX_XCM_MASK_BCN bit is set
         * MAC control frames (that are not pause packets)
@@ -2008,7 +2009,7 @@ elink_status_t elink_update_pfc(struct elink_params *params,
        if (!vars->link_up)
                return elink_status;
 
-       PMD_DRV_LOG(DEBUG, "About to update PFC in BMAC");
+       PMD_DRV_LOG(DEBUG, sc, "About to update PFC in BMAC");
 
        if (CHIP_IS_E3(sc)) {
                if (vars->mac_type == ELINK_MAC_TYPE_XMAC)
@@ -2018,7 +2019,7 @@ elink_status_t elink_update_pfc(struct elink_params *params,
                if ((val &
                     (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << params->port))
                    == 0) {
-                       PMD_DRV_LOG(DEBUG, "About to update PFC in EMAC");
+                       PMD_DRV_LOG(DEBUG, sc, "About to update PFC in EMAC");
                        elink_emac_enable(params, vars, 0);
                        return elink_status;
                }
@@ -2047,7 +2048,7 @@ static elink_status_t elink_bmac1_enable(struct elink_params *params,
        uint32_t wb_data[2];
        uint32_t val;
 
-       PMD_DRV_LOG(DEBUG, "Enabling BigMAC1");
+       PMD_DRV_LOG(DEBUG, sc, "Enabling BigMAC1");
 
        /* XGXS control */
        wb_data[0] = 0x3c;
@@ -2066,7 +2067,7 @@ static elink_status_t elink_bmac1_enable(struct elink_params *params,
        val = 0x3;
        if (is_lb) {
                val |= 0x4;
-               PMD_DRV_LOG(DEBUG, "enable bmac loopback");
+               PMD_DRV_LOG(DEBUG, sc, "enable bmac loopback");
        }
        wb_data[0] = val;
        wb_data[1] = 0;
@@ -2107,7 +2108,7 @@ static elink_status_t elink_bmac2_enable(struct elink_params *params,
            NIG_REG_INGRESS_BMAC0_MEM;
        uint32_t wb_data[2];
 
-       PMD_DRV_LOG(DEBUG, "Enabling BigMAC2");
+       PMD_DRV_LOG(DEBUG, sc, "Enabling BigMAC2");
 
        wb_data[0] = 0;
        wb_data[1] = 0;
@@ -2245,7 +2246,7 @@ static elink_status_t elink_pbf_update(struct elink_params *params,
        /* Wait for init credit */
        init_crd = REG_RD(sc, PBF_REG_P0_INIT_CRD + port * 4);
        crd = REG_RD(sc, PBF_REG_P0_CREDIT + port * 8);
-       PMD_DRV_LOG(DEBUG, "init_crd 0x%x  crd 0x%x", init_crd, crd);
+       PMD_DRV_LOG(DEBUG, sc, "init_crd 0x%x  crd 0x%x", init_crd, crd);
 
        while ((init_crd != crd) && count) {
                DELAY(1000 * 5);
@@ -2254,7 +2255,7 @@ static elink_status_t elink_pbf_update(struct elink_params *params,
        }
        crd = REG_RD(sc, PBF_REG_P0_CREDIT + port * 8);
        if (init_crd != crd) {
-               PMD_DRV_LOG(DEBUG, "BUG! init_crd 0x%x != crd 0x%x",
+               PMD_DRV_LOG(DEBUG, sc, "BUG! init_crd 0x%x != crd 0x%x",
                            init_crd, crd);
                return ELINK_STATUS_ERROR;
        }
@@ -2281,13 +2282,13 @@ static elink_status_t elink_pbf_update(struct elink_params *params,
                        init_crd = thresh + 553 - 22;
                        break;
                default:
-                       PMD_DRV_LOG(DEBUG, "Invalid line_speed 0x%x",
+                       PMD_DRV_LOG(DEBUG, sc, "Invalid line_speed 0x%x",
                                    line_speed);
                        return ELINK_STATUS_ERROR;
                }
        }
        REG_WR(sc, PBF_REG_P0_INIT_CRD + port * 4, init_crd);
-       PMD_DRV_LOG(DEBUG, "PBF updated to speed %d credit %d",
+       PMD_DRV_LOG(DEBUG, sc, "PBF updated to speed %d credit %d",
                    line_speed, init_crd);
 
        /* Probe the credit changes */
@@ -2377,7 +2378,7 @@ static elink_status_t elink_cl22_write(struct bnx2x_softc *sc,
                }
        }
        if (tmp & EMAC_MDIO_COMM_START_BUSY) {
-               PMD_DRV_LOG(DEBUG, "write phy register failed");
+               PMD_DRV_LOG(DEBUG, sc, "write phy register failed");
                rc = ELINK_STATUS_TIMEOUT;
        }
        REG_WR(sc, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE, mode);
@@ -2413,7 +2414,7 @@ static elink_status_t elink_cl22_read(struct bnx2x_softc *sc,
                }
        }
        if (val & EMAC_MDIO_COMM_START_BUSY) {
-               PMD_DRV_LOG(DEBUG, "read phy register failed");
+               PMD_DRV_LOG(DEBUG, sc, "read phy register failed");
 
                *ret_val = 0;
                rc = ELINK_STATUS_TIMEOUT;
@@ -2454,7 +2455,7 @@ static elink_status_t elink_cl45_read(struct bnx2x_softc *sc,
                }
        }
        if (val & EMAC_MDIO_COMM_START_BUSY) {
-               PMD_DRV_LOG(DEBUG, "read phy register failed");
+               PMD_DRV_LOG(DEBUG, sc, "read phy register failed");
                elink_cb_event_log(sc, ELINK_LOG_ID_MDIO_ACCESS_TIMEOUT);       // "MDC/MDIO access timeout"
 
                *ret_val = 0;
@@ -2478,7 +2479,7 @@ static elink_status_t elink_cl45_read(struct bnx2x_softc *sc,
                        }
                }
                if (val & EMAC_MDIO_COMM_START_BUSY) {
-                       PMD_DRV_LOG(DEBUG, "read phy register failed");
+                       PMD_DRV_LOG(DEBUG, sc, "read phy register failed");
                        elink_cb_event_log(sc, ELINK_LOG_ID_MDIO_ACCESS_TIMEOUT);       // "MDC/MDIO access timeout"
 
                        *ret_val = 0;
@@ -2530,7 +2531,7 @@ static elink_status_t elink_cl45_write(struct bnx2x_softc *sc,
                }
        }
        if (tmp & EMAC_MDIO_COMM_START_BUSY) {
-               PMD_DRV_LOG(DEBUG, "write phy register failed");
+               PMD_DRV_LOG(DEBUG, sc, "write phy register failed");
                elink_cb_event_log(sc, ELINK_LOG_ID_MDIO_ACCESS_TIMEOUT);       // "MDC/MDIO access timeout"
 
                rc = ELINK_STATUS_TIMEOUT;
@@ -2552,7 +2553,7 @@ static elink_status_t elink_cl45_write(struct bnx2x_softc *sc,
                        }
                }
                if (tmp & EMAC_MDIO_COMM_START_BUSY) {
-                       PMD_DRV_LOG(DEBUG, "write phy register failed");
+                       PMD_DRV_LOG(DEBUG, sc, "write phy register failed");
                        elink_cb_event_log(sc, ELINK_LOG_ID_MDIO_ACCESS_TIMEOUT);       // "MDC/MDIO access timeout"
 
                        rc = ELINK_STATUS_TIMEOUT;
@@ -2675,7 +2676,7 @@ static elink_status_t elink_eee_set_timers(struct elink_params *params,
        } else if ((params->eee_mode & ELINK_EEE_MODE_ENABLE_LPI) &&
                   (params->eee_mode & ELINK_EEE_MODE_OVERRIDE_NVRAM) &&
                   (params->eee_mode & ELINK_EEE_MODE_OUTPUT_TIME)) {
-               PMD_DRV_LOG(DEBUG, "Error: Tx LPI is enabled with timer 0");
+               PMD_DRV_LOG(DEBUG, sc, "Error: Tx LPI is enabled with timer 0");
                return ELINK_STATUS_ERROR;
        }
 
@@ -2742,11 +2743,11 @@ static elink_status_t elink_eee_advertise(struct elink_phy *phy,
        REG_WR(sc, MISC_REG_CPMU_LP_MASK_EXT_P0 + (params->port << 2), 0xfc20);
 
        if (modes & SHMEM_EEE_10G_ADV) {
-               PMD_DRV_LOG(DEBUG, "Advertise 10GBase-T EEE");
+               PMD_DRV_LOG(DEBUG, sc, "Advertise 10GBase-T EEE");
                val |= 0x8;
        }
        if (modes & SHMEM_EEE_1G_ADV) {
-               PMD_DRV_LOG(DEBUG, "Advertise 1GBase-T EEE");
+               PMD_DRV_LOG(DEBUG, sc, "Advertise 1GBase-T EEE");
                val |= 0x4;
        }
 
@@ -2786,7 +2787,7 @@ static void elink_eee_an_resolve(struct elink_phy *phy,
                if (adv & 0x2) {
                        if (vars->line_speed == ELINK_SPEED_100)
                                neg = 1;
-                       PMD_DRV_LOG(DEBUG, "EEE negotiated - 100M");
+                       PMD_DRV_LOG(DEBUG, sc, "EEE negotiated - 100M");
                }
        }
        if (lp & 0x14) {
@@ -2794,7 +2795,7 @@ static void elink_eee_an_resolve(struct elink_phy *phy,
                if (adv & 0x14) {
                        if (vars->line_speed == ELINK_SPEED_1000)
                                neg = 1;
-                       PMD_DRV_LOG(DEBUG, "EEE negotiated - 1G");
+                       PMD_DRV_LOG(DEBUG, sc, "EEE negotiated - 1G");
                }
        }
        if (lp & 0x68) {
@@ -2802,7 +2803,7 @@ static void elink_eee_an_resolve(struct elink_phy *phy,
                if (adv & 0x68) {
                        if (vars->line_speed == ELINK_SPEED_10000)
                                neg = 1;
-                       PMD_DRV_LOG(DEBUG, "EEE negotiated - 10G");
+                       PMD_DRV_LOG(DEBUG, sc, "EEE negotiated - 10G");
                }
        }
 
@@ -2810,7 +2811,7 @@ static void elink_eee_an_resolve(struct elink_phy *phy,
        vars->eee_status |= (lp_adv << SHMEM_EEE_LP_ADV_STATUS_SHIFT);
 
        if (neg) {
-               PMD_DRV_LOG(DEBUG, "EEE is active");
+               PMD_DRV_LOG(DEBUG, sc, "EEE is active");
                vars->eee_status |= SHMEM_EEE_ACTIVE_BIT;
        }
 }
@@ -2840,7 +2841,7 @@ static void elink_bsc_module_sel(struct elink_params *params)
                                   e3_cmn_pin_cfg));
        i2c_val[I2C_BSC0] = (sfp_ctrl & PORT_HW_CFG_E3_I2C_MUX0_MASK) > 0;
        i2c_val[I2C_BSC1] = (sfp_ctrl & PORT_HW_CFG_E3_I2C_MUX1_MASK) > 0;
-       PMD_DRV_LOG(DEBUG, "Setting BSC switch");
+       PMD_DRV_LOG(DEBUG, sc, "Setting BSC switch");
        for (idx = 0; idx < I2C_SWITCH_WIDTH; idx++)
                elink_set_cfg_pin(sc, i2c_pins[idx], i2c_val[idx]);
 }
@@ -2856,7 +2857,7 @@ static elink_status_t elink_bsc_read(struct elink_params *params,
        elink_status_t rc = ELINK_STATUS_OK;
 
        if (xfer_cnt > 16) {
-               PMD_DRV_LOG(DEBUG, "invalid xfer_cnt %d. Max is 16 bytes",
+               PMD_DRV_LOG(DEBUG, sc, "invalid xfer_cnt %d. Max is 16 bytes",
                            xfer_cnt);
                return ELINK_STATUS_ERROR;
        }
@@ -2888,7 +2889,7 @@ static elink_status_t elink_bsc_read(struct elink_params *params,
                DELAY(10);
                val = REG_RD(sc, MCP_REG_MCPR_IMC_COMMAND);
                if (i++ > 1000) {
-                       PMD_DRV_LOG(DEBUG, "wr 0 byte timed out after %d try",
+                       PMD_DRV_LOG(DEBUG, sc, "wr 0 byte timed out after %d try",
                                    i);
                        rc = ELINK_STATUS_TIMEOUT;
                        break;
@@ -2912,7 +2913,8 @@ static elink_status_t elink_bsc_read(struct elink_params *params,
                DELAY(10);
                val = REG_RD(sc, MCP_REG_MCPR_IMC_COMMAND);
                if (i++ > 1000) {
-                       PMD_DRV_LOG(DEBUG, "rd op timed out after %d try", i);
+                       PMD_DRV_LOG(DEBUG, sc,
+                                   "rd op timed out after %d try", i);
                        rc = ELINK_STATUS_TIMEOUT;
                        break;
                }
@@ -3057,7 +3059,7 @@ static void elink_serdes_deassert(struct bnx2x_softc *sc, uint8_t port)
 {
        uint32_t val;
 
-       PMD_DRV_LOG(DEBUG, "elink_serdes_deassert");
+       PMD_DRV_LOG(DEBUG, sc, "elink_serdes_deassert");
 
        val = ELINK_SERDES_RESET_BITS << (port * 16);
 
@@ -3092,7 +3094,7 @@ static void elink_xgxs_deassert(struct elink_params *params)
        struct bnx2x_softc *sc = params->sc;
        uint8_t port;
        uint32_t val;
-       PMD_DRV_LOG(DEBUG, "elink_xgxs_deassert");
+       PMD_DRV_LOG(DEBUG, sc, "elink_xgxs_deassert");
        port = params->port;
 
        val = ELINK_XGXS_RESET_BITS << (port * 16);
@@ -3143,7 +3145,7 @@ static void elink_calc_ieee_aneg_adv(struct elink_phy *phy,
                *ieee_fc |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE;
                break;
        }
-       PMD_DRV_LOG(DEBUG, "ieee_fc = 0x%x", *ieee_fc);
+       PMD_DRV_LOG(DEBUG, params->sc, "ieee_fc = 0x%x", *ieee_fc);
 }
 
 static void set_phy_vars(struct elink_params *params, struct elink_vars *vars)
@@ -3177,7 +3179,7 @@ static void set_phy_vars(struct elink_params *params, struct elink_vars *vars)
                    ELINK_SPEED_AUTO_NEG)
                        vars->link_status |= LINK_STATUS_AUTO_NEGOTIATE_ENABLED;
 
-               PMD_DRV_LOG(DEBUG, "req_flow_ctrl %x, req_line_speed %x,"
+               PMD_DRV_LOG(DEBUG, params->sc, "req_flow_ctrl %x, req_line_speed %x,"
                            " speed_cap_mask %x",
                            params->phy[actual_phy_idx].req_flow_ctrl,
                            params->phy[actual_phy_idx].req_line_speed,
@@ -3208,7 +3210,7 @@ static void elink_ext_phy_set_pause(struct elink_params *params,
            MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) {
                val |= MDIO_AN_REG_ADV_PAUSE_PAUSE;
        }
-       PMD_DRV_LOG(DEBUG, "Ext phy AN advertize 0x%x", val);
+       PMD_DRV_LOG(DEBUG, sc, "Ext phy AN advertize 0x%x", val);
        elink_cl45_write(sc, phy, MDIO_AN_DEVAD, MDIO_AN_REG_ADV_PAUSE, val);
 }
 
@@ -3287,7 +3289,7 @@ static void elink_ext_phy_update_adv_fc(struct elink_phy *phy,
        }
        pause_result = (ld_pause & MDIO_AN_REG_ADV_PAUSE_MASK) >> 8;
        pause_result |= (lp_pause & MDIO_AN_REG_ADV_PAUSE_MASK) >> 10;
-       PMD_DRV_LOG(DEBUG, "Ext PHY pause result 0x%x", pause_result);
+       PMD_DRV_LOG(DEBUG, sc, "Ext PHY pause result 0x%x", pause_result);
        elink_pause_resolve(vars, pause_result);
 
 }
@@ -3356,7 +3358,7 @@ static void elink_warpcore_enable_AN_KR2(struct elink_phy *phy,
                {MDIO_WC_DEVAD, MDIO_WC_REG_ETA_CL73_LD_BAM_CODE, 0x0157},
                {MDIO_WC_DEVAD, MDIO_WC_REG_ETA_CL73_LD_UD_CODE, 0x0620}
        };
-       PMD_DRV_LOG(DEBUG, "Enabling 20G-KR2");
+       PMD_DRV_LOG(DEBUG, sc, "Enabling 20G-KR2");
 
        elink_cl45_read_or_write(sc, phy, MDIO_WC_DEVAD,
                                 MDIO_WC_REG_CL49_USERB0_CTRL, (3 << 6));
@@ -3393,7 +3395,7 @@ static void elink_disable_kr2(struct elink_params *params,
                {MDIO_WC_DEVAD, MDIO_WC_REG_ETA_CL73_LD_BAM_CODE, 0x0002},
                {MDIO_WC_DEVAD, MDIO_WC_REG_ETA_CL73_LD_UD_CODE, 0x0000}
        };
-       PMD_DRV_LOG(DEBUG, "Disabling 20G-KR2");
+       PMD_DRV_LOG(DEBUG, sc, "Disabling 20G-KR2");
 
        for (i = 0; i < ARRAY_SIZE(reg_set); i++)
                elink_cl45_write(sc, phy, reg_set[i].devad, reg_set[i].reg,
@@ -3409,7 +3411,7 @@ static void elink_warpcore_set_lpi_passthrough(struct elink_phy *phy,
 {
        struct bnx2x_softc *sc = params->sc;
 
-       PMD_DRV_LOG(DEBUG, "Configure WC for LPI pass through");
+       PMD_DRV_LOG(DEBUG, sc, "Configure WC for LPI pass through");
        elink_cl45_write(sc, phy, MDIO_WC_DEVAD,
                         MDIO_WC_REG_EEE_COMBO_CONTROL0, 0x7c);
        elink_cl45_read_or_write(sc, phy, MDIO_WC_DEVAD,
@@ -3447,7 +3449,7 @@ static void elink_warpcore_enable_AN_KR(struct elink_phy *phy,
                {MDIO_PMA_DEVAD, MDIO_WC_REG_PMD_KR_CONTROL, 0x2},
                {MDIO_WC_DEVAD, MDIO_WC_REG_CL72_USERB0_CL72_TX_FIR_TAP, 0},
        };
-       PMD_DRV_LOG(DEBUG, "Enable Auto Negotiation for KR");
+       PMD_DRV_LOG(DEBUG, sc, "Enable Auto Negotiation for KR");
        /* Set to default registers that may be overridden by 10G force */
        for (i = 0; i < ARRAY_SIZE(reg_set); i++)
                elink_cl45_write(sc, phy, reg_set[i].devad, reg_set[i].reg,
@@ -3469,7 +3471,7 @@ static void elink_warpcore_enable_AN_KR(struct elink_phy *phy,
 
                /* Enable CL37 1G Parallel Detect */
                elink_cl45_read_or_write(sc, phy, MDIO_WC_DEVAD, addr, 0x1);
-               PMD_DRV_LOG(DEBUG, "Advertize 1G");
+               PMD_DRV_LOG(DEBUG, sc, "Advertize 1G");
        }
        if (((vars->line_speed == ELINK_SPEED_AUTO_NEG) &&
             (phy->speed_cap_mask & PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)) ||
@@ -3483,7 +3485,7 @@ static void elink_warpcore_enable_AN_KR(struct elink_phy *phy,
                elink_cl45_write(sc, phy, MDIO_AN_DEVAD,
                                 MDIO_WC_REG_PAR_DET_10G_CTRL, 1);
                elink_set_aer_mmd(params, phy);
-               PMD_DRV_LOG(DEBUG, "Advertize 10G");
+               PMD_DRV_LOG(DEBUG, sc, "Advertize 10G");
        }
 
        /* Set Transmit PMD settings */
@@ -3520,7 +3522,7 @@ static void elink_warpcore_enable_AN_KR(struct elink_phy *phy,
                elink_cl45_read_or_write(sc, phy, MDIO_WC_DEVAD,
                                         MDIO_WC_REG_DIGITAL6_MP5_NEXTPAGECTRL,
                                         1);
-               PMD_DRV_LOG(DEBUG, "Enable CL37 BAM on KR");
+               PMD_DRV_LOG(DEBUG, sc, "Enable CL37 BAM on KR");
        }
 
        /* Advertise pause */
@@ -3857,7 +3859,7 @@ static void elink_warpcore_set_sgmii_speed(struct elink_phy *phy,
                elink_cl45_read_or_write(sc, phy, MDIO_WC_DEVAD,
                                         MDIO_WC_REG_COMBO_IEEE0_MIICTRL,
                                         0x1000);
-               PMD_DRV_LOG(DEBUG, "set SGMII AUTONEG");
+               PMD_DRV_LOG(DEBUG, sc, "set SGMII AUTONEG");
        } else {
                elink_cl45_read(sc, phy, MDIO_WC_DEVAD,
                                MDIO_WC_REG_COMBO_IEEE0_MIICTRL, &val16);
@@ -3872,7 +3874,7 @@ static void elink_warpcore_set_sgmii_speed(struct elink_phy *phy,
                        val16 |= 0x0040;
                        break;
                default:
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                                    "Speed not supported: 0x%x",
                                    phy->req_line_speed);
                        return;
@@ -3884,11 +3886,11 @@ static void elink_warpcore_set_sgmii_speed(struct elink_phy *phy,
                elink_cl45_write(sc, phy, MDIO_WC_DEVAD,
                                 MDIO_WC_REG_COMBO_IEEE0_MIICTRL, val16);
 
-               PMD_DRV_LOG(DEBUG, "set SGMII force speed %d",
+               PMD_DRV_LOG(DEBUG, sc, "set SGMII force speed %d",
                            phy->req_line_speed);
                elink_cl45_read(sc, phy, MDIO_WC_DEVAD,
                                MDIO_WC_REG_COMBO_IEEE0_MIICTRL, &val16);
-               PMD_DRV_LOG(DEBUG, "  (readback) %x", val16);
+               PMD_DRV_LOG(DEBUG, sc, "  (readback) %x", val16);
        }
 
        /* SGMII Slave mode and disable signal detect */
@@ -3999,7 +4001,7 @@ static elink_status_t elink_get_mod_abs_int_cfg(struct bnx2x_softc *sc,
                 */
                if ((cfg_pin < PIN_CFG_GPIO0_P0) ||
                    (cfg_pin > PIN_CFG_GPIO3_P1)) {
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                                    "No cfg pin %x for module detect indication",
                                    cfg_pin);
                        return ELINK_STATUS_ERROR;
@@ -4091,7 +4093,7 @@ static void elink_warpcore_config_runtime(struct elink_phy *phy,
                                                 0x1200);
 
                                vars->rx_tx_asic_rst--;
-                               PMD_DRV_LOG(DEBUG, "0x%x retry left",
+                               PMD_DRV_LOG(DEBUG, sc, "0x%x retry left",
                                            vars->rx_tx_asic_rst);
                        }
                        break;
@@ -4113,10 +4115,10 @@ static void elink_warpcore_config_sfi(struct elink_phy *phy,
        if ((params->req_line_speed[ELINK_LINK_CONFIG_IDX(ELINK_INT_PHY)] ==
             ELINK_SPEED_10000) &&
            (phy->media_type != ELINK_ETH_PHY_SFP_1G_FIBER)) {
-               PMD_DRV_LOG(DEBUG, "Setting 10G SFI");
+               PMD_DRV_LOG(DEBUG, params->sc, "Setting 10G SFI");
                elink_warpcore_set_10G_XFI(phy, params, 0);
        } else {
-               PMD_DRV_LOG(DEBUG, "Setting 1G Fiber");
+               PMD_DRV_LOG(DEBUG, params->sc, "Setting 1G Fiber");
                elink_warpcore_set_sgmii_speed(phy, params, 1, 0);
        }
 }
@@ -4133,7 +4135,7 @@ static void elink_sfp_e3_set_transmitter(struct elink_params *params,
                                  dev_info.port_hw_config[port].e3_sfp_ctrl)) &
            PORT_HW_CFG_E3_TX_LASER_MASK;
        /* Set the !tx_en since this pin is DISABLE_TX_LASER */
-       PMD_DRV_LOG(DEBUG, "Setting WC TX to %d", tx_en);
+       PMD_DRV_LOG(DEBUG, sc, "Setting WC TX to %d", tx_en);
 
        /* For 20G, the expected pin to be used is 3 pins after the current */
        elink_set_cfg_pin(sc, cfg_pin, tx_en ^ 1);
@@ -4154,7 +4156,7 @@ static uint8_t elink_warpcore_config_init(struct elink_phy *phy,
                                         dev_info.port_hw_config[params->port].
                                         default_cfg)) &
                         PORT_HW_CFG_NET_SERDES_IF_MASK);
-       PMD_DRV_LOG(DEBUG,
+       PMD_DRV_LOG(DEBUG, sc,
                    "Begin Warpcore init, link_speed %d, "
                    "serdes_net_if = 0x%x", vars->line_speed, serdes_net_if);
        elink_set_aer_mmd(params, phy);
@@ -4165,7 +4167,7 @@ static uint8_t elink_warpcore_config_init(struct elink_phy *phy,
             ((phy->req_line_speed == ELINK_SPEED_100) ||
              (phy->req_line_speed == ELINK_SPEED_10)))) {
                vars->phy_flags |= PHY_SGMII_FLAG;
-               PMD_DRV_LOG(DEBUG, "Setting SGMII mode");
+               PMD_DRV_LOG(DEBUG, sc, "Setting SGMII mode");
                elink_warpcore_clear_regs(phy, params, lane);
                elink_warpcore_set_sgmii_speed(phy, params, 0, 1);
        } else {
@@ -4175,7 +4177,7 @@ static uint8_t elink_warpcore_config_init(struct elink_phy *phy,
                        if (params->loopback_mode != ELINK_LOOPBACK_EXT)
                                elink_warpcore_enable_AN_KR(phy, params, vars);
                        else {
-                               PMD_DRV_LOG(DEBUG, "Setting KR 10G-Force");
+                               PMD_DRV_LOG(DEBUG, sc, "Setting KR 10G-Force");
                                elink_warpcore_set_10G_KR(phy, params);
                        }
                        break;
@@ -4183,14 +4185,14 @@ static uint8_t elink_warpcore_config_init(struct elink_phy *phy,
                case PORT_HW_CFG_NET_SERDES_IF_XFI:
                        elink_warpcore_clear_regs(phy, params, lane);
                        if (vars->line_speed == ELINK_SPEED_10000) {
-                               PMD_DRV_LOG(DEBUG, "Setting 10G XFI");
+                               PMD_DRV_LOG(DEBUG, sc, "Setting 10G XFI");
                                elink_warpcore_set_10G_XFI(phy, params, 1);
                        } else {
                                if (ELINK_SINGLE_MEDIA_DIRECT(params)) {
-                                       PMD_DRV_LOG(DEBUG, "1G Fiber");
+                                       PMD_DRV_LOG(DEBUG, sc, "1G Fiber");
                                        fiber_mode = 1;
                                } else {
-                                       PMD_DRV_LOG(DEBUG, "10/100/1G SGMII");
+                                       PMD_DRV_LOG(DEBUG, sc, "10/100/1G SGMII");
                                        fiber_mode = 0;
                                }
                                elink_warpcore_set_sgmii_speed(phy,
@@ -4219,10 +4221,10 @@ static uint8_t elink_warpcore_config_init(struct elink_phy *phy,
 
                case PORT_HW_CFG_NET_SERDES_IF_DXGXS:
                        if (vars->line_speed != ELINK_SPEED_20000) {
-                               PMD_DRV_LOG(DEBUG, "Speed not supported yet");
+                               PMD_DRV_LOG(DEBUG, sc, "Speed not supported yet");
                                return 0;
                        }
-                       PMD_DRV_LOG(DEBUG, "Setting 20G DXGXS");
+                       PMD_DRV_LOG(DEBUG, sc, "Setting 20G DXGXS");
                        elink_warpcore_set_20G_DXGXS(sc, phy, lane);
                        /* Issue Module detection */
 
@@ -4232,12 +4234,12 @@ static uint8_t elink_warpcore_config_init(struct elink_phy *phy,
                        if (!params->loopback_mode) {
                                elink_warpcore_enable_AN_KR(phy, params, vars);
                        } else {
-                               PMD_DRV_LOG(DEBUG, "Setting KR 20G-Force");
+                               PMD_DRV_LOG(DEBUG, sc, "Setting KR 20G-Force");
                                elink_warpcore_set_20G_force_KR2(phy, params);
                        }
                        break;
                default:
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                                    "Unsupported Serdes Net Interface 0x%x",
                                    serdes_net_if);
                        return 0;
@@ -4246,7 +4248,7 @@ static uint8_t elink_warpcore_config_init(struct elink_phy *phy,
 
        /* Take lane out of reset after configuration is finished */
        elink_warpcore_reset_lane(sc, phy, 0);
-       PMD_DRV_LOG(DEBUG, "Exit config init");
+       PMD_DRV_LOG(DEBUG, sc, "Exit config init");
 
        return 0;
 }
@@ -4311,7 +4313,7 @@ static void elink_set_warpcore_loopback(struct elink_phy *phy,
        struct bnx2x_softc *sc = params->sc;
        uint16_t val16;
        uint32_t lane;
-       PMD_DRV_LOG(DEBUG, "Setting Warpcore loopback type %x, speed %d",
+       PMD_DRV_LOG(DEBUG, sc, "Setting Warpcore loopback type %x, speed %d",
                    params->loopback_mode, phy->req_line_speed);
 
        if (phy->req_line_speed < ELINK_SPEED_10000 ||
@@ -4356,7 +4358,7 @@ static void elink_sync_link(struct elink_params *params,
                vars->phy_flags |= PHY_PHYSICAL_LINK_FLAG;
        vars->link_up = (vars->link_status & LINK_STATUS_LINK_UP);
        if (vars->link_up) {
-               PMD_DRV_LOG(DEBUG, "phy link up");
+               PMD_DRV_LOG(DEBUG, sc, "phy link up");
 
                vars->phy_link_up = 1;
                vars->duplex = DUPLEX_FULL;
@@ -4434,7 +4436,7 @@ static void elink_sync_link(struct elink_params *params,
                                vars->mac_type = ELINK_MAC_TYPE_EMAC;
                }
        } else {                /* Link down */
-               PMD_DRV_LOG(DEBUG, "phy link down");
+               PMD_DRV_LOG(DEBUG, sc, "phy link down");
 
                vars->phy_link_up = 0;
 
@@ -4491,7 +4493,7 @@ void elink_link_status_update(struct elink_params *params,
        params->phy[ELINK_EXT_PHY2].media_type =
            (media_types & PORT_HW_CFG_MEDIA_TYPE_PHY2_MASK) >>
            PORT_HW_CFG_MEDIA_TYPE_PHY2_SHIFT;
-       PMD_DRV_LOG(DEBUG, "media_types = 0x%x", media_types);
+       PMD_DRV_LOG(DEBUG, sc, "media_types = 0x%x", media_types);
 
        /* Sync AEU offset */
        sync_offset = params->shmem_base +
@@ -4512,9 +4514,9 @@ void elink_link_status_update(struct elink_params *params,
                vars->link_attr_sync = SHMEM2_RD(sc,
                                                 link_attr_sync[params->port]);
 
-       PMD_DRV_LOG(DEBUG, "link_status 0x%x  phy_link_up %x int_mask 0x%x",
+       PMD_DRV_LOG(DEBUG, sc, "link_status 0x%x  phy_link_up %x int_mask 0x%x",
                    vars->link_status, vars->phy_link_up, vars->aeu_int_mask);
-       PMD_DRV_LOG(DEBUG, "line_speed %x  duplex %x  flow_ctrl 0x%x",
+       PMD_DRV_LOG(DEBUG, sc, "line_speed %x  duplex %x  flow_ctrl 0x%x",
                    vars->line_speed, vars->duplex, vars->flow_ctrl);
 }
 
@@ -4575,7 +4577,7 @@ static elink_status_t elink_reset_unicore(struct elink_params *params,
        elink_cb_event_log(sc, ELINK_LOG_ID_PHY_UNINITIALIZED, params->port);   // "Warning: PHY was not initialized,"
        // " Port %d",
 
-       PMD_DRV_LOG(DEBUG, "BUG! XGXS is still in reset!");
+       PMD_DRV_LOG(DEBUG, sc, "BUG! XGXS is still in reset!");
        return ELINK_STATUS_ERROR;
 
 }
@@ -4634,7 +4636,7 @@ static void elink_set_parallel_detection(struct elink_phy *phy,
                control2 |= MDIO_SERDES_DIGITAL_A_1000X_CONTROL2_PRL_DT_EN;
        else
                control2 &= ~MDIO_SERDES_DIGITAL_A_1000X_CONTROL2_PRL_DT_EN;
-       PMD_DRV_LOG(DEBUG, "phy->speed_cap_mask = 0x%x, control2 = 0x%x",
+       PMD_DRV_LOG(DEBUG, sc, "phy->speed_cap_mask = 0x%x, control2 = 0x%x",
                    phy->speed_cap_mask, control2);
        CL22_WR_OVER_CL45(sc, phy,
                          MDIO_REG_BANK_SERDES_DIGITAL,
@@ -4642,7 +4644,7 @@ static void elink_set_parallel_detection(struct elink_phy *phy,
 
        if ((phy->type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT) &&
            (phy->speed_cap_mask & PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)) {
-               PMD_DRV_LOG(DEBUG, "XGXS");
+               PMD_DRV_LOG(DEBUG, sc, "XGXS");
 
                CL22_WR_OVER_CL45(sc, phy,
                                  MDIO_REG_BANK_10G_PARALLEL_DETECT,
@@ -4795,7 +4797,7 @@ static void elink_program_serdes(struct elink_phy *phy,
                          MDIO_REG_BANK_SERDES_DIGITAL,
                          MDIO_SERDES_DIGITAL_MISC1, &reg_val);
        /* Clearing the speed value before setting the right speed */
-       PMD_DRV_LOG(DEBUG, "MDIO_REG_BANK_SERDES_DIGITAL = 0x%x", reg_val);
+       PMD_DRV_LOG(DEBUG, sc, "MDIO_REG_BANK_SERDES_DIGITAL = 0x%x", reg_val);
 
        reg_val &= ~(MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_MASK |
                     MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_SEL);
@@ -4863,7 +4865,7 @@ static void elink_restart_autoneg(struct elink_phy *phy,
        struct bnx2x_softc *sc = params->sc;
        uint16_t mii_control;
 
-       PMD_DRV_LOG(DEBUG, "elink_restart_autoneg");
+       PMD_DRV_LOG(DEBUG, sc, "elink_restart_autoneg");
        /* Enable and restart BAM/CL37 aneg */
 
        if (enable_cl73) {
@@ -4883,7 +4885,7 @@ static void elink_restart_autoneg(struct elink_phy *phy,
                CL22_RD_OVER_CL45(sc, phy,
                                  MDIO_REG_BANK_COMBO_IEEE0,
                                  MDIO_COMBO_IEEE0_MII_CONTROL, &mii_control);
-               PMD_DRV_LOG(DEBUG,
+               PMD_DRV_LOG(DEBUG, sc,
                            "elink_restart_autoneg mii_control before = 0x%x",
                            mii_control);
                CL22_WR_OVER_CL45(sc, phy,
@@ -4942,7 +4944,7 @@ static void elink_initialize_sgmii_process(struct elink_phy *phy,
                        break;
                default:
                        /* Invalid speed for SGMII */
-                       PMD_DRV_LOG(DEBUG, "Invalid line_speed 0x%x",
+                       PMD_DRV_LOG(DEBUG, sc, "Invalid line_speed 0x%x",
                                    vars->line_speed);
                        break;
                }
@@ -4977,7 +4979,7 @@ static elink_status_t elink_direct_parallel_detect_used(struct elink_phy *phy,
                          MDIO_REG_BANK_SERDES_DIGITAL,
                          MDIO_SERDES_DIGITAL_A_1000X_STATUS2, &status2_1000x);
        if (status2_1000x & MDIO_SERDES_DIGITAL_A_1000X_STATUS2_AN_DISABLED) {
-               PMD_DRV_LOG(DEBUG, "1G parallel detect link on port %d",
+               PMD_DRV_LOG(DEBUG, sc, "1G parallel detect link on port %d",
                            params->port);
                return ELINK_STATUS_ERROR;
        }
@@ -4987,7 +4989,7 @@ static elink_status_t elink_direct_parallel_detect_used(struct elink_phy *phy,
                          MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_STATUS, &pd_10g);
 
        if (pd_10g & MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_STATUS_PD_LINK) {
-               PMD_DRV_LOG(DEBUG, "10G parallel detect link on port %d",
+               PMD_DRV_LOG(DEBUG, sc, "10G parallel detect link on port %d",
                            params->port);
                return ELINK_STATUS_ERROR;
        }
@@ -5018,7 +5020,7 @@ static void elink_update_adv_fc(struct elink_phy *phy,
                                MDIO_CL73_IEEEB1_AN_ADV1_PAUSE_MASK) >> 8;
                pause_result |= (lp_pause &
                                 MDIO_CL73_IEEEB1_AN_LP_ADV1_PAUSE_MASK) >> 10;
-               PMD_DRV_LOG(DEBUG, "pause_result CL73 0x%x", pause_result);
+               PMD_DRV_LOG(DEBUG, sc, "pause_result CL73 0x%x", pause_result);
        } else {
                CL22_RD_OVER_CL45(sc, phy,
                                  MDIO_REG_BANK_COMBO_IEEE0,
@@ -5031,7 +5033,7 @@ static void elink_update_adv_fc(struct elink_phy *phy,
                                MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) >> 5;
                pause_result |= (lp_pause &
                                 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) >> 7;
-               PMD_DRV_LOG(DEBUG, "pause_result CL37 0x%x", pause_result);
+               PMD_DRV_LOG(DEBUG, sc, "pause_result CL37 0x%x", pause_result);
        }
        elink_pause_resolve(vars, pause_result);
 
@@ -5060,7 +5062,7 @@ static void elink_flow_ctrl_resolve(struct elink_phy *phy,
                }
                elink_update_adv_fc(phy, params, vars, gp_status);
        }
-       PMD_DRV_LOG(DEBUG, "flow_ctrl 0x%x", vars->flow_ctrl);
+       PMD_DRV_LOG(DEBUG, params->sc, "flow_ctrl 0x%x", vars->flow_ctrl);
 }
 
 static void elink_check_fallback_to_cl37(struct elink_phy *phy,
@@ -5068,13 +5070,13 @@ static void elink_check_fallback_to_cl37(struct elink_phy *phy,
 {
        struct bnx2x_softc *sc = params->sc;
        uint16_t rx_status, ustat_val, cl37_fsm_received;
-       PMD_DRV_LOG(DEBUG, "elink_check_fallback_to_cl37");
+       PMD_DRV_LOG(DEBUG, sc, "elink_check_fallback_to_cl37");
        /* Step 1: Make sure signal is detected */
        CL22_RD_OVER_CL45(sc, phy,
                          MDIO_REG_BANK_RX0, MDIO_RX0_RX_STATUS, &rx_status);
        if ((rx_status & MDIO_RX0_RX_STATUS_SIGDET) !=
            (MDIO_RX0_RX_STATUS_SIGDET)) {
-               PMD_DRV_LOG(DEBUG, "Signal is not detected. Restoring CL73."
+               PMD_DRV_LOG(DEBUG, sc, "Signal is not detected. Restoring CL73."
                            "rx_status(0x80b0) = 0x%x", rx_status);
                CL22_WR_OVER_CL45(sc, phy,
                                  MDIO_REG_BANK_CL73_IEEEB0,
@@ -5091,7 +5093,7 @@ static void elink_check_fallback_to_cl37(struct elink_phy *phy,
              MDIO_CL73_USERB0_CL73_USTAT1_AN_GOOD_CHECK_BAM37)) !=
            (MDIO_CL73_USERB0_CL73_USTAT1_LINK_STATUS_CHECK |
             MDIO_CL73_USERB0_CL73_USTAT1_AN_GOOD_CHECK_BAM37)) {
-               PMD_DRV_LOG(DEBUG, "CL73 state-machine is not stable. "
+               PMD_DRV_LOG(DEBUG, sc, "CL73 state-machine is not stable. "
                            "ustat_val(0x8371) = 0x%x", ustat_val);
                return;
        }
@@ -5106,7 +5108,7 @@ static void elink_check_fallback_to_cl37(struct elink_phy *phy,
              MDIO_REMOTE_PHY_MISC_RX_STATUS_CL37_FSM_RECEIVED_BRCM_OUI_MSG)) !=
            (MDIO_REMOTE_PHY_MISC_RX_STATUS_CL37_FSM_RECEIVED_OVER1G_MSG |
             MDIO_REMOTE_PHY_MISC_RX_STATUS_CL37_FSM_RECEIVED_BRCM_OUI_MSG)) {
-               PMD_DRV_LOG(DEBUG, "No CL37 FSM were received. "
+               PMD_DRV_LOG(DEBUG, sc, "No CL37 FSM were received. "
                            "misc_rx_status(0x8330) = 0x%x", cl37_fsm_received);
                return;
        }
@@ -5122,7 +5124,7 @@ static void elink_check_fallback_to_cl37(struct elink_phy *phy,
                          MDIO_CL73_IEEEB0_CL73_AN_CONTROL, 0);
        /* Restart CL37 autoneg */
        elink_restart_autoneg(phy, params, 0);
-       PMD_DRV_LOG(DEBUG, "Disabling CL73, and restarting CL37 autoneg");
+       PMD_DRV_LOG(DEBUG, sc, "Disabling CL73, and restarting CL37 autoneg");
 }
 
 static void elink_xgxs_an_resolve(struct elink_phy *phy,
@@ -5146,7 +5148,7 @@ static elink_status_t elink_get_link_speed_duplex(struct elink_phy *phy,
        if (phy->req_line_speed == ELINK_SPEED_AUTO_NEG)
                vars->link_status |= LINK_STATUS_AUTO_NEGOTIATE_ENABLED;
        if (is_link_up) {
-               PMD_DRV_LOG(DEBUG, "phy link up");
+               PMD_DRV_LOG(DEBUG, params->sc, "phy link up");
 
                vars->phy_link_up = 1;
                vars->link_status |= LINK_STATUS_LINK_UP;
@@ -5187,7 +5189,7 @@ static elink_status_t elink_get_link_speed_duplex(struct elink_phy *phy,
 
                case ELINK_GP_STATUS_5G:
                case ELINK_GP_STATUS_6G:
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, params->sc,
                                    "link speed unsupported  gp_status 0x%x",
                                    speed_mask);
                        return ELINK_STATUS_ERROR;
@@ -5207,13 +5209,13 @@ static elink_status_t elink_get_link_speed_duplex(struct elink_phy *phy,
                        vars->link_status |= ELINK_LINK_20GTFD;
                        break;
                default:
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, params->sc,
                                    "link speed unsupported gp_status 0x%x",
                                    speed_mask);
                        return ELINK_STATUS_ERROR;
                }
        } else {                /* link_down */
-               PMD_DRV_LOG(DEBUG, "phy link down");
+               PMD_DRV_LOG(DEBUG, params->sc, "phy link down");
 
                vars->phy_link_up = 0;
 
@@ -5221,7 +5223,7 @@ static elink_status_t elink_get_link_speed_duplex(struct elink_phy *phy,
                vars->flow_ctrl = ELINK_FLOW_CTRL_NONE;
                vars->mac_type = ELINK_MAC_TYPE_NONE;
        }
-       PMD_DRV_LOG(DEBUG, " phy_link_up %x line_speed %d",
+       PMD_DRV_LOG(DEBUG, params->sc, " phy_link_up %x line_speed %d",
                    vars->phy_link_up, vars->line_speed);
        return ELINK_STATUS_OK;
 }
@@ -5244,7 +5246,7 @@ static uint8_t elink_link_settings_status(struct elink_phy *phy,
        if (gp_status & MDIO_GP_STATUS_TOP_AN_STATUS1_LINK_STATUS)
                link_up = 1;
        speed_mask = gp_status & ELINK_GP_STATUS_SPEED_MASK;
-       PMD_DRV_LOG(DEBUG, "gp_status 0x%x, is_link_up %d, speed_mask 0x%x",
+       PMD_DRV_LOG(DEBUG, sc, "gp_status 0x%x, is_link_up %d, speed_mask 0x%x",
                    gp_status, link_up, speed_mask);
        rc = elink_get_link_speed_duplex(phy, params, vars, link_up, speed_mask,
                                         duplex);
@@ -5294,7 +5296,7 @@ static uint8_t elink_link_settings_status(struct elink_phy *phy,
                            LINK_STATUS_LINK_PARTNER_10GXFD_CAPABLE;
        }
 
-       PMD_DRV_LOG(DEBUG, "duplex %x  flow_ctrl 0x%x link_status 0x%x",
+       PMD_DRV_LOG(DEBUG, sc, "duplex %x  flow_ctrl 0x%x link_status 0x%x",
                    vars->duplex, vars->flow_ctrl, vars->link_status);
        return rc;
 }
@@ -5320,7 +5322,7 @@ static uint8_t elink_warpcore_read_status(struct elink_phy *phy,
                uint16_t temp_link_up;
                elink_cl45_read(sc, phy, MDIO_WC_DEVAD, 1, &temp_link_up);
                elink_cl45_read(sc, phy, MDIO_WC_DEVAD, 1, &link_up);
-               PMD_DRV_LOG(DEBUG, "PCS RX link status = 0x%x-->0x%x",
+               PMD_DRV_LOG(DEBUG, sc, "PCS RX link status = 0x%x-->0x%x",
                            temp_link_up, link_up);
                link_up &= (1 << 2);
                if (link_up)
@@ -5328,7 +5330,7 @@ static uint8_t elink_warpcore_read_status(struct elink_phy *phy,
        } else {
                elink_cl45_read(sc, phy, MDIO_WC_DEVAD,
                                MDIO_WC_REG_GP2_STATUS_GP_2_1, &gp_status1);
-               PMD_DRV_LOG(DEBUG, "0x81d1 = 0x%x", gp_status1);
+               PMD_DRV_LOG(DEBUG, sc, "0x81d1 = 0x%x", gp_status1);
                /* Check for either KR, 1G, or AN up. */
                link_up = ((gp_status1 >> 8) |
                           (gp_status1 >> 12) | (gp_status1)) & (1 << lane);
@@ -5398,7 +5400,7 @@ static uint8_t elink_warpcore_read_status(struct elink_phy *phy,
                elink_cl45_read(sc, phy, MDIO_WC_DEVAD,
                                MDIO_WC_REG_GP2_STATUS_GP_2_3, &gp_speed);
        }
-       PMD_DRV_LOG(DEBUG, "lane %d gp_speed 0x%x", lane, gp_speed);
+       PMD_DRV_LOG(DEBUG, sc, "lane %d gp_speed 0x%x", lane, gp_speed);
 
        if ((lane & 1) == 0)
                gp_speed <<= 8;
@@ -5414,7 +5416,7 @@ static uint8_t elink_warpcore_read_status(struct elink_phy *phy,
            (!(phy->flags & ELINK_FLAGS_WC_DUAL_MODE)))
                vars->rx_tx_asic_rst = MAX_KR_LINK_RETRY;
 
-       PMD_DRV_LOG(DEBUG, "duplex %x  flow_ctrl 0x%x link_status 0x%x",
+       PMD_DRV_LOG(DEBUG, sc, "duplex %x  flow_ctrl 0x%x link_status 0x%x",
                    vars->duplex, vars->flow_ctrl, vars->link_status);
        return rc;
 }
@@ -5461,7 +5463,7 @@ static elink_status_t elink_emac_program(struct elink_params *params,
        uint8_t port = params->port;
        uint16_t mode = 0;
 
-       PMD_DRV_LOG(DEBUG, "setting link speed & duplex");
+       PMD_DRV_LOG(DEBUG, sc, "setting link speed & duplex");
        elink_bits_dis(sc, GRCBASE_EMAC0 + port * 0x400 +
                       EMAC_REG_EMAC_MODE,
                       (EMAC_MODE_25G_MODE |
@@ -5485,7 +5487,8 @@ static elink_status_t elink_emac_program(struct elink_params *params,
 
        default:
                /* 10G not valid for EMAC */
-               PMD_DRV_LOG(DEBUG, "Invalid line_speed 0x%x", vars->line_speed);
+               PMD_DRV_LOG(DEBUG, sc,
+                           "Invalid line_speed 0x%x", vars->line_speed);
                return ELINK_STATUS_ERROR;
        }
 
@@ -5537,7 +5540,7 @@ static uint8_t elink_xgxs_config_init(struct elink_phy *phy,
                if (vars->line_speed != ELINK_SPEED_AUTO_NEG ||
                    (ELINK_SINGLE_MEDIA_DIRECT(params) &&
                     params->loopback_mode == ELINK_LOOPBACK_EXT)) {
-                       PMD_DRV_LOG(DEBUG, "not SGMII, no AN");
+                       PMD_DRV_LOG(DEBUG, params->sc, "not SGMII, no AN");
 
                        /* Disable autoneg */
                        elink_set_autoneg(phy, params, vars, 0);
@@ -5546,7 +5549,7 @@ static uint8_t elink_xgxs_config_init(struct elink_phy *phy,
                        elink_program_serdes(phy, params, vars);
 
                } else {        /* AN_mode */
-                       PMD_DRV_LOG(DEBUG, "not SGMII, AN");
+                       PMD_DRV_LOG(DEBUG, params->sc, "not SGMII, AN");
 
                        /* AN enabled */
                        elink_set_brcm_cl37_advertisement(phy, params);
@@ -5563,7 +5566,7 @@ static uint8_t elink_xgxs_config_init(struct elink_phy *phy,
                }
 
        } else {                /* SGMII mode */
-               PMD_DRV_LOG(DEBUG, "SGMII");
+               PMD_DRV_LOG(DEBUG, params->sc, "SGMII");
 
                elink_initialize_sgmii_process(phy, params, vars);
        }
@@ -5632,7 +5635,7 @@ static uint16_t elink_wait_reset_complete(struct bnx2x_softc *sc,
                elink_cb_event_log(sc, ELINK_LOG_ID_PHY_UNINITIALIZED, params->port);   // "Warning: PHY was not initialized,"
        // " Port %d",
 
-       PMD_DRV_LOG(DEBUG, "control reg 0x%x (after %d ms)", ctrl, cnt);
+       PMD_DRV_LOG(DEBUG, sc, "control reg 0x%x (after %d ms)", ctrl, cnt);
        return cnt;
 }
 
@@ -5650,35 +5653,35 @@ static void elink_link_int_enable(struct elink_params *params)
        } else if (params->switch_cfg == ELINK_SWITCH_CFG_10G) {
                mask = (ELINK_NIG_MASK_XGXS0_LINK10G |
                        ELINK_NIG_MASK_XGXS0_LINK_STATUS);
-               PMD_DRV_LOG(DEBUG, "enabled XGXS interrupt");
+               PMD_DRV_LOG(DEBUG, sc, "enabled XGXS interrupt");
                if (!(ELINK_SINGLE_MEDIA_DIRECT(params)) &&
                    params->phy[ELINK_INT_PHY].type !=
                    PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE) {
                        mask |= ELINK_NIG_MASK_MI_INT;
-                       PMD_DRV_LOG(DEBUG, "enabled external phy int");
+                       PMD_DRV_LOG(DEBUG, sc, "enabled external phy int");
                }
 
        } else {                /* SerDes */
                mask = ELINK_NIG_MASK_SERDES0_LINK_STATUS;
-               PMD_DRV_LOG(DEBUG, "enabled SerDes interrupt");
+               PMD_DRV_LOG(DEBUG, sc, "enabled SerDes interrupt");
                if (!(ELINK_SINGLE_MEDIA_DIRECT(params)) &&
                    params->phy[ELINK_INT_PHY].type !=
                    PORT_HW_CFG_SERDES_EXT_PHY_TYPE_NOT_CONN) {
                        mask |= ELINK_NIG_MASK_MI_INT;
-                       PMD_DRV_LOG(DEBUG, "enabled external phy int");
+                       PMD_DRV_LOG(DEBUG, sc, "enabled external phy int");
                }
        }
        elink_bits_en(sc, NIG_REG_MASK_INTERRUPT_PORT0 + port * 4, mask);
 
-       PMD_DRV_LOG(DEBUG, "port %x, is_xgxs %x, int_status 0x%x", port,
+       PMD_DRV_LOG(DEBUG, sc, "port %x, is_xgxs %x, int_status 0x%x", port,
                    (params->switch_cfg == ELINK_SWITCH_CFG_10G),
                    REG_RD(sc, NIG_REG_STATUS_INTERRUPT_PORT0 + port * 4));
-       PMD_DRV_LOG(DEBUG, " int_mask 0x%x, MI_INT %x, SERDES_LINK %x",
+       PMD_DRV_LOG(DEBUG, sc, " int_mask 0x%x, MI_INT %x, SERDES_LINK %x",
                    REG_RD(sc, NIG_REG_MASK_INTERRUPT_PORT0 + port * 4),
                    REG_RD(sc, NIG_REG_EMAC0_STATUS_MISC_MI_INT + port * 0x18),
                    REG_RD(sc,
                           NIG_REG_SERDES0_STATUS_LINK_STATUS + port * 0x3c));
-       PMD_DRV_LOG(DEBUG, " 10G %x, XGXS_LINK %x",
+       PMD_DRV_LOG(DEBUG, sc, " 10G %x, XGXS_LINK %x",
                    REG_RD(sc, NIG_REG_XGXS0_STATUS_LINK10G + port * 0x68),
                    REG_RD(sc, NIG_REG_XGXS0_STATUS_LINK_STATUS + port * 0x68));
 }
@@ -5694,7 +5697,7 @@ static void elink_rearm_latch_signal(struct bnx2x_softc *sc, uint8_t port,
         */
        /* Read Latched signals */
        latch_status = REG_RD(sc, NIG_REG_LATCH_STATUS_0 + port * 8);
-       PMD_DRV_LOG(DEBUG, "latch_status = 0x%x", latch_status);
+       PMD_DRV_LOG(DEBUG, sc, "latch_status = 0x%x", latch_status);
        /* Handle only those with latched-signal=up. */
        if (exp_mi_int)
                elink_bits_en(sc,
@@ -5746,7 +5749,7 @@ static void elink_link_int_ack(struct elink_params *params,
                        } else
                                mask = ELINK_NIG_STATUS_SERDES0_LINK_STATUS;
                }
-               PMD_DRV_LOG(DEBUG, "Ack link up interrupt with mask 0x%x",
+               PMD_DRV_LOG(DEBUG, sc, "Ack link up interrupt with mask 0x%x",
                            mask);
                elink_bits_en(sc,
                              NIG_REG_STATUS_INTERRUPT_PORT0 + port * 4, mask);
@@ -5809,7 +5812,7 @@ static void elink_set_xgxs_loopback(struct elink_phy *phy,
        if (phy->req_line_speed != ELINK_SPEED_1000) {
                uint32_t md_devad = 0;
 
-               PMD_DRV_LOG(DEBUG, "XGXS 10G loopback enable");
+               PMD_DRV_LOG(DEBUG, sc, "XGXS 10G loopback enable");
 
                if (!CHIP_IS_E3(sc)) {
                        /* Change the uni_phy_addr in the nig */
@@ -5841,7 +5844,7 @@ static void elink_set_xgxs_loopback(struct elink_phy *phy,
                }
        } else {
                uint16_t mii_ctrl;
-               PMD_DRV_LOG(DEBUG, "XGXS 1G loopback enable");
+               PMD_DRV_LOG(DEBUG, sc, "XGXS 1G loopback enable");
                elink_cl45_read(sc, phy, 5,
                                (MDIO_REG_BANK_COMBO_IEEE0 +
                                 (MDIO_COMBO_IEEE0_MII_CONTROL & 0xf)),
@@ -5865,8 +5868,9 @@ elink_status_t elink_set_led(struct elink_params *params,
        uint32_t tmp;
        uint32_t emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
        struct bnx2x_softc *sc = params->sc;
-       PMD_DRV_LOG(DEBUG, "elink_set_led: port %x, mode %d", port, mode);
-       PMD_DRV_LOG(DEBUG, "speed 0x%x, hw_led_mode 0x%x", speed, hw_led_mode);
+       PMD_DRV_LOG(DEBUG, sc, "elink_set_led: port %x, mode %d", port, mode);
+       PMD_DRV_LOG(DEBUG, sc,
+                   "speed 0x%x, hw_led_mode 0x%x", speed, hw_led_mode);
        /* In case */
        for (phy_idx = ELINK_EXT_PHY1; phy_idx < ELINK_MAX_PHYS; phy_idx++) {
                if (params->phy[phy_idx].set_link_led) {
@@ -5986,7 +5990,8 @@ elink_status_t elink_set_led(struct elink_params *params,
 
        default:
                rc = ELINK_STATUS_ERROR;
-               PMD_DRV_LOG(DEBUG, "elink_set_led: Invalid led mode %d", mode);
+               PMD_DRV_LOG(DEBUG, sc,
+                           "elink_set_led: Invalid led mode %d", mode);
                break;
        }
        return rc;
@@ -6053,7 +6058,7 @@ static elink_status_t elink_link_initialize(struct elink_params *params,
                        if (phy_index == ELINK_EXT_PHY2 &&
                            (elink_phy_selection(params) ==
                             PORT_HW_CFG_PHY_SELECTION_FIRST_PHY)) {
-                               PMD_DRV_LOG(DEBUG,
+                               PMD_DRV_LOG(DEBUG, sc,
                                            "Not initializing second phy");
                                continue;
                        }
@@ -6094,7 +6099,7 @@ static void elink_common_ext_link_reset(__rte_unused struct elink_phy *phy,
                            MISC_REGISTERS_GPIO_OUTPUT_LOW, gpio_port);
        elink_cb_gpio_write(sc, MISC_REGISTERS_GPIO_2,
                            MISC_REGISTERS_GPIO_OUTPUT_LOW, gpio_port);
-       PMD_DRV_LOG(DEBUG, "reset external PHY");
+       PMD_DRV_LOG(DEBUG, sc, "reset external PHY");
 }
 
 static elink_status_t elink_update_link_down(struct elink_params *params,
@@ -6103,7 +6108,7 @@ static elink_status_t elink_update_link_down(struct elink_params *params,
        struct bnx2x_softc *sc = params->sc;
        uint8_t port = params->port;
 
-       PMD_DRV_LOG(DEBUG, "Port %x: Link is down", port);
+       PMD_DRV_LOG(DEBUG, sc, "Port %x: Link is down", port);
        elink_set_led(params, vars, ELINK_LED_MODE_OFF, 0);
        vars->phy_flags &= ~PHY_PHYSICAL_LINK_FLAG;
        /* Indicate no mac active */
@@ -6164,7 +6169,7 @@ static elink_status_t elink_update_link_up(struct elink_params *params,
                if (link_10g) {
                        if (elink_xmac_enable(params, vars, 0) ==
                            ELINK_STATUS_NO_LINK) {
-                               PMD_DRV_LOG(DEBUG, "Found errors on XMAC");
+                               PMD_DRV_LOG(DEBUG, sc, "Found errors on XMAC");
                                vars->link_up = 0;
                                vars->phy_flags |= PHY_HALF_OPEN_CONN_FLAG;
                                vars->link_status &= ~LINK_STATUS_LINK_UP;
@@ -6176,7 +6181,7 @@ static elink_status_t elink_update_link_up(struct elink_params *params,
 
                if ((vars->eee_status & SHMEM_EEE_ACTIVE_BIT) &&
                    (vars->eee_status & SHMEM_EEE_LPI_REQUESTED_BIT)) {
-                       PMD_DRV_LOG(DEBUG, "Enabling LPI assertion");
+                       PMD_DRV_LOG(DEBUG, sc, "Enabling LPI assertion");
                        REG_WR(sc, MISC_REG_CPMU_LP_FW_ENABLE_P0 +
                               (params->port << 2), 1);
                        REG_WR(sc, MISC_REG_CPMU_LP_DR_ENABLE, 1);
@@ -6188,7 +6193,7 @@ static elink_status_t elink_update_link_up(struct elink_params *params,
                if (link_10g) {
                        if (elink_bmac_enable(params, vars, 0, 1) ==
                            ELINK_STATUS_NO_LINK) {
-                               PMD_DRV_LOG(DEBUG, "Found errors on BMAC");
+                               PMD_DRV_LOG(DEBUG, sc, "Found errors on BMAC");
                                vars->link_up = 0;
                                vars->phy_flags |= PHY_HALF_OPEN_CONN_FLAG;
                                vars->link_status &= ~LINK_STATUS_LINK_UP;
@@ -6273,19 +6278,19 @@ elink_status_t elink_link_update(struct elink_params * params,
        if (USES_WARPCORE(sc))
                elink_set_aer_mmd(params, &params->phy[ELINK_INT_PHY]);
 
-       PMD_DRV_LOG(DEBUG, "port %x, XGXS?%x, int_status 0x%x",
+       PMD_DRV_LOG(DEBUG, sc, "port %x, XGXS?%x, int_status 0x%x",
                    port, (vars->phy_flags & PHY_XGXS_FLAG),
                    REG_RD(sc, NIG_REG_STATUS_INTERRUPT_PORT0 + port * 4));
 
        is_mi_int = (uint8_t) (REG_RD(sc, NIG_REG_EMAC0_STATUS_MISC_MI_INT +
                                      port * 0x18) > 0);
-       PMD_DRV_LOG(DEBUG, "int_mask 0x%x MI_INT %x, SERDES_LINK %x",
+       PMD_DRV_LOG(DEBUG, sc, "int_mask 0x%x MI_INT %x, SERDES_LINK %x",
                    REG_RD(sc, NIG_REG_MASK_INTERRUPT_PORT0 + port * 4),
                    is_mi_int,
                    REG_RD(sc,
                           NIG_REG_SERDES0_STATUS_LINK_STATUS + port * 0x3c));
 
-       PMD_DRV_LOG(DEBUG, " 10G %x, XGXS_LINK %x",
+       PMD_DRV_LOG(DEBUG, sc, " 10G %x, XGXS_LINK %x",
                    REG_RD(sc, NIG_REG_XGXS0_STATUS_LINK10G + port * 0x68),
                    REG_RD(sc, NIG_REG_XGXS0_STATUS_LINK_STATUS + port * 0x68));
 
@@ -6309,10 +6314,10 @@ elink_status_t elink_link_update(struct elink_params * params,
                cur_link_up = phy->read_status(phy, params,
                                               &phy_vars[phy_index]);
                if (cur_link_up) {
-                       PMD_DRV_LOG(DEBUG, "phy in index %d link is up",
+                       PMD_DRV_LOG(DEBUG, sc, "phy in index %d link is up",
                                    phy_index);
                } else {
-                       PMD_DRV_LOG(DEBUG, "phy in index %d link is down",
+                       PMD_DRV_LOG(DEBUG, sc, "phy in index %d link is down",
                                    phy_index);
                        continue;
                }
@@ -6345,7 +6350,7 @@ elink_status_t elink_link_update(struct elink_params * params,
                                 * to link up by itself (using configuration)
                                 * - DEFAULT should be overridden during initialization
                                 */
-                               PMD_DRV_LOG(DEBUG, "Invalid link indication"
+                               PMD_DRV_LOG(DEBUG, sc, "Invalid link indication"
                                            "mpc=0x%x. DISABLING LINK !!!",
                                            params->multi_phy_config);
                                ext_phy_link_up = 0;
@@ -6383,7 +6388,7 @@ elink_status_t elink_link_update(struct elink_params * params,
                 */
                if (active_external_phy == ELINK_EXT_PHY1) {
                        if (params->phy[ELINK_EXT_PHY2].phy_specific_func) {
-                               PMD_DRV_LOG(DEBUG, "Disabling TX on EXT_PHY2");
+                               PMD_DRV_LOG(DEBUG, sc, "Disabling TX on EXT_PHY2");
                                params->phy[ELINK_EXT_PHY2].
                                    phy_specific_func(&params->
                                                      phy[ELINK_EXT_PHY2],
@@ -6401,7 +6406,7 @@ elink_status_t elink_link_update(struct elink_params * params,
 
                vars->eee_status = phy_vars[active_external_phy].eee_status;
 
-               PMD_DRV_LOG(DEBUG, "Active external phy selected: %x",
+               PMD_DRV_LOG(DEBUG, sc, "Active external phy selected: %x",
                            active_external_phy);
        }
 
@@ -6415,7 +6420,7 @@ elink_status_t elink_link_update(struct elink_params * params,
                        break;
                }
        }
-       PMD_DRV_LOG(DEBUG, "vars->flow_ctrl = 0x%x, vars->link_status = 0x%x,"
+       PMD_DRV_LOG(DEBUG, sc, "vars->flow_ctrl = 0x%x, vars->link_status = 0x%x,"
                    " ext_phy_line_speed = %d", vars->flow_ctrl,
                    vars->link_status, ext_phy_line_speed);
        /* Upon link speed change set the NIG into drain mode. Comes to
@@ -6426,7 +6431,7 @@ elink_status_t elink_link_update(struct elink_params * params,
        if (vars->phy_link_up) {
                if (!(ELINK_SINGLE_MEDIA_DIRECT(params)) && ext_phy_link_up &&
                    (ext_phy_line_speed != vars->line_speed)) {
-                       PMD_DRV_LOG(DEBUG, "Internal link speed %d is"
+                       PMD_DRV_LOG(DEBUG, sc, "Internal link speed %d is"
                                    " different than the external"
                                    " link speed %d", vars->line_speed,
                                    ext_phy_line_speed);
@@ -6452,7 +6457,7 @@ elink_status_t elink_link_update(struct elink_params * params,
         * initialize it
         */
        if (!(ELINK_SINGLE_MEDIA_DIRECT(params))) {
-               PMD_DRV_LOG(DEBUG, "ext_phy_link_up = %d, int_link_up = %d,"
+               PMD_DRV_LOG(DEBUG, sc, "ext_phy_link_up = %d, int_link_up = %d,"
                            " init_preceding = %d", ext_phy_link_up,
                            vars->phy_link_up,
                            params->phy[ELINK_EXT_PHY1].flags &
@@ -6517,7 +6522,7 @@ static void elink_save_spirom_version(struct bnx2x_softc *sc,
                                      __rte_unused uint8_t port,
                                      uint32_t spirom_ver, uint32_t ver_addr)
 {
-       PMD_DRV_LOG(DEBUG, "FW version 0x%x:0x%x for port %d",
+       PMD_DRV_LOG(DEBUG, sc, "FW version 0x%x:0x%x for port %d",
                    (uint16_t) (spirom_ver >> 16), (uint16_t) spirom_ver, port);
 
        if (ver_addr)
@@ -6583,7 +6588,7 @@ static void elink_8073_resolve_fc(struct elink_phy *phy,
                                 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) >> 7;
 
                elink_pause_resolve(vars, pause_result);
-               PMD_DRV_LOG(DEBUG, "Ext PHY CL37 pause result 0x%x",
+               PMD_DRV_LOG(DEBUG, sc, "Ext PHY CL37 pause result 0x%x",
                            pause_result);
        }
 }
@@ -6627,7 +6632,7 @@ static elink_status_t elink_8073_8727_external_rom_boot(struct bnx2x_softc *sc,
        do {
                count++;
                if (count > 300) {
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                                    "elink_8073_8727_external_rom_boot port %x:"
                                    "Download failed. fw version = 0x%x",
                                    port, fw_ver1);
@@ -6652,7 +6657,7 @@ static elink_status_t elink_8073_8727_external_rom_boot(struct bnx2x_softc *sc,
                         MDIO_PMA_DEVAD, MDIO_PMA_REG_MISC_CTRL1, 0x0000);
        elink_save_bnx2x_spirom_ver(sc, phy, port);
 
-       PMD_DRV_LOG(DEBUG,
+       PMD_DRV_LOG(DEBUG, sc,
                    "elink_8073_8727_external_rom_boot port %x:"
                    "Download complete. fw version = 0x%x", port, fw_ver1);
 
@@ -6713,10 +6718,10 @@ static elink_status_t elink_8073_xaui_wa(struct bnx2x_softc *sc,
                 * these bits indicate 2.5G or 1G link up).
                 */
                if (!(val & (1 << 14)) || !(val & (1 << 13))) {
-                       PMD_DRV_LOG(DEBUG, "XAUI work-around not required");
+                       PMD_DRV_LOG(DEBUG, sc, "XAUI work-around not required");
                        return ELINK_STATUS_OK;
                } else if (!(val & (1 << 15))) {
-                       PMD_DRV_LOG(DEBUG, "bit 15 went off");
+                       PMD_DRV_LOG(DEBUG, sc, "bit 15 went off");
                        /* If bit 15 is 0, then poll Dev1, Reg $C841 until it's
                         * MSB (bit15) goes to 1 (indicating that the XAUI
                         * workaround has completed), then continue on with
@@ -6728,7 +6733,7 @@ static elink_status_t elink_8073_xaui_wa(struct bnx2x_softc *sc,
                                                MDIO_PMA_REG_8073_XAUI_WA,
                                                &val);
                                if (val & (1 << 15)) {
-                                       PMD_DRV_LOG(DEBUG,
+                                       PMD_DRV_LOG(DEBUG, sc,
                                                    "XAUI workaround has completed");
                                        return ELINK_STATUS_OK;
                                }
@@ -6738,7 +6743,7 @@ static elink_status_t elink_8073_xaui_wa(struct bnx2x_softc *sc,
                }
                DELAY(1000 * 3);
        }
-       PMD_DRV_LOG(DEBUG, "Warning: XAUI work-around timeout !!!");
+       PMD_DRV_LOG(DEBUG, sc, "Warning: XAUI work-around timeout !!!");
        return ELINK_STATUS_ERROR;
 }
 
@@ -6780,7 +6785,7 @@ static void elink_8073_set_pause_cl37(struct elink_params *params,
            MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) {
                cl37_val |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH;
        }
-       PMD_DRV_LOG(DEBUG, "Ext phy AN advertize cl37 0x%x", cl37_val);
+       PMD_DRV_LOG(DEBUG, sc, "Ext phy AN advertize cl37 0x%x", cl37_val);
 
        elink_cl45_write(sc, phy,
                         MDIO_AN_DEVAD, MDIO_AN_REG_CL37_FC_LD, cl37_val);
@@ -6811,7 +6816,7 @@ static uint8_t elink_8073_config_init(struct elink_phy *phy,
        struct bnx2x_softc *sc = params->sc;
        uint16_t val = 0, tmp1;
        uint8_t gpio_port;
-       PMD_DRV_LOG(DEBUG, "Init 8073");
+       PMD_DRV_LOG(DEBUG, sc, "Init 8073");
 
        if (CHIP_IS_E2(sc))
                gpio_port = SC_PATH(sc);
@@ -6832,12 +6837,12 @@ static uint8_t elink_8073_config_init(struct elink_phy *phy,
 
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_RXSTAT, &tmp1);
 
-       PMD_DRV_LOG(DEBUG, "Before rom RX_ALARM(port1): 0x%x", tmp1);
+       PMD_DRV_LOG(DEBUG, sc, "Before rom RX_ALARM(port1): 0x%x", tmp1);
 
        /* Swap polarity if required - Must be done only in non-1G mode */
        if (params->lane_config & PORT_HW_CFG_SWAP_PHY_POLARITY_ENABLED) {
                /* Configure the 8073 to swap _P and _N of the KR lines */
-               PMD_DRV_LOG(DEBUG, "Swapping polarity for the 8073");
+               PMD_DRV_LOG(DEBUG, sc, "Swapping polarity for the 8073");
                /* 10G Rx/Tx and 1G Tx signal polarity swap */
                elink_cl45_read(sc, phy,
                                MDIO_PMA_DEVAD,
@@ -6859,11 +6864,11 @@ static uint8_t elink_8073_config_init(struct elink_phy *phy,
                                MDIO_AN_DEVAD, MDIO_AN_REG_8073_BAM, &val);
                elink_cl45_write(sc, phy,
                                 MDIO_AN_DEVAD, MDIO_AN_REG_8073_BAM, val | 1);
-               PMD_DRV_LOG(DEBUG, "Enable CL37 BAM on KR");
+               PMD_DRV_LOG(DEBUG, sc, "Enable CL37 BAM on KR");
        }
        if (params->loopback_mode == ELINK_LOOPBACK_EXT) {
                elink_807x_force_10G(sc, phy);
-               PMD_DRV_LOG(DEBUG, "Forced speed 10G on 807X");
+               PMD_DRV_LOG(DEBUG, sc, "Forced speed 10G on 807X");
                return ELINK_STATUS_OK;
        } else {
                elink_cl45_write(sc, phy,
@@ -6889,7 +6894,7 @@ static uint8_t elink_8073_config_init(struct elink_phy *phy,
                    (PORT_HW_CFG_SPEED_CAPABILITY_D0_1G |
                     PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G))
                        val |= (1 << 5);
-               PMD_DRV_LOG(DEBUG, "807x autoneg val = 0x%x", val);
+               PMD_DRV_LOG(DEBUG, sc, "807x autoneg val = 0x%x", val);
        }
 
        elink_cl45_write(sc, phy, MDIO_AN_DEVAD, MDIO_AN_REG_ADV, val);
@@ -6903,13 +6908,13 @@ static uint8_t elink_8073_config_init(struct elink_phy *phy,
                elink_cl45_read(sc, phy,
                                MDIO_PMA_DEVAD, MDIO_PMA_REG_8073_CHIP_REV,
                                &phy_ver);
-               PMD_DRV_LOG(DEBUG, "Add 2.5G");
+               PMD_DRV_LOG(DEBUG, sc, "Add 2.5G");
                if (phy_ver > 0)
                        tmp1 |= 1;
                else
                        tmp1 &= 0xfffe;
        } else {
-               PMD_DRV_LOG(DEBUG, "Disable 2.5G");
+               PMD_DRV_LOG(DEBUG, sc, "Disable 2.5G");
                tmp1 &= 0xfffe;
        }
 
@@ -6943,7 +6948,7 @@ static uint8_t elink_8073_config_init(struct elink_phy *phy,
        /* Restart autoneg */
        DELAY(1000 * 500);
        elink_cl45_write(sc, phy, MDIO_AN_DEVAD, MDIO_AN_REG_CTRL, 0x1200);
-       PMD_DRV_LOG(DEBUG, "807x Autoneg Restart: Advertise 1G=%x, 10G=%x",
+       PMD_DRV_LOG(DEBUG, sc, "807x Autoneg Restart: Advertise 1G=%x, 10G=%x",
                    ((val & (1 << 5)) > 0), ((val & (1 << 7)) > 0));
        return ELINK_STATUS_OK;
 }
@@ -6960,12 +6965,12 @@ static uint8_t elink_8073_read_status(struct elink_phy *phy,
 
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_STAT, &val1);
 
-       PMD_DRV_LOG(DEBUG, "8703 LASI status 0x%x", val1);
+       PMD_DRV_LOG(DEBUG, sc, "8703 LASI status 0x%x", val1);
 
        /* Clear the interrupt LASI status register */
        elink_cl45_read(sc, phy, MDIO_PCS_DEVAD, MDIO_PCS_REG_STATUS, &val2);
        elink_cl45_read(sc, phy, MDIO_PCS_DEVAD, MDIO_PCS_REG_STATUS, &val1);
-       PMD_DRV_LOG(DEBUG, "807x PCS status 0x%x->0x%x", val2, val1);
+       PMD_DRV_LOG(DEBUG, sc, "807x PCS status 0x%x->0x%x", val2, val1);
        /* Clear MSG-OUT */
        elink_cl45_read(sc, phy,
                        MDIO_PMA_DEVAD, MDIO_PMA_REG_M8051_MSGOUT_REG, &val1);
@@ -6973,16 +6978,16 @@ static uint8_t elink_8073_read_status(struct elink_phy *phy,
        /* Check the LASI */
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_RXSTAT, &val2);
 
-       PMD_DRV_LOG(DEBUG, "KR 0x9003 0x%x", val2);
+       PMD_DRV_LOG(DEBUG, sc, "KR 0x9003 0x%x", val2);
 
        /* Check the link status */
        elink_cl45_read(sc, phy, MDIO_PCS_DEVAD, MDIO_PCS_REG_STATUS, &val2);
-       PMD_DRV_LOG(DEBUG, "KR PCS status 0x%x", val2);
+       PMD_DRV_LOG(DEBUG, sc, "KR PCS status 0x%x", val2);
 
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_STATUS, &val2);
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_STATUS, &val1);
        link_up = ((val1 & 4) == 4);
-       PMD_DRV_LOG(DEBUG, "PMA_REG_STATUS=0x%x", val1);
+       PMD_DRV_LOG(DEBUG, sc, "PMA_REG_STATUS=0x%x", val1);
 
        if (link_up && ((phy->req_line_speed != ELINK_SPEED_10000))) {
                if (elink_8073_xaui_wa(sc, phy) != 0)
@@ -6996,7 +7001,7 @@ static uint8_t elink_8073_read_status(struct elink_phy *phy,
        /* Check the link status on 1.1.2 */
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_STATUS, &val2);
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_STATUS, &val1);
-       PMD_DRV_LOG(DEBUG, "KR PMA status 0x%x->0x%x,"
+       PMD_DRV_LOG(DEBUG, sc, "KR PMA status 0x%x->0x%x,"
                    "an_link_status=0x%x", val2, val1, an1000_status);
 
        link_up = (((val1 & 4) == 4) || (an1000_status & (1 << 1)));
@@ -7022,21 +7027,21 @@ static uint8_t elink_8073_read_status(struct elink_phy *phy,
        if ((link_status & (1 << 2)) && (!(link_status & (1 << 15)))) {
                link_up = 1;
                vars->line_speed = ELINK_SPEED_10000;
-               PMD_DRV_LOG(DEBUG, "port %x: External link up in 10G",
+               PMD_DRV_LOG(DEBUG, sc, "port %x: External link up in 10G",
                            params->port);
        } else if ((link_status & (1 << 1)) && (!(link_status & (1 << 14)))) {
                link_up = 1;
                vars->line_speed = ELINK_SPEED_2500;
-               PMD_DRV_LOG(DEBUG, "port %x: External link up in 2.5G",
+               PMD_DRV_LOG(DEBUG, sc, "port %x: External link up in 2.5G",
                            params->port);
        } else if ((link_status & (1 << 0)) && (!(link_status & (1 << 13)))) {
                link_up = 1;
                vars->line_speed = ELINK_SPEED_1000;
-               PMD_DRV_LOG(DEBUG, "port %x: External link up in 1G",
+               PMD_DRV_LOG(DEBUG, sc, "port %x: External link up in 1G",
                            params->port);
        } else {
                link_up = 0;
-               PMD_DRV_LOG(DEBUG, "port %x: External link is down",
+               PMD_DRV_LOG(DEBUG, sc, "port %x: External link is down",
                            params->port);
        }
 
@@ -7051,7 +7056,7 @@ static uint8_t elink_8073_read_status(struct elink_phy *phy,
                         * when it`s in 10G mode.
                         */
                        if (vars->line_speed == ELINK_SPEED_1000) {
-                               PMD_DRV_LOG(DEBUG, "Swapping 1G polarity for"
+                               PMD_DRV_LOG(DEBUG, sc, "Swapping 1G polarity for"
                                            "the 8073");
                                val1 |= (1 << 3);
                        } else
@@ -7090,7 +7095,7 @@ static void elink_8073_link_reset(__rte_unused struct elink_phy *phy,
                gpio_port = SC_PATH(sc);
        else
                gpio_port = params->port;
-       PMD_DRV_LOG(DEBUG, "Setting 8073 port %d into low power mode",
+       PMD_DRV_LOG(DEBUG, sc, "Setting 8073 port %d into low power mode",
                    gpio_port);
        elink_cb_gpio_write(sc, MISC_REGISTERS_GPIO_2,
                            MISC_REGISTERS_GPIO_OUTPUT_LOW, gpio_port);
@@ -7105,7 +7110,7 @@ static uint8_t elink_8705_config_init(struct elink_phy *phy,
                                             *vars)
 {
        struct bnx2x_softc *sc = params->sc;
-       PMD_DRV_LOG(DEBUG, "init 8705");
+       PMD_DRV_LOG(DEBUG, sc, "init 8705");
        /* Restore normal power mode */
        elink_cb_gpio_write(sc, MISC_REGISTERS_GPIO_2,
                            MISC_REGISTERS_GPIO_OUTPUT_HIGH, params->port);
@@ -7133,21 +7138,21 @@ static uint8_t elink_8705_read_status(struct elink_phy *phy,
        uint8_t link_up = 0;
        uint16_t val1, rx_sd;
        struct bnx2x_softc *sc = params->sc;
-       PMD_DRV_LOG(DEBUG, "read status 8705");
+       PMD_DRV_LOG(DEBUG, sc, "read status 8705");
        elink_cl45_read(sc, phy,
                        MDIO_WIS_DEVAD, MDIO_WIS_REG_LASI_STATUS, &val1);
-       PMD_DRV_LOG(DEBUG, "8705 LASI status 0x%x", val1);
+       PMD_DRV_LOG(DEBUG, sc, "8705 LASI status 0x%x", val1);
 
        elink_cl45_read(sc, phy,
                        MDIO_WIS_DEVAD, MDIO_WIS_REG_LASI_STATUS, &val1);
-       PMD_DRV_LOG(DEBUG, "8705 LASI status 0x%x", val1);
+       PMD_DRV_LOG(DEBUG, sc, "8705 LASI status 0x%x", val1);
 
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_SD, &rx_sd);
 
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, 0xc809, &val1);
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, 0xc809, &val1);
 
-       PMD_DRV_LOG(DEBUG, "8705 1.c809 val=0x%x", val1);
+       PMD_DRV_LOG(DEBUG, sc, "8705 1.c809 val=0x%x", val1);
        link_up = ((rx_sd & 0x1) && (val1 & (1 << 9))
                   && ((val1 & (1 << 8)) == 0));
        if (link_up) {
@@ -7171,13 +7176,13 @@ static void elink_set_disable_pmd_transmit(struct elink_params *params,
        if (pmd_dis) {
                if (params->feature_config_flags &
                    ELINK_FEATURE_CONFIG_BC_SUPPORTS_SFP_TX_DISABLED) {
-                       PMD_DRV_LOG(DEBUG, "Disabling PMD transmitter");
+                       PMD_DRV_LOG(DEBUG, sc, "Disabling PMD transmitter");
                } else {
-                       PMD_DRV_LOG(DEBUG, "NOT disabling PMD transmitter");
+                       PMD_DRV_LOG(DEBUG, sc, "NOT disabling PMD transmitter");
                        return;
                }
        } else {
-               PMD_DRV_LOG(DEBUG, "Enabling PMD transmitter");
+               PMD_DRV_LOG(DEBUG, sc, "Enabling PMD transmitter");
        }
        elink_cl45_write(sc, phy,
                         MDIO_PMA_DEVAD, MDIO_PMA_REG_TX_DISABLE, pmd_dis);
@@ -7211,7 +7216,7 @@ static void elink_sfp_e1e2_set_transmitter(struct elink_params *params,
                            offsetof(struct shmem_region,
                                     dev_info.port_hw_config[port].sfp_ctrl)) &
            PORT_HW_CFG_TX_LASER_MASK;
-       PMD_DRV_LOG(DEBUG, "Setting transmitter tx_en=%x for port %x "
+       PMD_DRV_LOG(DEBUG, sc, "Setting transmitter tx_en=%x for port %x "
                    "mode = %x", tx_en, port, tx_en_mode);
        switch (tx_en_mode) {
        case PORT_HW_CFG_TX_LASER_MDIO:
@@ -7247,7 +7252,8 @@ static void elink_sfp_e1e2_set_transmitter(struct elink_params *params,
                        break;
                }
        default:
-               PMD_DRV_LOG(DEBUG, "Invalid TX_LASER_MDIO 0x%x", tx_en_mode);
+               PMD_DRV_LOG(DEBUG, sc,
+                           "Invalid TX_LASER_MDIO 0x%x", tx_en_mode);
                break;
        }
 }
@@ -7256,7 +7262,7 @@ static void elink_sfp_set_transmitter(struct elink_params *params,
                                      struct elink_phy *phy, uint8_t tx_en)
 {
        struct bnx2x_softc *sc = params->sc;
-       PMD_DRV_LOG(DEBUG, "Setting SFP+ transmitter to %d", tx_en);
+       PMD_DRV_LOG(DEBUG, sc, "Setting SFP+ transmitter to %d", tx_en);
        if (CHIP_IS_E3(sc))
                elink_sfp_e3_set_transmitter(params, phy, tx_en);
        else
@@ -7277,7 +7283,7 @@ static elink_status_t elink_8726_read_sfp_module_eeprom(struct elink_phy *phy,
        uint16_t val = 0;
        uint16_t i;
        if (byte_cnt > ELINK_SFP_EEPROM_PAGE_SIZE) {
-               PMD_DRV_LOG(DEBUG, "Reading from eeprom is limited to 0xf");
+               PMD_DRV_LOG(DEBUG, sc, "Reading from eeprom is limited to 0xf");
                return ELINK_STATUS_ERROR;
        }
        /* Set the read command byte count */
@@ -7308,7 +7314,7 @@ static elink_status_t elink_8726_read_sfp_module_eeprom(struct elink_phy *phy,
 
        if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) !=
            MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_COMPLETE) {
-               PMD_DRV_LOG(DEBUG,
+               PMD_DRV_LOG(DEBUG, sc,
                            "Got bad status 0x%x when reading from SFP+ EEPROM",
                            (val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK));
                return ELINK_STATUS_ERROR;
@@ -7349,7 +7355,7 @@ static void elink_warpcore_power_module(struct elink_params *params,
 
        if (pin_cfg == PIN_CFG_NA)
                return;
-       PMD_DRV_LOG(DEBUG, "Setting SFP+ module power to %d using pin cfg %d",
+       PMD_DRV_LOG(DEBUG, sc, "Setting SFP+ module power to %d using pin cfg %d",
                    power, pin_cfg);
        /* Low ==> corresponding SFP+ module is powered
         * high ==> the SFP+ module is powered down
@@ -7374,7 +7380,7 @@ static elink_status_t elink_warpcore_read_sfp_module_eeprom(__rte_unused struct
        struct bnx2x_softc *sc = params->sc;
 
        if (byte_cnt > ELINK_SFP_EEPROM_PAGE_SIZE) {
-               PMD_DRV_LOG(DEBUG,
+               PMD_DRV_LOG(DEBUG, sc,
                            "Reading from eeprom is limited to 16 bytes");
                return ELINK_STATUS_ERROR;
        }
@@ -7416,7 +7422,7 @@ static elink_status_t elink_8727_read_sfp_module_eeprom(struct elink_phy *phy,
        uint16_t val, i;
 
        if (byte_cnt > ELINK_SFP_EEPROM_PAGE_SIZE) {
-               PMD_DRV_LOG(DEBUG, "Reading from eeprom is limited to 0xf");
+               PMD_DRV_LOG(DEBUG, sc, "Reading from eeprom is limited to 0xf");
                return ELINK_STATUS_ERROR;
        }
 
@@ -7470,7 +7476,7 @@ static elink_status_t elink_8727_read_sfp_module_eeprom(struct elink_phy *phy,
 
        if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) !=
            MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_COMPLETE) {
-               PMD_DRV_LOG(DEBUG,
+               PMD_DRV_LOG(DEBUG, sc,
                            "Got bad status 0x%x when reading from SFP+ EEPROM",
                            (val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK));
                return ELINK_STATUS_TIMEOUT;
@@ -7511,7 +7517,8 @@ static elink_status_t elink_read_sfp_module_eeprom(struct elink_phy *phy,
        read_sfp_module_eeprom_func_p read_func;
 
        if ((dev_addr != 0xa0) && (dev_addr != 0xa2)) {
-               PMD_DRV_LOG(DEBUG, "invalid dev_addr 0x%x", dev_addr);
+               PMD_DRV_LOG(DEBUG, params->sc,
+                           "invalid dev_addr 0x%x", dev_addr);
                return ELINK_STATUS_ERROR;
        }
 
@@ -7557,7 +7564,7 @@ static elink_status_t elink_get_edc_mode(struct elink_phy *phy,
                                         ELINK_I2C_DEV_ADDR_A0,
                                         ELINK_SFP_EEPROM_CON_TYPE_ADDR,
                                         2, (uint8_t *) val) != 0) {
-               PMD_DRV_LOG(DEBUG, "Failed to read from SFP+ module EEPROM");
+               PMD_DRV_LOG(DEBUG, sc, "Failed to read from SFP+ module EEPROM");
                return ELINK_STATUS_ERROR;
        }
 
@@ -7576,7 +7583,7 @@ static elink_status_t elink_get_edc_mode(struct elink_phy *phy,
                                                         1,
                                                         &copper_module_type) !=
                            0) {
-                               PMD_DRV_LOG(DEBUG,
+                               PMD_DRV_LOG(DEBUG, sc,
                                            "Failed to read copper-cable-type"
                                            " from SFP+ EEPROM");
                                return ELINK_STATUS_ERROR;
@@ -7584,7 +7591,7 @@ static elink_status_t elink_get_edc_mode(struct elink_phy *phy,
 
                        if (copper_module_type &
                            ELINK_SFP_EEPROM_FC_TX_TECH_BITMASK_COPPER_ACTIVE) {
-                               PMD_DRV_LOG(DEBUG,
+                               PMD_DRV_LOG(DEBUG, sc,
                                            "Active Copper cable detected");
                                if (phy->type ==
                                    PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT)
@@ -7594,11 +7601,11 @@ static elink_status_t elink_get_edc_mode(struct elink_phy *phy,
                        } else if (copper_module_type &
                                   ELINK_SFP_EEPROM_FC_TX_TECH_BITMASK_COPPER_PASSIVE)
                        {
-                               PMD_DRV_LOG(DEBUG,
+                               PMD_DRV_LOG(DEBUG, sc,
                                            "Passive Copper cable detected");
                                *edc_mode = ELINK_EDC_MODE_PASSIVE_DAC;
                        } else {
-                               PMD_DRV_LOG(DEBUG,
+                               PMD_DRV_LOG(DEBUG, sc,
                                            "Unknown copper-cable-type 0x%x !!!",
                                            copper_module_type);
                                return ELINK_STATUS_ERROR;
@@ -7611,7 +7618,7 @@ static elink_status_t elink_get_edc_mode(struct elink_phy *phy,
                if ((val[1] & (ELINK_SFP_EEPROM_COMP_CODE_SR_MASK |
                               ELINK_SFP_EEPROM_COMP_CODE_LR_MASK |
                               ELINK_SFP_EEPROM_COMP_CODE_LRM_MASK)) == 0) {
-                       PMD_DRV_LOG(DEBUG, "1G SFP module detected");
+                       PMD_DRV_LOG(DEBUG, sc, "1G SFP module detected");
                        gport = params->port;
                        phy->media_type = ELINK_ETH_PHY_SFP_1G_FIBER;
                        if (phy->req_line_speed != ELINK_SPEED_1000) {
@@ -7627,7 +7634,7 @@ static elink_status_t elink_get_edc_mode(struct elink_phy *phy,
                        }
                } else {
                        int idx, cfg_idx = 0;
-                       PMD_DRV_LOG(DEBUG, "10G Optic module detected");
+                       PMD_DRV_LOG(DEBUG, sc, "10G Optic module detected");
                        for (idx = ELINK_INT_PHY; idx < ELINK_MAX_PHYS; idx++) {
                                if (params->phy[idx].type == phy->type) {
                                        cfg_idx = ELINK_LINK_CONFIG_IDX(idx);
@@ -7639,7 +7646,7 @@ static elink_status_t elink_get_edc_mode(struct elink_phy *phy,
                }
                break;
        default:
-               PMD_DRV_LOG(DEBUG, "Unable to determine module type 0x%x !!!",
+               PMD_DRV_LOG(DEBUG, sc, "Unable to determine module type 0x%x !!!",
                            val[0]);
                return ELINK_STATUS_ERROR;
        }
@@ -7669,7 +7676,7 @@ static elink_status_t elink_get_edc_mode(struct elink_phy *phy,
                                                 ELINK_SFP_EEPROM_OPTIONS_ADDR,
                                                 ELINK_SFP_EEPROM_OPTIONS_SIZE,
                                                 options) != 0) {
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                                    "Failed to read Option field from module EEPROM");
                        return ELINK_STATUS_ERROR;
                }
@@ -7678,7 +7685,7 @@ static elink_status_t elink_get_edc_mode(struct elink_phy *phy,
                else
                        *edc_mode = ELINK_EDC_MODE_LIMITING;
        }
-       PMD_DRV_LOG(DEBUG, "EDC mode is set to 0x%x", *edc_mode);
+       PMD_DRV_LOG(DEBUG, sc, "EDC mode is set to 0x%x", *edc_mode);
        return ELINK_STATUS_OK;
 }
 
@@ -7700,7 +7707,7 @@ static elink_status_t elink_verify_sfp_module(struct elink_phy *phy,
                              config));
        if ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
            PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_NO_ENFORCEMENT) {
-               PMD_DRV_LOG(DEBUG, "NOT enforcing module verification");
+               PMD_DRV_LOG(DEBUG, sc, "NOT enforcing module verification");
                return ELINK_STATUS_OK;
        }
 
@@ -7712,21 +7719,21 @@ static elink_status_t elink_verify_sfp_module(struct elink_phy *phy,
                   ELINK_FEATURE_CONFIG_BC_SUPPORTS_OPT_MDL_VRFY) {
                /* Use first phy request only in case of non-dual media */
                if (ELINK_DUAL_MEDIA(params)) {
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                                    "FW does not support OPT MDL verification");
                        return ELINK_STATUS_ERROR;
                }
                cmd = DRV_MSG_CODE_VRFY_FIRST_PHY_OPT_MDL;
        } else {
                /* No support in OPT MDL detection */
-               PMD_DRV_LOG(DEBUG, "FW does not support OPT MDL verification");
+               PMD_DRV_LOG(DEBUG, sc, "FW does not support OPT MDL verification");
                return ELINK_STATUS_ERROR;
        }
 
        fw_cmd_param = ELINK_FW_PARAM_SET(phy->addr, phy->type, phy->mdio_ctrl);
        fw_resp = elink_cb_fw_command(sc, cmd, fw_cmd_param);
        if (fw_resp == FW_MSG_CODE_VRFY_OPT_MDL_SUCCESS) {
-               PMD_DRV_LOG(DEBUG, "Approved module");
+               PMD_DRV_LOG(DEBUG, sc, "Approved module");
                return ELINK_STATUS_OK;
        }
 
@@ -7782,7 +7789,7 @@ static elink_status_t elink_wait_for_sfp_module_initialized(struct elink_phy
                                                          ELINK_I2C_DEV_ADDR_A0,
                                                          1, 1, &val);
                if (rc == 0) {
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, params->sc,
                                    "SFP+ module initialization took %d ms",
                                    timeout * 5);
                        return ELINK_STATUS_OK;
@@ -7833,17 +7840,18 @@ static elink_status_t elink_8726_set_limiting_mode(struct bnx2x_softc *sc,
        elink_cl45_read(sc, phy,
                        MDIO_PMA_DEVAD,
                        MDIO_PMA_REG_ROM_VER2, &cur_limiting_mode);
-       PMD_DRV_LOG(DEBUG, "Current Limiting mode is 0x%x", cur_limiting_mode);
+       PMD_DRV_LOG(DEBUG, sc,
+                   "Current Limiting mode is 0x%x", cur_limiting_mode);
 
        if (edc_mode == ELINK_EDC_MODE_LIMITING) {
-               PMD_DRV_LOG(DEBUG, "Setting LIMITING MODE");
+               PMD_DRV_LOG(DEBUG, sc, "Setting LIMITING MODE");
                elink_cl45_write(sc, phy,
                                 MDIO_PMA_DEVAD,
                                 MDIO_PMA_REG_ROM_VER2,
                                 ELINK_EDC_MODE_LIMITING);
        } else {                /* LRM mode ( default ) */
 
-               PMD_DRV_LOG(DEBUG, "Setting LRM MODE");
+               PMD_DRV_LOG(DEBUG, sc, "Setting LRM MODE");
 
                /* Changing to LRM mode takes quite few seconds. So do it only
                 * if current mode is limiting (default is LRM)
@@ -7933,7 +7941,7 @@ static void elink_8727_specific_func(struct elink_phy *phy,
                                 val);
                break;
        default:
-               PMD_DRV_LOG(DEBUG, "Function 0x%x not supported by 8727",
+               PMD_DRV_LOG(DEBUG, sc, "Function 0x%x not supported by 8727",
                            action);
                return;
        }
@@ -7961,14 +7969,14 @@ static void elink_set_e1e2_module_fault_led(struct elink_params *params,
                        uint8_t gpio_port = elink_get_gpio_port(params);
                        uint16_t gpio_pin = fault_led_gpio -
                            PORT_HW_CFG_FAULT_MODULE_LED_GPIO0;
-                       PMD_DRV_LOG(DEBUG, "Set fault module-detected led "
+                       PMD_DRV_LOG(DEBUG, sc, "Set fault module-detected led "
                                    "pin %x port %x mode %x",
                                    gpio_pin, gpio_port, gpio_mode);
                        elink_cb_gpio_write(sc, gpio_pin, gpio_mode, gpio_port);
                }
                break;
        default:
-               PMD_DRV_LOG(DEBUG, "Error: Invalid fault led mode 0x%x",
+               PMD_DRV_LOG(DEBUG, sc, "Error: Invalid fault led mode 0x%x",
                            fault_led_gpio);
        }
 }
@@ -7984,7 +7992,7 @@ static void elink_set_e3_module_fault_led(struct elink_params *params,
                                   dev_info.port_hw_config[port].e3_sfp_ctrl)) &
                   PORT_HW_CFG_E3_FAULT_MDL_LED_MASK) >>
            PORT_HW_CFG_E3_FAULT_MDL_LED_SHIFT;
-       PMD_DRV_LOG(DEBUG, "Setting Fault LED to %d using pin cfg %d",
+       PMD_DRV_LOG(DEBUG, sc, "Setting Fault LED to %d using pin cfg %d",
                    gpio_mode, pin_cfg);
        elink_set_cfg_pin(sc, pin_cfg, gpio_mode);
 }
@@ -7993,7 +8001,8 @@ static void elink_set_sfp_module_fault_led(struct elink_params *params,
                                           uint8_t gpio_mode)
 {
        struct bnx2x_softc *sc = params->sc;
-       PMD_DRV_LOG(DEBUG, "Setting SFP+ module fault LED to %d", gpio_mode);
+       PMD_DRV_LOG(DEBUG, sc,
+                   "Setting SFP+ module fault LED to %d", gpio_mode);
        if (CHIP_IS_E3(sc)) {
                /* Low ==> if SFP+ module is supported otherwise
                 * High ==> if SFP+ module is not on the approved vendor list
@@ -8020,7 +8029,7 @@ static void elink_warpcore_hw_reset(__rte_unused struct elink_phy *phy,
 static void elink_power_sfp_module(struct elink_params *params,
                                   struct elink_phy *phy, uint8_t power)
 {
-       PMD_DRV_LOG(DEBUG, "Setting SFP+ power to %x", power);
+       PMD_DRV_LOG(DEBUG, params->sc, "Setting SFP+ power to %x", power);
 
        switch (phy->type) {
        case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BNX2X8727:
@@ -8106,16 +8115,16 @@ static elink_status_t elink_sfp_module_detection(struct elink_phy *phy,
                                       config));
        /* Enabled transmitter by default */
        elink_sfp_set_transmitter(params, phy, 1);
-       PMD_DRV_LOG(DEBUG, "SFP+ module plugged in/out detected on port %d",
+       PMD_DRV_LOG(DEBUG, sc, "SFP+ module plugged in/out detected on port %d",
                    params->port);
        /* Power up module */
        elink_power_sfp_module(params, phy, 1);
        if (elink_get_edc_mode(phy, params, &edc_mode) != 0) {
-               PMD_DRV_LOG(DEBUG, "Failed to get valid module type");
+               PMD_DRV_LOG(DEBUG, sc, "Failed to get valid module type");
                return ELINK_STATUS_ERROR;
        } else if (elink_verify_sfp_module(phy, params) != 0) {
                /* Check SFP+ module compatibility */
-               PMD_DRV_LOG(DEBUG, "Module verification failed!!");
+               PMD_DRV_LOG(DEBUG, sc, "Module verification failed!!");
                rc = ELINK_STATUS_ERROR;
                /* Turn on fault module-detected led */
                elink_set_sfp_module_fault_led(params,
@@ -8124,7 +8133,7 @@ static elink_status_t elink_sfp_module_detection(struct elink_phy *phy,
                /* Check if need to power down the SFP+ module */
                if ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
                    PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_POWER_DOWN) {
-                       PMD_DRV_LOG(DEBUG, "Shutdown SFP+ module!!");
+                       PMD_DRV_LOG(DEBUG, sc, "Shutdown SFP+ module!!");
                        elink_power_sfp_module(params, phy, 0);
                        return rc;
                }
@@ -8165,7 +8174,7 @@ void elink_handle_module_detect_int(struct elink_params *params)
        if (elink_get_mod_abs_int_cfg(sc, params->shmem_base,
                                      params->port, &gpio_num, &gpio_port) ==
            ELINK_STATUS_ERROR) {
-               PMD_DRV_LOG(DEBUG, "Failed to get MOD_ABS interrupt config");
+               PMD_DRV_LOG(DEBUG, sc, "Failed to get MOD_ABS interrupt config");
                return;
        }
 
@@ -8205,7 +8214,7 @@ void elink_handle_module_detect_int(struct elink_params *params)
                                }
                        }
                } else {
-                       PMD_DRV_LOG(DEBUG, "SFP+ module is not initialized");
+                       PMD_DRV_LOG(DEBUG, sc, "SFP+ module is not initialized");
                }
        } else {
                elink_cb_gpio_int_write(sc, gpio_num,
@@ -8250,7 +8259,7 @@ static uint8_t elink_8706_8726_read_status(struct elink_phy *phy,
        uint8_t link_up = 0;
        uint16_t val1, val2, rx_sd, pcs_status;
        struct bnx2x_softc *sc = params->sc;
-       PMD_DRV_LOG(DEBUG, "XGXS 8706/8726");
+       PMD_DRV_LOG(DEBUG, sc, "XGXS 8706/8726");
        /* Clear RX Alarm */
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_RXSTAT, &val2);
 
@@ -8260,7 +8269,8 @@ static uint8_t elink_8706_8726_read_status(struct elink_phy *phy,
        /* Clear LASI indication */
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_STAT, &val1);
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_STAT, &val2);
-       PMD_DRV_LOG(DEBUG, "8706/8726 LASI status 0x%x--> 0x%x", val1, val2);
+       PMD_DRV_LOG(DEBUG, sc,
+                   "8706/8726 LASI status 0x%x--> 0x%x", val1, val2);
 
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_SD, &rx_sd);
        elink_cl45_read(sc, phy,
@@ -8268,7 +8278,7 @@ static uint8_t elink_8706_8726_read_status(struct elink_phy *phy,
        elink_cl45_read(sc, phy, MDIO_AN_DEVAD, MDIO_AN_REG_LINK_STATUS, &val2);
        elink_cl45_read(sc, phy, MDIO_AN_DEVAD, MDIO_AN_REG_LINK_STATUS, &val2);
 
-       PMD_DRV_LOG(DEBUG, "8706/8726 rx_sd 0x%x pcs_status 0x%x 1Gbps"
+       PMD_DRV_LOG(DEBUG, sc, "8706/8726 rx_sd 0x%x pcs_status 0x%x 1Gbps"
                    " link_status 0x%x", rx_sd, pcs_status, val2);
        /* Link is up if both bit 0 of pmd_rx_sd and bit 0 of pcs_status
         * are set, or if the autoneg bit 1 is set
@@ -8322,7 +8332,7 @@ static uint8_t elink_8706_config_init(struct elink_phy *phy,
                        break;
                DELAY(1000 * 10);
        }
-       PMD_DRV_LOG(DEBUG, "XGXS 8706 is initialized after %d ms", cnt);
+       PMD_DRV_LOG(DEBUG, sc, "XGXS 8706 is initialized after %d ms", cnt);
        if ((params->feature_config_flags &
             ELINK_FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED)) {
                uint8_t i;
@@ -8336,14 +8346,14 @@ static uint8_t elink_8706_config_init(struct elink_phy *phy,
                        val &= ~0x7;
                        /* Set control bits according to configuration */
                        val |= (phy->rx_preemphasis[i] & 0x7);
-                       PMD_DRV_LOG(DEBUG, "Setting RX Equalizer to BNX2X8706"
+                       PMD_DRV_LOG(DEBUG, sc, "Setting RX Equalizer to BNX2X8706"
                                    " reg 0x%x <-- val 0x%x", reg, val);
                        elink_cl45_write(sc, phy, MDIO_XS_DEVAD, reg, val);
                }
        }
        /* Force speed */
        if (phy->req_line_speed == ELINK_SPEED_10000) {
-               PMD_DRV_LOG(DEBUG, "XGXS 8706 force 10Gbps");
+               PMD_DRV_LOG(DEBUG, sc, "XGXS 8706 force 10Gbps");
 
                elink_cl45_write(sc, phy,
                                 MDIO_PMA_DEVAD,
@@ -8357,7 +8367,7 @@ static uint8_t elink_8706_config_init(struct elink_phy *phy,
                /* Force 1Gbps using autoneg with 1G advertisement */
 
                /* Allow CL37 through CL73 */
-               PMD_DRV_LOG(DEBUG, "XGXS 8706 AutoNeg");
+               PMD_DRV_LOG(DEBUG, sc, "XGXS 8706 AutoNeg");
                elink_cl45_write(sc, phy,
                                 MDIO_AN_DEVAD, MDIO_AN_REG_CL37_CL73, 0x040c);
 
@@ -8392,7 +8402,7 @@ static uint8_t elink_8706_config_init(struct elink_phy *phy,
        & PORT_HW_CFG_TX_LASER_MASK;
 
        if (tx_en_mode == PORT_HW_CFG_TX_LASER_GPIO0) {
-               PMD_DRV_LOG(DEBUG, "Enabling TXONOFF_PWRDN_DIS");
+               PMD_DRV_LOG(DEBUG, sc, "Enabling TXONOFF_PWRDN_DIS");
                elink_cl45_read(sc, phy,
                                MDIO_PMA_DEVAD, MDIO_PMA_REG_DIGITAL_CTRL,
                                &tmp1);
@@ -8419,7 +8429,7 @@ static void elink_8726_config_loopback(struct elink_phy *phy,
                                       struct elink_params *params)
 {
        struct bnx2x_softc *sc = params->sc;
-       PMD_DRV_LOG(DEBUG, "PMA/PMD ext_phy_loopback: 8726");
+       PMD_DRV_LOG(DEBUG, sc, "PMA/PMD ext_phy_loopback: 8726");
        elink_cl45_write(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 0x0001);
 }
 
@@ -8471,7 +8481,7 @@ static uint8_t elink_8726_read_status(struct elink_phy *phy,
                                MDIO_PMA_DEVAD, MDIO_PMA_REG_PHY_IDENTIFIER,
                                &val1);
                if (val1 & (1 << 15)) {
-                       PMD_DRV_LOG(DEBUG, "Tx is disabled");
+                       PMD_DRV_LOG(DEBUG, sc, "Tx is disabled");
                        link_up = 0;
                        vars->line_speed = 0;
                }
@@ -8484,7 +8494,7 @@ static uint8_t elink_8726_config_init(struct elink_phy *phy,
                                      struct elink_vars *vars)
 {
        struct bnx2x_softc *sc = params->sc;
-       PMD_DRV_LOG(DEBUG, "Initializing BNX2X8726");
+       PMD_DRV_LOG(DEBUG, sc, "Initializing BNX2X8726");
 
        elink_cl45_write(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 1 << 15);
        elink_wait_reset_complete(sc, phy, params);
@@ -8499,7 +8509,7 @@ static uint8_t elink_8726_config_init(struct elink_phy *phy,
        elink_sfp_module_detection(phy, params);
 
        if (phy->req_line_speed == ELINK_SPEED_1000) {
-               PMD_DRV_LOG(DEBUG, "Setting 1G force");
+               PMD_DRV_LOG(DEBUG, sc, "Setting 1G force");
                elink_cl45_write(sc, phy,
                                 MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 0x40);
                elink_cl45_write(sc, phy,
@@ -8514,7 +8524,7 @@ static uint8_t elink_8726_config_init(struct elink_phy *phy,
                   ((phy->speed_cap_mask &
                     PORT_HW_CFG_SPEED_CAPABILITY_D0_10G) !=
                    PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)) {
-               PMD_DRV_LOG(DEBUG, "Setting 1G clause37");
+               PMD_DRV_LOG(DEBUG, sc, "Setting 1G clause37");
                /* Set Flow control */
                elink_ext_phy_set_pause(params, phy, vars);
                elink_cl45_write(sc, phy, MDIO_AN_DEVAD, MDIO_AN_REG_ADV, 0x20);
@@ -8542,7 +8552,7 @@ static uint8_t elink_8726_config_init(struct elink_phy *phy,
        /* Set TX PreEmphasis if needed */
        if ((params->feature_config_flags &
             ELINK_FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED)) {
-               PMD_DRV_LOG(DEBUG,
+               PMD_DRV_LOG(DEBUG, sc,
                            "Setting TX_CTRL1 0x%x, TX_CTRL2 0x%x",
                            phy->tx_preemphasis[0], phy->tx_preemphasis[1]);
                elink_cl45_write(sc, phy,
@@ -8564,7 +8574,7 @@ static void elink_8726_link_reset(struct elink_phy *phy,
                                  struct elink_params *params)
 {
        struct bnx2x_softc *sc = params->sc;
-       PMD_DRV_LOG(DEBUG, "elink_8726_link_reset port %d", params->port);
+       PMD_DRV_LOG(DEBUG, sc, "elink_8726_link_reset port %d", params->port);
        /* Set serial boot control for external load */
        elink_cl45_write(sc, phy,
                         MDIO_PMA_DEVAD, MDIO_PMA_REG_GEN_CTRL, 0x0001);
@@ -8637,14 +8647,14 @@ static void elink_8727_config_speed(struct elink_phy *phy,
        /* Set option 1G speed */
        if ((phy->req_line_speed == ELINK_SPEED_1000) ||
            (phy->media_type == ELINK_ETH_PHY_SFP_1G_FIBER)) {
-               PMD_DRV_LOG(DEBUG, "Setting 1G force");
+               PMD_DRV_LOG(DEBUG, sc, "Setting 1G force");
                elink_cl45_write(sc, phy,
                                 MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 0x40);
                elink_cl45_write(sc, phy,
                                 MDIO_PMA_DEVAD, MDIO_PMA_REG_10G_CTRL2, 0xD);
                elink_cl45_read(sc, phy,
                                MDIO_PMA_DEVAD, MDIO_PMA_REG_10G_CTRL2, &tmp1);
-               PMD_DRV_LOG(DEBUG, "1.7 = 0x%x", tmp1);
+               PMD_DRV_LOG(DEBUG, sc, "1.7 = 0x%x", tmp1);
                /* Power down the XAUI until link is up in case of dual-media
                 * and 1G
                 */
@@ -8664,7 +8674,7 @@ static void elink_8727_config_speed(struct elink_phy *phy,
                     PORT_HW_CFG_SPEED_CAPABILITY_D0_10G) !=
                    PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)) {
 
-               PMD_DRV_LOG(DEBUG, "Setting 1G clause37");
+               PMD_DRV_LOG(DEBUG, sc, "Setting 1G clause37");
                elink_cl45_write(sc, phy,
                                 MDIO_AN_DEVAD, MDIO_AN_REG_8727_MISC_CTRL, 0);
                elink_cl45_write(sc, phy,
@@ -8698,7 +8708,7 @@ static uint8_t elink_8727_config_init(struct elink_phy *phy,
 
        elink_wait_reset_complete(sc, phy, params);
 
-       PMD_DRV_LOG(DEBUG, "Initializing BNX2X8727");
+       PMD_DRV_LOG(DEBUG, sc, "Initializing BNX2X8727");
 
        elink_8727_specific_func(phy, params, ELINK_PHY_INIT);
        /* Initially configure MOD_ABS to interrupt when module is
@@ -8731,7 +8741,7 @@ static uint8_t elink_8727_config_init(struct elink_phy *phy,
        /* Set TX PreEmphasis if needed */
        if ((params->feature_config_flags &
             ELINK_FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED)) {
-               PMD_DRV_LOG(DEBUG, "Setting TX_CTRL1 0x%x, TX_CTRL2 0x%x",
+               PMD_DRV_LOG(DEBUG, sc, "Setting TX_CTRL1 0x%x, TX_CTRL2 0x%x",
                            phy->tx_preemphasis[0], phy->tx_preemphasis[1]);
                elink_cl45_write(sc, phy,
                                 MDIO_PMA_DEVAD, MDIO_PMA_REG_8727_TX_CTRL1,
@@ -8753,7 +8763,7 @@ static uint8_t elink_8727_config_init(struct elink_phy *phy,
 
        if (tx_en_mode == PORT_HW_CFG_TX_LASER_GPIO0) {
 
-               PMD_DRV_LOG(DEBUG, "Enabling TXONOFF_PWRDN_DIS");
+               PMD_DRV_LOG(DEBUG, sc, "Enabling TXONOFF_PWRDN_DIS");
                elink_cl45_read(sc, phy,
                                MDIO_PMA_DEVAD, MDIO_PMA_REG_8727_OPT_CFG_REG,
                                &tmp2);
@@ -8785,7 +8795,7 @@ static void elink_8727_handle_mod_abs(struct elink_phy *phy,
        if (mod_abs & (1 << 8)) {
 
                /* Module is absent */
-               PMD_DRV_LOG(DEBUG, "MOD_ABS indication show module is absent");
+               PMD_DRV_LOG(DEBUG, sc, "MOD_ABS indication show module is absent");
                phy->media_type = ELINK_ETH_PHY_NOT_PRESENT;
                /* 1. Set mod_abs to detect next module
                 *    presence event
@@ -8810,7 +8820,7 @@ static void elink_8727_handle_mod_abs(struct elink_phy *phy,
 
        } else {
                /* Module is present */
-               PMD_DRV_LOG(DEBUG, "MOD_ABS indication show module is present");
+               PMD_DRV_LOG(DEBUG, sc, "MOD_ABS indication show module is present");
                /* First disable transmitter, and if the module is ok, the
                 * module_detection will enable it
                 * 1. Set mod_abs to detect next module absent event ( bit 8)
@@ -8841,14 +8851,14 @@ static void elink_8727_handle_mod_abs(struct elink_phy *phy,
                if (elink_wait_for_sfp_module_initialized(phy, params) == 0) {
                        elink_sfp_module_detection(phy, params);
                } else {
-                       PMD_DRV_LOG(DEBUG, "SFP+ module is not initialized");
+                       PMD_DRV_LOG(DEBUG, sc, "SFP+ module is not initialized");
                }
 
                /* Reconfigure link speed based on module type limitations */
                elink_8727_config_speed(phy, params);
        }
 
-       PMD_DRV_LOG(DEBUG, "8727 RX_ALARM_STATUS 0x%x", rx_alarm_status);
+       PMD_DRV_LOG(DEBUG, sc, "8727 RX_ALARM_STATUS 0x%x", rx_alarm_status);
        /* No need to check link status in case of module plugged in/out */
 }
 
@@ -8871,14 +8881,14 @@ static uint8_t elink_8727_read_status(struct elink_phy *phy,
        elink_cl45_read(sc, phy,
                        MDIO_PMA_DEVAD, MDIO_PMA_LASI_RXSTAT, &rx_alarm_status);
        vars->line_speed = 0;
-       PMD_DRV_LOG(DEBUG, "8727 RX_ALARM_STATUS  0x%x", rx_alarm_status);
+       PMD_DRV_LOG(DEBUG, sc, "8727 RX_ALARM_STATUS  0x%x", rx_alarm_status);
 
        elink_sfp_mask_fault(sc, phy, MDIO_PMA_LASI_TXSTAT,
                             MDIO_PMA_LASI_TXCTRL);
 
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_STAT, &val1);
 
-       PMD_DRV_LOG(DEBUG, "8727 LASI status 0x%x", val1);
+       PMD_DRV_LOG(DEBUG, sc, "8727 LASI status 0x%x", val1);
 
        /* Clear MSG-OUT */
        elink_cl45_read(sc, phy,
@@ -8896,7 +8906,7 @@ static uint8_t elink_8727_read_status(struct elink_phy *phy,
                if ((val1 & (1 << 8)) == 0) {
                        if (!CHIP_IS_E1x(sc))
                                oc_port = SC_PATH(sc) + (params->port << 1);
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                                    "8727 Power fault has been detected on port %d",
                                    oc_port);
                        elink_cb_event_log(sc, ELINK_LOG_ID_OVER_CURRENT, oc_port);     //"Error: Power fault on Port %d has "
@@ -8939,10 +8949,10 @@ static uint8_t elink_8727_read_status(struct elink_phy *phy,
        }
 
        if (!(phy->flags & ELINK_FLAGS_SFP_NOT_APPROVED)) {
-               PMD_DRV_LOG(DEBUG, "Enabling 8727 TX laser");
+               PMD_DRV_LOG(DEBUG, sc, "Enabling 8727 TX laser");
                elink_sfp_set_transmitter(params, phy, 1);
        } else {
-               PMD_DRV_LOG(DEBUG, "Tx is disabled");
+               PMD_DRV_LOG(DEBUG, sc, "Tx is disabled");
                return 0;
        }
 
@@ -8956,16 +8966,16 @@ static uint8_t elink_8727_read_status(struct elink_phy *phy,
        if ((link_status & (1 << 2)) && (!(link_status & (1 << 15)))) {
                link_up = 1;
                vars->line_speed = ELINK_SPEED_10000;
-               PMD_DRV_LOG(DEBUG, "port %x: External link up in 10G",
+               PMD_DRV_LOG(DEBUG, sc, "port %x: External link up in 10G",
                            params->port);
        } else if ((link_status & (1 << 0)) && (!(link_status & (1 << 13)))) {
                link_up = 1;
                vars->line_speed = ELINK_SPEED_1000;
-               PMD_DRV_LOG(DEBUG, "port %x: External link up in 1G",
+               PMD_DRV_LOG(DEBUG, sc, "port %x: External link up in 1G",
                            params->port);
        } else {
                link_up = 0;
-               PMD_DRV_LOG(DEBUG, "port %x: External link is down",
+               PMD_DRV_LOG(DEBUG, sc, "port %x: External link is down",
                            params->port);
        }
 
@@ -8985,7 +8995,7 @@ static uint8_t elink_8727_read_status(struct elink_phy *phy,
        if (link_up) {
                elink_ext_phy_resolve_fc(phy, params, vars);
                vars->duplex = DUPLEX_FULL;
-               PMD_DRV_LOG(DEBUG, "duplex = 0x%x", vars->duplex);
+               PMD_DRV_LOG(DEBUG, sc, "duplex = 0x%x", vars->duplex);
        }
 
        if ((ELINK_DUAL_MEDIA(params)) &&
@@ -9057,7 +9067,7 @@ static void elink_save_848xx_spirom_version(struct elink_phy *phy,
                        DELAY(5);
                }
                if (cnt == 100) {
-                       PMD_DRV_LOG(DEBUG, "Unable to read 848xx "
+                       PMD_DRV_LOG(DEBUG, sc, "Unable to read 848xx "
                                    "phy fw version(1)");
                        elink_save_spirom_version(sc, port, 0, phy->ver_addr);
                        return;
@@ -9074,7 +9084,7 @@ static void elink_save_848xx_spirom_version(struct elink_phy *phy,
                        DELAY(5);
                }
                if (cnt == 100) {
-                       PMD_DRV_LOG(DEBUG, "Unable to read 848xx phy fw "
+                       PMD_DRV_LOG(DEBUG, sc, "Unable to read 848xx phy fw "
                                    "version(2)");
                        elink_save_spirom_version(sc, port, 0, phy->ver_addr);
                        return;
@@ -9187,7 +9197,7 @@ static elink_status_t elink_848xx_cmn_config_init(struct elink_phy *phy,
                autoneg_val |= (1 << 9 | 1 << 12);
                if (phy->req_duplex == DUPLEX_FULL)
                        an_1000_val |= (1 << 9);
-               PMD_DRV_LOG(DEBUG, "Advertising 1G");
+               PMD_DRV_LOG(DEBUG, sc, "Advertising 1G");
        } else
                an_1000_val &= ~((1 << 8) | (1 << 9));
 
@@ -9203,7 +9213,7 @@ static elink_status_t elink_848xx_cmn_config_init(struct elink_phy *phy,
                         */
                        autoneg_val |= (1 << 9 | 1 << 12);
                        an_10_100_val |= (1 << 8);
-                       PMD_DRV_LOG(DEBUG, "Advertising 100M-FD");
+                       PMD_DRV_LOG(DEBUG, sc, "Advertising 100M-FD");
                }
 
                if (phy->speed_cap_mask &
@@ -9212,7 +9222,7 @@ static elink_status_t elink_848xx_cmn_config_init(struct elink_phy *phy,
                         */
                        autoneg_val |= (1 << 9 | 1 << 12);
                        an_10_100_val |= (1 << 7);
-                       PMD_DRV_LOG(DEBUG, "Advertising 100M-HD");
+                       PMD_DRV_LOG(DEBUG, sc, "Advertising 100M-HD");
                }
 
                if ((phy->speed_cap_mask &
@@ -9220,7 +9230,7 @@ static elink_status_t elink_848xx_cmn_config_init(struct elink_phy *phy,
                    (phy->supported & ELINK_SUPPORTED_10baseT_Full)) {
                        an_10_100_val |= (1 << 6);
                        autoneg_val |= (1 << 9 | 1 << 12);
-                       PMD_DRV_LOG(DEBUG, "Advertising 10M-FD");
+                       PMD_DRV_LOG(DEBUG, sc, "Advertising 10M-FD");
                }
 
                if ((phy->speed_cap_mask &
@@ -9228,7 +9238,7 @@ static elink_status_t elink_848xx_cmn_config_init(struct elink_phy *phy,
                    (phy->supported & ELINK_SUPPORTED_10baseT_Half)) {
                        an_10_100_val |= (1 << 5);
                        autoneg_val |= (1 << 9 | 1 << 12);
-                       PMD_DRV_LOG(DEBUG, "Advertising 10M-HD");
+                       PMD_DRV_LOG(DEBUG, sc, "Advertising 10M-HD");
                }
        }
 
@@ -9243,7 +9253,7 @@ static elink_status_t elink_848xx_cmn_config_init(struct elink_phy *phy,
                                 (1 << 15 | 1 << 9 | 7 << 0));
                /* The PHY needs this set even for forced link. */
                an_10_100_val |= (1 << 8) | (1 << 7);
-               PMD_DRV_LOG(DEBUG, "Setting 100M force");
+               PMD_DRV_LOG(DEBUG, sc, "Setting 100M force");
        }
        if ((phy->req_line_speed == ELINK_SPEED_10) &&
            (phy->supported &
@@ -9252,7 +9262,7 @@ static elink_status_t elink_848xx_cmn_config_init(struct elink_phy *phy,
                elink_cl45_write(sc, phy,
                                 MDIO_AN_DEVAD, MDIO_AN_REG_8481_AUX_CTRL,
                                 (1 << 15 | 1 << 9 | 7 << 0));
-               PMD_DRV_LOG(DEBUG, "Setting 10M force");
+               PMD_DRV_LOG(DEBUG, sc, "Setting 10M force");
        }
 
        elink_cl45_write(sc, phy,
@@ -9276,7 +9286,7 @@ static elink_status_t elink_848xx_cmn_config_init(struct elink_phy *phy,
             (phy->speed_cap_mask &
              PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)) ||
            (phy->req_line_speed == ELINK_SPEED_10000)) {
-               PMD_DRV_LOG(DEBUG, "Advertising 10G");
+               PMD_DRV_LOG(DEBUG, sc, "Advertising 10G");
                /* Restart autoneg for 10G */
 
                elink_cl45_read_or_write(sc, phy,
@@ -9332,7 +9342,7 @@ static elink_status_t elink_84833_cmd_hdlr(struct elink_phy *phy,
                DELAY(1000 * 1);
        }
        if (idx >= PHY84833_CMDHDLR_WAIT) {
-               PMD_DRV_LOG(DEBUG, "FW cmd: FW not ready.");
+               PMD_DRV_LOG(DEBUG, sc, "FW cmd: FW not ready.");
                return ELINK_STATUS_ERROR;
        }
 
@@ -9354,7 +9364,7 @@ static elink_status_t elink_84833_cmd_hdlr(struct elink_phy *phy,
        }
        if ((idx >= PHY84833_CMDHDLR_WAIT) ||
            (val == PHY84833_STATUS_CMD_COMPLETE_ERROR)) {
-               PMD_DRV_LOG(DEBUG, "FW cmd failed.");
+               PMD_DRV_LOG(DEBUG, sc, "FW cmd failed.");
                return ELINK_STATUS_ERROR;
        }
        /* Gather returning data */
@@ -9396,7 +9406,7 @@ static elink_status_t elink_84833_pair_swap_cfg(struct elink_phy *phy,
                                      PHY84833_CMD_SET_PAIR_SWAP, data,
                                      PHY84833_CMDHDLR_MAX_ARGS);
        if (status == ELINK_STATUS_OK) {
-               PMD_DRV_LOG(DEBUG, "Pairswap OK, val=0x%x", data[1]);
+               PMD_DRV_LOG(DEBUG, sc, "Pairswap OK, val=0x%x", data[1]);
        }
 
        return status;
@@ -9472,7 +9482,8 @@ static void elink_84833_hw_reset_phy(struct elink_phy *phy,
        elink_cb_gpio_mult_write(sc, reset_gpios,
                                 MISC_REGISTERS_GPIO_OUTPUT_LOW);
        DELAY(10);
-       PMD_DRV_LOG(DEBUG, "84833 hw reset on pin values 0x%x", reset_gpios);
+       PMD_DRV_LOG(DEBUG, sc,
+                   "84833 hw reset on pin values 0x%x", reset_gpios);
 }
 
 static elink_status_t elink_8483x_disable_eee(struct elink_phy *phy,
@@ -9482,13 +9493,13 @@ static elink_status_t elink_8483x_disable_eee(struct elink_phy *phy,
        elink_status_t rc;
        uint16_t cmd_args = 0;
 
-       PMD_DRV_LOG(DEBUG, "Don't Advertise 10GBase-T EEE");
+       PMD_DRV_LOG(DEBUG, params->sc, "Don't Advertise 10GBase-T EEE");
 
        /* Prevent Phy from working in EEE and advertising it */
        rc = elink_84833_cmd_hdlr(phy, params,
                                  PHY84833_CMD_SET_EEE_MODE, &cmd_args, 1);
        if (rc != ELINK_STATUS_OK) {
-               PMD_DRV_LOG(DEBUG, "EEE disable failed.");
+               PMD_DRV_LOG(DEBUG, params->sc, "EEE disable failed.");
                return rc;
        }
 
@@ -9505,7 +9516,7 @@ static elink_status_t elink_8483x_enable_eee(struct elink_phy *phy,
        rc = elink_84833_cmd_hdlr(phy, params,
                                  PHY84833_CMD_SET_EEE_MODE, &cmd_args, 1);
        if (rc != ELINK_STATUS_OK) {
-               PMD_DRV_LOG(DEBUG, "EEE enable failed.");
+               PMD_DRV_LOG(DEBUG, params->sc, "EEE enable failed.");
                return rc;
        }
 
@@ -9598,7 +9609,7 @@ static uint8_t elink_848x3_config_init(struct elink_phy *phy,
 
        elink_cl45_write(sc, phy, MDIO_CTL_DEVAD,
                         MDIO_CTL_REG_84823_MEDIA, val);
-       PMD_DRV_LOG(DEBUG, "Multi_phy config = 0x%x, Media control = 0x%x",
+       PMD_DRV_LOG(DEBUG, sc, "Multi_phy config = 0x%x, Media control = 0x%x",
                    params->multi_phy_config, val);
 
        if ((phy->type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BNX2X84833) ||
@@ -9614,7 +9625,7 @@ static uint8_t elink_848x3_config_init(struct elink_phy *phy,
                                          PHY84833_CMD_SET_EEE_MODE, cmd_args,
                                          PHY84833_CMDHDLR_MAX_ARGS);
                if (rc != ELINK_STATUS_OK) {
-                       PMD_DRV_LOG(DEBUG, "Cfg AutogrEEEn failed.");
+                       PMD_DRV_LOG(DEBUG, sc, "Cfg AutogrEEEn failed.");
                }
        }
        if (initialize) {
@@ -9651,7 +9662,7 @@ static uint8_t elink_848x3_config_init(struct elink_phy *phy,
            elink_eee_has_cap(params)) {
                rc = elink_eee_initial_config(params, vars, SHMEM_EEE_10G_ADV);
                if (rc != ELINK_STATUS_OK) {
-                       PMD_DRV_LOG(DEBUG, "Failed to configure EEE timers");
+                       PMD_DRV_LOG(DEBUG, sc, "Failed to configure EEE timers");
                        elink_8483x_disable_eee(phy, params, vars);
                        return rc;
                }
@@ -9664,7 +9675,7 @@ static uint8_t elink_848x3_config_init(struct elink_phy *phy,
                else
                        rc = elink_8483x_disable_eee(phy, params, vars);
                if (rc != ELINK_STATUS_OK) {
-                       PMD_DRV_LOG(DEBUG, "Failed to set EEE advertisement");
+                       PMD_DRV_LOG(DEBUG, sc, "Failed to set EEE advertisement");
                        return rc;
                }
        } else {
@@ -9696,7 +9707,7 @@ static uint8_t elink_848xx_read_status(struct elink_phy *phy,
        elink_cl45_read(sc, phy, MDIO_AN_DEVAD, 0xFFFA, &val1);
        elink_cl45_read(sc, phy,
                        MDIO_PMA_DEVAD, MDIO_PMA_REG_8481_PMD_SIGNAL, &val2);
-       PMD_DRV_LOG(DEBUG, "BNX2X848xx: PMD_SIGNAL 1.a811 = 0x%x", val2);
+       PMD_DRV_LOG(DEBUG, sc, "BNX2X848xx: PMD_SIGNAL 1.a811 = 0x%x", val2);
 
        /* Check link 10G */
        if (val2 & (1 << 11)) {
@@ -9718,7 +9729,8 @@ static uint8_t elink_848xx_read_status(struct elink_phy *phy,
                                MDIO_AN_REG_8481_EXPANSION_REG_RD_RW,
                                &legacy_status);
 
-               PMD_DRV_LOG(DEBUG, "Legacy speed status = 0x%x", legacy_status);
+               PMD_DRV_LOG(DEBUG, sc,
+                           "Legacy speed status = 0x%x", legacy_status);
                link_up = ((legacy_status & (1 << 11)) == (1 << 11));
                legacy_speed = (legacy_status & (3 << 9));
                if (legacy_speed == (0 << 9))
@@ -9748,7 +9760,7 @@ static uint8_t elink_848xx_read_status(struct elink_phy *phy,
                        else
                                vars->duplex = DUPLEX_HALF;
 
-                       PMD_DRV_LOG(DEBUG,
+                       PMD_DRV_LOG(DEBUG, sc,
                                    "Link is up in %dMbps, is_duplex_full= %d",
                                    vars->line_speed,
                                    (vars->duplex == DUPLEX_FULL));
@@ -9770,7 +9782,7 @@ static uint8_t elink_848xx_read_status(struct elink_phy *phy,
                }
        }
        if (link_up) {
-               PMD_DRV_LOG(DEBUG, "BNX2X848x3: link speed is %d",
+               PMD_DRV_LOG(DEBUG, sc, "BNX2X848x3: link speed is %d",
                            vars->line_speed);
                elink_ext_phy_resolve_fc(phy, params, vars);
 
@@ -9887,7 +9899,7 @@ static void elink_848xx_set_link_led(struct elink_phy *phy,
        switch (mode) {
        case ELINK_LED_MODE_OFF:
 
-               PMD_DRV_LOG(DEBUG, "Port 0x%x: LED MODE OFF", port);
+               PMD_DRV_LOG(DEBUG, sc, "Port 0x%x: LED MODE OFF", port);
 
                if ((params->hw_led_mode << SHARED_HW_CFG_LED_MODE_SHIFT) ==
                    SHARED_HW_CFG_LED_EXTPHY1) {
@@ -9917,7 +9929,8 @@ static void elink_848xx_set_link_led(struct elink_phy *phy,
                break;
        case ELINK_LED_MODE_FRONT_PANEL_OFF:
 
-               PMD_DRV_LOG(DEBUG, "Port 0x%x: LED MODE FRONT PANEL OFF", port);
+               PMD_DRV_LOG(DEBUG, sc,
+                           "Port 0x%x: LED MODE FRONT PANEL OFF", port);
 
                if ((params->hw_led_mode << SHARED_HW_CFG_LED_MODE_SHIFT) ==
                    SHARED_HW_CFG_LED_EXTPHY1) {
@@ -9967,7 +9980,7 @@ static void elink_848xx_set_link_led(struct elink_phy *phy,
                break;
        case ELINK_LED_MODE_ON:
 
-               PMD_DRV_LOG(DEBUG, "Port 0x%x: LED MODE ON", port);
+               PMD_DRV_LOG(DEBUG, sc, "Port 0x%x: LED MODE ON", port);
 
                if ((params->hw_led_mode << SHARED_HW_CFG_LED_MODE_SHIFT) ==
                    SHARED_HW_CFG_LED_EXTPHY1) {
@@ -10027,7 +10040,7 @@ static void elink_848xx_set_link_led(struct elink_phy *phy,
 
        case ELINK_LED_MODE_OPER:
 
-               PMD_DRV_LOG(DEBUG, "Port 0x%x: LED MODE OPER", port);
+               PMD_DRV_LOG(DEBUG, sc, "Port 0x%x: LED MODE OPER", port);
 
                if ((params->hw_led_mode << SHARED_HW_CFG_LED_MODE_SHIFT) ==
                    SHARED_HW_CFG_LED_EXTPHY1) {
@@ -10042,7 +10055,7 @@ static void elink_848xx_set_link_led(struct elink_phy *phy,
                              >>
                              MDIO_PMA_REG_8481_LINK_SIGNAL_LED4_ENABLE_SHIFT))
                        {
-                               PMD_DRV_LOG(DEBUG, "Setting LINK_SIGNAL");
+                               PMD_DRV_LOG(DEBUG, sc, "Setting LINK_SIGNAL");
                                elink_cl45_write(sc, phy,
                                                 MDIO_PMA_DEVAD,
                                                 MDIO_PMA_REG_8481_LINK_SIGNAL,
@@ -10155,7 +10168,7 @@ static uint8_t elink_54618se_config_init(struct elink_phy *phy,
        uint16_t autoneg_val, an_1000_val, an_10_100_val, fc_val, temp;
        uint32_t cfg_pin;
 
-       PMD_DRV_LOG(DEBUG, "54618SE cfg init");
+       PMD_DRV_LOG(DEBUG, sc, "54618SE cfg init");
        DELAY(1000 * 1);
 
        /* This works with E3 only, no need to check the chip
@@ -10228,7 +10241,7 @@ static uint8_t elink_54618se_config_init(struct elink_phy *phy,
                autoneg_val |= (1 << 9 | 1 << 12);
                if (phy->req_duplex == DUPLEX_FULL)
                        an_1000_val |= (1 << 9);
-               PMD_DRV_LOG(DEBUG, "Advertising 1G");
+               PMD_DRV_LOG(DEBUG, sc, "Advertising 1G");
        } else
                an_1000_val &= ~((1 << 8) | (1 << 9));
 
@@ -10241,25 +10254,25 @@ static uint8_t elink_54618se_config_init(struct elink_phy *phy,
                    PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF) {
                        an_10_100_val |= (1 << 5);
                        autoneg_val |= (1 << 9 | 1 << 12);
-                       PMD_DRV_LOG(DEBUG, "Advertising 10M-HD");
+                       PMD_DRV_LOG(DEBUG, sc, "Advertising 10M-HD");
                }
                if (phy->speed_cap_mask &
                    PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF) {
                        an_10_100_val |= (1 << 6);
                        autoneg_val |= (1 << 9 | 1 << 12);
-                       PMD_DRV_LOG(DEBUG, "Advertising 10M-FD");
+                       PMD_DRV_LOG(DEBUG, sc, "Advertising 10M-FD");
                }
                if (phy->speed_cap_mask &
                    PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_HALF) {
                        an_10_100_val |= (1 << 7);
                        autoneg_val |= (1 << 9 | 1 << 12);
-                       PMD_DRV_LOG(DEBUG, "Advertising 100M-HD");
+                       PMD_DRV_LOG(DEBUG, sc, "Advertising 100M-HD");
                }
                if (phy->speed_cap_mask &
                    PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_FULL) {
                        an_10_100_val |= (1 << 8);
                        autoneg_val |= (1 << 9 | 1 << 12);
-                       PMD_DRV_LOG(DEBUG, "Advertising 100M-FD");
+                       PMD_DRV_LOG(DEBUG, sc, "Advertising 100M-FD");
                }
        }
 
@@ -10268,12 +10281,12 @@ static uint8_t elink_54618se_config_init(struct elink_phy *phy,
                autoneg_val |= (1 << 13);
                /* Enabled AUTO-MDIX when autoneg is disabled */
                elink_cl22_write(sc, phy, 0x18, (1 << 15 | 1 << 9 | 7 << 0));
-               PMD_DRV_LOG(DEBUG, "Setting 100M force");
+               PMD_DRV_LOG(DEBUG, sc, "Setting 100M force");
        }
        if (phy->req_line_speed == ELINK_SPEED_10) {
                /* Enabled AUTO-MDIX when autoneg is disabled */
                elink_cl22_write(sc, phy, 0x18, (1 << 15 | 1 << 9 | 7 << 0));
-               PMD_DRV_LOG(DEBUG, "Setting 10M force");
+               PMD_DRV_LOG(DEBUG, sc, "Setting 10M force");
        }
 
        if ((phy->flags & ELINK_FLAGS_EEE) && elink_eee_has_cap(params)) {
@@ -10288,7 +10301,7 @@ static uint8_t elink_54618se_config_init(struct elink_phy *phy,
 
                rc = elink_eee_initial_config(params, vars, SHMEM_EEE_1G_ADV);
                if (rc != ELINK_STATUS_OK) {
-                       PMD_DRV_LOG(DEBUG, "Failed to configure EEE timers");
+                       PMD_DRV_LOG(DEBUG, sc, "Failed to configure EEE timers");
                        elink_eee_disable(phy, params, vars);
                } else if ((params->eee_mode & ELINK_EEE_MODE_ADV_LPI) &&
                           (phy->req_duplex == DUPLEX_FULL) &&
@@ -10302,7 +10315,7 @@ static uint8_t elink_54618se_config_init(struct elink_phy *phy,
                        elink_eee_advertise(phy, params, vars,
                                            SHMEM_EEE_1G_ADV);
                } else {
-                       PMD_DRV_LOG(DEBUG, "Don't Advertise 1GBase-T EEE");
+                       PMD_DRV_LOG(DEBUG, sc, "Don't Advertise 1GBase-T EEE");
                        elink_eee_disable(phy, params, vars);
                }
        } else {
@@ -10314,10 +10327,10 @@ static uint8_t elink_54618se_config_init(struct elink_phy *phy,
                        if (params->feature_config_flags &
                            ELINK_FEATURE_CONFIG_AUTOGREEEN_ENABLED) {
                                temp = 6;
-                               PMD_DRV_LOG(DEBUG, "Enabling Auto-GrEEEn");
+                               PMD_DRV_LOG(DEBUG, sc, "Enabling Auto-GrEEEn");
                        } else {
                                temp = 0;
-                               PMD_DRV_LOG(DEBUG, "Don't Adv. EEE");
+                               PMD_DRV_LOG(DEBUG, sc, "Don't Adv. EEE");
                        }
                        elink_cl45_write(sc, phy, MDIO_AN_DEVAD,
                                         MDIO_AN_REG_EEE_ADV, temp);
@@ -10345,7 +10358,7 @@ static void elink_5461x_set_link_led(struct elink_phy *phy,
        elink_cl22_read(sc, phy, MDIO_REG_GPHY_SHADOW, &temp);
        temp &= 0xff00;
 
-       PMD_DRV_LOG(DEBUG, "54618x set link led (mode=%x)", mode);
+       PMD_DRV_LOG(DEBUG, sc, "54618x set link led (mode=%x)", mode);
        switch (mode) {
        case ELINK_LED_MODE_FRONT_PANEL_OFF:
        case ELINK_LED_MODE_OFF:
@@ -10403,7 +10416,7 @@ static uint8_t elink_54618se_read_status(struct elink_phy *phy,
 
        /* Get speed operation status */
        elink_cl22_read(sc, phy, MDIO_REG_GPHY_AUX_STATUS, &legacy_status);
-       PMD_DRV_LOG(DEBUG, "54618SE read_status: 0x%x", legacy_status);
+       PMD_DRV_LOG(DEBUG, sc, "54618SE read_status: 0x%x", legacy_status);
 
        /* Read status to clear the PHY interrupt. */
        elink_cl22_read(sc, phy, MDIO_REG_INTR_STATUS, &val);
@@ -10435,7 +10448,7 @@ static uint8_t elink_54618se_read_status(struct elink_phy *phy,
                } else          /* Should not happen */
                        vars->line_speed = 0;
 
-               PMD_DRV_LOG(DEBUG,
+               PMD_DRV_LOG(DEBUG, sc,
                            "Link is up in %dMbps, is_duplex_full= %d",
                            vars->line_speed, (vars->duplex == DUPLEX_FULL));
 
@@ -10449,7 +10462,7 @@ static uint8_t elink_54618se_read_status(struct elink_phy *phy,
                        vars->link_status |=
                            LINK_STATUS_PARALLEL_DETECTION_USED;
 
-               PMD_DRV_LOG(DEBUG, "BNX2X54618SE: link speed is %d",
+               PMD_DRV_LOG(DEBUG, sc, "BNX2X54618SE: link speed is %d",
                            vars->line_speed);
 
                elink_ext_phy_resolve_fc(phy, params, vars);
@@ -10497,7 +10510,7 @@ static void elink_54618se_config_loopback(struct elink_phy *phy,
        uint16_t val;
        uint32_t umac_base = params->port ? GRCBASE_UMAC1 : GRCBASE_UMAC0;
 
-       PMD_DRV_LOG(DEBUG, "2PMA/PMD ext_phy_loopback: 54618se");
+       PMD_DRV_LOG(DEBUG, sc, "2PMA/PMD ext_phy_loopback: 54618se");
 
        /* Enable master/slave manual mmode and set to master */
        /* mii write 9 [bits set 11 12] */
@@ -10548,7 +10561,7 @@ static uint8_t elink_7101_config_init(struct elink_phy *phy,
 {
        uint16_t fw_ver1, fw_ver2, val;
        struct bnx2x_softc *sc = params->sc;
-       PMD_DRV_LOG(DEBUG, "Setting the SFX7101 LASI indication");
+       PMD_DRV_LOG(DEBUG, sc, "Setting the SFX7101 LASI indication");
 
        /* Restore normal power mode */
        elink_cb_gpio_write(sc, MISC_REGISTERS_GPIO_2,
@@ -10558,7 +10571,7 @@ static uint8_t elink_7101_config_init(struct elink_phy *phy,
        elink_wait_reset_complete(sc, phy, params);
 
        elink_cl45_write(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_CTRL, 0x1);
-       PMD_DRV_LOG(DEBUG, "Setting the SFX7101 LED to blink on traffic");
+       PMD_DRV_LOG(DEBUG, sc, "Setting the SFX7101 LED to blink on traffic");
        elink_cl45_write(sc, phy,
                         MDIO_PMA_DEVAD, MDIO_PMA_REG_7107_LED_CNTL, (1 << 3));
 
@@ -10589,10 +10602,10 @@ static uint8_t elink_7101_read_status(struct elink_phy *phy,
        uint16_t val1, val2;
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_STAT, &val2);
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_STAT, &val1);
-       PMD_DRV_LOG(DEBUG, "10G-base-T LASI status 0x%x->0x%x", val2, val1);
+       PMD_DRV_LOG(DEBUG, sc, "10G-base-T LASI status 0x%x->0x%x", val2, val1);
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_STATUS, &val2);
        elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_STATUS, &val1);
-       PMD_DRV_LOG(DEBUG, "10G-base-T PMA status 0x%x->0x%x", val2, val1);
+       PMD_DRV_LOG(DEBUG, sc, "10G-base-T PMA status 0x%x->0x%x", val2, val1);
        link_up = ((val1 & 4) == 4);
        /* If link is up print the AN outcome of the SFX7101 PHY */
        if (link_up) {
@@ -10601,7 +10614,7 @@ static uint8_t elink_7101_read_status(struct elink_phy *phy,
                                &val2);
                vars->line_speed = ELINK_SPEED_10000;
                vars->duplex = DUPLEX_FULL;
-               PMD_DRV_LOG(DEBUG, "SFX7101 AN status 0x%x->Master=%x",
+               PMD_DRV_LOG(DEBUG, sc, "SFX7101 AN status 0x%x->Master=%x",
                            val2, (val2 & (1 << 14)));
                elink_ext_phy_10G_an_resolve(sc, phy, vars);
                elink_ext_phy_resolve_fc(phy, params, vars);
@@ -11208,7 +11221,7 @@ static uint32_t elink_get_ext_phy_config(struct bnx2x_softc *sc,
                                                 external_phy_config2));
                break;
        default:
-               PMD_DRV_LOG(DEBUG, "Invalid phy_index %d", phy_index);
+               PMD_DRV_LOG(DEBUG, sc, "Invalid phy_index %d", phy_index);
                return ELINK_STATUS_ERROR;
        }
 
@@ -11231,7 +11244,7 @@ static elink_status_t elink_populate_int_phy(struct bnx2x_softc *sc,
            (REG_RD(sc, MISC_REG_CHIP_NUM) << 16) |
            ((REG_RD(sc, MISC_REG_CHIP_REV) & 0xf) << 12);
 
-       PMD_DRV_LOG(DEBUG, ":chip_id = 0x%x", chip_id);
+       PMD_DRV_LOG(DEBUG, sc, ":chip_id = 0x%x", chip_id);
        if (USES_WARPCORE(sc)) {
                uint32_t serdes_net_if;
                phy_addr = REG_RD(sc, MISC_REG_WC0_CTRL_PHY_ADDR);
@@ -11308,7 +11321,7 @@ static elink_status_t elink_populate_int_phy(struct bnx2x_softc *sc,
                        phy->flags &= ~ELINK_FLAGS_TX_ERROR_CHECK;
                        break;
                default:
-                       PMD_DRV_LOG(DEBUG, "Unknown WC interface type 0x%x",
+                       PMD_DRV_LOG(DEBUG, sc, "Unknown WC interface type 0x%x",
                                    serdes_net_if);
                        break;
                }
@@ -11336,7 +11349,7 @@ static elink_status_t elink_populate_int_phy(struct bnx2x_softc *sc,
                        *phy = phy_xgxs;
                        break;
                default:
-                       PMD_DRV_LOG(DEBUG, "Invalid switch_cfg");
+                       PMD_DRV_LOG(DEBUG, sc, "Invalid switch_cfg");
                        return ELINK_STATUS_ERROR;
                }
        }
@@ -11349,7 +11362,7 @@ static elink_status_t elink_populate_int_phy(struct bnx2x_softc *sc,
        else
                phy->def_md_devad = ELINK_DEFAULT_PHY_DEV_ADDR;
 
-       PMD_DRV_LOG(DEBUG, "Internal phy port=%d, addr=0x%x, mdio_ctl=0x%x",
+       PMD_DRV_LOG(DEBUG, sc, "Internal phy port=%d, addr=0x%x, mdio_ctl=0x%x",
                    port, phy->addr, phy->mdio_ctrl);
 
        elink_populate_preemphasis(sc, shmem_base, phy, port, ELINK_INT_PHY);
@@ -11476,9 +11489,9 @@ static elink_status_t elink_populate_ext_phy(struct bnx2x_softc *sc,
                                            ELINK_SUPPORTED_100baseT_Full);
        }
 
-       PMD_DRV_LOG(DEBUG, "phy_type 0x%x port %d found in index %d",
+       PMD_DRV_LOG(DEBUG, sc, "phy_type 0x%x port %d found in index %d",
                    phy_type, port, phy_index);
-       PMD_DRV_LOG(DEBUG, "             addr=0x%x, mdio_ctl=0x%x",
+       PMD_DRV_LOG(DEBUG, sc, "             addr=0x%x, mdio_ctl=0x%x",
                    phy->addr, phy->mdio_ctrl);
        return ELINK_STATUS_OK;
 }
@@ -11527,7 +11540,7 @@ static void elink_phy_def_cfg(struct elink_params *params,
                                                         speed_capability_mask));
        }
 
-       PMD_DRV_LOG(DEBUG,
+       PMD_DRV_LOG(DEBUG, sc,
                    "Default config phy idx %x cfg 0x%x speed_cap_mask 0x%x",
                    phy_index, link_config, phy->speed_cap_mask);
 
@@ -11618,7 +11631,7 @@ elink_status_t elink_phy_probe(struct elink_params * params)
        struct bnx2x_softc *sc = params->sc;
        struct elink_phy *phy;
        params->num_phys = 0;
-       PMD_DRV_LOG(DEBUG, "Begin phy probe");
+       PMD_DRV_LOG(DEBUG, sc, "Begin phy probe");
 
        phy_config_swapped = params->multi_phy_config &
            PORT_HW_CFG_PHY_SWAPPED_ENABLED;
@@ -11631,7 +11644,7 @@ elink_status_t elink_phy_probe(struct elink_params * params)
                        else if (phy_index == ELINK_EXT_PHY2)
                                actual_phy_idx = ELINK_EXT_PHY1;
                }
-               PMD_DRV_LOG(DEBUG, "phy_config_swapped %x, phy_index %x,"
+               PMD_DRV_LOG(DEBUG, sc, "phy_config_swapped %x, phy_index %x,"
                            " actual_phy_idx %x", phy_config_swapped,
                            phy_index, actual_phy_idx);
                phy = &params->phy[actual_phy_idx];
@@ -11639,7 +11652,7 @@ elink_status_t elink_phy_probe(struct elink_params * params)
                                       params->shmem2_base, params->port,
                                       phy) != ELINK_STATUS_OK) {
                        params->num_phys = 0;
-                       PMD_DRV_LOG(DEBUG, "phy probe failed in phy index %d",
+                       PMD_DRV_LOG(DEBUG, sc, "phy probe failed in phy index %d",
                                    phy_index);
                        for (phy_index = ELINK_INT_PHY;
                             phy_index < ELINK_MAX_PHYS; phy_index++)
@@ -11680,7 +11693,8 @@ elink_status_t elink_phy_probe(struct elink_params * params)
                params->num_phys++;
        }
 
-       PMD_DRV_LOG(DEBUG, "End phy probe. #phys found %x", params->num_phys);
+       PMD_DRV_LOG(DEBUG, sc,
+                   "End phy probe. #phys found %x", params->num_phys);
        return ELINK_STATUS_OK;
 }
 
@@ -11850,7 +11864,7 @@ static elink_status_t elink_avoid_link_flap(struct elink_params *params,
        for (phy_idx = ELINK_INT_PHY; phy_idx < params->num_phys; phy_idx++) {
                struct elink_phy *phy = &params->phy[phy_idx];
                if (phy->phy_specific_func) {
-                       PMD_DRV_LOG(DEBUG, "Calling PHY specific func");
+                       PMD_DRV_LOG(DEBUG, sc, "Calling PHY specific func");
                        phy->phy_specific_func(phy, params, ELINK_PHY_INIT);
                }
                if ((phy->media_type == ELINK_ETH_PHY_SFPP_10G_FIBER) ||
@@ -11970,12 +11984,13 @@ elink_status_t elink_phy_init(struct elink_params *params,
 {
        int lfa_status;
        struct bnx2x_softc *sc = params->sc;
-       PMD_DRV_LOG(DEBUG, "Phy Initialization started");
-       PMD_DRV_LOG(DEBUG, "(1) req_speed %d, req_flowctrl %d",
+       PMD_DRV_LOG(DEBUG, sc, "Phy Initialization started");
+       PMD_DRV_LOG(DEBUG, sc, "(1) req_speed %d, req_flowctrl %d",
                    params->req_line_speed[0], params->req_flow_ctrl[0]);
-       PMD_DRV_LOG(DEBUG, "(2) req_speed %d, req_flowctrl %d",
+       PMD_DRV_LOG(DEBUG, sc, "(2) req_speed %d, req_flowctrl %d",
                    params->req_line_speed[1], params->req_flow_ctrl[1]);
-       PMD_DRV_LOG(DEBUG, "req_adv_flow_ctrl 0x%x", params->req_fc_auto_adv);
+       PMD_DRV_LOG(DEBUG, sc,
+                   "req_adv_flow_ctrl 0x%x", params->req_fc_auto_adv);
        vars->link_status = 0;
        vars->phy_link_up = 0;
        vars->link_up = 0;
@@ -11992,11 +12007,13 @@ elink_status_t elink_phy_init(struct elink_params *params,
        lfa_status = elink_check_lfa(params);
 
        if (lfa_status == 0) {
-               PMD_DRV_LOG(DEBUG, "Link Flap Avoidance in progress");
+               PMD_DRV_LOG(DEBUG, sc,
+                           "Link Flap Avoidance in progress");
                return elink_avoid_link_flap(params, vars);
        }
 
-       PMD_DRV_LOG(DEBUG, "Cannot avoid link flap lfa_sta=0x%x", lfa_status);
+       PMD_DRV_LOG(DEBUG, sc,
+                   "Cannot avoid link flap lfa_sta=0x%x", lfa_status);
        elink_cannot_avoid_link_flap(params, vars, lfa_status);
 
        /* Disable attentions */
@@ -12012,12 +12029,12 @@ elink_status_t elink_phy_init(struct elink_params *params,
                vars->link_status |= LINK_STATUS_PFC_ENABLED;
 
        if ((params->num_phys == 0) && !CHIP_REV_IS_SLOW(sc)) {
-               PMD_DRV_LOG(DEBUG, "No phy found for initialization !!");
+               PMD_DRV_LOG(DEBUG, sc, "No phy found for initialization !!");
                return ELINK_STATUS_ERROR;
        }
        set_phy_vars(params, vars);
 
-       PMD_DRV_LOG(DEBUG, "Num of phys on board: %d", params->num_phys);
+       PMD_DRV_LOG(DEBUG, sc, "Num of phys on board: %d", params->num_phys);
 
        switch (params->loopback_mode) {
        case ELINK_LOOPBACK_BMAC:
@@ -12060,7 +12077,7 @@ static elink_status_t elink_link_reset(struct elink_params *params,
 {
        struct bnx2x_softc *sc = params->sc;
        uint8_t phy_index, port = params->port, clear_latch_ind = 0;
-       PMD_DRV_LOG(DEBUG, "Resetting the link of port %d", port);
+       PMD_DRV_LOG(DEBUG, sc, "Resetting the link of port %d", port);
        /* Disable attentions */
        vars->link_status = 0;
        elink_update_mng(params, vars->link_status);
@@ -12238,7 +12255,7 @@ static elink_status_t elink_8073_common_init_phy(struct bnx2x_softc *sc,
                if (elink_populate_phy(sc, phy_index, shmem_base, shmem2_base,
                                       port_of_path, &phy[port]) !=
                    ELINK_STATUS_OK) {
-                       PMD_DRV_LOG(DEBUG, "populate_phy failed");
+                       PMD_DRV_LOG(DEBUG, sc, "populate_phy failed");
                        return ELINK_STATUS_ERROR;
                }
                /* Disable attentions */
@@ -12278,7 +12295,7 @@ static elink_status_t elink_8073_common_init_phy(struct bnx2x_softc *sc,
                else
                        port_of_path = 0;
 
-               PMD_DRV_LOG(DEBUG, "Loading spirom for phy address 0x%x",
+               PMD_DRV_LOG(DEBUG, sc, "Loading spirom for phy address 0x%x",
                            phy_blk[port]->addr);
                if (elink_8073_8727_external_rom_boot(sc, phy_blk[port],
                                                      port_of_path))
@@ -12362,7 +12379,7 @@ static elink_status_t elink_8726_common_init_phy(struct bnx2x_softc *sc,
                /* Extract the ext phy address for the port */
                if (elink_populate_phy(sc, phy_index, shmem_base, shmem2_base,
                                       port, &phy) != ELINK_STATUS_OK) {
-                       PMD_DRV_LOG(DEBUG, "populate phy failed");
+                       PMD_DRV_LOG(DEBUG, sc, "populate phy failed");
                        return ELINK_STATUS_ERROR;
                }
 
@@ -12482,7 +12499,7 @@ static elink_status_t elink_8727_common_init_phy(struct bnx2x_softc *sc,
                if (elink_populate_phy(sc, phy_index, shmem_base, shmem2_base,
                                       port_of_path, &phy[port]) !=
                    ELINK_STATUS_OK) {
-                       PMD_DRV_LOG(DEBUG, "populate phy failed");
+                       PMD_DRV_LOG(DEBUG, sc, "populate phy failed");
                        return ELINK_STATUS_ERROR;
                }
                /* disable attentions */
@@ -12513,7 +12530,7 @@ static elink_status_t elink_8727_common_init_phy(struct bnx2x_softc *sc,
                        port_of_path = port;
                else
                        port_of_path = 0;
-               PMD_DRV_LOG(DEBUG, "Loading spirom for phy address 0x%x",
+               PMD_DRV_LOG(DEBUG, sc, "Loading spirom for phy address 0x%x",
                            phy_blk[port]->addr);
                if (elink_8073_8727_external_rom_boot(sc, phy_blk[port],
                                                      port_of_path))
@@ -12540,7 +12557,8 @@ static elink_status_t elink_84833_common_init_phy(struct bnx2x_softc *sc,
        DELAY(10);
        elink_cb_gpio_mult_write(sc, reset_gpios,
                                 MISC_REGISTERS_GPIO_OUTPUT_HIGH);
-       PMD_DRV_LOG(DEBUG, "84833 reset pulse on pin values 0x%x", reset_gpios);
+       PMD_DRV_LOG(DEBUG, sc,
+                   "84833 reset pulse on pin values 0x%x", reset_gpios);
        return ELINK_STATUS_OK;
 }
 
@@ -12588,7 +12606,7 @@ static elink_status_t elink_ext_phy_common_init(struct bnx2x_softc *sc,
                rc = ELINK_STATUS_ERROR;
                break;
        default:
-               PMD_DRV_LOG(DEBUG,
+               PMD_DRV_LOG(DEBUG, sc,
                            "ext_phy 0x%x common init not required",
                            ext_phy_type);
                break;
@@ -12614,7 +12632,7 @@ elink_status_t elink_common_init_phy(struct bnx2x_softc * sc,
 
        elink_set_mdio_clk(sc, GRCBASE_EMAC0);
        elink_set_mdio_clk(sc, GRCBASE_EMAC1);
-       PMD_DRV_LOG(DEBUG, "Begin common phy init");
+       PMD_DRV_LOG(DEBUG, sc, "Begin common phy init");
        if (CHIP_IS_E3(sc)) {
                /* Enable EPIO */
                val = REG_RD(sc, MISC_REG_GEN_PURP_HWG);
@@ -12625,7 +12643,7 @@ elink_status_t elink_common_init_phy(struct bnx2x_softc * sc,
                         offsetof(struct shmem_region,
                                  port_mb[PORT_0].ext_phy_fw_version));
        if (phy_ver) {
-               PMD_DRV_LOG(DEBUG, "Not doing common init; phy ver is 0x%x",
+               PMD_DRV_LOG(DEBUG, sc, "Not doing common init; phy ver is 0x%x",
                            phy_ver);
                return ELINK_STATUS_OK;
        }
@@ -12697,15 +12715,15 @@ static uint8_t elink_analyze_link_error(struct elink_params *params,
        /* If values differ */
        switch (phy_flag) {
        case PHY_HALF_OPEN_CONN_FLAG:
-               PMD_DRV_LOG(DEBUG, "Analyze Remote Fault");
+               PMD_DRV_LOG(DEBUG, sc, "Analyze Remote Fault");
                break;
        case PHY_SFP_TX_FAULT_FLAG:
-               PMD_DRV_LOG(DEBUG, "Analyze TX Fault");
+               PMD_DRV_LOG(DEBUG, sc, "Analyze TX Fault");
                break;
        default:
-               PMD_DRV_LOG(DEBUG, "Analyze UNKNOWN");
+               PMD_DRV_LOG(DEBUG, sc, "Analyze UNKNOWN");
        }
-       PMD_DRV_LOG(DEBUG, "Link changed:[%x %x]->%x", vars->link_up,
+       PMD_DRV_LOG(DEBUG, sc, "Link changed:[%x %x]->%x", vars->link_up,
                    old_status, status);
 
        /* a. Update shmem->link_status accordingly
@@ -12831,7 +12849,7 @@ static void elink_sfp_tx_fault_detection(struct elink_phy *phy,
            PORT_HW_CFG_E3_TX_FAULT_SHIFT;
 
        if (elink_get_cfg_pin(sc, cfg_pin, &value)) {
-               PMD_DRV_LOG(DEBUG, "Failed to read pin 0x%02x", cfg_pin);
+               PMD_DRV_LOG(DEBUG, sc, "Failed to read pin 0x%02x", cfg_pin);
                return;
        }
 
@@ -12853,7 +12871,7 @@ static void elink_sfp_tx_fault_detection(struct elink_phy *phy,
 
                /* If module is unapproved, led should be on regardless */
                if (!(phy->flags & ELINK_FLAGS_SFP_NOT_APPROVED)) {
-                       PMD_DRV_LOG(DEBUG, "Change TX_Fault LED: ->%x",
+                       PMD_DRV_LOG(DEBUG, sc, "Change TX_Fault LED: ->%x",
                                    led_mode);
                        elink_set_e3_module_fault_led(params, led_mode);
                }
@@ -12863,7 +12881,7 @@ static void elink_sfp_tx_fault_detection(struct elink_phy *phy,
 static void elink_kr2_recovery(struct elink_params *params,
                               struct elink_vars *vars, struct elink_phy *phy)
 {
-       PMD_DRV_LOG(DEBUG, "KR2 recovery");
+       PMD_DRV_LOG(DEBUG, params->sc, "KR2 recovery");
 
        elink_warpcore_enable_AN_KR2(phy, params, vars);
        elink_warpcore_restart_AN_KR(phy, params);
@@ -12890,7 +12908,7 @@ static void elink_check_kr2_wa(struct elink_params *params,
        if (!sigdet) {
                if (!(vars->link_attr_sync & LINK_ATTR_SYNC_KR2_ENABLE)) {
                        elink_kr2_recovery(params, vars, phy);
-                       PMD_DRV_LOG(DEBUG, "No sigdet");
+                       PMD_DRV_LOG(DEBUG, sc, "No sigdet");
                }
                return;
        }
@@ -12908,7 +12926,7 @@ static void elink_check_kr2_wa(struct elink_params *params,
        if (base_page == 0) {
                if (!(vars->link_attr_sync & LINK_ATTR_SYNC_KR2_ENABLE)) {
                        elink_kr2_recovery(params, vars, phy);
-                       PMD_DRV_LOG(DEBUG, "No BP");
+                       PMD_DRV_LOG(DEBUG, sc, "No BP");
                }
                return;
        }
@@ -12924,7 +12942,7 @@ static void elink_check_kr2_wa(struct elink_params *params,
        /* In case KR2 is already disabled, check if we need to re-enable it */
        if (!(vars->link_attr_sync & LINK_ATTR_SYNC_KR2_ENABLE)) {
                if (!not_kr2_device) {
-                       PMD_DRV_LOG(DEBUG, "BP=0x%x, NP=0x%x", base_page,
+                       PMD_DRV_LOG(DEBUG, sc, "BP=0x%x, NP=0x%x", base_page,
                                    next_page);
                        elink_kr2_recovery(params, vars, phy);
                }
@@ -12933,7 +12951,8 @@ static void elink_check_kr2_wa(struct elink_params *params,
        /* KR2 is enabled, but not KR2 device */
        if (not_kr2_device) {
                /* Disable KR2 on both lanes */
-               PMD_DRV_LOG(DEBUG, "BP=0x%x, NP=0x%x", base_page, next_page);
+               PMD_DRV_LOG(DEBUG, sc,
+                           "BP=0x%x, NP=0x%x", base_page, next_page);
                elink_disable_kr2(params, vars, phy);
                /* Restart AN on leading lane */
                elink_warpcore_restart_AN_KR(phy, params);
@@ -12950,7 +12969,7 @@ void elink_period_func(struct elink_params *params, struct elink_vars *vars)
                        elink_set_aer_mmd(params, &params->phy[phy_idx]);
                        if (elink_check_half_open_conn(params, vars, 1) !=
                            ELINK_STATUS_OK) {
-                               PMD_DRV_LOG(DEBUG, "Fault detection failed");
+                               PMD_DRV_LOG(DEBUG, sc, "Fault detection failed");
                        }
                        break;
                }
@@ -12996,7 +13015,7 @@ uint8_t elink_fan_failure_det_req(struct bnx2x_softc *sc,
                if (elink_populate_phy(sc, phy_index, shmem_base, shmem2_base,
                                       port, &phy)
                    != ELINK_STATUS_OK) {
-                       PMD_DRV_LOG(DEBUG, "populate phy failed");
+                       PMD_DRV_LOG(DEBUG, sc, "populate phy failed");
                        return 0;
                }
                fan_failure_det_req |= (phy.flags &
@@ -13046,7 +13065,7 @@ void elink_init_mod_abs_int(struct bnx2x_softc *sc, struct elink_vars *vars,
                        if (elink_populate_phy(sc, phy_index, shmem_base,
                                               shmem2_base, port, &phy)
                            != ELINK_STATUS_OK) {
-                               PMD_DRV_LOG(DEBUG, "populate phy failed");
+                               PMD_DRV_LOG(DEBUG, sc, "populate phy failed");
                                return;
                        }
                        if (phy.type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BNX2X8726) {
@@ -13076,7 +13095,7 @@ void elink_init_mod_abs_int(struct bnx2x_softc *sc, struct elink_vars *vars,
                     dev_info.port_hw_config[port].aeu_int_mask);
        REG_WR(sc, sync_offset, vars->aeu_int_mask);
 
-       PMD_DRV_LOG(DEBUG, "Setting MOD_ABS (GPIO%d_P%d) AEU to 0x%x",
+       PMD_DRV_LOG(DEBUG, sc, "Setting MOD_ABS (GPIO%d_P%d) AEU to 0x%x",
                    gpio_num, gpio_port, vars->aeu_int_mask);
 
        if (port == 0)