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>

diff --git a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c
index c2a4171ab9cb7f962ca32b07a85e8d2f37630d10..8908760cca9fa4eed2430f4438f16cd2d3b42273 100644 (file)
--- 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 c69bb50d46635dfb2148f580739f99b46c5602dc..b5b8dcbb33a202e38e34593edb9b8f5c7e04a4e2 100644 (file)
--- 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 6987b535aa9896b1b8da93757412109adf0769d0..95fa1217afdd7e8184377ead839c37815229a640 100644 (file)
--- 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 b3f712f8cf178a2c7e0c418c39a32fe2089ce886..a4bebacc5caef232b631f184d7e2c9f72820e6c7 100644 (file)
--- 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 04b5ed90ffb2ded9739407e081e4dd4f52794e69..f4ee74da44e847d71afb12f451e2c94cacbf3a85 100644 (file)
--- 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 9c79fb22f3415dd18d7ba28f7013e894188bf4b9..0dd8cce9c9d360cdf8008e39e185f1d64351ad4d 100644 (file)
--- 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 2b3b7bfeb332ea853bc74ee50c68e69183628eaf..a673f4b25b08ac05813ab87ec357f8efe71cef43 100644 (file)
--- 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 716930ab1bb1931b114b82572717565d820b9c04..73956d48a0c57bb5566fb0c1b47a581e438bb4a1 100644 (file)
--- 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 d6960aebe246f24b623132c1c2eeca5f6484832e..6125fce7d0f6f1c43485a790e55e382e13ad857d 100644 (file)
--- 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 1b4054fe52a5fccf85d4be4cbe4cbb3b30ff03b7..4f441c2c0668312e2f4bb8155af9ed5e95ab6a0a 100644 (file)
--- 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 b739a1732b7671daf1a3d4a0f7de8c9f5f62f063..ee68191e87c62ee0d4ba667ae15937b77f607e28 100644 (file)
--- 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 bc176ae61743c19495a9d59c6c53fd1e8628e4ea..2496e71e406aac662cb7df76b58adb39a1ab6dfa 100644 (file)
--- 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 1b4f1d2479c108ddab303067f97ae4a1cee4b5e8..90c77b20c883763b6be0ae1648993f3244044947 100644 (file)
--- 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 a2080ac7b7e5d696d89bee64f6b2ab72af1add3a..1dea599bb71bb2ff9072fc15210b974ca907a066 100644 (file)
--- 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 9a7dfa3738d9db7e1e353758a2c2aa7627409ade..3dd5398174c1f3f59724b81657f8b9ece3d00130 100644 (file)
--- 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 a24d59ae403277b0f474458c2387e28a7a234577..cb51dd757b5632a776a719da793a9dde996c5fea 100644 (file)
--- 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 de958c5b52e33ea5b7c3ff23efe42d33322bdeb4..a9eb6221a8155a0cd0882f2f5d50acab7c75c7f2 100644 (file)
--- 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 4a649edaa2c0004fbb7f1957ccfc0ae7a0e51975..698dc14b7d0d41cda14ed856a53ea25606d83010 100644 (file)
--- 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 85365784040b28a2c8c92a23ff4f4d5fe758834e..640fe0173236807c3178d53265da8588a01cb730 100644 (file)
--- 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 ae016439e2cd6d56f81788aca52fbbe3a33771fa..d93878541ee7ff0d35228be68b6383d8cf5c2abe 100644 (file)
--- 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 d23290e496ef2f6411dd450875691560ee34061c..1d9d7008ad19aca13bbc5160cea414ab8260c3cb 100644 (file)
--- 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;