sles9-sp2.patch

最新的Megaraid SAS卡驱动源代码

+		sdev->timeout = 90 * HZ ;
+	return 0;
+}
+
 static struct megasas_instance *megasas_lookup_instance(u16 host_no)
 {
 	int i;
@@ -1255,14 +1232,13 @@ static struct scsi_host_template megasas
 	.module = THIS_MODULE,
 	.name = "LSI Logic SAS based MegaRAID driver",
 	.proc_name = "megaraid_sas",
-	.slave_configure = megasas_slave_configure,
 	.slave_alloc = megasas_slave_alloc,
+	.slave_configure = megasas_slave_configure,
 	.queuecommand = megasas_queue_command,
 	.eh_device_reset_handler = megasas_reset_device,
 	.eh_bus_reset_handler = megasas_reset_bus_host,
 	.eh_host_reset_handler = megasas_reset_bus_host,
-	.eh_timed_out = megasas_reset_timer,
-	.bios_param = megasas_bios_param,
+	.bios_param	 	= megasas_bios_param,	
 	.use_clustering = ENABLE_CLUSTERING,
 };
 
@@ -1314,7 +1290,7 @@ megasas_complete_abort(struct megasas_in
  * @instance:			Adapter soft state
  * @cmd:			Completed command
  */
-static void
+static inline void
 megasas_unmap_sgbuf(struct megasas_instance *instance, struct megasas_cmd *cmd)
 {
 	dma_addr_t buf_h;
@@ -1358,16 +1334,16 @@ megasas_unmap_sgbuf(struct megasas_insta
  * 				an alternate status (as in the case of aborted
  * 				commands)
  */
-static void
+static inline void
 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
 		     u8 alt_status)
 {
 	int exception = 0;
 	struct megasas_header *hdr = &cmd->frame->hdr;
 	unsigned long flags;
-
+	int outstanding;
 	if (cmd->scmd)
-		cmd->scmd->SCp.ptr = NULL;
+		cmd->scmd->SCp.ptr = (char *)0;
 
 	switch (hdr->cmd) {
 
@@ -1384,6 +1360,19 @@ megasas_complete_cmd(struct megasas_inst
 			megasas_complete_int_cmd(instance, cmd);
 			break;
 		}
+		/*
+		 * Don't export physical disk devices to mid-layer.
+		 */
+		if (!MEGASAS_IS_LOGICAL(cmd->scmd) &&
+		    (hdr->cmd_status == MFI_STAT_OK) &&
+		    (cmd->scmd->cmnd[0] == INQUIRY)) {
+
+			if (((*(u8 *) cmd->scmd->request_buffer) & 0x1F) ==
+			    TYPE_DISK) {
+				cmd->scmd->result = DID_BAD_TARGET << 16;
+				exception = 1;
+			}
+		}
 
 	case MFI_CMD_LD_READ:
 	case MFI_CMD_LD_WRITE:
@@ -1477,22 +1466,11 @@ megasas_complete_cmd(struct megasas_inst
 		       hdr->cmd);
 		break;
 	}
-	
-	/*
-	 * Check if we can restore can_queue
-	 */
-	if (instance->flag & MEGASAS_FW_BUSY
-		&& time_after(jiffies, instance->last_time + 5 * HZ)
-		&& atomic_read(&instance->fw_outstanding) < 17) {
-
-		spin_lock_irqsave(instance->host->host_lock, flags);
-		instance->flag &= ~MEGASAS_FW_BUSY;
-		instance->host->can_queue =
-				instance->max_fw_cmds - MEGASAS_INT_CMDS;
-
-		spin_unlock_irqrestore(instance->host->host_lock, flags);
+	if(instance->is_busy){
+		outstanding = atomic_read(&instance->fw_outstanding);
+		if(outstanding<17)
+			instance->is_busy=0;
 	}
-	
 }
 
 /**
@@ -1502,21 +1480,22 @@ megasas_complete_cmd(struct megasas_inst
  * 					SCSI mid-layer instead of the status
  * 					returned by the FW
  */
-static int
+static inline int
 megasas_deplete_reply_queue(struct megasas_instance *instance, u8 alt_status)
 {
+
 	/*
 	 * Check if it is our interrupt
 	 * Clear the interrupt 
 	 */
 	if(instance->instancet->clear_intr(instance->reg_set))
 		return IRQ_NONE;
-
-	if (instance->hw_crit_error)
+	if(instance->hw_crit_error)
 		goto out_done;
-        /*
-	 * Schedule the tasklet for cmd completion
-	 */
+
+        /* 
+	* Schedule the tasklet for cmd completion 
+	*/
 	tasklet_schedule(&instance->isr_tasklet);
 out_done:
 	return IRQ_HANDLED;
@@ -1525,7 +1504,7 @@ out_done:
 /**
  * megasas_isr - isr entry point
  */
-static irqreturn_t megasas_isr(int irq, void *devp)
+static irqreturn_t megasas_isr(int irq, void *devp, struct pt_regs *regs)
 {
 	return megasas_deplete_reply_queue((struct megasas_instance *)devp,
 					   DID_OK);
@@ -1550,7 +1529,7 @@ megasas_transition_to_ready(struct megas
 
 	fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) & MFI_STATE_MASK;
 
-	if (fw_state != MFI_STATE_READY)
+	if (fw_state != MFI_STATE_READY) 
  		printk(KERN_INFO "megasas: Waiting for FW to come to ready"
  		       " state\n");
 
@@ -1574,7 +1553,7 @@ megasas_transition_to_ready(struct megas
 			cur_state = MFI_STATE_WAIT_HANDSHAKE;
 			break;
 
-		case MFI_STATE_BOOT_MESSAGE_PENDING:
+		case MFI_STATE_BOOT_MESSAGE_PENDING:	
 			writel(MFI_INIT_HOTPLUG,
 				&instance->reg_set->inbound_doorbell);
 
@@ -1960,81 +1939,6 @@ megasas_get_ctrl_info(struct megasas_ins
 }
 
 /**
- * megasas_issue_init_mfi -	Initializes the FW
- * @instance:		Adapter soft state
- *
- * Issues the INIT MFI cmd
- */
-static int
-megasas_issue_init_mfi(struct megasas_instance *instance)
-{
-	u32 context;
-
-	struct megasas_cmd *cmd;
-
-	struct megasas_init_frame *init_frame;
-	struct megasas_init_queue_info *initq_info;
-	dma_addr_t init_frame_h;
-	dma_addr_t initq_info_h;
-
-	/*
-	 * Prepare a init frame. Note the init frame points to queue info
-	 * structure. Each frame has SGL allocated after first 64 bytes. For
-	 * this frame - since we don't need any SGL - we use SGL's space as
-	 * queue info structure
-	 *
-	 * We will not get a NULL command below. We just created the pool.
-	 */
-	cmd = megasas_get_cmd(instance);
-
-	init_frame = (struct megasas_init_frame *)cmd->frame;
-	initq_info = (struct megasas_init_queue_info *)
-	    ((unsigned long)init_frame + 64);
-
-	init_frame_h = cmd->frame_phys_addr;
-	initq_info_h = init_frame_h + 64;
-
-	context = init_frame->context;
-	memset(init_frame, 0, MEGAMFI_FRAME_SIZE);
-	memset(initq_info, 0, sizeof(struct megasas_init_queue_info));
-	init_frame->context = context;
-	
-	initq_info->reply_queue_entries = instance->max_fw_cmds + 1;
-	initq_info->reply_queue_start_phys_addr_lo = instance->reply_queue_h;
-
-	initq_info->producer_index_phys_addr_lo = instance->producer_h;
-	initq_info->consumer_index_phys_addr_lo = instance->consumer_h;
-
-	init_frame->cmd = MFI_CMD_INIT;
-	init_frame->cmd_status = 0xFF;
-	init_frame->queue_info_new_phys_addr_lo = initq_info_h;
-
-	init_frame->data_xfer_len = sizeof(struct megasas_init_queue_info);
-
-	/*
-	 * disable the intr before firing the init frame to FW 
-	 */	
-	instance->instancet->disable_intr(instance->reg_set);
-	
-	/*
-	 * Issue the init frame in polled mode
-	 */
-
-	if (megasas_issue_polled(instance, cmd)) {
-		printk(KERN_DEBUG "megasas: Failed to init firmware\n");
-		megasas_return_cmd(instance, cmd);
-		goto fail_fw_init;
-	}
-
-	megasas_return_cmd(instance, cmd);
-
-	return 0;
-
-	fail_fw_init:
-		return -EINVAL;
-}
-
-/**
  * megasas_init_mfi -	Initializes the FW
  * @instance:		Adapter soft state
  *
@@ -2049,8 +1953,14 @@ static int megasas_init_mfi(struct megas
 	u32 tmp_sectors;
 	struct megasas_register_set __iomem *reg_set;
 
+	struct megasas_cmd *cmd;
 	struct megasas_ctrl_info *ctrl_info;
 
+	struct megasas_init_frame *init_frame;
+	struct megasas_init_queue_info *initq_info;
+	dma_addr_t init_frame_h;
+	dma_addr_t initq_info_h;
+
 	/*
 	 * Map the message registers
 	 */
@@ -2126,9 +2036,53 @@ static int megasas_init_mfi(struct megas
 		printk(KERN_DEBUG "megasas: Out of DMA mem for reply queue\n");
 		goto fail_reply_queue;
 	}
+
+	/*
+	 * Prepare a init frame. Note the init frame points to queue info
+	 * structure. Each frame has SGL allocated after first 64 bytes. For
+	 * this frame - since we don't need any SGL - we use SGL's space as
+	 * queue info structure
+	 *
+	 * We will not get a NULL command below. We just created the pool.
+	 */
+	cmd = megasas_get_cmd(instance);
+
+	init_frame = (struct megasas_init_frame *)cmd->frame;
+	initq_info = (struct megasas_init_queue_info *)
+	    ((unsigned long)init_frame + 64);
+
+	init_frame_h = cmd->frame_phys_addr;
+	initq_info_h = init_frame_h + 64;
+
+	memset(init_frame, 0, MEGAMFI_FRAME_SIZE);
+	memset(initq_info, 0, sizeof(struct megasas_init_queue_info));
+
+	initq_info->reply_queue_entries = instance->max_fw_cmds + 1;
+	initq_info->reply_queue_start_phys_addr_lo = instance->reply_queue_h;
+
+	initq_info->producer_index_phys_addr_lo = instance->producer_h;
+	initq_info->consumer_index_phys_addr_lo = instance->consumer_h;
+
+	init_frame->cmd = MFI_CMD_INIT;
+	init_frame->cmd_status = 0xFF;
+	init_frame->queue_info_new_phys_addr_lo = initq_info_h;
+
+	init_frame->data_xfer_len = sizeof(struct megasas_init_queue_info);
+
+	/*
+	 * disable the intr before firing the init frame to FW 
+	 */	
+	instance->instancet->disable_intr(instance->reg_set);
 	
-	if (megasas_issue_init_mfi(instance))
+	/*
+	 * Issue the init frame in polled mode
+	 */
+	if (megasas_issue_polled(instance, cmd)) {
+		printk(KERN_DEBUG "megasas: Failed to init firmware\n");
 		goto fail_fw_init;
+	}
+
+	megasas_return_cmd(instance, cmd);
 
 	ctrl_info = kmalloc(sizeof(struct megasas_ctrl_info), GFP_KERNEL);
 
@@ -2153,7 +2107,7 @@ static int megasas_init_mfi(struct megas
 	}
  
 	instance->max_sectors_per_req = instance->max_num_sge *
-		    PAGE_SIZE / 512;
+ 		    PAGE_SIZE / 512;
 	if (tmp_sectors && (instance->max_sectors_per_req > tmp_sectors))
 		instance->max_sectors_per_req = tmp_sectors;
 
@@ -2163,11 +2117,13 @@ static int megasas_init_mfi(struct megas
 	* Setup tasklet for cmd completion
 	*/
 
-	tasklet_init(&instance->isr_tasklet, megasas_complete_cmd_dpc,
+        tasklet_init(&instance->isr_tasklet, megasas_complete_cmd_dpc,
                         (unsigned long)instance);
+
 	return 0;
 
       fail_fw_init:
+	megasas_return_cmd(instance, cmd);
 
 	pci_free_consistent(instance->pdev, reply_q_sz,
 			    instance->reply_queue, instance->reply_queue_h);
@@ -2412,8 +2368,7 @@ static int megasas_start_aen(struct mega
 }
 
 static ssize_t
-sysfs_max_sectors_read(struct kobject *kobj, char *buf,
-			loff_t off, size_t count)
+sysfs_max_sectors_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
 {
 	struct Scsi_Host *host = class_to_shost(container_of(kobj,
 					struct class_device, kobj));
@@ -2435,6 +2390,7 @@ static struct bin_attribute sysfs_max_se
 	.read = sysfs_max_sectors_read,
 };
 
+
 /**
  * megasas_io_attach -	Attaches this driver to SCSI mid-layer
  * @instance:		Adapter soft state
@@ -2494,21 +2450,22 @@ static int megasas_io_attach(struct mega
 		return -ENODEV;
 	}
 
-	/*
+	/*	 
 	 * Create sysfs entries for module paramaters
 	 */
 	error = sysfs_create_bin_file(&instance->host->shost_classdev.kobj,
 			&sysfs_max_sectors_attr);
 	if (error) {
-		printk(KERN_INFO "megasas: Error in creating the sysfs entry"
-				" max_sectors.\n");
+		printk(KERN_INFO "megasas: Error in creating the sysfs entry max_sectors.\n");
 		goto out_remove_host;
 	}
 
 	/*
 	 * Trigger SCSI to scan our drives
 	 */
+
 	scsi_scan_host(host);
+	
 	return 0;
 
 out_remove_host:
@@ -2516,28 +2473,6 @@ out_remove_host:
 	return error;
 }
 
-static int
-megasas_set_dma_mask(struct pci_dev *pdev)
-{
-	/*
-	 * All our contollers are capable of performing 64-bit DMA
-	 */
-	if (IS_DMA64) {
-		if (pci_set_dma_mask(pdev, DMA_64BIT_MASK) != 0) {
-
-			if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) != 0)
-				goto fail_set_dma_mask;
-		}
-	} else {
-		if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) != 0)
-			goto fail_set_dma_mask;
-	}
-	return 0;
-
-fail_set_dma_mask:
-	return 1;
-}
-
 /**
  * megasas_probe_one -	PCI hotplug entry point
  * @pdev:		PCI device structure
@@ -2546,7 +2481,7 @@ fail_set_dma_mask:
 static int __devinit
 megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
 {
-	int rval;
+	int rval, i;
 	struct Scsi_Host *host;
 	struct megasas_instance *instance;
 
@@ -2571,8 +2506,19 @@ megasas_probe_one(struct pci_dev *pdev, 
 
 	pci_set_master(pdev);
 
-	if (megasas_set_dma_mask(pdev))
-		goto fail_set_dma_mask;
+	/*
+	 * All our contollers are capable of performing 64-bit DMA
+	 */
+	if (IS_DMA64) {
+		if (pci_set_dma_mask(pdev, DMA_64BIT_MASK) != 0) {
+
+			if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) != 0)
+				goto fail_set_dma_mask;
+		}
+	} else {
+		if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) != 0)
+			goto fail_set_dma_mask;
+	}
 
 	host = scsi_host_alloc(&megasas_template,
 			       sizeof(struct megasas_instance));
@@ -2614,7 +2560,7 @@ megasas_probe_one(struct pci_dev *pdev, 
 	 * Initialize locks and queues
 	 */
 	INIT_LIST_HEAD(&instance->cmd_pool);
-
+		
 	atomic_set(&instance->fw_outstanding,0);
 
 	init_waitqueue_head(&instance->int_cmd_wait_q);
@@ -2635,8 +2581,8 @@ megasas_probe_one(struct pci_dev *pdev, 
 	instance->init_id = MEGASAS_DEFAULT_INIT_ID;
 
 	megasas_dbg_lvl = 0;
-	instance->flag = 0;
-	instance->last_time = 0;
+	instance->is_busy=0;
+	instance->last_time=0;
 
 	/*
 	 * Initialize MFI Firmware
@@ -2647,7 +2593,7 @@ megasas_probe_one(struct pci_dev *pdev, 
 	/*
 	 * Register IRQ
 	 */
-	if (request_irq(pdev->irq, megasas_isr, IRQF_SHARED, "megasas", instance)) {
+	if (request_irq(pdev->irq, megasas_isr, SA_SHIRQ, "megasas", instance)) {
 		printk(KERN_DEBUG "megasas: Failed to register IRQ\n");
 		goto fail_irq;
 	}
@@ -2755,10 +2701,8 @@ static void megasas_flush_cache(struct m
 /**
  * megasas_shutdown_controller -	Instructs FW to shutdown the controller
  * @instance:				Adapter soft state
- * @opcode:				Shutdown/Hibernate
  */
-static void megasas_shutdown_controller(struct megasas_instance *instance,
-					u32 opcode)
+static void megasas_shutdown_controller(struct megasas_instance *instance)
 {
 	struct megasas_cmd *cmd;
 	struct megasas_dcmd_frame *dcmd;
@@ -2781,7 +2725,7 @@ static void megasas_shutdown_controller(
 	dcmd->flags = MFI_FRAME_DIR_NONE;
 	dcmd->timeout = 0;
 	dcmd->data_xfer_len = 0;
-	dcmd->opcode = opcode;
+	dcmd->opcode = MR_DCMD_CTRL_SHUTDOWN;
 
 	megasas_issue_blocked_cmd(instance, cmd);
 
@@ -2791,136 +2735,6 @@ static void megasas_shutdown_controller(
 }