if (ps == status) {
                dev_err(&sndev->stdev->dev,
-                       "Timed out while performing %s (%d). (%08x)",
+                       "Timed out while performing %s (%d). (%08x)\n",
                        op_text[op], op,
                        ioread32(&ctl->partition_status));
 
        if (pidx != NTB_DEF_PEER_IDX)
                return -EINVAL;
 
-       dev_dbg(&sndev->stdev->dev, "MW %d: part %d addr %pad size %pap",
+       dev_dbg(&sndev->stdev->dev, "MW %d: part %d addr %pad size %pap\n",
                widx, pidx, &addr, &size);
 
        if (widx >= switchtec_ntb_mw_count(ntb, pidx))
 
        if (rc == -EIO) {
                dev_err(&sndev->stdev->dev,
-                       "Hardware reported an error configuring mw %d: %08x",
+                       "Hardware reported an error configuring mw %d: %08x\n",
                        widx, ioread32(&ctl->bar_error));
 
                if (widx < nr_direct_mw)
        if (link_sta != old) {
                switchtec_ntb_send_msg(sndev, LINK_MESSAGE, MSG_CHECK_LINK);
                ntb_link_event(&sndev->ntb);
-               dev_info(&sndev->stdev->dev, "ntb link %s",
+               dev_info(&sndev->stdev->dev, "ntb link %s\n",
                         link_sta ? "up" : "down");
        }
 }
 {
        struct switchtec_ntb *sndev = ntb_sndev(ntb);
 
-       dev_dbg(&sndev->stdev->dev, "enabling link");
+       dev_dbg(&sndev->stdev->dev, "enabling link\n");
 
        sndev->self_shared->link_sta = 1;
        switchtec_ntb_send_msg(sndev, LINK_MESSAGE, MSG_LINK_UP);
 {
        struct switchtec_ntb *sndev = ntb_sndev(ntb);
 
-       dev_dbg(&sndev->stdev->dev, "disabling link");
+       dev_dbg(&sndev->stdev->dev, "disabling link\n");
 
        sndev->self_shared->link_sta = 0;
        switchtec_ntb_send_msg(sndev, LINK_MESSAGE, MSG_LINK_UP);
        part_map &= ~(1 << sndev->self_partition);
        sndev->peer_partition = ffs(part_map) - 1;
 
-       dev_dbg(&sndev->stdev->dev, "Partition ID %d of %d (%llx)",
+       dev_dbg(&sndev->stdev->dev, "Partition ID %d of %d (%llx)\n",
                sndev->self_partition, sndev->stdev->partition_count,
                part_map);
 
        sndev->nr_lut_mw = ioread16(&sndev->mmio_self_ctrl->lut_table_entries);
        sndev->nr_lut_mw = rounddown_pow_of_two(sndev->nr_lut_mw);
 
-       dev_dbg(&sndev->stdev->dev, "MWs: %d direct, %d lut",
+       dev_dbg(&sndev->stdev->dev, "MWs: %d direct, %d lut\n",
                sndev->nr_direct_mw, sndev->nr_lut_mw);
 
        sndev->peer_nr_direct_mw = map_bars(sndev->peer_direct_mw_to_bar,
                ioread16(&sndev->mmio_peer_ctrl->lut_table_entries);
        sndev->peer_nr_lut_mw = rounddown_pow_of_two(sndev->peer_nr_lut_mw);
 
-       dev_dbg(&sndev->stdev->dev, "Peer MWs: %d direct, %d lut",
+       dev_dbg(&sndev->stdev->dev, "Peer MWs: %d direct, %d lut\n",
                sndev->peer_nr_direct_mw, sndev->peer_nr_lut_mw);
 
 }
 
        if (ioread32(&sndev->mmio_self_ctrl->req_id_table_size) < 2) {
                dev_err(&sndev->stdev->dev,
-                       "Not enough requester IDs available.");
+                       "Not enough requester IDs available\n");
                return -EFAULT;
        }
 
        if (rc == -EIO) {
                error = ioread32(&sndev->mmio_self_ctrl->req_id_error);
                dev_err(&sndev->stdev->dev,
-                       "Error setting up the requester ID table: %08x",
+                       "Error setting up the requester ID table: %08x\n",
                        error);
        }
 
                                                 GFP_KERNEL);
        if (!sndev->self_shared) {
                dev_err(&sndev->stdev->dev,
-                       "unable to allocate memory for shared mw");
+                       "unable to allocate memory for shared mw\n");
                return -ENOMEM;
        }
 
                bar_error = ioread32(&ctl->bar_error);
                lut_error = ioread32(&ctl->lut_error);
                dev_err(&sndev->stdev->dev,
-                       "Error setting up shared MW: %08x / %08x",
+                       "Error setting up shared MW: %08x / %08x\n",
                        bar_error, lut_error);
                goto unalloc_and_exit;
        }
                goto unalloc_and_exit;
        }
 
-       dev_dbg(&sndev->stdev->dev, "Shared MW Ready");
+       dev_dbg(&sndev->stdev->dev, "Shared MW Ready\n");
        return 0;
 
 unalloc_and_exit:
                u64 msg = ioread64(&sndev->mmio_self_dbmsg->imsg[i]);
 
                if (msg & NTB_DBMSG_IMSG_STATUS) {
-                       dev_dbg(&sndev->stdev->dev, "message: %d %08x\n", i,
-                               (u32)msg);
+                       dev_dbg(&sndev->stdev->dev, "message: %d %08x\n",
+                               i, (u32)msg);
                        iowrite8(1, &sndev->mmio_self_dbmsg->imsg[i].status);
 
                        if (i == LINK_MESSAGE)
               message_irq == event_irq)
                message_irq++;
 
-       dev_dbg(&sndev->stdev->dev, "irqs - event: %d, db: %d, msgs: %d",
+       dev_dbg(&sndev->stdev->dev, "irqs - event: %d, db: %d, msgs: %d\n",
                event_irq, doorbell_irq, message_irq);
 
        for (i = 0; i < idb_vecs - 4; i++)
                return -ENODEV;
 
        if (stdev->partition_count != 2)
-               dev_warn(dev, "ntb driver only supports 2 partitions");
+               dev_warn(dev, "ntb driver only supports 2 partitions\n");
 
        sndev = kzalloc_node(sizeof(*sndev), GFP_KERNEL, dev_to_node(dev));
        if (!sndev)
 
        stdev->sndev = sndev;
        stdev->link_notifier = switchtec_ntb_link_notification;
-       dev_info(dev, "NTB device registered");
+       dev_info(dev, "NTB device registered\n");
 
        return 0;
 
        switchtec_ntb_deinit_shared_mw(sndev);
 free_and_exit:
        kfree(sndev);
-       dev_err(dev, "failed to register ntb device: %d", rc);
+       dev_err(dev, "failed to register ntb device: %d\n", rc);
        return rc;
 }
 
        switchtec_ntb_deinit_db_msg_irq(sndev);
        switchtec_ntb_deinit_shared_mw(sndev);
        kfree(sndev);
-       dev_info(dev, "ntb device unregistered");
+       dev_info(dev, "ntb device unregistered\n");
 }
 
 static struct class_interface switchtec_interface  = {