1 files changed, 29 insertions, 209 deletions

diff --git a/drivers/ide/ide.c b/drivers/ide/ide.c
index 772451600e4d..9dcf5aed92cb 100644
--- a/drivers/ide/ide.c
+++ b/drivers/ide/ide.c
@@ -44,8 +44,6 @@
  *  inspiration from lots of linux users, esp.  hamish@zot.apana.org.au
  */
 
-#define _IDE_C                  /* Tell ide.h it's really us */
-
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/string.h>
@@ -58,6 +56,7 @@
 #include <linux/init.h>
 #include <linux/pci.h>
 #include <linux/ide.h>
+#include <linux/hdreg.h>
 #include <linux/completion.h>
 #include <linux/device.h>
 
@@ -97,8 +96,6 @@ void ide_init_port_data(ide_hwif_t *hwif, unsigned int index)
         hwif->name[2]   = 'e';
         hwif->name[3]   = '0' + index;
 
-        hwif->bus_state = BUSSTATE_ON;
-
         init_completion(&hwif->gendev_rel_comp);
 
         hwif->tp_ops = &default_tp_ops;
@@ -119,7 +116,7 @@ static void ide_port_init_devices_data(ide_hwif_t *hwif)
                 drive->media                    = ide_disk;
                 drive->select.all               = (unit<<4)|0xa0;
                 drive->hwif                     = hwif;
-                drive->ready_stat               = READY_STAT;
+                drive->ready_stat               = ATA_DRDY;
                 drive->bad_wstat                = BAD_W_STAT;
                 drive->special.b.recalibrate    = 1;
                 drive->special.b.set_geometry   = 1;
@@ -253,42 +250,9 @@ void ide_init_port_hw(ide_hwif_t *hwif, hw_regs_t *hw)
 
 DEFINE_MUTEX(ide_setting_mtx);
 
-EXPORT_SYMBOL_GPL(ide_setting_mtx);
-
-/**
- *      ide_spin_wait_hwgroup   -       wait for group
- *      @drive: drive in the group
- *
- *      Wait for an IDE device group to go non busy and then return
- *      holding the ide_lock which guards the hwgroup->busy status
- *      and right to use it.
- */
+ide_devset_get(io_32bit, io_32bit);
 
-int ide_spin_wait_hwgroup (ide_drive_t *drive)
-{
-        ide_hwgroup_t *hwgroup = HWGROUP(drive);
-        unsigned long timeout = jiffies + (3 * HZ);
-
-        spin_lock_irq(&ide_lock);
-
-        while (hwgroup->busy) {
-                unsigned long lflags;
-                spin_unlock_irq(&ide_lock);
-                local_irq_set(lflags);
-                if (time_after(jiffies, timeout)) {
-                        local_irq_restore(lflags);
-                        printk(KERN_ERR "%s: channel busy\n", drive->name);
-                        return -EBUSY;
-                }
-                local_irq_restore(lflags);
-                spin_lock_irq(&ide_lock);
-        }
-        return 0;
-}
-
-EXPORT_SYMBOL(ide_spin_wait_hwgroup);
-
-int set_io_32bit(ide_drive_t *drive, int arg)
+static int set_io_32bit(ide_drive_t *drive, int arg)
 {
         if (drive->no_io_32bit)
                 return -EPERM;
@@ -296,53 +260,39 @@ int set_io_32bit(ide_drive_t *drive, int arg)
         if (arg < 0 || arg > 1 + (SUPPORT_VLB_SYNC << 1))
                 return -EINVAL;
 
-        if (ide_spin_wait_hwgroup(drive))
-                return -EBUSY;
-
         drive->io_32bit = arg;
 
-        spin_unlock_irq(&ide_lock);
-
         return 0;
 }
 
+ide_devset_get(ksettings, keep_settings);
+
 static int set_ksettings(ide_drive_t *drive, int arg)
 {
         if (arg < 0 || arg > 1)
                 return -EINVAL;
 
-        if (ide_spin_wait_hwgroup(drive))
-                return -EBUSY;
         drive->keep_settings = arg;
-        spin_unlock_irq(&ide_lock);
 
         return 0;
 }
 
-int set_using_dma(ide_drive_t *drive, int arg)
+ide_devset_get(using_dma, using_dma);
+
+static int set_using_dma(ide_drive_t *drive, int arg)
 {
 #ifdef CONFIG_BLK_DEV_IDEDMA
-        ide_hwif_t *hwif = drive->hwif;
         int err = -EPERM;
 
         if (arg < 0 || arg > 1)
                 return -EINVAL;
 
-        if (!drive->id || !(drive->id->capability & 1))
+        if (ata_id_has_dma(drive->id) == 0)
                 goto out;
 
-        if (hwif->dma_ops == NULL)
+        if (drive->hwif->dma_ops == NULL)
                 goto out;
 
-        err = -EBUSY;
-        if (ide_spin_wait_hwgroup(drive))
-                goto out;
-        /*
-         * set ->busy flag, unlock and let it ride
-         */
-        hwif->hwgroup->busy = 1;
-        spin_unlock_irq(&ide_lock);
-
         err = 0;
 
         if (arg) {
@@ -351,12 +301,6 @@ int set_using_dma(ide_drive_t *drive, int arg)
         } else
                 ide_dma_off(drive);
 
-        /*
-         * lock, clear ->busy flag and unlock before leaving
-         */
-        spin_lock_irq(&ide_lock);
-        hwif->hwgroup->busy = 0;
-        spin_unlock_irq(&ide_lock);
 out:
         return err;
 #else
@@ -367,7 +311,7 @@ out:
 #endif
 }
 
-int set_pio_mode(ide_drive_t *drive, int arg)
+static int set_pio_mode(ide_drive_t *drive, int arg)
 {
         struct request *rq;
         ide_hwif_t *hwif = drive->hwif;
@@ -395,6 +339,8 @@ int set_pio_mode(ide_drive_t *drive, int arg)
         return 0;
 }
 
+ide_devset_get(unmaskirq, unmask);
+
 static int set_unmaskirq(ide_drive_t *drive, int arg)
 {
         if (drive->no_unmask)
@@ -403,14 +349,20 @@ static int set_unmaskirq(ide_drive_t *drive, int arg)
         if (arg < 0 || arg > 1)
                 return -EINVAL;
 
-        if (ide_spin_wait_hwgroup(drive))
-                return -EBUSY;
         drive->unmask = arg;
-        spin_unlock_irq(&ide_lock);
 
         return 0;
 }
 
+#define ide_gen_devset_rw(_name, _func) \
+__IDE_DEVSET(_name, DS_SYNC, get_##_func, set_##_func)
+
+ide_gen_devset_rw(io_32bit, io_32bit);
+ide_gen_devset_rw(keepsettings, ksettings);
+ide_gen_devset_rw(unmaskirq, unmaskirq);
+ide_gen_devset_rw(using_dma, using_dma);
+__IDE_DEVSET(pio_mode, 0, NULL, set_pio_mode);
+
 static int generic_ide_suspend(struct device *dev, pm_message_t mesg)
 {
         ide_drive_t *drive = dev->driver_data;
@@ -486,138 +438,6 @@ static int generic_ide_resume(struct device *dev)
         return err;
 }
 
-static int generic_drive_reset(ide_drive_t *drive)
-{
-        struct request *rq;
-        int ret = 0;
-
-        rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
-        rq->cmd_type = REQ_TYPE_SPECIAL;
-        rq->cmd_len = 1;
-        rq->cmd[0] = REQ_DRIVE_RESET;
-        rq->cmd_flags |= REQ_SOFTBARRIER;
-        if (blk_execute_rq(drive->queue, NULL, rq, 1))
-                ret = rq->errors;
-        blk_put_request(rq);
-        return ret;
-}
-
-int generic_ide_ioctl(ide_drive_t *drive, struct file *file, struct block_device *bdev,
-                        unsigned int cmd, unsigned long arg)
-{
-        unsigned long flags;
-        ide_driver_t *drv;
-        void __user *p = (void __user *)arg;
-        int err = 0, (*setfunc)(ide_drive_t *, int);
-        u8 *val;
-
-        switch (cmd) {
-        case HDIO_GET_32BIT:        val = &drive->io_32bit;      goto read_val;
-        case HDIO_GET_KEEPSETTINGS: val = &drive->keep_settings; goto read_val;
-        case HDIO_GET_UNMASKINTR:   val = &drive->unmask;        goto read_val;
-        case HDIO_GET_DMA:          val = &drive->using_dma;     goto read_val;
-        case HDIO_SET_32BIT:        setfunc = set_io_32bit;      goto set_val;
-        case HDIO_SET_KEEPSETTINGS: setfunc = set_ksettings;     goto set_val;
-        case HDIO_SET_PIO_MODE:     setfunc = set_pio_mode;      goto set_val;
-        case HDIO_SET_UNMASKINTR:   setfunc = set_unmaskirq;     goto set_val;
-        case HDIO_SET_DMA:          setfunc = set_using_dma;     goto set_val;
-        }
-
-        switch (cmd) {
-                case HDIO_OBSOLETE_IDENTITY:
-                case HDIO_GET_IDENTITY:
-                        if (bdev != bdev->bd_contains)
-                                return -EINVAL;
-                        if (drive->id_read == 0)
-                                return -ENOMSG;
-                        if (copy_to_user(p, drive->id, (cmd == HDIO_GET_IDENTITY) ? sizeof(*drive->id) : 142))
-                                return -EFAULT;
-                        return 0;
-
-                case HDIO_GET_NICE:
-                        return put_user(drive->dsc_overlap      <<      IDE_NICE_DSC_OVERLAP    |
-                                        drive->atapi_overlap    <<      IDE_NICE_ATAPI_OVERLAP  |
-                                        drive->nice1 << IDE_NICE_1,
-                                        (long __user *) arg);
-#ifdef CONFIG_IDE_TASK_IOCTL
-                case HDIO_DRIVE_TASKFILE:
-                        if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
-                                return -EACCES;
-                        switch(drive->media) {
-                                case ide_disk:
-                                        return ide_taskfile_ioctl(drive, cmd, arg);
-                                default:
-                                        return -ENOMSG;
-                        }
-#endif /* CONFIG_IDE_TASK_IOCTL */
-
-                case HDIO_DRIVE_CMD:
-                        if (!capable(CAP_SYS_RAWIO))
-                                return -EACCES;
-                        return ide_cmd_ioctl(drive, cmd, arg);
-
-                case HDIO_DRIVE_TASK:
-                        if (!capable(CAP_SYS_RAWIO))
-                                return -EACCES;
-                        return ide_task_ioctl(drive, cmd, arg);
-                case HDIO_SET_NICE:
-                        if (!capable(CAP_SYS_ADMIN)) return -EACCES;
-                        if (arg != (arg & ((1 << IDE_NICE_DSC_OVERLAP) | (1 << IDE_NICE_1))))
-                                return -EPERM;
-                        drive->dsc_overlap = (arg >> IDE_NICE_DSC_OVERLAP) & 1;
-                        drv = *(ide_driver_t **)bdev->bd_disk->private_data;
-                        if (drive->dsc_overlap && !drv->supports_dsc_overlap) {
-                                drive->dsc_overlap = 0;
-                                return -EPERM;
-                        }
-                        drive->nice1 = (arg >> IDE_NICE_1) & 1;
-                        return 0;
-                case HDIO_DRIVE_RESET:
-                        if (!capable(CAP_SYS_ADMIN))
-                                return -EACCES;
-
-                        return generic_drive_reset(drive);
-
-                case HDIO_GET_BUSSTATE:
-                        if (!capable(CAP_SYS_ADMIN))
-                                return -EACCES;
-                        if (put_user(HWIF(drive)->bus_state, (long __user *)arg))
-                                return -EFAULT;
-                        return 0;
-
-                case HDIO_SET_BUSSTATE:
-                        if (!capable(CAP_SYS_ADMIN))
-                                return -EACCES;
-                        return -EOPNOTSUPP;
-                default:
-                        return -EINVAL;
-        }
-
-read_val:
-        mutex_lock(&ide_setting_mtx);
-        spin_lock_irqsave(&ide_lock, flags);
-        err = *val;
-        spin_unlock_irqrestore(&ide_lock, flags);
-        mutex_unlock(&ide_setting_mtx);
-        return err >= 0 ? put_user(err, (long __user *)arg) : err;
-
-set_val:
-        if (bdev != bdev->bd_contains)
-                err = -EINVAL;
-        else {
-                if (!capable(CAP_SYS_ADMIN))
-                        err = -EACCES;
-                else {
-                        mutex_lock(&ide_setting_mtx);
-                        err = setfunc(drive, arg);
-                        mutex_unlock(&ide_setting_mtx);
-                }
-        }
-        return err;
-}
-
-EXPORT_SYMBOL(generic_ide_ioctl);
-
 /**
  * ide_device_get       -       get an additional reference to a ide_drive_t
  * @drive:      device to get a reference to
@@ -710,21 +530,21 @@ static ssize_t model_show(struct device *dev, struct device_attribute *attr,
                           char *buf)
 {
         ide_drive_t *drive = to_ide_device(dev);
-        return sprintf(buf, "%s\n", drive->id->model);
+        return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_PROD]);
 }
 
 static ssize_t firmware_show(struct device *dev, struct device_attribute *attr,
                              char *buf)
 {
         ide_drive_t *drive = to_ide_device(dev);
-        return sprintf(buf, "%s\n", drive->id->fw_rev);
+        return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_FW_REV]);
 }
 
 static ssize_t serial_show(struct device *dev, struct device_attribute *attr,
                            char *buf)
 {
         ide_drive_t *drive = to_ide_device(dev);
-        return sprintf(buf, "%s\n", drive->id->serial_no);
+        return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_SERNO]);
 }
 
 static struct device_attribute ide_dev_attrs[] = {
@@ -841,7 +661,7 @@ MODULE_PARM_DESC(noprobe, "skip probing for a device");
 static unsigned int ide_nowerr;
 
 module_param_call(nowerr, ide_set_dev_param_mask, NULL, &ide_nowerr, 0);
-MODULE_PARM_DESC(nowerr, "ignore the WRERR_STAT bit for a device");
+MODULE_PARM_DESC(nowerr, "ignore the ATA_DF bit for a device");
 
 static unsigned int ide_cdroms;
 
@@ -906,7 +726,7 @@ static void ide_dev_apply_params(ide_drive_t *drive)
                 drive->noprobe = 1;
         }
         if (ide_nowerr & (1 << i)) {
-                printk(KERN_INFO "ide: ignoring the WRERR_STAT bit for %s\n",
+                printk(KERN_INFO "ide: ignoring the ATA_DF bit for %s\n",
                                  drive->name);
                 drive->bad_wstat = BAD_R_STAT;
         }
@@ -927,7 +747,7 @@ static void ide_dev_apply_params(ide_drive_t *drive)
                                  drive->cyl, drive->head, drive->sect);
                 drive->present = 1;
                 drive->media = ide_disk;
-                drive->ready_stat = READY_STAT;
+                drive->ready_stat = ATA_DRDY;
         }
 }