1 files changed, 185 insertions, 123 deletions

diff --git a/include/linux/ide.h b/include/linux/ide.h
index eddb6daadf4a..d67ccca2b964 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -139,6 +139,12 @@ struct ide_io_ports {
 #define WAIT_MIN_SLEEP  (2*HZ/100)      /* 20msec - minimum sleep time */
 
 /*
+ * 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
+
+/*
  * Check for an interrupt and acknowledge the interrupt status
  */
 struct hwif_s;
@@ -171,7 +177,8 @@ typedef struct hw_regs_s {
         int             irq;                    /* our irq number */
         ide_ack_intr_t  *ack_intr;              /* acknowledge interrupt */
         hwif_chipset_t  chipset;
-        struct device   *dev;
+        struct device   *dev, *parent;
+        unsigned long   config;
 } hw_regs_t;
 
 void ide_init_port_data(struct hwif_s *, unsigned int);
@@ -301,7 +308,65 @@ struct ide_acpi_drive_link;
 struct ide_acpi_hwif_link;
 #endif
 
-typedef struct ide_drive_s {
+/* ATAPI device flags */
+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),
+        /* Drive cannot eject the disc. */
+        IDE_AFLAG_NO_EJECT              = (1 << 3),
+        /* Drive is a pre ATAPI 1.2 drive. */
+        IDE_AFLAG_PRE_ATAPI12           = (1 << 4),
+        /* TOC addresses are in BCD. */
+        IDE_AFLAG_TOCADDR_AS_BCD        = (1 << 5),
+        /* TOC track numbers are in BCD. */
+        IDE_AFLAG_TOCTRACKS_AS_BCD      = (1 << 6),
+        /*
+         * Drive does not provide data in multiples of SECTOR_SIZE
+         * when more than one interrupt is needed.
+         */
+        IDE_AFLAG_LIMIT_NFRAMES         = (1 << 7),
+        /* Seeking in progress. */
+        IDE_AFLAG_SEEKING               = (1 << 8),
+        /* Saved TOC information is current. */
+        IDE_AFLAG_TOC_VALID             = (1 << 9),
+        /* We think that the drive door is locked. */
+        IDE_AFLAG_DOOR_LOCKED           = (1 << 10),
+        /* SET_CD_SPEED command is unsupported. */
+        IDE_AFLAG_NO_SPEED_SELECT       = (1 << 11),
+        IDE_AFLAG_VERTOS_300_SSD        = (1 << 12),
+        IDE_AFLAG_VERTOS_600_ESD        = (1 << 13),
+        IDE_AFLAG_SANYO_3CD             = (1 << 14),
+        IDE_AFLAG_FULL_CAPS_PAGE        = (1 << 15),
+        IDE_AFLAG_PLAY_AUDIO_OK         = (1 << 16),
+        IDE_AFLAG_LE_SPEED_FIELDS       = (1 << 17),
+
+        /* ide-floppy */
+        /* Format in progress */
+        IDE_AFLAG_FORMAT_IN_PROGRESS    = (1 << 18),
+        /* Avoid commands not supported in Clik drive */
+        IDE_AFLAG_CLIK_DRIVE            = (1 << 19),
+        /* Requires BH algorithm for packets */
+        IDE_AFLAG_ZIP_DRIVE             = (1 << 20),
+
+        /* ide-tape */
+        IDE_AFLAG_IGNORE_DSC            = (1 << 21),
+        /* 0 When the tape position is unknown */
+        IDE_AFLAG_ADDRESS_VALID         = (1 << 22),
+        /* Device already opened */
+        IDE_AFLAG_BUSY                  = (1 << 23),
+        /* Attempt to auto-detect the current user block size */
+        IDE_AFLAG_DETECT_BS             = (1 << 24),
+        /* Currently on a filemark */
+        IDE_AFLAG_FILEMARK              = (1 << 25),
+        /* 0 = no tape is loaded, so we don't rewind after ejecting */
+        IDE_AFLAG_MEDIUM_PRESENT        = (1 << 26)
+};
+
+struct ide_drive_s {
         char            name[4];        /* drive name, such as "hda" */
         char            driver_req[10]; /* requests specific driver */
 
@@ -349,7 +414,6 @@ typedef struct ide_drive_s {
         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 vdma           : 1;    /* 1=doing PIO over DMA 0=doing normal DMA */
         unsigned scsi           : 1;    /* 0=default, 1=ide-scsi emulation */
         unsigned sleeping       : 1;    /* 1=sleeping & sleep field valid */
         unsigned post_reset     : 1;
@@ -364,7 +428,6 @@ typedef struct ide_drive_s {
         u8      wcache;         /* status of write cache */
         u8      acoustic;       /* acoustic management */
         u8      media;          /* disk, cdrom, tape, floppy, ... */
-        u8      ctl;            /* "normal" value for Control register */
         u8      ready_stat;     /* min status value for drive ready */
         u8      mult_count;     /* current multiple sector setting */
         u8      mult_req;       /* requested multiple sector setting */
@@ -395,7 +458,14 @@ typedef struct ide_drive_s {
         struct list_head list;
         struct device   gendev;
         struct completion gendev_rel_comp;      /* to deal with device release() */
-} ide_drive_t;
+
+        /* callback for packet commands */
+        void (*pc_callback)(struct ide_drive_s *);
+
+        unsigned long atapi_flags;
+};
+
+typedef struct ide_drive_s ide_drive_t;
 
 #define to_ide_device(dev)container_of(dev, ide_drive_t, gendev)
 
@@ -403,11 +473,31 @@ typedef struct ide_drive_s {
     ((1<<ide_pci)|(1<<ide_cmd646)|(1<<ide_ali14xx))
 #define IDE_CHIPSET_IS_PCI(c)   ((IDE_CHIPSET_PCI_MASK >> (c)) & 1)
 
+struct ide_task_s;
 struct ide_port_info;
 
+struct ide_tp_ops {
+        void    (*exec_command)(struct hwif_s *, u8);
+        u8      (*read_status)(struct hwif_s *);
+        u8      (*read_altstatus)(struct hwif_s *);
+        u8      (*read_sff_dma_status)(struct hwif_s *);
+
+        void    (*set_irq)(struct hwif_s *, int);
+
+        void    (*tf_load)(ide_drive_t *, struct ide_task_s *);
+        void    (*tf_read)(ide_drive_t *, struct ide_task_s *);
+
+        void    (*input_data)(ide_drive_t *, struct request *, void *,
+                              unsigned int);
+        void    (*output_data)(ide_drive_t *, struct request *, void *,
+                               unsigned int);
+};
+
+extern const struct ide_tp_ops default_tp_ops;
+
 struct ide_port_ops {
-        /* host specific initialization of devices on a port */
-        void    (*port_init_devs)(struct hwif_s *);
+        /* host specific initialization of a device */
+        void    (*init_dev)(ide_drive_t *);
         /* routine to program host for PIO mode */
         void    (*set_pio_mode)(ide_drive_t *, const u8);
         /* routine to program host for DMA mode */
@@ -442,8 +532,6 @@ struct ide_dma_ops {
         void    (*dma_timeout)(struct ide_drive_s *);
 };
 
-struct ide_task_s;
-
 typedef struct hwif_s {
         struct hwif_s *next;            /* for linked-list in ide_hwgroup_t */
         struct hwif_s *mate;            /* other hwif from same PCI chip */
@@ -481,22 +569,12 @@ typedef struct hwif_s {
 
         void (*rw_disk)(ide_drive_t *, struct request *);
 
+        const struct ide_tp_ops         *tp_ops;
         const struct ide_port_ops       *port_ops;
         const struct ide_dma_ops        *dma_ops;
 
-        void (*tf_load)(ide_drive_t *, struct ide_task_s *);
-        void (*tf_read)(ide_drive_t *, struct ide_task_s *);
-
-        void (*input_data)(ide_drive_t *, struct request *, void *, unsigned);
-        void (*output_data)(ide_drive_t *, struct request *, void *, unsigned);
-
         void (*ide_dma_clear_irq)(ide_drive_t *drive);
 
-        void (*OUTB)(u8 addr, unsigned long port);
-        void (*OUTBSYNC)(ide_drive_t *drive, u8 addr, unsigned long port);
-
-        u8  (*INB)(unsigned long port);
-
         /* dma physical region descriptor table (cpu view) */
         unsigned int    *dmatable_cpu;
         /* dma physical region descriptor table (dma view) */
@@ -519,8 +597,6 @@ typedef struct hwif_s {
         int             irq;            /* our irq number */
 
         unsigned long   dma_base;       /* base addr for dma ports */
-        unsigned long   dma_command;    /* dma command register */
-        unsigned long   dma_status;     /* dma status register */
 
         unsigned long   config_data;    /* for use by chipset-specific code */
         unsigned long   select_data;    /* for use by chipset-specific code */
@@ -532,7 +608,6 @@ typedef struct hwif_s {
         unsigned        serialized : 1; /* serialized all channel operation */
         unsigned        sharing_irq: 1; /* 1 = sharing irq with another hwif */
         unsigned        sg_mapped  : 1; /* sg_table and sg_nents are ready */
-        unsigned        mmio       : 1; /* host uses MMIO */
 
         struct device           gendev;
         struct device           *portdev;
@@ -548,6 +623,11 @@ typedef struct hwif_s {
 #endif
 } ____cacheline_internodealigned_in_smp ide_hwif_t;
 
+struct ide_host {
+        ide_hwif_t      *ports[MAX_HWIFS];
+        unsigned int    n_ports;
+};
+
 /*
  *  internal ide interrupt handler type
  */
@@ -567,8 +647,6 @@ typedef struct hwgroup_s {
         unsigned int sleeping   : 1;
                 /* BOOL: polling active & poll_timeout field valid */
         unsigned int polling    : 1;
-                /* BOOL: in a polling reset situation. Must not trigger another reset yet */
-        unsigned int resetting  : 1;
 
                 /* current drive */
         ide_drive_t *drive;
@@ -604,12 +682,11 @@ enum {
         PC_FLAG_SUPPRESS_ERROR          = (1 << 1),
         PC_FLAG_WAIT_FOR_DSC            = (1 << 2),
         PC_FLAG_DMA_OK                  = (1 << 3),
-        PC_FLAG_DMA_RECOMMENDED         = (1 << 4),
-        PC_FLAG_DMA_IN_PROGRESS         = (1 << 5),
-        PC_FLAG_DMA_ERROR               = (1 << 6),
-        PC_FLAG_WRITING                 = (1 << 7),
+        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 << 8),
+        PC_FLAG_TIMEDOUT                = (1 << 7),
 };
 
 struct ide_atapi_pc {
@@ -642,8 +719,6 @@ struct ide_atapi_pc {
          * to change/removal later.
          */
         u8 pc_buf[256];
-        void (*idefloppy_callback) (ide_drive_t *);
-        ide_startstop_t (*idetape_callback) (ide_drive_t *);
 
         /* idetape only */
         struct idetape_bh *bh;
@@ -787,7 +862,6 @@ struct ide_driver_s {
         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);
-        ide_startstop_t (*abort)(ide_drive_t *, struct request *rq);
         struct device_driver    gen_driver;
         int             (*probe)(ide_drive_t *);
         void            (*remove)(ide_drive_t *);
@@ -802,32 +876,9 @@ struct ide_driver_s {
 
 int generic_ide_ioctl(ide_drive_t *, struct file *, struct block_device *, unsigned, unsigned long);
 
-/*
- * ide_hwifs[] is the master data structure used to keep track
- * of just about everything in ide.c.  Whenever possible, routines
- * should be using pointers to a drive (ide_drive_t *) or
- * pointers to a hwif (ide_hwif_t *), rather than indexing this
- * structure directly (the allocation/layout may change!).
- *
- */
-#ifndef _IDE_C
-extern  ide_hwif_t      ide_hwifs[];            /* master data repository */
-#endif
-extern int ide_noacpi;
-extern int ide_acpigtf;
-extern int ide_acpionboot;
-extern int noautodma;
-
 extern int ide_vlb_clk;
 extern int ide_pci_clk;
 
-ide_hwif_t *ide_find_port_slot(const struct ide_port_info *);
-
-static inline ide_hwif_t *ide_find_port(void)
-{
-        return ide_find_port_slot(NULL);
-}
-
 extern int ide_end_request (ide_drive_t *drive, int uptodate, int nrsecs);
 int ide_end_dequeued_request(ide_drive_t *drive, struct request *rq,
                              int uptodate, int nr_sectors);
@@ -845,10 +896,6 @@ 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);
 
-ide_startstop_t __ide_abort(ide_drive_t *, struct request *);
-
-extern ide_startstop_t ide_abort(ide_drive_t *, const char *);
-
 extern void ide_fix_driveid(struct hd_driveid *);
 
 extern void ide_fixstring(u8 *, const int, const int);
@@ -857,25 +904,12 @@ 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 void ide_init_drive_cmd (struct request *rq);
-
-/*
- * "action" parameter type for ide_do_drive_cmd() below.
- */
-typedef enum {
-        ide_wait,       /* insert rq at end of list, and wait for it */
-        ide_preempt,    /* insert rq in front of current request */
-        ide_head_wait,  /* insert rq in front of current request and wait for it */
-        ide_end         /* insert rq at end of list, but don't wait for it */
-} ide_action_t;
-
-extern int ide_do_drive_cmd(ide_drive_t *, struct request *, ide_action_t);
+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_NO_SELECT_MASK        = (1 << 1),
         IDE_TFLAG_FLAGGED               = (1 << 2),
         IDE_TFLAG_OUT_DATA              = (1 << 3),
         IDE_TFLAG_OUT_HOB_FEATURE       = (1 << 4),
@@ -915,6 +949,7 @@ enum {
         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),
@@ -979,12 +1014,40 @@ typedef struct ide_task_s {
 
 void ide_tf_dump(const char *, struct ide_taskfile *);
 
+void ide_exec_command(ide_hwif_t *, u8);
+u8 ide_read_status(ide_hwif_t *);
+u8 ide_read_altstatus(ide_hwif_t *);
+u8 ide_read_sff_dma_status(ide_hwif_t *);
+
+void ide_set_irq(ide_hwif_t *, int);
+
+void ide_tf_load(ide_drive_t *, ide_task_t *);
+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);
+
 extern void SELECT_DRIVE(ide_drive_t *);
+void SELECT_MASK(ide_drive_t *, int);
+
+u8 ide_read_error(ide_drive_t *);
+void ide_read_bcount_and_ireason(ide_drive_t *, u16 *, u8 *);
 
 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 *);
+
 ide_startstop_t do_rw_taskfile(ide_drive_t *, ide_task_t *);
 
 void task_end_request(ide_drive_t *, struct request *, u8);
@@ -996,8 +1059,6 @@ 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 system_bus_clock(void);
-
 extern int ide_driveid_update(ide_drive_t *);
 extern int ide_config_drive_speed(ide_drive_t *, u8);
 extern u8 eighty_ninty_three (ide_drive_t *);
@@ -1021,12 +1082,15 @@ extern int __ide_pci_register_driver(struct pci_driver *driver, struct module *o
 #define ide_pci_register_driver(d) pci_register_driver(d)
 #endif
 
-void ide_pci_setup_ports(struct pci_dev *, const struct ide_port_info *, int, u8 *);
+void ide_pci_setup_ports(struct pci_dev *, const struct ide_port_info *, int,
+                         hw_regs_t *, hw_regs_t **);
 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
 static inline int ide_hwif_setup_dma(ide_hwif_t *hwif,
@@ -1036,10 +1100,6 @@ static inline int ide_hwif_setup_dma(ide_hwif_t *hwif,
 }
 #endif
 
-extern void default_hwif_iops(ide_hwif_t *);
-extern void default_hwif_mmiops(ide_hwif_t *);
-extern void default_hwif_transport(ide_hwif_t *);
-
 typedef struct ide_pci_enablebit_s {
         u8      reg;    /* byte pci reg holding the enable-bit */
         u8      mask;   /* mask to isolate the enable-bit */
@@ -1102,7 +1162,6 @@ enum {
         IDE_HFLAG_IO_32BIT              = (1 << 24),
         /* unmask IRQs */
         IDE_HFLAG_UNMASK_IRQS           = (1 << 25),
-        IDE_HFLAG_ABUSE_SET_DMA_MODE    = (1 << 26),
         /* serialize ports if DMA is possible (for sl82c105) */
         IDE_HFLAG_SERIALIZE_DMA         = (1 << 27),
         /* force host out of "simplex" mode */
@@ -1113,8 +1172,6 @@ enum {
         IDE_HFLAG_NO_IO_32BIT           = (1 << 30),
         /* never unmask IRQs */
         IDE_HFLAG_NO_UNMASK_IRQS        = (1 << 31),
-        /* host uses VDMA (disabled for now) */
-        IDE_HFLAG_VDMA                  = 0,
 };
 
 #ifdef CONFIG_BLK_DEV_OFFBOARD
@@ -1131,6 +1188,7 @@ struct ide_port_info {
         int                     (*init_dma)(ide_hwif_t *,
                                             const struct ide_port_info *);
 
+        const struct ide_tp_ops         *tp_ops;
         const struct ide_port_ops       *port_ops;
         const struct ide_dma_ops        *dma_ops;
 
@@ -1184,7 +1242,6 @@ void ide_destroy_dmatable(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_setup_dma(ide_hwif_t *, unsigned long);
 
 void ide_dma_host_set(ide_drive_t *, int);
 extern int ide_dma_setup(ide_drive_t *);
@@ -1238,8 +1295,14 @@ void ide_undecoded_slave(ide_drive_t *);
 
 void ide_port_apply_params(ide_hwif_t *);
 
-int ide_device_add_all(u8 *idx, const struct ide_port_info *);
-int ide_device_add(u8 idx[4], const struct ide_port_info *);
+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 *,
+                      hw_regs_t **);
+int ide_host_add(const struct ide_port_info *, hw_regs_t **,
+                 struct ide_host **);
+void ide_host_remove(struct ide_host *);
 int ide_legacy_device_add(const struct ide_port_info *, unsigned long);
 void ide_port_unregister_devices(ide_hwif_t *);
 void ide_port_scan(ide_hwif_t *);
@@ -1279,16 +1342,43 @@ static inline int ide_dev_is_sata(struct hd_driveid *id)
 u64 ide_get_lba_addr(struct ide_taskfile *, int);
 u8 ide_dump_status(ide_drive_t *, const char *, u8);
 
-typedef struct ide_pio_timings_s {
-        int     setup_time;     /* Address setup (ns) minimum */
-        int     active_time;    /* Active pulse (ns) minimum */
-        int     cycle_time;     /* Cycle time (ns) minimum = */
-                                /* active + recovery (+ setup for some chips) */
-} ide_pio_timings_t;
+struct ide_timing {
+        u8  mode;
+        u8  setup;      /* t1 */
+        u16 act8b;      /* t2 for 8-bit io */
+        u16 rec8b;      /* t2i for 8-bit io */
+        u16 cyc8b;      /* t0 for 8-bit io */
+        u16 active;     /* t2 or tD */
+        u16 recover;    /* t2i or tK */
+        u16 cycle;      /* t0 */
+        u16 udma;       /* t2CYCTYP/2 */
+};
+
+enum {
+        IDE_TIMING_SETUP        = (1 << 0),
+        IDE_TIMING_ACT8B        = (1 << 1),
+        IDE_TIMING_REC8B        = (1 << 2),
+        IDE_TIMING_CYC8B        = (1 << 3),
+        IDE_TIMING_8BIT         = IDE_TIMING_ACT8B | IDE_TIMING_REC8B |
+                                  IDE_TIMING_CYC8B,
+        IDE_TIMING_ACTIVE       = (1 << 4),
+        IDE_TIMING_RECOVER      = (1 << 5),
+        IDE_TIMING_CYCLE        = (1 << 6),
+        IDE_TIMING_UDMA         = (1 << 7),
+        IDE_TIMING_ALL          = IDE_TIMING_SETUP | IDE_TIMING_8BIT |
+                                  IDE_TIMING_ACTIVE | IDE_TIMING_RECOVER |
+                                  IDE_TIMING_CYCLE | IDE_TIMING_UDMA,
+};
+
+struct ide_timing *ide_timing_find_mode(u8);
+u16 ide_pio_cycle_time(ide_drive_t *, u8);
+void ide_timing_merge(struct ide_timing *, struct ide_timing *,
+                      struct ide_timing *, unsigned int);
+int ide_timing_compute(ide_drive_t *, u8, struct ide_timing *, int, int);
+
+int ide_scan_pio_blacklist(char *);
 
-unsigned int ide_pio_cycle_time(ide_drive_t *, u8);
 u8 ide_get_best_pio_mode(ide_drive_t *, u8, u8);
-extern const ide_pio_timings_t ide_pio_timings[6];
 
 int ide_set_pio_mode(ide_drive_t *, u8);
 int ide_set_dma_mode(ide_drive_t *, u8);
@@ -1344,32 +1434,4 @@ static inline ide_drive_t *ide_get_paired_drive(ide_drive_t *drive)
 
         return &hwif->drives[(drive->dn ^ 1) & 1];
 }
-
-static inline void ide_set_irq(ide_drive_t *drive, int on)
-{
-        ide_hwif_t *hwif = drive->hwif;
-
-        hwif->OUTB(drive->ctl | (on ? 0 : 2), hwif->io_ports.ctl_addr);
-}
-
-static inline u8 ide_read_status(ide_drive_t *drive)
-{
-        ide_hwif_t *hwif = drive->hwif;
-
-        return hwif->INB(hwif->io_ports.status_addr);
-}
-
-static inline u8 ide_read_altstatus(ide_drive_t *drive)
-{
-        ide_hwif_t *hwif = drive->hwif;
-
-        return hwif->INB(hwif->io_ports.ctl_addr);
-}
-
-static inline u8 ide_read_error(ide_drive_t *drive)
-{
-        ide_hwif_t *hwif = drive->hwif;
-
-        return hwif->INB(hwif->io_ports.error_addr);
-}
 #endif /* _IDE_H */