scsi: use pci_zalloc_consistent

Remove the now unnecessary memset too.

Signed-off-by: Joe Perches <joe@perches.com>
Cc: Adam Radford <linuxraid@lsi.com>
Cc: "James E.J. Bottomley" <JBottomley@parallels.com>
Cc: Jayamohan Kallickal <jayamohan.kallickal@emulex.com>
Cc: Dario Ballabio <ballabio_dario@emc.com>
Cc: Michael Neuffer <mike@i-Connect.Net>
Cc: "Stephen M. Cameron" <scameron@beardog.cce.hp.com>
Cc: Neela Syam Kolli <megaraidlinux@lsi.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/drivers/scsi/3w-sas.c b/drivers/scsi/3w-sas.c
index 4de346017e9ff91b43aed80d48231ac60f23a4e3..6da6cec9a65191882f141453c3ef18d73cb208f4 100644 (file)
--- a/drivers/scsi/3w-sas.c
+++ b/drivers/scsi/3w-sas.c
@@ -683,14 +683,13 @@ static int twl_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
        unsigned long *cpu_addr;
        int retval = 1;
 
-       cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle);
+       cpu_addr = pci_zalloc_consistent(tw_dev->tw_pci_dev, size * TW_Q_LENGTH,
+                                        &dma_handle);
        if (!cpu_addr) {
                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
                goto out;
        }
 
-       memset(cpu_addr, 0, size*TW_Q_LENGTH);
-
        for (i = 0; i < TW_Q_LENGTH; i++) {
                switch(which) {
                case 0:

diff --git a/drivers/scsi/a100u2w.c b/drivers/scsi/a100u2w.c
index 522570d297ca370e37e92279d734f9fd76701492..7e33a61c1ba45ed91db2b0fe86d4385eaac1e762 100644 (file)
--- a/drivers/scsi/a100u2w.c
+++ b/drivers/scsi/a100u2w.c
@@ -1125,23 +1125,19 @@ static int inia100_probe_one(struct pci_dev *pdev,
 
        /* Get total memory needed for SCB */
        sz = ORC_MAXQUEUE * sizeof(struct orc_scb);
-       host->scb_virt = pci_alloc_consistent(pdev, sz,
-                       &host->scb_phys);
+       host->scb_virt = pci_zalloc_consistent(pdev, sz, &host->scb_phys);
        if (!host->scb_virt) {
                printk("inia100: SCB memory allocation error\n");
                goto out_host_put;
        }
-       memset(host->scb_virt, 0, sz);
 
        /* Get total memory needed for ESCB */
        sz = ORC_MAXQUEUE * sizeof(struct orc_extended_scb);
-       host->escb_virt = pci_alloc_consistent(pdev, sz,
-                       &host->escb_phys);
+       host->escb_virt = pci_zalloc_consistent(pdev, sz, &host->escb_phys);
        if (!host->escb_virt) {
                printk("inia100: ESCB memory allocation error\n");
                goto out_free_scb_array;
        }
-       memset(host->escb_virt, 0, sz);
 
        biosaddr = host->BIOScfg;
        biosaddr = (biosaddr << 4);

diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
index 56467df3d6de668521fd2d578d52aa2578027a08..eb3e3e619155ea9929e2c140617d4b4ef2b888b9 100644 (file)
--- a/drivers/scsi/be2iscsi/be_main.c
+++ b/drivers/scsi/be2iscsi/be_main.c
@@ -3538,10 +3538,9 @@ static int be_queue_alloc(struct beiscsi_hba *phba, struct be_queue_info *q,
        q->len = len;
        q->entry_size = entry_size;
        mem->size = len * entry_size;
-       mem->va = pci_alloc_consistent(phba->pcidev, mem->size, &mem->dma);
+       mem->va = pci_zalloc_consistent(phba->pcidev, mem->size, &mem->dma);
        if (!mem->va)
                return -ENOMEM;
-       memset(mem->va, 0, mem->size);
        return 0;
 }
 
@@ -4320,9 +4319,9 @@ static int beiscsi_get_boot_info(struct beiscsi_hba *phba)
                            "BM_%d : No boot session\n");
                return ret;
        }
-       nonemb_cmd.va = pci_alloc_consistent(phba->ctrl.pdev,
-                               sizeof(*session_resp),
-                               &nonemb_cmd.dma);
+       nonemb_cmd.va = pci_zalloc_consistent(phba->ctrl.pdev,
+                                             sizeof(*session_resp),
+                                             &nonemb_cmd.dma);
        if (nonemb_cmd.va == NULL) {
                beiscsi_log(phba, KERN_ERR,
                            BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
@@ -4332,7 +4331,6 @@ static int beiscsi_get_boot_info(struct beiscsi_hba *phba)
                return -ENOMEM;
        }
 
-       memset(nonemb_cmd.va, 0, sizeof(*session_resp));
        tag = mgmt_get_session_info(phba, s_handle,
                                    &nonemb_cmd);
        if (!tag) {

diff --git a/drivers/scsi/be2iscsi/be_mgmt.c b/drivers/scsi/be2iscsi/be_mgmt.c
index a3e56487616c2b5ea37c25010fd6c9d58d12da19..665afcb74a56cdc1f9de12ea0bf21a973fc1cbc6 100644 (file)
--- a/drivers/scsi/be2iscsi/be_mgmt.c
+++ b/drivers/scsi/be2iscsi/be_mgmt.c
@@ -900,13 +900,12 @@ free_cmd:
 static int mgmt_alloc_cmd_data(struct beiscsi_hba *phba, struct be_dma_mem *cmd,
                               int iscsi_cmd, int size)
 {
-       cmd->va = pci_alloc_consistent(phba->ctrl.pdev, size, &cmd->dma);
+       cmd->va = pci_zalloc_consistent(phba->ctrl.pdev, size, &cmd->dma);
        if (!cmd->va) {
                beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
                            "BG_%d : Failed to allocate memory for if info\n");
                return -ENOMEM;
        }
-       memset(cmd->va, 0, size);
        cmd->size = size;
        be_cmd_hdr_prepare(cmd->va, CMD_SUBSYSTEM_ISCSI, iscsi_cmd, size);
        return 0;

diff --git a/drivers/scsi/csiostor/csio_wr.c b/drivers/scsi/csiostor/csio_wr.c
index 4255ce264abf9085040de66d5075b75e9125eb9c..773da14cfa145c703550e59a1f33c420544fedd4 100644 (file)
--- a/drivers/scsi/csiostor/csio_wr.c
+++ b/drivers/scsi/csiostor/csio_wr.c
@@ -232,7 +232,7 @@ csio_wr_alloc_q(struct csio_hw *hw, uint32_t qsize, uint32_t wrsize,
 
        q = wrm->q_arr[free_idx];
 
-       q->vstart = pci_alloc_consistent(hw->pdev, qsz, &q->pstart);
+       q->vstart = pci_zalloc_consistent(hw->pdev, qsz, &q->pstart);
        if (!q->vstart) {
                csio_err(hw,
                         "Failed to allocate DMA memory for "
@@ -240,12 +240,6 @@ csio_wr_alloc_q(struct csio_hw *hw, uint32_t qsize, uint32_t wrsize,
                return -1;
        }
 
-       /*
-        * We need to zero out the contents, importantly for ingress,
-        * since we start with a generatiom bit of 1 for ingress.
-        */
-       memset(q->vstart, 0, qsz);
-
        q->type         = type;
        q->owner        = owner;
        q->pidx         = q->cidx = q->inc_idx = 0;

diff --git a/drivers/scsi/eata.c b/drivers/scsi/eata.c
index 03372cff38f39b3caef6ff47b36cd04c5bf79c6c..813dd5c998e44ac6a3d8ba32280fc9bc57148c25 100644 (file)
--- a/drivers/scsi/eata.c
+++ b/drivers/scsi/eata.c
@@ -1238,8 +1238,8 @@ static int port_detect(unsigned long port_base, unsigned int j,
                struct eata_config *cf;
                dma_addr_t cf_dma_addr;
 
-               cf = pci_alloc_consistent(pdev, sizeof(struct eata_config),
-                                         &cf_dma_addr);
+               cf = pci_zalloc_consistent(pdev, sizeof(struct eata_config),
+                                          &cf_dma_addr);
 
                if (!cf) {
                        printk
@@ -1249,7 +1249,6 @@ static int port_detect(unsigned long port_base, unsigned int j,
                }
 
                /* Set board configuration */
-               memset((char *)cf, 0, sizeof(struct eata_config));
                cf->len = (ushort) H2DEV16((ushort) 510);
                cf->ocena = 1;
 

diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
index 8545d1826725bde1aee310f2f4c1469aa11e4c12..6b35d0dfe64c943a5a9caac8564fdfa8fc5c9a83 100644 (file)
--- a/drivers/scsi/hpsa.c
+++ b/drivers/scsi/hpsa.c
@@ -4732,23 +4732,21 @@ static struct CommandList *cmd_special_alloc(struct ctlr_info *h)
        union u64bit temp64;
        dma_addr_t cmd_dma_handle, err_dma_handle;
 
-       c = pci_alloc_consistent(h->pdev, sizeof(*c), &cmd_dma_handle);
+       c = pci_zalloc_consistent(h->pdev, sizeof(*c), &cmd_dma_handle);
        if (c == NULL)
                return NULL;
-       memset(c, 0, sizeof(*c));
 
        c->cmd_type = CMD_SCSI;
        c->cmdindex = -1;
 
-       c->err_info = pci_alloc_consistent(h->pdev, sizeof(*c->err_info),
-                   &err_dma_handle);
+       c->err_info = pci_zalloc_consistent(h->pdev, sizeof(*c->err_info),
+                                           &err_dma_handle);
 
        if (c->err_info == NULL) {
                pci_free_consistent(h->pdev,
                        sizeof(*c), c, cmd_dma_handle);
                return NULL;
        }
-       memset(c->err_info, 0, sizeof(*c->err_info));
 
        INIT_LIST_HEAD(&c->list);
        c->busaddr = (u32) cmd_dma_handle;

diff --git a/drivers/scsi/megaraid/megaraid_mbox.c b/drivers/scsi/megaraid/megaraid_mbox.c
index e2237a97cb9d314b485869cc37da7e3de8062531..531dce419c18103d3ad78b3a7fcc6329432cfe87 100644 (file)
--- a/drivers/scsi/megaraid/megaraid_mbox.c
+++ b/drivers/scsi/megaraid/megaraid_mbox.c
@@ -998,8 +998,9 @@ megaraid_alloc_cmd_packets(adapter_t *adapter)
         * Allocate the common 16-byte aligned memory for the handshake
         * mailbox.
         */
-       raid_dev->una_mbox64 = pci_alloc_consistent(adapter->pdev,
-                       sizeof(mbox64_t), &raid_dev->una_mbox64_dma);
+       raid_dev->una_mbox64 = pci_zalloc_consistent(adapter->pdev,
+                                                    sizeof(mbox64_t),
+                                                    &raid_dev->una_mbox64_dma);
 
        if (!raid_dev->una_mbox64) {
                con_log(CL_ANN, (KERN_WARNING
@@ -1007,7 +1008,6 @@ megaraid_alloc_cmd_packets(adapter_t *adapter)
                        __LINE__));
                return -1;
        }
-       memset(raid_dev->una_mbox64, 0, sizeof(mbox64_t));
 
        /*
         * Align the mailbox at 16-byte boundary
@@ -1026,8 +1026,8 @@ megaraid_alloc_cmd_packets(adapter_t *adapter)
                        align;
 
        // Allocate memory for commands issued internally
-       adapter->ibuf = pci_alloc_consistent(pdev, MBOX_IBUF_SIZE,
-                               &adapter->ibuf_dma_h);
+       adapter->ibuf = pci_zalloc_consistent(pdev, MBOX_IBUF_SIZE,
+                                             &adapter->ibuf_dma_h);
        if (!adapter->ibuf) {
 
                con_log(CL_ANN, (KERN_WARNING
@@ -1036,7 +1036,6 @@ megaraid_alloc_cmd_packets(adapter_t *adapter)
 
                goto out_free_common_mbox;
        }
-       memset(adapter->ibuf, 0, MBOX_IBUF_SIZE);
 
        // Allocate memory for our SCSI Command Blocks and their associated
        // memory
@@ -2972,8 +2971,8 @@ megaraid_mbox_product_info(adapter_t *adapter)
         * Issue an ENQUIRY3 command to find out certain adapter parameters,
         * e.g., max channels, max commands etc.
         */
-       pinfo = pci_alloc_consistent(adapter->pdev, sizeof(mraid_pinfo_t),
-                       &pinfo_dma_h);
+       pinfo = pci_zalloc_consistent(adapter->pdev, sizeof(mraid_pinfo_t),
+                                     &pinfo_dma_h);
 
        if (pinfo == NULL) {
                con_log(CL_ANN, (KERN_WARNING
@@ -2982,7 +2981,6 @@ megaraid_mbox_product_info(adapter_t *adapter)
 
                return -1;
        }
-       memset(pinfo, 0, sizeof(mraid_pinfo_t));
 
        mbox->xferaddr = (uint32_t)adapter->ibuf_dma_h;
        memset((void *)adapter->ibuf, 0, MBOX_IBUF_SIZE);

diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index 112799b131a93253d1b06170e2d7e1d5a1d998c2..22a04e37b70acfa63b3f3cb7e61ddb31ef9ec209 100644 (file)
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -2038,9 +2038,9 @@ int megasas_sriov_start_heartbeat(struct megasas_instance *instance,
 
        if (initial) {
                instance->hb_host_mem =
-                       pci_alloc_consistent(instance->pdev,
-                                            sizeof(struct MR_CTRL_HB_HOST_MEM),
-                                            &instance->hb_host_mem_h);
+                       pci_zalloc_consistent(instance->pdev,
+                                             sizeof(struct MR_CTRL_HB_HOST_MEM),
+                                             &instance->hb_host_mem_h);
                if (!instance->hb_host_mem) {
                        printk(KERN_DEBUG "megasas: SR-IOV: Couldn't allocate"
                               " memory for heartbeat host memory for "
@@ -2048,8 +2048,6 @@ int megasas_sriov_start_heartbeat(struct megasas_instance *instance,
                        retval = -ENOMEM;
                        goto out;
                }
-               memset(instance->hb_host_mem, 0,
-                      sizeof(struct MR_CTRL_HB_HOST_MEM));
        }
 
        memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);

diff --git a/drivers/scsi/mesh.c b/drivers/scsi/mesh.c
index 7a6160f172ce1b44b980784992ce599fd8c56658..57a95e2c3442c7d3fa52001a610fb51663412259 100644 (file)
--- a/drivers/scsi/mesh.c
+++ b/drivers/scsi/mesh.c
@@ -1915,14 +1915,12 @@ static int mesh_probe(struct macio_dev *mdev, const struct of_device_id *match)
        /* We use the PCI APIs for now until the generic one gets fixed
         * enough or until we get some macio-specific versions
         */
-       dma_cmd_space = pci_alloc_consistent(macio_get_pci_dev(mdev),
-                                            ms->dma_cmd_size,
-                                            &dma_cmd_bus);
+       dma_cmd_space = pci_zalloc_consistent(macio_get_pci_dev(mdev),
+                                             ms->dma_cmd_size, &dma_cmd_bus);
        if (dma_cmd_space == NULL) {
                printk(KERN_ERR "mesh: can't allocate DMA table\n");
                goto out_unmap;
        }
-       memset(dma_cmd_space, 0, ms->dma_cmd_size);
 
        ms->dma_cmds = (struct dbdma_cmd *) DBDMA_ALIGN(dma_cmd_space);
                ms->dma_cmd_space = dma_cmd_space;

diff --git a/drivers/scsi/mvumi.c b/drivers/scsi/mvumi.c
index edbee8dc62c9ab546b5340ca06cbef62ba4cecf3..3e716b2f611ae119d6510a661cab846598c4f7d5 100644 (file)
--- a/drivers/scsi/mvumi.c
+++ b/drivers/scsi/mvumi.c
@@ -142,8 +142,8 @@ static struct mvumi_res *mvumi_alloc_mem_resource(struct mvumi_hba *mhba,
 
        case RESOURCE_UNCACHED_MEMORY:
                size = round_up(size, 8);
-               res->virt_addr = pci_alloc_consistent(mhba->pdev, size,
-                                                       &res->bus_addr);
+               res->virt_addr = pci_zalloc_consistent(mhba->pdev, size,
+                                                      &res->bus_addr);
                if (!res->virt_addr) {
                        dev_err(&mhba->pdev->dev,
                                        "unable to allocate consistent mem,"
@@ -151,7 +151,6 @@ static struct mvumi_res *mvumi_alloc_mem_resource(struct mvumi_hba *mhba,
                        kfree(res);
                        return NULL;
                }
-               memset(res->virt_addr, 0, size);
                break;
 
        default:
@@ -258,12 +257,10 @@ static int mvumi_internal_cmd_sgl(struct mvumi_hba *mhba, struct mvumi_cmd *cmd,
        if (size == 0)
                return 0;
 
-       virt_addr = pci_alloc_consistent(mhba->pdev, size, &phy_addr);
+       virt_addr = pci_zalloc_consistent(mhba->pdev, size, &phy_addr);
        if (!virt_addr)
                return -1;
 
-       memset(virt_addr, 0, size);
-
        m_sg = (struct mvumi_sgl *) &cmd->frame->payload[0];
        cmd->frame->sg_counts = 1;
        cmd->data_buf = virt_addr;

diff --git a/drivers/scsi/pm8001/pm8001_sas.c b/drivers/scsi/pm8001/pm8001_sas.c
index 34cea82917722fbe9ad0a295f31d37638d7cf308..76570e6a547d26df5cfaffa715c9f49310085467 100644 (file)
--- a/drivers/scsi/pm8001/pm8001_sas.c
+++ b/drivers/scsi/pm8001/pm8001_sas.c
@@ -116,13 +116,12 @@ int pm8001_mem_alloc(struct pci_dev *pdev, void **virt_addr,
        u64 align_offset = 0;
        if (align)
                align_offset = (dma_addr_t)align - 1;
-       mem_virt_alloc =
-               pci_alloc_consistent(pdev, mem_size + align, &mem_dma_handle);
+       mem_virt_alloc = pci_zalloc_consistent(pdev, mem_size + align,
+                                              &mem_dma_handle);
        if (!mem_virt_alloc) {
                pm8001_printk("memory allocation error\n");
                return -1;
        }
-       memset((void *)mem_virt_alloc, 0, mem_size+align);
        *pphys_addr = mem_dma_handle;
        phys_align = (*pphys_addr + align_offset) & ~align_offset;
        *virt_addr = (void *)mem_virt_alloc + phys_align - *pphys_addr;