[PATCH] USB: kzalloc() conversion for rest of drivers/usb

Signed-off-by: Eric Sesterhenn <snakebyte@gmx.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

diff --git a/drivers/usb/host/ehci-mem.c b/drivers/usb/host/ehci-mem.c
index ec7eb3f4f867b9a456fb6dc55c2d37cef79e715d..766061e0260a5e96d6258149bc6f7f8a31f71ee9 100644 (file)
--- a/drivers/usb/host/ehci-mem.c
+++ b/drivers/usb/host/ehci-mem.c
@@ -220,13 +220,9 @@ static int ehci_mem_init (struct ehci_hcd *ehci, gfp_t flags)
                ehci->periodic [i] = EHCI_LIST_END;
 
        /* software shadow of hardware table */
-       ehci->pshadow = kmalloc (ehci->periodic_size * sizeof (void *), flags);
-       if (ehci->pshadow == NULL) {
-               goto fail;
-       }
-       memset (ehci->pshadow, 0, ehci->periodic_size * sizeof (void *));
-
-       return 0;
+       ehci->pshadow = kcalloc(ehci->periodic_size, sizeof(void *), flags);
+       if (ehci->pshadow != NULL)
+               return 0;
 
 fail:
        ehci_dbg (ehci, "couldn't init memory\n");

diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index 90d6900a37f47c5ba4814c5c3b71d29689e95f19..5871944e61459cca9cbd9fa85a992186b838c691 100644 (file)
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -864,9 +864,8 @@ iso_sched_alloc (unsigned packets, gfp_t mem_flags)
        int                     size = sizeof *iso_sched;
 
        size += packets * sizeof (struct ehci_iso_packet);
-       iso_sched = kmalloc (size, mem_flags);
+       iso_sched = kzalloc(size, mem_flags);
        if (likely (iso_sched != NULL)) {
-               memset(iso_sched, 0, size);
                INIT_LIST_HEAD (&iso_sched->td_list);
        }
        return iso_sched;

diff --git a/drivers/usb/host/hc_crisv10.c b/drivers/usb/host/hc_crisv10.c
index 641268d7e6f3ff650ebd3790cb1ece5637d25b81..2fe7fd19437b945fcf77da33a69ed174650c853d 100644 (file)
--- a/drivers/usb/host/hc_crisv10.c
+++ b/drivers/usb/host/hc_crisv10.c
@@ -2137,10 +2137,9 @@ static int etrax_usb_submit_bulk_urb(struct urb *urb)
        urb->status = -EINPROGRESS;
 
        /* Setup the hcpriv data. */
-       urb_priv = kmalloc(sizeof(etrax_urb_priv_t), KMALLOC_FLAG);
+       urb_priv = kzalloc(sizeof(etrax_urb_priv_t), KMALLOC_FLAG);
        assert(urb_priv != NULL);
        /* This sets rx_offset to 0. */
-       memset(urb_priv, 0, sizeof(etrax_urb_priv_t));
        urb_priv->urb_state = NOT_STARTED;
        urb->hcpriv = urb_priv;
 
@@ -2475,10 +2474,9 @@ static int etrax_usb_submit_ctrl_urb(struct urb *urb)
        urb->status = -EINPROGRESS;
 
        /* Setup the hcpriv data. */
-       urb_priv = kmalloc(sizeof(etrax_urb_priv_t), KMALLOC_FLAG);
+       urb_priv = kzalloc(sizeof(etrax_urb_priv_t), KMALLOC_FLAG);
        assert(urb_priv != NULL);
        /* This sets rx_offset to 0. */
-       memset(urb_priv, 0, sizeof(etrax_urb_priv_t));
        urb_priv->urb_state = NOT_STARTED;
        urb->hcpriv = urb_priv;
 
@@ -2767,9 +2765,8 @@ static void etrax_usb_add_to_intr_sb_list(struct urb *urb, int epid)
        maxlen = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
        interval = urb->interval;
 
-       urb_priv = kmalloc(sizeof(etrax_urb_priv_t), KMALLOC_FLAG);
+       urb_priv = kzalloc(sizeof(etrax_urb_priv_t), KMALLOC_FLAG);
        assert(urb_priv != NULL);
-       memset(urb_priv, 0, sizeof(etrax_urb_priv_t));
        urb->hcpriv = urb_priv;
 
        first_ep = &TxIntrEPList[0];
@@ -2997,9 +2994,8 @@ static void etrax_usb_add_to_isoc_sb_list(struct urb *urb, int epid)
 
        prev_sb_desc = next_sb_desc = temp_sb_desc = NULL;
 
-       urb_priv = kmalloc(sizeof(etrax_urb_priv_t), GFP_ATOMIC);
+       urb_priv = kzalloc(sizeof(etrax_urb_priv_t), GFP_ATOMIC);
        assert(urb_priv != NULL);
-       memset(urb_priv, 0, sizeof(etrax_urb_priv_t));
 
        urb->hcpriv = urb_priv;
        urb_priv->epid = epid;

diff --git a/drivers/usb/media/ov511.c b/drivers/usb/media/ov511.c
index 1d887ec06080dc2e05beeff67bedac584ef271f1..da44579d6f29105e725ebce6da7332b7bc9f295c 100644 (file)
--- a/drivers/usb/media/ov511.c
+++ b/drivers/usb/media/ov511.c
@@ -5686,13 +5686,11 @@ ov51x_probe(struct usb_interface *intf, const struct usb_device_id *id)
        if (idesc->bInterfaceSubClass != 0x00)
                return -ENODEV;
 
-       if ((ov = kmalloc(sizeof(*ov), GFP_KERNEL)) == NULL) {
+       if ((ov = kzalloc(sizeof(*ov), GFP_KERNEL)) == NULL) {
                err("couldn't kmalloc ov struct");
                goto error_out;
        }
 
-       memset(ov, 0, sizeof(*ov));
-
        ov->dev = dev;
        ov->iface = idesc->bInterfaceNumber;
        ov->led_policy = led;

diff --git a/drivers/usb/media/pwc/pwc-if.c b/drivers/usb/media/pwc/pwc-if.c
index db6753dc5ba55a76368aec886a4c7620f9e50600..90eb26042817677f48f8552f45bda1cb7a3223a9 100644 (file)
--- a/drivers/usb/media/pwc/pwc-if.c
+++ b/drivers/usb/media/pwc/pwc-if.c
@@ -1867,12 +1867,11 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
                Info("Warning: more than 1 configuration available.\n");
 
        /* Allocate structure, initialize pointers, mutexes, etc. and link it to the usb_device */
-       pdev = kmalloc(sizeof(struct pwc_device), GFP_KERNEL);
+       pdev = kzalloc(sizeof(struct pwc_device), GFP_KERNEL);
        if (pdev == NULL) {
                Err("Oops, could not allocate memory for pwc_device.\n");
                return -ENOMEM;
        }
-       memset(pdev, 0, sizeof(struct pwc_device));
        pdev->type = type_id;
        pdev->vsize = default_size;
        pdev->vframes = default_fps;

diff --git a/drivers/usb/media/se401.c b/drivers/usb/media/se401.c
index 8c3b1ad8a8fd4f1b5613eb6e24bd6f151c45987b..f03ea7f89596356db55cbc780722d9df177b9b21 100644 (file)
--- a/drivers/usb/media/se401.c
+++ b/drivers/usb/media/se401.c
@@ -1345,13 +1345,11 @@ static int se401_probe(struct usb_interface *intf,
         /* We found one */
         info("SE401 camera found: %s", camera_name);
 
-        if ((se401 = kmalloc(sizeof(*se401), GFP_KERNEL)) == NULL) {
+        if ((se401 = kzalloc(sizeof(*se401), GFP_KERNEL)) == NULL) {
                 err("couldn't kmalloc se401 struct");
                return -ENOMEM;
         }
 
-        memset(se401, 0, sizeof(*se401));
-
         se401->dev = dev;
         se401->iface = interface->bInterfaceNumber;
         se401->camera_name = camera_name;

diff --git a/drivers/usb/media/stv680.c b/drivers/usb/media/stv680.c
index b1a6be2958ed920c2ed73eff3db388e4bcc97ba3..9636da20748d56fa288148bc780b7cb91db716c1 100644 (file)
--- a/drivers/usb/media/stv680.c
+++ b/drivers/usb/media/stv680.c
@@ -318,12 +318,11 @@ static int stv_init (struct usb_stv *stv680)
        unsigned char *buffer;
        unsigned long int bufsize;
 
-       buffer = kmalloc (40, GFP_KERNEL);
+       buffer = kzalloc (40, GFP_KERNEL);
        if (buffer == NULL) {
                PDEBUG (0, "STV(e): Out of (small buf) memory");
                return -1;
        }
-       memset (buffer, 0, 40);
        udelay (100);
 
        /* set config 1, interface 0, alternate 0 */
@@ -1388,14 +1387,12 @@ static int stv680_probe (struct usb_interface *intf, const struct usb_device_id
                goto error;
        }
        /* We found one */
-       if ((stv680 = kmalloc (sizeof (*stv680), GFP_KERNEL)) == NULL) {
+       if ((stv680 = kzalloc (sizeof (*stv680), GFP_KERNEL)) == NULL) {
                PDEBUG (0, "STV(e): couldn't kmalloc stv680 struct.");
                retval = -ENOMEM;
                goto error;
        }
 
-       memset (stv680, 0, sizeof (*stv680));
-
        stv680->udev = dev;
        stv680->camera_name = camera_name;
 

diff --git a/drivers/usb/misc/auerswald.c b/drivers/usb/misc/auerswald.c
index ad2f4cccd3889d7a6b55dc973600000deb686cd7..1fef36e71c573ed10dc05b2de5240816e87fa0c5 100644 (file)
--- a/drivers/usb/misc/auerswald.c
+++ b/drivers/usb/misc/auerswald.c
@@ -570,10 +570,9 @@ static int auerchain_setup (pauerchain_t acp, unsigned int numElements)
 
         /* fill the list of free elements */
         for (;numElements; numElements--) {
-                acep = (pauerchainelement_t) kmalloc (sizeof (auerchainelement_t), GFP_KERNEL);
+                acep = kzalloc(sizeof(auerchainelement_t), GFP_KERNEL);
                 if (!acep)
                        goto ac_fail;
-               memset (acep, 0, sizeof (auerchainelement_t));
                 INIT_LIST_HEAD (&acep->list);
                 list_add_tail (&acep->list, &acp->free_list);
         }
@@ -761,10 +760,9 @@ static int auerbuf_setup (pauerbufctl_t bcp, unsigned int numElements, unsigned
 
         /* fill the list of free elements */
         for (;numElements; numElements--) {
-                bep = (pauerbuf_t) kmalloc (sizeof (auerbuf_t), GFP_KERNEL);
+                bep = kzalloc(sizeof(auerbuf_t), GFP_KERNEL);
                 if (!bep)
                        goto bl_fail;
-               memset (bep, 0, sizeof (auerbuf_t));
                 bep->list = bcp;
                 INIT_LIST_HEAD (&bep->buff_list);
                 bep->bufp = kmalloc (bufsize, GFP_KERNEL);

diff --git a/drivers/usb/misc/usblcd.c b/drivers/usb/misc/usblcd.c
index cc3dae3f34e0361ae6b0b70a7b574d3eaf929fce..c82c402285a0d42ced463dcd87084ca5f4d540cf 100644 (file)
--- a/drivers/usb/misc/usblcd.c
+++ b/drivers/usb/misc/usblcd.c
@@ -270,12 +270,11 @@ static int lcd_probe(struct usb_interface *interface, const struct usb_device_id
        int retval = -ENOMEM;
 
        /* allocate memory for our device state and initialize it */
-       dev = kmalloc(sizeof(*dev), GFP_KERNEL);
+       dev = kzalloc(sizeof(*dev), GFP_KERNEL);
        if (dev == NULL) {
                err("Out of memory");
                goto error;
        }
-       memset(dev, 0x00, sizeof(*dev));
        kref_init(&dev->kref);
 
        dev->udev = usb_get_dev(interface_to_usbdev(interface));

diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c
index 84fa1728f052969d527ded2e85ffa31e78810784..9d59b901841cc46908dde0aea2cb64e218992731 100644 (file)
--- a/drivers/usb/misc/usbtest.c
+++ b/drivers/usb/misc/usbtest.c
@@ -382,12 +382,11 @@ alloc_sglist (int nents, int max, int vary)
        for (i = 0; i < nents; i++) {
                char            *buf;
 
-               buf = kmalloc (size, SLAB_KERNEL);
+               buf = kzalloc (size, SLAB_KERNEL);
                if (!buf) {
                        free_sglist (sg, i);
                        return NULL;
                }
-               memset (buf, 0, size);
 
                /* kmalloc pages are always physically contiguous! */
                sg_init_one(&sg[i], buf, size);
@@ -842,10 +841,9 @@ test_ctrl_queue (struct usbtest_dev *dev, struct usbtest_param *param)
         * as with bulk/intr sglists, sglen is the queue depth; it also
         * controls which subtests run (more tests than sglen) or rerun.
         */
-       urb = kmalloc (param->sglen * sizeof (struct urb *), SLAB_KERNEL);
+       urb = kcalloc(param->sglen, sizeof(struct urb *), SLAB_KERNEL);
        if (!urb)
                return -ENOMEM;
-       memset (urb, 0, param->sglen * sizeof (struct urb *));
        for (i = 0; i < param->sglen; i++) {
                int                     pipe = usb_rcvctrlpipe (udev, 0);
                unsigned                len;
@@ -1865,10 +1863,9 @@ usbtest_probe (struct usb_interface *intf, const struct usb_device_id *id)
        }
 #endif
 
-       dev = kmalloc (sizeof *dev, SLAB_KERNEL);
+       dev = kzalloc(sizeof(*dev), SLAB_KERNEL);
        if (!dev)
                return -ENOMEM;
-       memset (dev, 0, sizeof *dev);
        info = (struct usbtest_info *) id->driver_info;
        dev->info = info;
        init_MUTEX (&dev->sem);

diff --git a/drivers/usb/mon/mon_main.c b/drivers/usb/mon/mon_main.c
index b03e346e33f1181ffae27c7cd9c83f8ab207209e..6ecc273022117351f9d155e3d16ab6d3a8a7ab34 100644 (file)
--- a/drivers/usb/mon/mon_main.c
+++ b/drivers/usb/mon/mon_main.c
@@ -277,9 +277,8 @@ static void mon_bus_init(struct dentry *mondir, struct usb_bus *ubus)
        char name[NAMESZ];
        int rc;
 
-       if ((mbus = kmalloc(sizeof(struct mon_bus), GFP_KERNEL)) == NULL)
+       if ((mbus = kzalloc(sizeof(struct mon_bus), GFP_KERNEL)) == NULL)
                goto err_alloc;
-       memset(mbus, 0, sizeof(struct mon_bus));
        kref_init(&mbus->ref);
        spin_lock_init(&mbus->lock);
        INIT_LIST_HEAD(&mbus->r_list);

diff --git a/drivers/usb/mon/mon_text.c b/drivers/usb/mon/mon_text.c
index 59089e8b7e5e473abe02fdbf5bc1be5d18603438..ac043ec2b8dcece7b124b8917bd21ab69a1c70ad 100644 (file)
--- a/drivers/usb/mon/mon_text.c
+++ b/drivers/usb/mon/mon_text.c
@@ -213,12 +213,11 @@ static int mon_text_open(struct inode *inode, struct file *file)
        mbus = inode->u.generic_ip;
        ubus = mbus->u_bus;
 
-       rp = kmalloc(sizeof(struct mon_reader_text), GFP_KERNEL);
+       rp = kzalloc(sizeof(struct mon_reader_text), GFP_KERNEL);
        if (rp == NULL) {
                rc = -ENOMEM;
                goto err_alloc;
        }
-       memset(rp, 0, sizeof(struct mon_reader_text));
        INIT_LIST_HEAD(&rp->e_list);
        init_waitqueue_head(&rp->wait);
        mutex_init(&rp->printf_lock);

diff --git a/drivers/usb/net/zd1201.c b/drivers/usb/net/zd1201.c
index f3a8e2807c3b8afd87d605e12ff50849d1adcb28..fe9b60cd8d9519924427e9c4d2ca563224d37031 100644 (file)
--- a/drivers/usb/net/zd1201.c
+++ b/drivers/usb/net/zd1201.c
@@ -621,10 +621,9 @@ static int zd1201_drvr_start(struct zd1201 *zd)
        __le16 zdmax;
        unsigned char *buffer;
        
-       buffer = kmalloc(ZD1201_RXSIZE, GFP_KERNEL);
+       buffer = kzalloc(ZD1201_RXSIZE, GFP_KERNEL);
        if (!buffer)
                return -ENOMEM;
-       memset(buffer, 0, ZD1201_RXSIZE);
 
        usb_fill_bulk_urb(zd->rx_urb, zd->usb, 
            usb_rcvbulkpipe(zd->usb, zd->endp_in), buffer, ZD1201_RXSIZE,
@@ -1750,11 +1749,9 @@ static int zd1201_probe(struct usb_interface *interface,
 
        usb = interface_to_usbdev(interface);
 
-       zd = kmalloc(sizeof(struct zd1201), GFP_KERNEL);
-       if (!zd) {
+       zd = kzalloc(sizeof(struct zd1201), GFP_KERNEL);
+       if (!zd)
                return -ENOMEM;
-       }
-       memset(zd, 0, sizeof(struct zd1201));
        zd->ap = ap;
        zd->usb = usb;
        zd->removed = 0;

diff --git a/drivers/usb/serial/cp2101.c b/drivers/usb/serial/cp2101.c
index dc7a069503e04528eeb03dfae7b55237e6ead0eb..9ea7b4a4a22b5cc8f9a2b4f724e3faabbed00c26 100644 (file)
--- a/drivers/usb/serial/cp2101.c
+++ b/drivers/usb/serial/cp2101.c
@@ -169,9 +169,7 @@ static int cp2101_get_config(struct usb_serial_port* port, u8 request,
        /* Number of integers required to contain the array */
        length = (((size - 1) | 3) + 1)/4;
 
-       buf = kmalloc (length * sizeof(u32), GFP_KERNEL);
-       memset(buf, 0, length * sizeof(u32));
-
+       buf = kcalloc(length, sizeof(u32), GFP_KERNEL);
        if (!buf) {
                dev_err(&port->dev, "%s - out of memory.\n", __FUNCTION__);
                return -ENOMEM;

diff --git a/drivers/usb/serial/cypress_m8.c b/drivers/usb/serial/cypress_m8.c
index 68067fe117a46ab25d0ce71695643095eea2fdc3..71af3bf5adb7434763f5c9ebbb0fb11ec8c9f24c 100644 (file)
--- a/drivers/usb/serial/cypress_m8.c
+++ b/drivers/usb/serial/cypress_m8.c
@@ -435,11 +435,10 @@ static int generic_startup (struct usb_serial *serial)
 
        dbg("%s - port %d", __FUNCTION__, serial->port[0]->number);
 
-       priv = kmalloc(sizeof (struct cypress_private), GFP_KERNEL);
+       priv = kzalloc(sizeof (struct cypress_private), GFP_KERNEL);
        if (!priv)
                return -ENOMEM;
 
-       memset(priv, 0x00, sizeof (struct cypress_private));
        spin_lock_init(&priv->lock);
        priv->buf = cypress_buf_alloc(CYPRESS_BUF_SIZE);
        if (priv->buf == NULL) {

diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index c145e1ed8429d6bdf813bb534b441c2db1d149e0..ece52a6328b5c72d14de51b231468f87cb2f7d16 100644 (file)
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -1141,12 +1141,11 @@ static int ftdi_sio_attach (struct usb_serial *serial)
        
        dbg("%s",__FUNCTION__);
 
-       priv = kmalloc(sizeof(struct ftdi_private), GFP_KERNEL);
+       priv = kzalloc(sizeof(struct ftdi_private), GFP_KERNEL);
        if (!priv){
                err("%s- kmalloc(%Zd) failed.", __FUNCTION__, sizeof(struct ftdi_private));
                return -ENOMEM;
        }
-       memset(priv, 0, sizeof(*priv));
 
        spin_lock_init(&priv->rx_lock);
         init_waitqueue_head(&priv->delta_msr_wait);

diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c
index d6f55e9dccae26433fc066273c1a0858943c27fb..5ec9bf5bac8dc635608dd195db4bc51277174b83 100644 (file)
--- a/drivers/usb/serial/garmin_gps.c
+++ b/drivers/usb/serial/garmin_gps.c
@@ -1422,12 +1422,11 @@ static int garmin_attach (struct usb_serial *serial)
 
        dbg("%s", __FUNCTION__);
 
-       garmin_data_p = kmalloc (sizeof(struct garmin_data), GFP_KERNEL);
+       garmin_data_p = kzalloc(sizeof(struct garmin_data), GFP_KERNEL);
        if (garmin_data_p == NULL) {
                dev_err(&port->dev, "%s - Out of memory\n", __FUNCTION__);
                return -ENOMEM;
        }
-       memset (garmin_data_p, 0, sizeof(struct garmin_data));
        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 3f29e6b0fd196ca95e7c47537d3f3c23e856db2c..b606c596810283a292c96df327f9f8d1f1b12b94 100644 (file)
--- a/drivers/usb/serial/io_edgeport.c
+++ b/drivers/usb/serial/io_edgeport.c
@@ -2725,12 +2725,11 @@ static int edge_startup (struct usb_serial *serial)
        dev = serial->dev;
 
        /* create our private serial structure */
-       edge_serial = kmalloc (sizeof(struct edgeport_serial), GFP_KERNEL);
+       edge_serial = kzalloc(sizeof(struct edgeport_serial), GFP_KERNEL);
        if (edge_serial == NULL) {
                dev_err(&serial->dev->dev, "%s - Out of memory\n", __FUNCTION__);
                return -ENOMEM;
        }
-       memset (edge_serial, 0, sizeof(struct edgeport_serial));
        spin_lock_init(&edge_serial->es_lock);
        edge_serial->serial = serial;
        usb_set_serial_data(serial, edge_serial);

diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c
index afc0f34b3a4695cc0ead14ad98368035d08da6a7..8e1e2253748bfaa2e2f72a768de4f70e802165cb 100644 (file)
--- a/drivers/usb/serial/io_ti.c
+++ b/drivers/usb/serial/io_ti.c
@@ -2727,12 +2727,11 @@ static int edge_startup (struct usb_serial *serial)
        dev = serial->dev;
 
        /* create our private serial structure */
-       edge_serial = kmalloc (sizeof(struct edgeport_serial), GFP_KERNEL);
+       edge_serial = kzalloc(sizeof(struct edgeport_serial), GFP_KERNEL);
        if (edge_serial == NULL) {
                dev_err(&serial->dev->dev, "%s - Out of memory\n", __FUNCTION__);
                return -ENOMEM;
        }
-       memset (edge_serial, 0, sizeof(struct edgeport_serial));
        sema_init(&edge_serial->es_sem, 1);
        edge_serial->serial = serial;
        usb_set_serial_data(serial, edge_serial);
@@ -2745,12 +2744,11 @@ static int edge_startup (struct usb_serial *serial)
 
        /* set up our port private structures */
        for (i = 0; i < serial->num_ports; ++i) {
-               edge_port = kmalloc (sizeof(struct edgeport_port), GFP_KERNEL);
+               edge_port = kzalloc(sizeof(struct edgeport_port), GFP_KERNEL);
                if (edge_port == NULL) {
                        dev_err(&serial->dev->dev, "%s - Out of memory\n", __FUNCTION__);
                        goto cleanup;
                }
-               memset (edge_port, 0, sizeof(struct edgeport_port));
                spin_lock_init(&edge_port->ep_lock);
                edge_port->ep_out_buf = edge_buf_alloc(EDGE_OUT_BUF_SIZE);
                if (edge_port->ep_out_buf == NULL) {

diff --git a/drivers/usb/serial/ir-usb.c b/drivers/usb/serial/ir-usb.c
index a59010421444b9419bd0e3990f87cf8b2dd9edf5..426182ddc42a871d758ae8fc400f460138fd38f5 100644 (file)
--- a/drivers/usb/serial/ir-usb.c
+++ b/drivers/usb/serial/ir-usb.c
@@ -184,10 +184,9 @@ static struct irda_class_desc *irda_usb_find_class_desc(struct usb_device *dev,
        struct irda_class_desc *desc;
        int ret;
                
-       desc = kmalloc(sizeof (struct irda_class_desc), GFP_KERNEL);
+       desc = kzalloc(sizeof (struct irda_class_desc), GFP_KERNEL);
        if (desc == NULL) 
                return NULL;
-       memset(desc, 0, sizeof(struct irda_class_desc));
        
        ret = usb_control_msg(dev, usb_rcvctrlpipe(dev,0),
                        IU_REQ_GET_CLASS_DESC,

diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
index 3b958e60f5e8ee717513d3f0d35cb36c0425db94..052b735c4fbddd20daae7b80a6ad65768894ad31 100644 (file)
--- a/drivers/usb/serial/keyspan.c
+++ b/drivers/usb/serial/keyspan.c
@@ -2250,12 +2250,11 @@ static int keyspan_startup (struct usb_serial *serial)
        }
 
        /* Setup private data for serial driver */
-       s_priv = kmalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL);
+       s_priv = kzalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL);
        if (!s_priv) {
                dbg("%s - kmalloc for keyspan_serial_private failed.", __FUNCTION__);
                return -ENOMEM;
        }
-       memset(s_priv, 0, sizeof(struct keyspan_serial_private));
 
        s_priv->device_details = d_details;
        usb_set_serial_data(serial, s_priv);
@@ -2263,12 +2262,11 @@ static int keyspan_startup (struct usb_serial *serial)
        /* Now setup per port private data */
        for (i = 0; i < serial->num_ports; i++) {
                port = serial->port[i];
-               p_priv = kmalloc(sizeof(struct keyspan_port_private), GFP_KERNEL);
+               p_priv = kzalloc(sizeof(struct keyspan_port_private), GFP_KERNEL);
                if (!p_priv) {
                        dbg("%s - kmalloc for keyspan_port_private (%d) failed!.", __FUNCTION__, i);
                        return (1);
                }
-               memset(p_priv, 0, sizeof(struct keyspan_port_private));
                p_priv->device_details = d_details;
                usb_set_serial_port_data(port, p_priv);
        }

diff --git a/drivers/usb/serial/kobil_sct.c b/drivers/usb/serial/kobil_sct.c
index b8b213185d0f05ea6fc3d6a142962e039fea75ea..87dfcd89ffabf44316fefa86d18cf4ecb1f077ce 100644 (file)
--- a/drivers/usb/serial/kobil_sct.c
+++ b/drivers/usb/serial/kobil_sct.c
@@ -255,11 +255,9 @@ static int kobil_open (struct usb_serial_port *port, struct file *filp)
        }
        
        // allocate memory for transfer buffer
-       transfer_buffer = (unsigned char *) kmalloc(transfer_buffer_length, GFP_KERNEL);  
+       transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
        if (! transfer_buffer) {
                return -ENOMEM;
-       } else {
-               memset(transfer_buffer, 0, transfer_buffer_length);
        }
        
        // allocate write_urb
@@ -383,11 +381,10 @@ static void kobil_read_int_callback( struct urb *purb, struct pt_regs *regs)
                
                // BEGIN DEBUG
                /*
-                 dbg_data = (unsigned char *) kmalloc((3 *  purb->actual_length + 10) * sizeof(char), GFP_KERNEL);
+                 dbg_data = kzalloc((3 *  purb->actual_length + 10) * sizeof(char), GFP_KERNEL);
                  if (! dbg_data) {
                  return;
                  }
-                 memset(dbg_data, 0, (3 *  purb->actual_length + 10));
                  for (i = 0; i < purb->actual_length; i++) { 
                  sprintf(dbg_data +3*i, "%02X ", data[i]); 
                  }
@@ -518,11 +515,10 @@ static int kobil_tiocmget(struct usb_serial_port *port, struct file *file)
        }
 
        // allocate memory for transfer buffer
-       transfer_buffer = (unsigned char *) kmalloc(transfer_buffer_length, GFP_KERNEL);  
+       transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
        if (!transfer_buffer) {
                return -ENOMEM;
        }
-       memset(transfer_buffer, 0, transfer_buffer_length);
 
        result = usb_control_msg( port->serial->dev, 
                                  usb_rcvctrlpipe(port->serial->dev, 0 ), 
@@ -564,11 +560,10 @@ static int  kobil_tiocmset(struct usb_serial_port *port, struct file *file,
        }
 
        // allocate memory for transfer buffer
-       transfer_buffer = (unsigned char *) kmalloc(transfer_buffer_length, GFP_KERNEL);
+       transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
        if (! transfer_buffer) {
                return -ENOMEM;
        }
-       memset(transfer_buffer, 0, transfer_buffer_length);
 
        if (set & TIOCM_RTS)
                rts = 1;
@@ -655,11 +650,10 @@ static int  kobil_ioctl(struct usb_serial_port *port, struct file *file,
                                                   (struct termios __user *)arg))
                        return -EFAULT;
                
-               settings = (unsigned char *) kmalloc(50, GFP_KERNEL);  
+               settings = kzalloc(50, GFP_KERNEL);
                if (! settings) {
                        return -ENOBUFS;
                }
-               memset(settings, 0, 50);
 
                switch (priv->internal_termios.c_cflag & CBAUD) {
                case B1200:

diff --git a/drivers/usb/serial/mct_u232.c b/drivers/usb/serial/mct_u232.c
index b6d6cab9c85911831fd046d8926f8e0cbf1df084..35bd29b6c408e50967f177b12aeab5d71af8ae60 100644 (file)
--- a/drivers/usb/serial/mct_u232.c
+++ b/drivers/usb/serial/mct_u232.c
@@ -348,10 +348,9 @@ static int mct_u232_startup (struct usb_serial *serial)
        struct mct_u232_private *priv;
        struct usb_serial_port *port, *rport;
 
-       priv = kmalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
+       priv = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
        if (!priv)
                return -ENOMEM;
-       memset(priv, 0, sizeof(struct mct_u232_private));
        spin_lock_init(&priv->lock);
        usb_set_serial_port_data(serial->port[0], priv);
 

diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 52bdf6fe46f27b59df7f69ac35fb6e6bb06c7e48..a8455c9e79ddd4b688695765df59b9588df8f2ba 100644 (file)
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -631,13 +631,12 @@ static int option_startup(struct usb_serial *serial)
        /* Now setup per port private data */
        for (i = 0; i < serial->num_ports; i++) {
                port = serial->port[i];
-               portdata = kmalloc(sizeof(*portdata), GFP_KERNEL);
+               portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
                if (!portdata) {
                        dbg("%s: kmalloc for option_port_private (%d) failed!.",
                                        __FUNCTION__, i);
                        return (1);
                }
-               memset(portdata, 0, sizeof(struct option_port_private));
 
                usb_set_serial_port_data(port, portdata);
 

diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index 37c81c08faadcb19a15442ff2cfbd89126d09bbc..cf2213bae0e07507af59877c73aeaf5019693a62 100644 (file)
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -218,10 +218,9 @@ static int pl2303_startup (struct usb_serial *serial)
        dbg("device type: %d", type);
 
        for (i = 0; i < serial->num_ports; ++i) {
-               priv = kmalloc (sizeof (struct pl2303_private), GFP_KERNEL);
+               priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
                if (!priv)
                        goto cleanup;
-               memset (priv, 0x00, sizeof (struct pl2303_private));
                spin_lock_init(&priv->lock);
                priv->buf = pl2303_buf_alloc(PL2303_BUF_SIZE);
                if (priv->buf == NULL) {
@@ -383,12 +382,11 @@ static void pl2303_set_termios (struct usb_serial_port *port, struct termios *ol
                }
        }
 
-       buf = kmalloc (7, GFP_KERNEL);
+       buf = kzalloc (7, GFP_KERNEL);
        if (!buf) {
                dev_err(&port->dev, "%s - out of memory.\n", __FUNCTION__);
                return;
        }
-       memset (buf, 0x00, 0x07);
        
        i = usb_control_msg (serial->dev, usb_rcvctrlpipe (serial->dev, 0),
                             GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,

diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c
index c18db325707311ca29fd7e0a9dc516027932fc1e..c3a2071b802d283de1d6a9a520b883925f698e32 100644 (file)
--- a/drivers/usb/serial/ti_usb_3410_5052.c
+++ b/drivers/usb/serial/ti_usb_3410_5052.c
@@ -416,12 +416,11 @@ static int ti_startup(struct usb_serial *serial)
            dev->actconfig->desc.bConfigurationValue);
 
        /* create device structure */
-       tdev = kmalloc(sizeof(struct ti_device), GFP_KERNEL);
+       tdev = kzalloc(sizeof(struct ti_device), GFP_KERNEL);
        if (tdev == NULL) {
                dev_err(&dev->dev, "%s - out of memory\n", __FUNCTION__);
                return -ENOMEM;
        }
-       memset(tdev, 0, sizeof(struct ti_device));
        sema_init(&tdev->td_open_close_sem, 1);
        tdev->td_serial = serial;
        usb_set_serial_data(serial, tdev);

diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index b5c96e74a903c2eb466c56259b7444606780a068..097f4e8488feb2788b42699e48a4010fc5ab8a3f 100644 (file)
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -564,12 +564,11 @@ static struct usb_serial * create_serial (struct usb_device *dev,
 {
        struct usb_serial *serial;
 
-       serial = kmalloc (sizeof (*serial), GFP_KERNEL);
+       serial = kzalloc(sizeof(*serial), GFP_KERNEL);
        if (!serial) {
                dev_err(&dev->dev, "%s - out of memory\n", __FUNCTION__);
                return NULL;
        }
-       memset (serial, 0, sizeof(*serial));
        serial->dev = usb_get_dev(dev);
        serial->type = driver;
        serial->interface = interface;
@@ -778,10 +777,9 @@ int usb_serial_probe(struct usb_interface *interface,
        serial->num_port_pointers = max_endpoints;
        dbg("%s - setting up %d port structures for this device", __FUNCTION__, max_endpoints);
        for (i = 0; i < max_endpoints; ++i) {
-               port = kmalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
+               port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
                if (!port)
                        goto probe_error;
-               memset(port, 0x00, sizeof(struct usb_serial_port));
                port->number = i + serial->minor;
                port->serial = serial;
                spin_lock_init(&port->lock);

diff --git a/drivers/usb/serial/visor.c b/drivers/usb/serial/visor.c
index 11a48d8747526a31355eb306fdac9cbefa6103dd..f5c3841d4843f7dc1cec0d681ee62dd42dfad322 100644 (file)
--- a/drivers/usb/serial/visor.c
+++ b/drivers/usb/serial/visor.c
@@ -763,10 +763,9 @@ static int generic_startup(struct usb_serial *serial)
        int i;
 
        for (i = 0; i < serial->num_ports; ++i) {
-               priv = kmalloc (sizeof(*priv), GFP_KERNEL);
+               priv = kzalloc (sizeof(*priv), GFP_KERNEL);
                if (!priv)
                        return -ENOMEM;
-               memset (priv, 0x00, sizeof(*priv));
                spin_lock_init(&priv->lock);
                usb_set_serial_port_data(serial->port[i], priv);
        }

diff --git a/drivers/usb/storage/isd200.c b/drivers/usb/storage/isd200.c
index 7308e8cbe8f972320c7dfcc76b6fabd1dca520c3..6831dca93c1bd9643ea6ebc7c7b4c15a21a4f2ac 100644 (file)
--- a/drivers/usb/storage/isd200.c
+++ b/drivers/usb/storage/isd200.c
@@ -1382,7 +1382,7 @@ static int isd200_init_info(struct us_data *us)
        } else
                US_DEBUGP("ERROR - kmalloc failure\n");
 
-       return(retStatus);
+       return retStatus;
 }
 
 /**************************************************************************