/* Allocating card structures to hold addresses, ... */
        card = kzalloc(sizeof(struct ems_pci_card), GFP_KERNEL);
        if (card == NULL) {
-               dev_err(&pdev->dev, "Unable to allocate memory\n");
                pci_disable_device(pdev);
                return -ENOMEM;
        }
 
        } else {
                /* create the bit banging I2C adapter structure */
                card = kzalloc(sizeof(struct peak_pciec_card), GFP_KERNEL);
-               if (!card) {
-                       dev_err(&pdev->dev,
-                                "failed allocating memory for i2c chip\n");
+               if (!card)
                        return -ENOMEM;
-               }
 
                card->cfg_base = chan->cfg_base;
                card->reg_base = priv->reg_base;
 
 
        card = kzalloc(sizeof(struct pcan_pccard), GFP_KERNEL);
        if (!card) {
-               dev_err(&pdev->dev, "couldn't allocate card memory\n");
                err = -ENOMEM;
                goto probe_err_2;
        }
 
        /* Allocate card structures to hold addresses, ... */
        card = kzalloc(sizeof(*card), GFP_KERNEL);
        if (!card) {
-               dev_err(&pdev->dev, "Unable to allocate memory\n");
                pci_disable_device(pdev);
                return -ENOMEM;
        }
 
        }
 
        dev->intr_in_buffer = kzalloc(INTR_IN_BUFFER_SIZE, GFP_KERNEL);
-       if (!dev->intr_in_buffer) {
-               dev_err(&intf->dev, "Couldn't alloc Intr buffer\n");
+       if (!dev->intr_in_buffer)
                goto cleanup_intr_urb;
-       }
 
        dev->tx_msg_buffer = kzalloc(CPC_HEADER_SIZE +
                                     sizeof(struct ems_cpc_msg), GFP_KERNEL);
 
 
        buf = kmalloc(sizeof(struct kvaser_msg), GFP_ATOMIC);
        if (!buf) {
-               netdev_err(netdev, "No memory left for USB buffer\n");
                usb_free_urb(urb);
                return -ENOMEM;
        }
 
        buf = kmalloc(sizeof(struct kvaser_msg), GFP_ATOMIC);
        if (!buf) {
-               netdev_err(netdev, "No memory left for USB buffer\n");
                stats->tx_dropped++;
                goto nobufmem;
        }
 
 
                buf = kmalloc(dev->adapter->rx_buffer_size, GFP_KERNEL);
                if (!buf) {
-                       netdev_err(netdev, "No memory left for USB buffer\n");
                        usb_free_urb(urb);
                        err = -ENOMEM;
                        break;
 
                buf = kmalloc(dev->adapter->tx_buffer_size, GFP_KERNEL);
                if (!buf) {
-                       netdev_err(netdev, "No memory left for USB buffer\n");
                        usb_free_urb(urb);
                        err = -ENOMEM;
                        break;
        /* also allocate enough space for the commands to send */
        buf = kmalloc(PCAN_USB_MAX_CMD_LEN, GFP_ATOMIC);
        if (!buf) {
-               netdev_err(dev->netdev, "no memory left for async cmd\n");
                usb_free_urb(urb);
                return -ENOMEM;
        }
        /* allocate a buffer large enough to send commands */
        dev->cmd_buf = kmalloc(PCAN_USB_MAX_CMD_LEN, GFP_KERNEL);
        if (!dev->cmd_buf) {
-               dev_err(&intf->dev, "%s: couldn't alloc cmd buffer\n",
-                       PCAN_USB_DRIVER_NAME);
                err = -ENOMEM;
                goto lbl_set_intf_data;
        }
 
 
        priv->cmd_msg_buffer = kzalloc(sizeof(struct usb_8dev_cmd_msg),
                                      GFP_KERNEL);
-       if (!priv->cmd_msg_buffer) {
-               netdev_err(netdev, "Couldn't alloc Tx buffer\n");
+       if (!priv->cmd_msg_buffer)
                goto cleanup_candev;
-       }
 
        usb_set_intfdata(intf, priv);