s2io.c: Use calculated size in kmallocs

Use consistent style.  Don't calculate the kmalloc size multiple times

Signed-off-by: Joe Perches <joe@perches.com>
Acked-by: Sreenivasa Honnur <sreenivasa.honnur@neterion.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 28 insertions, 35 deletions

diff --git a/drivers/net/s2io.c b/drivers/net/s2io.c
index b6bd3c812adb..75f2209bc013 100644
--- a/drivers/net/s2io.c
+++ b/drivers/net/s2io.c
@@ -823,15 +823,15 @@ static int init_shared_mem(struct s2io_nic *nic)
                         }
                         mem_allocated += size;
                         memset(tmp_v_addr, 0, size);
+
+                        size = sizeof(struct rxd_info) *
+                                rxd_count[nic->rxd_mode];
                         rx_blocks->block_virt_addr = tmp_v_addr;
                         rx_blocks->block_dma_addr = tmp_p_addr;
-                        rx_blocks->rxds = kmalloc(sizeof(struct rxd_info)*
-                                                  rxd_count[nic->rxd_mode],
-                                                  GFP_KERNEL);
+                        rx_blocks->rxds = kmalloc(size,  GFP_KERNEL);
                         if (!rx_blocks->rxds)
                                 return -ENOMEM;
-                        mem_allocated +=
-                        (sizeof(struct rxd_info)* rxd_count[nic->rxd_mode]);
+                        mem_allocated += size;
                         for (l=0; l<rxd_count[nic->rxd_mode];l++) {
                                 rx_blocks->rxds[l].virt_addr =
                                         rx_blocks->block_virt_addr +
@@ -867,41 +867,37 @@ static int init_shared_mem(struct s2io_nic *nic)
 
                         blk_cnt = rx_cfg->num_rxd /
                                 (rxd_count[nic->rxd_mode]+ 1);
-                        ring->ba = kmalloc((sizeof(struct buffAdd *) * blk_cnt),
-                                           GFP_KERNEL);
+                        size = sizeof(struct buffAdd *) * blk_cnt;
+                        ring->ba = kmalloc(size, GFP_KERNEL);
                         if (!ring->ba)
                                 return -ENOMEM;
-                        mem_allocated +=(sizeof(struct buffAdd *) * blk_cnt);
+                        mem_allocated += size;
                         for (j = 0; j < blk_cnt; j++) {
                                 int k = 0;
-                                ring->ba[j] =
-                                        kmalloc((sizeof(struct buffAdd) *
-                                                (rxd_count[nic->rxd_mode] + 1)),
-                                                GFP_KERNEL);
+
+                                size = sizeof(struct buffAdd) *
+                                        (rxd_count[nic->rxd_mode] + 1);
+                                ring->ba[j] = kmalloc(size, GFP_KERNEL);
                                 if (!ring->ba[j])
                                         return -ENOMEM;
-                                mem_allocated += (sizeof(struct buffAdd) *  \
-                                        (rxd_count[nic->rxd_mode] + 1));
+                                mem_allocated += size;
                                 while (k != rxd_count[nic->rxd_mode]) {
                                         ba = &ring->ba[j][k];
-
-                                        ba->ba_0_org = (void *) kmalloc
-                                            (BUF0_LEN + ALIGN_SIZE, GFP_KERNEL);
+                                        size = BUF0_LEN + ALIGN_SIZE;
+                                        ba->ba_0_org = kmalloc(size, GFP_KERNEL);
                                         if (!ba->ba_0_org)
                                                 return -ENOMEM;
-                                        mem_allocated +=
-                                                (BUF0_LEN + ALIGN_SIZE);
+                                        mem_allocated += size;
                                         tmp = (unsigned long)ba->ba_0_org;
                                         tmp += ALIGN_SIZE;
                                         tmp &= ~((unsigned long) ALIGN_SIZE);
                                         ba->ba_0 = (void *) tmp;
 
-                                        ba->ba_1_org = (void *) kmalloc
-                                            (BUF1_LEN + ALIGN_SIZE, GFP_KERNEL);
+                                        size = BUF1_LEN + ALIGN_SIZE;
+                                        ba->ba_1_org = kmalloc(size, GFP_KERNEL);
                                         if (!ba->ba_1_org)
                                                 return -ENOMEM;
-                                        mem_allocated
-                                                += (BUF1_LEN + ALIGN_SIZE);
+                                        mem_allocated += size;
                                         tmp = (unsigned long) ba->ba_1_org;
                                         tmp += ALIGN_SIZE;
                                         tmp &= ~((unsigned long) ALIGN_SIZE);
@@ -3835,23 +3831,22 @@ static int s2io_enable_msi_x(struct s2io_nic *nic)
         u64 rx_mat;
         u16 msi_control; /* Temp variable */
         int ret, i, j, msix_indx = 1;
+        int size;
 
-        nic->entries = kmalloc(nic->num_entries * sizeof(struct msix_entry),
-                               GFP_KERNEL);
+        size = nic->num_entries * sizeof(struct msix_entry);
+        nic->entries = kmalloc(size, GFP_KERNEL);
         if (!nic->entries) {
                 DBG_PRINT(INFO_DBG, "%s: Memory allocation failed\n", \
                         __func__);
                 nic->mac_control.stats_info->sw_stat.mem_alloc_fail_cnt++;
                 return -ENOMEM;
         }
-        nic->mac_control.stats_info->sw_stat.mem_allocated
-                += (nic->num_entries * sizeof(struct msix_entry));
+        nic->mac_control.stats_info->sw_stat.mem_allocated += size;
 
-        memset(nic->entries, 0, nic->num_entries * sizeof(struct msix_entry));
+        memset(nic->entries, 0, size);
 
-        nic->s2io_entries =
-                kmalloc(nic->num_entries * sizeof(struct s2io_msix_entry),
-                                   GFP_KERNEL);
+        size = nic->num_entries * sizeof(struct s2io_msix_entry);
+        nic->s2io_entries = kmalloc(size, GFP_KERNEL);
         if (!nic->s2io_entries) {
                 DBG_PRINT(INFO_DBG, "%s: Memory allocation failed\n",
                         __func__);
@@ -3861,10 +3856,8 @@ static int s2io_enable_msi_x(struct s2io_nic *nic)
                         += (nic->num_entries * sizeof(struct msix_entry));
                 return -ENOMEM;
         }
-         nic->mac_control.stats_info->sw_stat.mem_allocated
-                += (nic->num_entries * sizeof(struct s2io_msix_entry));
-        memset(nic->s2io_entries, 0,
-                nic->num_entries * sizeof(struct s2io_msix_entry));
+        nic->mac_control.stats_info->sw_stat.mem_allocated += size;
+        memset(nic->s2io_entries, 0, size);
 
         nic->entries[0].entry = 0;
         nic->s2io_entries[0].entry = 0;