USB: serial: remove redundant OOM messages

Remove redundant error messages on allocation failures, which have
already been logged.

Cc: Joe Perches <joe@perches.com>
Signed-off-by: Johan Hovold <jhovold@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

21 files changed, 74 insertions, 217 deletions

diff --git a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c
index c2a4171ab9cb..8908760cca9f 100644
--- a/drivers/usb/serial/ch341.c
+++ b/drivers/usb/serial/ch341.c
@@ -384,10 +384,8 @@ static void ch341_break_ctl(struct tty_struct *tty, int break_state)
         uint8_t *break_reg;
 
         break_reg = kmalloc(2, GFP_KERNEL);
-        if (!break_reg) {
-                dev_err(&port->dev, "%s - kmalloc failed\n", __func__);
+        if (!break_reg)
                 return;
-        }
 
         r = ch341_control_in(port->serial->dev, CH341_REQ_READ_REG,
                         ch341_break_reg, 0, break_reg, 2);
diff --git a/drivers/usb/serial/console.c b/drivers/usb/serial/console.c
index c69bb50d4663..b5b8dcbb33a2 100644
--- a/drivers/usb/serial/console.c
+++ b/drivers/usb/serial/console.c
@@ -135,7 +135,6 @@ static int usb_console_setup(struct console *co, char *options)
                         tty = kzalloc(sizeof(*tty), GFP_KERNEL);
                         if (!tty) {
                                 retval = -ENOMEM;
-                                dev_err(&port->dev, "no more memory\n");
                                 goto reset_open_count;
                         }
                         kref_init(&tty->kref);
@@ -144,7 +143,6 @@ static int usb_console_setup(struct console *co, char *options)
                         tty->index = co->index;
                         if (tty_init_termios(tty)) {
                                 retval = -ENOMEM;
-                                dev_err(&port->dev, "no more memory\n");
                                 goto free_tty;
                         }
                 }
diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c
index 6987b535aa98..95fa1217afdd 100644
--- a/drivers/usb/serial/cp210x.c
+++ b/drivers/usb/serial/cp210x.c
@@ -305,10 +305,8 @@ static int cp210x_get_config(struct usb_serial_port *port, u8 request,
         length = (((size - 1) | 3) + 1) / 4;
 
         buf = kcalloc(length, sizeof(__le32), GFP_KERNEL);
-        if (!buf) {
-                dev_err(&port->dev, "%s - out of memory.\n", __func__);
+        if (!buf)
                 return -ENOMEM;
-        }
 
         /* Issue the request, attempting to read 'size' bytes */
         result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
@@ -352,10 +350,8 @@ static int cp210x_set_config(struct usb_serial_port *port, u8 request,
         length = (((size - 1) | 3) + 1) / 4;
 
         buf = kmalloc(length * sizeof(__le32), GFP_KERNEL);
-        if (!buf) {
-                dev_err(&port->dev, "%s - out of memory.\n", __func__);
+        if (!buf)
                 return -ENOMEM;
-        }
 
         /* Array of integers into bytes */
         for (i = 0; i < length; i++)
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index b3f712f8cf17..a4bebacc5cae 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -1695,11 +1695,8 @@ static int ftdi_sio_port_probe(struct usb_serial_port *port)
 
 
         priv = kzalloc(sizeof(struct ftdi_private), GFP_KERNEL);
-        if (!priv) {
-                dev_err(&port->dev, "%s- kmalloc(%Zd) failed.\n", __func__,
-                                        sizeof(struct ftdi_private));
+        if (!priv)
                 return -ENOMEM;
-        }
 
         mutex_init(&priv->cfg_lock);
 
diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c
index 04b5ed90ffb2..f4ee74da44e8 100644
--- a/drivers/usb/serial/garmin_gps.c
+++ b/drivers/usb/serial/garmin_gps.c
@@ -279,10 +279,9 @@ static int pkt_add(struct garmin_data *garmin_data_p,
         if (data_length) {
                 pkt = kmalloc(sizeof(struct garmin_packet)+data_length,
                                                                 GFP_ATOMIC);
-                if (pkt == NULL) {
-                        dev_err(&garmin_data_p->port->dev, "out of memory\n");
+                if (!pkt)
                         return 0;
-                }
+
                 pkt->size = data_length;
                 memcpy(pkt->data, data, data_length);
 
@@ -1006,14 +1005,11 @@ static int garmin_write_bulk(struct usb_serial_port *port,
         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 
         buffer = kmalloc(count, GFP_ATOMIC);
-        if (!buffer) {
-                dev_err(&port->dev, "out of memory\n");
+        if (!buffer)
                 return -ENOMEM;
-        }
 
         urb = usb_alloc_urb(0, GFP_ATOMIC);
         if (!urb) {
-                dev_err(&port->dev, "no more free urbs\n");
                 kfree(buffer);
                 return -ENOMEM;
         }
@@ -1393,10 +1389,9 @@ static int garmin_port_probe(struct usb_serial_port *port)
         struct garmin_data *garmin_data_p;
 
         garmin_data_p = kzalloc(sizeof(struct garmin_data), GFP_KERNEL);
-        if (garmin_data_p == NULL) {
-                dev_err(&port->dev, "%s - Out of memory\n", __func__);
+        if (!garmin_data_p)
                 return -ENOMEM;
-        }
+
         init_timer(&garmin_data_p->timer);
         spin_lock_init(&garmin_data_p->lock);
         INIT_LIST_HEAD(&garmin_data_p->pktlist);
diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c
index 9c79fb22f341..0dd8cce9c9d3 100644
--- a/drivers/usb/serial/io_edgeport.c
+++ b/drivers/usb/serial/io_edgeport.c
@@ -898,7 +898,6 @@ static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
         edge_port->txfifo.fifo  = kmalloc(edge_port->maxTxCredits, GFP_KERNEL);
 
         if (!edge_port->txfifo.fifo) {
-                dev_dbg(dev, "%s - no memory\n", __func__);
                 edge_close(port);
                 return -ENOMEM;
         }
@@ -908,7 +907,6 @@ static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
         edge_port->write_in_progress = false;
 
         if (!edge_port->write_urb) {
-                dev_dbg(dev, "%s - no memory\n", __func__);
                 edge_close(port);
                 return -ENOMEM;
         }
@@ -1245,9 +1243,7 @@ static void send_more_port_data(struct edgeport_serial *edge_serial,
            to send out */
         count = fifo->count;
         buffer = kmalloc(count+2, GFP_ATOMIC);
-        if (buffer == NULL) {
-                dev_err_console(edge_port->port,
-                                "%s - no more kernel memory...\n", __func__);
+        if (!buffer) {
                 edge_port->write_in_progress = false;
                 goto exit_send;
         }
@@ -2025,11 +2021,8 @@ static int sram_write(struct usb_serial *serial, __u16 extAddr, __u16 addr,
         dev_dbg(&serial->dev->dev, "%s - %x, %x, %d\n", __func__, extAddr, addr, length);
 
         transfer_buffer =  kmalloc(64, GFP_KERNEL);
-        if (!transfer_buffer) {
-                dev_err(&serial->dev->dev, "%s - kmalloc(%d) failed.\n",
-                                                        __func__, 64);
+        if (!transfer_buffer)
                 return -ENOMEM;
-        }
 
         /* need to split these writes up into 64 byte chunks */
         result = 0;
@@ -2073,11 +2066,8 @@ static int rom_write(struct usb_serial *serial, __u16 extAddr, __u16 addr,
         unsigned char *transfer_buffer;
 
         transfer_buffer =  kmalloc(64, GFP_KERNEL);
-        if (!transfer_buffer) {
-                dev_err(&serial->dev->dev, "%s - kmalloc(%d) failed.\n",
-                                                                __func__, 64);
+        if (!transfer_buffer)
                 return -ENOMEM;
-        }
 
         /* need to split these writes up into 64 byte chunks */
         result = 0;
@@ -2119,11 +2109,8 @@ static int rom_read(struct usb_serial *serial, __u16 extAddr,
         unsigned char *transfer_buffer;
 
         transfer_buffer =  kmalloc(64, GFP_KERNEL);
-        if (!transfer_buffer) {
-                dev_err(&serial->dev->dev,
-                        "%s - kmalloc(%d) failed.\n", __func__, 64);
+        if (!transfer_buffer)
                 return -ENOMEM;
-        }
 
         /* need to split these reads up into 64 byte chunks */
         result = 0;
@@ -2163,11 +2150,8 @@ static int send_iosp_ext_cmd(struct edgeport_port *edge_port,
         int             status = 0;
 
         buffer = kmalloc(10, GFP_ATOMIC);
-        if (!buffer) {
-                dev_err(&edge_port->port->dev,
-                                "%s - kmalloc(%d) failed.\n", __func__, 10);
+        if (!buffer)
                 return -ENOMEM;
-        }
 
         currentCommand = buffer;
 
@@ -2274,10 +2258,9 @@ static int send_cmd_write_baud_rate(struct edgeport_port *edge_port,
 
         /* Alloc memory for the string of commands. */
         cmdBuffer =  kmalloc(0x100, GFP_ATOMIC);
-        if (!cmdBuffer) {
-                dev_err(dev, "%s - kmalloc(%d) failed.\n", __func__, 0x100);
+        if (!cmdBuffer)
                 return -ENOMEM;
-        }
+
         currCmd = cmdBuffer;
 
         /* Enable access to divisor latch */
@@ -2783,10 +2766,9 @@ static int edge_startup(struct usb_serial *serial)
 
         /* create our private serial structure */
         edge_serial = kzalloc(sizeof(struct edgeport_serial), GFP_KERNEL);
-        if (edge_serial == NULL) {
-                dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
+        if (!edge_serial)
                 return -ENOMEM;
-        }
+
         spin_lock_init(&edge_serial->es_lock);
         edge_serial->serial = serial;
         usb_set_serial_data(serial, edge_serial);
@@ -2875,14 +2857,12 @@ static int edge_startup(struct usb_serial *serial)
                                 /* not set up yet, so do it now */
                                 edge_serial->interrupt_read_urb =
                                                 usb_alloc_urb(0, GFP_KERNEL);
-                                if (!edge_serial->interrupt_read_urb) {
-                                        dev_err(ddev, "out of memory\n");
+                                if (!edge_serial->interrupt_read_urb)
                                         return -ENOMEM;
-                                }
+
                                 edge_serial->interrupt_in_buffer =
                                         kmalloc(buffer_size, GFP_KERNEL);
                                 if (!edge_serial->interrupt_in_buffer) {
-                                        dev_err(ddev, "out of memory\n");
                                         usb_free_urb(edge_serial->interrupt_read_urb);
                                         return -ENOMEM;
                                 }
@@ -2912,14 +2892,12 @@ static int edge_startup(struct usb_serial *serial)
                                 /* not set up yet, so do it now */
                                 edge_serial->read_urb =
                                                 usb_alloc_urb(0, GFP_KERNEL);
-                                if (!edge_serial->read_urb) {
-                                        dev_err(ddev, "out of memory\n");
+                                if (!edge_serial->read_urb)
                                         return -ENOMEM;
-                                }
+
                                 edge_serial->bulk_in_buffer =
                                         kmalloc(buffer_size, GFP_KERNEL);
                                 if (!edge_serial->bulk_in_buffer) {
-                                        dev_err(&dev->dev, "out of memory\n");
                                         usb_free_urb(edge_serial->read_urb);
                                         return -ENOMEM;
                                 }
diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c
index 2b3b7bfeb332..a673f4b25b08 100644
--- a/drivers/usb/serial/io_ti.c
+++ b/drivers/usb/serial/io_ti.c
@@ -364,11 +364,9 @@ static int write_boot_mem(struct edgeport_serial *serial,
         /* Must do a read before write */
         if (!serial->TiReadI2C) {
                 temp = kmalloc(1, GFP_KERNEL);
-                if (!temp) {
-                        dev_err(&serial->serial->dev->dev,
-                                        "%s - out of memory\n", __func__);
+                if (!temp)
                         return -ENOMEM;
-                }
+
                 status = read_boot_mem(serial, 0, 1, temp);
                 kfree(temp);
                 if (status)
@@ -471,10 +469,8 @@ static int tx_active(struct edgeport_port *port)
         int bytes_left = 0;
 
         oedb = kmalloc(sizeof(*oedb), GFP_KERNEL);
-        if (!oedb) {
-                dev_err(&port->port->dev, "%s - out of memory\n", __func__);
+        if (!oedb)
                 return -ENOMEM;
-        }
 
         lsr = kmalloc(1, GFP_KERNEL);   /* Sigh, that's right, just one byte,
                                            as not all platforms can do DMA
@@ -625,14 +621,11 @@ static int check_i2c_image(struct edgeport_serial *serial)
         __u16 ttype;
 
         rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);
-        if (!rom_desc) {
-                dev_err(dev, "%s - out of memory\n", __func__);
+        if (!rom_desc)
                 return -ENOMEM;
-        }
+
         buffer = kmalloc(TI_MAX_I2C_SIZE, GFP_KERNEL);
         if (!buffer) {
-                dev_err(dev, "%s - out of memory when allocating buffer\n",
-                                                                __func__);
                 kfree(rom_desc);
                 return -ENOMEM;
         }
@@ -706,10 +699,9 @@ static int get_manuf_info(struct edgeport_serial *serial, __u8 *buffer)
         struct device *dev = &serial->serial->dev->dev;
 
         rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);
-        if (!rom_desc) {
-                dev_err(dev, "%s - out of memory\n", __func__);
+        if (!rom_desc)
                 return -ENOMEM;
-        }
+
         start_address = get_descriptor_addr(serial, I2C_DESC_TYPE_ION,
                                                                 rom_desc);
 
@@ -769,10 +761,8 @@ static int build_i2c_fw_hdr(__u8 *header, struct device *dev)
                         sizeof(struct ti_i2c_firmware_rec));
 
         buffer = kmalloc(buffer_size, GFP_KERNEL);
-        if (!buffer) {
-                dev_err(dev, "%s - out of memory\n", __func__);
+        if (!buffer)
                 return -ENOMEM;
-        }
 
         // Set entire image of 0xffs
         memset(buffer, 0xff, buffer_size);
@@ -832,10 +822,8 @@ static int i2c_type_bootmode(struct edgeport_serial *serial)
         u8 *data;
 
         data = kmalloc(1, GFP_KERNEL);
-        if (!data) {
-                dev_err(dev, "%s - out of memory\n", __func__);
+        if (!data)
                 return -ENOMEM;
-        }
 
         /* Try to read type 2 */
         status = ti_vread_sync(serial->serial->dev, UMPC_MEMORY_READ,
@@ -986,10 +974,9 @@ static int download_fw(struct edgeport_serial *serial)
                  * Read Manufacturing Descriptor from TI Based Edgeport
                  */
                 ti_manuf_desc = kmalloc(sizeof(*ti_manuf_desc), GFP_KERNEL);
-                if (!ti_manuf_desc) {
-                        dev_err(dev, "%s - out of memory.\n", __func__);
+                if (!ti_manuf_desc)
                         return -ENOMEM;
-                }
+
                 status = get_manuf_info(serial, (__u8 *)ti_manuf_desc);
                 if (status) {
                         kfree(ti_manuf_desc);
@@ -1006,7 +993,6 @@ static int download_fw(struct edgeport_serial *serial)
 
                 rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);
                 if (!rom_desc) {
-                        dev_err(dev, "%s - out of memory.\n", __func__);
                         kfree(ti_manuf_desc);
                         return -ENOMEM;
                 }
@@ -1023,7 +1009,6 @@ static int download_fw(struct edgeport_serial *serial)
                         firmware_version = kmalloc(sizeof(*firmware_version),
                                                                 GFP_KERNEL);
                         if (!firmware_version) {
-                                dev_err(dev, "%s - out of memory.\n", __func__);
                                 kfree(rom_desc);
                                 kfree(ti_manuf_desc);
                                 return -ENOMEM;
@@ -1068,8 +1053,6 @@ static int download_fw(struct edgeport_serial *serial)
 
                                 record = kmalloc(1, GFP_KERNEL);
                                 if (!record) {
-                                        dev_err(dev, "%s - out of memory.\n",
-                                                        __func__);
                                         kfree(firmware_version);
                                         kfree(rom_desc);
                                         kfree(ti_manuf_desc);
@@ -1153,7 +1136,6 @@ static int download_fw(struct edgeport_serial *serial)
 
                         header = kmalloc(HEADER_SIZE, GFP_KERNEL);
                         if (!header) {
-                                dev_err(dev, "%s - out of memory.\n", __func__);
                                 kfree(rom_desc);
                                 kfree(ti_manuf_desc);
                                 return -ENOMEM;
@@ -1161,7 +1143,6 @@ static int download_fw(struct edgeport_serial *serial)
 
                         vheader = kmalloc(HEADER_SIZE, GFP_KERNEL);
                         if (!vheader) {
-                                dev_err(dev, "%s - out of memory.\n", __func__);
                                 kfree(header);
                                 kfree(rom_desc);
                                 kfree(ti_manuf_desc);
@@ -1290,10 +1271,9 @@ static int download_fw(struct edgeport_serial *serial)
                  * Read Manufacturing Descriptor from TI Based Edgeport
                  */
                 ti_manuf_desc = kmalloc(sizeof(*ti_manuf_desc), GFP_KERNEL);
-                if (!ti_manuf_desc) {
-                        dev_err(dev, "%s - out of memory.\n", __func__);
+                if (!ti_manuf_desc)
                         return -ENOMEM;
-                }
+
                 status = get_manuf_info(serial, (__u8 *)ti_manuf_desc);
                 if (status) {
                         kfree(ti_manuf_desc);
@@ -1328,10 +1308,8 @@ static int download_fw(struct edgeport_serial *serial)
                 buffer_size = (((1024 * 16) - 512) +
                                         sizeof(struct ti_i2c_image_header));
                 buffer = kmalloc(buffer_size, GFP_KERNEL);
-                if (!buffer) {
-                        dev_err(dev, "%s - out of memory\n", __func__);
+                if (!buffer)
                         return -ENOMEM;
-                }
 
                 /* Initialize the buffer to 0xff (pad the buffer) */
                 memset(buffer, 0xff, buffer_size);
@@ -2122,7 +2100,6 @@ static void change_port_settings(struct tty_struct *tty,
         config = kmalloc (sizeof (*config), GFP_KERNEL);
         if (!config) {
                 tty->termios = *old_termios;
-                dev_err(dev, "%s - out of memory\n", __func__);
                 return;
         }
 
@@ -2393,10 +2370,9 @@ static int edge_startup(struct usb_serial *serial)
 
         /* create our private serial structure */
         edge_serial = kzalloc(sizeof(struct edgeport_serial), GFP_KERNEL);
-        if (edge_serial == NULL) {
-                dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
+        if (!edge_serial)
                 return -ENOMEM;
-        }
+
         mutex_init(&edge_serial->es_lock);
         edge_serial->serial = serial;
         usb_set_serial_data(serial, edge_serial);
diff --git a/drivers/usb/serial/ir-usb.c b/drivers/usb/serial/ir-usb.c
index 716930ab1bb1..73956d48a0c5 100644
--- a/drivers/usb/serial/ir-usb.c
+++ b/drivers/usb/serial/ir-usb.c
@@ -377,15 +377,12 @@ static void ir_set_termios(struct tty_struct *tty,
          * send the baud change out on an "empty" data packet
          */
         urb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!urb) {
-                dev_err(&port->dev, "%s - no more urbs\n", __func__);
+        if (!urb)
                 return;
-        }
+
         transfer_buffer = kmalloc(1, GFP_KERNEL);
-        if (!transfer_buffer) {
-                dev_err(&port->dev, "%s - out of memory\n", __func__);
+        if (!transfer_buffer)
                 goto err_buf;
-        }
 
         *transfer_buffer = ir_xbof | ir_baud;
 
diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
index d6960aebe246..6125fce7d0f6 100644
--- a/drivers/usb/serial/keyspan.c
+++ b/drivers/usb/serial/keyspan.c
@@ -1226,10 +1226,8 @@ static struct urb *keyspan_setup_urb(struct usb_serial *serial, int endpoint,
 
         dev_dbg(&serial->interface->dev, "%s - alloc for endpoint %d.\n", __func__, endpoint);
         urb = usb_alloc_urb(0, GFP_KERNEL);             /* No ISO */
-        if (urb == NULL) {
-                dev_dbg(&serial->interface->dev, "%s - alloc for endpoint %d failed.\n", __func__, endpoint);
+        if (!urb)
                 return NULL;
-        }
 
         if (endpoint == 0) {
                 /* control EP filled in when used */
@@ -2312,10 +2310,8 @@ static int keyspan_startup(struct usb_serial *serial)
 
         /* Setup private data for serial driver */
         s_priv = kzalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL);
-        if (!s_priv) {
-                dev_dbg(&serial->dev->dev, "%s - kmalloc for keyspan_serial_private failed.\n", __func__);
+        if (!s_priv)
                 return -ENOMEM;
-        }
 
         s_priv->instat_buf = kzalloc(INSTAT_BUFLEN, GFP_KERNEL);
         if (!s_priv->instat_buf)
diff --git a/drivers/usb/serial/kl5kusb105.c b/drivers/usb/serial/kl5kusb105.c
index 1b4054fe52a5..4f441c2c0668 100644
--- a/drivers/usb/serial/kl5kusb105.c
+++ b/drivers/usb/serial/kl5kusb105.c
@@ -182,11 +182,9 @@ static int klsi_105_get_line_state(struct usb_serial_port *port,
         dev_info(&port->serial->dev->dev, "sending SIO Poll request\n");
 
         status_buf = kmalloc(KLSI_STATUSBUF_LEN, GFP_KERNEL);
-        if (!status_buf) {
-                dev_err(&port->dev, "%s - out of memory for status buffer.\n",
-                                __func__);
+        if (!status_buf)
                 return -ENOMEM;
-        }
+
         status_buf[0] = 0xff;
         status_buf[1] = 0xff;
         rc = usb_control_msg(port->serial->dev,
@@ -273,11 +271,9 @@ static int  klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port)
          * priv->line_state.
          */
         cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
-        if (!cfg) {
-                dev_err(&port->dev, "%s - out of memory for config buffer.\n",
-                                __func__);
+        if (!cfg)
                 return -ENOMEM;
-        }
+
         cfg->pktlen   = 5;
         cfg->baudrate = kl5kusb105a_sio_b9600;
         cfg->databits = kl5kusb105a_dtb_8;
@@ -417,10 +413,8 @@ static void klsi_105_set_termios(struct tty_struct *tty,
         speed_t baud;
 
         cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
-        if (!cfg) {
-                dev_err(dev, "%s - out of memory for config buffer.\n", __func__);
+        if (!cfg)
                 return;
-        }
 
         /* lock while we are modifying the settings */
         spin_lock_irqsave(&priv->lock, flags);
diff --git a/drivers/usb/serial/mos7720.c b/drivers/usb/serial/mos7720.c
index b739a1732b76..ee68191e87c6 100644
--- a/drivers/usb/serial/mos7720.c
+++ b/drivers/usb/serial/mos7720.c
@@ -362,15 +362,13 @@ static int write_parport_reg_nonblock(struct mos7715_parport *mos_parport,
 
         /* create and initialize the control urb and containing urbtracker */
         urbtrack = kmalloc(sizeof(struct urbtracker), GFP_ATOMIC);
-        if (urbtrack == NULL) {
-                dev_err(&usbdev->dev, "out of memory");
+        if (!urbtrack)
                 return -ENOMEM;
-        }
+
         kref_get(&mos_parport->ref_count);
         urbtrack->mos_parport = mos_parport;
         urbtrack->urb = usb_alloc_urb(0, GFP_ATOMIC);
-        if (urbtrack->urb == NULL) {
-                dev_err(&usbdev->dev, "out of urbs");
+        if (!urbtrack->urb) {
                 kfree(urbtrack);
                 return -ENOMEM;
         }
@@ -702,10 +700,9 @@ static int mos7715_parport_init(struct usb_serial *serial)
 
         /* allocate and initialize parallel port control struct */
         mos_parport = kzalloc(sizeof(struct mos7715_parport), GFP_KERNEL);
-        if (mos_parport == NULL) {
-                dev_dbg(&serial->dev->dev, "%s: kzalloc failed\n", __func__);
+        if (!mos_parport)
                 return -ENOMEM;
-        }
+
         mos_parport->msg_pending = false;
         kref_init(&mos_parport->ref_count);
         spin_lock_init(&mos_parport->listlock);
@@ -1018,18 +1015,12 @@ static int mos7720_open(struct tty_struct *tty, struct usb_serial_port *port)
         for (j = 0; j < NUM_URBS; ++j) {
                 urb = usb_alloc_urb(0, GFP_KERNEL);
                 mos7720_port->write_urb_pool[j] = urb;
-
-                if (urb == NULL) {
-                        dev_err(&port->dev, "No more urbs???\n");
+                if (!urb)
                         continue;
-                }
 
                 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
                                                GFP_KERNEL);
                 if (!urb->transfer_buffer) {
-                        dev_err(&port->dev,
-                                "%s-out of memory for urb buffers.\n",
-                                __func__);
                         usb_free_urb(mos7720_port->write_urb_pool[j]);
                         mos7720_port->write_urb_pool[j] = NULL;
                         continue;
@@ -1250,11 +1241,8 @@ static int mos7720_write(struct tty_struct *tty, struct usb_serial_port *port,
         if (urb->transfer_buffer == NULL) {
                 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
                                                GFP_KERNEL);
-                if (urb->transfer_buffer == NULL) {
-                        dev_err_console(port, "%s no more kernel memory...\n",
-                                __func__);
+                if (!urb->transfer_buffer)
                         goto exit;
-                }
         }
         transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE);
 
diff --git a/drivers/usb/serial/mos7840.c b/drivers/usb/serial/mos7840.c
index bc176ae61743..2496e71e406a 100644
--- a/drivers/usb/serial/mos7840.c
+++ b/drivers/usb/serial/mos7840.c
@@ -876,20 +876,14 @@ static int mos7840_open(struct tty_struct *tty, struct usb_serial_port *port)
         for (j = 0; j < NUM_URBS; ++j) {
                 urb = usb_alloc_urb(0, GFP_KERNEL);
                 mos7840_port->write_urb_pool[j] = urb;
-
-                if (urb == NULL) {
-                        dev_err(&port->dev, "No more urbs???\n");
+                if (!urb)
                         continue;
-                }
 
                 urb->transfer_buffer = kmalloc(URB_TRANSFER_BUFFER_SIZE,
                                                                 GFP_KERNEL);
                 if (!urb->transfer_buffer) {
                         usb_free_urb(urb);
                         mos7840_port->write_urb_pool[j] = NULL;
-                        dev_err(&port->dev,
-                                "%s-out of memory for urb buffers.\n",
-                                __func__);
                         continue;
                 }
         }
@@ -1381,12 +1375,8 @@ static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port,
         if (urb->transfer_buffer == NULL) {
                 urb->transfer_buffer =
                     kmalloc(URB_TRANSFER_BUFFER_SIZE, GFP_KERNEL);
-
-                if (urb->transfer_buffer == NULL) {
-                        dev_err_console(port, "%s no more kernel memory...\n",
-                                __func__);
+                if (!urb->transfer_buffer)
                         goto exit;
-                }
         }
         transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE);
 
@@ -2206,10 +2196,8 @@ static int mos7840_port_probe(struct usb_serial_port *port)
 
         dev_dbg(&port->dev, "mos7840_startup: configuring port %d\n", pnum);
         mos7840_port = kzalloc(sizeof(struct moschip_port), GFP_KERNEL);
-        if (mos7840_port == NULL) {
-                dev_err(&port->dev, "%s - Out of memory\n", __func__);
+        if (!mos7840_port)
                 return -ENOMEM;
-        }
 
         /* Initialize all port interrupt end point to port 0 int
          * endpoint. Our device has only one interrupt end point
diff --git a/drivers/usb/serial/opticon.c b/drivers/usb/serial/opticon.c
index 1b4f1d2479c1..90c77b20c883 100644
--- a/drivers/usb/serial/opticon.c
+++ b/drivers/usb/serial/opticon.c
@@ -200,15 +200,12 @@ static int opticon_write(struct tty_struct *tty, struct usb_serial_port *port,
 
         buffer = kmalloc(count, GFP_ATOMIC);
         if (!buffer) {
-                dev_err(&port->dev, "out of memory\n");
                 count = -ENOMEM;
-
                 goto error_no_buffer;
         }
 
         urb = usb_alloc_urb(0, GFP_ATOMIC);
         if (!urb) {
-                dev_err(&port->dev, "no more free urbs\n");
                 count = -ENOMEM;
                 goto error_no_urb;
         }
@@ -221,7 +218,6 @@ static int opticon_write(struct tty_struct *tty, struct usb_serial_port *port,
          * to transmit data to de barcode device the control endpoint is used */
         dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_NOIO);
         if (!dr) {
-                dev_err(&port->dev, "out of memory\n");
                 count = -ENOMEM;
                 goto error_no_dr;
         }
diff --git a/drivers/usb/serial/oti6858.c b/drivers/usb/serial/oti6858.c
index a2080ac7b7e5..1dea599bb71b 100644
--- a/drivers/usb/serial/oti6858.c
+++ b/drivers/usb/serial/oti6858.c
@@ -200,8 +200,7 @@ static void setup_line(struct work_struct *work)
         int result;
 
         new_setup = kmalloc(OTI6858_CTRL_PKT_SIZE, GFP_KERNEL);
-        if (new_setup == NULL) {
-                dev_err(&port->dev, "%s(): out of memory!\n", __func__);
+        if (!new_setup) {
                 /* we will try again */
                 schedule_delayed_work(&priv->delayed_setup_work,
                                                 msecs_to_jiffies(2));
@@ -287,11 +286,9 @@ static void send_data(struct work_struct *work)
 
         if (count != 0) {
                 allow = kmalloc(1, GFP_KERNEL);
-                if (!allow) {
-                        dev_err_console(port, "%s(): kmalloc failed\n",
-                                        __func__);
+                if (!allow)
                         return;
-                }
+
                 result = usb_control_msg(port->serial->dev,
                                 usb_rcvctrlpipe(port->serial->dev, 0),
                                 OTI6858_REQ_T_CHECK_TXBUFF,
@@ -517,10 +514,8 @@ static int oti6858_open(struct tty_struct *tty, struct usb_serial_port *port)
         usb_clear_halt(serial->dev, port->read_urb->pipe);
 
         buf = kmalloc(OTI6858_CTRL_PKT_SIZE, GFP_KERNEL);
-        if (buf == NULL) {
-                dev_err(&port->dev, "%s(): out of memory!\n", __func__);
+        if (!buf)
                 return -ENOMEM;
-        }
 
         result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
                                 OTI6858_REQ_T_GET_STATUS,
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index 9a7dfa3738d9..3dd5398174c1 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -346,7 +346,6 @@ static void pl2303_set_termios(struct tty_struct *tty,
 
         buf = kzalloc(7, GFP_KERNEL);
         if (!buf) {
-                dev_err(&port->dev, "%s - out of memory.\n", __func__);
                 /* Report back no change occurred */
                 if (old_termios)
                         tty->termios = *old_termios;
diff --git a/drivers/usb/serial/quatech2.c b/drivers/usb/serial/quatech2.c
index a24d59ae4032..cb51dd757b56 100644
--- a/drivers/usb/serial/quatech2.c
+++ b/drivers/usb/serial/quatech2.c
@@ -676,10 +676,8 @@ static int qt2_setup_urbs(struct usb_serial *serial)
 
         serial_priv = usb_get_serial_data(serial);
         serial_priv->read_urb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!serial_priv->read_urb) {
-                dev_err(&serial->dev->dev, "No free urbs available\n");
+        if (!serial_priv->read_urb)
                 return -ENOMEM;
-        }
 
         usb_fill_bulk_urb(serial_priv->read_urb, serial->dev,
                           usb_rcvbulkpipe(serial->dev,
@@ -715,10 +713,8 @@ static int qt2_attach(struct usb_serial *serial)
         }
 
         serial_priv = kzalloc(sizeof(*serial_priv), GFP_KERNEL);
-        if (!serial_priv) {
-                dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
+        if (!serial_priv)
                 return -ENOMEM;
-        }
 
         serial_priv->read_buffer = kmalloc(QT2_READ_BUFFER_SIZE, GFP_KERNEL);
         if (!serial_priv->read_buffer) {
diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c
index de958c5b52e3..a9eb6221a815 100644
--- a/drivers/usb/serial/sierra.c
+++ b/drivers/usb/serial/sierra.c
@@ -497,14 +497,12 @@ static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,
 
         buffer = kmalloc(writesize, GFP_ATOMIC);
         if (!buffer) {
-                dev_err(&port->dev, "out of memory\n");
                 retval = -ENOMEM;
                 goto error_no_buffer;
         }
 
         urb = usb_alloc_urb(0, GFP_ATOMIC);
         if (!urb) {
-                dev_err(&port->dev, "no more free urbs\n");
                 retval = -ENOMEM;
                 goto error_no_urb;
         }
@@ -736,11 +734,8 @@ static struct urb *sierra_setup_urb(struct usb_serial *serial, int endpoint,
                 return NULL;
 
         urb = usb_alloc_urb(0, mem_flags);
-        if (urb == NULL) {
-                dev_dbg(&serial->dev->dev, "%s: alloc for endpoint %d failed\n",
-                        __func__, endpoint);
+        if (!urb)
                 return NULL;
-        }
 
         buf = kmalloc(len, mem_flags);
         if (buf) {
@@ -752,9 +747,6 @@ static struct urb *sierra_setup_urb(struct usb_serial *serial, int endpoint,
                 dev_dbg(&serial->dev->dev, "%s %c u : %p d:%p\n", __func__,
                                 dir == USB_DIR_IN ? 'i' : 'o', urb, buf);
         } else {
-                dev_dbg(&serial->dev->dev, "%s %c u:%p d:%p\n", __func__,
-                                dir == USB_DIR_IN ? 'i' : 'o', urb, buf);
-
                 sierra_release_urb(urb);
                 urb = NULL;
         }
diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c
index 4a649edaa2c0..698dc14b7d0d 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.c
+++ b/drivers/usb/serial/ti_usb_3410_5052.c
@@ -301,10 +301,9 @@ static int ti_startup(struct usb_serial *serial)
 
         /* create device structure */
         tdev = kzalloc(sizeof(struct ti_device), GFP_KERNEL);
-        if (tdev == NULL) {
-                dev_err(&dev->dev, "%s - out of memory\n", __func__);
+        if (!tdev)
                 return -ENOMEM;
-        }
+
         mutex_init(&tdev->td_open_close_lock);
         tdev->td_serial = serial;
         usb_set_serial_data(serial, tdev);
@@ -722,10 +721,8 @@ static void ti_set_termios(struct tty_struct *tty,
                 return;
 
         config = kmalloc(sizeof(*config), GFP_KERNEL);
-        if (!config) {
-                dev_err(&port->dev, "%s - out of memory\n", __func__);
+        if (!config)
                 return;
-        }
 
         config->wFlags = 0;
 
@@ -1194,10 +1191,8 @@ static int ti_get_lsr(struct ti_port *tport, u8 *lsr)
 
         size = sizeof(struct ti_port_status);
         data = kmalloc(size, GFP_KERNEL);
-        if (!data) {
-                dev_err(&port->dev, "%s - out of memory\n", __func__);
+        if (!data)
                 return -ENOMEM;
-        }
 
         status = ti_command_in_sync(tdev, TI_GET_PORT_STATUS,
                 (__u8)(TI_UART1_PORT+port_number), 0, (__u8 *)data, size);
@@ -1397,10 +1392,8 @@ static int ti_write_byte(struct usb_serial_port *port,
 
         size = sizeof(struct ti_write_data_bytes) + 2;
         data = kmalloc(size, GFP_KERNEL);
-        if (!data) {
-                dev_err(&port->dev, "%s - out of memory\n", __func__);
+        if (!data)
                 return -ENOMEM;
-        }
 
         data->bAddrType = TI_RW_DATA_ADDR_XDATA;
         data->bDataType = TI_RW_DATA_BYTE;
@@ -1516,7 +1509,6 @@ static int ti_download_firmware(struct ti_device *tdev)
                 status = ti_do_download(dev, pipe, buffer, fw_p->size);
                 kfree(buffer);
         } else {
-                dev_dbg(&dev->dev, "%s ENOMEM\n", __func__);
                 status = -ENOMEM;
         }
         release_firmware(fw_p);
diff --git a/drivers/usb/serial/usb_wwan.c b/drivers/usb/serial/usb_wwan.c
index 85365784040b..640fe0173236 100644
--- a/drivers/usb/serial/usb_wwan.c
+++ b/drivers/usb/serial/usb_wwan.c
@@ -447,12 +447,8 @@ static struct urb *usb_wwan_setup_urb(struct usb_serial_port *port,
         struct urb *urb;
 
         urb = usb_alloc_urb(0, GFP_KERNEL);     /* No ISO */
-        if (urb == NULL) {
-                dev_dbg(&serial->interface->dev,
-                        "%s: alloc for endpoint %d failed.\n", __func__,
-                        endpoint);
+        if (!urb)
                 return NULL;
-        }
 
         /* Fill URB using supplied data. */
         usb_fill_bulk_urb(urb, serial->dev,
diff --git a/drivers/usb/serial/visor.c b/drivers/usb/serial/visor.c
index ae016439e2cd..d93878541ee7 100644
--- a/drivers/usb/serial/visor.c
+++ b/drivers/usb/serial/visor.c
@@ -324,11 +324,8 @@ static int palm_os_3_probe(struct usb_serial *serial,
         int num_ports = 0;
 
         transfer_buffer = kmalloc(sizeof(*connection_info), GFP_KERNEL);
-        if (!transfer_buffer) {
-                dev_err(dev, "%s - kmalloc(%Zd) failed.\n", __func__,
-                        sizeof(*connection_info));
+        if (!transfer_buffer)
                 return -ENOMEM;
-        }
 
         /* send a get connection info request */
         retval = usb_control_msg(serial->dev,
@@ -419,11 +416,8 @@ static int palm_os_4_probe(struct usb_serial *serial,
         int retval;
 
         transfer_buffer =  kmalloc(sizeof(*connection_info), GFP_KERNEL);
-        if (!transfer_buffer) {
-                dev_err(dev, "%s - kmalloc(%Zd) failed.\n", __func__,
-                        sizeof(*connection_info));
+        if (!transfer_buffer)
                 return -ENOMEM;
-        }
 
         retval = usb_control_msg(serial->dev,
                                   usb_rcvctrlpipe(serial->dev, 0),
diff --git a/drivers/usb/serial/whiteheat.c b/drivers/usb/serial/whiteheat.c
index d23290e496ef..1d9d7008ad19 100644
--- a/drivers/usb/serial/whiteheat.c
+++ b/drivers/usb/serial/whiteheat.c
@@ -288,12 +288,8 @@ static int whiteheat_attach(struct usb_serial *serial)
 
         command_info = kmalloc(sizeof(struct whiteheat_command_private),
                                                                 GFP_KERNEL);
-        if (command_info == NULL) {
-                dev_err(&serial->dev->dev,
-                        "%s: Out of memory for port structures\n",
-                        serial->type->description);
+        if (!command_info)
                 goto no_command_private;
-        }
 
         mutex_init(&command_info->mutex);
         command_info->port_running = 0;