12 files changed, 75 insertions, 88 deletions

diff --git a/drivers/scsi/aha152x.c b/drivers/scsi/aha152x.c
index b5a868d85eb4..1e5478abd90e 100644
--- a/drivers/scsi/aha152x.c
+++ b/drivers/scsi/aha152x.c
@@ -337,7 +337,7 @@ CMD_INC_RESID(struct scsi_cmnd *cmd, int inc)
 #else
 #define IRQ_MIN 9
 #if defined(__PPC)
-#define IRQ_MAX (NR_IRQS-1)
+#define IRQ_MAX (nr_irqs-1)
 #else
 #define IRQ_MAX 12
 #endif
diff --git a/drivers/scsi/arcmsr/arcmsr_attr.c b/drivers/scsi/arcmsr/arcmsr_attr.c
index 69f8346aa288..5877f29a6005 100644
--- a/drivers/scsi/arcmsr/arcmsr_attr.c
+++ b/drivers/scsi/arcmsr/arcmsr_attr.c
@@ -189,7 +189,6 @@ static struct bin_attribute arcmsr_sysfs_message_read_attr = {
         .attr = {
                 .name = "mu_read",
                 .mode = S_IRUSR ,
-                .owner = THIS_MODULE,
         },
         .size = 1032,
         .read = arcmsr_sysfs_iop_message_read,
@@ -199,7 +198,6 @@ static struct bin_attribute arcmsr_sysfs_message_write_attr = {
         .attr = {
                 .name = "mu_write",
                 .mode = S_IWUSR,
-                .owner = THIS_MODULE,
         },
         .size = 1032,
         .write = arcmsr_sysfs_iop_message_write,
@@ -209,7 +207,6 @@ static struct bin_attribute arcmsr_sysfs_message_clear_attr = {
         .attr = {
                 .name = "mu_clear",
                 .mode = S_IWUSR,
-                .owner = THIS_MODULE,
         },
         .size = 1,
         .write = arcmsr_sysfs_iop_message_clear,
diff --git a/drivers/scsi/ide-scsi.c b/drivers/scsi/ide-scsi.c
index 740bad435995..2370fd82ebfe 100644
--- a/drivers/scsi/ide-scsi.c
+++ b/drivers/scsi/ide-scsi.c
@@ -343,6 +343,11 @@ static ide_startstop_t idescsi_do_request (ide_drive_t *drive, struct request *r
 }
 
 #ifdef CONFIG_IDE_PROC_FS
+static ide_proc_entry_t idescsi_proc[] = {
+        { "capacity", S_IFREG|S_IRUGO, proc_ide_read_capacity, NULL },
+        { NULL, 0, NULL, NULL }
+};
+
 #define ide_scsi_devset_get(name, field) \
 static int get_##name(ide_drive_t *drive) \
 { \
@@ -378,6 +383,16 @@ static const struct ide_proc_devset idescsi_settings[] = {
         IDE_PROC_DEVSET(transform, 0,    3),
         { 0 },
 };
+
+static ide_proc_entry_t *ide_scsi_proc_entries(ide_drive_t *drive)
+{
+        return idescsi_proc;
+}
+
+static const struct ide_proc_devset *ide_scsi_proc_devsets(ide_drive_t *drive)
+{
+        return idescsi_settings;
+}
 #endif
 
 /*
@@ -419,13 +434,6 @@ static void ide_scsi_remove(ide_drive_t *drive)
 
 static int ide_scsi_probe(ide_drive_t *);
 
-#ifdef CONFIG_IDE_PROC_FS
-static ide_proc_entry_t idescsi_proc[] = {
-        { "capacity", S_IFREG|S_IRUGO, proc_ide_read_capacity, NULL },
-        { NULL, 0, NULL, NULL }
-};
-#endif
-
 static ide_driver_t idescsi_driver = {
         .gen_driver = {
                 .owner          = THIS_MODULE,
@@ -439,45 +447,39 @@ static ide_driver_t idescsi_driver = {
         .end_request            = idescsi_end_request,
         .error                  = idescsi_atapi_error,
 #ifdef CONFIG_IDE_PROC_FS
-        .proc                   = idescsi_proc,
-        .settings               = idescsi_settings,
+        .proc_entries           = ide_scsi_proc_entries,
+        .proc_devsets           = ide_scsi_proc_devsets,
 #endif
 };
 
-static int idescsi_ide_open(struct inode *inode, struct file *filp)
+static int idescsi_ide_open(struct block_device *bdev, fmode_t mode)
 {
-        struct gendisk *disk = inode->i_bdev->bd_disk;
-        struct ide_scsi_obj *scsi;
+        struct ide_scsi_obj *scsi = ide_scsi_get(bdev->bd_disk);
 
-        if (!(scsi = ide_scsi_get(disk)))
+        if (!scsi)
                 return -ENXIO;
 
         return 0;
 }
 
-static int idescsi_ide_release(struct inode *inode, struct file *filp)
+static int idescsi_ide_release(struct gendisk *disk, fmode_t mode)
 {
-        struct gendisk *disk = inode->i_bdev->bd_disk;
-        struct ide_scsi_obj *scsi = ide_scsi_g(disk);
-
-        ide_scsi_put(scsi);
-
+        ide_scsi_put(ide_scsi_g(disk));
         return 0;
 }
 
-static int idescsi_ide_ioctl(struct inode *inode, struct file *file,
+static int idescsi_ide_ioctl(struct block_device *bdev, fmode_t mode,
                         unsigned int cmd, unsigned long arg)
 {
-        struct block_device *bdev = inode->i_bdev;
         struct ide_scsi_obj *scsi = ide_scsi_g(bdev->bd_disk);
-        return generic_ide_ioctl(scsi->drive, file, bdev, cmd, arg);
+        return generic_ide_ioctl(scsi->drive, bdev, cmd, arg);
 }
 
 static struct block_device_operations idescsi_ops = {
         .owner          = THIS_MODULE,
         .open           = idescsi_ide_open,
         .release        = idescsi_ide_release,
-        .ioctl          = idescsi_ide_ioctl,
+        .locked_ioctl   = idescsi_ide_ioctl,
 };
 
 static int idescsi_slave_configure(struct scsi_device * sdp)
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index de62f4dfeb0e..ded854a6dd35 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -7853,7 +7853,6 @@ static struct pci_driver ipr_driver = {
         .remove = ipr_remove,
         .shutdown = ipr_shutdown,
         .err_handler = &ipr_err_handler,
-        .dynids.use_driver_data = 1
 };
 
 /**
diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index 83c819216771..f25f41a499e5 100644
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -2108,7 +2108,7 @@ struct scsi_qla_host;
 
 struct qla_msix_entry {
         int have_irq;
-        uint16_t msix_vector;
+        uint32_t msix_vector;
         uint16_t msix_entry;
 };
 
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 2aed4721c0d0..21dd182ad512 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -1566,9 +1566,8 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
                         goto probe_out;
         }
 
-        if (pci_find_aer_capability(pdev))
-                if (pci_enable_pcie_error_reporting(pdev))
-                        goto probe_out;
+        /* This may fail but that's ok */
+        pci_enable_pcie_error_reporting(pdev);
 
         host = scsi_host_alloc(sht, sizeof(scsi_qla_host_t));
         if (host == NULL) {
diff --git a/drivers/scsi/scsi_ioctl.c b/drivers/scsi/scsi_ioctl.c
index 28b19ef26309..dc1cfb2fd76b 100644
--- a/drivers/scsi/scsi_ioctl.c
+++ b/drivers/scsi/scsi_ioctl.c
@@ -237,7 +237,7 @@ int scsi_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
         case SCSI_IOCTL_SEND_COMMAND:
                 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
                         return -EACCES;
-                return sg_scsi_ioctl(NULL, sdev->request_queue, NULL, arg);
+                return sg_scsi_ioctl(sdev->request_queue, NULL, 0, arg);
         case SCSI_IOCTL_DOORLOCK:
                 return scsi_set_medium_removal(sdev, SCSI_REMOVAL_PREVENT);
         case SCSI_IOCTL_DOORUNLOCK:
@@ -277,14 +277,14 @@ EXPORT_SYMBOL(scsi_ioctl);
  * @filp: either NULL or a &struct file which must have the O_NONBLOCK flag.
  */
 int scsi_nonblockable_ioctl(struct scsi_device *sdev, int cmd,
-                            void __user *arg, struct file *filp)
+                            void __user *arg, int ndelay)
 {
         int val, result;
 
         /* The first set of iocts may be executed even if we're doing
          * error processing, as long as the device was opened
          * non-blocking */
-        if (filp && (filp->f_flags & O_NONBLOCK)) {
+        if (ndelay) {
                 if (scsi_host_in_recovery(sdev->host))
                         return -ENODEV;
         } else if (!scsi_block_when_processing_errors(sdev))
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 7ba70bef8b5d..c9e1242eaf25 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -609,17 +609,15 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
  *      In the latter case @inode and @filp carry an abridged amount
  *      of information as noted above.
  **/
-static int sd_open(struct inode *inode, struct file *filp)
+static int sd_open(struct block_device *bdev, fmode_t mode)
 {
-        struct gendisk *disk = inode->i_bdev->bd_disk;
-        struct scsi_disk *sdkp;
+        struct scsi_disk *sdkp = scsi_disk_get(bdev->bd_disk);
         struct scsi_device *sdev;
         int retval;
 
-        if (!(sdkp = scsi_disk_get(disk)))
+        if (!sdkp)
                 return -ENXIO;
 
-
         SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_open\n"));
 
         sdev = sdkp->device;
@@ -633,14 +631,13 @@ static int sd_open(struct inode *inode, struct file *filp)
                 goto error_out;
 
         if (sdev->removable || sdkp->write_prot)
-                check_disk_change(inode->i_bdev);
+                check_disk_change(bdev);
 
         /*
          * If the drive is empty, just let the open fail.
          */
         retval = -ENOMEDIUM;
-        if (sdev->removable && !sdkp->media_present &&
-            !(filp->f_flags & O_NDELAY))
+        if (sdev->removable && !sdkp->media_present && !(mode & FMODE_NDELAY))
                 goto error_out;
 
         /*
@@ -648,7 +645,7 @@ static int sd_open(struct inode *inode, struct file *filp)
          * if the user expects to be able to write to the thing.
          */
         retval = -EROFS;
-        if (sdkp->write_prot && (filp->f_mode & FMODE_WRITE))
+        if (sdkp->write_prot && (mode & FMODE_WRITE))
                 goto error_out;
 
         /*
@@ -684,9 +681,8 @@ error_out:
  *      Note: may block (uninterruptible) if error recovery is underway
  *      on this disk.
  **/
-static int sd_release(struct inode *inode, struct file *filp)
+static int sd_release(struct gendisk *disk, fmode_t mode)
 {
-        struct gendisk *disk = inode->i_bdev->bd_disk;
         struct scsi_disk *sdkp = scsi_disk(disk);
         struct scsi_device *sdev = sdkp->device;
 
@@ -743,10 +739,9 @@ static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
  *      Note: most ioctls are forward onto the block subsystem or further
  *      down in the scsi subsystem.
  **/
-static int sd_ioctl(struct inode * inode, struct file * filp, 
+static int sd_ioctl(struct block_device *bdev, fmode_t mode,
                     unsigned int cmd, unsigned long arg)
 {
-        struct block_device *bdev = inode->i_bdev;
         struct gendisk *disk = bdev->bd_disk;
         struct scsi_device *sdp = scsi_disk(disk)->device;
         void __user *p = (void __user *)arg;
@@ -761,7 +756,8 @@ static int sd_ioctl(struct inode * inode, struct file * filp,
          * may try and take the device offline, in which case all further
          * access to the device is prohibited.
          */
-        error = scsi_nonblockable_ioctl(sdp, cmd, p, filp);
+        error = scsi_nonblockable_ioctl(sdp, cmd, p,
+                                        (mode & FMODE_NDELAY_NOW) != 0);
         if (!scsi_block_when_processing_errors(sdp) || !error)
                 return error;
 
@@ -775,7 +771,7 @@ static int sd_ioctl(struct inode * inode, struct file * filp,
                 case SCSI_IOCTL_GET_BUS_NUMBER:
                         return scsi_ioctl(sdp, cmd, p);
                 default:
-                        error = scsi_cmd_ioctl(filp, disk->queue, disk, cmd, p);
+                        error = scsi_cmd_ioctl(disk->queue, disk, mode, cmd, p);
                         if (error != -ENOTTY)
                                 return error;
         }
@@ -928,11 +924,10 @@ static void sd_rescan(struct device *dev)
  * This gets directly called from VFS. When the ioctl 
  * is not recognized we go back to the other translation paths. 
  */
-static long sd_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+static int sd_compat_ioctl(struct block_device *bdev, fmode_t mode,
+                           unsigned int cmd, unsigned long arg)
 {
-        struct block_device *bdev = file->f_path.dentry->d_inode->i_bdev;
-        struct gendisk *disk = bdev->bd_disk;
-        struct scsi_device *sdev = scsi_disk(disk)->device;
+        struct scsi_device *sdev = scsi_disk(bdev->bd_disk)->device;
 
         /*
          * If we are in the middle of error recovery, don't let anyone
@@ -962,7 +957,7 @@ static struct block_device_operations sd_fops = {
         .owner                  = THIS_MODULE,
         .open                   = sd_open,
         .release                = sd_release,
-        .ioctl                  = sd_ioctl,
+        .locked_ioctl           = sd_ioctl,
         .getgeo                 = sd_getgeo,
 #ifdef CONFIG_COMPAT
         .compat_ioctl           = sd_compat_ioctl,
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 93bd59a1ed79..9adf35bd8b56 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -1059,7 +1059,7 @@ sg_ioctl(struct inode *inode, struct file *filp,
                         if (sg_allow_access(filp, &opcode))
                                 return -EPERM;
                 }
-                return sg_scsi_ioctl(filp, sdp->device->request_queue, NULL, p);
+                return sg_scsi_ioctl(sdp->device->request_queue, NULL, filp->f_mode, p);
         case SG_SET_DEBUG:
                 result = get_user(val, ip);
                 if (result)
diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index 0f17009c99d2..62b6633e3a97 100644
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -471,38 +471,31 @@ static int sr_prep_fn(struct request_queue *q, struct request *rq)
         return scsi_prep_return(q, rq, ret);
 }
 
-static int sr_block_open(struct inode *inode, struct file *file)
+static int sr_block_open(struct block_device *bdev, fmode_t mode)
 {
-        struct gendisk *disk = inode->i_bdev->bd_disk;
-        struct scsi_cd *cd;
-        int ret = 0;
-
-        if(!(cd = scsi_cd_get(disk)))
-                return -ENXIO;
-
-        if((ret = cdrom_open(&cd->cdi, inode, file)) != 0)
-                scsi_cd_put(cd);
+        struct scsi_cd *cd = scsi_cd_get(bdev->bd_disk);
+        int ret = -ENXIO;
 
+        if (cd) {
+                ret = cdrom_open(&cd->cdi, bdev, mode);
+                if (ret)
+                        scsi_cd_put(cd);
+        }
         return ret;
 }
 
-static int sr_block_release(struct inode *inode, struct file *file)
+static int sr_block_release(struct gendisk *disk, fmode_t mode)
 {
-        int ret;
-        struct scsi_cd *cd = scsi_cd(inode->i_bdev->bd_disk);
-        ret = cdrom_release(&cd->cdi, file);
-        if(ret)
-                return ret;
-        
+        struct scsi_cd *cd = scsi_cd(disk);
+        cdrom_release(&cd->cdi, mode);
         scsi_cd_put(cd);
-
         return 0;
 }
 
-static int sr_block_ioctl(struct inode *inode, struct file *file, unsigned cmd,
+static int sr_block_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
                           unsigned long arg)
 {
-        struct scsi_cd *cd = scsi_cd(inode->i_bdev->bd_disk);
+        struct scsi_cd *cd = scsi_cd(bdev->bd_disk);
         struct scsi_device *sdev = cd->device;
         void __user *argp = (void __user *)arg;
         int ret;
@@ -517,7 +510,7 @@ static int sr_block_ioctl(struct inode *inode, struct file *file, unsigned cmd,
                 return scsi_ioctl(sdev, cmd, argp);
         }
 
-        ret = cdrom_ioctl(file, &cd->cdi, inode, cmd, arg);
+        ret = cdrom_ioctl(&cd->cdi, bdev, mode, cmd, arg);
         if (ret != -ENOSYS)
                 return ret;
 
@@ -527,7 +520,8 @@ static int sr_block_ioctl(struct inode *inode, struct file *file, unsigned cmd,
          * case fall through to scsi_ioctl, which will return ENDOEV again
          * if it doesn't recognise the ioctl
          */
-        ret = scsi_nonblockable_ioctl(sdev, cmd, argp, NULL);
+        ret = scsi_nonblockable_ioctl(sdev, cmd, argp,
+                                        (mode & FMODE_NDELAY_NOW) != 0);
         if (ret != -ENODEV)
                 return ret;
         return scsi_ioctl(sdev, cmd, argp);
@@ -544,7 +538,7 @@ static struct block_device_operations sr_bdops =
         .owner          = THIS_MODULE,
         .open           = sr_block_open,
         .release        = sr_block_release,
-        .ioctl          = sr_block_ioctl,
+        .locked_ioctl   = sr_block_ioctl,
         .media_changed  = sr_block_media_changed,
         /* 
          * No compat_ioctl for now because sr_block_ioctl never
diff --git a/drivers/scsi/sr_vendor.c b/drivers/scsi/sr_vendor.c
index 4eb3da996b36..4ad3e017213f 100644
--- a/drivers/scsi/sr_vendor.c
+++ b/drivers/scsi/sr_vendor.c
@@ -223,9 +223,9 @@ int sr_cd_check(struct cdrom_device_info *cdi)
                                 no_multi = 1;
                                 break;
                         }
-                        min = BCD2BIN(buffer[15]);
-                        sec = BCD2BIN(buffer[16]);
-                        frame = BCD2BIN(buffer[17]);
+                        min = bcd2bin(buffer[15]);
+                        sec = bcd2bin(buffer[16]);
+                        frame = bcd2bin(buffer[17]);
                         sector = min * CD_SECS * CD_FRAMES + sec * CD_FRAMES + frame;
                         break;
                 }
@@ -252,9 +252,9 @@ int sr_cd_check(struct cdrom_device_info *cdi)
                         }
                         if (rc != 0)
                                 break;
-                        min = BCD2BIN(buffer[1]);
-                        sec = BCD2BIN(buffer[2]);
-                        frame = BCD2BIN(buffer[3]);
+                        min = bcd2bin(buffer[1]);
+                        sec = bcd2bin(buffer[2]);
+                        frame = bcd2bin(buffer[3]);
                         sector = min * CD_SECS * CD_FRAMES + sec * CD_FRAMES + frame;
                         if (sector)
                                 sector -= CD_MSF_OFFSET;
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index 5c28d08f18f4..c959bdc55f4f 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -3263,7 +3263,8 @@ static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
          * may try and take the device offline, in which case all further
          * access to the device is prohibited.
          */
-        retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p, file);
+        retval = scsi_nonblockable_ioctl(STp->device, cmd_in, p,
+                                        file->f_flags & O_NDELAY);
         if (!scsi_block_when_processing_errors(STp->device) || retval != -ENODEV)
                 goto out;
         retval = 0;
@@ -3567,8 +3568,8 @@ static long st_ioctl(struct file *file, unsigned int cmd_in, unsigned long arg)
                             !capable(CAP_SYS_RAWIO))
                                 i = -EPERM;
                         else
-                                i = scsi_cmd_ioctl(file, STp->disk->queue,
-                                                   STp->disk, cmd_in, p);
+                                i = scsi_cmd_ioctl(STp->disk->queue, STp->disk,
+                                                   file->f_mode, cmd_in, p);
                         if (i != -ENOTTY)
                                 return i;
                         break;