V4L/DVB (3344a): Conversions from kmalloc+memset to k(z|c)alloc
authorPanagiotis Issaris <takis@issaris.org>
Wed, 11 Jan 2006 21:40:56 +0000 (19:40 -0200)
committerMauro Carvalho Chehab <mchehab@brturbo.com.br>
Wed, 11 Jan 2006 21:40:56 +0000 (19:40 -0200)
Conversions from kmalloc+memset to k(z|c)alloc.

Signed-off-by: Panagiotis Issaris <takis@issaris.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>
82 files changed:
drivers/media/common/saa7146_core.c
drivers/media/common/saa7146_fops.c
drivers/media/dvb/b2c2/flexcop.c
drivers/media/dvb/bt8xx/dvb-bt8xx.c
drivers/media/dvb/dvb-core/dvb_ca_en50221.c
drivers/media/dvb/dvb-core/dvb_frontend.c
drivers/media/dvb/dvb-usb/dtt200u-fe.c
drivers/media/dvb/dvb-usb/dvb-usb-init.c
drivers/media/dvb/dvb-usb/dvb-usb-urb.c
drivers/media/dvb/dvb-usb/vp702x-fe.c
drivers/media/dvb/dvb-usb/vp7045-fe.c
drivers/media/dvb/frontends/bcm3510.c
drivers/media/dvb/frontends/dib3000mb.c
drivers/media/dvb/frontends/dib3000mc.c
drivers/media/dvb/frontends/lgdt330x.c
drivers/media/dvb/frontends/mt352.c
drivers/media/dvb/frontends/nxt200x.c
drivers/media/dvb/pluto2/pluto2.c
drivers/media/dvb/ttpci/av7110.c
drivers/media/dvb/ttpci/budget-av.c
drivers/media/dvb/ttusb-budget/dvb-ttusb-budget.c
drivers/media/dvb/ttusb-dec/ttusb_dec.c
drivers/media/radio/radio-gemtek-pci.c
drivers/media/video/adv7170.c
drivers/media/video/adv7175.c
drivers/media/video/bt819.c
drivers/media/video/bt832.c
drivers/media/video/bt856.c
drivers/media/video/bttv-gpio.c
drivers/media/video/cpia_pp.c
drivers/media/video/cpia_usb.c
drivers/media/video/cs53l32a.c
drivers/media/video/cx25840/cx25840-core.c
drivers/media/video/cx88/cx88-blackbird.c
drivers/media/video/cx88/cx88-core.c
drivers/media/video/cx88/cx88-dvb.c
drivers/media/video/cx88/cx88-video.c
drivers/media/video/dpc7146.c
drivers/media/video/em28xx/em28xx-video.c
drivers/media/video/hexium_gemini.c
drivers/media/video/hexium_orion.c
drivers/media/video/indycam.c
drivers/media/video/mxb.c
drivers/media/video/ovcamchip/ov6x20.c
drivers/media/video/ovcamchip/ov6x30.c
drivers/media/video/ovcamchip/ov76be.c
drivers/media/video/ovcamchip/ov7x10.c
drivers/media/video/ovcamchip/ov7x20.c
drivers/media/video/ovcamchip/ovcamchip_core.c
drivers/media/video/saa5246a.c
drivers/media/video/saa5249.c
drivers/media/video/saa7110.c
drivers/media/video/saa7111.c
drivers/media/video/saa7114.c
drivers/media/video/saa7115.c
drivers/media/video/saa711x.c
drivers/media/video/saa7127.c
drivers/media/video/saa7134/saa6752hs.c
drivers/media/video/saa7134/saa7134-core.c
drivers/media/video/saa7134/saa7134-video.c
drivers/media/video/saa7185.c
drivers/media/video/saa7191.c
drivers/media/video/tda7432.c
drivers/media/video/tda9875.c
drivers/media/video/tda9887.c
drivers/media/video/tea6420.c
drivers/media/video/tuner-core.c
drivers/media/video/tvaudio.c
drivers/media/video/tveeprom.c
drivers/media/video/tvp5150.c
drivers/media/video/v4l1-compat.c
drivers/media/video/video-buf.c
drivers/media/video/videocodec.c
drivers/media/video/videodev.c
drivers/media/video/vino.c
drivers/media/video/vpx3220.c
drivers/media/video/wm8775.c
drivers/media/video/zoran_card.c
drivers/media/video/zoran_driver.c
drivers/media/video/zr36016.c
drivers/media/video/zr36050.c
drivers/media/video/zr36060.c

index 2899d34e5f7e3249c8be04ea941d2be7bb9af327..04c1938b9c918f9330c27627f8dde1a7e21c3696 100644 (file)
@@ -109,10 +109,9 @@ static struct scatterlist* vmalloc_to_sg(unsigned char *virt, int nr_pages)
        struct page *pg;
        int i;
 
-       sglist = kmalloc(sizeof(struct scatterlist)*nr_pages, GFP_KERNEL);
+       sglist = kcalloc(nr_pages, sizeof(struct scatterlist), GFP_KERNEL);
        if (NULL == sglist)
                return NULL;
-       memset(sglist,0,sizeof(struct scatterlist)*nr_pages);
        for (i = 0; i < nr_pages; i++, virt += PAGE_SIZE) {
                pg = vmalloc_to_page(virt);
                if (NULL == pg)
@@ -306,15 +305,13 @@ static int saa7146_init_one(struct pci_dev *pci, const struct pci_device_id *ent
        struct saa7146_dev *dev;
        int err = -ENOMEM;
 
-       dev = kmalloc(sizeof(struct saa7146_dev), GFP_KERNEL);
+       /* clear out mem for sure */
+       dev = kzalloc(sizeof(struct saa7146_dev), GFP_KERNEL);
        if (!dev) {
                ERR(("out of memory.\n"));
                goto out;
        }
 
-       /* clear out mem for sure */
-       memset(dev, 0x0, sizeof(struct saa7146_dev));
-
        DEB_EE(("pci:%p\n",pci));
 
        err = pci_enable_device(pci);
index b614612be7b439252c97451ced9e9de34a93609e..f8cf73ed49ad683e62119b34de9f5a857d44549d 100644 (file)
@@ -239,13 +239,12 @@ static int fops_open(struct inode *inode, struct file *file)
        }
 
        /* allocate per open data */
-       fh = kmalloc(sizeof(*fh),GFP_KERNEL);
+       fh = kzalloc(sizeof(*fh),GFP_KERNEL);
        if (NULL == fh) {
                DEB_S(("cannot allocate memory for per open data.\n"));
                result = -ENOMEM;
                goto out;
        }
-       memset(fh,0,sizeof(*fh));
 
        file->private_data = fh;
        fh->dev = dev;
@@ -464,12 +463,11 @@ static struct video_device device_template =
 
 int saa7146_vv_init(struct saa7146_dev* dev, struct saa7146_ext_vv *ext_vv)
 {
-       struct saa7146_vv *vv = kmalloc (sizeof(struct saa7146_vv),GFP_KERNEL);
+       struct saa7146_vv *vv = kzalloc (sizeof(struct saa7146_vv),GFP_KERNEL);
        if( NULL == vv ) {
                ERR(("out of memory. aborting.\n"));
                return -1;
        }
-       memset(vv, 0x0, sizeof(*vv));
 
        DEB_EE(("dev:%p\n",dev));
 
index 123ed96f6faa54d4851c6e3c3171735dc9a01bd7..56ba52470676821070a88050b43c35d634f3d209 100644 (file)
@@ -220,20 +220,18 @@ EXPORT_SYMBOL(flexcop_reset_block_300);
 struct flexcop_device *flexcop_device_kmalloc(size_t bus_specific_len)
 {
        void *bus;
-       struct flexcop_device *fc = kmalloc(sizeof(struct flexcop_device), GFP_KERNEL);
+       struct flexcop_device *fc = kzalloc(sizeof(struct flexcop_device), GFP_KERNEL);
        if (!fc) {
                err("no memory");
                return NULL;
        }
-       memset(fc, 0, sizeof(struct flexcop_device));
 
-       bus = kmalloc(bus_specific_len, GFP_KERNEL);
+       bus = kzalloc(bus_specific_len, GFP_KERNEL);
        if (!bus) {
                err("no memory");
                kfree(fc);
                return NULL;
        }
-       memset(bus, 0, bus_specific_len);
 
        fc->bus_specific = bus;
 
index 01b4e0aac0491fc0620414f84f1207263d9a0f1e..f65f64b00ff342aa5c0140198e13be55db99ff2b 100644 (file)
@@ -786,10 +786,9 @@ static int dvb_bt8xx_probe(struct device *dev)
        struct pci_dev* bttv_pci_dev;
        int ret;
 
-       if (!(card = kmalloc(sizeof(struct dvb_bt8xx_card), GFP_KERNEL)))
+       if (!(card = kzalloc(sizeof(struct dvb_bt8xx_card), GFP_KERNEL)))
                return -ENOMEM;
 
-       memset(card, 0, sizeof(*card));
        init_MUTEX(&card->lock);
        card->bttv_nr = sub->core->nr;
        strncpy(card->card_name, sub->core->name, sizeof(sub->core->name));
index 4bb779aeff6af804f3682fca089b5e075add7f18..00347a750681942db7775769de7f7f2cf8f3eea3 100644 (file)
@@ -1649,21 +1649,17 @@ int dvb_ca_en50221_init(struct dvb_adapter *dvb_adapter,
                return -EINVAL;
 
        /* initialise the system data */
-       if ((ca =
-            (struct dvb_ca_private *) kmalloc(sizeof(struct dvb_ca_private),
-                                              GFP_KERNEL)) == NULL) {
+       if ((ca = kzalloc(sizeof(struct dvb_ca_private), GFP_KERNEL)) == NULL) {
                ret = -ENOMEM;
                goto error;
        }
-       memset(ca, 0, sizeof(struct dvb_ca_private));
        ca->pub = pubca;
        ca->flags = flags;
        ca->slot_count = slot_count;
-       if ((ca->slot_info = kmalloc(sizeof(struct dvb_ca_slot) * slot_count, GFP_KERNEL)) == NULL) {
+       if ((ca->slot_info = kcalloc(slot_count, sizeof(struct dvb_ca_slot), GFP_KERNEL)) == NULL) {
                ret = -ENOMEM;
                goto error;
        }
-       memset(ca->slot_info, 0, sizeof(struct dvb_ca_slot) * slot_count);
        init_waitqueue_head(&ca->wait_queue);
        ca->thread_pid = 0;
        init_waitqueue_head(&ca->thread_queue);
index 4a08c4ab67309190b07e8bb1491d12fdd695b8cd..771f32d889e6261de8b8c77d10fad85b55da20a4 100644 (file)
@@ -1024,13 +1024,12 @@ int dvb_register_frontend(struct dvb_adapter* dvb,
        if (down_interruptible (&frontend_mutex))
                return -ERESTARTSYS;
 
-       fe->frontend_priv = kmalloc(sizeof(struct dvb_frontend_private), GFP_KERNEL);
+       fe->frontend_priv = kzalloc(sizeof(struct dvb_frontend_private), GFP_KERNEL);
        if (fe->frontend_priv == NULL) {
                up(&frontend_mutex);
                return -ENOMEM;
        }
        fepriv = fe->frontend_priv;
-       memset(fe->frontend_priv, 0, sizeof(struct dvb_frontend_private));
 
        init_MUTEX (&fepriv->sem);
        init_waitqueue_head (&fepriv->wait_queue);
index 0a94ec22aeb863bc7423d8fc55882ff3daae640f..cd21ddbfd05479f9be098ba01e8fe8c1011f064c 100644 (file)
@@ -156,10 +156,9 @@ struct dvb_frontend* dtt200u_fe_attach(struct dvb_usb_device *d)
        struct dtt200u_fe_state* state = NULL;
 
        /* allocate memory for the internal state */
-       state = (struct dtt200u_fe_state*) kmalloc(sizeof(struct dtt200u_fe_state), GFP_KERNEL);
+       state = kzalloc(sizeof(struct dtt200u_fe_state), GFP_KERNEL);
        if (state == NULL)
                goto error;
-       memset(state,0,sizeof(struct dtt200u_fe_state));
 
        deb_info("attaching frontend dtt200u\n");
 
index 2e23060cbbca736c4f8a0ea690ee3a893d36b9e9..716f8bf528cdc1999fe00d658f0e643ff8968750 100644 (file)
@@ -154,12 +154,11 @@ int dvb_usb_device_init(struct usb_interface *intf, struct dvb_usb_properties
        }
 
        info("found a '%s' in warm state.",desc->name);
-       d = kmalloc(sizeof(struct dvb_usb_device),GFP_KERNEL);
+               d = kzalloc(sizeof(struct dvb_usb_device),GFP_KERNEL);
        if (d == NULL) {
                err("no memory for 'struct dvb_usb_device'");
                return ret;
        }
-       memset(d,0,sizeof(struct dvb_usb_device));
 
        d->udev = udev;
        memcpy(&d->props,props,sizeof(struct dvb_usb_properties));
@@ -167,13 +166,12 @@ int dvb_usb_device_init(struct usb_interface *intf, struct dvb_usb_properties
        d->owner = owner;
 
        if (d->props.size_of_priv > 0) {
-               d->priv = kmalloc(d->props.size_of_priv,GFP_KERNEL);
+                       d->priv = kzalloc(d->props.size_of_priv,GFP_KERNEL);
                if (d->priv == NULL) {
                        err("no memory for priv in 'struct dvb_usb_device'");
                        kfree(d);
                        return -ENOMEM;
                }
-               memset(d->priv,0,d->props.size_of_priv);
        }
 
        usb_set_intfdata(intf, d);
index 36b7048c02d26616a5f18794f0a7116cb5309f1c..ee821974dc604a97d9fed5ffa084f620e2c14a60 100644 (file)
@@ -175,15 +175,13 @@ static int dvb_usb_allocate_stream_buffers(struct dvb_usb_device *d, int num, un
 
        deb_mem("all in all I will use %lu bytes for streaming\n",num*size);
 
-       if ((d->buf_list = kmalloc(num*sizeof(u8 *), GFP_ATOMIC)) == NULL)
+       if ((d->buf_list = kcalloc(num, sizeof(u8 *), GFP_ATOMIC)) == NULL)
                return -ENOMEM;
 
-       if ((d->dma_addr = kmalloc(num*sizeof(dma_addr_t), GFP_ATOMIC)) == NULL) {
+       if ((d->dma_addr = kcalloc(num, sizeof(dma_addr_t), GFP_ATOMIC)) == NULL) {
                kfree(d->buf_list);
                return -ENOMEM;
        }
-       memset(d->buf_list,0,num*sizeof(u8 *));
-       memset(d->dma_addr,0,num*sizeof(dma_addr_t));
 
        d->state |= DVB_USB_STATE_URB_BUF;
 
@@ -285,10 +283,9 @@ int dvb_usb_urb_init(struct dvb_usb_device *d)
        usb_clear_halt(d->udev,usb_rcvbulkpipe(d->udev,d->props.urb.endpoint));
 
        /* allocate the array for the data transfer URBs */
-       d->urb_list = kmalloc(d->props.urb.count * sizeof(struct urb *),GFP_KERNEL);
+       d->urb_list = kzalloc(d->props.urb.count * sizeof(struct urb *),GFP_KERNEL);
        if (d->urb_list == NULL)
                return -ENOMEM;
-       memset(d->urb_list,0,d->props.urb.count * sizeof(struct urb *));
        d->state |= DVB_USB_STATE_URB_LIST;
 
        switch (d->props.urb.type) {
index 0885d9fb2bf231a6373fbbc30725d0adaf5ae67d..b6d95e1c9c527d7d799ecf4e20cb435973f469c6 100644 (file)
@@ -281,10 +281,9 @@ static struct dvb_frontend_ops vp702x_fe_ops;
 
 struct dvb_frontend * vp702x_fe_attach(struct dvb_usb_device *d)
 {
-       struct vp702x_fe_state *s = kmalloc(sizeof(struct vp702x_fe_state), GFP_KERNEL);
+       struct vp702x_fe_state *s = kzalloc(sizeof(struct vp702x_fe_state), GFP_KERNEL);
        if (s == NULL)
                goto error;
-       memset(s,0,sizeof(struct vp702x_fe_state));
 
        s->d = d;
        s->fe.ops = &vp702x_fe_ops;
index 83f1de1e7e571daaede818ace9b90c50fbab484a..5242cca5db4a2a7ca4e9213cb450401a82cbbfcb 100644 (file)
@@ -145,10 +145,9 @@ static struct dvb_frontend_ops vp7045_fe_ops;
 
 struct dvb_frontend * vp7045_fe_attach(struct dvb_usb_device *d)
 {
-       struct vp7045_fe_state *s = kmalloc(sizeof(struct vp7045_fe_state), GFP_KERNEL);
+       struct vp7045_fe_state *s = kzalloc(sizeof(struct vp7045_fe_state), GFP_KERNEL);
        if (s == NULL)
                goto error;
-       memset(s,0,sizeof(struct vp7045_fe_state));
 
        s->d = d;
        s->fe.ops = &vp7045_fe_ops;
index 3b132bafd4de0f0f39bcf87ab83b5b05ae444c88..caaee893ca7674d048ba91b16c084c09b5934fd8 100644 (file)
@@ -782,10 +782,9 @@ struct dvb_frontend* bcm3510_attach(const struct bcm3510_config *config,
        bcm3510_register_value v;
 
        /* allocate memory for the internal state */
-       state = kmalloc(sizeof(struct bcm3510_state), GFP_KERNEL);
+       state = kzalloc(sizeof(struct bcm3510_state), GFP_KERNEL);
        if (state == NULL)
                goto error;
-       memset(state,0,sizeof(struct bcm3510_state));
 
        /* setup the state */
 
index 6b05536086109fd40a1b3c1a9a9c3a9e89b58365..ae589adb1c0a47b9960bb9e5a130f47dc1619fe7 100644 (file)
@@ -700,10 +700,9 @@ struct dvb_frontend* dib3000mb_attach(const struct dib3000_config* config,
        struct dib3000_state* state = NULL;
 
        /* allocate memory for the internal state */
-       state = kmalloc(sizeof(struct dib3000_state), GFP_KERNEL);
+       state = kzalloc(sizeof(struct dib3000_state), GFP_KERNEL);
        if (state == NULL)
                goto error;
-       memset(state,0,sizeof(struct dib3000_state));
 
        /* setup the state */
        state->i2c = i2c;
index c024fad173370f62f8222cbcb947de31b530bf0a..3b303dbb61565db54ed15b4bbab810be2c622860 100644 (file)
@@ -832,10 +832,9 @@ struct dvb_frontend* dib3000mc_attach(const struct dib3000_config* config,
        u16 devid;
 
        /* allocate memory for the internal state */
-       state = kmalloc(sizeof(struct dib3000_state), GFP_KERNEL);
+       state = kzalloc(sizeof(struct dib3000_state), GFP_KERNEL);
        if (state == NULL)
                goto error;
-       memset(state,0,sizeof(struct dib3000_state));
 
        /* setup the state */
        state->i2c = i2c;
index 9d214643b87a4c65e1551070adfc636165bc13c4..4691ac54bc1d2a8f3202fb43cae0f504d9a8ce7e 100644 (file)
@@ -714,10 +714,9 @@ struct dvb_frontend* lgdt330x_attach(const struct lgdt330x_config* config,
        u8 buf[1];
 
        /* Allocate memory for the internal state */
-       state = (struct lgdt330x_state*) kmalloc(sizeof(struct lgdt330x_state), GFP_KERNEL);
+       state = kzalloc(sizeof(struct lgdt330x_state), GFP_KERNEL);
        if (state == NULL)
                goto error;
-       memset(state,0,sizeof(*state));
 
        /* Setup the state */
        state->config = config;
index f0c610f2c2dfe437e696417cf5aafbe8c3d71848..aaaec909ddf830f0372bdf11d19aff43a164852c 100644 (file)
@@ -535,9 +535,8 @@ struct dvb_frontend* mt352_attach(const struct mt352_config* config,
        struct mt352_state* state = NULL;
 
        /* allocate memory for the internal state */
-       state = kmalloc(sizeof(struct mt352_state), GFP_KERNEL);
+       state = kzalloc(sizeof(struct mt352_state), GFP_KERNEL);
        if (state == NULL) goto error;
-       memset(state,0,sizeof(*state));
 
        /* setup the state */
        state->i2c = i2c;
index aeafef46e3ebd4b68bd03b94624a0fdb3720d83a..78d2b93d35b9d7670beab86263fa0dbd46c6be14 100644 (file)
@@ -1110,10 +1110,9 @@ struct dvb_frontend* nxt200x_attach(const struct nxt200x_config* config,
        u8 buf [] = {0,0,0,0,0};
 
        /* allocate memory for the internal state */
-       state = (struct nxt200x_state*) kmalloc(sizeof(struct nxt200x_state), GFP_KERNEL);
+       state = kzalloc(sizeof(struct nxt200x_state), GFP_KERNEL);
        if (state == NULL)
                goto error;
-       memset(state,0,sizeof(*state));
 
        /* setup the state */
        state->config = config;
index bbebd1c4caca575fb7cd0890e30105bd68ae7b34..1c5316e209efc9993ccc4d4def81e3032e6142e6 100644 (file)
@@ -584,11 +584,10 @@ static int __devinit pluto2_probe(struct pci_dev *pdev,
        struct dmx_demux *dmx;
        int ret = -ENOMEM;
 
-       pluto = kmalloc(sizeof(struct pluto), GFP_KERNEL);
+       pluto = kzalloc(sizeof(struct pluto), GFP_KERNEL);
        if (!pluto)
                goto out;
 
-       memset(pluto, 0, sizeof(struct pluto));
        pluto->pdev = pdev;
 
        ret = pci_enable_device(pdev);
index 8ce4146f55f12cc96953e1f96e6b0826fa3ea684..327a8089193b7332a0342abbbcff7f0ae6d259f7 100644 (file)
@@ -2565,14 +2565,12 @@ static int av7110_attach(struct saa7146_dev* dev, struct saa7146_pci_extension_d
        }
 
        /* prepare the av7110 device struct */
-       av7110 = kmalloc(sizeof(struct av7110), GFP_KERNEL);
+       av7110 = kzalloc(sizeof(struct av7110), GFP_KERNEL);
        if (!av7110) {
                dprintk(1, "out of memory\n");
                return -ENOMEM;
        }
 
-       memset(av7110, 0, sizeof(struct av7110));
-
        av7110->card_name = (char*) pci_ext->ext_priv;
        av7110->dev = dev;
        dev->ext_priv = av7110;
index f9d00452e6393132c9bc044b8215bffca5eba680..aa2645895769343073e76bd35cfaf42badcf0a02 100644 (file)
@@ -1027,11 +1027,9 @@ static int budget_av_attach(struct saa7146_dev *dev, struct saa7146_pci_extensio
 
        dprintk(2, "dev: %p\n", dev);
 
-       if (!(budget_av = kmalloc(sizeof(struct budget_av), GFP_KERNEL)))
+       if (!(budget_av = kzalloc(sizeof(struct budget_av), GFP_KERNEL)))
                return -ENOMEM;
 
-       memset(budget_av, 0, sizeof(struct budget_av));
-
        budget_av->has_saa7113 = 0;
        budget_av->budget.ci_present = 0;
 
index 104df610dbe1d59b81b5488f92a65e500a6e7986..5a13c4744f616d9799af9e6858f51c9ce5ce141e 100644 (file)
@@ -1489,11 +1489,9 @@ static int ttusb_probe(struct usb_interface *intf, const struct usb_device_id *i
 
        if (intf->altsetting->desc.bInterfaceNumber != 1) return -ENODEV;
 
-       if (!(ttusb = kmalloc(sizeof(struct ttusb), GFP_KERNEL)))
+       if (!(ttusb = kzalloc(sizeof(struct ttusb), GFP_KERNEL)))
                return -ENOMEM;
 
-       memset(ttusb, 0, sizeof(struct ttusb));
-
        ttusb->dev = udev;
        ttusb->c = 0;
        ttusb->mux_state = 0;
index d8966d1d25ee7c613df1411d20d558a00351d81a..df831171e03ca3ba92e65fac70e78a8f9c6cc08e 100644 (file)
@@ -1606,15 +1606,13 @@ static int ttusb_dec_probe(struct usb_interface *intf,
 
        udev = interface_to_usbdev(intf);
 
-       if (!(dec = kmalloc(sizeof(struct ttusb_dec), GFP_KERNEL))) {
+       if (!(dec = kzalloc(sizeof(struct ttusb_dec), GFP_KERNEL))) {
                printk("%s: couldn't allocate memory.\n", __FUNCTION__);
                return -ENOMEM;
        }
 
        usb_set_intfdata(intf, (void *)dec);
 
-       memset(dec, 0, sizeof(struct ttusb_dec));
-
        switch (le16_to_cpu(id->idProduct)) {
        case 0x1006:
                ttusb_dec_set_model(dec, TTUSB_DEC3000S);
index 69ac8aa73eba45f2f974af726e7443a247198ec8..8e499b8f64c79e88474db41b93f6ae824c164db1 100644 (file)
@@ -318,11 +318,10 @@ static int __devinit gemtek_pci_probe( struct pci_dev *pci_dev, const struct pci
        struct gemtek_pci_card *card;
        struct video_device *devradio;
 
-       if ( (card = kmalloc( sizeof( struct gemtek_pci_card ), GFP_KERNEL )) == NULL ) {
+       if ( (card = kzalloc( sizeof( struct gemtek_pci_card ), GFP_KERNEL )) == NULL ) {
                printk( KERN_ERR "gemtek_pci: out of memory\n" );
                return -ENOMEM;
        }
-       memset( card, 0, sizeof( struct gemtek_pci_card ) );
 
        if ( pci_enable_device( pci_dev ) ) 
                goto err_pci;
index e61003de1d5f760281b4bb55e5032fe3a9554c86..4ce07ae62dac4048fe0b58701c1a12d0f7a87ba4 100644 (file)
@@ -413,10 +413,9 @@ adv7170_detect_client (struct i2c_adapter *adapter,
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return 0;
 
-       client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (client == 0)
                return -ENOMEM;
-       memset(client, 0, sizeof(struct i2c_client));
        client->addr = address;
        client->adapter = adapter;
        client->driver = &i2c_driver_adv7170;
@@ -433,12 +432,11 @@ adv7170_detect_client (struct i2c_adapter *adapter,
        }
        strlcpy(I2C_NAME(client), dname, sizeof(I2C_NAME(client)));
 
-       encoder = kmalloc(sizeof(struct adv7170), GFP_KERNEL);
+       encoder = kzalloc(sizeof(struct adv7170), GFP_KERNEL);
        if (encoder == NULL) {
                kfree(client);
                return -ENOMEM;
        }
-       memset(encoder, 0, sizeof(struct adv7170));
        encoder->norm = VIDEO_MODE_NTSC;
        encoder->input = 0;
        encoder->enable = 1;
index 6d9536a71ee437854f41aeeceb2feea9ed47ddea..4e218f22b214653aaad19696be4303eef2120ae0 100644 (file)
@@ -463,10 +463,9 @@ adv7175_detect_client (struct i2c_adapter *adapter,
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return 0;
 
-       client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (client == 0)
                return -ENOMEM;
-       memset(client, 0, sizeof(struct i2c_client));
        client->addr = address;
        client->adapter = adapter;
        client->driver = &i2c_driver_adv7175;
@@ -483,12 +482,11 @@ adv7175_detect_client (struct i2c_adapter *adapter,
        }
        strlcpy(I2C_NAME(client), dname, sizeof(I2C_NAME(client)));
 
-       encoder = kmalloc(sizeof(struct adv7175), GFP_KERNEL);
+       encoder = kzalloc(sizeof(struct adv7175), GFP_KERNEL);
        if (encoder == NULL) {
                kfree(client);
                return -ENOMEM;
        }
-       memset(encoder, 0, sizeof(struct adv7175));
        encoder->norm = VIDEO_MODE_PAL;
        encoder->input = 0;
        encoder->enable = 1;
index 560b998917538d5b08b3bccdfb90bec69c901291..d6447791d0e5914545a8501fc0cee5574a9b9acc 100644 (file)
@@ -528,21 +528,18 @@ bt819_detect_client (struct i2c_adapter *adapter,
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return 0;
 
-       client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (client == 0)
                return -ENOMEM;
-       memset(client, 0, sizeof(struct i2c_client));
        client->addr = address;
        client->adapter = adapter;
        client->driver = &i2c_driver_bt819;
 
-       decoder = kmalloc(sizeof(struct bt819), GFP_KERNEL);
+       decoder = kzalloc(sizeof(struct bt819), GFP_KERNEL);
        if (decoder == NULL) {
                kfree(client);
                return -ENOMEM;
        }
-
-       memset(decoder, 0, sizeof(struct bt819));
        decoder->norm = VIDEO_MODE_NTSC;
        decoder->input = 0;
        decoder->enable = 1;
index dda4aa6bef27c6da07a6fc104faef8972075edfe..361a9b6ccce364f0ef8d93ea24cec7281e2deb33 100644 (file)
@@ -167,9 +167,8 @@ static int bt832_attach(struct i2c_adapter *adap, int addr, int kind)
        client_template.adapter = adap;
        client_template.addr    = addr;
 
-       if (NULL == (t = kmalloc(sizeof(*t), GFP_KERNEL)))
+       if (NULL == (t = kzalloc(sizeof(*t), GFP_KERNEL)))
                return -ENOMEM;
-       memset(t,0,sizeof(*t));
        t->client = client_template;
        i2c_set_clientdata(&t->client, t);
        i2c_attach_client(&t->client);
index 60508069bbedf73425f0196081c4bcf80e7476be..909b593530edf30fe25ac12377f0f1a5f3ad533d 100644 (file)
@@ -316,21 +316,19 @@ bt856_detect_client (struct i2c_adapter *adapter,
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return 0;
 
-       client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (client == 0)
                return -ENOMEM;
-       memset(client, 0, sizeof(struct i2c_client));
        client->addr = address;
        client->adapter = adapter;
        client->driver = &i2c_driver_bt856;
        strlcpy(I2C_NAME(client), "bt856", sizeof(I2C_NAME(client)));
 
-       encoder = kmalloc(sizeof(struct bt856), GFP_KERNEL);
+       encoder = kzalloc(sizeof(struct bt856), GFP_KERNEL);
        if (encoder == NULL) {
                kfree(client);
                return -ENOMEM;
        }
-       memset(encoder, 0, sizeof(struct bt856));
        encoder->norm = VIDEO_MODE_NTSC;
        encoder->enable = 1;
        i2c_set_clientdata(client, encoder);
index 575ce8b8e714d995a92c2f6f0daa53c09e6b2dac..d64accc17b0ef7854438845f6b4cb49096988e89 100644 (file)
@@ -64,10 +64,9 @@ int bttv_sub_add_device(struct bttv_core *core, char *name)
        struct bttv_sub_device *sub;
        int err;
 
-       sub = kmalloc(sizeof(*sub),GFP_KERNEL);
+       sub = kzalloc(sizeof(*sub),GFP_KERNEL);
        if (NULL == sub)
                return -ENOMEM;
-       memset(sub,0,sizeof(*sub));
 
        sub->core        = core;
        sub->dev.parent  = &core->pci->dev;
index 6861d408f1b3c98dc72de086c72c9d08d9621a53..74cff626e044375a467000ae57a64846af4d7e58 100644 (file)
@@ -702,12 +702,11 @@ static int cpia_pp_register(struct parport *port)
                return -ENXIO;
        }
 
-       cam = kmalloc(sizeof(struct pp_cam_entry), GFP_KERNEL);
+       cam = kzalloc(sizeof(struct pp_cam_entry), GFP_KERNEL);
        if (cam == NULL) {
                LOG("failed to allocate camera structure\n");
                return -ENOMEM;
        }
-       memset(cam,0,sizeof(struct pp_cam_entry));
        
        pdev = parport_register_device(port, "cpia_pp", NULL, NULL,
                                       NULL, 0, cam);
index 1439cb752874c23ef5fdf265c73d136f4f4ba895..03275c37c5d330b344e5150d4ae7482942e8ee5a 100644 (file)
@@ -499,14 +499,12 @@ static int cpia_probe(struct usb_interface *intf,
 
        printk(KERN_INFO "USB CPiA camera found\n");
 
-       ucpia = kmalloc(sizeof(*ucpia), GFP_KERNEL);
+       ucpia = kzalloc(sizeof(*ucpia), GFP_KERNEL);
        if (!ucpia) {
                printk(KERN_ERR "couldn't kmalloc cpia struct\n");
                return -ENOMEM;
        }
 
-       memset(ucpia, 0, sizeof(*ucpia));
-
        ucpia->dev = udev;
        ucpia->iface = interface->desc.bInterfaceNumber;
        init_waitqueue_head(&ucpia->wq_stream);
index b421068f7ea30bc3bf778cdd747b1e45284f9fc3..9a66b5961d19839936a38d72890798b146f01009 100644 (file)
@@ -141,11 +141,10 @@ static int cs53l32a_attach(struct i2c_adapter *adapter, int address, int kind)
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return 0;
 
-       client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (client == 0)
                return -ENOMEM;
 
-       memset(client, 0, sizeof(struct i2c_client));
        client->addr = address;
        client->adapter = adapter;
        client->driver = &i2c_driver;
index d45237d508c45e868dafa4b3afef8103756ea72f..c1734762436dc894c1f15151aa6333a7c0c9fbf2 100644 (file)
@@ -862,11 +862,10 @@ static int cx25840_detect_client(struct i2c_adapter *adapter, int address,
        if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
                return 0;
 
-       client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (client == 0)
                return -ENOMEM;
 
-       memset(client, 0, sizeof(struct i2c_client));
        client->addr = address;
        client->adapter = adapter;
        client->driver = &i2c_driver_cx25840;
index a490621193132bbf294f5211c279f28542a20fc0..a502a4d6e4ae0ea68e01e9ed7875217d2d514865 100644 (file)
@@ -1539,10 +1539,9 @@ static int mpeg_open(struct inode *inode, struct file *file)
        dprintk(1,"open minor=%d\n",minor);
 
        /* allocate + initialize per filehandle data */
-       fh = kmalloc(sizeof(*fh),GFP_KERNEL);
+       fh = kzalloc(sizeof(*fh),GFP_KERNEL);
        if (NULL == fh)
                return -ENOMEM;
-       memset(fh,0,sizeof(*fh));
        file->private_data = fh;
        fh->dev      = dev;
 
@@ -1678,10 +1677,9 @@ static int __devinit blackbird_probe(struct pci_dev *pci_dev,
                goto fail_core;
 
        err = -ENOMEM;
-       dev = kmalloc(sizeof(*dev),GFP_KERNEL);
+       dev = kzalloc(sizeof(*dev),GFP_KERNEL);
        if (NULL == dev)
                goto fail_core;
-       memset(dev,0,sizeof(*dev));
        dev->pci = pci_dev;
        dev->core = core;
        dev->width = 720;
index 9975be1aca38979340b70a7a061d56702f7a1b41..194446f28c55c366b82a4f91f38222d0c5c9edfa 100644 (file)
@@ -1050,11 +1050,10 @@ struct cx88_core* cx88_core_get(struct pci_dev *pci)
                up(&devlist);
                return core;
        }
-       core = kmalloc(sizeof(*core),GFP_KERNEL);
+       core = kzalloc(sizeof(*core),GFP_KERNEL);
        if (NULL == core)
                goto fail_unlock;
 
-       memset(core,0,sizeof(*core));
        atomic_inc(&core->refcount);
        core->pci_bus  = pci->bus->number;
        core->pci_slot = PCI_SLOT(pci->devfn);
index 42c012aaa849de3314182fce35a435f8a9f9043f..e48aa3f6e50012a1c2e854a9d96943e11337038d 100644 (file)
@@ -657,10 +657,9 @@ static int __devinit dvb_probe(struct pci_dev *pci_dev,
                goto fail_core;
 
        err = -ENOMEM;
-       dev = kmalloc(sizeof(*dev),GFP_KERNEL);
+       dev = kzalloc(sizeof(*dev),GFP_KERNEL);
        if (NULL == dev)
                goto fail_core;
-       memset(dev,0,sizeof(*dev));
        dev->pci = pci_dev;
        dev->core = core;
 
index 9a02515fe18bc440b6c7a26fc32faf9e7f03ec14..073494ceab0fbe17d59357d4eed19c9742cada9a 100644 (file)
@@ -750,10 +750,9 @@ static int video_open(struct inode *inode, struct file *file)
                minor,radio,v4l2_type_names[type]);
 
        /* allocate + initialize per filehandle data */
-       fh = kmalloc(sizeof(*fh),GFP_KERNEL);
+       fh = kzalloc(sizeof(*fh),GFP_KERNEL);
        if (NULL == fh)
                return -ENOMEM;
-       memset(fh,0,sizeof(*fh));
        file->private_data = fh;
        fh->dev      = dev;
        fh->radio    = radio;
@@ -1809,10 +1808,9 @@ static int __devinit cx8800_initdev(struct pci_dev *pci_dev,
        struct cx88_core *core;
        int err;
 
-       dev = kmalloc(sizeof(*dev),GFP_KERNEL);
+       dev = kzalloc(sizeof(*dev),GFP_KERNEL);
        if (NULL == dev)
                return -ENOMEM;
-       memset(dev,0,sizeof(*dev));
 
        /* pci init */
        dev->pci = pci_dev;
index da9481198c5305c4a916d858c046f7d1eb0fd9f7..2831bdd120573b911a5e719670db3be550bbb205 100644 (file)
@@ -94,12 +94,11 @@ static int dpc_probe(struct saa7146_dev* dev)
        struct i2c_client *client;
        struct list_head *item;
 
-       dpc = (struct dpc*)kmalloc(sizeof(struct dpc), GFP_KERNEL);
+       dpc = kzalloc(sizeof(struct dpc), GFP_KERNEL);
        if( NULL == dpc ) {
                printk("dpc_v4l2.o: dpc_probe: not enough kernel memory.\n");
                return -ENOMEM;
        }
-       memset(dpc, 0x0, sizeof(struct dpc));   
 
        /* FIXME: enable i2c-port pins, video-port-pins
           video port pins should be enabled here ?! */
index fdc255918ddef1e11d8416cb170ceb1baecd1a3f..3323dffe26a479323be61337e1ae51a54b6bb796 100644 (file)
@@ -1861,12 +1861,11 @@ static int em28xx_usb_probe(struct usb_interface *interface,
        }
 
        /* allocate memory for our device state and initialize it */
-       dev = kmalloc(sizeof(*dev), GFP_KERNEL);
+       dev = kzalloc(sizeof(*dev), GFP_KERNEL);
        if (dev == NULL) {
                em28xx_err(DRIVER_NAME ": out of memory!\n");
                return -ENOMEM;
        }
-       memset(dev, 0, sizeof(*dev));
 
        /* compute alternate max packet sizes */
        uif = udev->actconfig->interface[0];
index c9b00eafefde16415d6ebb3bb4a9dca36e93b7dc..e7bbeb11553d5d72ef17337d9dcac0a932c9f8bf 100644 (file)
@@ -240,12 +240,11 @@ static int hexium_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_d
 
        DEB_EE((".\n"));
 
-       hexium = (struct hexium *) kmalloc(sizeof(struct hexium), GFP_KERNEL);
+       hexium = kzalloc(sizeof(struct hexium), GFP_KERNEL);
        if (NULL == hexium) {
                printk("hexium_gemini: not enough kernel memory in hexium_attach().\n");
                return -ENOMEM;
        }
-       memset(hexium, 0x0, sizeof(struct hexium));
        dev->ext_priv = hexium;
 
        /* enable i2c-port pins */
index 42a9414155c370dfc3afd8784c347317f40a648e..0b6c2096ec66bb367eeb0928e4686eec23e68e07 100644 (file)
@@ -224,12 +224,11 @@ static int hexium_probe(struct saa7146_dev *dev)
                return -EFAULT;
        }
 
-       hexium = (struct hexium *) kmalloc(sizeof(struct hexium), GFP_KERNEL);
+       hexium = kzalloc(sizeof(struct hexium), GFP_KERNEL);
        if (NULL == hexium) {
                printk("hexium_orion: hexium_probe: not enough kernel memory.\n");
                return -ENOMEM;
        }
-       memset(hexium, 0x0, sizeof(struct hexium));
 
        /* enable i2c-port pins */
        saa7146_write(dev, MC1, (MASK_08 | MASK_24 | MASK_10 | MASK_26));
index bb5cbecffcc3e5e4c2320f8b946ee2894f522ffb..7420b79e987abe775d81a5135d9d8e2657a227f2 100644 (file)
@@ -289,18 +289,15 @@ static int indycam_attach(struct i2c_adapter *adap, int addr, int kind)
        printk(KERN_INFO "SGI IndyCam driver version %s\n",
               INDYCAM_MODULE_VERSION);
 
-       client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (!client)
                return -ENOMEM;
-       camera = kmalloc(sizeof(struct indycam), GFP_KERNEL);
+       camera = kzalloc(sizeof(struct indycam), GFP_KERNEL);
        if (!camera) {
                err = -ENOMEM;
                goto out_free_client;
        }
 
-       memset(client, 0, sizeof(struct i2c_client));
-       memset(camera, 0, sizeof(struct indycam));
-
        client->addr = addr;
        client->adapter = adap;
        client->driver = &i2c_driver_indycam;
index 91681aa6c6574261102deb36a60fe47fad63e005..8416ceff524bf3f5900e5b684cf7e439fc19c4ec 100644 (file)
@@ -177,12 +177,11 @@ static int mxb_probe(struct saa7146_dev* dev)
                return -ENODEV;
        }
 
-       mxb = (struct mxb*)kmalloc(sizeof(struct mxb), GFP_KERNEL);
+       mxb = kzalloc(sizeof(struct mxb), GFP_KERNEL);
        if( NULL == mxb ) {
                DEB_D(("not enough kernel memory.\n"));
                return -ENOMEM;
        }
-       memset(mxb, 0x0, sizeof(struct mxb));   
 
        mxb->i2c_adapter = (struct i2c_adapter) {
                .class = I2C_CLASS_TV_ANALOG,
index b3f4d266cedead6f1afd053ec0b4e2edd117b88e..c04130dab127b17a7a86c928a997be6745c86b26 100644 (file)
@@ -178,10 +178,9 @@ static int ov6x20_init(struct i2c_client *c)
        if (rc < 0)
                return rc;
 
-       ov->spriv = s = kmalloc(sizeof *s, GFP_KERNEL);
+       ov->spriv = s = kzalloc(sizeof *s, GFP_KERNEL);
        if (!s)
                return -ENOMEM;
-       memset(s, 0, sizeof *s);
 
        s->auto_brt = 1;
        s->auto_exp = 1;
index 6eab458ab792a88e58313731f11ab27160fe1535..73b94f51a85a8c03f4e126fd67db612a82fce754 100644 (file)
@@ -141,10 +141,9 @@ static int ov6x30_init(struct i2c_client *c)
        if (rc < 0)
                return rc;
 
-       ov->spriv = s = kmalloc(sizeof *s, GFP_KERNEL);
+       ov->spriv = s = kzalloc(sizeof *s, GFP_KERNEL);
        if (!s)
                return -ENOMEM;
-       memset(s, 0, sizeof *s);
 
        s->auto_brt = 1;
        s->auto_exp = 1;
index 29bbdc05e3b687ede034bff12cb668f5c203a3ff..11f6be924d8b4d4e42cbfe732d1acbec988c20b3 100644 (file)
@@ -105,10 +105,9 @@ static int ov76be_init(struct i2c_client *c)
        if (rc < 0)
                return rc;
 
-       ov->spriv = s = kmalloc(sizeof *s, GFP_KERNEL);
+       ov->spriv = s = kzalloc(sizeof *s, GFP_KERNEL);
        if (!s)
                return -ENOMEM;
-       memset(s, 0, sizeof *s);
 
        s->auto_brt = 1;
        s->auto_exp = 1;
index 6c383d4b14fa4f378c64591fddac92446f7dad23..5206e7913924dc83aefc4c472b48dfa7f0ea9a29 100644 (file)
@@ -115,10 +115,9 @@ static int ov7x10_init(struct i2c_client *c)
        if (rc < 0)
                return rc;
 
-       ov->spriv = s = kmalloc(sizeof *s, GFP_KERNEL);
+       ov->spriv = s = kzalloc(sizeof *s, GFP_KERNEL);
        if (!s)
                return -ENOMEM;
-       memset(s, 0, sizeof *s);
 
        s->auto_brt = 1;
        s->auto_exp = 1;
index 3c8c48f338bafff423d17b732111e34eb19167f3..8e26ae338f317a28910a02be71c83d3bb1da7655 100644 (file)
@@ -232,10 +232,9 @@ static int ov7x20_init(struct i2c_client *c)
        if (rc < 0)
                return rc;
 
-       ov->spriv = s = kmalloc(sizeof *s, GFP_KERNEL);
+       ov->spriv = s = kzalloc(sizeof *s, GFP_KERNEL);
        if (!s)
                return -ENOMEM;
-       memset(s, 0, sizeof *s);
 
        s->auto_brt = 1;
        s->auto_exp = DFL_AUTO_EXP;
index 428f1bb75ec30620a98cd9074e2277cdada67976..e76b53d5909cf97cbca24634f2df1e5adc4cfb74 100644 (file)
@@ -316,12 +316,11 @@ static int ovcamchip_attach(struct i2c_adapter *adap)
        c->adapter = adap;
        strcpy(c->name, "OV????");
 
-       ov = kmalloc(sizeof *ov, GFP_KERNEL);
+       ov = kzalloc(sizeof *ov, GFP_KERNEL);
        if (!ov) {
                rc = -ENOMEM;
                goto no_ov;
        }
-       memset(ov, 0, sizeof *ov);
        i2c_set_clientdata(c, ov);
 
        rc = ovcamchip_detect(c);
index 0aa9e72f632c605140c883787dd71af1708ac599..2ce0102013083bdbd497addd96aa55cc3a28ab5b 100644 (file)
@@ -83,13 +83,12 @@ static int saa5246a_attach(struct i2c_adapter *adap, int addr, int kind)
        client_template.adapter = adap;
        client_template.addr = addr;
        memcpy(client, &client_template, sizeof(*client));
-       t = kmalloc(sizeof(*t), GFP_KERNEL);
+       t = kzalloc(sizeof(*t), GFP_KERNEL);
        if(t==NULL)
        {
                kfree(client);
                return -ENOMEM;
        }
-       memset(t, 0, sizeof(*t));
        strlcpy(client->name, IF_NAME, I2C_NAME_SIZE);
        init_MUTEX(&t->lock);
 
index 73b4f0e2abf086d7974e76b6148f2822a8b33ecc..5694eb58c3a1fb5e236e585a0069ea65bb7a34ec 100644 (file)
@@ -151,13 +151,12 @@ static int saa5249_attach(struct i2c_adapter *adap, int addr, int kind)
         client_template.adapter = adap;
         client_template.addr = addr;
        memcpy(client, &client_template, sizeof(*client));
-       t = kmalloc(sizeof(*t), GFP_KERNEL);
+       t = kzalloc(sizeof(*t), GFP_KERNEL);
        if(t==NULL)
        {
                kfree(client);
                return -ENOMEM;
        }
-       memset(t, 0, sizeof(*t));
        strlcpy(client->name, IF_NAME, I2C_NAME_SIZE);
        init_MUTEX(&t->lock);
        
@@ -165,7 +164,7 @@ static int saa5249_attach(struct i2c_adapter *adap, int addr, int kind)
         *      Now create a video4linux device
         */
         
-       vd = (struct video_device *)kmalloc(sizeof(struct video_device), GFP_KERNEL);
+       vd = kmalloc(sizeof(struct video_device), GFP_KERNEL);
        if(vd==NULL)
        {
                kfree(t);
index 619ff0b7a1ff3b5a97c1118294e6be41f39c8825..7bb85a7b326ef9bd8955e4beae8c944b015c73f0 100644 (file)
@@ -494,21 +494,19 @@ saa7110_detect_client (struct i2c_adapter *adapter,
             I2C_FUNC_SMBUS_READ_BYTE | I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
                return 0;
 
-       client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (client == 0)
                return -ENOMEM;
-       memset(client, 0, sizeof(struct i2c_client));
        client->addr = address;
        client->adapter = adapter;
        client->driver = &i2c_driver_saa7110;
        strlcpy(I2C_NAME(client), "saa7110", sizeof(I2C_NAME(client)));
 
-       decoder = kmalloc(sizeof(struct saa7110), GFP_KERNEL);
+       decoder = kzalloc(sizeof(struct saa7110), GFP_KERNEL);
        if (decoder == 0) {
                kfree(client);
                return -ENOMEM;
        }
-       memset(decoder, 0, sizeof(struct saa7110));
        decoder->norm = VIDEO_MODE_PAL;
        decoder->input = 0;
        decoder->enable = 1;
index acaeee592b54d9b587f3fc918ff52f67130e87ca..8c06592b37ff125a0f50fba400a01e64115f7e26 100644 (file)
@@ -511,21 +511,19 @@ saa7111_detect_client (struct i2c_adapter *adapter,
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return 0;
 
-       client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (client == 0)
                return -ENOMEM;
-       memset(client, 0, sizeof(struct i2c_client));
        client->addr = address;
        client->adapter = adapter;
        client->driver = &i2c_driver_saa7111;
        strlcpy(I2C_NAME(client), "saa7111", sizeof(I2C_NAME(client)));
 
-       decoder = kmalloc(sizeof(struct saa7111), GFP_KERNEL);
+       decoder = kzalloc(sizeof(struct saa7111), GFP_KERNEL);
        if (decoder == NULL) {
                kfree(client);
                return -ENOMEM;
        }
-       memset(decoder, 0, sizeof(struct saa7111));
        decoder->norm = VIDEO_MODE_NTSC;
        decoder->input = 0;
        decoder->enable = 1;
index b7ac0122f7291e45a736f30c9f8192b9eff2a1c4..fd0a4b4ef014387394523c70ef17b9e033d2b148 100644 (file)
@@ -852,21 +852,19 @@ saa7114_detect_client (struct i2c_adapter *adapter,
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return 0;
 
-       client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (client == 0)
                return -ENOMEM;
-       memset(client, 0, sizeof(struct i2c_client));
        client->addr = address;
        client->adapter = adapter;
        client->driver = &i2c_driver_saa7114;
        strlcpy(I2C_NAME(client), "saa7114", sizeof(I2C_NAME(client)));
 
-       decoder = kmalloc(sizeof(struct saa7114), GFP_KERNEL);
+       decoder = kzalloc(sizeof(struct saa7114), GFP_KERNEL);
        if (decoder == NULL) {
                kfree(client);
                return -ENOMEM;
        }
-       memset(decoder, 0, sizeof(struct saa7114));
        decoder->norm = VIDEO_MODE_NTSC;
        decoder->input = -1;
        decoder->enable = 1;
index 4a4bc69fb0e97a7e95218a3fb563d51a68e841c6..ab8b4bcb5dd6c4589f4dcc0180b01bcce808f59c 100644 (file)
@@ -1249,10 +1249,9 @@ static int saa7115_attach(struct i2c_adapter *adapter, int address, int kind)
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return 0;
 
-       client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (client == 0)
                return -ENOMEM;
-       memset(client, 0, sizeof(struct i2c_client));
        client->addr = address;
        client->adapter = adapter;
        client->driver = &i2c_driver_saa7115;
@@ -1272,13 +1271,12 @@ static int saa7115_attach(struct i2c_adapter *adapter, int address, int kind)
        }
        v4l_info(client, "saa711%d found @ 0x%x (%s)\n", chip_id, address << 1, adapter->name);
 
-       state = kmalloc(sizeof(struct saa7115_state), GFP_KERNEL);
+       state = kzalloc(sizeof(struct saa7115_state), GFP_KERNEL);
        i2c_set_clientdata(client, state);
        if (state == NULL) {
                kfree(client);
                return -ENOMEM;
        }
-       memset(state, 0, sizeof(struct saa7115_state));
        state->std = V4L2_STD_NTSC;
        state->input = -1;
        state->enable = 1;
index f39a7be08588010fe5c29393793f2e576c5cbf1c..ae53063875f922dd0d4a9a783ba67ca22a3e85cb 100644 (file)
@@ -487,20 +487,18 @@ saa711x_detect_client (struct i2c_adapter *adapter,
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return 0;
 
-       client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (client == 0)
                return -ENOMEM;
-       memset(client, 0, sizeof(struct i2c_client));
        client->addr = address;
        client->adapter = adapter;
        client->driver = &i2c_driver_saa711x;
        strlcpy(I2C_NAME(client), "saa711x", sizeof(I2C_NAME(client)));
-       decoder = kmalloc(sizeof(struct saa711x), GFP_KERNEL);
+       decoder = kzalloc(sizeof(struct saa711x), GFP_KERNEL);
        if (decoder == NULL) {
                kfree(client);
                return -ENOMEM;
        }
-       memset(decoder, 0, sizeof(struct saa711x));
        decoder->norm = VIDEO_MODE_NTSC;
        decoder->input = 0;
        decoder->enable = 1;
index 2009c1bc47207c1b1f4e8d8eb75d5e6027399e22..d14eb3e5c96270ff3db8dbe5d811f0ae1efc7af1 100644 (file)
@@ -689,11 +689,10 @@ static int saa7127_attach(struct i2c_adapter *adapter, int address, int kind)
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return 0;
 
-       client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (client == 0)
                return -ENOMEM;
 
-       memset(client, 0, sizeof(struct i2c_client));
        client->addr = address;
        client->adapter = adapter;
        client->driver = &i2c_driver_saa7127;
@@ -712,7 +711,7 @@ static int saa7127_attach(struct i2c_adapter *adapter, int address, int kind)
                kfree(client);
                return 0;
        }
-       state = kmalloc(sizeof(struct saa7127_state), GFP_KERNEL);
+       state = kzalloc(sizeof(struct saa7127_state), GFP_KERNEL);
 
        if (state == NULL) {
                kfree(client);
@@ -720,7 +719,6 @@ static int saa7127_attach(struct i2c_adapter *adapter, int address, int kind)
        }
 
        i2c_set_clientdata(client, state);
-       memset(state, 0, sizeof(struct saa7127_state));
 
        /* Configure Encoder */
 
index ad73c4a60f2b2078f788d2d45aed9502bd065441..0e0ba50946e8923e9dc230cad0d046cc46cebe5f 100644 (file)
@@ -511,9 +511,8 @@ static int saa6752hs_attach(struct i2c_adapter *adap, int addr, int kind)
        struct saa6752hs_state *h;
 
 
-       if (NULL == (h = kmalloc(sizeof(*h), GFP_KERNEL)))
+       if (NULL == (h = kzalloc(sizeof(*h), GFP_KERNEL)))
                return -ENOMEM;
-       memset(h,0,sizeof(*h));
        h->client = client_template;
        h->params = param_defaults;
        h->client.adapter = adap;
index accbc32725cf9d9fdd190c0ff5590e83d8d97291..3983a6524cac98107a02b126babd1117c0cfb853 100644 (file)
@@ -803,10 +803,9 @@ static int __devinit saa7134_initdev(struct pci_dev *pci_dev,
        struct saa7134_mpeg_ops *mops;
        int err;
 
-       dev = kmalloc(sizeof(*dev),GFP_KERNEL);
+       dev = kzalloc(sizeof(*dev),GFP_KERNEL);
        if (NULL == dev)
                return -ENOMEM;
-       memset(dev,0,sizeof(*dev));
 
        /* pci init */
        dev->pci = pci_dev;
index adfa8fe49a11547c468e5a418f88e841d106deb4..e97426bc85df6aece8d49fd7aa639a0a36b7b5f8 100644 (file)
@@ -1264,10 +1264,9 @@ static int video_open(struct inode *inode, struct file *file)
                v4l2_type_names[type]);
 
        /* allocate + initialize per filehandle data */
-       fh = kmalloc(sizeof(*fh),GFP_KERNEL);
+       fh = kzalloc(sizeof(*fh),GFP_KERNEL);
        if (NULL == fh)
                return -ENOMEM;
-       memset(fh,0,sizeof(*fh));
        file->private_data = fh;
        fh->dev      = dev;
        fh->radio    = radio;
index f72a9f7962094ed563b09eed09193db602242b6a..3ed0edb870a4eccd295f24eaaacf576cee00e4f9 100644 (file)
@@ -408,21 +408,19 @@ saa7185_detect_client (struct i2c_adapter *adapter,
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return 0;
 
-       client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (client == 0)
                return -ENOMEM;
-       memset(client, 0, sizeof(struct i2c_client));
        client->addr = address;
        client->adapter = adapter;
        client->driver = &i2c_driver_saa7185;
        strlcpy(I2C_NAME(client), "saa7185", sizeof(I2C_NAME(client)));
 
-       encoder = kmalloc(sizeof(struct saa7185), GFP_KERNEL);
+       encoder = kzalloc(sizeof(struct saa7185), GFP_KERNEL);
        if (encoder == NULL) {
                kfree(client);
                return -ENOMEM;
        }
-       memset(encoder, 0, sizeof(struct saa7185));
        encoder->norm = VIDEO_MODE_NTSC;
        encoder->enable = 1;
        i2c_set_clientdata(client, encoder);
index 41f6f05a0436b947b7402ed0eeb007dd64b4fb1a..746cadb8f1c45d9b1af42ad892b98cc4a695df4b 100644 (file)
@@ -571,18 +571,15 @@ static int saa7191_attach(struct i2c_adapter *adap, int addr, int kind)
        printk(KERN_INFO "Philips SAA7191 driver version %s\n",
               SAA7191_MODULE_VERSION);
 
-       client = kmalloc(sizeof(*client), GFP_KERNEL);
+       client = kzalloc(sizeof(*client), GFP_KERNEL);
        if (!client)
                return -ENOMEM;
-       decoder = kmalloc(sizeof(*decoder), GFP_KERNEL);
+       decoder = kzalloc(sizeof(*decoder), GFP_KERNEL);
        if (!decoder) {
                err = -ENOMEM;
                goto out_free_client;
        }
 
-       memset(client, 0, sizeof(struct i2c_client));
-       memset(decoder, 0, sizeof(struct saa7191));
-
        client->addr = addr;
        client->adapter = adap;
        client->driver = &i2c_driver_saa7191;
index 99261f15e66ebebdb15a3ea9921ff1029188d291..873796bedec8f7454f3dc06004c696a5eb914b07 100644 (file)
@@ -300,10 +300,9 @@ static int tda7432_attach(struct i2c_adapter *adap, int addr, int kind)
        struct tda7432 *t;
        struct i2c_client *client;
 
-       t = kmalloc(sizeof *t,GFP_KERNEL);
+       t = kzalloc(sizeof *t,GFP_KERNEL);
        if (!t)
                return -ENOMEM;
-       memset(t,0,sizeof *t);
 
        client = &t->c;
        memcpy(client,&client_template,sizeof(struct i2c_client));
index 299393bf900a38c7fd67754a8845a8be102f070e..ef98c49822507f63d5ffbf710890541cdc8c2e6c 100644 (file)
@@ -232,10 +232,9 @@ static int tda9875_attach(struct i2c_adapter *adap, int addr, int kind)
        struct i2c_client *client;
        dprintk("In tda9875_attach\n");
 
-       t = kmalloc(sizeof *t,GFP_KERNEL);
+       t = kzalloc(sizeof *t,GFP_KERNEL);
        if (!t)
                return -ENOMEM;
-       memset(t,0,sizeof *t);
 
        client = &t->c;
        memcpy(client,&client_template,sizeof(struct i2c_client));
index 9cf47dc65579c28acc2b9fcf4224593884484745..5815649bdc78e316f3fd40c655530909a3986321 100644 (file)
@@ -696,9 +696,8 @@ static int tda9887_attach(struct i2c_adapter *adap, int addr, int kind)
        client_template.adapter = adap;
        client_template.addr    = addr;
 
-       if (NULL == (t = kmalloc(sizeof(*t), GFP_KERNEL)))
+       if (NULL == (t = kzalloc(sizeof(*t), GFP_KERNEL)))
                return -ENOMEM;
-       memset(t,0,sizeof(*t));
 
        t->client      = client_template;
        t->std         = 0;
index c4ba3742f5c779eceb2fef90545791dbc9d1988a..4dcba5a4fff099d95a19b61391c4925e6df47f92 100644 (file)
@@ -99,11 +99,10 @@ static int tea6420_detect(struct i2c_adapter *adapter, int address, int kind)
        }
 
        /* allocate memory for client structure */
-       client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (0 == client) {
                return -ENOMEM;
        }
-       memset(client, 0x0, sizeof(struct i2c_client));
 
        /* fill client structure */
        memcpy(client, &client_template, sizeof(struct i2c_client));
index 57bc585a6955c135dfad3c37fefd0f4eaf58c79c..89d013ce5edb1513f893c536ef32413fd26522fc 100644 (file)
@@ -410,10 +410,9 @@ static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
        client_template.adapter = adap;
        client_template.addr = addr;
 
-       t = kmalloc(sizeof(struct tuner), GFP_KERNEL);
+       t = kzalloc(sizeof(struct tuner), GFP_KERNEL);
        if (NULL == t)
                return -ENOMEM;
-       memset(t, 0, sizeof(struct tuner));
        memcpy(&t->i2c, &client_template, sizeof(struct i2c_client));
        i2c_set_clientdata(&t->i2c, t);
        t->type = UNSET;
index b582943a0d3e57406f9d3ed1434c20f26586b873..9baa6392e9b50d3752fbb6e3a9ef6063d25eb4d7 100644 (file)
@@ -1468,10 +1468,9 @@ static int chip_attach(struct i2c_adapter *adap, int addr, int kind)
        struct CHIPSTATE *chip;
        struct CHIPDESC  *desc;
 
-       chip = kmalloc(sizeof(*chip),GFP_KERNEL);
+       chip = kzalloc(sizeof(*chip),GFP_KERNEL);
        if (!chip)
                return -ENOMEM;
-       memset(chip,0,sizeof(*chip));
        memcpy(&chip->c,&client_template,sizeof(struct i2c_client));
        chip->c.adapter = adap;
        chip->c.addr = addr;
index fd0acc5da66771e5c5af5aa73bff79537ea3ea30..5e71a354e879464b6d3d99fc324be2d6512e0778 100644 (file)
@@ -719,8 +719,7 @@ tveeprom_command(struct i2c_client *client,
 
        switch (cmd) {
        case 0:
-               buf = kmalloc(256,GFP_KERNEL);
-               memset(buf,0,256);
+               buf = kzalloc(256,GFP_KERNEL);
                tveeprom_read(client,buf,256);
                tveeprom_hauppauge_analog(client, &eeprom,buf);
                kfree(buf);
@@ -743,10 +742,9 @@ tveeprom_detect_client(struct i2c_adapter *adapter,
 {
        struct i2c_client *client;
 
-       client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (NULL == client)
                return -ENOMEM;
-       memset(client, 0, sizeof(struct i2c_client));
        client->addr = address;
        client->adapter = adapter;
        client->driver = &i2c_driver_tveeprom;
index c35b8042eee58dd84bd7080a28801762bb36c4c9..e86b522938fdad9a09cc7fe78194e1b84e499683 100644 (file)
@@ -1074,12 +1074,11 @@ static int tvp5150_detect_client(struct i2c_adapter *adapter,
                return -ENOMEM;
        memcpy(c, &client_template, sizeof(struct i2c_client));
 
-       core = kmalloc(sizeof(struct tvp5150), GFP_KERNEL);
+       core = kzalloc(sizeof(struct tvp5150), GFP_KERNEL);
        if (core == 0) {
                kfree(c);
                return -ENOMEM;
        }
-       memset(core, 0, sizeof(struct tvp5150));
        i2c_set_clientdata(c, core);
 
        rv = i2c_attach_client(c);
index 2ab5b4093800bc789c992e067e8bc21b9e54f442..474a29bc1760d9feedc2bf8beb6b7d8907666783 100644 (file)
@@ -305,9 +305,8 @@ v4l_compat_translate_ioctl(struct inode         *inode,
        {
                struct video_capability *cap = arg;
 
-               cap2 = kmalloc(sizeof(*cap2),GFP_KERNEL);
+               cap2 = kzalloc(sizeof(*cap2),GFP_KERNEL);
                memset(cap, 0, sizeof(*cap));
-               memset(cap2, 0, sizeof(*cap2));
                memset(&fbuf2, 0, sizeof(fbuf2));
 
                err = drv(inode, file, VIDIOC_QUERYCAP, cap2);
@@ -422,9 +421,8 @@ v4l_compat_translate_ioctl(struct inode         *inode,
        {
                struct video_window     *win = arg;
 
-               fmt2 = kmalloc(sizeof(*fmt2),GFP_KERNEL);
+               fmt2 = kzalloc(sizeof(*fmt2),GFP_KERNEL);
                memset(win,0,sizeof(*win));
-               memset(fmt2,0,sizeof(*fmt2));
 
                fmt2->type = V4L2_BUF_TYPE_VIDEO_OVERLAY;
                err = drv(inode, file, VIDIOC_G_FMT, fmt2);
@@ -461,8 +459,7 @@ v4l_compat_translate_ioctl(struct inode         *inode,
                struct video_window     *win = arg;
                int err1,err2;
 
-               fmt2 = kmalloc(sizeof(*fmt2),GFP_KERNEL);
-               memset(fmt2,0,sizeof(*fmt2));
+               fmt2 = kzalloc(sizeof(*fmt2),GFP_KERNEL);
                fmt2->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                drv(inode, file, VIDIOC_STREAMOFF, &fmt2->type);
                err1 = drv(inode, file, VIDIOC_G_FMT, fmt2);
@@ -595,8 +592,7 @@ v4l_compat_translate_ioctl(struct inode         *inode,
                pict->whiteness = get_v4l_control(inode, file,
                                                  V4L2_CID_WHITENESS, drv);
 
-               fmt2 = kmalloc(sizeof(*fmt2),GFP_KERNEL);
-               memset(fmt2,0,sizeof(*fmt2));
+               fmt2 = kzalloc(sizeof(*fmt2),GFP_KERNEL);
                fmt2->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                err = drv(inode, file, VIDIOC_G_FMT, fmt2);
                if (err < 0) {
@@ -622,8 +618,7 @@ v4l_compat_translate_ioctl(struct inode         *inode,
                set_v4l_control(inode, file,
                                V4L2_CID_WHITENESS, pict->whiteness, drv);
 
-               fmt2 = kmalloc(sizeof(*fmt2),GFP_KERNEL);
-               memset(fmt2,0,sizeof(*fmt2));
+               fmt2 = kzalloc(sizeof(*fmt2),GFP_KERNEL);
                fmt2->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                err = drv(inode, file, VIDIOC_G_FMT, fmt2);
                if (err < 0)
@@ -846,9 +841,8 @@ v4l_compat_translate_ioctl(struct inode         *inode,
        {
                struct video_mmap       *mm = arg;
 
-               fmt2 = kmalloc(sizeof(*fmt2),GFP_KERNEL);
+               fmt2 = kzalloc(sizeof(*fmt2),GFP_KERNEL);
                memset(&buf2,0,sizeof(buf2));
-               memset(fmt2,0,sizeof(*fmt2));
 
                fmt2->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                err = drv(inode, file, VIDIOC_G_FMT, fmt2);
@@ -942,8 +936,7 @@ v4l_compat_translate_ioctl(struct inode         *inode,
        {
                struct vbi_format      *fmt = arg;
 
-               fmt2 = kmalloc(sizeof(*fmt2),GFP_KERNEL);
-               memset(fmt2, 0, sizeof(*fmt2));
+               fmt2 = kzalloc(sizeof(*fmt2),GFP_KERNEL);
                fmt2->type = V4L2_BUF_TYPE_VBI_CAPTURE;
 
                err = drv(inode, file, VIDIOC_G_FMT, fmt2);
@@ -975,8 +968,7 @@ v4l_compat_translate_ioctl(struct inode         *inode,
                        break;
                }
 
-               fmt2 = kmalloc(sizeof(*fmt2),GFP_KERNEL);
-               memset(fmt2, 0, sizeof(*fmt2));
+               fmt2 = kzalloc(sizeof(*fmt2),GFP_KERNEL);
 
                fmt2->type = V4L2_BUF_TYPE_VBI_CAPTURE;
                fmt2->fmt.vbi.samples_per_line = fmt->samples_per_line;
index 9a6bf287e26ae629497aa0e9c3c206281e817a41..9ef477523d27ecba4789ed4607bcb959ec335440 100644 (file)
@@ -52,10 +52,9 @@ videobuf_vmalloc_to_sg(unsigned char *virt, int nr_pages)
        struct page *pg;
        int i;
 
-       sglist = kmalloc(sizeof(struct scatterlist)*nr_pages, GFP_KERNEL);
+       sglist = kcalloc(nr_pages, sizeof(struct scatterlist), GFP_KERNEL);
        if (NULL == sglist)
                return NULL;
-       memset(sglist,0,sizeof(struct scatterlist)*nr_pages);
        for (i = 0; i < nr_pages; i++, virt += PAGE_SIZE) {
                pg = vmalloc_to_page(virt);
                if (NULL == pg)
@@ -80,10 +79,9 @@ videobuf_pages_to_sg(struct page **pages, int nr_pages, int offset)
 
        if (NULL == pages[0])
                return NULL;
-       sglist = kmalloc(sizeof(*sglist) * nr_pages, GFP_KERNEL);
+       sglist = kcalloc(nr_pages, sizeof(*sglist), GFP_KERNEL);
        if (NULL == sglist)
                return NULL;
-       memset(sglist, 0, sizeof(*sglist) * nr_pages);
 
        if (NULL == pages[0])
                goto nopage;
@@ -284,9 +282,8 @@ void* videobuf_alloc(unsigned int size)
 {
        struct videobuf_buffer *vb;
 
-       vb = kmalloc(size,GFP_KERNEL);
+       vb = kzalloc(size,GFP_KERNEL);
        if (NULL != vb) {
-               memset(vb,0,size);
                videobuf_dma_init(&vb->dma);
                init_waitqueue_head(&vb->done);
                vb->magic     = MAGIC_BUFFER;
index 839db622040dcdcfe1ff344d7f8846b5c9a7ef53..8f271de57fd6c8e0fe246b49cf692e6f02d4b510 100644 (file)
@@ -124,17 +124,13 @@ videocodec_attach (struct videocodec_master *master)
                        if (res == 0) {
                                dprintk(3, "videocodec_attach '%s'\n",
                                        codec->name);
-                               ptr = (struct attached_list *)
-                                   kmalloc(sizeof(struct attached_list),
-                                           GFP_KERNEL);
+                               ptr = kzalloc(sizeof(struct attached_list), GFP_KERNEL);
                                if (!ptr) {
                                        dprintk(1,
                                                KERN_ERR
                                                "videocodec_attach: no memory\n");
                                        goto out_kfree;
                                }
-                               memset(ptr, 0,
-                                      sizeof(struct attached_list));
                                ptr->codec = codec;
 
                                a = h->list;
@@ -249,14 +245,11 @@ videocodec_register (const struct videocodec *codec)
                "videocodec: register '%s', type: %x, flags %lx, magic %lx\n",
                codec->name, codec->type, codec->flags, codec->magic);
 
-       ptr =
-           (struct codec_list *) kmalloc(sizeof(struct codec_list),
-                                         GFP_KERNEL);
+       ptr = kzalloc(sizeof(struct codec_list), GFP_KERNEL);
        if (!ptr) {
                dprintk(1, KERN_ERR "videocodec_register: no memory\n");
                return -ENOMEM;
        }
-       memset(ptr, 0, sizeof(struct codec_list));
        ptr->codec = codec;
 
        if (!h) {
index 9a9902c56ae72f81d06ebf58088baf73e05cc28a..d5be25987142c65eb891bacbdae3d55b74fe08bc 100644 (file)
@@ -52,10 +52,7 @@ struct video_device *video_device_alloc(void)
 {
        struct video_device *vfd;
 
-       vfd = kmalloc(sizeof(*vfd),GFP_KERNEL);
-       if (NULL == vfd)
-               return NULL;
-       memset(vfd,0,sizeof(*vfd));
+       vfd = kzalloc(sizeof(*vfd),GFP_KERNEL);
        return vfd;
 }
 
index 71b28e9e085021e1fdae979e4edf7fe6b270a353..c8fd8238904dbaef113c6f550dcc2396549d3c26 100644 (file)
@@ -4499,13 +4499,11 @@ static int vino_init(void)
        dma_addr_t dma_dummy_address;
        int i;
 
-       vino_drvdata = (struct vino_settings *)
-               kmalloc(sizeof(struct vino_settings), GFP_KERNEL);
+       vino_drvdata = kzalloc(sizeof(struct vino_settings), GFP_KERNEL);
        if (!vino_drvdata) {
                vino_module_cleanup(vino_init_stage);
                return -ENOMEM;
        }
-       memset(vino_drvdata, 0, sizeof(struct vino_settings));
        vino_init_stage++;
 
        /* create a dummy dma descriptor */
index 8dcee8b60e21a2cfc458808b1bbf13376d814a7b..d0a1e72ea8c46924482141d1ad2dc64b30570c78 100644 (file)
@@ -621,13 +621,11 @@ vpx3220_detect_client (struct i2c_adapter *adapter,
            (adapter, I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
                return 0;
 
-       client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (client == NULL) {
                return -ENOMEM;
        }
 
-       memset(client, 0, sizeof(struct i2c_client));
-
        client->addr = address;
        client->adapter = adapter;
        client->driver = &vpx3220_i2c_driver;
@@ -675,12 +673,11 @@ vpx3220_detect_client (struct i2c_adapter *adapter,
                        sizeof(I2C_NAME(client)));
        }
 
-       decoder = kmalloc(sizeof(struct vpx3220), GFP_KERNEL);
+       decoder = kzalloc(sizeof(struct vpx3220), GFP_KERNEL);
        if (decoder == NULL) {
                kfree(client);
                return -ENOMEM;
        }
-       memset(decoder, 0, sizeof(struct vpx3220));
        decoder->norm = VIDEO_MODE_PAL;
        decoder->input = 0;
        decoder->enable = 1;
index c2e6d2e9f5f12ad70bcd52c6421debeef62dda25..8cb64f8a8a9182b8e5f9a146c8d4f3fba8d9381d 100644 (file)
@@ -166,11 +166,10 @@ static int wm8775_attach(struct i2c_adapter *adapter, int address, int kind)
        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
                return 0;
 
-       client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
+       client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
        if (client == 0)
                return -ENOMEM;
 
-       memset(client, 0, sizeof(struct i2c_client));
        client->addr = address;
        client->adapter = adapter;
        client->driver = &i2c_driver;
index 39a0d238900e63f26c34992944b73a441e66b8f4..ea3288661a3457d65a49b2d841514c18674760e8 100644 (file)
@@ -1050,7 +1050,7 @@ zr36057_init (struct zoran *zr)
        /* allocate memory *before* doing anything to the hardware
         * in case allocation fails */
        mem_needed = BUZ_NUM_STAT_COM * 4;
-       mem = (unsigned long) kmalloc(mem_needed, GFP_KERNEL);
+       mem = kzalloc(mem_needed, GFP_KERNEL);
        vdev = (void *) kmalloc(sizeof(struct video_device), GFP_KERNEL);
        if (!mem || !vdev) {
                dprintk(1,
@@ -1061,7 +1061,6 @@ zr36057_init (struct zoran *zr)
                kfree((void *)mem);
                return -ENOMEM;
        }
-       memset((void *) mem, 0, mem_needed);
        zr->stat_com = (u32 *) mem;
        for (j = 0; j < BUZ_NUM_STAT_COM; j++) {
                zr->stat_com[j] = 1;    /* mark as unavailable to zr36057 */
index 15283f44e79f6b56ba6bd708f8710ed9779156aa..485553be190be7cd764ba6081d8427b97c5df15b 100644 (file)
@@ -1345,7 +1345,7 @@ zoran_open (struct inode *inode,
                ZR_DEVNAME(zr), current->comm, current->pid, zr->user);
 
        /* now, create the open()-specific file_ops struct */
-       fh = kmalloc(sizeof(struct zoran_fh), GFP_KERNEL);
+       fh = kzalloc(sizeof(struct zoran_fh), GFP_KERNEL);
        if (!fh) {
                dprintk(1,
                        KERN_ERR
@@ -1354,7 +1354,6 @@ zoran_open (struct inode *inode,
                res = -ENOMEM;
                goto open_unlock_and_return;
        }
-       memset(fh, 0, sizeof(struct zoran_fh));
        /* used to be BUZ_MAX_WIDTH/HEIGHT, but that gives overflows
         * on norm-change! */
        fh->overlay_mask =
index 4ed898585c7082234aaec06bfd6e6150dd2068d4..10130ef67ea7f644d736c0d3daa45c88254f8b4c 100644 (file)
@@ -451,12 +451,11 @@ zr36016_setup (struct videocodec *codec)
                return -ENOSPC;
        }
        //mem structure init
-       codec->data = ptr = kmalloc(sizeof(struct zr36016), GFP_KERNEL);
+       codec->data = ptr = kzalloc(sizeof(struct zr36016), GFP_KERNEL);
        if (NULL == ptr) {
                dprintk(1, KERN_ERR "zr36016: Can't get enough memory!\n");
                return -ENOMEM;
        }
-       memset(ptr, 0, sizeof(struct zr36016));
 
        snprintf(ptr->name, sizeof(ptr->name), "zr36016[%d]",
                 zr36016_codecs);
index 0144576a61233d239e7bf35f1f0811418b8ed6b7..bd0cd28543ca02f7f007c4abff113f9792d8149a 100644 (file)
@@ -813,12 +813,11 @@ zr36050_setup (struct videocodec *codec)
                return -ENOSPC;
        }
        //mem structure init
-       codec->data = ptr = kmalloc(sizeof(struct zr36050), GFP_KERNEL);
+       codec->data = ptr = kzalloc(sizeof(struct zr36050), GFP_KERNEL);
        if (NULL == ptr) {
                dprintk(1, KERN_ERR "zr36050: Can't get enough memory!\n");
                return -ENOMEM;
        }
-       memset(ptr, 0, sizeof(struct zr36050));
 
        snprintf(ptr->name, sizeof(ptr->name), "zr36050[%d]",
                 zr36050_codecs);
index 129744a07abd868c47609ad23adda80c42f8e82e..28fa31a5f1501a2afcc2989085b6fd3b372d76cd 100644 (file)
@@ -919,12 +919,11 @@ zr36060_setup (struct videocodec *codec)
                return -ENOSPC;
        }
        //mem structure init
-       codec->data = ptr = kmalloc(sizeof(struct zr36060), GFP_KERNEL);
+       codec->data = ptr = kzalloc(sizeof(struct zr36060), GFP_KERNEL);
        if (NULL == ptr) {
                dprintk(1, KERN_ERR "zr36060: Can't get enough memory!\n");
                return -ENOMEM;
        }
-       memset(ptr, 0, sizeof(struct zr36060));
 
        snprintf(ptr->name, sizeof(ptr->name), "zr36060[%d]",
                 zr36060_codecs);