if (link_up) {
                if (!netif_carrier_ok(bnad->netdev)) {
                        uint tx_id, tcb_id;
-                       printk(KERN_WARNING "bna: %s link up\n",
-                               bnad->netdev->name);
+                       netdev_info(bnad->netdev, "link up\n");
                        netif_carrier_on(bnad->netdev);
                        BNAD_UPDATE_CTR(bnad, link_toggle);
                        for (tx_id = 0; tx_id < bnad->num_tx; tx_id++) {
                                                /*
                                                 * Force an immediate
                                                 * Transmit Schedule */
-                                               printk(KERN_INFO "bna: %s %d "
-                                                     "TXQ_STARTED\n",
-                                                      bnad->netdev->name,
-                                                      txq_id);
                                                netif_wake_subqueue(
                                                                bnad->netdev,
                                                                txq_id);
                }
        } else {
                if (netif_carrier_ok(bnad->netdev)) {
-                       printk(KERN_WARNING "bna: %s link down\n",
-                               bnad->netdev->name);
+                       netdev_info(bnad->netdev, "link down\n");
                        netif_carrier_off(bnad->netdev);
                        BNAD_UPDATE_CTR(bnad, link_toggle);
                }
                txq_id = tcb->id;
                clear_bit(BNAD_TXQ_TX_STARTED, &tcb->flags);
                netif_stop_subqueue(bnad->netdev, txq_id);
-               printk(KERN_INFO "bna: %s %d TXQ_STOPPED\n",
-                       bnad->netdev->name, txq_id);
        }
 }
 
                BUG_ON(*(tcb->hw_consumer_index) != 0);
 
                if (netif_carrier_ok(bnad->netdev)) {
-                       printk(KERN_INFO "bna: %s %d TXQ_STARTED\n",
-                               bnad->netdev->name, txq_id);
                        netif_wake_subqueue(bnad->netdev, txq_id);
                        BNAD_UPDATE_CTR(bnad, netif_queue_wakeup);
                }
                current_err = bnad_setup_rx(bnad, rx_id);
                if (current_err && !err) {
                        err = current_err;
-                       pr_err("RXQ:%u setup failed\n", rx_id);
+                       netdev_err(netdev, "RXQ:%u setup failed\n", rx_id);
                }
        }
 
        if (ret < 0) {
                goto intx_mode;
        } else if (ret < bnad->msix_num) {
-               pr_warn("BNA: %d MSI-X vectors allocated < %d requested\n",
-                       ret, bnad->msix_num);
+               dev_warn(&bnad->pcidev->dev,
+                        "%d MSI-X vectors allocated < %d requested\n",
+                        ret, bnad->msix_num);
 
                spin_lock_irqsave(&bnad->bna_lock, flags);
                /* ret = #of vectors that we got */
        return;
 
 intx_mode:
-       pr_warn("BNA: MSI-X enable failed - operating in INTx mode\n");
+       dev_warn(&bnad->pcidev->dev,
+                "MSI-X enable failed - operating in INTx mode\n");
 
        kfree(bnad->msix_table);
        bnad->msix_table = NULL;
                dev_err(&pdev->dev, "ioremap for bar0 failed\n");
                return -ENOMEM;
        }
-       pr_info("bar0 mapped to %p, len %llu\n", bnad->bar0,
-              (unsigned long long) bnad->mmio_len);
+       dev_info(&pdev->dev, "bar0 mapped to %p, len %llu\n", bnad->bar0,
+                (unsigned long long) bnad->mmio_len);
 
        spin_lock_irqsave(&bnad->bna_lock, flags);
        if (!bnad_msix_disable)
        struct bfa_pcidev pcidev_info;
        unsigned long flags;
 
-       pr_info("bnad_pci_probe : (0x%p, 0x%p) PCI Func : (%d)\n",
-              pdev, pcidev_id, PCI_FUNC(pdev->devfn));
-
        mutex_lock(&bnad_fwimg_mutex);
        if (!cna_get_firmware_buf(pdev)) {
                mutex_unlock(&bnad_fwimg_mutex);
-               pr_warn("Failed to load Firmware Image!\n");
+               dev_err(&pdev->dev, "failed to load firmware image!\n");
                return -ENODEV;
        }
        mutex_unlock(&bnad_fwimg_mutex);
         */
        err = bnad_ioceth_enable(bnad);
        if (err) {
-               pr_err("BNA: Initialization failed err=%d\n",
-                      err);
+               dev_err(&pdev->dev, "initialization failed err=%d\n", err);
                goto probe_success;
        }
 
        /* Finally, reguister with net_device layer */
        err = register_netdev(netdev);
        if (err) {
-               pr_err("BNA : Registering with netdev failed\n");
+               dev_err(&pdev->dev, "registering net device failed\n");
                goto probe_uninit;
        }
        set_bit(BNAD_RF_NETDEV_REGISTERED, &bnad->run_flags);
        if (!netdev)
                return;
 
-       pr_info("%s bnad_pci_remove\n", netdev->name);
        bnad = netdev_priv(netdev);
        bna = &bnad->bna;
 
 {
        int err;
 
-       pr_info("QLogic BR-series 10G Ethernet driver - version: %s\n",
-                       BNAD_VERSION);
+       pr_info("bna: QLogic BR-series 10G Ethernet driver - version: %s\n",
+               BNAD_VERSION);
 
        bfa_nw_ioc_auto_recover(bnad_ioc_auto_recover);
 
        err = pci_register_driver(&bnad_pci_driver);
        if (err < 0) {
-               pr_err("bna : PCI registration failed in module init "
-                      "(%d)\n", err);
+               pr_err("bna: PCI driver registration failed err=%d\n", err);
                return err;
        }
 
 
                fw_debug->debug_buffer = NULL;
                kfree(fw_debug);
                fw_debug = NULL;
-               pr_warn("bnad %s: Failed to collect fwtrc\n",
-                       pci_name(bnad->pcidev));
+               netdev_warn(bnad->netdev, "failed to collect fwtrc\n");
                return -ENOMEM;
        }
 
                fw_debug->debug_buffer = NULL;
                kfree(fw_debug);
                fw_debug = NULL;
-               pr_warn("bna %s: Failed to collect fwsave\n",
-                       pci_name(bnad->pcidev));
+               netdev_warn(bnad->netdev, "failed to collect fwsave\n");
                return -ENOMEM;
        }
 
                drv_info->debug_buffer = NULL;
                kfree(drv_info);
                drv_info = NULL;
-               pr_warn("bna %s: Failed to collect drvinfo\n",
-                       pci_name(bnad->pcidev));
+               netdev_warn(bnad->netdev, "failed to collect drvinfo\n");
                return -ENOMEM;
        }
 
 
        rc = sscanf(kern_buf, "%x:%x", &addr, &len);
        if (rc < 2) {
-               pr_warn("bna %s: Failed to read user buffer\n",
-                       pci_name(bnad->pcidev));
+               netdev_warn(bnad->netdev, "failed to read user buffer\n");
                kfree(kern_buf);
                return -EINVAL;
        }
        /* offset and len sanity check */
        rc = bna_reg_offset_check(ioc, addr, len);
        if (rc) {
-               pr_warn("bna %s: Failed reg offset check\n",
-                       pci_name(bnad->pcidev));
+               netdev_warn(bnad->netdev, "failed reg offset check\n");
                kfree(bnad->regdata);
                bnad->regdata = NULL;
                bnad->reglen = 0;
 
        rc = sscanf(kern_buf, "%x:%x", &addr, &val);
        if (rc < 2) {
-               pr_warn("bna %s: Failed to read user buffer\n",
-                       pci_name(bnad->pcidev));
+               netdev_warn(bnad->netdev, "failed to read user buffer\n");
                kfree(kern_buf);
                return -EINVAL;
        }
        /* offset and len sanity check */
        rc = bna_reg_offset_check(ioc, addr, 1);
        if (rc) {
-               pr_warn("bna %s: Failed reg offset check\n",
-                       pci_name(bnad->pcidev));
+               netdev_warn(bnad->netdev, "failed reg offset check\n");
                return -EINVAL;
        }
 
                bna_debugfs_root = debugfs_create_dir("bna", NULL);
                atomic_set(&bna_debugfs_port_count, 0);
                if (!bna_debugfs_root) {
-                       pr_warn("BNA: debugfs root dir creation failed\n");
+                       netdev_warn(bnad->netdev,
+                                   "debugfs root dir creation failed\n");
                        return;
                }
        }
                bnad->port_debugfs_root =
                        debugfs_create_dir(name, bna_debugfs_root);
                if (!bnad->port_debugfs_root) {
-                       pr_warn("bna pci_dev %s: root dir creation failed\n",
-                               pci_name(bnad->pcidev));
+                       netdev_warn(bnad->netdev,
+                                   "debugfs root dir creation failed\n");
                        return;
                }
 
                                                        bnad,
                                                        file->fops);
                        if (!bnad->bnad_dentry_files[i]) {
-                               pr_warn(
-                                    "BNA pci_dev:%s: create %s entry failed\n",
-                                    pci_name(bnad->pcidev), file->name);
+                               netdev_warn(bnad->netdev,
+                                           "create %s entry failed\n",
+                                           file->name);
                                return;
                        }
                }
 
 
        ret = request_firmware(&fw, eflash->data, &bnad->pcidev->dev);
        if (ret) {
-               pr_err("BNA: Can't locate firmware %s\n", eflash->data);
+               netdev_err(netdev, "can't load firmware %s\n", eflash->data);
                goto out;
        }
 
                                bnad->id, (u8 *)fw->data, fw->size, 0,
                                bnad_cb_completion, &fcomp);
        if (ret != BFA_STATUS_OK) {
-               pr_warn("BNA: Flash update failed with err: %d\n", ret);
+               netdev_warn(netdev, "flash update failed with err=%d\n", ret);
                ret = -EIO;
                spin_unlock_irq(&bnad->bna_lock);
                goto out;
        wait_for_completion(&fcomp.comp);
        if (fcomp.comp_status != BFA_STATUS_OK) {
                ret = -EIO;
-               pr_warn("BNA: Firmware image update to flash failed with: %d\n",
-                       fcomp.comp_status);
+               netdev_warn(netdev,
+                           "firmware image update failed with err=%d\n",
+                           fcomp.comp_status);
        }
 out:
        release_firmware(fw);