[PATCH] 2.5.12 IDE 49
[opensuse:kernel.git] / include / linux / ide.h
1 #ifndef _IDE_H
2 #define _IDE_H
3 /*
4  *  Copyright (C) 1994-2002  Linus Torvalds & authors
5  */
6
7 #include <linux/config.h>
8 #include <linux/init.h>
9 #include <linux/ioport.h>
10 #include <linux/hdreg.h>
11 #include <linux/hdsmart.h>
12 #include <linux/blkdev.h>
13 #include <linux/proc_fs.h>
14 #include <linux/device.h>
15 #include <linux/devfs_fs_kernel.h>
16 #include <linux/interrupt.h>
17 #include <linux/bitops.h>
18 #include <asm/hdreg.h>
19
20 /*
21  * This is the multiple IDE interface driver, as evolved from hd.c.
22  * It supports up to four IDE interfaces, on one or more IRQs (usually 14, 15).
23  * There can be up to two drives per interface, as per the ATA-2 spec.
24  *
25  * Primary i/f:    ide0: major=3;  (hda) minor=0; (hdb) minor=64
26  * Secondary i/f:  ide1: major=22; (hdc) minor=0; (hdd) minor=64
27  * Tertiary i/f:   ide2: major=33; (hde) minor=0; (hdf) minor=64
28  * Quaternary i/f: ide3: major=34; (hdg) minor=0; (hdh) minor=64
29  */
30
31 /******************************************************************************
32  * IDE driver configuration options (play with these as desired):
33  */
34 #define INITIAL_MULT_COUNT      0       /* off=0; on=2,4,8,16,32, etc.. */
35
36 #ifndef SUPPORT_SLOW_DATA_PORTS                 /* 1 to support slow data ports */
37 # define SUPPORT_SLOW_DATA_PORTS        1       /* 0 to reduce kernel size */
38 #endif
39
40 /* Right now this is only needed by a promise controlled.
41  */
42 #ifndef SUPPORT_VLB_SYNC                /* 1 to support weird 32-bit chips */
43 # define SUPPORT_VLB_SYNC       1       /* 0 to reduce kernel size */
44 #endif
45 #ifndef DISK_RECOVERY_TIME              /* off=0; on=access_delay_time */
46 # define DISK_RECOVERY_TIME     0       /*  for hardware that needs it */
47 #endif
48 #ifndef OK_TO_RESET_CONTROLLER          /* 1 needed for good error recovery */
49 # define OK_TO_RESET_CONTROLLER 1       /* 0 for use with AH2372A/B interface */
50 #endif
51 #ifndef FANCY_STATUS_DUMPS              /* 1 for human-readable drive errors */
52 # define FANCY_STATUS_DUMPS     1       /* 0 to reduce kernel size */
53 #endif
54 #ifndef DISABLE_IRQ_NOSYNC
55 # define DISABLE_IRQ_NOSYNC     0
56 #endif
57
58 /*
59  *  "No user-serviceable parts" beyond this point
60  *****************************************************************************/
61
62 typedef unsigned char   byte;   /* used everywhere */
63
64 /*
65  * Probably not wise to fiddle with these
66  */
67 #define ERROR_MAX       8       /* Max read/write errors per sector */
68 #define ERROR_RESET     3       /* Reset controller every 4th retry */
69 #define ERROR_RECAL     1       /* Recalibrate every 2nd retry */
70
71 /*
72  * state flags
73  */
74 #define DMA_PIO_RETRY   1       /* retrying in PIO */
75
76 #define HWGROUP(drive)          (drive->channel->hwgroup)
77
78 /*
79  * Definitions for accessing IDE controller registers
80  */
81 #define IDE_NR_PORTS            (10)
82
83 #define IDE_DATA_OFFSET         (0)
84 #define IDE_ERROR_OFFSET        (1)
85 #define IDE_NSECTOR_OFFSET      (2)
86 #define IDE_SECTOR_OFFSET       (3)
87 #define IDE_LCYL_OFFSET         (4)
88 #define IDE_HCYL_OFFSET         (5)
89 #define IDE_SELECT_OFFSET       (6)
90 #define IDE_STATUS_OFFSET       (7)
91 #define IDE_CONTROL_OFFSET      (8)
92 #define IDE_IRQ_OFFSET          (9)
93
94 #define IDE_FEATURE_OFFSET      IDE_ERROR_OFFSET
95 #define IDE_COMMAND_OFFSET      IDE_STATUS_OFFSET
96
97 #define IDE_DATA_REG            (drive->channel->io_ports[IDE_DATA_OFFSET])
98 #define IDE_ERROR_REG           (drive->channel->io_ports[IDE_ERROR_OFFSET])
99 #define IDE_NSECTOR_REG         (drive->channel->io_ports[IDE_NSECTOR_OFFSET])
100 #define IDE_SECTOR_REG          (drive->channel->io_ports[IDE_SECTOR_OFFSET])
101 #define IDE_LCYL_REG            (drive->channel->io_ports[IDE_LCYL_OFFSET])
102 #define IDE_HCYL_REG            (drive->channel->io_ports[IDE_HCYL_OFFSET])
103 #define IDE_SELECT_REG          (drive->channel->io_ports[IDE_SELECT_OFFSET])
104 #define IDE_STATUS_REG          (drive->channel->io_ports[IDE_STATUS_OFFSET])
105 #define IDE_CONTROL_REG         (drive->channel->io_ports[IDE_CONTROL_OFFSET])
106 #define IDE_IRQ_REG             (drive->channel->io_ports[IDE_IRQ_OFFSET])
107
108 #define IDE_FEATURE_REG         IDE_ERROR_REG
109 #define IDE_COMMAND_REG         IDE_STATUS_REG
110 #define IDE_ALTSTATUS_REG       IDE_CONTROL_REG
111 #define IDE_IREASON_REG         IDE_NSECTOR_REG
112 #define IDE_BCOUNTL_REG         IDE_LCYL_REG
113 #define IDE_BCOUNTH_REG         IDE_HCYL_REG
114
115 #define GET_ERR()               IN_BYTE(IDE_ERROR_REG)
116 #define GET_STAT()              IN_BYTE(IDE_STATUS_REG)
117 #define GET_ALTSTAT()           IN_BYTE(IDE_CONTROL_REG)
118 #define GET_FEAT()              IN_BYTE(IDE_NSECTOR_REG)
119
120 #define OK_STAT(stat,good,bad)  (((stat)&((good)|(bad)))==(good))
121
122 #define BAD_R_STAT              (BUSY_STAT   | ERR_STAT)
123 #define BAD_W_STAT              (BAD_R_STAT  | WRERR_STAT)
124 #define BAD_STAT                (BAD_R_STAT  | DRQ_STAT)
125
126 #define DRIVE_READY             (READY_STAT  | SEEK_STAT)
127 #define DATA_READY              (DRQ_STAT)
128
129 /*
130  * Our Physical Region Descriptor (PRD) table should be large enough
131  * to handle the biggest I/O request we are likely to see.  Since requests
132  * can have no more than 256 sectors, and since the typical blocksize is
133  * two or more sectors, we could get by with a limit of 128 entries here for
134  * the usual worst case.  Most requests seem to include some contiguous blocks,
135  * further reducing the number of table entries required.
136  *
137  * As it turns out though, we must allocate a full 4KB page for this,
138  * so the two PRD tables (ide0 & ide1) will each get half of that,
139  * allowing each to have about 256 entries (8 bytes each) from this.
140  */
141 #define PRD_BYTES       8
142 #define PRD_ENTRIES     (PAGE_SIZE / (2 * PRD_BYTES))
143 #define PRD_SEGMENTS    32
144
145 /*
146  * Some more useful definitions
147  */
148 #define IDE_MAJOR_NAME  "hd"    /* the same for all i/f; see also genhd.c */
149 #define MAJOR_NAME      IDE_MAJOR_NAME
150 #define PARTN_BITS      6       /* number of minor dev bits for partitions */
151 #define PARTN_MASK      ((1<<PARTN_BITS)-1)     /* a useful bit mask */
152 #define MAX_DRIVES      2       /* per interface; 2 assumed by lots of code */
153 #define SECTOR_SIZE     512
154 #define SECTOR_WORDS    (SECTOR_SIZE / 4)       /* number of 32bit words per sector */
155
156 /*
157  * Timeouts for various operations:
158  */
159 #define WAIT_DRQ        (5*HZ/100)      /* 50msec - spec allows up to 20ms */
160 #define WAIT_READY      (5*HZ)          /* 5sec   - some laptops are very slow */
161 #define WAIT_PIDENTIFY  (10*HZ)         /* 10sec  - should be less than 3ms (?), if all ATAPI CD is closed at boot */
162 #define WAIT_WORSTCASE  (30*HZ)         /* 30sec  - worst case when spinning up */
163 #define WAIT_CMD        (10*HZ)         /* 10sec  - maximum wait for an IRQ to happen */
164 #define WAIT_MIN_SLEEP  (2*HZ/100)      /* 20msec - minimum sleep time */
165
166 #define SELECT_DRIVE(channel, drive)                            \
167 {                                                               \
168         if (channel->selectproc)                                \
169                 channel->selectproc(drive);                     \
170         OUT_BYTE((drive)->select.all, channel->io_ports[IDE_SELECT_OFFSET]); \
171 }
172
173 #define SELECT_MASK(channel, drive, mask)                       \
174 {                                                               \
175         if (channel->maskproc)                                  \
176                 channel->maskproc(drive,mask);                  \
177 }
178
179 /*
180  * Check for an interrupt and acknowledge the interrupt status
181  */
182 struct ata_channel;
183 typedef int (ide_ack_intr_t)(struct ata_channel *);
184
185 #ifndef NO_DMA
186 # define NO_DMA  255
187 #endif
188
189 /*
190  * This is used to keep track of the specific hardware chipset used by each IDE
191  * interface, if known. Please note that we don't discriminate between
192  * different PCI host chips here.
193  */
194 typedef enum {
195         ide_unknown,
196         ide_generic,
197         ide_pci,
198         ide_cmd640,
199         ide_dtc2278,
200         ide_ali14xx,
201         ide_qd65xx,
202         ide_umc8672,
203         ide_ht6560b,
204         ide_pdc4030,
205         ide_rz1000,
206         ide_trm290,
207         ide_cmd646,
208         ide_cy82c693,
209         ide_pmac,
210         ide_etrax100
211 } hwif_chipset_t;
212
213
214 #define IDE_CHIPSET_PCI_MASK    \
215     ((1<<ide_pci)|(1<<ide_cmd646)|(1<<ide_ali14xx))
216 #define IDE_CHIPSET_IS_PCI(c)   ((IDE_CHIPSET_PCI_MASK >> (c)) & 1)
217
218 /*
219  * Structure to hold all information about the location of this port
220  */
221 typedef struct hw_regs_s {
222         ide_ioreg_t     io_ports[IDE_NR_PORTS]; /* task file registers */
223         int             irq;                    /* our irq number */
224         int             dma;                    /* our dma entry */
225         ide_ack_intr_t  *ack_intr;              /* acknowledge interrupt */
226         hwif_chipset_t  chipset;
227 } hw_regs_t;
228
229 /*
230  * Set up hw_regs_t structure before calling ide_register_hw (optional)
231  */
232 void ide_setup_ports(hw_regs_t *hw,
233                         ide_ioreg_t base,
234                         int *offsets,
235                         ide_ioreg_t ctrl,
236                         ide_ioreg_t intr,
237                         ide_ack_intr_t *ack_intr,
238                         int irq);
239
240 #include <asm/ide.h>
241
242 /*
243  * If the arch-dependant ide.h did not declare/define any OUT_BYTE or IN_BYTE
244  * functions, we make some defaults here. The only architecture currently
245  * needing this is Cris.
246  */
247
248 #ifndef HAVE_ARCH_IN_OUT
249 # define OUT_BYTE(b,p)          outb((b),(p))
250 # define OUT_WORD(w,p)          outw((w),(p))
251 # define IN_BYTE(p)             (u8)inb(p)
252 # define IN_WORD(p)             (u16)inw(p)
253 #endif
254
255 /*
256  * Device types - the nomenclature is analogous to SCSI code.
257  */
258
259 #define ATA_DISK        0x20
260 #define ATA_TAPE        0x01
261 #define ATA_ROM         0x05    /* CD-ROM */
262 #define ATA_MOD         0x07    /* optical */
263 #define ATA_FLOPPY      0x00
264 #define ATA_SCSI        0x21
265 #define ATA_NO_LUN      0x7f
266
267 struct ide_settings_s;
268
269 /*
270  * ATA/ATAPI device structure :
271  */
272 typedef
273 struct ata_device {
274         struct ata_channel *    channel;
275         char                    name[6];        /* device name */
276
277         unsigned int usage;             /* current "open()" count for drive */
278         char type; /* distingiush different devices: disk, cdrom, tape, floppy, ... */
279
280         /* NOTE: If we had proper separation between channel and host chip, we
281          * could move this to the channel and many sync problems would
282          * magically just go away.
283          */
284         request_queue_t queue;  /* per device request queue */
285
286
287         unsigned long sleep;    /* sleep until this time */
288
289         /* Flags requesting/indicating one of the following special commands
290          * executed on the request queue.
291          */
292 #define ATA_SPECIAL_GEOMETRY            0x01
293 #define ATA_SPECIAL_RECALIBRATE         0x02
294 #define ATA_SPECIAL_MMODE               0x04
295 #define ATA_SPECIAL_TUNE                0x08
296         unsigned char special_cmd;
297         u8 mult_req;                    /* requested multiple sector setting */
298         u8 tune_req;                    /* requested drive tuning setting */
299
300         byte     using_dma;             /* disk is using dma for read/write */
301         byte     retry_pio;             /* retrying dma capable host in pio */
302         byte     state;                 /* retry state */
303         byte     dsc_overlap;           /* flag: DSC overlap */
304
305         unsigned waiting_for_dma: 1;    /* dma currently in progress */
306         unsigned busy           : 1;    /* currently doing revalidate_disk() */
307         unsigned blocked        : 1;    /* 1=powermanagment told us not to do anything, so sleep nicely */
308
309         unsigned present        : 1;    /* drive is physically present */
310         unsigned noprobe        : 1;    /* from:  hdx=noprobe */
311         unsigned removable      : 1;    /* 1 if need to do check_media_change */
312         unsigned forced_geom    : 1;    /* 1 if hdx=c,h,s was given at boot */
313         unsigned nobios         : 1;    /* flag: do not probe bios for drive */
314         unsigned revalidate     : 1;    /* request revalidation */
315         unsigned atapi_overlap  : 1;    /* flag: ATAPI overlap (not supported) */
316         unsigned doorlocking    : 1;    /* flag: for removable only: door lock/unlock works */
317         unsigned autotune       : 2;    /* 1=autotune, 2=noautotune, 0=default */
318         unsigned remap_0_to_1   : 2;    /* 0=remap if ezdrive, 1=remap, 2=noremap */
319         unsigned ata_flash      : 1;    /* 1=present, 0=default */
320         unsigned        addressing;     /* : 2; 0=28-bit, 1=48-bit, 2=64-bit */
321         byte            scsi;           /* 0=default, 1=skip current ide-subdriver for ide-scsi emulation */
322         select_t        select;         /* basic drive/head select reg value */
323         byte            ctl;            /* "normal" value for IDE_CONTROL_REG */
324         byte            ready_stat;     /* min status value for drive ready */
325         byte            mult_count;     /* current multiple sector setting */
326         byte            bad_wstat;      /* used for ignoring WRERR_STAT */
327         byte            nowerr;         /* used for ignoring WRERR_STAT */
328         byte            sect0;          /* offset of first sector for DM6:DDO */
329         byte            head;           /* "real" number of heads */
330         byte            sect;           /* "real" sectors per track */
331         byte            bios_head;      /* BIOS/fdisk/LILO number of heads */
332         byte            bios_sect;      /* BIOS/fdisk/LILO sectors per track */
333         unsigned int    bios_cyl;       /* BIOS/fdisk/LILO number of cyls */
334         unsigned int    cyl;            /* "real" number of cyls */
335         u64             capacity;       /* total number of sectors */
336         unsigned int    drive_data;     /* for use by tuneproc/selectproc as needed */
337
338         wait_queue_head_t wqueue;       /* used to wait for drive in open() */
339
340         struct hd_driveid *id;          /* drive model identification info */
341         struct hd_struct  *part;        /* drive partition table */
342
343         struct ata_operations *driver;
344
345         void            *driver_data;   /* extra driver data */
346         devfs_handle_t  de;             /* directory for device */
347         struct proc_dir_entry *proc;    /* /proc/ide/ directory entry */
348         struct ide_settings_s *settings;    /* /proc/ide/ drive settings */
349         char            driver_req[10]; /* requests specific driver */
350
351         int             last_lun;       /* last logical unit */
352         int             forced_lun;     /* if hdxlun was given at boot */
353         int             lun;            /* logical unit */
354
355         int             crc_count;      /* crc counter to reduce drive speed */
356         byte            quirk_list;     /* drive is considered quirky if set for a specific host */
357         byte            suspend_reset;  /* drive suspend mode flag, soft-reset recovers */
358         byte            init_speed;     /* transfer rate set at boot */
359         byte            current_speed;  /* current transfer rate set */
360         byte            dn;             /* now wide spread use */
361         byte            wcache;         /* status of write cache */
362         byte            acoustic;       /* acoustic management */
363         unsigned int    failures;       /* current failure count */
364         unsigned int    max_failures;   /* maximum allowed failure count */
365         struct device   device;         /* global device tree handle */
366 } ide_drive_t;
367
368 /*
369  * This initiates/aborts DMA read/write operations on a drive.
370  *
371  * The caller is assumed to have selected the drive and programmed the drive's
372  * sector address using CHS or LBA.  All that remains is to prepare for DMA
373  * and then issue the actual read/write DMA/PIO command to the drive.
374  *
375  * Returns 0 if all went well.
376  * Returns 1 if DMA read/write could not be started, in which case the caller
377  * should either try again later, or revert to PIO for the current request.
378  */
379 typedef enum {  ide_dma_read,   ide_dma_write,          ide_dma_begin,
380                 ide_dma_end,    ide_dma_check,          ide_dma_on,
381                 ide_dma_off,    ide_dma_off_quietly,    ide_dma_test_irq,
382                 ide_dma_bad_drive,                      ide_dma_good_drive,
383                 ide_dma_verbose,                        ide_dma_retune,
384                 ide_dma_lostirq,                        ide_dma_timeout
385 } ide_dma_action_t;
386
387 enum {
388         ATA_PRIMARY     = 0,
389         ATA_SECONDARY   = 1
390 };
391
392 struct ata_channel {
393         struct device   dev;            /* device handle */
394         int             unit;           /* channel number */
395
396         struct hwgroup_s *hwgroup;      /* actually (ide_hwgroup_t *) */
397
398         ide_ioreg_t     io_ports[IDE_NR_PORTS]; /* task file registers */
399         hw_regs_t       hw;             /* Hardware info */
400 #ifdef CONFIG_BLK_DEV_IDEPCI
401         struct pci_dev  *pci_dev;       /* for pci chipsets */
402 #endif
403         ide_drive_t     drives[MAX_DRIVES];     /* drive info */
404         struct gendisk  *gd;            /* gendisk structure */
405
406         /*
407          * Routines to tune PIO and DMA mode for drives.
408          *
409          * A value of 255 indicates that the function should choose the optimal
410          * mode itself.
411          */
412         void (*tuneproc) (ide_drive_t *, byte pio);
413         int (*speedproc) (ide_drive_t *, byte pio);
414
415         /* tweaks hardware to select drive */
416         void (*selectproc) (ide_drive_t *);
417
418         /* routine to reset controller after a disk reset */
419         void (*resetproc) (ide_drive_t *);
420
421         /* special interrupt handling for shared pci interrupts */
422         void (*intrproc) (ide_drive_t *);
423
424         /* special host masking for drive selection */
425         void (*maskproc) (ide_drive_t *, int);
426
427         /* adjust timing based upon rq->cmd direction */
428         void (*rwproc) (ide_drive_t *, ide_dma_action_t);
429
430         /* check host's drive quirk list */
431         int (*quirkproc) (ide_drive_t *);
432
433         /* CPU-polled transfer routines */
434         void (*ata_read)(ide_drive_t *, void *, unsigned int);
435         void (*ata_write)(ide_drive_t *, void *, unsigned int);
436         void (*atapi_read)(ide_drive_t *, void *, unsigned int);
437         void (*atapi_write)(ide_drive_t *, void *, unsigned int);
438
439         int (*udma)(ide_dma_action_t, struct ata_device *, struct request *); /* dma read/write/abort routine */
440         unsigned int    *dmatable_cpu;  /* dma physical region descriptor table (cpu view) */
441         dma_addr_t      dmatable_dma;   /* dma physical region descriptor table (dma view) */
442         struct scatterlist *sg_table;   /* Scatter-gather list used to build the above */
443         int sg_nents;                   /* Current number of entries in it */
444         int sg_dma_direction;           /* dma transfer direction */
445         unsigned long   dma_base;       /* base addr for dma ports */
446         unsigned        dma_extra;      /* extra addr for dma ports */
447         unsigned long   config_data;    /* for use by chipset-specific code */
448         unsigned long   select_data;    /* for use by chipset-specific code */
449         struct proc_dir_entry *proc;    /* /proc/ide/ directory entry */
450         int             irq;            /* our irq number */
451         int             major;          /* our major number */
452         char            name[8];        /* name of interface */
453         int             index;          /* 0 for ide0; 1 for ide1; ... */
454         hwif_chipset_t  chipset;        /* sub-module for tuning.. */
455         unsigned noprobe        : 1;    /* don't probe for this interface */
456         unsigned present        : 1;    /* there is a device on this interface */
457         unsigned serialized     : 1;    /* serialized operation between channels */
458         unsigned sharing_irq    : 1;    /* 1 = sharing irq with another hwif */
459         unsigned reset          : 1;    /* reset after probe */
460         unsigned autodma        : 1;    /* automatically try to enable DMA at boot */
461         unsigned udma_four      : 1;    /* 1=ATA-66 capable, 0=default */
462         unsigned highmem        : 1;    /* can do full 32-bit dma */
463         unsigned no_io_32bit    : 1;    /* disallow enabling 32bit I/O */
464         unsigned no_unmask      : 1;    /* disallow setting unmask bit */
465         byte            io_32bit;       /* 0=16-bit, 1=32-bit, 2/3=32bit+sync */
466         byte            unmask;         /* flag: okay to unmask other irqs */
467         byte            slow;           /* flag: slow data port */
468
469 #if (DISK_RECOVERY_TIME > 0)
470         unsigned long   last_time;      /* time when previous rq was done */
471 #endif
472         byte            straight8;      /* Alan's straight 8 check */
473         int (*busproc)(ide_drive_t *, int);     /* driver soft-power interface */
474         byte            bus_state;      /* power state of the IDE bus */
475 };
476
477 /*
478  * Register new hardware with ide
479  */
480 extern int ide_register_hw(hw_regs_t *hw, struct ata_channel **hwifp);
481 extern void ide_unregister(struct ata_channel *hwif);
482
483 /*
484  * Status returned by various functions.
485  */
486 typedef enum {
487         ide_stopped,    /* no drive operation was started */
488         ide_started,    /* a drive operation was started, and a handler was set */
489         ide_released    /* started and released bus */
490 } ide_startstop_t;
491
492 /*
493  *  Interrupt and timeout handler type.
494  */
495 typedef ide_startstop_t (ata_handler_t)(struct ata_device *, struct request *);
496 typedef int (ata_expiry_t)(struct ata_device *, struct request *);
497
498 struct ata_taskfile;
499
500 #define IDE_BUSY        0       /* awaiting an interrupt */
501 #define IDE_SLEEP       1
502 #define IDE_DMA         2       /* DMA in progress */
503
504 typedef struct hwgroup_s {
505         ide_startstop_t (*handler)(struct ata_device *, struct request *);      /* irq handler, if active */
506         unsigned long flags;            /* BUSY, SLEEPING */
507         struct ata_device *XXX_drive;   /* current drive */
508         struct request *rq;             /* current request */
509         struct timer_list timer;        /* failsafe timer */
510         unsigned long poll_timeout;     /* timeout value during long polls */
511         int (*expiry)(struct ata_device *, struct request *);   /* irq handler, if active */
512 } ide_hwgroup_t;
513
514 /* structure attached to the request for IDE_TASK_CMDS */
515
516 /*
517  * configurable drive settings
518  */
519
520 #define TYPE_INT        0
521 #define TYPE_INTA       1
522 #define TYPE_BYTE       2
523 #define TYPE_SHORT      3
524
525 #define SETTING_READ    (1 << 0)
526 #define SETTING_WRITE   (1 << 1)
527 #define SETTING_RW      (SETTING_READ | SETTING_WRITE)
528
529 typedef int (ide_procset_t)(ide_drive_t *, int);
530 typedef struct ide_settings_s {
531         char                    *name;
532         int                     rw;
533         int                     read_ioctl;
534         int                     write_ioctl;
535         int                     data_type;
536         int                     min;
537         int                     max;
538         int                     mul_factor;
539         int                     div_factor;
540         void                    *data;
541         ide_procset_t           *set;
542         int                     auto_remove;
543         struct ide_settings_s   *next;
544 } ide_settings_t;
545
546 void ide_add_setting(ide_drive_t *drive, const char *name, int rw, int read_ioctl, int write_ioctl, int data_type, int min, int max, int mul_factor, int div_factor, void *data, ide_procset_t *set);
547 void ide_remove_setting(ide_drive_t *drive, char *name);
548 int ide_read_setting(ide_drive_t *t, ide_settings_t *setting);
549 int ide_write_setting(ide_drive_t *drive, ide_settings_t *setting, int val);
550 void ide_add_generic_settings(ide_drive_t *drive);
551
552 /*
553  * /proc/ide interface
554  */
555 typedef struct {
556         const char      *name;
557         mode_t          mode;
558         read_proc_t     *read_proc;
559         write_proc_t    *write_proc;
560 } ide_proc_entry_t;
561
562 #ifdef CONFIG_PROC_FS
563 void proc_ide_create(void);
564 void proc_ide_destroy(void);
565 void destroy_proc_ide_drives(struct ata_channel *);
566 void create_proc_ide_interfaces(void);
567 void ide_add_proc_entries(struct proc_dir_entry *dir, ide_proc_entry_t *p, void *data);
568 void ide_remove_proc_entries(struct proc_dir_entry *dir, ide_proc_entry_t *p);
569 read_proc_t proc_ide_read_capacity;
570 read_proc_t proc_ide_read_geometry;
571
572 /*
573  * Standard exit stuff:
574  */
575 #define PROC_IDE_READ_RETURN(page,start,off,count,eof,len) \
576 {                                       \
577         len -= off;                     \
578         if (len < count) {              \
579                 *eof = 1;               \
580                 if (len <= 0)           \
581                         return 0;       \
582         } else                          \
583                 len = count;            \
584         *start = page + off;            \
585         return len;                     \
586 }
587 #else
588 # define PROC_IDE_READ_RETURN(page,start,off,count,eof,len) return 0;
589 #endif
590
591 /*
592  * This structure describes the operations possible on a particular device type
593  * (CD-ROM, tape, DISK and so on).
594  *
595  * This is the main hook for device type support submodules.
596  */
597
598 struct ata_operations {
599         struct module *owner;
600         int (*cleanup)(struct ata_device *);
601         int (*standby)(struct ata_device *);
602         ide_startstop_t (*do_request)(struct ata_device *, struct request *, sector_t);
603         int (*end_request)(struct ata_device *, struct request *, int);
604
605         int (*ioctl)(struct ata_device *, struct inode *, struct file *, unsigned int, unsigned long);
606         int (*open)(struct inode *, struct file *, struct ata_device *);
607         void (*release)(struct inode *, struct file *, struct ata_device *);
608         int (*check_media_change)(struct ata_device *);
609         void (*revalidate)(struct ata_device *);
610
611         void (*pre_reset)(struct ata_device *);
612         sector_t (*capacity)(struct ata_device *);
613         ide_startstop_t (*special)(struct ata_device *);
614
615         ide_proc_entry_t *proc;
616 };
617
618 /* Alas, no aliases. Too much hassle with bringing module.h everywhere */
619 #define ata_get(ata) \
620         (((ata) && (ata)->owner)        \
621                 ? ( try_inc_mod_count((ata)->owner) ? (ata) : NULL ) \
622                 : (ata))
623
624 #define ata_put(ata) \
625 do {    \
626         if ((ata) && (ata)->owner) \
627                 __MOD_DEC_USE_COUNT((ata)->owner);      \
628 } while(0)
629
630 extern sector_t ata_capacity(struct ata_device *drive);
631
632 /* FIXME: Actually implement and use them as soon as possible!  to make the
633  * ide_scan_devices() go away! */
634
635 extern int unregister_ata_driver(unsigned int type, struct ata_operations *driver);
636 extern int register_ata_driver(unsigned int type, struct ata_operations *driver);
637
638 #define ata_ops(drive)          ((drive)->driver)
639
640 extern struct ata_channel ide_hwifs[];          /* master data repository */
641 extern int noautodma;
642
643 /*
644  * We need blk.h, but we replace its end_request by our own version.
645  */
646 #define IDE_DRIVER              /* Toggle some magic bits in blk.h */
647 #define LOCAL_END_REQUEST       /* Don't generate end_request in blk.h */
648 #include <linux/blk.h>
649
650 extern int __ide_end_request(struct ata_device *, struct request *, int, int);
651 extern int ide_end_request(struct ata_device *drive, struct request *, int);
652
653 /*
654  * This is used on exit from the driver, to designate the next irq handler
655  * and also to start the safety timer.
656  */
657 extern void ide_set_handler(struct ata_device *drive, ata_handler_t handler,
658                 unsigned long timeout, ata_expiry_t expiry);
659
660 /*
661  * Error reporting, in human readable form (luxurious, but a memory hog).
662  */
663 byte ide_dump_status (ide_drive_t *drive, const char *msg, byte stat);
664
665 /*
666  * ide_error() takes action based on the error returned by the controller.
667  * The caller should return immediately after invoking this.
668  */
669 ide_startstop_t ide_error (ide_drive_t *drive, const char *msg, byte stat);
670
671 /*
672  * Issue a simple drive command
673  * The drive must be selected beforehand.
674  */
675 void ide_cmd(ide_drive_t *drive, byte cmd, byte nsect, ata_handler_t handler);
676
677 /*
678  * ide_fixstring() cleans up and (optionally) byte-swaps a text string,
679  * removing leading/trailing blanks and compressing internal blanks.
680  * It is primarily used to tidy up the model name/number fields as
681  * returned by the WIN_[P]IDENTIFY commands.
682  */
683 void ide_fixstring(byte *s, const int bytecount, const int byteswap);
684
685 /*
686  * This routine busy-waits for the drive status to be not "busy".
687  * It then checks the status for all of the "good" bits and none
688  * of the "bad" bits, and if all is okay it returns 0.  All other
689  * cases return 1 after doing "*startstop = ide_error()", and the
690  * caller should return the updated value of "startstop" in this case.
691  * "startstop" is unchanged when the function returns 0;
692  */
693 int ide_wait_stat(ide_startstop_t *startstop, ide_drive_t *drive, byte good, byte bad, unsigned long timeout);
694
695 int ide_wait_noerr(ide_drive_t *drive, byte good, byte bad, unsigned long timeout);
696
697 /*
698  * This routine is called from the partition-table code in genhd.c
699  * to "convert" a drive to a logical geometry with fewer than 1024 cyls.
700  */
701 int ide_xlate_1024(kdev_t, int, int, const char *);
702
703 /*
704  * Convert kdev_t structure into ide_drive_t * one.
705  */
706 ide_drive_t *get_info_ptr(kdev_t i_rdev);
707
708 /*
709  * Re-Start an operation for an IDE interface.
710  * The caller should return immediately after invoking this.
711  */
712 ide_startstop_t restart_request(ide_drive_t *);
713
714 /*
715  * This function is intended to be used prior to invoking ide_do_drive_cmd().
716  */
717 extern void ide_init_drive_cmd(struct request *rq);
718
719 /*
720  * "action" parameter type for ide_do_drive_cmd() below.
721  */
722 typedef enum {
723         ide_wait,       /* insert rq at end of list, and wait for it */
724         ide_next,       /* insert rq immediately after current request */
725         ide_preempt,    /* insert rq in front of current request */
726         ide_end         /* insert rq at end of list, but don't wait for it */
727 } ide_action_t;
728
729 /*
730  * temporarily mapping a (possible) highmem bio for PIO transfer
731  */
732 #define ide_rq_offset(rq) (((rq)->hard_cur_sectors - (rq)->current_nr_sectors) << 9)
733
734 extern int ide_do_drive_cmd(ide_drive_t *drive, struct request *rq, ide_action_t action);
735
736 /*
737  * Clean up after success/failure of an explicit drive cmd.
738  */
739 void ide_end_drive_cmd (ide_drive_t *drive, byte stat, byte err);
740
741 struct ata_taskfile {
742         struct hd_drive_task_hdr taskfile;
743         struct hd_drive_hob_hdr  hobfile;
744         int command_type;
745         ide_startstop_t (*prehandler)(struct ata_device *, struct request *);
746         ide_startstop_t (*handler)(struct ata_device *, struct request *);
747 };
748
749 extern void ata_read(ide_drive_t *drive, void *buffer, unsigned int wcount);
750 extern void ata_write(ide_drive_t *drive, void *buffer, unsigned int wcount);
751
752 extern void atapi_read(ide_drive_t *drive, void *buffer, unsigned int bytecount);
753 extern void atapi_write(ide_drive_t *drive, void *buffer, unsigned int bytecount);
754
755 extern ide_startstop_t ata_taskfile(ide_drive_t *drive,
756                 struct ata_taskfile *args, struct request *rq);
757
758 /*
759  * Special Flagged Register Validation Caller
760  */
761
762 extern ide_startstop_t recal_intr(struct ata_device *, struct request *);
763 extern ide_startstop_t set_geometry_intr(struct ata_device *, struct request *);
764 extern ide_startstop_t set_multmode_intr(struct ata_device *, struct request *);
765 extern ide_startstop_t task_no_data_intr(struct ata_device *, struct request *);
766
767
768 /* This is setting up all fields in args, which depend upon the command type.
769  */
770 extern void ide_cmd_type_parser(struct ata_taskfile *args);
771 extern int ide_raw_taskfile(struct ata_device *drive, struct ata_taskfile *cmd, byte *buf);
772 extern int ide_cmd_ioctl(struct ata_device *drive, unsigned long arg);
773
774 void ide_delay_50ms(void);
775
776 byte ide_auto_reduce_xfer (ide_drive_t *drive);
777 int ide_driveid_update (ide_drive_t *drive);
778 int ide_ata66_check (ide_drive_t *drive, struct ata_taskfile *args);
779 int ide_config_drive_speed (ide_drive_t *drive, byte speed);
780 byte eighty_ninty_three (ide_drive_t *drive);
781 int set_transfer (ide_drive_t *drive, struct ata_taskfile *args);
782
783 extern int system_bus_speed;
784
785 /*
786  * idedisk_input_data() is a wrapper around ide_input_data() which copes
787  * with byte-swapping the input data if required.
788  */
789 extern void idedisk_input_data(ide_drive_t *drive, void *buffer, unsigned int wcount);
790
791 /*
792  * ide_stall_queue() can be used by a drive to give excess bandwidth back
793  * to the hwgroup by sleeping for timeout jiffies.
794  */
795 void ide_stall_queue (ide_drive_t *drive, unsigned long timeout);
796
797 /*
798  * ide_get_queue() returns the queue which corresponds to a given device.
799  */
800 request_queue_t *ide_get_queue(kdev_t dev);
801
802 /*
803  * CompactFlash cards and their brethern pretend to be removable hard disks,
804  * but they never have a slave unit, and they don't have doorlock mechanisms.
805  * This test catches them, and is invoked elsewhere when setting appropriate
806  * config bits.
807  */
808
809 extern int drive_is_flashcard(ide_drive_t *drive);
810
811 int ide_spin_wait_hwgroup (ide_drive_t *drive);
812 void ide_timer_expiry (unsigned long data);
813 extern void ata_irq_request(int irq, void *data, struct pt_regs *regs);
814 void do_ide_request (request_queue_t * q);
815 void ide_init_subdrivers (void);
816
817 extern struct block_device_operations ide_fops[];
818 extern ide_proc_entry_t generic_subdriver_entries[];
819
820 #ifdef CONFIG_BLK_DEV_IDE
821 /* Probe for devices attached to the systems host controllers.
822  */
823 extern int ideprobe_init (void);
824 #endif
825 #ifdef CONFIG_BLK_DEV_IDEDISK
826 extern int idedisk_init (void);
827 #endif
828 #ifdef CONFIG_BLK_DEV_IDECD
829 extern int ide_cdrom_init (void);
830 #endif
831 #ifdef CONFIG_BLK_DEV_IDETAPE
832 extern int idetape_init (void);
833 #endif
834 #ifdef CONFIG_BLK_DEV_IDEFLOPPY
835 extern int idefloppy_init (void);
836 #endif
837 #ifdef CONFIG_BLK_DEV_IDESCSI
838 extern int idescsi_init (void);
839 #endif
840
841 ide_drive_t *ide_scan_devices (byte media, const char *name, struct ata_operations *driver, int n);
842 extern int ide_register_subdriver(ide_drive_t *drive, struct ata_operations *driver);
843 extern int ide_unregister_subdriver(ide_drive_t *drive);
844
845 #ifdef CONFIG_BLK_DEV_IDEPCI
846 # define ON_BOARD               1
847 # define NEVER_BOARD            0
848 # ifdef CONFIG_BLK_DEV_OFFBOARD
849 #  define OFF_BOARD             ON_BOARD
850 # else
851 #  define OFF_BOARD             NEVER_BOARD
852 # endif
853
854 void __init ide_scan_pcibus(int scan_direction);
855 #endif
856 #ifdef CONFIG_BLK_DEV_IDEDMA
857 int ide_build_dmatable (ide_drive_t *drive, ide_dma_action_t func);
858 void ide_destroy_dmatable (ide_drive_t *drive);
859 extern ide_startstop_t ide_dma_intr(struct ata_device *, struct request *);
860 int check_drive_lists (ide_drive_t *drive, int good_bad);
861 int ide_dmaproc (ide_dma_action_t func, struct ata_device *drive, struct request *);
862 extern void ide_release_dma(struct ata_channel *hwif);
863 extern void ide_setup_dma(struct ata_channel *hwif,
864                 unsigned long dmabase, unsigned int num_ports) __init;
865 #endif
866
867 extern spinlock_t ide_lock;
868
869 #define DRIVE_LOCK(drive)               ((drive)->queue.queue_lock)
870
871 extern int drive_is_ready(ide_drive_t *drive);
872 extern void revalidate_drives(void);
873
874 #endif