2 files changed, 12 insertions, 35 deletions

diff --git a/drivers/net/vxge/vxge-config.c b/drivers/net/vxge/vxge-config.c
index 409c2e6053d0..a0241fe72d8b 100644
--- a/drivers/net/vxge/vxge-config.c
+++ b/drivers/net/vxge/vxge-config.c
@@ -1219,14 +1219,12 @@ vxge_hw_device_initialize(
         if (status != VXGE_HW_OK)
                 goto exit;
 
-        hldev = (struct __vxge_hw_device *)
-                        vmalloc(sizeof(struct __vxge_hw_device));
+        hldev = vzalloc(sizeof(struct __vxge_hw_device));
         if (hldev == NULL) {
                 status = VXGE_HW_ERR_OUT_OF_MEMORY;
                 goto exit;
         }
 
-        memset(hldev, 0, sizeof(struct __vxge_hw_device));
         hldev->magic = VXGE_HW_DEVICE_MAGIC;
 
         vxge_hw_device_debug_set(hldev, VXGE_ERR, VXGE_COMPONENT_ALL);
@@ -2064,15 +2062,12 @@ __vxge_hw_mempool_grow(struct vxge_hw_mempool *mempool, u32 num_allocate,
                  * allocate new memblock and its private part at once.
                  * This helps to minimize memory usage a lot. */
                 mempool->memblocks_priv_arr[i] =
-                                vmalloc(mempool->items_priv_size * n_items);
+                                vzalloc(mempool->items_priv_size * n_items);
                 if (mempool->memblocks_priv_arr[i] == NULL) {
                         status = VXGE_HW_ERR_OUT_OF_MEMORY;
                         goto exit;
                 }
 
-                memset(mempool->memblocks_priv_arr[i], 0,
-                             mempool->items_priv_size * n_items);
-
                 /* allocate DMA-capable memblock */
                 mempool->memblocks_arr[i] =
                         __vxge_hw_blockpool_malloc(mempool->devh,
@@ -2144,13 +2139,11 @@ __vxge_hw_mempool_create(
                 goto exit;
         }
 
-        mempool = (struct vxge_hw_mempool *)
-                        vmalloc(sizeof(struct vxge_hw_mempool));
+        mempool = vzalloc(sizeof(struct vxge_hw_mempool));
         if (mempool == NULL) {
                 status = VXGE_HW_ERR_OUT_OF_MEMORY;
                 goto exit;
         }
-        memset(mempool, 0, sizeof(struct vxge_hw_mempool));
 
         mempool->devh                   = devh;
         mempool->memblock_size          = memblock_size;
@@ -2170,31 +2163,27 @@ __vxge_hw_mempool_create(
 
         /* allocate array of memblocks */
         mempool->memblocks_arr =
-                (void **) vmalloc(sizeof(void *) * mempool->memblocks_max);
+                vzalloc(sizeof(void *) * mempool->memblocks_max);
         if (mempool->memblocks_arr == NULL) {
                 __vxge_hw_mempool_destroy(mempool);
                 status = VXGE_HW_ERR_OUT_OF_MEMORY;
                 mempool = NULL;
                 goto exit;
         }
-        memset(mempool->memblocks_arr, 0,
-                sizeof(void *) * mempool->memblocks_max);
 
         /* allocate array of private parts of items per memblocks */
         mempool->memblocks_priv_arr =
-                (void **) vmalloc(sizeof(void *) * mempool->memblocks_max);
+                vzalloc(sizeof(void *) * mempool->memblocks_max);
         if (mempool->memblocks_priv_arr == NULL) {
                 __vxge_hw_mempool_destroy(mempool);
                 status = VXGE_HW_ERR_OUT_OF_MEMORY;
                 mempool = NULL;
                 goto exit;
         }
-        memset(mempool->memblocks_priv_arr, 0,
-                    sizeof(void *) * mempool->memblocks_max);
 
         /* allocate array of memblocks DMA objects */
-        mempool->memblocks_dma_arr = (struct vxge_hw_mempool_dma *)
-                vmalloc(sizeof(struct vxge_hw_mempool_dma) *
+        mempool->memblocks_dma_arr =
+                vzalloc(sizeof(struct vxge_hw_mempool_dma) *
                         mempool->memblocks_max);
 
         if (mempool->memblocks_dma_arr == NULL) {
@@ -2203,20 +2192,15 @@ __vxge_hw_mempool_create(
                 mempool = NULL;
                 goto exit;
         }
-        memset(mempool->memblocks_dma_arr, 0,
-                        sizeof(struct vxge_hw_mempool_dma) *
-                        mempool->memblocks_max);
 
         /* allocate hash array of items */
-        mempool->items_arr =
-                (void **) vmalloc(sizeof(void *) * mempool->items_max);
+        mempool->items_arr = vzalloc(sizeof(void *) * mempool->items_max);
         if (mempool->items_arr == NULL) {
                 __vxge_hw_mempool_destroy(mempool);
                 status = VXGE_HW_ERR_OUT_OF_MEMORY;
                 mempool = NULL;
                 goto exit;
         }
-        memset(mempool->items_arr, 0, sizeof(void *) * mempool->items_max);
 
         /* calculate initial number of memblocks */
         memblocks_to_allocate = (mempool->items_initial +
@@ -4271,15 +4255,12 @@ vxge_hw_vpath_open(struct __vxge_hw_device *hldev,
         if (status != VXGE_HW_OK)
                 goto vpath_open_exit1;
 
-        vp = (struct __vxge_hw_vpath_handle *)
-                vmalloc(sizeof(struct __vxge_hw_vpath_handle));
+        vp = vzalloc(sizeof(struct __vxge_hw_vpath_handle));
         if (vp == NULL) {
                 status = VXGE_HW_ERR_OUT_OF_MEMORY;
                 goto vpath_open_exit2;
         }
 
-        memset(vp, 0, sizeof(struct __vxge_hw_vpath_handle));
-
         vp->vpath = vpath;
 
         if (vpath->vp_config->fifo.enable == VXGE_HW_FIFO_ENABLE) {
@@ -5080,8 +5061,7 @@ static void vxge_hw_blockpool_block_add(struct __vxge_hw_device *devh,
                                 item);
 
         if (entry == NULL)
-                entry = (struct __vxge_hw_blockpool_entry *)
-                        vmalloc(sizeof(struct __vxge_hw_blockpool_entry));
+                entry = vmalloc(sizeof(struct __vxge_hw_blockpool_entry));
         else
                 list_del(&entry->item);
 
@@ -5197,8 +5177,7 @@ __vxge_hw_blockpool_free(struct __vxge_hw_device *devh,
                                         item);
 
                 if (entry == NULL)
-                        entry = (struct __vxge_hw_blockpool_entry *)
-                                vmalloc(sizeof(
+                        entry = vmalloc(sizeof(
                                         struct __vxge_hw_blockpool_entry));
                 else
                         list_del(&entry->item);
diff --git a/drivers/net/vxge/vxge-main.c b/drivers/net/vxge/vxge-main.c
index 5cba4a684f08..a21dae1183e0 100644
--- a/drivers/net/vxge/vxge-main.c
+++ b/drivers/net/vxge/vxge-main.c
@@ -4602,9 +4602,7 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre)
 
         /* Copy the station mac address to the list */
         for (i = 0; i < vdev->no_of_vpath; i++) {
-                entry = (struct vxge_mac_addrs *)
-                                kzalloc(sizeof(struct vxge_mac_addrs),
-                                        GFP_KERNEL);
+                entry = kzalloc(sizeof(struct vxge_mac_addrs), GFP_KERNEL);
                 if (NULL == entry) {
                         vxge_debug_init(VXGE_ERR,
                                 "%s: mac_addr_list : memory allocation failed",