30 files changed, 35 insertions, 73 deletions

diff --git a/drivers/net/b44.c b/drivers/net/b44.c
index 96fb0ec905a7..37f1b6ff5c12 100644
--- a/drivers/net/b44.c
+++ b/drivers/net/b44.c
@@ -1519,14 +1519,13 @@ static void b44_setup_pseudo_magicp(struct b44 *bp)
         u8 *pwol_pattern;
         u8 pwol_mask[B44_PMASK_SIZE];
 
-        pwol_pattern = kmalloc(B44_PATTERN_SIZE, GFP_KERNEL);
+        pwol_pattern = kzalloc(B44_PATTERN_SIZE, GFP_KERNEL);
         if (!pwol_pattern) {
                 printk(KERN_ERR PFX "Memory not available for WOL\n");
                 return;
         }
 
         /* Ipv4 magic packet pattern - pattern 0.*/
-        memset(pwol_pattern, 0, B44_PATTERN_SIZE);
         memset(pwol_mask, 0, B44_PMASK_SIZE);
         plen0 = b44_magic_pattern(bp->dev->dev_addr, pwol_pattern, pwol_mask,
                                   B44_ETHIPV4UDP_HLEN);
diff --git a/drivers/net/bsd_comp.c b/drivers/net/bsd_comp.c
index 7845eaf6f29f..202d4a4ef751 100644
--- a/drivers/net/bsd_comp.c
+++ b/drivers/net/bsd_comp.c
@@ -395,14 +395,13 @@ static void *bsd_alloc (unsigned char *options, int opt_len, int decomp)
  * Allocate the main control structure for this instance.
  */
     maxmaxcode = MAXCODE(bits);
-    db         = kmalloc(sizeof (struct bsd_db),
+    db         = kzalloc(sizeof (struct bsd_db),
                                             GFP_KERNEL);
     if (!db)
       {
         return NULL;
       }
 
-    memset (db, 0, sizeof(struct bsd_db));
 /*
  * Allocate space for the dictionary. This may be more than one page in
  * length.
diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c
index 136827f8dc2e..6d1d50a19783 100644
--- a/drivers/net/forcedeth.c
+++ b/drivers/net/forcedeth.c
@@ -5137,12 +5137,10 @@ static int __devinit nv_probe(struct pci_dev *pci_dev, const struct pci_device_i
                         goto out_unmap;
                 np->tx_ring.ex = &np->rx_ring.ex[np->rx_ring_size];
         }
-        np->rx_skb = kmalloc(sizeof(struct nv_skb_map) * np->rx_ring_size, GFP_KERNEL);
-        np->tx_skb = kmalloc(sizeof(struct nv_skb_map) * np->tx_ring_size, GFP_KERNEL);
+        np->rx_skb = kcalloc(np->rx_ring_size, sizeof(struct nv_skb_map), GFP_KERNEL);
+        np->tx_skb = kcalloc(np->tx_ring_size, sizeof(struct nv_skb_map), GFP_KERNEL);
         if (!np->rx_skb || !np->tx_skb)
                 goto out_freering;
-        memset(np->rx_skb, 0, sizeof(struct nv_skb_map) * np->rx_ring_size);
-        memset(np->tx_skb, 0, sizeof(struct nv_skb_map) * np->tx_ring_size);
 
         dev->open = nv_open;
         dev->stop = nv_close;
diff --git a/drivers/net/hamradio/dmascc.c b/drivers/net/hamradio/dmascc.c
index 3be8c5047599..205f09672492 100644
--- a/drivers/net/hamradio/dmascc.c
+++ b/drivers/net/hamradio/dmascc.c
@@ -453,8 +453,8 @@ static int __init setup_adapter(int card_base, int type, int n)
         int scc_base = card_base + hw[type].scc_offset;
         char *chipnames[] = CHIPNAMES;
 
-        /* Allocate memory */
-        info = kmalloc(sizeof(struct scc_info), GFP_KERNEL | GFP_DMA);
+        /* Initialize what is necessary for write_scc and write_scc_data */
+        info = kzalloc(sizeof(struct scc_info), GFP_KERNEL | GFP_DMA);
         if (!info) {
                 printk(KERN_ERR "dmascc: "
                        "could not allocate memory for %s at %#3x\n",
@@ -462,8 +462,6 @@ static int __init setup_adapter(int card_base, int type, int n)
                 goto out;
         }
 
-        /* Initialize what is necessary for write_scc and write_scc_data */
-        memset(info, 0, sizeof(struct scc_info));
 
         info->dev[0] = alloc_netdev(0, "", dev_setup);
         if (!info->dev[0]) {
diff --git a/drivers/net/irda/irport.c b/drivers/net/irda/irport.c
index 3078c419cb02..20732458f5ac 100644
--- a/drivers/net/irda/irport.c
+++ b/drivers/net/irda/irport.c
@@ -164,14 +164,13 @@ irport_open(int i, unsigned int iobase, unsigned int irq)
         
         /* Allocate memory if needed */
         if (self->tx_buff.truesize > 0) {
-                self->tx_buff.head = kmalloc(self->tx_buff.truesize,
+                self->tx_buff.head = kzalloc(self->tx_buff.truesize,
                                                       GFP_KERNEL);
                 if (self->tx_buff.head == NULL) {
                         IRDA_ERROR("%s(), can't allocate memory for "
                                    "transmit buffer!\n", __FUNCTION__);
                         goto err_out4;
                 }
-                memset(self->tx_buff.head, 0, self->tx_buff.truesize);
         }       
         self->tx_buff.data = self->tx_buff.head;
 
diff --git a/drivers/net/irda/irtty-sir.c b/drivers/net/irda/irtty-sir.c
index ad1857364d51..6f5f697ec9f8 100644
--- a/drivers/net/irda/irtty-sir.c
+++ b/drivers/net/irda/irtty-sir.c
@@ -505,10 +505,9 @@ static int irtty_open(struct tty_struct *tty)
         }
 
         /* allocate private device info block */
-        priv = kmalloc(sizeof(*priv), GFP_KERNEL);
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
         if (!priv)
                 goto out_put;
-        memset(priv, 0, sizeof(*priv));
 
         priv->magic = IRTTY_MAGIC;
         priv->tty = tty;
diff --git a/drivers/net/iseries_veth.c b/drivers/net/iseries_veth.c
index 347d50cd77d4..0433c41f9029 100644
--- a/drivers/net/iseries_veth.c
+++ b/drivers/net/iseries_veth.c
@@ -822,10 +822,9 @@ static int veth_init_connection(u8 rlp)
              || ! HvLpConfig_doLpsCommunicateOnVirtualLan(this_lp, rlp) )
                 return 0;
 
-        cnx = kmalloc(sizeof(*cnx), GFP_KERNEL);
+        cnx = kzalloc(sizeof(*cnx), GFP_KERNEL);
         if (! cnx)
                 return -ENOMEM;
-        memset(cnx, 0, sizeof(*cnx));
 
         cnx->remote_lp = rlp;
         spin_lock_init(&cnx->lock);
@@ -852,14 +851,13 @@ static int veth_init_connection(u8 rlp)
         if (rc != 0)
                 return rc;
 
-        msgs = kmalloc(VETH_NUMBUFFERS * sizeof(struct veth_msg), GFP_KERNEL);
+        msgs = kcalloc(VETH_NUMBUFFERS, sizeof(struct veth_msg), GFP_KERNEL);
         if (! msgs) {
                 veth_error("Can't allocate buffers for LPAR %d.\n", rlp);
                 return -ENOMEM;
         }
 
         cnx->msgs = msgs;
-        memset(msgs, 0, VETH_NUMBUFFERS * sizeof(struct veth_msg));
 
         for (i = 0; i < VETH_NUMBUFFERS; i++) {
                 msgs[i].token = i;
diff --git a/drivers/net/lance.c b/drivers/net/lance.c
index a2f37e52b928..a4e5fab12628 100644
--- a/drivers/net/lance.c
+++ b/drivers/net/lance.c
@@ -533,11 +533,10 @@ static int __init lance_probe1(struct net_device *dev, int ioaddr, int irq, int
         dev->base_addr = ioaddr;
         /* Make certain the data structures used by the LANCE are aligned and DMAble. */
 
-        lp = kmalloc(sizeof(*lp), GFP_DMA | GFP_KERNEL);
+        lp = kzalloc(sizeof(*lp), GFP_DMA | GFP_KERNEL);
         if(lp==NULL)
                 return -ENODEV;
         if (lance_debug > 6) printk(" (#0x%05lx)", (unsigned long)lp);
-        memset(lp, 0, sizeof(*lp));
         dev->priv = lp;
         lp->name = chipname;
         lp->rx_buffs = (unsigned long)kmalloc(PKT_BUF_SZ*RX_RING_SIZE,
diff --git a/drivers/net/pcmcia/com20020_cs.c b/drivers/net/pcmcia/com20020_cs.c
index 0d1c7a41c9c6..ea9414c4d900 100644
--- a/drivers/net/pcmcia/com20020_cs.c
+++ b/drivers/net/pcmcia/com20020_cs.c
@@ -147,7 +147,7 @@ static int com20020_probe(struct pcmcia_device *p_dev)
     DEBUG(0, "com20020_attach()\n");
 
     /* Create new network device */
-    info = kmalloc(sizeof(struct com20020_dev_t), GFP_KERNEL);
+    info = kzalloc(sizeof(struct com20020_dev_t), GFP_KERNEL);
     if (!info)
         goto fail_alloc_info;
 
@@ -155,7 +155,6 @@ static int com20020_probe(struct pcmcia_device *p_dev)
     if (!dev)
         goto fail_alloc_dev;
 
-    memset(info, 0, sizeof(struct com20020_dev_t));
     lp = dev->priv;
     lp->timeout = timeout;
     lp->backplane = backplane;
diff --git a/drivers/net/pcmcia/ibmtr_cs.c b/drivers/net/pcmcia/ibmtr_cs.c
index 4ecb8ca5a992..4eafa4f42cff 100644
--- a/drivers/net/pcmcia/ibmtr_cs.c
+++ b/drivers/net/pcmcia/ibmtr_cs.c
@@ -146,9 +146,8 @@ static int __devinit ibmtr_attach(struct pcmcia_device *link)
     DEBUG(0, "ibmtr_attach()\n");
 
     /* Create new token-ring device */
-    info = kmalloc(sizeof(*info), GFP_KERNEL); 
+    info = kzalloc(sizeof(*info), GFP_KERNEL);
     if (!info) return -ENOMEM;
-    memset(info,0,sizeof(*info));
     dev = alloc_trdev(sizeof(struct tok_info));
     if (!dev) {
         kfree(info);
diff --git a/drivers/net/ppp_async.c b/drivers/net/ppp_async.c
index caabbc408c34..27f5b904f48e 100644
--- a/drivers/net/ppp_async.c
+++ b/drivers/net/ppp_async.c
@@ -159,12 +159,11 @@ ppp_asynctty_open(struct tty_struct *tty)
         int err;
 
         err = -ENOMEM;
-        ap = kmalloc(sizeof(*ap), GFP_KERNEL);
+        ap = kzalloc(sizeof(*ap), GFP_KERNEL);
         if (ap == 0)
                 goto out;
 
         /* initialize the asyncppp structure */
-        memset(ap, 0, sizeof(*ap));
         ap->tty = tty;
         ap->mru = PPP_MRU;
         spin_lock_init(&ap->xmit_lock);
diff --git a/drivers/net/ppp_deflate.c b/drivers/net/ppp_deflate.c
index 72c8d6628f58..eb98b661efba 100644
--- a/drivers/net/ppp_deflate.c
+++ b/drivers/net/ppp_deflate.c
@@ -121,12 +121,11 @@ static void *z_comp_alloc(unsigned char *options, int opt_len)
         if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE)
                 return NULL;
 
-        state = kmalloc(sizeof(*state),
+        state = kzalloc(sizeof(*state),
                                                      GFP_KERNEL);
         if (state == NULL)
                 return NULL;
 
-        memset (state, 0, sizeof (struct ppp_deflate_state));
         state->strm.next_in   = NULL;
         state->w_size         = w_size;
         state->strm.workspace = vmalloc(zlib_deflate_workspacesize());
@@ -341,11 +340,10 @@ static void *z_decomp_alloc(unsigned char *options, int opt_len)
         if (w_size < DEFLATE_MIN_SIZE || w_size > DEFLATE_MAX_SIZE)
                 return NULL;
 
-        state = kmalloc(sizeof(*state), GFP_KERNEL);
+        state = kzalloc(sizeof(*state), GFP_KERNEL);
         if (state == NULL)
                 return NULL;
 
-        memset (state, 0, sizeof (struct ppp_deflate_state));
         state->w_size         = w_size;
         state->strm.next_out  = NULL;
         state->strm.workspace = kmalloc(zlib_inflate_workspacesize(),
diff --git a/drivers/net/ppp_mppe.c b/drivers/net/ppp_mppe.c
index d5bdd2574659..f79cf87a2bff 100644
--- a/drivers/net/ppp_mppe.c
+++ b/drivers/net/ppp_mppe.c
@@ -200,11 +200,10 @@ static void *mppe_alloc(unsigned char *options, int optlen)
             || options[0] != CI_MPPE || options[1] != CILEN_MPPE)
                 goto out;
 
-        state = kmalloc(sizeof(*state), GFP_KERNEL);
+        state = kzalloc(sizeof(*state), GFP_KERNEL);
         if (state == NULL)
                 goto out;
 
-        memset(state, 0, sizeof(*state));
 
         state->arc4 = crypto_alloc_blkcipher("ecb(arc4)", 0, CRYPTO_ALG_ASYNC);
         if (IS_ERR(state->arc4)) {
diff --git a/drivers/net/ppp_synctty.c b/drivers/net/ppp_synctty.c
index 5918fab38349..ce64032a465a 100644
--- a/drivers/net/ppp_synctty.c
+++ b/drivers/net/ppp_synctty.c
@@ -207,13 +207,12 @@ ppp_sync_open(struct tty_struct *tty)
         struct syncppp *ap;
         int err;
 
-        ap = kmalloc(sizeof(*ap), GFP_KERNEL);
+        ap = kzalloc(sizeof(*ap), GFP_KERNEL);
         err = -ENOMEM;
         if (ap == 0)
                 goto out;
 
         /* initialize the syncppp structure */
-        memset(ap, 0, sizeof(*ap));
         ap->tty = tty;
         ap->mru = PPP_MRU;
         spin_lock_init(&ap->xmit_lock);
diff --git a/drivers/net/shaper.c b/drivers/net/shaper.c
index e886e8d7cfdf..4c3d98ff4cd4 100644
--- a/drivers/net/shaper.c
+++ b/drivers/net/shaper.c
@@ -600,10 +600,9 @@ static int __init shaper_init(void)
                 return -ENODEV;
 
         alloc_size = sizeof(*dev) * shapers;
-        devs = kmalloc(alloc_size, GFP_KERNEL);
+        devs = kzalloc(alloc_size, GFP_KERNEL);
         if (!devs)
                 return -ENOMEM;
-        memset(devs, 0, alloc_size);
 
         for (i = 0; i < shapers; i++) {
 
diff --git a/drivers/net/wan/c101.c b/drivers/net/wan/c101.c
index 6b63b350cd52..8ead774d14c8 100644
--- a/drivers/net/wan/c101.c
+++ b/drivers/net/wan/c101.c
@@ -315,12 +315,11 @@ static int __init c101_run(unsigned long irq, unsigned long winbase)
                 return -ENODEV;
         }
 
-        card = kmalloc(sizeof(card_t), GFP_KERNEL);
+        card = kzalloc(sizeof(card_t), GFP_KERNEL);
         if (card == NULL) {
                 printk(KERN_ERR "c101: unable to allocate memory\n");
                 return -ENOBUFS;
         }
-        memset(card, 0, sizeof(card_t));
 
         card->dev = alloc_hdlcdev(card);
         if (!card->dev) {
diff --git a/drivers/net/wan/cosa.c b/drivers/net/wan/cosa.c
index 9ef49ce148b2..26058b4f8f36 100644
--- a/drivers/net/wan/cosa.c
+++ b/drivers/net/wan/cosa.c
@@ -572,13 +572,11 @@ static int cosa_probe(int base, int irq, int dma)
         sprintf(cosa->name, "cosa%d", cosa->num);
 
         /* Initialize the per-channel data */
-        cosa->chan = kmalloc(sizeof(struct channel_data)*cosa->nchannels,
-                             GFP_KERNEL);
+        cosa->chan = kcalloc(cosa->nchannels, sizeof(struct channel_data), GFP_KERNEL);
         if (!cosa->chan) {
                 err = -ENOMEM;
                 goto err_out3;
         }
-        memset(cosa->chan, 0, sizeof(struct channel_data)*cosa->nchannels);
         for (i=0; i<cosa->nchannels; i++) {
                 cosa->chan[i].cosa = cosa;
                 cosa->chan[i].num = i;
diff --git a/drivers/net/wan/cycx_main.c b/drivers/net/wan/cycx_main.c
index 6e5f1c898517..a0e8611ad8e8 100644
--- a/drivers/net/wan/cycx_main.c
+++ b/drivers/net/wan/cycx_main.c
@@ -113,12 +113,10 @@ static int __init cycx_init(void)
         /* Verify number of cards and allocate adapter data space */
         cycx_ncards = min_t(int, cycx_ncards, CYCX_MAX_CARDS);
         cycx_ncards = max_t(int, cycx_ncards, 1);
-        cycx_card_array = kmalloc(sizeof(struct cycx_device) * cycx_ncards,
-                                  GFP_KERNEL);
+        cycx_card_array = kcalloc(cycx_ncards, sizeof(struct cycx_device), GFP_KERNEL);
         if (!cycx_card_array)
                 goto out;
 
-        memset(cycx_card_array, 0, sizeof(struct cycx_device) * cycx_ncards);
 
         /* Register adapters with WAN router */
         for (cnt = 0; cnt < cycx_ncards; ++cnt) {
diff --git a/drivers/net/wan/cycx_x25.c b/drivers/net/wan/cycx_x25.c
index 016b3ff3ea5e..a8af28b273d3 100644
--- a/drivers/net/wan/cycx_x25.c
+++ b/drivers/net/wan/cycx_x25.c
@@ -376,11 +376,10 @@ static int cycx_wan_new_if(struct wan_device *wandev, struct net_device *dev,
         }
 
         /* allocate and initialize private data */
-        chan = kmalloc(sizeof(struct cycx_x25_channel), GFP_KERNEL);
+        chan = kzalloc(sizeof(struct cycx_x25_channel), GFP_KERNEL);
         if (!chan)
                 return -ENOMEM;
 
-        memset(chan, 0, sizeof(*chan));
         strcpy(chan->name, conf->name);
         chan->card = card;
         chan->link = conf->port;
diff --git a/drivers/net/wan/dscc4.c b/drivers/net/wan/dscc4.c
index dca024471455..50d2f9108dca 100644
--- a/drivers/net/wan/dscc4.c
+++ b/drivers/net/wan/dscc4.c
@@ -890,12 +890,11 @@ static int dscc4_found1(struct pci_dev *pdev, void __iomem *ioaddr)
         struct dscc4_dev_priv *root;
         int i, ret = -ENOMEM;
 
-        root = kmalloc(dev_per_card*sizeof(*root), GFP_KERNEL);
+        root = kcalloc(dev_per_card, sizeof(*root), GFP_KERNEL);
         if (!root) {
                 printk(KERN_ERR "%s: can't allocate data\n", DRV_NAME);
                 goto err_out;
         }
-        memset(root, 0, dev_per_card*sizeof(*root));
 
         for (i = 0; i < dev_per_card; i++) {
                 root[i].dev = alloc_hdlcdev(root + i);
@@ -903,12 +902,11 @@ static int dscc4_found1(struct pci_dev *pdev, void __iomem *ioaddr)
                         goto err_free_dev;
         }
 
-        ppriv = kmalloc(sizeof(*ppriv), GFP_KERNEL);
+        ppriv = kzalloc(sizeof(*ppriv), GFP_KERNEL);
         if (!ppriv) {
                 printk(KERN_ERR "%s: can't allocate private data\n", DRV_NAME);
                 goto err_free_dev;
         }
-        memset(ppriv, 0, sizeof(struct dscc4_pci_priv));
 
         ppriv->root = root;
         spin_lock_init(&ppriv->lock);
diff --git a/drivers/net/wan/farsync.c b/drivers/net/wan/farsync.c
index 58a53b6d9b42..12dae8e24844 100644
--- a/drivers/net/wan/farsync.c
+++ b/drivers/net/wan/farsync.c
@@ -2476,13 +2476,12 @@ fst_add_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         }
 
         /* Allocate driver private data */
-        card = kmalloc(sizeof (struct fst_card_info), GFP_KERNEL);
+        card = kzalloc(sizeof (struct fst_card_info), GFP_KERNEL);
         if (card == NULL) {
                 printk_err("FarSync card found but insufficient memory for"
                            " driver storage\n");
                 return -ENOMEM;
         }
-        memset(card, 0, sizeof (struct fst_card_info));
 
         /* Try to enable the device */
         if ((err = pci_enable_device(pdev)) != 0) {
diff --git a/drivers/net/wan/hostess_sv11.c b/drivers/net/wan/hostess_sv11.c
index 9ba3e4ee6ec7..bf5f8d9b5c83 100644
--- a/drivers/net/wan/hostess_sv11.c
+++ b/drivers/net/wan/hostess_sv11.c
@@ -231,11 +231,10 @@ static struct sv11_device *sv11_init(int iobase, int irq)
                 return NULL;
         }
         
-        sv = kmalloc(sizeof(struct sv11_device), GFP_KERNEL);
+        sv = kzalloc(sizeof(struct sv11_device), GFP_KERNEL);
         if(!sv)
                 goto fail3;
                         
-        memset(sv, 0, sizeof(*sv));
         sv->if_ptr=&sv->netdev;
         
         sv->netdev.dev = alloc_netdev(0, "hdlc%d", sv11_setup);
diff --git a/drivers/net/wan/n2.c b/drivers/net/wan/n2.c
index 5c322dfb79f6..cbdf0b748bde 100644
--- a/drivers/net/wan/n2.c
+++ b/drivers/net/wan/n2.c
@@ -351,12 +351,11 @@ static int __init n2_run(unsigned long io, unsigned long irq,
                 return -ENODEV;
         }
 
-        card = kmalloc(sizeof(card_t), GFP_KERNEL);
+        card = kzalloc(sizeof(card_t), GFP_KERNEL);
         if (card == NULL) {
                 printk(KERN_ERR "n2: unable to allocate memory\n");
                 return -ENOBUFS;
         }
-        memset(card, 0, sizeof(card_t));
 
         card->ports[0].dev = alloc_hdlcdev(&card->ports[0]);
         card->ports[1].dev = alloc_hdlcdev(&card->ports[1]);
diff --git a/drivers/net/wan/pc300_drv.c b/drivers/net/wan/pc300_drv.c
index 5d8c78ee2cd9..99fee2f1d019 100644
--- a/drivers/net/wan/pc300_drv.c
+++ b/drivers/net/wan/pc300_drv.c
@@ -3456,7 +3456,7 @@ cpc_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         if ((err = pci_enable_device(pdev)) < 0)
                 return err;
 
-        card = kmalloc(sizeof(pc300_t), GFP_KERNEL);
+        card = kzalloc(sizeof(pc300_t), GFP_KERNEL);
         if (card == NULL) {
                 printk("PC300 found at RAM 0x%016llx, "
                        "but could not allocate card structure.\n",
@@ -3464,7 +3464,6 @@ cpc_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                 err = -ENOMEM;
                 goto err_disable_dev;
         }
-        memset(card, 0, sizeof(pc300_t));
 
         err = -ENODEV;
 
diff --git a/drivers/net/wan/pc300too.c b/drivers/net/wan/pc300too.c
index dfbd3b00f03b..6353cb5c658d 100644
--- a/drivers/net/wan/pc300too.c
+++ b/drivers/net/wan/pc300too.c
@@ -334,14 +334,13 @@ static int __devinit pc300_pci_init_one(struct pci_dev *pdev,
                 return i;
         }
 
-        card = kmalloc(sizeof(card_t), GFP_KERNEL);
+        card = kzalloc(sizeof(card_t), GFP_KERNEL);
         if (card == NULL) {
                 printk(KERN_ERR "pc300: unable to allocate memory\n");
                 pci_release_regions(pdev);
                 pci_disable_device(pdev);
                 return -ENOBUFS;
         }
-        memset(card, 0, sizeof(card_t));
         pci_set_drvdata(pdev, card);
 
         if (pdev->device == PCI_DEVICE_ID_PC300_TE_1 ||
diff --git a/drivers/net/wan/pci200syn.c b/drivers/net/wan/pci200syn.c
index 7f720de2e9f0..092e51d89036 100644
--- a/drivers/net/wan/pci200syn.c
+++ b/drivers/net/wan/pci200syn.c
@@ -312,14 +312,13 @@ static int __devinit pci200_pci_init_one(struct pci_dev *pdev,
                 return i;
         }
 
-        card = kmalloc(sizeof(card_t), GFP_KERNEL);
+        card = kzalloc(sizeof(card_t), GFP_KERNEL);
         if (card == NULL) {
                 printk(KERN_ERR "pci200syn: unable to allocate memory\n");
                 pci_release_regions(pdev);
                 pci_disable_device(pdev);
                 return -ENOBUFS;
         }
-        memset(card, 0, sizeof(card_t));
         pci_set_drvdata(pdev, card);
         card->ports[0].dev = alloc_hdlcdev(&card->ports[0]);
         card->ports[1].dev = alloc_hdlcdev(&card->ports[1]);
diff --git a/drivers/net/wan/sdla.c b/drivers/net/wan/sdla.c
index 6a485f0556f4..792e588d7d61 100644
--- a/drivers/net/wan/sdla.c
+++ b/drivers/net/wan/sdla.c
@@ -1196,10 +1196,9 @@ static int sdla_xfer(struct net_device *dev, struct sdla_mem __user *info, int r
                 
         if (read)
         {       
-                temp = kmalloc(mem.len, GFP_KERNEL);
+                temp = kzalloc(mem.len, GFP_KERNEL);
                 if (!temp)
                         return(-ENOMEM);
-                memset(temp, 0, mem.len);
                 sdla_read(dev, mem.addr, temp, mem.len);
                 if(copy_to_user(mem.data, temp, mem.len))
                 {
diff --git a/drivers/net/wan/sealevel.c b/drivers/net/wan/sealevel.c
index 131358108c5a..11276bf3149f 100644
--- a/drivers/net/wan/sealevel.c
+++ b/drivers/net/wan/sealevel.c
@@ -270,11 +270,10 @@ static __init struct slvl_board *slvl_init(int iobase, int irq,
                 return NULL;
         }
         
-        b = kmalloc(sizeof(struct slvl_board), GFP_KERNEL);
+        b = kzalloc(sizeof(struct slvl_board), GFP_KERNEL);
         if(!b)
                 goto fail3;
 
-        memset(b, 0, sizeof(*b));
         if (!(b->dev[0]= slvl_alloc(iobase, irq)))
                 goto fail2;
 
diff --git a/drivers/net/wan/wanxl.c b/drivers/net/wan/wanxl.c
index c73601574334..3c78f9856380 100644
--- a/drivers/net/wan/wanxl.c
+++ b/drivers/net/wan/wanxl.c
@@ -599,7 +599,7 @@ static int __devinit wanxl_pci_init_one(struct pci_dev *pdev,
         }
 
         alloc_size = sizeof(card_t) + ports * sizeof(port_t);
-        card = kmalloc(alloc_size, GFP_KERNEL);
+        card = kzalloc(alloc_size, GFP_KERNEL);
         if (card == NULL) {
                 printk(KERN_ERR "wanXL %s: unable to allocate memory\n",
                        pci_name(pdev));
@@ -607,7 +607,6 @@ static int __devinit wanxl_pci_init_one(struct pci_dev *pdev,
                 pci_disable_device(pdev);
                 return -ENOBUFS;
         }
-        memset(card, 0, alloc_size);
 
         pci_set_drvdata(pdev, card);
         card->pdev = pdev;
diff --git a/drivers/net/wan/x25_asy.c b/drivers/net/wan/x25_asy.c
index 1c9edd97accd..c48b1cc63fd5 100644
--- a/drivers/net/wan/x25_asy.c
+++ b/drivers/net/wan/x25_asy.c
@@ -786,14 +786,12 @@ static int __init init_x25_asy(void)
         printk(KERN_INFO "X.25 async: version 0.00 ALPHA "
                         "(dynamic channels, max=%d).\n", x25_asy_maxdev );
 
-        x25_asy_devs = kmalloc(sizeof(struct net_device *)*x25_asy_maxdev, 
-                               GFP_KERNEL);
+        x25_asy_devs = kcalloc(x25_asy_maxdev, sizeof(struct net_device*), GFP_KERNEL);
         if (!x25_asy_devs) {
                 printk(KERN_WARNING "X25 async: Can't allocate x25_asy_ctrls[] "
                                 "array! Uaargh! (-> No X.25 available)\n");
                 return -ENOMEM;
         }
-        memset(x25_asy_devs, 0, sizeof(struct net_device *)*x25_asy_maxdev); 
 
         return tty_register_ldisc(N_X25, &x25_ldisc);
 }