2 files changed, 278 insertions, 4 deletions

diff --git a/drivers/scsi/megaraid/megaraid_sas.c b/drivers/scsi/megaraid/megaraid_sas.c
index d9b8ca5116bc..409648f5845f 100644
--- a/drivers/scsi/megaraid/megaraid_sas.c
+++ b/drivers/scsi/megaraid/megaraid_sas.c
@@ -10,7 +10,7 @@
  *         2 of the License, or (at your option) any later version.
  *
  * FILE         : megaraid_sas.c
- * Version     : v00.00.04.12-rc1
+ * Version     : v00.00.04.17.1-rc1
  *
  * Authors:
  *      (email-id : megaraidlinux@lsi.com)
@@ -843,6 +843,7 @@ megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
         pthru->lun = scp->device->lun;
         pthru->cdb_len = scp->cmd_len;
         pthru->timeout = 0;
+        pthru->pad_0 = 0;
         pthru->flags = flags;
         pthru->data_xfer_len = scsi_bufflen(scp);
 
@@ -874,6 +875,12 @@ megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
                 pthru->sge_count = megasas_make_sgl32(instance, scp,
                                                       &pthru->sgl);
 
+        if (pthru->sge_count > instance->max_num_sge) {
+                printk(KERN_ERR "megasas: DCDB two many SGE NUM=%x\n",
+                        pthru->sge_count);
+                return 0;
+        }
+
         /*
          * Sense info specific
          */
@@ -1000,6 +1007,12 @@ megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
         } else
                 ldio->sge_count = megasas_make_sgl32(instance, scp, &ldio->sgl);
 
+        if (ldio->sge_count > instance->max_num_sge) {
+                printk(KERN_ERR "megasas: build_ld_io: sge_count = %x\n",
+                        ldio->sge_count);
+                return 0;
+        }
+
         /*
          * Sense info specific
          */
@@ -2250,6 +2263,7 @@ megasas_get_pd_list(struct megasas_instance *instance)
         dcmd->sge_count = 1;
         dcmd->flags = MFI_FRAME_DIR_READ;
         dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
         dcmd->data_xfer_len = MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST);
         dcmd->opcode = MR_DCMD_PD_LIST_QUERY;
         dcmd->sgl.sge32[0].phys_addr = ci_h;
@@ -2294,6 +2308,86 @@ megasas_get_pd_list(struct megasas_instance *instance)
         return ret;
 }
 
+/*
+ * megasas_get_ld_list_info -   Returns FW's ld_list structure
+ * @instance:                           Adapter soft state
+ * @ld_list:                            ld_list structure
+ *
+ * Issues an internal command (DCMD) to get the FW's controller PD
+ * list structure.  This information is mainly used to find out SYSTEM
+ * supported by the FW.
+ */
+static int
+megasas_get_ld_list(struct megasas_instance *instance)
+{
+        int ret = 0, ld_index = 0, ids = 0;
+        struct megasas_cmd *cmd;
+        struct megasas_dcmd_frame *dcmd;
+        struct MR_LD_LIST *ci;
+        dma_addr_t ci_h = 0;
+
+        cmd = megasas_get_cmd(instance);
+
+        if (!cmd) {
+                printk(KERN_DEBUG "megasas_get_ld_list: Failed to get cmd\n");
+                return -ENOMEM;
+        }
+
+        dcmd = &cmd->frame->dcmd;
+
+        ci = pci_alloc_consistent(instance->pdev,
+                                sizeof(struct MR_LD_LIST),
+                                &ci_h);
+
+        if (!ci) {
+                printk(KERN_DEBUG "Failed to alloc mem in get_ld_list\n");
+                megasas_return_cmd(instance, cmd);
+                return -ENOMEM;
+        }
+
+        memset(ci, 0, sizeof(*ci));
+        memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
+
+        dcmd->cmd = MFI_CMD_DCMD;
+        dcmd->cmd_status = 0xFF;
+        dcmd->sge_count = 1;
+        dcmd->flags = MFI_FRAME_DIR_READ;
+        dcmd->timeout = 0;
+        dcmd->data_xfer_len = sizeof(struct MR_LD_LIST);
+        dcmd->opcode = MR_DCMD_LD_GET_LIST;
+        dcmd->sgl.sge32[0].phys_addr = ci_h;
+        dcmd->sgl.sge32[0].length = sizeof(struct MR_LD_LIST);
+        dcmd->pad_0  = 0;
+
+        if (!megasas_issue_polled(instance, cmd)) {
+                ret = 0;
+        } else {
+                ret = -1;
+        }
+
+        /* the following function will get the instance PD LIST */
+
+        if ((ret == 0) && (ci->ldCount < MAX_LOGICAL_DRIVES)) {
+                memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
+
+                for (ld_index = 0; ld_index < ci->ldCount; ld_index++) {
+                        if (ci->ldList[ld_index].state != 0) {
+                                ids = ci->ldList[ld_index].ref.targetId;
+                                instance->ld_ids[ids] =
+                                        ci->ldList[ld_index].ref.targetId;
+                        }
+                }
+        }
+
+        pci_free_consistent(instance->pdev,
+                                sizeof(struct MR_LD_LIST),
+                                ci,
+                                ci_h);
+
+        megasas_return_cmd(instance, cmd);
+        return ret;
+}
+
 /**
  * megasas_get_controller_info -        Returns FW's controller structure
  * @instance:                           Adapter soft state
@@ -2339,6 +2433,7 @@ megasas_get_ctrl_info(struct megasas_instance *instance,
         dcmd->sge_count = 1;
         dcmd->flags = MFI_FRAME_DIR_READ;
         dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
         dcmd->data_xfer_len = sizeof(struct megasas_ctrl_info);
         dcmd->opcode = MR_DCMD_CTRL_GET_INFO;
         dcmd->sgl.sge32[0].phys_addr = ci_h;
@@ -2590,6 +2685,9 @@ static int megasas_init_mfi(struct megasas_instance *instance)
                 (MEGASAS_MAX_PD * sizeof(struct megasas_pd_list)));
         megasas_get_pd_list(instance);
 
+        memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
+        megasas_get_ld_list(instance);
+
         ctrl_info = kmalloc(sizeof(struct megasas_ctrl_info), GFP_KERNEL);
 
         /*
@@ -2714,6 +2812,7 @@ megasas_get_seq_num(struct megasas_instance *instance,
         dcmd->sge_count = 1;
         dcmd->flags = MFI_FRAME_DIR_READ;
         dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
         dcmd->data_xfer_len = sizeof(struct megasas_evt_log_info);
         dcmd->opcode = MR_DCMD_CTRL_EVENT_GET_INFO;
         dcmd->sgl.sge32[0].phys_addr = el_info_h;
@@ -2828,6 +2927,7 @@ megasas_register_aen(struct megasas_instance *instance, u32 seq_num,
         dcmd->sge_count = 1;
         dcmd->flags = MFI_FRAME_DIR_READ;
         dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
         dcmd->data_xfer_len = sizeof(struct megasas_evt_detail);
         dcmd->opcode = MR_DCMD_CTRL_EVENT_WAIT;
         dcmd->mbox.w[0] = seq_num;
@@ -3166,6 +3266,7 @@ static void megasas_flush_cache(struct megasas_instance *instance)
         dcmd->sge_count = 0;
         dcmd->flags = MFI_FRAME_DIR_NONE;
         dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
         dcmd->data_xfer_len = 0;
         dcmd->opcode = MR_DCMD_CTRL_CACHE_FLUSH;
         dcmd->mbox.b[0] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE;
@@ -3205,6 +3306,7 @@ static void megasas_shutdown_controller(struct megasas_instance *instance,
         dcmd->sge_count = 0;
         dcmd->flags = MFI_FRAME_DIR_NONE;
         dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
         dcmd->data_xfer_len = 0;
         dcmd->opcode = opcode;
 
@@ -3984,6 +4086,7 @@ megasas_aen_polling(struct work_struct *work)
         struct  Scsi_Host *host;
         struct  scsi_device *sdev1;
         u16     pd_index = 0;
+        u16     ld_index = 0;
         int     i, j, doscan = 0;
         u32 seq_num;
         int error;
@@ -3999,8 +4102,124 @@ megasas_aen_polling(struct work_struct *work)
 
                 switch (instance->evt_detail->code) {
                 case MR_EVT_PD_INSERTED:
+                        if (megasas_get_pd_list(instance) == 0) {
+                        for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
+                                for (j = 0;
+                                j < MEGASAS_MAX_DEV_PER_CHANNEL;
+                                j++) {
+
+                                pd_index =
+                                (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
+
+                                sdev1 =
+                                scsi_device_lookup(host, i, j, 0);
+
+                                if (instance->pd_list[pd_index].driveState
+                                                == MR_PD_STATE_SYSTEM) {
+                                                if (!sdev1) {
+                                                scsi_add_device(host, i, j, 0);
+                                                }
+
+                                        if (sdev1)
+                                                scsi_device_put(sdev1);
+                                        }
+                                }
+                        }
+                        }
+                        doscan = 0;
+                        break;
+
                 case MR_EVT_PD_REMOVED:
+                        if (megasas_get_pd_list(instance) == 0) {
+                        megasas_get_pd_list(instance);
+                        for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
+                                for (j = 0;
+                                j < MEGASAS_MAX_DEV_PER_CHANNEL;
+                                j++) {
+
+                                pd_index =
+                                (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
+
+                                sdev1 =
+                                scsi_device_lookup(host, i, j, 0);
+
+                                if (instance->pd_list[pd_index].driveState
+                                        == MR_PD_STATE_SYSTEM) {
+                                        if (sdev1) {
+                                                scsi_device_put(sdev1);
+                                        }
+                                } else {
+                                        if (sdev1) {
+                                                scsi_remove_device(sdev1);
+                                                scsi_device_put(sdev1);
+                                        }
+                                }
+                                }
+                        }
+                        }
+                        doscan = 0;
+                        break;
+
+                case MR_EVT_LD_OFFLINE:
+                case MR_EVT_LD_DELETED:
+                        megasas_get_ld_list(instance);
+                        for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
+                                for (j = 0;
+                                j < MEGASAS_MAX_DEV_PER_CHANNEL;
+                                j++) {
+
+                                ld_index =
+                                (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
+
+                                sdev1 = scsi_device_lookup(host,
+                                        i + MEGASAS_MAX_LD_CHANNELS,
+                                        j,
+                                        0);
+
+                                if (instance->ld_ids[ld_index] != 0xff) {
+                                        if (sdev1) {
+                                                scsi_device_put(sdev1);
+                                        }
+                                } else {
+                                        if (sdev1) {
+                                                scsi_remove_device(sdev1);
+                                                scsi_device_put(sdev1);
+                                        }
+                                }
+                                }
+                        }
+                        doscan = 0;
+                        break;
+                case MR_EVT_LD_CREATED:
+                        megasas_get_ld_list(instance);
+                        for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
+                                for (j = 0;
+                                        j < MEGASAS_MAX_DEV_PER_CHANNEL;
+                                        j++) {
+                                        ld_index =
+                                        (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
+
+                                        sdev1 = scsi_device_lookup(host,
+                                                i+MEGASAS_MAX_LD_CHANNELS,
+                                                j, 0);
+
+                                        if (instance->ld_ids[ld_index] !=
+                                                                0xff) {
+                                                if (!sdev1) {
+                                                        scsi_add_device(host,
+                                                                i + 2,
+                                                                j, 0);
+                                                }
+                                        }
+                                        if (sdev1) {
+                                                scsi_device_put(sdev1);
+                                        }
+                                }
+                        }
+                        doscan = 0;
+                        break;
                 case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED:
+                case MR_EVT_FOREIGN_CFG_IMPORTED:
                         doscan = 1;
                         break;
                 default:
@@ -4035,6 +4254,31 @@ megasas_aen_polling(struct work_struct *work)
                                 }
                         }
                 }
+
+                megasas_get_ld_list(instance);
+                for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
+                        for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) {
+                                ld_index =
+                                (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
+
+                                sdev1 = scsi_device_lookup(host,
+                                        i+MEGASAS_MAX_LD_CHANNELS, j, 0);
+                                if (instance->ld_ids[ld_index] != 0xff) {
+                                        if (!sdev1) {
+                                                scsi_add_device(host,
+                                                                i+2,
+                                                                j, 0);
+                                        } else {
+                                                scsi_device_put(sdev1);
+                                        }
+                                } else {
+                                        if (sdev1) {
+                                                scsi_remove_device(sdev1);
+                                                scsi_device_put(sdev1);
+                                        }
+                                }
+                        }
+                }
         }
 
         if ( instance->aen_cmd != NULL ) {
diff --git a/drivers/scsi/megaraid/megaraid_sas.h b/drivers/scsi/megaraid/megaraid_sas.h
index 72b28e436e32..9d8b6bf605aa 100644
--- a/drivers/scsi/megaraid/megaraid_sas.h
+++ b/drivers/scsi/megaraid/megaraid_sas.h
@@ -18,9 +18,9 @@
 /*
  * MegaRAID SAS Driver meta data
  */
-#define MEGASAS_VERSION                         "00.00.04.12-rc1"
-#define MEGASAS_RELDATE                         "Sep. 17, 2009"
-#define MEGASAS_EXT_VERSION                     "Thu Sep. 17 11:41:51 PST 2009"
+#define MEGASAS_VERSION                 "00.00.04.17.1-rc1"
+#define MEGASAS_RELDATE                 "Oct. 29, 2009"
+#define MEGASAS_EXT_VERSION             "Thu. Oct. 29, 11:41:51 PST 2009"
 
 /*
  * Device IDs
@@ -117,6 +117,7 @@
 #define MFI_CMD_STP                             0x08
 
 #define MR_DCMD_CTRL_GET_INFO                   0x01010000
+#define MR_DCMD_LD_GET_LIST                     0x03010000
 
 #define MR_DCMD_CTRL_CACHE_FLUSH                0x01101000
 #define MR_FLUSH_CTRL_CACHE                     0x01
@@ -349,6 +350,32 @@ struct megasas_pd_list {
         u8             driveState;
 } __packed;
 
+ /*
+ * defines the logical drive reference structure
+ */
+union  MR_LD_REF {
+        struct {
+                u8      targetId;
+                u8      reserved;
+                u16     seqNum;
+        };
+        u32     ref;
+} __packed;
+
+/*
+ * defines the logical drive list structure
+ */
+struct MR_LD_LIST {
+        u32     ldCount;
+        u32     reserved;
+        struct {
+                union MR_LD_REF   ref;
+                u8          state;
+                u8          reserved[3];
+                u64         size;
+        } ldList[MAX_LOGICAL_DRIVES];
+} __packed;
+
 /*
  * SAS controller properties
  */
@@ -637,6 +664,8 @@ struct megasas_ctrl_info {
 #define MEGASAS_MAX_LD                          64
 #define MEGASAS_MAX_PD                          (MEGASAS_MAX_PD_CHANNELS * \
                                                 MEGASAS_MAX_DEV_PER_CHANNEL)
+#define MEGASAS_MAX_LD_IDS                      (MEGASAS_MAX_LD_CHANNELS * \
+                                                MEGASAS_MAX_DEV_PER_CHANNEL)
 
 #define MEGASAS_DBG_LVL                         1
 
@@ -1187,6 +1216,7 @@ struct megasas_instance {
         struct megasas_register_set __iomem *reg_set;
 
         struct megasas_pd_list          pd_list[MEGASAS_MAX_PD];
+        u8     ld_ids[MEGASAS_MAX_LD_IDS];
         s8 init_id;
 
         u16 max_num_sge;