1 files changed, 533 insertions, 373 deletions

diff --git a/include/linux/ide.h b/include/linux/ide.h
index 87c12ed96954..c47e371554c1 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -8,7 +8,7 @@
 
 #include <linux/init.h>
 #include <linux/ioport.h>
-#include <linux/hdreg.h>
+#include <linux/ata.h>
 #include <linux/blkdev.h>
 #include <linux/proc_fs.h>
 #include <linux/interrupt.h>
@@ -17,6 +17,7 @@
 #include <linux/device.h>
 #include <linux/pci.h>
 #include <linux/completion.h>
+#include <linux/pm.h>
 #ifdef CONFIG_BLK_DEV_IDEACPI
 #include <acpi/acpi.h>
 #endif
@@ -47,12 +48,6 @@ typedef unsigned char	byte;	/* used everywhere */
 #define ERROR_RESET     3       /* Reset controller every 4th retry */
 #define ERROR_RECAL     1       /* Recalibrate every 2nd retry */
 
-/*
- * state flags
- */
-
-#define DMA_PIO_RETRY   1       /* retrying in PIO */
-
 #define HWIF(drive)             ((ide_hwif_t *)((drive)->hwif))
 #define HWGROUP(drive)          ((ide_hwgroup_t *)(HWIF(drive)->hwgroup))
 
@@ -87,12 +82,13 @@ struct ide_io_ports {
 };
 
 #define OK_STAT(stat,good,bad)  (((stat)&((good)|(bad)))==(good))
-#define BAD_R_STAT              (BUSY_STAT   | ERR_STAT)
-#define BAD_W_STAT              (BAD_R_STAT  | WRERR_STAT)
-#define BAD_STAT                (BAD_R_STAT  | DRQ_STAT)
-#define DRIVE_READY             (READY_STAT  | SEEK_STAT)
 
-#define BAD_CRC                 (ABRT_ERR    | ICRC_ERR)
+#define BAD_R_STAT      (ATA_BUSY | ATA_ERR)
+#define BAD_W_STAT      (BAD_R_STAT | ATA_DF)
+#define BAD_STAT        (BAD_R_STAT | ATA_DRQ)
+#define DRIVE_READY     (ATA_DRDY | ATA_DSC)
+
+#define BAD_CRC         (ATA_ABORTED | ATA_ICRC)
 
 #define SATA_NR_PORTS           (3)     /* 16 possible ?? */
 
@@ -125,24 +121,43 @@ struct ide_io_ports {
 #define PARTN_BITS      6       /* number of minor dev bits for partitions */
 #define MAX_DRIVES      2       /* per interface; 2 assumed by lots of code */
 #define SECTOR_SIZE     512
-#define SECTOR_WORDS    (SECTOR_SIZE / 4)       /* number of 32bit words per sector */
+
 #define IDE_LARGE_SEEK(b1,b2,t) (((b1) > (b2) + (t)) || ((b2) > (b1) + (t)))
 
 /*
  * Timeouts for various operations:
  */
-#define WAIT_DRQ        (HZ/10)         /* 100msec - spec allows up to 20ms */
-#define WAIT_READY      (5*HZ)          /* 5sec - some laptops are very slow */
-#define WAIT_PIDENTIFY  (10*HZ) /* 10sec  - should be less than 3ms (?), if all ATAPI CD is closed at boot */
-#define WAIT_WORSTCASE  (30*HZ) /* 30sec  - worst case when spinning up */
-#define WAIT_CMD        (10*HZ) /* 10sec  - maximum wait for an IRQ to happen */
-#define WAIT_MIN_SLEEP  (2*HZ/100)      /* 20msec - minimum sleep time */
+enum {
+        /* spec allows up to 20ms */
+        WAIT_DRQ        = HZ / 10,      /* 100ms */
+        /* some laptops are very slow */
+        WAIT_READY      = 5 * HZ,       /* 5s */
+        /* should be less than 3ms (?), if all ATAPI CD is closed at boot */
+        WAIT_PIDENTIFY  = 10 * HZ,      /* 10s */
+        /* worst case when spinning up */
+        WAIT_WORSTCASE  = 30 * HZ,      /* 30s */
+        /* maximum wait for an IRQ to happen */
+        WAIT_CMD        = 10 * HZ,      /* 10s */
+        /* Some drives require a longer IRQ timeout. */
+        WAIT_FLOPPY_CMD = 50 * HZ,      /* 50s */
+        /*
+         * Some drives (for example, Seagate STT3401A Travan) require a very
+         * long timeout, because they don't return an interrupt or clear their
+         * BSY bit until after the command completes (even retension commands).
+         */
+        WAIT_TAPE_CMD   = 900 * HZ,     /* 900s */
+        /* minimum sleep time */
+        WAIT_MIN_SLEEP  = HZ / 50,      /* 20ms */
+};
 
 /*
  * Op codes for special requests to be handled by ide_special_rq().
  * Values should be in the range of 0x20 to 0x3f.
  */
 #define REQ_DRIVE_RESET         0x20
+#define REQ_DEVSET_EXEC         0x21
+#define REQ_PARK_HEADS          0x22
+#define REQ_UNPARK_HEADS        0x23
 
 /*
  * Check for an interrupt and acknowledge the interrupt status
@@ -249,8 +264,6 @@ static inline int __ide_default_irq(unsigned long base)
  * set_geometry : respecify drive geometry
  * recalibrate  : seek to cyl 0
  * set_multmode : set multmode count
- * set_tune     : tune interface for drive
- * serviced     : service command
  * reserved     : unused
  */
 typedef union {
@@ -259,43 +272,11 @@ typedef union {
                 unsigned set_geometry   : 1;
                 unsigned recalibrate    : 1;
                 unsigned set_multmode   : 1;
-                unsigned set_tune       : 1;
-                unsigned serviced       : 1;
-                unsigned reserved       : 3;
+                unsigned reserved       : 5;
         } b;
 } special_t;
 
 /*
- * ATA-IDE Select Register, aka Device-Head
- *
- * head         : always zeros here
- * unit         : drive select number: 0/1
- * bit5         : always 1
- * lba          : using LBA instead of CHS
- * bit7         : always 1
- */
-typedef union {
-        unsigned all                    : 8;
-        struct {
-#if defined(__LITTLE_ENDIAN_BITFIELD)
-                unsigned head           : 4;
-                unsigned unit           : 1;
-                unsigned bit5           : 1;
-                unsigned lba            : 1;
-                unsigned bit7           : 1;
-#elif defined(__BIG_ENDIAN_BITFIELD)
-                unsigned bit7           : 1;
-                unsigned lba            : 1;
-                unsigned bit5           : 1;
-                unsigned unit           : 1;
-                unsigned head           : 4;
-#else
-#error "Please fix <asm/byteorder.h>"
-#endif
-        } b;
-} select_t, ata_select_t;
-
-/*
  * Status returned from various ide_ functions
  */
 typedef enum {
@@ -303,8 +284,177 @@ typedef enum {
         ide_started,    /* a drive operation was started, handler was set */
 } ide_startstop_t;
 
+enum {
+        IDE_TFLAG_LBA48                 = (1 << 0),
+        IDE_TFLAG_FLAGGED               = (1 << 2),
+        IDE_TFLAG_OUT_DATA              = (1 << 3),
+        IDE_TFLAG_OUT_HOB_FEATURE       = (1 << 4),
+        IDE_TFLAG_OUT_HOB_NSECT         = (1 << 5),
+        IDE_TFLAG_OUT_HOB_LBAL          = (1 << 6),
+        IDE_TFLAG_OUT_HOB_LBAM          = (1 << 7),
+        IDE_TFLAG_OUT_HOB_LBAH          = (1 << 8),
+        IDE_TFLAG_OUT_HOB               = IDE_TFLAG_OUT_HOB_FEATURE |
+                                          IDE_TFLAG_OUT_HOB_NSECT |
+                                          IDE_TFLAG_OUT_HOB_LBAL |
+                                          IDE_TFLAG_OUT_HOB_LBAM |
+                                          IDE_TFLAG_OUT_HOB_LBAH,
+        IDE_TFLAG_OUT_FEATURE           = (1 << 9),
+        IDE_TFLAG_OUT_NSECT             = (1 << 10),
+        IDE_TFLAG_OUT_LBAL              = (1 << 11),
+        IDE_TFLAG_OUT_LBAM              = (1 << 12),
+        IDE_TFLAG_OUT_LBAH              = (1 << 13),
+        IDE_TFLAG_OUT_TF                = IDE_TFLAG_OUT_FEATURE |
+                                          IDE_TFLAG_OUT_NSECT |
+                                          IDE_TFLAG_OUT_LBAL |
+                                          IDE_TFLAG_OUT_LBAM |
+                                          IDE_TFLAG_OUT_LBAH,
+        IDE_TFLAG_OUT_DEVICE            = (1 << 14),
+        IDE_TFLAG_WRITE                 = (1 << 15),
+        IDE_TFLAG_FLAGGED_SET_IN_FLAGS  = (1 << 16),
+        IDE_TFLAG_IN_DATA               = (1 << 17),
+        IDE_TFLAG_CUSTOM_HANDLER        = (1 << 18),
+        IDE_TFLAG_DMA_PIO_FALLBACK      = (1 << 19),
+        IDE_TFLAG_IN_HOB_FEATURE        = (1 << 20),
+        IDE_TFLAG_IN_HOB_NSECT          = (1 << 21),
+        IDE_TFLAG_IN_HOB_LBAL           = (1 << 22),
+        IDE_TFLAG_IN_HOB_LBAM           = (1 << 23),
+        IDE_TFLAG_IN_HOB_LBAH           = (1 << 24),
+        IDE_TFLAG_IN_HOB_LBA            = IDE_TFLAG_IN_HOB_LBAL |
+                                          IDE_TFLAG_IN_HOB_LBAM |
+                                          IDE_TFLAG_IN_HOB_LBAH,
+        IDE_TFLAG_IN_HOB                = IDE_TFLAG_IN_HOB_FEATURE |
+                                          IDE_TFLAG_IN_HOB_NSECT |
+                                          IDE_TFLAG_IN_HOB_LBA,
+        IDE_TFLAG_IN_FEATURE            = (1 << 1),
+        IDE_TFLAG_IN_NSECT              = (1 << 25),
+        IDE_TFLAG_IN_LBAL               = (1 << 26),
+        IDE_TFLAG_IN_LBAM               = (1 << 27),
+        IDE_TFLAG_IN_LBAH               = (1 << 28),
+        IDE_TFLAG_IN_LBA                = IDE_TFLAG_IN_LBAL |
+                                          IDE_TFLAG_IN_LBAM |
+                                          IDE_TFLAG_IN_LBAH,
+        IDE_TFLAG_IN_TF                 = IDE_TFLAG_IN_NSECT |
+                                          IDE_TFLAG_IN_LBA,
+        IDE_TFLAG_IN_DEVICE             = (1 << 29),
+        IDE_TFLAG_HOB                   = IDE_TFLAG_OUT_HOB |
+                                          IDE_TFLAG_IN_HOB,
+        IDE_TFLAG_TF                    = IDE_TFLAG_OUT_TF |
+                                          IDE_TFLAG_IN_TF,
+        IDE_TFLAG_DEVICE                = IDE_TFLAG_OUT_DEVICE |
+                                          IDE_TFLAG_IN_DEVICE,
+        /* force 16-bit I/O operations */
+        IDE_TFLAG_IO_16BIT              = (1 << 30),
+        /* ide_task_t was allocated using kmalloc() */
+        IDE_TFLAG_DYN                   = (1 << 31),
+};
+
+struct ide_taskfile {
+        u8      hob_data;       /*  0: high data byte (for TASKFILE IOCTL) */
+
+        u8      hob_feature;    /*  1-5: additional data to support LBA48 */
+        u8      hob_nsect;
+        u8      hob_lbal;
+        u8      hob_lbam;
+        u8      hob_lbah;
+
+        u8      data;           /*  6: low data byte (for TASKFILE IOCTL) */
+
+        union {                 /*  7: */
+                u8 error;       /*   read:  error */
+                u8 feature;     /*  write: feature */
+        };
+
+        u8      nsect;          /*  8: number of sectors */
+        u8      lbal;           /*  9: LBA low */
+        u8      lbam;           /* 10: LBA mid */
+        u8      lbah;           /* 11: LBA high */
+
+        u8      device;         /* 12: device select */
+
+        union {                 /* 13: */
+                u8 status;      /*  read: status  */
+                u8 command;     /* write: command */
+        };
+};
+
+typedef struct ide_task_s {
+        union {
+                struct ide_taskfile     tf;
+                u8                      tf_array[14];
+        };
+        u32                     tf_flags;
+        int                     data_phase;
+        struct request          *rq;            /* copy of request */
+        void                    *special;       /* valid_t generally */
+} ide_task_t;
+
+/* ATAPI packet command flags */
+enum {
+        /* set when an error is considered normal - no retry (ide-tape) */
+        PC_FLAG_ABORT                   = (1 << 0),
+        PC_FLAG_SUPPRESS_ERROR          = (1 << 1),
+        PC_FLAG_WAIT_FOR_DSC            = (1 << 2),
+        PC_FLAG_DMA_OK                  = (1 << 3),
+        PC_FLAG_DMA_IN_PROGRESS         = (1 << 4),
+        PC_FLAG_DMA_ERROR               = (1 << 5),
+        PC_FLAG_WRITING                 = (1 << 6),
+        /* command timed out */
+        PC_FLAG_TIMEDOUT                = (1 << 7),
+};
+
+/*
+ * With each packet command, we allocate a buffer of IDE_PC_BUFFER_SIZE bytes.
+ * This is used for several packet commands (not for READ/WRITE commands).
+ */
+#define IDE_PC_BUFFER_SIZE      256
+
+struct ide_atapi_pc {
+        /* actual packet bytes */
+        u8 c[12];
+        /* incremented on each retry */
+        int retries;
+        int error;
+
+        /* bytes to transfer */
+        int req_xfer;
+        /* bytes actually transferred */
+        int xferred;
+
+        /* data buffer */
+        u8 *buf;
+        /* current buffer position */
+        u8 *cur_pos;
+        int buf_size;
+        /* missing/available data on the current buffer */
+        int b_count;
+
+        /* the corresponding request */
+        struct request *rq;
+
+        unsigned long flags;
+
+        /*
+         * those are more or less driver-specific and some of them are subject
+         * to change/removal later.
+         */
+        u8 pc_buf[IDE_PC_BUFFER_SIZE];
+
+        /* idetape only */
+        struct idetape_bh *bh;
+        char *b_data;
+
+        /* idescsi only for now */
+        struct scatterlist *sg;
+        unsigned int sg_cnt;
+
+        struct scsi_cmnd *scsi_cmd;
+        void (*done) (struct scsi_cmnd *);
+
+        unsigned long timeout;
+};
+
+struct ide_devset;
 struct ide_driver_s;
-struct ide_settings_s;
 
 #ifdef CONFIG_BLK_DEV_IDEACPI
 struct ide_acpi_drive_link;
@@ -315,10 +465,10 @@ struct ide_acpi_hwif_link;
 enum {
         IDE_AFLAG_DRQ_INTERRUPT         = (1 << 0),
         IDE_AFLAG_MEDIA_CHANGED         = (1 << 1),
-
-        /* ide-cd */
         /* Drive cannot lock the door. */
         IDE_AFLAG_NO_DOORLOCK           = (1 << 2),
+
+        /* ide-cd */
         /* Drive cannot eject the disc. */
         IDE_AFLAG_NO_EJECT              = (1 << 3),
         /* Drive is a pre ATAPI 1.2 drive. */
@@ -354,19 +504,81 @@ enum {
         IDE_AFLAG_CLIK_DRIVE            = (1 << 19),
         /* Requires BH algorithm for packets */
         IDE_AFLAG_ZIP_DRIVE             = (1 << 20),
+        /* Write protect */
+        IDE_AFLAG_WP                    = (1 << 21),
+        /* Supports format progress report */
+        IDE_AFLAG_SRFP                  = (1 << 22),
 
         /* ide-tape */
-        IDE_AFLAG_IGNORE_DSC            = (1 << 21),
+        IDE_AFLAG_IGNORE_DSC            = (1 << 23),
         /* 0 When the tape position is unknown */
-        IDE_AFLAG_ADDRESS_VALID         = (1 << 22),
+        IDE_AFLAG_ADDRESS_VALID         = (1 << 24),
         /* Device already opened */
-        IDE_AFLAG_BUSY                  = (1 << 23),
+        IDE_AFLAG_BUSY                  = (1 << 25),
         /* Attempt to auto-detect the current user block size */
-        IDE_AFLAG_DETECT_BS             = (1 << 24),
+        IDE_AFLAG_DETECT_BS             = (1 << 26),
         /* Currently on a filemark */
-        IDE_AFLAG_FILEMARK              = (1 << 25),
+        IDE_AFLAG_FILEMARK              = (1 << 27),
         /* 0 = no tape is loaded, so we don't rewind after ejecting */
-        IDE_AFLAG_MEDIUM_PRESENT        = (1 << 26)
+        IDE_AFLAG_MEDIUM_PRESENT        = (1 << 28),
+
+        IDE_AFLAG_NO_AUTOCLOSE          = (1 << 29),
+};
+
+/* device flags */
+enum {
+        /* restore settings after device reset */
+        IDE_DFLAG_KEEP_SETTINGS         = (1 << 0),
+        /* device is using DMA for read/write */
+        IDE_DFLAG_USING_DMA             = (1 << 1),
+        /* okay to unmask other IRQs */
+        IDE_DFLAG_UNMASK                = (1 << 2),
+        /* don't attempt flushes */
+        IDE_DFLAG_NOFLUSH               = (1 << 3),
+        /* DSC overlap */
+        IDE_DFLAG_DSC_OVERLAP           = (1 << 4),
+        /* give potential excess bandwidth */
+        IDE_DFLAG_NICE1                 = (1 << 5),
+        /* device is physically present */
+        IDE_DFLAG_PRESENT               = (1 << 6),
+        /* device ejected hint */
+        IDE_DFLAG_DEAD                  = (1 << 7),
+        /* id read from device (synthetic if not set) */
+        IDE_DFLAG_ID_READ               = (1 << 8),
+        IDE_DFLAG_NOPROBE               = (1 << 9),
+        /* need to do check_media_change() */
+        IDE_DFLAG_REMOVABLE             = (1 << 10),
+        /* needed for removable devices */
+        IDE_DFLAG_ATTACH                = (1 << 11),
+        IDE_DFLAG_FORCED_GEOM           = (1 << 12),
+        /* disallow setting unmask bit */
+        IDE_DFLAG_NO_UNMASK             = (1 << 13),
+        /* disallow enabling 32-bit I/O */
+        IDE_DFLAG_NO_IO_32BIT           = (1 << 14),
+        /* for removable only: door lock/unlock works */
+        IDE_DFLAG_DOORLOCKING           = (1 << 15),
+        /* disallow DMA */
+        IDE_DFLAG_NODMA                 = (1 << 16),
+        /* powermanagment told us not to do anything, so sleep nicely */
+        IDE_DFLAG_BLOCKED               = (1 << 17),
+        /* ide-scsi emulation */
+        IDE_DFLAG_SCSI                  = (1 << 18),
+        /* sleeping & sleep field valid */
+        IDE_DFLAG_SLEEPING              = (1 << 19),
+        IDE_DFLAG_POST_RESET            = (1 << 20),
+        IDE_DFLAG_UDMA33_WARNED         = (1 << 21),
+        IDE_DFLAG_LBA48                 = (1 << 22),
+        /* status of write cache */
+        IDE_DFLAG_WCACHE                = (1 << 23),
+        /* used for ignoring ATA_DF */
+        IDE_DFLAG_NOWERR                = (1 << 24),
+        /* retrying in PIO */
+        IDE_DFLAG_DMA_PIO_RETRY         = (1 << 25),
+        IDE_DFLAG_LBA                   = (1 << 26),
+        /* don't unload heads */
+        IDE_DFLAG_NO_UNLOAD             = (1 << 27),
+        /* heads unloaded, please don't reset port */
+        IDE_DFLAG_PARKED                = (1 << 28)
 };
 
 struct ide_drive_s {
@@ -378,72 +590,47 @@ struct ide_drive_s {
         struct request          *rq;    /* current request */
         struct ide_drive_s      *next;  /* circular list of hwgroup drives */
         void            *driver_data;   /* extra driver data */
-        struct hd_driveid       *id;    /* drive model identification info */
+        u16                     *id;    /* identification info */
 #ifdef CONFIG_IDE_PROC_FS
         struct proc_dir_entry *proc;    /* /proc/ide/ directory entry */
-        struct ide_settings_s *settings;/* /proc/ide/ drive settings */
+        const struct ide_proc_devset *settings; /* /proc/ide/ drive settings */
 #endif
         struct hwif_s           *hwif;  /* actually (ide_hwif_t *) */
 
+        unsigned long dev_flags;
+
         unsigned long sleep;            /* sleep until this time */
         unsigned long service_start;    /* time we started last request */
         unsigned long service_time;     /* service time of last request */
         unsigned long timeout;          /* max time to wait for irq */
 
         special_t       special;        /* special action flags */
-        select_t        select;         /* basic drive/head select reg value */
 
-        u8      keep_settings;          /* restore settings after drive reset */
-        u8      using_dma;              /* disk is using dma for read/write */
+        u8      select;                 /* basic drive/head select reg value */
         u8      retry_pio;              /* retrying dma capable host in pio */
-        u8      state;                  /* retry state */
         u8      waiting_for_dma;        /* dma currently in progress */
-        u8      unmask;                 /* okay to unmask other irqs */
-        u8      noflush;                /* don't attempt flushes */
-        u8      dsc_overlap;            /* DSC overlap */
-        u8      nice1;                  /* give potential excess bandwidth */
-
-        unsigned present        : 1;    /* drive is physically present */
-        unsigned dead           : 1;    /* device ejected hint */
-        unsigned id_read        : 1;    /* 1=id read from disk 0 = synthetic */
-        unsigned noprobe        : 1;    /* from:  hdx=noprobe */
-        unsigned removable      : 1;    /* 1 if need to do check_media_change */
-        unsigned attach         : 1;    /* needed for removable devices */
-        unsigned forced_geom    : 1;    /* 1 if hdx=c,h,s was given at boot */
-        unsigned no_unmask      : 1;    /* disallow setting unmask bit */
-        unsigned no_io_32bit    : 1;    /* disallow enabling 32bit I/O */
-        unsigned atapi_overlap  : 1;    /* ATAPI overlap (not supported) */
-        unsigned doorlocking    : 1;    /* for removable only: door lock/unlock works */
-        unsigned nodma          : 1;    /* disallow DMA */
-        unsigned remap_0_to_1   : 1;    /* 0=noremap, 1=remap 0->1 (for EZDrive) */
-        unsigned blocked        : 1;    /* 1=powermanagment told us not to do anything, so sleep nicely */
-        unsigned scsi           : 1;    /* 0=default, 1=ide-scsi emulation */
-        unsigned sleeping       : 1;    /* 1=sleeping & sleep field valid */
-        unsigned post_reset     : 1;
-        unsigned udma33_warned  : 1;
-
-        u8      addressing;     /* 0=28-bit, 1=48-bit, 2=48-bit doing 28-bit */
+        u8      dma;                    /* atapi dma flag */
+
         u8      quirk_list;     /* considered quirky, set for a specific host */
         u8      init_speed;     /* transfer rate set at boot */
         u8      current_speed;  /* current transfer rate set */
         u8      desired_speed;  /* desired transfer rate set */
         u8      dn;             /* now wide spread use */
-        u8      wcache;         /* status of write cache */
         u8      acoustic;       /* acoustic management */
         u8      media;          /* disk, cdrom, tape, floppy, ... */
         u8      ready_stat;     /* min status value for drive ready */
         u8      mult_count;     /* current multiple sector setting */
         u8      mult_req;       /* requested multiple sector setting */
-        u8      tune_req;       /* requested drive tuning setting */
         u8      io_32bit;       /* 0=16-bit, 1=32-bit, 2/3=32bit+sync */
-        u8      bad_wstat;      /* used for ignoring WRERR_STAT */
-        u8      nowerr;         /* used for ignoring WRERR_STAT */
-        u8      sect0;          /* offset of first sector for DM6:DDO */
+        u8      bad_wstat;      /* used for ignoring ATA_DF */
         u8      head;           /* "real" number of heads */
         u8      sect;           /* "real" sectors per track */
         u8      bios_head;      /* BIOS/fdisk/LILO number of heads */
         u8      bios_sect;      /* BIOS/fdisk/LILO sectors per track */
 
+        /* delay this long before sending packet command */
+        u8 pc_delay;
+
         unsigned int    bios_cyl;       /* BIOS/fdisk/LILO number of cyls */
         unsigned int    cyl;            /* "real" number of cyls */
         unsigned int    drive_data;     /* used by set_pio_mode/selectproc */
@@ -455,6 +642,9 @@ struct ide_drive_s {
 
         int             lun;            /* logical unit */
         int             crc_count;      /* crc counter to reduce drive speed */
+
+        unsigned long   debug_mask;     /* debugging levels switch */
+
 #ifdef CONFIG_BLK_DEV_IDEACPI
         struct ide_acpi_drive_link *acpidata;
 #endif
@@ -462,21 +652,32 @@ struct ide_drive_s {
         struct device   gendev;
         struct completion gendev_rel_comp;      /* to deal with device release() */
 
+        /* current packet command */
+        struct ide_atapi_pc *pc;
+
         /* callback for packet commands */
-        void (*pc_callback)(struct ide_drive_s *);
+        void (*pc_callback)(struct ide_drive_s *, int);
+
+        void (*pc_update_buffers)(struct ide_drive_s *, struct ide_atapi_pc *);
+        int  (*pc_io_buffers)(struct ide_drive_s *, struct ide_atapi_pc *,
+                              unsigned int, int);
 
         unsigned long atapi_flags;
+
+        struct ide_atapi_pc request_sense_pc;
+        struct request request_sense_rq;
 };
 
 typedef struct ide_drive_s ide_drive_t;
 
-#define to_ide_device(dev)container_of(dev, ide_drive_t, gendev)
+#define to_ide_device(dev)              container_of(dev, ide_drive_t, gendev)
 
-#define IDE_CHIPSET_PCI_MASK    \
-    ((1<<ide_pci)|(1<<ide_cmd646)|(1<<ide_ali14xx))
-#define IDE_CHIPSET_IS_PCI(c)   ((IDE_CHIPSET_PCI_MASK >> (c)) & 1)
+#define to_ide_drv(obj, cont_type)      \
+        container_of(obj, struct cont_type, kref)
+
+#define ide_drv_g(disk, cont_type)      \
+        container_of((disk)->private_data, struct cont_type, driver)
 
-struct ide_task_s;
 struct ide_port_info;
 
 struct ide_tp_ops {
@@ -510,6 +711,7 @@ extern const struct ide_tp_ops default_tp_ops;
  * @resetproc:          routine to reset controller after a disk reset
  * @maskproc:           special host masking for drive selection
  * @quirkproc:          check host's drive quirk list
+ * @clear_irq:          clear IRQ
  *
  * @mdma_filter:        filter MDMA modes
  * @udma_filter:        filter UDMA modes
@@ -526,6 +728,7 @@ struct ide_port_ops {
         void    (*resetproc)(ide_drive_t *);
         void    (*maskproc)(ide_drive_t *, int);
         void    (*quirkproc)(ide_drive_t *);
+        void    (*clear_irq)(ide_drive_t *);
 
         u8      (*mdma_filter)(ide_drive_t *);
         u8      (*udma_filter)(ide_drive_t *);
@@ -565,7 +768,6 @@ typedef struct hwif_s {
         u8 major;       /* our major number */
         u8 index;       /* 0 for ide0; 1 for ide1; ... */
         u8 channel;     /* for dual-port chips: 0=primary, 1=secondary */
-        u8 bus_state;   /* power state of the IDE bus */
 
         u32 host_flags;
 
@@ -589,12 +791,16 @@ typedef struct hwif_s {
         const struct ide_port_ops       *port_ops;
         const struct ide_dma_ops        *dma_ops;
 
-        void (*ide_dma_clear_irq)(ide_drive_t *drive);
-
         /* dma physical region descriptor table (cpu view) */
         unsigned int    *dmatable_cpu;
         /* dma physical region descriptor table (dma view) */
         dma_addr_t      dmatable_dma;
+
+        /* maximum number of PRD table entries */
+        int prd_max_nents;
+        /* PRD entry size in bytes */
+        int prd_ent_size;
+
         /* Scatter-gather list used to build the above */
         struct scatterlist *sg_table;
         int sg_max_nents;               /* Maximum number of entries in it */
@@ -604,6 +810,8 @@ typedef struct hwif_s {
         /* data phase of the active command (currently only valid for PIO/DMA) */
         int             data_phase;
 
+        struct ide_task_s task;         /* current command */
+
         unsigned int nsect;
         unsigned int nleft;
         struct scatterlist *cursg;
@@ -632,17 +840,18 @@ typedef struct hwif_s {
 
         void            *hwif_data;     /* extra hwif data */
 
-        unsigned dma;
-
 #ifdef CONFIG_BLK_DEV_IDEACPI
         struct ide_acpi_hwif_link *acpidata;
 #endif
 } ____cacheline_internodealigned_in_smp ide_hwif_t;
 
+#define MAX_HOST_PORTS 4
+
 struct ide_host {
-        ide_hwif_t      *ports[MAX_HWIFS];
+        ide_hwif_t      *ports[MAX_HOST_PORTS];
         unsigned int    n_ports;
         struct device   *dev[2];
+        unsigned int    (*init_chipset)(struct pci_dev *);
         unsigned long   host_flags;
         void            *host_priv;
 };
@@ -690,102 +899,116 @@ typedef struct ide_driver_s ide_driver_t;
 
 extern struct mutex ide_setting_mtx;
 
-int set_io_32bit(ide_drive_t *, int);
-int set_pio_mode(ide_drive_t *, int);
-int set_using_dma(ide_drive_t *, int);
+/*
+ * configurable drive settings
+ */
 
-/* ATAPI packet command flags */
-enum {
-        /* set when an error is considered normal - no retry (ide-tape) */
-        PC_FLAG_ABORT                   = (1 << 0),
-        PC_FLAG_SUPPRESS_ERROR          = (1 << 1),
-        PC_FLAG_WAIT_FOR_DSC            = (1 << 2),
-        PC_FLAG_DMA_OK                  = (1 << 3),
-        PC_FLAG_DMA_IN_PROGRESS         = (1 << 4),
-        PC_FLAG_DMA_ERROR               = (1 << 5),
-        PC_FLAG_WRITING                 = (1 << 6),
-        /* command timed out */
-        PC_FLAG_TIMEDOUT                = (1 << 7),
+#define DS_SYNC (1 << 0)
+
+struct ide_devset {
+        int             (*get)(ide_drive_t *);
+        int             (*set)(ide_drive_t *, int);
+        unsigned int    flags;
 };
 
-struct ide_atapi_pc {
-        /* actual packet bytes */
-        u8 c[12];
-        /* incremented on each retry */
-        int retries;
-        int error;
+#define __DEVSET(_flags, _get, _set) { \
+        .flags  = _flags, \
+        .get    = _get, \
+        .set    = _set, \
+}
 
-        /* bytes to transfer */
-        int req_xfer;
-        /* bytes actually transferred */
-        int xferred;
+#define ide_devset_get(name, field) \
+static int get_##name(ide_drive_t *drive) \
+{ \
+        return drive->field; \
+}
 
-        /* data buffer */
-        u8 *buf;
-        /* current buffer position */
-        u8 *cur_pos;
-        int buf_size;
-        /* missing/available data on the current buffer */
-        int b_count;
+#define ide_devset_set(name, field) \
+static int set_##name(ide_drive_t *drive, int arg) \
+{ \
+        drive->field = arg; \
+        return 0; \
+}
 
-        /* the corresponding request */
-        struct request *rq;
+#define ide_devset_get_flag(name, flag) \
+static int get_##name(ide_drive_t *drive) \
+{ \
+        return !!(drive->dev_flags & flag); \
+}
 
-        unsigned long flags;
+#define ide_devset_set_flag(name, flag) \
+static int set_##name(ide_drive_t *drive, int arg) \
+{ \
+        if (arg) \
+                drive->dev_flags |= flag; \
+        else \
+                drive->dev_flags &= ~flag; \
+        return 0; \
+}
 
-        /*
-         * those are more or less driver-specific and some of them are subject
-         * to change/removal later.
-         */
-        u8 pc_buf[256];
+#define __IDE_DEVSET(_name, _flags, _get, _set) \
+const struct ide_devset ide_devset_##_name = \
+        __DEVSET(_flags, _get, _set)
 
-        /* idetape only */
-        struct idetape_bh *bh;
-        char *b_data;
+#define IDE_DEVSET(_name, _flags, _get, _set) \
+static __IDE_DEVSET(_name, _flags, _get, _set)
 
-        /* idescsi only for now */
-        struct scatterlist *sg;
-        unsigned int sg_cnt;
+#define ide_devset_rw(_name, _func) \
+IDE_DEVSET(_name, 0, get_##_func, set_##_func)
 
-        struct scsi_cmnd *scsi_cmd;
-        void (*done) (struct scsi_cmnd *);
+#define ide_devset_w(_name, _func) \
+IDE_DEVSET(_name, 0, NULL, set_##_func)
 
-        unsigned long timeout;
-};
+#define ide_ext_devset_rw(_name, _func) \
+__IDE_DEVSET(_name, 0, get_##_func, set_##_func)
+
+#define ide_ext_devset_rw_sync(_name, _func) \
+__IDE_DEVSET(_name, DS_SYNC, get_##_func, set_##_func)
+
+#define ide_decl_devset(_name) \
+extern const struct ide_devset ide_devset_##_name
+
+ide_decl_devset(io_32bit);
+ide_decl_devset(keepsettings);
+ide_decl_devset(pio_mode);
+ide_decl_devset(unmaskirq);
+ide_decl_devset(using_dma);
 
 #ifdef CONFIG_IDE_PROC_FS
 /*
- * configurable drive settings
+ * /proc/ide interface
  */
 
-#define TYPE_INT        0
-#define TYPE_BYTE       1
-#define TYPE_SHORT      2
+#define ide_devset_rw_field(_name, _field) \
+ide_devset_get(_name, _field); \
+ide_devset_set(_name, _field); \
+IDE_DEVSET(_name, DS_SYNC, get_##_name, set_##_name)
+
+#define ide_devset_rw_flag(_name, _field) \
+ide_devset_get_flag(_name, _field); \
+ide_devset_set_flag(_name, _field); \
+IDE_DEVSET(_name, DS_SYNC, get_##_name, set_##_name)
+
+struct ide_proc_devset {
+        const char              *name;
+        const struct ide_devset *setting;
+        int                     min, max;
+        int                     (*mulf)(ide_drive_t *);
+        int                     (*divf)(ide_drive_t *);
+};
 
-#define SETTING_READ    (1 << 0)
-#define SETTING_WRITE   (1 << 1)
-#define SETTING_RW      (SETTING_READ | SETTING_WRITE)
+#define __IDE_PROC_DEVSET(_name, _min, _max, _mulf, _divf) { \
+        .name = __stringify(_name), \
+        .setting = &ide_devset_##_name, \
+        .min = _min, \
+        .max = _max, \
+        .mulf = _mulf, \
+        .divf = _divf, \
+}
 
-typedef int (ide_procset_t)(ide_drive_t *, int);
-typedef struct ide_settings_s {
-        char                    *name;
-        int                     rw;
-        int                     data_type;
-        int                     min;
-        int                     max;
-        int                     mul_factor;
-        int                     div_factor;
-        void                    *data;
-        ide_procset_t           *set;
-        int                     auto_remove;
-        struct ide_settings_s   *next;
-} ide_settings_t;
-
-int ide_add_setting(ide_drive_t *, const char *, int, int, int, int, int, int, void *, ide_procset_t *set);
+#define IDE_PROC_DEVSET(_name, _min, _max) \
+__IDE_PROC_DEVSET(_name, _min, _max, NULL, NULL)
 
-/*
- * /proc/ide interface
- */
 typedef struct {
         const char      *name;
         mode_t          mode;
@@ -802,8 +1025,6 @@ void ide_proc_unregister_port(ide_hwif_t *);
 void ide_proc_register_driver(ide_drive_t *, ide_driver_t *);
 void ide_proc_unregister_driver(ide_drive_t *, ide_driver_t *);
 
-void ide_add_generic_settings(ide_drive_t *);
-
 read_proc_t proc_ide_read_capacity;
 read_proc_t proc_ide_read_geometry;
 
@@ -831,41 +1052,58 @@ static inline void ide_proc_unregister_device(ide_drive_t *drive) { ; }
 static inline void ide_proc_unregister_port(ide_hwif_t *hwif) { ; }
 static inline void ide_proc_register_driver(ide_drive_t *drive, ide_driver_t *driver) { ; }
 static inline void ide_proc_unregister_driver(ide_drive_t *drive, ide_driver_t *driver) { ; }
-static inline void ide_add_generic_settings(ide_drive_t *drive) { ; }
 #define PROC_IDE_READ_RETURN(page,start,off,count,eof,len) return 0;
 #endif
 
+enum {
+        /* enter/exit functions */
+        IDE_DBG_FUNC =                  (1 << 0),
+        /* sense key/asc handling */
+        IDE_DBG_SENSE =                 (1 << 1),
+        /* packet commands handling */
+        IDE_DBG_PC =                    (1 << 2),
+        /* request handling */
+        IDE_DBG_RQ =                    (1 << 3),
+        /* driver probing/setup */
+        IDE_DBG_PROBE =                 (1 << 4),
+};
+
+/* DRV_NAME has to be defined in the driver before using the macro below */
+#define __ide_debug_log(lvl, fmt, args...)                      \
+{                                                               \
+        if (unlikely(drive->debug_mask & lvl))                  \
+                printk(KERN_INFO DRV_NAME ": " fmt, ## args);   \
+}
+
 /*
- * Power Management step value (rq->pm->pm_step).
- *
- * The step value starts at 0 (ide_pm_state_start_suspend) for a
- * suspend operation or 1000 (ide_pm_state_start_resume) for a
- * resume operation.
+ * Power Management state machine (rq->pm->pm_step).
  *
- * For each step, the core calls the subdriver start_power_step() first.
+ * For each step, the core calls ide_start_power_step() first.
  * This can return:
  *      - ide_stopped : In this case, the core calls us back again unless
  *                      step have been set to ide_power_state_completed.
  *      - ide_started : In this case, the channel is left busy until an
  *                      async event (interrupt) occurs.
- * Typically, start_power_step() will issue a taskfile request with
+ * Typically, ide_start_power_step() will issue a taskfile request with
  * do_rw_taskfile().
  *
- * Upon reception of the interrupt, the core will call complete_power_step()
+ * Upon reception of the interrupt, the core will call ide_complete_power_step()
  * with the error code if any. This routine should update the step value
  * and return. It should not start a new request. The core will call
- * start_power_step for the new step value, unless step have been set to
- * ide_power_state_completed.
- *
- * Subdrivers are expected to define their own additional power
- * steps from 1..999 for suspend and from 1001..1999 for resume,
- * other values are reserved for future use.
+ * ide_start_power_step() for the new step value, unless step have been
+ * set to IDE_PM_COMPLETED.
  */
-
 enum {
-        ide_pm_state_completed          = -1,
-        ide_pm_state_start_suspend      = 0,
-        ide_pm_state_start_resume       = 1000,
+        IDE_PM_START_SUSPEND,
+        IDE_PM_FLUSH_CACHE      = IDE_PM_START_SUSPEND,
+        IDE_PM_STANDBY,
+
+        IDE_PM_START_RESUME,
+        IDE_PM_RESTORE_PIO      = IDE_PM_START_RESUME,
+        IDE_PM_IDLE,
+        IDE_PM_RESTORE_DMA,
+
+        IDE_PM_COMPLETED,
 };
 
 /*
@@ -876,8 +1114,6 @@ enum {
  */
 struct ide_driver_s {
         const char                      *version;
-        u8                              media;
-        unsigned supports_dsc_overlap   : 1;
         ide_startstop_t (*do_request)(ide_drive_t *, struct request *, sector_t);
         int             (*end_request)(ide_drive_t *, int, int);
         ide_startstop_t (*error)(ide_drive_t *, struct request *rq, u8, u8);
@@ -887,7 +1123,8 @@ struct ide_driver_s {
         void            (*resume)(ide_drive_t *);
         void            (*shutdown)(ide_drive_t *);
 #ifdef CONFIG_IDE_PROC_FS
-        ide_proc_entry_t        *proc;
+        ide_proc_entry_t                *proc;
+        const struct ide_proc_devset    *settings;
 #endif
 };
 
@@ -896,7 +1133,17 @@ struct ide_driver_s {
 int ide_device_get(ide_drive_t *);
 void ide_device_put(ide_drive_t *);
 
-int generic_ide_ioctl(ide_drive_t *, struct file *, struct block_device *, unsigned, unsigned long);
+struct ide_ioctl_devset {
+        unsigned int    get_ioctl;
+        unsigned int    set_ioctl;
+        const struct ide_devset *setting;
+};
+
+int ide_setting_ioctl(ide_drive_t *, struct block_device *, unsigned int,
+                      unsigned long, const struct ide_ioctl_devset *);
+
+int generic_ide_ioctl(ide_drive_t *, struct file *, struct block_device *,
+                      unsigned, unsigned long);
 
 extern int ide_vlb_clk;
 extern int ide_pci_clk;
@@ -918,122 +1165,23 @@ ide_startstop_t __ide_error(ide_drive_t *, struct request *, u8, u8);
 
 ide_startstop_t ide_error (ide_drive_t *drive, const char *msg, byte stat);
 
-extern void ide_fix_driveid(struct hd_driveid *);
+void ide_fix_driveid(u16 *);
 
 extern void ide_fixstring(u8 *, const int, const int);
 
+int ide_busy_sleep(ide_hwif_t *, unsigned long, int);
+
 int ide_wait_stat(ide_startstop_t *, ide_drive_t *, u8, u8, unsigned long);
 
 extern ide_startstop_t ide_do_reset (ide_drive_t *);
 
+extern int ide_devset_execute(ide_drive_t *drive,
+                              const struct ide_devset *setting, int arg);
+
 extern void ide_do_drive_cmd(ide_drive_t *, struct request *);
 
 extern void ide_end_drive_cmd(ide_drive_t *, u8, u8);
 
-enum {
-        IDE_TFLAG_LBA48                 = (1 << 0),
-        IDE_TFLAG_FLAGGED               = (1 << 2),
-        IDE_TFLAG_OUT_DATA              = (1 << 3),
-        IDE_TFLAG_OUT_HOB_FEATURE       = (1 << 4),
-        IDE_TFLAG_OUT_HOB_NSECT         = (1 << 5),
-        IDE_TFLAG_OUT_HOB_LBAL          = (1 << 6),
-        IDE_TFLAG_OUT_HOB_LBAM          = (1 << 7),
-        IDE_TFLAG_OUT_HOB_LBAH          = (1 << 8),
-        IDE_TFLAG_OUT_HOB               = IDE_TFLAG_OUT_HOB_FEATURE |
-                                          IDE_TFLAG_OUT_HOB_NSECT |
-                                          IDE_TFLAG_OUT_HOB_LBAL |
-                                          IDE_TFLAG_OUT_HOB_LBAM |
-                                          IDE_TFLAG_OUT_HOB_LBAH,
-        IDE_TFLAG_OUT_FEATURE           = (1 << 9),
-        IDE_TFLAG_OUT_NSECT             = (1 << 10),
-        IDE_TFLAG_OUT_LBAL              = (1 << 11),
-        IDE_TFLAG_OUT_LBAM              = (1 << 12),
-        IDE_TFLAG_OUT_LBAH              = (1 << 13),
-        IDE_TFLAG_OUT_TF                = IDE_TFLAG_OUT_FEATURE |
-                                          IDE_TFLAG_OUT_NSECT |
-                                          IDE_TFLAG_OUT_LBAL |
-                                          IDE_TFLAG_OUT_LBAM |
-                                          IDE_TFLAG_OUT_LBAH,
-        IDE_TFLAG_OUT_DEVICE            = (1 << 14),
-        IDE_TFLAG_WRITE                 = (1 << 15),
-        IDE_TFLAG_FLAGGED_SET_IN_FLAGS  = (1 << 16),
-        IDE_TFLAG_IN_DATA               = (1 << 17),
-        IDE_TFLAG_CUSTOM_HANDLER        = (1 << 18),
-        IDE_TFLAG_DMA_PIO_FALLBACK      = (1 << 19),
-        IDE_TFLAG_IN_HOB_FEATURE        = (1 << 20),
-        IDE_TFLAG_IN_HOB_NSECT          = (1 << 21),
-        IDE_TFLAG_IN_HOB_LBAL           = (1 << 22),
-        IDE_TFLAG_IN_HOB_LBAM           = (1 << 23),
-        IDE_TFLAG_IN_HOB_LBAH           = (1 << 24),
-        IDE_TFLAG_IN_HOB_LBA            = IDE_TFLAG_IN_HOB_LBAL |
-                                          IDE_TFLAG_IN_HOB_LBAM |
-                                          IDE_TFLAG_IN_HOB_LBAH,
-        IDE_TFLAG_IN_HOB                = IDE_TFLAG_IN_HOB_FEATURE |
-                                          IDE_TFLAG_IN_HOB_NSECT |
-                                          IDE_TFLAG_IN_HOB_LBA,
-        IDE_TFLAG_IN_FEATURE            = (1 << 1),
-        IDE_TFLAG_IN_NSECT              = (1 << 25),
-        IDE_TFLAG_IN_LBAL               = (1 << 26),
-        IDE_TFLAG_IN_LBAM               = (1 << 27),
-        IDE_TFLAG_IN_LBAH               = (1 << 28),
-        IDE_TFLAG_IN_LBA                = IDE_TFLAG_IN_LBAL |
-                                          IDE_TFLAG_IN_LBAM |
-                                          IDE_TFLAG_IN_LBAH,
-        IDE_TFLAG_IN_TF                 = IDE_TFLAG_IN_NSECT |
-                                          IDE_TFLAG_IN_LBA,
-        IDE_TFLAG_IN_DEVICE             = (1 << 29),
-        IDE_TFLAG_HOB                   = IDE_TFLAG_OUT_HOB |
-                                          IDE_TFLAG_IN_HOB,
-        IDE_TFLAG_TF                    = IDE_TFLAG_OUT_TF |
-                                          IDE_TFLAG_IN_TF,
-        IDE_TFLAG_DEVICE                = IDE_TFLAG_OUT_DEVICE |
-                                          IDE_TFLAG_IN_DEVICE,
-        /* force 16-bit I/O operations */
-        IDE_TFLAG_IO_16BIT              = (1 << 30),
-        /* ide_task_t was allocated using kmalloc() */
-        IDE_TFLAG_DYN                   = (1 << 31),
-};
-
-struct ide_taskfile {
-        u8      hob_data;       /*  0: high data byte (for TASKFILE IOCTL) */
-
-        u8      hob_feature;    /*  1-5: additional data to support LBA48 */
-        u8      hob_nsect;
-        u8      hob_lbal;
-        u8      hob_lbam;
-        u8      hob_lbah;
-
-        u8      data;           /*  6: low data byte (for TASKFILE IOCTL) */
-
-        union {                 /*  7: */
-                u8 error;       /*   read:  error */
-                u8 feature;     /*  write: feature */
-        };
-
-        u8      nsect;          /*  8: number of sectors */
-        u8      lbal;           /*  9: LBA low */
-        u8      lbam;           /* 10: LBA mid */
-        u8      lbah;           /* 11: LBA high */
-
-        u8      device;         /* 12: device select */
-
-        union {                 /* 13: */
-                u8 status;      /*  read: status  */
-                u8 command;     /* write: command */
-        };
-};
-
-typedef struct ide_task_s {
-        union {
-                struct ide_taskfile     tf;
-                u8                      tf_array[14];
-        };
-        u32                     tf_flags;
-        int                     data_phase;
-        struct request          *rq;            /* copy of request */
-        void                    *special;       /* valid_t generally */
-} ide_task_t;
-
 void ide_tf_dump(const char *, struct ide_taskfile *);
 
 void ide_exec_command(ide_hwif_t *, u8);
@@ -1049,6 +1197,8 @@ void ide_tf_read(ide_drive_t *, ide_task_t *);
 void ide_input_data(ide_drive_t *, struct request *, void *, unsigned int);
 void ide_output_data(ide_drive_t *, struct request *, void *, unsigned int);
 
+int ide_io_buffers(ide_drive_t *, struct ide_atapi_pc *, unsigned int, int);
+
 extern void SELECT_DRIVE(ide_drive_t *);
 void SELECT_MASK(ide_drive_t *, int);
 
@@ -1059,16 +1209,46 @@ extern int drive_is_ready(ide_drive_t *);
 
 void ide_pktcmd_tf_load(ide_drive_t *, u32, u16, u8);
 
-ide_startstop_t ide_pc_intr(ide_drive_t *drive, struct ide_atapi_pc *pc,
-        ide_handler_t *handler, unsigned int timeout, ide_expiry_t *expiry,
-        void (*update_buffers)(ide_drive_t *, struct ide_atapi_pc *),
-        void (*retry_pc)(ide_drive_t *), void (*dsc_handle)(ide_drive_t *),
-        void (*io_buffers)(ide_drive_t *, struct ide_atapi_pc *, unsigned int,
-                           int));
-ide_startstop_t ide_transfer_pc(ide_drive_t *, struct ide_atapi_pc *,
-                                ide_handler_t *, unsigned int, ide_expiry_t *);
-ide_startstop_t ide_issue_pc(ide_drive_t *, struct ide_atapi_pc *,
-                             ide_handler_t *, unsigned int, ide_expiry_t *);
+int ide_check_atapi_device(ide_drive_t *, const char *);
+
+void ide_init_pc(struct ide_atapi_pc *);
+
+/* Disk head parking */
+extern wait_queue_head_t ide_park_wq;
+ssize_t ide_park_show(struct device *dev, struct device_attribute *attr,
+                      char *buf);
+ssize_t ide_park_store(struct device *dev, struct device_attribute *attr,
+                       const char *buf, size_t len);
+
+/*
+ * Special requests for ide-tape block device strategy routine.
+ *
+ * In order to service a character device command, we add special requests to
+ * the tail of our block device request queue and wait for their completion.
+ */
+enum {
+        REQ_IDETAPE_PC1         = (1 << 0), /* packet command (first stage) */
+        REQ_IDETAPE_PC2         = (1 << 1), /* packet command (second stage) */
+        REQ_IDETAPE_READ        = (1 << 2),
+        REQ_IDETAPE_WRITE       = (1 << 3),
+};
+
+int ide_queue_pc_tail(ide_drive_t *, struct gendisk *, struct ide_atapi_pc *);
+
+int ide_do_test_unit_ready(ide_drive_t *, struct gendisk *);
+int ide_do_start_stop(ide_drive_t *, struct gendisk *, int);
+int ide_set_media_lock(ide_drive_t *, struct gendisk *, int);
+void ide_create_request_sense_cmd(ide_drive_t *, struct ide_atapi_pc *);
+void ide_retry_pc(ide_drive_t *, struct gendisk *);
+
+static inline unsigned long ide_scsi_get_timeout(struct ide_atapi_pc *pc)
+{
+        return max_t(unsigned long, WAIT_CMD, pc->timeout - jiffies);
+}
+
+int ide_scsi_expiry(ide_drive_t *);
+
+ide_startstop_t ide_issue_pc(ide_drive_t *, unsigned int, ide_expiry_t *);
 
 ide_startstop_t do_rw_taskfile(ide_drive_t *, ide_task_t *);
 
@@ -1078,8 +1258,6 @@ int ide_raw_taskfile(ide_drive_t *, ide_task_t *, u8 *, u16);
 int ide_no_data_taskfile(ide_drive_t *, ide_task_t *);
 
 int ide_taskfile_ioctl(ide_drive_t *, unsigned int, unsigned long);
-int ide_cmd_ioctl(ide_drive_t *, unsigned int, unsigned long);
-int ide_task_ioctl(ide_drive_t *, unsigned int, unsigned long);
 
 extern int ide_driveid_update(ide_drive_t *);
 extern int ide_config_drive_speed(ide_drive_t *, u8);
@@ -1090,7 +1268,6 @@ extern int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout);
 
 extern void ide_stall_queue(ide_drive_t *drive, unsigned long timeout);
 
-extern int ide_spin_wait_hwgroup(ide_drive_t *);
 extern void ide_timer_expiry(unsigned long);
 extern irqreturn_t ide_intr(int irq, void *dev_id);
 extern void do_ide_request(struct request_queue *);
@@ -1111,7 +1288,6 @@ void ide_setup_pci_noise(struct pci_dev *, const struct ide_port_info *);
 #ifdef CONFIG_BLK_DEV_IDEDMA_PCI
 int ide_pci_set_master(struct pci_dev *, const char *);
 unsigned long ide_pci_dma_base(ide_hwif_t *, const struct ide_port_info *);
-extern const struct ide_dma_ops sff_dma_ops;
 int ide_pci_check_simplex(ide_hwif_t *, const struct ide_port_info *);
 int ide_hwif_setup_dma(ide_hwif_t *, const struct ide_port_info *);
 #else
@@ -1228,6 +1404,14 @@ int ide_pci_init_two(struct pci_dev *, struct pci_dev *,
                      const struct ide_port_info *, void *);
 void ide_pci_remove(struct pci_dev *);
 
+#ifdef CONFIG_PM
+int ide_pci_suspend(struct pci_dev *, pm_message_t);
+int ide_pci_resume(struct pci_dev *);
+#else
+#define ide_pci_suspend NULL
+#define ide_pci_resume NULL
+#endif
+
 void ide_map_sg(ide_drive_t *, struct request *);
 void ide_init_sg_cmd(ide_drive_t *, struct request *);
 
@@ -1239,9 +1423,10 @@ struct drive_list_entry {
         const char *id_firmware;
 };
 
-int ide_in_drive_list(struct hd_driveid *, const struct drive_list_entry *);
+int ide_in_drive_list(u16 *, const struct drive_list_entry *);
 
 #ifdef CONFIG_BLK_DEV_IDEDMA
+int ide_dma_good_drive(ide_drive_t *);
 int __ide_dma_bad_drive(ide_drive_t *);
 int ide_id_dma_bug(ide_drive_t *);
 
@@ -1259,24 +1444,29 @@ int ide_set_dma(ide_drive_t *);
 void ide_check_dma_crc(ide_drive_t *);
 ide_startstop_t ide_dma_intr(ide_drive_t *);
 
+int ide_allocate_dma_engine(ide_hwif_t *);
+void ide_release_dma_engine(ide_hwif_t *);
+
 int ide_build_sglist(ide_drive_t *, struct request *);
 void ide_destroy_dmatable(ide_drive_t *);
 
 #ifdef CONFIG_BLK_DEV_IDEDMA_SFF
+int config_drive_for_dma(ide_drive_t *);
 extern int ide_build_dmatable(ide_drive_t *, struct request *);
-int ide_allocate_dma_engine(ide_hwif_t *);
-void ide_release_dma_engine(ide_hwif_t *);
-
 void ide_dma_host_set(ide_drive_t *, int);
 extern int ide_dma_setup(ide_drive_t *);
 void ide_dma_exec_cmd(ide_drive_t *, u8);
 extern void ide_dma_start(ide_drive_t *);
-extern int __ide_dma_end(ide_drive_t *);
+int ide_dma_end(ide_drive_t *);
 int ide_dma_test_irq(ide_drive_t *);
-extern void ide_dma_lost_irq(ide_drive_t *);
-extern void ide_dma_timeout(ide_drive_t *);
+extern const struct ide_dma_ops sff_dma_ops;
+#else
+static inline int config_drive_for_dma(ide_drive_t *drive) { return 0; }
 #endif /* CONFIG_BLK_DEV_IDEDMA_SFF */
 
+void ide_dma_lost_irq(ide_drive_t *);
+void ide_dma_timeout(ide_drive_t *);
+
 #else
 static inline int ide_id_dma_bug(ide_drive_t *drive) { return 0; }
 static inline u8 ide_find_dma_mode(ide_drive_t *drive, u8 speed) { return 0; }
@@ -1287,11 +1477,8 @@ static inline void ide_dma_on(ide_drive_t *drive) { ; }
 static inline void ide_dma_verbose(ide_drive_t *drive) { ; }
 static inline int ide_set_dma(ide_drive_t *drive) { return 1; }
 static inline void ide_check_dma_crc(ide_drive_t *drive) { ; }
-#endif /* CONFIG_BLK_DEV_IDEDMA */
-
-#ifndef CONFIG_BLK_DEV_IDEDMA_SFF
 static inline void ide_release_dma_engine(ide_hwif_t *hwif) { ; }
-#endif
+#endif /* CONFIG_BLK_DEV_IDEDMA */
 
 #ifdef CONFIG_BLK_DEV_IDEACPI
 extern int ide_acpi_exec_tfs(ide_drive_t *drive);
@@ -1319,7 +1506,6 @@ void ide_undecoded_slave(ide_drive_t *);
 
 void ide_port_apply_params(ide_hwif_t *);
 
-struct ide_host *ide_host_alloc_all(const struct ide_port_info *, hw_regs_t **);
 struct ide_host *ide_host_alloc(const struct ide_port_info *, hw_regs_t **);
 void ide_host_free(struct ide_host *);
 int ide_host_register(struct ide_host *, const struct ide_port_info *,
@@ -1345,24 +1531,6 @@ const char *ide_xfer_verbose(u8 mode);
 extern void ide_toggle_bounce(ide_drive_t *drive, int on);
 extern int ide_set_xfer_rate(ide_drive_t *drive, u8 rate);
 
-static inline int ide_dev_has_iordy(struct hd_driveid *id)
-{
-        return ((id->field_valid & 2) && (id->capability & 8)) ? 1 : 0;
-}
-
-static inline int ide_dev_is_sata(struct hd_driveid *id)
-{
-        /*
-         * See if word 93 is 0 AND drive is at least ATA-5 compatible
-         * verifying that word 80 by casting it to a signed type --
-         * this trick allows us to filter out the reserved values of
-         * 0x0000 and 0xffff along with the earlier ATA revisions...
-         */
-        if (id->hw_config == 0 && (short)id->major_rev_num >= 0x0020)
-                return 1;
-        return 0;
-}
-
 u64 ide_get_lba_addr(struct ide_taskfile *, int);
 u8 ide_dump_status(ide_drive_t *, const char *, u8);
 
@@ -1434,13 +1602,6 @@ extern struct mutex ide_cfg_mtx;
 extern struct bus_type ide_bus_type;
 extern struct class *ide_port_class;
 
-/* check if CACHE FLUSH (EXT) command is supported (bits defined in ATA-6) */
-#define ide_id_has_flush_cache(id)      ((id)->cfs_enable_2 & 0x3000)
-
-/* some Maxtor disks have bit 13 defined incorrectly so check bit 10 too */
-#define ide_id_has_flush_cache_ext(id)  \
-        (((id)->cfs_enable_2 & 0x2400) == 0x2400)
-
 static inline void ide_dump_identify(u8 *id)
 {
         print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 16, 2, id, 512, 0);
@@ -1448,14 +1609,13 @@ static inline void ide_dump_identify(u8 *id)
 
 static inline int hwif_to_node(ide_hwif_t *hwif)
 {
-        struct pci_dev *dev = to_pci_dev(hwif->dev);
-        return hwif->dev ? pcibus_to_node(dev->bus) : -1;
+        return hwif->dev ? dev_to_node(hwif->dev) : -1;
 }
 
-static inline ide_drive_t *ide_get_paired_drive(ide_drive_t *drive)
+static inline ide_drive_t *ide_get_pair_dev(ide_drive_t *drive)
 {
-        ide_hwif_t *hwif        = HWIF(drive);
+        ide_drive_t *peer = &drive->hwif->drives[(drive->dn ^ 1) & 1];
 
-        return &hwif->drives[(drive->dn ^ 1) & 1];
+        return (peer->dev_flags & IDE_DFLAG_PRESENT) ? peer : NULL;
 }
 #endif /* _IDE_H */