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