if (r < 0)
                goto err_irq;
 
-       nfc_info(&client->dev, "Probed");
+       nfc_info(&client->dev, "Probed\n");
 
        return 0;
 
 
 
        priv->ndev = nci_allocate_device(&nfcmrvl_nci_ops, protocols, 0, 0);
        if (!priv->ndev) {
-               nfc_err(dev, "nci_allocate_device failed");
+               nfc_err(dev, "nci_allocate_device failed\n");
                rc = -ENOMEM;
                goto error;
        }
 
        rc = nci_register_device(priv->ndev);
        if (rc) {
-               nfc_err(dev, "nci_register_device failed %d", rc);
+               nfc_err(dev, "nci_register_device failed %d\n", rc);
                nci_free_device(priv->ndev);
                goto error;
        }
 
        if (!urb->status) {
                if (nfcmrvl_nci_recv_frame(drv_data->priv, urb->transfer_buffer,
                                           urb->actual_length) < 0)
-                       nfc_err(&drv_data->udev->dev, "corrupted Rx packet");
+                       nfc_err(&drv_data->udev->dev, "corrupted Rx packet\n");
        }
 
        if (!test_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags))
                 */
                if (err != -EPERM && err != -ENODEV)
                        nfc_err(&drv_data->udev->dev,
-                               "urb %p failed to resubmit (%d)", urb, -err);
+                               "urb %p failed to resubmit (%d)\n", urb, -err);
                usb_unanchor_urb(urb);
        }
 }
        if (err) {
                if (err != -EPERM && err != -ENODEV)
                        nfc_err(&drv_data->udev->dev,
-                               "urb %p submission failed (%d)", urb, -err);
+                               "urb %p submission failed (%d)\n", urb, -err);
                usb_unanchor_urb(urb);
        }
 
        struct nfcmrvl_private *priv = nci_get_drvdata(ndev);
        struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
 
-       nfc_info(priv->dev, "urb %p status %d count %d",
+       nfc_info(priv->dev, "urb %p status %d count %d\n",
                 urb, urb->status, urb->actual_length);
 
        spin_lock(&drv_data->txlock);
        if (err) {
                if (err != -EPERM && err != -ENODEV)
                        nfc_err(&drv_data->udev->dev,
-                               "urb %p submission failed (%d)", urb, -err);
+                               "urb %p submission failed (%d)\n", urb, -err);
                kfree(urb->setup_packet);
                usb_unanchor_urb(urb);
        } else {
        int i;
        struct usb_device *udev = interface_to_usbdev(intf);
 
-       nfc_info(&udev->dev, "intf %p id %p", intf, id);
+       nfc_info(&udev->dev, "intf %p id %p\n", intf, id);
 
        drv_data = devm_kzalloc(&intf->dev, sizeof(*drv_data), GFP_KERNEL);
        if (!drv_data)
        if (!drv_data)
                return;
 
-       nfc_info(&drv_data->udev->dev, "intf %p", intf);
+       nfc_info(&drv_data->udev->dev, "intf %p\n", intf);
 
        nfcmrvl_nci_unregister_dev(drv_data->priv);
 
 {
        struct nfcmrvl_usb_drv_data *drv_data = usb_get_intfdata(intf);
 
-       nfc_info(&drv_data->udev->dev, "intf %p", intf);
+       nfc_info(&drv_data->udev->dev, "intf %p\n", intf);
 
        if (drv_data->suspend_count++)
                return 0;
        struct nfcmrvl_usb_drv_data *drv_data = usb_get_intfdata(intf);
        int err = 0;
 
-       nfc_info(&drv_data->udev->dev, "intf %p", intf);
+       nfc_info(&drv_data->udev->dev, "intf %p\n", intf);
 
        if (--drv_data->suspend_count)
                return 0;
 
        if (IS_ERR(resp)) {
                rc = PTR_ERR(resp);
 
-               nfc_err(&dev->interface->dev, "RF setting error %d", rc);
+               nfc_err(&dev->interface->dev, "RF setting error %d\n", rc);
 
                return rc;
        }
 
        }
 
        nfc_info(dev, "GPIO resource, no:%d irq:%d\n",
-                       desc_to_gpio(gpiod_irq), ret);
+                desc_to_gpio(gpiod_irq), ret);
        client->irq = ret;
 
        return 0;
 
        phy = devm_kzalloc(&client->dev, sizeof(struct pn544_i2c_phy),
                           GFP_KERNEL);
-       if (!phy) {
-               nfc_err(&client->dev,
-                       "Cannot allocate memory for pn544 i2c phy.\n");
+       if (!phy)
                return -ENOMEM;
-       }
 
        INIT_WORK(&phy->fw_work, pn544_hci_i2c_fw_work);
        phy->fw_work_state = FW_WORK_STATE_IDLE;
 
        case -ECONNRESET:
        case -ENOENT:
                nfc_err(&dev->interface->dev,
-                       "The urb has been canceled (status %d)", urb->status);
+                       "The urb has been canceled (status %d)\n", urb->status);
                goto sched_wq;
        case -ESHUTDOWN:
        default:
-               nfc_err(&dev->interface->dev, "Urb failure (status %d)",
+               nfc_err(&dev->interface->dev, "Urb failure (status %d)\n",
                        urb->status);
                goto sched_wq;
        }
        in_frame = dev->in_urb->transfer_buffer;
 
        if (!port100_rx_frame_is_valid(in_frame)) {
-               nfc_err(&dev->interface->dev, "Received an invalid frame");
+               nfc_err(&dev->interface->dev, "Received an invalid frame\n");
                cmd->status = -EIO;
                goto sched_wq;
        }
 
        if (!port100_rx_frame_is_cmd_response(dev, in_frame)) {
                nfc_err(&dev->interface->dev,
-                       "It's not the response to the last command");
+                       "It's not the response to the last command\n");
                cmd->status = -EIO;
                goto sched_wq;
        }
        case -ECONNRESET:
        case -ENOENT:
                nfc_err(&dev->interface->dev,
-                       "The urb has been stopped (status %d)", urb->status);
+                       "The urb has been stopped (status %d)\n", urb->status);
                goto sched_wq;
        case -ESHUTDOWN:
        default:
-               nfc_err(&dev->interface->dev, "Urb failure (status %d)",
+               nfc_err(&dev->interface->dev, "Urb failure (status %d)\n",
                        urb->status);
                goto sched_wq;
        }
        in_frame = dev->in_urb->transfer_buffer;
 
        if (!port100_rx_frame_is_ack(in_frame)) {
-               nfc_err(&dev->interface->dev, "Received an invalid ack");
+               nfc_err(&dev->interface->dev, "Received an invalid ack\n");
                cmd->status = -EIO;
                goto sched_wq;
        }
        rc = port100_submit_urb_for_response(dev, GFP_ATOMIC);
        if (rc) {
                nfc_err(&dev->interface->dev,
-                       "usb_submit_urb failed with result %d", rc);
+                       "usb_submit_urb failed with result %d\n", rc);
                cmd->status = rc;
                goto sched_wq;
        }
        case -ECONNRESET:
        case -ENOENT:
                nfc_err(&dev->interface->dev,
-                       "The urb has been stopped (status %d)", urb->status);
+                       "The urb has been stopped (status %d)\n", urb->status);
                break;
        case -ESHUTDOWN:
        default:
-               nfc_err(&dev->interface->dev, "Urb failure (status %d)",
+               nfc_err(&dev->interface->dev, "Urb failure (status %d)\n",
                        urb->status);
        }
 }
 
        if (resp->len < 4) {
                nfc_err(&dev->interface->dev,
-                       "Invalid packet length received.\n");
+                       "Invalid packet length received\n");
                rc = -EIO;
                goto error;
        }
                       PORT100_MDAA_TGT_WAS_ACTIVATED_MASK;
                break;
        default:
-               nfc_err(&dev->interface->dev, "Unknonwn command type.\n");
+               nfc_err(&dev->interface->dev, "Unknown command type\n");
                return false;
        }
 
        cmd_type_mask = port100_get_command_type_mask(dev);
        if (!cmd_type_mask) {
                nfc_err(&interface->dev,
-                       "Could not get supported command types.\n");
+                       "Could not get supported command types\n");
                rc = -ENODEV;
                goto error;
        }
        rc = port100_set_command_type(dev, dev->cmd_type);
        if (rc) {
                nfc_err(&interface->dev,
-                       "The device does not support command type %u.\n",
+                       "The device does not support command type %u\n",
                        dev->cmd_type);
                goto error;
        }
        fw_version = port100_get_firmware_version(dev);
        if (!fw_version)
                nfc_err(&interface->dev,
-                       "Could not get device firmware version.\n");
+                       "Could not get device firmware version\n");
 
        nfc_info(&interface->dev,
                 "Sony NFC Port-100 Series attached (firmware v%x.%02x)\n",
                                                           dev->skb_tailroom);
        if (!dev->nfc_digital_dev) {
                nfc_err(&interface->dev,
-                       "Could not allocate nfc_digital_dev.\n");
+                       "Could not allocate nfc_digital_dev\n");
                rc = -ENOMEM;
                goto error;
        }
        rc = nfc_digital_register_device(dev->nfc_digital_dev);
        if (rc) {
                nfc_err(&interface->dev,
-                       "Could not register digital device.\n");
+                       "Could not register digital device\n");
                goto free_nfc_dev;
        }
 
 
        kfree(dev->cmd);
 
-       nfc_info(&interface->dev, "Sony Port-100 NFC device disconnected");
+       nfc_info(&interface->dev, "Sony Port-100 NFC device disconnected\n");
 }
 
 static struct usb_driver port100_driver = {
 
 
        phy = devm_kzalloc(&client->dev, sizeof(struct st21nfcb_i2c_phy),
                           GFP_KERNEL);
-       if (!phy) {
-               nfc_err(&client->dev,
-                       "Cannot allocate memory for st21nfcb i2c phy.\n");
+       if (!phy)
                return -ENOMEM;
-       }
 
        phy->i2c_dev = client;
 
 
        struct llt_ndlc *ndlc;
 
        ndlc = devm_kzalloc(dev, sizeof(struct llt_ndlc), GFP_KERNEL);
-       if (!ndlc) {
-               nfc_err(dev, "Cannot allocate memory for ndlc.\n");
+       if (!ndlc)
                return -ENOMEM;
-       }
+
        ndlc->ops = phy_ops;
        ndlc->phy_id = phy_id;
        ndlc->dev = dev;