rhel3.patch

最新的Megaraid SAS卡驱动源代码

+
+	error = megasas_mgmt_fw_ioctl(instance, ioc);
+
+	if (copy_to_user(&user_ioc->frame.hdr.cmd_status,
+			 &ioc->frame.hdr.cmd_status, sizeof(u8))) {
+
+		printk(KERN_DEBUG "megasas: Error copying out cmd_status\n");
+		error = -EFAULT;
+	}
+
 	up(&instance->ioctl_sem);
 
       out_kfree_ioc:
@@ -3252,12 +3369,6 @@ static int megasas_mgmt_ioctl_aen(struct
 	struct megasas_aen aen;
 	int error;
 
-	if (file->private_data != file) {
-		printk(KERN_DEBUG "megasas: fasync_helper was not "
-		       "called first\n");
-		return -EINVAL;
-	}
-
 	if (copy_from_user(&aen, (void __user *)arg, sizeof(aen)))
 		return -EFAULT;
 
@@ -3277,12 +3388,12 @@ static int megasas_mgmt_ioctl_aen(struct
  * megasas_mgmt_ioctl -	char node ioctl entry point
  */
 static long
-megasas_mgmt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+megasas_mgmt_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
+		   unsigned long arg)
 {
 	switch (cmd) {
 	case MEGASAS_IOC_FIRMWARE:
 		return megasas_mgmt_ioctl_fw(file, arg);
-
 	case MEGASAS_IOC_GET_AEN:
 		return megasas_mgmt_ioctl_aen(file, arg);
 	}
@@ -3290,50 +3401,100 @@ megasas_mgmt_ioctl(struct file *file, un
 	return -ENOTTY;
 }
 
-#ifdef CONFIG_COMPAT
-static int megasas_mgmt_compat_ioctl_fw(struct file *file, unsigned long arg)
+#ifdef __x86_64__
+
+static inline void
+megasas_convert_compat_iocpacket(struct megasas_iocpacket *ioc,
+			struct compat_megasas_iocpacket* kcioc)
 {
-	struct compat_megasas_iocpacket __user *cioc =
-	    (struct compat_megasas_iocpacket __user *)arg;
-	struct megasas_iocpacket __user *ioc =
-	    compat_alloc_user_space(sizeof(struct megasas_iocpacket));
-	int i;
-	int error = 0;
+	int i = 0;
+	compat_uptr_t ptr;
 
-	if (clear_user(ioc, sizeof(*ioc)))
-		return -EFAULT;
+	ioc->host_no = kcioc->host_no;
+	ioc->sgl_off = kcioc->sgl_off;
+	ioc->sense_off = kcioc->sense_off;
+	ioc->sense_len = kcioc->sense_len;
+	ioc->sge_count = kcioc->sge_count;
 
-	if (copy_in_user(&ioc->host_no, &cioc->host_no, sizeof(u16)) ||
-	    copy_in_user(&ioc->sgl_off, &cioc->sgl_off, sizeof(u32)) ||
-	    copy_in_user(&ioc->sense_off, &cioc->sense_off, sizeof(u32)) ||
-	    copy_in_user(&ioc->sense_len, &cioc->sense_len, sizeof(u32)) ||
-	    copy_in_user(ioc->frame.raw, cioc->frame.raw, 128) ||
-	    copy_in_user(&ioc->sge_count, &cioc->sge_count, sizeof(u32)))
-		return -EFAULT;
+	memcpy(ioc->frame.raw, kcioc->frame.raw, 128);
 
 	for (i = 0; i < MAX_IOCTL_SGE; i++) {
 		compat_uptr_t ptr;
-
-		if (get_user(ptr, &cioc->sgl[i].iov_base) ||
-		    put_user(compat_ptr(ptr), &ioc->sgl[i].iov_base) ||
-		    copy_in_user(&ioc->sgl[i].iov_len,
-				 &cioc->sgl[i].iov_len, sizeof(compat_size_t)))
-			return -EFAULT;
+		ptr = kcioc->sgl[i].iov_base;
+		ioc->sgl[i].iov_len = kcioc->sgl[i].iov_len;
+		ioc->sgl[i].iov_base = ptr;
 	}
+}
 
-	error = megasas_mgmt_ioctl_fw(file, (unsigned long)ioc);
 
-	if (copy_in_user(&cioc->frame.hdr.cmd_status,
-			 &ioc->frame.hdr.cmd_status, sizeof(u8))) {
-		printk(KERN_DEBUG "megasas: error copy_in_user cmd_status\n");
-		return -EFAULT;
+static int 
+megasas_mgmt_compat_ioctl_fw(struct file *file, unsigned long arg)
+{
+	int i = 0;
+	int error = 0;
+
+	struct megasas_instance *instance = NULL;
+	struct megasas_iocpacket *ioc = NULL;
+	struct compat_megasas_iocpacket *kcioc = NULL;
+	struct compat_megasas_iocpacket *ucioc =
+	    (struct compat_megasas_iocpacket *)arg;
+
+
+	ioc = kmalloc(sizeof(struct megasas_iocpacket), GFP_KERNEL);
+	kcioc = kmalloc(sizeof(struct compat_megasas_iocpacket), GFP_KERNEL);
+
+	if (!ioc || !kcioc) {
+		printk(KERN_DEBUG "megasas: memalloc error\n");
+		return ENOMEM;
 	}
-	return error;
-}
 
-static long
-megasas_mgmt_compat_ioctl(struct file *file, unsigned int cmd,
-			  unsigned long arg)
+	if (copy_from_user(kcioc, ucioc, sizeof(*kcioc))) {
+		printk(KERN_DEBUG "megasas: cp from usr failed in compat\n");
+		error = -EFAULT;
+		goto out;
+	}
+
+	/*
+	 * The application has sent a struct compat_megasas_iocpacket
+	 * (it is a 32 bit application). Convert it to regular 64 bit
+	 * struct megasas_iocpacket
+	 */
+	megasas_convert_compat_iocpacket(ioc, kcioc);
+
+	instance = megasas_lookup_instance(ioc->host_no);
+	if (!instance) {
+		ioc = kmalloc(sizeof(*ioc), GFP_KERNEL);
+		error = -ENODEV;
+		goto out;
+	}
+ 
+	/*
+	 * Now send the ioc through regular ioctl path. Note that we allow
+	 * only MEGASAS_INT_CMDS number of parallel ioctl cmds
+	 */
+	if (down_interruptible(&instance->ioctl_sem)) {
+		error = -ERESTARTSYS;
+		goto out;
+	}
+	error = megasas_mgmt_fw_ioctl(instance, ioc);
+	
+	up(&instance->ioctl_sem);
+	/*
+	 * copy the status codes returned by the fw
+	 */
+	if (copy_to_user(&ucioc->frame.hdr.cmd_status,
+ 			 &ioc->frame.hdr.cmd_status, sizeof(u8))) {
+		printk(KERN_DEBUG "megasas: Error copying out cmd_status\n");
+		error = -EFAULT;
+ 	}
+out:
+	kfree(ioc);
+	kfree(kcioc);
+ 	return error;
+ }
+static int
+megasas_mgmt_compat_ioctl(unsigned int fd, unsigned int cmd,
+			  unsigned long arg, struct file *file)
 {
 	switch (cmd) {
 	case MEGASAS_IOC_FIRMWARE32:
@@ -3349,15 +3510,12 @@ megasas_mgmt_compat_ioctl(struct file *f
 /*
  * File operations structure for management interface
  */
-static const struct file_operations megasas_mgmt_fops = {
+static struct file_operations megasas_mgmt_fops = {
 	.owner = THIS_MODULE,
 	.open = megasas_mgmt_open,
 	.release = megasas_mgmt_release,
 	.fasync = megasas_mgmt_fasync,
-	.unlocked_ioctl = megasas_mgmt_ioctl,
-#ifdef CONFIG_COMPAT
-	.compat_ioctl = megasas_mgmt_compat_ioctl,
-#endif
+	.ioctl = megasas_mgmt_ioctl,
 };
 
 /*
@@ -3369,52 +3527,8 @@ static struct pci_driver megasas_pci_dri
 	.id_table = megasas_pci_table,
 	.probe = megasas_probe_one,
 	.remove = __devexit_p(megasas_detach_one),
-	.suspend = megasas_suspend,
-	.resume = megasas_resume,
-	.shutdown = megasas_shutdown,
 };
 
-/*
- * Sysfs driver attributes
- */
-static ssize_t megasas_sysfs_show_version(struct device_driver *dd, char *buf)
-{
-	return snprintf(buf, strlen(MEGASAS_VERSION) + 2, "%s\n",
-			MEGASAS_VERSION);
-}
-
-static DRIVER_ATTR(version, S_IRUGO, megasas_sysfs_show_version, NULL);
-
-static ssize_t
-megasas_sysfs_show_release_date(struct device_driver *dd, char *buf)
-{
-	return snprintf(buf, strlen(MEGASAS_RELDATE) + 2, "%s\n",
-			MEGASAS_RELDATE);
-}
-
-static DRIVER_ATTR(release_date, S_IRUGO, megasas_sysfs_show_release_date,
-		   NULL);
-
-static ssize_t
-megasas_sysfs_show_dbg_lvl(struct device_driver *dd, char *buf)
-{
-	return sprintf(buf,"%u",megasas_dbg_lvl);
-}
-
-static ssize_t
-megasas_sysfs_set_dbg_lvl(struct device_driver *dd, const char *buf, size_t count)
-{
-	int retval = count;
-	if(sscanf(buf,"%u",&megasas_dbg_lvl)<1){
-		printk(KERN_ERR "megasas: could not set dbg_lvl\n");
-		retval = -EINVAL;
-	}
-	return retval;
-}
-
-static DRIVER_ATTR(dbg_lvl, S_IRUGO|S_IWUGO, megasas_sysfs_show_dbg_lvl,
-		   megasas_sysfs_set_dbg_lvl);
-
 /**
  * megasas_init - Driver load entry point
  */
@@ -3441,41 +3555,63 @@ static int __init megasas_init(void)
 	}
 
 	megasas_mgmt_majorno = rval;
+#ifdef CONFIG_PROC_FS
+	megasas_proc_root = proc_mkdir("megaraid_sas", proc_scsi);
+
+	if (megasas_proc_root) {
+		megasas_proc_version = create_proc_read_entry("version",
+							      S_IRUSR | S_IFREG,
+							      megasas_proc_root,
+							      megasas_proc_show_version,
+							      NULL);
+
+		megasas_proc_release_date =
+		    create_proc_read_entry("release_date", S_IRUSR | S_IFREG,
+					   megasas_proc_root,
+					   megasas_proc_show_release_date,
+					   NULL);
+
+		megasas_proc_dbg_lvl =
+		    create_proc_read_entry("dbg_lvl", S_IRUSR|S_IFREG|S_IWUSR,
+					   megasas_proc_root,
+					   megasas_proc_show_dbg_lvl,
+					   megasas_proc_get_dbg_lvl);
+
+		megasas_proc_hba_map = proc_mkdir("hba_map", megasas_proc_root);
+	}
+#endif
 
 	/*
 	 * Register ourselves as PCI hotplug module
 	 */
-	rval = pci_register_driver(&megasas_pci_driver);
+	rval = pci_module_init(&megasas_pci_driver);
 
 	if (rval) {
 		printk(KERN_DEBUG "megasas: PCI hotplug regisration failed \n");
-		goto err_pcidrv;
+#ifdef CONFIG_PROC_FS
+		if (megasas_proc_root) {
+			remove_proc_entry("version", megasas_proc_root);
+			remove_proc_entry("release_date", megasas_proc_root);
+			remove_proc_entry("dbg_lvl", megasas_proc_root);
+			remove_proc_entry("hba_map", megasas_proc_root);
+			remove_proc_entry("megaraid_sas", proc_scsi);
+		}
+#endif
+		unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
+		return rval;
 	}
 
-	rval = driver_create_file(&megasas_pci_driver.driver,
-				  &driver_attr_version);
-	if (rval)
-		goto err_dcf_attr_ver;
-	rval = driver_create_file(&megasas_pci_driver.driver,
-				  &driver_attr_release_date);
-	if (rval)
-		goto err_dcf_rel_date;
-	rval = driver_create_file(&megasas_pci_driver.driver,
-				  &driver_attr_dbg_lvl);
-	if (rval)
-		goto err_dcf_dbg_lvl;
+#ifdef __x86_64__
+	register_ioctl32_conversion(MEGASAS_IOC_FIRMWARE32,
+				    megasas_mgmt_compat_ioctl);
+	register_ioctl32_conversion(MEGASAS_IOC_GET_AEN,
+				    megasas_mgmt_compat_ioctl);
+#endif
+	if(register_reboot_notifier(&megasas_notifier)) {
+		printk("megasas: reboot notify routine registration failed!!\n");
+	}
 
 	return rval;
-err_dcf_dbg_lvl:
-	driver_remove_file(&megasas_pci_driver.driver,
-			   &driver_attr_release_date);
-err_dcf_rel_date:
-	driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
-err_dcf_attr_ver:
-	pci_unregister_driver(&megasas_pci_driver);
-err_pcidrv:
-	unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
-  	return rval;
 }
 
 /**
@@ -3483,14 +3619,25 @@ err_pcidrv:
  */
 static void __exit megasas_exit(void)
 {
-	driver_remove_file(&megasas_pci_driver.driver,
-			   &driver_attr_dbg_lvl);
-	driver_remove_file(&megasas_pci_driver.driver,
-			   &driver_attr_release_date);
-	driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
 
+#ifdef __x86_64__
+	unregister_ioctl32_conversion(MEGASAS_IOC_FIRMWARE32);
+	unregister_ioctl32_conversion(MEGASAS_IOC_GET_AEN);
+#endif
 	pci_unregister_driver(&megasas_pci_driver);
+
+#ifdef CONFIG_PROC_FS
+	if (megasas_proc_root) {
+		remove_proc_entry("version", megasas_proc_root);
+		remove_proc_entry("release_date", megasas_proc_root);
+		remove_proc_entry("dbg_lvl", megasas_proc_root);
+		remove_proc_entry("hba_map", megasas_proc_root);
+		remove_proc_entry("megaraid_sas", proc_scsi);
+	}
+#endif
+
 	unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
+	unregister_reboot_notifier(&megasas_notifier);
 }
 
 module_init(megasas_init);
diff -uprN base/megaraid_sas.h rhel3/megaraid_sas.h
--- base/megaraid_sas.h	2007-10-13 20:37:32.000000000 -0700
+++ rhel3/megaraid_sas.h	2007-10-13 20:39:15.000000000 -0700
@@ -15,7 +15,7 @@
 #ifndef LSI_MEGARAID_SAS_H
 #define LSI_MEGARAID_SAS_H
 
-/*
+/**
  * MegaRAID SAS Driver meta data
  */
 #define MEGASAS_VERSION				"00.00.03.16"
@@ -24,10 +24,45 @@
 
 /*
  * Device IDs
+ * 
  */
 #define	PCI_DEVICE_ID_LSI_SAS1078R		0x0060
 #define	PCI_DEVICE_ID_LSI_VERDE_ZCR		0x0413
+#define	PCI_DEVICE_ID_LSI_SAS1064R		0x0411
+#define	PCI_DEVICE_ID_DELL_PERC5		0x0015
+
+#define __user
+#define __iomem
+#define dma_pool pci_pool
+
+#ifndef	READ_16
+#define READ_16		0x88
+#endif
+
+#ifndef WRITE_16
+#define WRITE_16	0x8a
+#endif
+
+#ifndef REPORT_LUNS
+#define REPORT_LUNS	0xa0
+#endif
+
+#define DID_IMM_RETRY			DID_SOFT_ERROR
+#define SAM_STAT_CHECK_CONDITION	0x02
 
+#define	scsi_host_alloc		scsi_register
+#define scsi_host_put		scsi_unregister
+#define scsi_add_host(x,y)	(0)
+#define	scsi_remove_host(x)	do{}while(0)
+
+typedef void irqreturn_t;
+
+#define IRQ_NONE
+#define IRQ_HANDLED
+
+#define DMA_32BIT_MASK		0xFFFFFFFF
+#define DMA_64BIT_MASK		0xFFFFFFFFFFFFFFFF
+ 
 /*
  * =====================================
  * MegaRAID SAS MFI firmware definitions
@@ -117,7 +152,6 @@
 #define MR_FLUSH_DISK_CACHE			0x02
 
 #define MR_DCMD_CTRL_SHUTDOWN			0x01050000
-#define MR_DCMD_HIBERNATE_SHUTDOWN		0x01060000
 #define MR_ENABLE_DRIVE_SPINDOWN		0x01
 
 #define MR_DCMD_CTRL_EVENT_GET_INFO		0x01040100
@@ -507,6 +541,7 @@ struct megasas_ctrl_info {
 	/*
 	 * Define ECC single-bit-error bucket information
 	 */
+
 	u8 ecc_bucket_count;
 	u8 reserved_2[11];
 
@@ -539,9 +574,18 @@ struct megasas_ctrl_info {
 #define MEGASAS_MAX_LD				64
 #define MEGASAS_DEFAULT_CMD_PER_LUN		128
 
-
 #define MEGASAS_DBG_LVL				1
-#define MEGASAS_FW_BUSY				1
+
+/* 
+ * For ioctl memory manager
+ */
+
+#define MAX_IOCTL_MEM_POOL			3
+#define MEGASAS_INIT_IOCTL_MEM_SIZE		4096
+#define MAX_IOCTL_MEM_BLOCK			16
+#define MAX_4K_BUFF				8
+#define MAX_8K_BUFF				4
+#define MAX_64K_BUFF				1
 
 /*
  * When SCSI mid-layer calls driver's reset routine, driver waits for
@@ -551,13 +595,10 @@ struct megasas_ctrl_info {
  * every MEGASAS_RESET_NOTICE_INTERVAL seconds
  */
 #define MEGASAS_RESET_WAIT_TIME			180
-#define MEGASAS_INTERNAL_CMD_WAIT_TIME		180
 #define	MEG