ioc_init_handle = fusion->ioc_init_request_phys;
        IOCInitMessage = fusion->ioc_init_request;
 
-       cmd = megasas_get_cmd(instance);
-
-       if (!cmd) {
-               dev_err(&instance->pdev->dev, "Could not allocate cmd for INIT Frame\n");
-               ret = 1;
-               goto fail_get_cmd;
-       }
+       cmd = fusion->ioc_init_cmd;
 
        scratch_pad_2 = readl
                (&instance->reg_set->outbound_scratch_pad_2);
        ret = 0;
 
 fail_fw_init:
-       megasas_return_cmd(instance, cmd);
-fail_get_cmd:
        dev_err(&instance->pdev->dev,
                "Init cmd return status %s for SCSI host %d\n",
                ret ? "FAILED" : "SUCCESS", instance->host->host_no);
        return -ENOMEM;
 }
 
+static int megasas_alloc_ioc_init_frame(struct megasas_instance *instance)
+{
+       struct fusion_context *fusion;
+       struct megasas_cmd *cmd;
+
+       fusion = instance->ctrl_context;
+
+       cmd = kmalloc(sizeof(struct megasas_cmd), GFP_KERNEL);
+
+       if (!cmd) {
+               dev_err(&instance->pdev->dev, "Failed from func: %s line: %d\n",
+                       __func__, __LINE__);
+               return -ENOMEM;
+       }
+
+       cmd->frame = dma_alloc_coherent(&instance->pdev->dev,
+                                       IOC_INIT_FRAME_SIZE,
+                                       &cmd->frame_phys_addr, GFP_KERNEL);
+
+       if (!cmd->frame) {
+               dev_err(&instance->pdev->dev, "Failed from func: %s line: %d\n",
+                       __func__, __LINE__);
+               kfree(cmd);
+               return -ENOMEM;
+       }
+
+       fusion->ioc_init_cmd = cmd;
+       return 0;
+}
+
+/**
+ * megasas_free_ioc_init_cmd - Free IOC INIT command frame
+ * @instance:          Adapter soft state
+ */
+static inline void megasas_free_ioc_init_cmd(struct megasas_instance *instance)
+{
+       struct fusion_context *fusion;
+
+       fusion = instance->ctrl_context;
+
+       if (fusion->ioc_init_cmd && fusion->ioc_init_cmd->frame)
+               dma_free_coherent(&instance->pdev->dev,
+                                 IOC_INIT_FRAME_SIZE,
+                                 fusion->ioc_init_cmd->frame,
+                                 fusion->ioc_init_cmd->frame_phys_addr);
+
+       if (fusion->ioc_init_cmd)
+               kfree(fusion->ioc_init_cmd);
+}
+
 /**
  * megasas_init_adapter_fusion -       Initializes the FW
  * @instance:          Adapter soft state
                                MEGASAS_FUSION_IOCTL_CMDS);
        sema_init(&instance->ioctl_sem, MEGASAS_FUSION_IOCTL_CMDS);
 
+       if (megasas_alloc_ioc_init_frame(instance))
+               return 1;
+
        /*
         * Allocate memory for descriptors
         * Create a pool of commands
 fail_alloc_cmds:
        megasas_free_cmds(instance);
 fail_alloc_mfi_cmds:
+       megasas_free_ioc_init_cmd(instance);
        return 1;
 }
 
 void
 megasas_release_fusion(struct megasas_instance *instance)
 {
+       megasas_free_ioc_init_cmd(instance);
        megasas_free_cmds(instance);
        megasas_free_cmds_fusion(instance);