1 files changed, 137 insertions, 218 deletions

diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index 07ef88bd109b..01846f244b40 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -30,10 +30,8 @@
 #include <linux/delay.h>
 #include <linux/mutex.h>
 #include <linux/leds.h>
-
-#define _IDE_DISK
-
 #include <linux/ide.h>
+#include <linux/hdreg.h>
 
 #include <asm/byteorder.h>
 #include <asm/irq.h>
@@ -41,6 +39,12 @@
 #include <asm/io.h>
 #include <asm/div64.h>
 
+#if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
+#define IDE_DISK_MINORS         (1 << PARTN_BITS)
+#else
+#define IDE_DISK_MINORS         0
+#endif
+
 struct ide_disk_obj {
         ide_drive_t     *drive;
         ide_driver_t    *driver;
@@ -84,68 +88,19 @@ static void ide_disk_put(struct ide_disk_obj *idkp)
         mutex_unlock(&idedisk_ref_mutex);
 }
 
-/*
- * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
- * value for this drive (from its reported identification information).
- *
- * Returns:     1 if lba_capacity looks sensible
- *              0 otherwise
- *
- * It is called only once for each drive.
- */
-static int lba_capacity_is_ok(struct hd_driveid *id)
-{
-        unsigned long lba_sects, chs_sects, head, tail;
-
-        /* No non-LBA info .. so valid! */
-        if (id->cyls == 0)
-                return 1;
-
-        /*
-         * The ATA spec tells large drives to return
-         * C/H/S = 16383/16/63 independent of their size.
-         * Some drives can be jumpered to use 15 heads instead of 16.
-         * Some drives can be jumpered to use 4092 cyls instead of 16383.
-         */
-        if ((id->cyls == 16383
-             || (id->cyls == 4092 && id->cur_cyls == 16383)) &&
-            id->sectors == 63 &&
-            (id->heads == 15 || id->heads == 16) &&
-            (id->lba_capacity >= 16383*63*id->heads))
-                return 1;
-
-        lba_sects   = id->lba_capacity;
-        chs_sects   = id->cyls * id->heads * id->sectors;
-
-        /* perform a rough sanity check on lba_sects:  within 10% is OK */
-        if ((lba_sects - chs_sects) < chs_sects/10)
-                return 1;
-
-        /* some drives have the word order reversed */
-        head = ((lba_sects >> 16) & 0xffff);
-        tail = (lba_sects & 0xffff);
-        lba_sects = (head | (tail << 16));
-        if ((lba_sects - chs_sects) < chs_sects/10) {
-                id->lba_capacity = lba_sects;
-                return 1;       /* lba_capacity is (now) good */
-        }
-
-        return 0;       /* lba_capacity value may be bad */
-}
-
 static const u8 ide_rw_cmds[] = {
-        WIN_MULTREAD,
-        WIN_MULTWRITE,
-        WIN_MULTREAD_EXT,
-        WIN_MULTWRITE_EXT,
-        WIN_READ,
-        WIN_WRITE,
-        WIN_READ_EXT,
-        WIN_WRITE_EXT,
-        WIN_READDMA,
-        WIN_WRITEDMA,
-        WIN_READDMA_EXT,
-        WIN_WRITEDMA_EXT,
+        ATA_CMD_READ_MULTI,
+        ATA_CMD_WRITE_MULTI,
+        ATA_CMD_READ_MULTI_EXT,
+        ATA_CMD_WRITE_MULTI_EXT,
+        ATA_CMD_PIO_READ,
+        ATA_CMD_PIO_WRITE,
+        ATA_CMD_PIO_READ_EXT,
+        ATA_CMD_PIO_WRITE_EXT,
+        ATA_CMD_READ,
+        ATA_CMD_WRITE,
+        ATA_CMD_READ_EXT,
+        ATA_CMD_WRITE_EXT,
 };
 
 static const u8 ide_data_phases[] = {
@@ -316,9 +271,9 @@ static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
         /* Create IDE/ATA command request structure */
         memset(&args, 0, sizeof(ide_task_t));
         if (lba48)
-                tf->command = WIN_READ_NATIVE_MAX_EXT;
+                tf->command = ATA_CMD_READ_NATIVE_MAX_EXT;
         else
-                tf->command = WIN_READ_NATIVE_MAX;
+                tf->command = ATA_CMD_READ_NATIVE_MAX;
         tf->device  = ATA_LBA;
         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
         if (lba48)
@@ -353,10 +308,10 @@ static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
                 tf->hob_lbal = (addr_req >>= 8) & 0xff;
                 tf->hob_lbam = (addr_req >>= 8) & 0xff;
                 tf->hob_lbah = (addr_req >>= 8) & 0xff;
-                tf->command  = WIN_SET_MAX_EXT;
+                tf->command  = ATA_CMD_SET_MAX_EXT;
         } else {
                 tf->device   = (addr_req >>= 8) & 0x0f;
-                tf->command  = WIN_SET_MAX;
+                tf->command  = ATA_CMD_SET_MAX;
         }
         tf->device |= ATA_LBA;
         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
@@ -379,25 +334,6 @@ static unsigned long long sectors_to_MB(unsigned long long n)
 }
 
 /*
- * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
- * so on non-buggy drives we need test only one.
- * However, we should also check whether these fields are valid.
- */
-static inline int idedisk_supports_hpa(const struct hd_driveid *id)
-{
-        return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
-}
-
-/*
- * The same here.
- */
-static inline int idedisk_supports_lba48(const struct hd_driveid *id)
-{
-        return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
-               && id->lba_capacity_2;
-}
-
-/*
  * Some disks report total number of sectors instead of
  * maximum sector address.  We list them here.
  */
@@ -411,7 +347,7 @@ static const struct drive_list_entry hpa_list[] = {
 static void idedisk_check_hpa(ide_drive_t *drive)
 {
         unsigned long long capacity, set_max;
-        int lba48 = idedisk_supports_lba48(drive->id);
+        int lba48 = ata_id_lba48_enabled(drive->id);
 
         capacity = drive->capacity64;
 
@@ -447,23 +383,23 @@ static void idedisk_check_hpa(ide_drive_t *drive)
 
 static void init_idedisk_capacity(ide_drive_t *drive)
 {
-        struct hd_driveid *id = drive->id;
+        u16 *id = drive->id;
         /*
          * If this drive supports the Host Protected Area feature set,
          * then we may need to change our opinion about the drive's capacity.
          */
-        int hpa = idedisk_supports_hpa(id);
+        int hpa = ata_id_hpa_enabled(id);
 
-        if (idedisk_supports_lba48(id)) {
+        if (ata_id_lba48_enabled(id)) {
                 /* drive speaks 48-bit LBA */
                 drive->select.b.lba = 1;
-                drive->capacity64 = id->lba_capacity_2;
+                drive->capacity64 = ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
                 if (hpa)
                         idedisk_check_hpa(drive);
-        } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
+        } else if (ata_id_has_lba(id) && ata_id_is_lba_capacity_ok(id)) {
                 /* drive speaks 28-bit LBA */
                 drive->select.b.lba = 1;
-                drive->capacity64 = id->lba_capacity;
+                drive->capacity64 = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
                 if (hpa)
                         idedisk_check_hpa(drive);
         } else {
@@ -474,7 +410,7 @@ static void init_idedisk_capacity(ide_drive_t *drive)
 
 static sector_t idedisk_capacity(ide_drive_t *drive)
 {
-        return drive->capacity64 - drive->sect0;
+        return drive->capacity64;
 }
 
 #ifdef CONFIG_IDE_PROC_FS
@@ -484,10 +420,10 @@ static int smart_enable(ide_drive_t *drive)
         struct ide_taskfile *tf = &args.tf;
 
         memset(&args, 0, sizeof(ide_task_t));
-        tf->feature = SMART_ENABLE;
-        tf->lbam    = SMART_LCYL_PASS;
-        tf->lbah    = SMART_HCYL_PASS;
-        tf->command = WIN_SMART;
+        tf->feature = ATA_SMART_ENABLE;
+        tf->lbam    = ATA_SMART_LBAM_PASS;
+        tf->lbah    = ATA_SMART_LBAH_PASS;
+        tf->command = ATA_CMD_SMART;
         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
         return ide_no_data_taskfile(drive, &args);
 }
@@ -500,9 +436,9 @@ static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
         memset(&args, 0, sizeof(ide_task_t));
         tf->feature = sub_cmd;
         tf->nsect   = 0x01;
-        tf->lbam    = SMART_LCYL_PASS;
-        tf->lbah    = SMART_HCYL_PASS;
-        tf->command = WIN_SMART;
+        tf->lbam    = ATA_SMART_LBAM_PASS;
+        tf->lbah    = ATA_SMART_LBAH_PASS;
+        tf->command = ATA_CMD_SMART;
         args.tf_flags   = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
         args.data_phase = TASKFILE_IN;
         (void) smart_enable(drive);
@@ -517,7 +453,7 @@ static int proc_idedisk_read_cache
         int             len;
 
         if (drive->id_read)
-                len = sprintf(out, "%i\n", drive->id->buf_size / 2);
+                len = sprintf(out, "%i\n", drive->id[ATA_ID_BUF_SIZE] / 2);
         else
                 len = sprintf(out, "(none)\n");
 
@@ -543,13 +479,14 @@ static int proc_idedisk_read_smart(char *page, char **start, off_t off,
 
         if (get_smart_data(drive, page, sub_cmd) == 0) {
                 unsigned short *val = (unsigned short *) page;
-                char *out = ((char *)val) + (SECTOR_WORDS * 4);
+                char *out = (char *)val + SECTOR_SIZE;
+
                 page = out;
                 do {
                         out += sprintf(out, "%04x%c", le16_to_cpu(*val),
                                        (++i & 7) ? ' ' : '\n');
                         val += 1;
-                } while (i < (SECTOR_WORDS * 2));
+                } while (i < SECTOR_SIZE / 2);
                 len = out - page;
         }
 
@@ -560,14 +497,14 @@ static int proc_idedisk_read_sv
         (char *page, char **start, off_t off, int count, int *eof, void *data)
 {
         return proc_idedisk_read_smart(page, start, off, count, eof, data,
-                                       SMART_READ_VALUES);
+                                       ATA_SMART_READ_VALUES);
 }
 
 static int proc_idedisk_read_st
         (char *page, char **start, off_t off, int count, int *eof, void *data)
 {
         return proc_idedisk_read_smart(page, start, off, count, eof, data,
-                                       SMART_READ_THRESHOLDS);
+                                       ATA_SMART_READ_THRESHOLDS);
 }
 
 static ide_proc_entry_t idedisk_proc[] = {
@@ -589,11 +526,11 @@ static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
         BUG_ON(task == NULL);
 
         memset(task, 0, sizeof(*task));
-        if (ide_id_has_flush_cache_ext(drive->id) &&
+        if (ata_id_flush_ext_enabled(drive->id) &&
             (drive->capacity64 >= (1UL << 28)))
-                task->tf.command = WIN_FLUSH_CACHE_EXT;
+                task->tf.command = ATA_CMD_FLUSH_EXT;
         else
-                task->tf.command = WIN_FLUSH_CACHE;
+                task->tf.command = ATA_CMD_FLUSH;
         task->tf_flags   = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
                            IDE_TFLAG_DYN;
         task->data_phase = TASKFILE_NO_DATA;
@@ -603,6 +540,8 @@ static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
         rq->special = task;
 }
 
+ide_devset_get(multcount, mult_count);
+
 /*
  * This is tightly woven into the driver->do_special can not touch.
  * DON'T do it again until a total personality rewrite is committed.
@@ -612,7 +551,7 @@ static int set_multcount(ide_drive_t *drive, int arg)
         struct request *rq;
         int error;
 
-        if (arg < 0 || arg > drive->id->max_multsect)
+        if (arg < 0 || arg > (drive->id[ATA_ID_MAX_MULTSECT] & 0xff))
                 return -EINVAL;
 
         if (drive->special.b.set_multmode)
@@ -629,22 +568,21 @@ static int set_multcount(ide_drive_t *drive, int arg)
         return (drive->mult_count == arg) ? 0 : -EIO;
 }
 
+ide_devset_get(nowerr, nowerr);
+
 static int set_nowerr(ide_drive_t *drive, int arg)
 {
         if (arg < 0 || arg > 1)
                 return -EINVAL;
 
-        if (ide_spin_wait_hwgroup(drive))
-                return -EBUSY;
         drive->nowerr = arg;
         drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
-        spin_unlock_irq(&ide_lock);
         return 0;
 }
 
 static void update_ordered(ide_drive_t *drive)
 {
-        struct hd_driveid *id = drive->id;
+        u16 *id = drive->id;
         unsigned ordered = QUEUE_ORDERED_NONE;
         prepare_flush_fn *prep_fn = NULL;
 
@@ -660,9 +598,9 @@ static void update_ordered(ide_drive_t *drive)
                  * not available so we don't need to recheck that.
                  */
                 capacity = idedisk_capacity(drive);
-                barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
+                barrier = ata_id_flush_enabled(id) && !drive->noflush &&
                         (drive->addressing == 0 || capacity <= (1ULL << 28) ||
-                         ide_id_has_flush_cache_ext(id));
+                         ata_id_flush_ext_enabled(id));
 
                 printk(KERN_INFO "%s: cache flushes %ssupported\n",
                        drive->name, barrier ? "" : "not ");
@@ -677,7 +615,9 @@ static void update_ordered(ide_drive_t *drive)
         blk_queue_ordered(drive->queue, ordered, prep_fn);
 }
 
-static int write_cache(ide_drive_t *drive, int arg)
+ide_devset_get(wcache, wcache);
+
+static int set_wcache(ide_drive_t *drive, int arg)
 {
         ide_task_t args;
         int err = 1;
@@ -685,11 +625,11 @@ static int write_cache(ide_drive_t *drive, int arg)
         if (arg < 0 || arg > 1)
                 return -EINVAL;
 
-        if (ide_id_has_flush_cache(drive->id)) {
+        if (ata_id_flush_enabled(drive->id)) {
                 memset(&args, 0, sizeof(ide_task_t));
                 args.tf.feature = arg ?
-                        SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
-                args.tf.command = WIN_SETFEATURES;
+                        SETFEATURES_WC_ON : SETFEATURES_WC_OFF;
+                args.tf.command = ATA_CMD_SET_FEATURES;
                 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
                 err = ide_no_data_taskfile(drive, &args);
                 if (err == 0)
@@ -706,14 +646,16 @@ static int do_idedisk_flushcache(ide_drive_t *drive)
         ide_task_t args;
 
         memset(&args, 0, sizeof(ide_task_t));
-        if (ide_id_has_flush_cache_ext(drive->id))
-                args.tf.command = WIN_FLUSH_CACHE_EXT;
+        if (ata_id_flush_ext_enabled(drive->id))
+                args.tf.command = ATA_CMD_FLUSH_EXT;
         else
-                args.tf.command = WIN_FLUSH_CACHE;
+                args.tf.command = ATA_CMD_FLUSH;
         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
         return ide_no_data_taskfile(drive, &args);
 }
 
+ide_devset_get(acoustic, acoustic);
+
 static int set_acoustic(ide_drive_t *drive, int arg)
 {
         ide_task_t args;
@@ -722,22 +664,24 @@ static int set_acoustic(ide_drive_t *drive, int arg)
                 return -EINVAL;
 
         memset(&args, 0, sizeof(ide_task_t));
-        args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM;
+        args.tf.feature = arg ? SETFEATURES_AAM_ON : SETFEATURES_AAM_OFF;
         args.tf.nsect   = arg;
-        args.tf.command = WIN_SETFEATURES;
+        args.tf.command = ATA_CMD_SET_FEATURES;
         args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
         ide_no_data_taskfile(drive, &args);
         drive->acoustic = arg;
         return 0;
 }
 
+ide_devset_get(addressing, addressing);
+
 /*
  * drive->addressing:
  *      0: 28-bit
  *      1: 48-bit
  *      2: 48-bit capable doing 28-bit
  */
-static int set_lba_addressing(ide_drive_t *drive, int arg)
+static int set_addressing(ide_drive_t *drive, int arg)
 {
         if (arg < 0 || arg > 2)
                 return -EINVAL;
@@ -747,52 +691,54 @@ static int set_lba_addressing(ide_drive_t *drive, int arg)
         if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
                 return 0;
 
-        if (!idedisk_supports_lba48(drive->id))
+        if (ata_id_lba48_enabled(drive->id) == 0)
                 return -EIO;
+
         drive->addressing = arg;
+
         return 0;
 }
 
+ide_devset_rw(acoustic, acoustic);
+ide_devset_rw(address, addressing);
+ide_devset_rw(multcount, multcount);
+ide_devset_rw(wcache, wcache);
+
+ide_devset_rw_sync(nowerr, nowerr);
+
 #ifdef CONFIG_IDE_PROC_FS
-static void idedisk_add_settings(ide_drive_t *drive)
-{
-        struct hd_driveid *id = drive->id;
-
-        ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1,
-                        &drive->bios_cyl, NULL);
-        ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1,
-                        &drive->bios_head, NULL);
-        ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1,
-                        &drive->bios_sect, NULL);
-        ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1,
-                        &drive->addressing, set_lba_addressing);
-        ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0,
-                        id->max_multsect, 1, 1, &drive->mult_count,
-                        set_multcount);
-        ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1,
-                        &drive->nowerr, set_nowerr);
-        ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1,
-                        &drive->lun, NULL);
-        ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1,
-                        &drive->wcache, write_cache);
-        ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1,
-                        &drive->acoustic, set_acoustic);
-        ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1,
-                        &drive->failures, NULL);
-        ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535,
-                        1, 1, &drive->max_failures, NULL);
-}
-#else
-static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
+ide_devset_rw_field(bios_cyl, bios_cyl);
+ide_devset_rw_field(bios_head, bios_head);
+ide_devset_rw_field(bios_sect, bios_sect);
+ide_devset_rw_field(failures, failures);
+ide_devset_rw_field(lun, lun);
+ide_devset_rw_field(max_failures, max_failures);
+
+static const struct ide_proc_devset idedisk_settings[] = {
+        IDE_PROC_DEVSET(acoustic,       0,   254),
+        IDE_PROC_DEVSET(address,        0,     2),
+        IDE_PROC_DEVSET(bios_cyl,       0, 65535),
+        IDE_PROC_DEVSET(bios_head,      0,   255),
+        IDE_PROC_DEVSET(bios_sect,      0,    63),
+        IDE_PROC_DEVSET(failures,       0, 65535),
+        IDE_PROC_DEVSET(lun,            0,     7),
+        IDE_PROC_DEVSET(max_failures,   0, 65535),
+        IDE_PROC_DEVSET(multcount,      0,    16),
+        IDE_PROC_DEVSET(nowerr,         0,     1),
+        IDE_PROC_DEVSET(wcache,         0,     1),
+        { 0 },
+};
 #endif
 
 static void idedisk_setup(ide_drive_t *drive)
 {
+        struct ide_disk_obj *idkp = drive->driver_data;
         ide_hwif_t *hwif = drive->hwif;
-        struct hd_driveid *id = drive->id;
+        u16 *id = drive->id;
+        char *m = (char *)&id[ATA_ID_PROD];
         unsigned long long capacity;
 
-        idedisk_add_settings(drive);
+        ide_proc_register_driver(drive, idkp->driver);
 
         if (drive->id_read == 0)
                 return;
@@ -801,11 +747,11 @@ static void idedisk_setup(ide_drive_t *drive)
                 /*
                  * Removable disks (eg. SYQUEST); ignore 'WD' drives
                  */
-                if (id->model[0] != 'W' || id->model[1] != 'D')
+                if (m[0] != 'W' || m[1] != 'D')
                         drive->doorlocking = 1;
         }
 
-        (void)set_lba_addressing(drive, 1);
+        (void)set_addressing(drive, 1);
 
         if (drive->addressing == 1) {
                 int max_s = 2048;
@@ -847,8 +793,7 @@ static void idedisk_setup(ide_drive_t *drive)
         capacity = idedisk_capacity(drive);
 
         if (!drive->forced_geom) {
-
-                if (idedisk_supports_lba48(drive->id)) {
+                if (ata_id_lba48_enabled(drive->id)) {
                         /* compatibility */
                         drive->bios_sect = 63;
                         drive->bios_head = 255;
@@ -874,22 +819,22 @@ static void idedisk_setup(ide_drive_t *drive)
                          drive->name, capacity, sectors_to_MB(capacity));
 
         /* Only print cache size when it was specified */
-        if (id->buf_size)
-                printk(KERN_CONT " w/%dKiB Cache", id->buf_size / 2);
+        if (id[ATA_ID_BUF_SIZE])
+                printk(KERN_CONT " w/%dKiB Cache", id[ATA_ID_BUF_SIZE] / 2);
 
         printk(KERN_CONT ", CHS=%d/%d/%d\n",
                          drive->bios_cyl, drive->bios_head, drive->bios_sect);
 
         /* write cache enabled? */
-        if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
+        if ((id[ATA_ID_CSFO] & 1) || ata_id_wcache_enabled(id))
                 drive->wcache = 1;
 
-        write_cache(drive, 1);
+        set_wcache(drive, 1);
 }
 
 static void ide_cacheflush_p(ide_drive_t *drive)
 {
-        if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
+        if (!drive->wcache || ata_id_flush_enabled(drive->id) == 0)
                 return;
 
         if (do_idedisk_flushcache(drive))
@@ -931,7 +876,7 @@ static int ide_disk_probe(ide_drive_t *drive);
  */
 static void ide_disk_resume(ide_drive_t *drive)
 {
-        if (idedisk_supports_hpa(drive->id))
+        if (ata_id_hpa_enabled(drive->id))
                 init_idedisk_capacity(drive);
 }
 
@@ -974,12 +919,12 @@ static ide_driver_t idedisk_driver = {
         .shutdown               = ide_device_shutdown,
         .version                = IDEDISK_VERSION,
         .media                  = ide_disk,
-        .supports_dsc_overlap   = 0,
         .do_request             = ide_do_rw_disk,
         .end_request            = ide_end_request,
         .error                  = __ide_error,
 #ifdef CONFIG_IDE_PROC_FS
         .proc                   = idedisk_proc,
+        .settings               = idedisk_settings,
 #endif
 };
 
@@ -988,7 +933,7 @@ static int idedisk_set_doorlock(ide_drive_t *drive, int on)
         ide_task_t task;
 
         memset(&task, 0, sizeof(task));
-        task.tf.command = on ? WIN_DOORLOCK : WIN_DOORUNLOCK;
+        task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
         task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
 
         return ide_no_data_taskfile(drive, &task);
@@ -1053,52 +998,28 @@ static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
         return 0;
 }
 
+static const struct ide_ioctl_devset ide_disk_ioctl_settings[] = {
+{ HDIO_GET_ADDRESS,     HDIO_SET_ADDRESS,   &ide_devset_address   },
+{ HDIO_GET_MULTCOUNT,   HDIO_SET_MULTCOUNT, &ide_devset_multcount },
+{ HDIO_GET_NOWERR,      HDIO_SET_NOWERR,    &ide_devset_nowerr    },
+{ HDIO_GET_WCACHE,      HDIO_SET_WCACHE,    &ide_devset_wcache    },
+{ HDIO_GET_ACOUSTIC,    HDIO_SET_ACOUSTIC,  &ide_devset_acoustic  },
+{ 0 }
+};
+
 static int idedisk_ioctl(struct inode *inode, struct file *file,
                         unsigned int cmd, unsigned long arg)
 {
-        unsigned long flags;
         struct block_device *bdev = inode->i_bdev;
         struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
         ide_drive_t *drive = idkp->drive;
-        int err, (*setfunc)(ide_drive_t *, int);
-        u8 *val;
-
-        switch (cmd) {
-        case HDIO_GET_ADDRESS:   val = &drive->addressing;      goto read_val;
-        case HDIO_GET_MULTCOUNT: val = &drive->mult_count;      goto read_val;
-        case HDIO_GET_NOWERR:    val = &drive->nowerr;          goto read_val;
-        case HDIO_GET_WCACHE:    val = &drive->wcache;          goto read_val;
-        case HDIO_GET_ACOUSTIC:  val = &drive->acoustic;        goto read_val;
-        case HDIO_SET_ADDRESS:   setfunc = set_lba_addressing;  goto set_val;
-        case HDIO_SET_MULTCOUNT: setfunc = set_multcount;       goto set_val;
-        case HDIO_SET_NOWERR:    setfunc = set_nowerr;          goto set_val;
-        case HDIO_SET_WCACHE:    setfunc = write_cache;         goto set_val;
-        case HDIO_SET_ACOUSTIC:  setfunc = set_acoustic;        goto set_val;
-        }
+        int err;
 
-        return generic_ide_ioctl(drive, file, bdev, cmd, arg);
+        err = ide_setting_ioctl(drive, bdev, cmd, arg, ide_disk_ioctl_settings);
+        if (err != -EOPNOTSUPP)
+                return err;
 
-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;
+        return generic_ide_ioctl(drive, file, bdev, cmd, arg);
 }
 
 static int idedisk_media_changed(struct gendisk *disk)
@@ -1142,8 +1063,7 @@ static int ide_disk_probe(ide_drive_t *drive)
         /* strstr("foo", "") is non-NULL */
         if (!strstr("ide-disk", drive->driver_req))
                 goto failed;
-        if (!drive->present)
-                goto failed;
+
         if (drive->media != ide_disk)
                 goto failed;
 
@@ -1151,15 +1071,12 @@ static int ide_disk_probe(ide_drive_t *drive)
         if (!idkp)
                 goto failed;
 
-        g = alloc_disk_node(1 << PARTN_BITS,
-                        hwif_to_node(drive->hwif));
+        g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
         if (!g)
                 goto out_free_idkp;
 
         ide_init_disk(g, drive);
 
-        ide_proc_register_driver(drive, &idedisk_driver);
-
         kref_init(&idkp->kref);
 
         idkp->drive = drive;
@@ -1178,9 +1095,11 @@ static int ide_disk_probe(ide_drive_t *drive)
         } else
                 drive->attach = 1;
 
-        g->minors = 1 << PARTN_BITS;
+        g->minors = IDE_DISK_MINORS;
         g->driverfs_dev = &drive->gendev;
-        g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
+        g->flags |= GENHD_FL_EXT_DEVT;
+        if (drive->removable)
+                g->flags |= GENHD_FL_REMOVABLE;
         set_capacity(g, idedisk_capacity(drive));
         g->fops = &idedisk_ops;
         add_disk(g);