source: svn/trunk/newcon3bcm2_21bu/toolchain/mips-linux-uclibc/include/linux/libata.h @ 2

Last change on this file since 2 was 2, checked in by phkim, 11 years ago

1.phkim

  1. revision copy newcon3sk r27
  • Property svn:executable set to *
File size: 18.2 KB
Line 
1/*
2   Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
3   Copyright 2003-2004 Jeff Garzik
4
5   The contents of this file are subject to the Open
6   Software License version 1.1 that can be found at
7   http://www.opensource.org/licenses/osl-1.1.txt and is included herein
8   by reference.
9
10   Alternatively, the contents of this file may be used under the terms
11   of the GNU General Public License version 2 (the "GPL") as distributed
12   in the kernel source COPYING file, in which case the provisions of
13   the GPL are applicable instead of the above.  If you wish to allow
14   the use of your version of this file only under the terms of the
15   GPL and not to allow others to use your version of this file under
16   the OSL, indicate your decision by deleting the provisions above and
17   replace them with the notice and other provisions required by the GPL.
18   If you do not delete the provisions above, a recipient may use your
19   version of this file under either the OSL or the GPL.
20
21 */
22
23#ifndef __LINUX_LIBATA_H__
24#define __LINUX_LIBATA_H__
25
26#include <asm/types.h>
27
28#include <linux/delay.h>
29#include <linux/interrupt.h>
30#include <linux/pci.h>
31#include <asm/io.h>
32#include <linux/ata.h>
33#include <linux/workqueue.h>
34
35/*
36 * compile-time options
37 */
38#undef ATA_DEBUG                /* debugging output */
39#undef ATA_VERBOSE_DEBUG        /* yet more debugging output */
40#undef ATA_IRQ_TRAP             /* define to ack screaming irqs */
41#undef ATA_NDEBUG               /* define to disable quick runtime checks */
42#undef ATA_ENABLE_ATAPI         /* define to enable ATAPI support */
43#undef ATA_ENABLE_PATA          /* define to enable PATA support in some
44                                 * low-level drivers */
45#undef ATAPI_ENABLE_DMADIR      /* enables ATAPI DMADIR bridge support */
46
47
48/* note: prints function name for you */
49#ifdef ATA_DEBUG
50#define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
51#ifdef ATA_VERBOSE_DEBUG
52#define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
53#else
54#define VPRINTK(fmt, args...)
55#endif  /* ATA_VERBOSE_DEBUG */
56#else
57#define DPRINTK(fmt, args...)
58#define VPRINTK(fmt, args...)
59#endif  /* ATA_DEBUG */
60
61#ifdef ATA_NDEBUG
62#define assert(expr)
63#else
64#define assert(expr) \
65        if(unlikely(!(expr))) {                                   \
66        printk(KERN_ERR "Assertion failed! %s,%s,%s,line=%d\n", \
67        #expr,__FILE__,__FUNCTION__,__LINE__);          \
68        }
69#endif
70
71/* defines only for the constants which don't work well as enums */
72#define ATA_TAG_POISON          0xfafbfcfdU
73
74/* move to PCI layer? */
75static inline struct device *pci_dev_to_dev(struct pci_dev *pdev)
76{
77        return &pdev->dev;
78}
79
80enum {
81        /* various global constants */
82        LIBATA_MAX_PRD          = ATA_MAX_PRD / 2,
83        ATA_MAX_PORTS           = 8,
84        ATA_DEF_QUEUE           = 1,
85        ATA_MAX_QUEUE           = 1,
86        ATA_MAX_SECTORS         = 200,  /* FIXME */
87        ATA_MAX_BUS             = 2,
88        ATA_DEF_BUSY_WAIT       = 10000,
89        ATA_SHORT_PAUSE         = (HZ >> 6) + 1,
90
91        ATA_SHT_EMULATED        = 1,
92        ATA_SHT_CMD_PER_LUN     = 1,
93        ATA_SHT_THIS_ID         = -1,
94        ATA_SHT_USE_CLUSTERING  = 0,
95
96        /* struct ata_device stuff */
97        ATA_DFLAG_LBA48         = (1 << 0), /* device supports LBA48 */
98        ATA_DFLAG_PIO           = (1 << 1), /* device currently in PIO mode */
99        ATA_DFLAG_LOCK_SECTORS  = (1 << 2), /* don't adjust max_sectors */
100
101        ATA_DEV_UNKNOWN         = 0,    /* unknown device */
102        ATA_DEV_ATA             = 1,    /* ATA device */
103        ATA_DEV_ATA_UNSUP       = 2,    /* ATA device (unsupported) */
104        ATA_DEV_ATAPI           = 3,    /* ATAPI device */
105        ATA_DEV_ATAPI_UNSUP     = 4,    /* ATAPI device (unsupported) */
106        ATA_DEV_NONE            = 5,    /* no device */
107
108        /* struct ata_port flags */
109        ATA_FLAG_SLAVE_POSS     = (1 << 1), /* host supports slave dev */
110                                            /* (doesn't imply presence) */
111        ATA_FLAG_PORT_DISABLED  = (1 << 2), /* port is disabled, ignore it */
112        ATA_FLAG_SATA           = (1 << 3),
113        ATA_FLAG_NO_LEGACY      = (1 << 4), /* no legacy mode check */
114        ATA_FLAG_SRST           = (1 << 5), /* use ATA SRST, not E.D.D. */
115        ATA_FLAG_MMIO           = (1 << 6), /* use MMIO, not PIO */
116        ATA_FLAG_SATA_RESET     = (1 << 7), /* use COMRESET */
117        ATA_FLAG_PIO_DMA        = (1 << 8), /* PIO cmds via DMA */
118
119        ATA_QCFLAG_ACTIVE       = (1 << 1), /* cmd not yet ack'd to scsi lyer */
120        ATA_QCFLAG_SG           = (1 << 3), /* have s/g table? */
121        ATA_QCFLAG_SINGLE       = (1 << 4), /* no s/g, just a single buffer */
122        ATA_QCFLAG_DMAMAP       = ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE,
123
124        /* various lengths of time */
125        ATA_TMOUT_EDD           = 5 * HZ,       /* hueristic */
126        ATA_TMOUT_PIO           = 30 * HZ,
127        ATA_TMOUT_BOOT          = 30 * HZ,      /* hueristic */
128        ATA_TMOUT_BOOT_QUICK    = 7 * HZ,       /* hueristic */
129        ATA_TMOUT_CDB           = 30 * HZ,
130        ATA_TMOUT_CDB_QUICK     = 5 * HZ,
131
132        /* ATA bus states */
133        BUS_UNKNOWN             = 0,
134        BUS_DMA                 = 1,
135        BUS_IDLE                = 2,
136        BUS_NOINTR              = 3,
137        BUS_NODATA              = 4,
138        BUS_TIMER               = 5,
139        BUS_PIO                 = 6,
140        BUS_EDD                 = 7,
141        BUS_IDENTIFY            = 8,
142        BUS_PACKET              = 9,
143
144        /* SATA port states */
145        PORT_UNKNOWN            = 0,
146        PORT_ENABLED            = 1,
147        PORT_DISABLED           = 2,
148
149        /* encoding various smaller bitmaps into a single
150         * unsigned long bitmap
151         */
152        ATA_SHIFT_UDMA          = 0,
153        ATA_SHIFT_MWDMA         = 8,
154        ATA_SHIFT_PIO           = 11,
155};
156
157enum pio_task_states {
158        PIO_ST_UNKNOWN,
159        PIO_ST_IDLE,
160        PIO_ST_POLL,
161        PIO_ST_TMOUT,
162        PIO_ST,
163        PIO_ST_LAST,
164        PIO_ST_LAST_POLL,
165        PIO_ST_ERR,
166};
167
168/* forward declarations */
169struct scsi_device;
170struct ata_port_operations;
171struct ata_port;
172struct ata_queued_cmd;
173
174/* typedefs */
175typedef int (*ata_qc_cb_t) (struct ata_queued_cmd *qc, __u8 drv_stat);
176
177struct ata_ioports {
178        unsigned long           cmd_addr;
179        unsigned long           data_addr;
180        unsigned long           error_addr;
181        unsigned long           feature_addr;
182        unsigned long           nsect_addr;
183        unsigned long           lbal_addr;
184        unsigned long           lbam_addr;
185        unsigned long           lbah_addr;
186        unsigned long           device_addr;
187        unsigned long           status_addr;
188        unsigned long           command_addr;
189        unsigned long           altstatus_addr;
190        unsigned long           ctl_addr;
191        unsigned long           bmdma_addr;
192        unsigned long           scr_addr;
193};
194
195struct ata_probe_ent {
196        struct list_head        node;
197        struct device           *dev;
198        struct ata_port_operations      *port_ops;
199        Scsi_Host_Template      *sht;
200        struct ata_ioports      port[ATA_MAX_PORTS];
201        unsigned int            n_ports;
202        unsigned int            hard_port_no;
203        unsigned int            pio_mask;
204        unsigned int            mwdma_mask;
205        unsigned int            udma_mask;
206        unsigned int            legacy_mode;
207        unsigned long           irq;
208        unsigned int            irq_flags;
209        unsigned long           host_flags;
210        void            *mmio_base;
211        void                    *private_data;
212};
213
214struct ata_host_set {
215        spinlock_t              lock;
216        struct device           *dev;
217        unsigned long           irq;
218        void            *mmio_base;
219        unsigned int            n_ports;
220        void                    *private_data;
221        struct ata_port_operations *ops;
222        struct ata_port *       ports[0];
223};
224
225struct ata_queued_cmd {
226        struct ata_port         *ap;
227        struct ata_device       *dev;
228
229        struct scsi_cmnd        *scsicmd;
230        void                    (*scsidone)(struct scsi_cmnd *);
231
232        struct ata_taskfile     tf;
233        __u8                    cdb[ATAPI_CDB_LEN];
234
235        unsigned long           flags;          /* ATA_QCFLAG_xxx */
236        unsigned int            tag;
237        unsigned int            n_elem;
238
239        int                     dma_dir;
240
241        unsigned int            nsect;
242        unsigned int            cursect;
243
244        unsigned int            nbytes;
245        unsigned int            curbytes;
246
247        unsigned int            cursg;
248        unsigned int            cursg_ofs;
249
250        struct scatterlist      sgent;
251        void                    *buf_virt;
252
253        struct scatterlist      *sg;
254
255        ata_qc_cb_t             complete_fn;
256
257        struct completion       *waiting;
258
259        void                    *private_data;
260};
261
262struct ata_host_stats {
263        unsigned long           unhandled_irq;
264        unsigned long           idle_irq;
265        unsigned long           rw_reqbuf;
266};
267
268struct ata_device {
269        __u64                   n_sectors;      /* size of device, if ATA */
270        unsigned long           flags;          /* ATA_DFLAG_xxx */
271        unsigned int            class;          /* ATA_DEV_xxx */
272        unsigned int            devno;          /* 0 or 1 */
273        __u16                   id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
274        __u8                    pio_mode;
275        __u8                    dma_mode;
276        __u8                    xfer_mode;
277        unsigned int            xfer_shift;     /* ATA_SHIFT_xxx */
278
279        /* cache info about current transfer mode */
280        __u8                    xfer_protocol;  /* taskfile xfer protocol */
281        __u8                    read_cmd;       /* opcode to use on read */
282        __u8                    write_cmd;      /* opcode to use on write */
283};
284
285struct ata_port {
286        struct Scsi_Host        *host;  /* our co-allocated scsi host */
287        struct ata_port_operations      *ops;
288        unsigned long           flags;  /* ATA_FLAG_xxx */
289        unsigned int            id;     /* unique id req'd by scsi midlyr */
290        unsigned int            port_no; /* unique port #; from zero */
291        unsigned int            hard_port_no;   /* hardware port #; from zero */
292
293        struct ata_prd          *prd;    /* our SG list */
294        dma_addr_t              prd_dma; /* and its DMA mapping */
295
296        struct ata_ioports      ioaddr; /* ATA cmd/ctl/dma register blocks */
297
298        __u8                    ctl;    /* cache of ATA control register */
299        __u8                    last_ctl;       /* Cache last written value */
300        unsigned int            bus_state;
301        unsigned int            port_state;
302        unsigned int            pio_mask;
303        unsigned int            mwdma_mask;
304        unsigned int            udma_mask;
305        unsigned int            cbl;    /* cable type; ATA_CBL_xxx */
306        unsigned int            cdb_len;
307
308        struct ata_device       device[ATA_MAX_DEVICES];
309
310        struct ata_queued_cmd   qcmd[ATA_MAX_QUEUE];
311        unsigned long           qactive;
312        unsigned int            active_tag;
313
314        struct ata_host_stats   stats;
315        struct ata_host_set     *host_set;
316
317        struct work_struct      packet_task;
318
319        struct work_struct      pio_task;
320        unsigned int            pio_task_state;
321        unsigned long           pio_task_timeout;
322
323        void                    *private_data;
324};
325
326struct ata_port_operations {
327        void (*port_disable) (struct ata_port *);
328
329        void (*dev_config) (struct ata_port *, struct ata_device *);
330
331        void (*set_piomode) (struct ata_port *, struct ata_device *);
332        void (*set_dmamode) (struct ata_port *, struct ata_device *);
333
334        void (*tf_load) (struct ata_port *ap, struct ata_taskfile *tf);
335        void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);
336
337        void (*exec_command)(struct ata_port *ap, struct ata_taskfile *tf);
338        __u8   (*check_status)(struct ata_port *ap);
339        __u8   (*check_altstatus)(struct ata_port *ap);
340        __u8   (*check_err)(struct ata_port *ap);
341        void (*dev_select)(struct ata_port *ap, unsigned int device);
342
343        void (*phy_reset) (struct ata_port *ap);
344        void (*post_set_mode) (struct ata_port *ap);
345
346        int (*check_atapi_dma) (struct ata_queued_cmd *qc);
347
348        void (*bmdma_setup) (struct ata_queued_cmd *qc);
349        void (*bmdma_start) (struct ata_queued_cmd *qc);
350
351        void (*qc_prep) (struct ata_queued_cmd *qc);
352        int (*qc_issue) (struct ata_queued_cmd *qc);
353
354        void (*eng_timeout) (struct ata_port *ap);
355
356        irqreturn_t (*irq_handler)(int, void *, struct pt_regs *);
357        void (*irq_clear) (struct ata_port *);
358
359        __u32 (*scr_read) (struct ata_port *ap, unsigned int sc_reg);
360        void (*scr_write) (struct ata_port *ap, unsigned int sc_reg,
361                           __u32 val);
362
363        int (*port_start) (struct ata_port *ap);
364        void (*port_stop) (struct ata_port *ap);
365
366        void (*host_stop) (struct ata_host_set *host_set);
367
368        void (*bmdma_stop) (struct ata_port *ap);
369        __u8   (*bmdma_status) (struct ata_port *ap);
370};
371
372struct ata_port_info {
373        Scsi_Host_Template      *sht;
374        unsigned long           host_flags;
375        unsigned long           pio_mask;
376        unsigned long           mwdma_mask;
377        unsigned long           udma_mask;
378        struct ata_port_operations      *port_ops;
379};
380
381
382extern void ata_port_probe(struct ata_port *);
383extern void __sata_phy_reset(struct ata_port *ap);
384extern void sata_phy_reset(struct ata_port *ap);
385extern void ata_bus_reset(struct ata_port *ap);
386extern void ata_port_disable(struct ata_port *);
387extern void ata_std_ports(struct ata_ioports *ioaddr);
388#ifdef CONFIG_PCI
389extern int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
390                             unsigned int n_ports);
391extern void ata_pci_remove_one (struct pci_dev *pdev);
392#endif /* CONFIG_PCI */
393extern int ata_device_add(struct ata_probe_ent *ent);
394extern int ata_scsi_detect(Scsi_Host_Template *sht);
395extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
396extern int ata_scsi_error(struct Scsi_Host *host);
397extern int ata_scsi_release(struct Scsi_Host *host);
398extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
399/*
400 * Default driver ops implementations
401 */
402extern void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf);
403extern void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
404extern void ata_tf_to_fis(struct ata_taskfile *tf, __u8 *fis, __u8 pmp);
405extern void ata_tf_from_fis(__u8 *fis, struct ata_taskfile *tf);
406extern void ata_noop_dev_select (struct ata_port *ap, unsigned int device);
407extern void ata_std_dev_select (struct ata_port *ap, unsigned int device);
408extern __u8 ata_check_status(struct ata_port *ap);
409extern __u8 ata_altstatus(struct ata_port *ap);
410extern __u8 ata_chk_err(struct ata_port *ap);
411extern void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf);
412extern int ata_port_start (struct ata_port *ap);
413extern void ata_port_stop (struct ata_port *ap);
414extern void ata_host_stop (struct ata_host_set *host_set);
415extern irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs);
416extern void ata_qc_prep(struct ata_queued_cmd *qc);
417extern int ata_qc_issue_prot(struct ata_queued_cmd *qc);
418extern void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf,
419                unsigned int buflen);
420extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
421                 unsigned int n_elem);
422extern unsigned int ata_dev_classify(struct ata_taskfile *tf);
423extern void ata_dev_id_string(__u16 *id, unsigned char *s,
424                              unsigned int ofs, unsigned int len);
425extern void ata_bmdma_setup (struct ata_queued_cmd *qc);
426extern void ata_bmdma_start (struct ata_queued_cmd *qc);
427extern void ata_bmdma_stop(struct ata_port *ap);
428extern __u8   ata_bmdma_status(struct ata_port *ap);
429extern void ata_bmdma_irq_clear(struct ata_port *ap);
430extern void ata_qc_complete(struct ata_queued_cmd *qc, __u8 drv_stat);
431extern void ata_eng_timeout(struct ata_port *ap);
432extern void ata_scsi_simulate(__u16 *id, struct scsi_cmnd *cmd,
433                              void (*done)(struct scsi_cmnd *));
434extern int ata_std_bios_param(struct scsi_device *sdev,
435                              struct block_device *bdev,
436                              sector_t capacity, int geom[]);
437extern int ata_scsi_slave_config(struct scsi_device *sdev);
438
439
440#ifdef CONFIG_PCI
441struct pci_bits {
442        unsigned int            reg;    /* PCI config register to read */
443        unsigned int            width;  /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
444        unsigned long           mask;
445        unsigned long           val;
446};
447
448extern struct ata_probe_ent *
449ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port);
450extern int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits);
451
452#endif /* CONFIG_PCI */
453
454
455static inline unsigned int ata_tag_valid(unsigned int tag)
456{
457        return (tag < ATA_MAX_QUEUE) ? 1 : 0;
458}
459
460static inline unsigned int ata_dev_present(struct ata_device *dev)
461{
462        return ((dev->class == ATA_DEV_ATA) ||
463                (dev->class == ATA_DEV_ATAPI));
464}
465
466static inline __u8 ata_chk_status(struct ata_port *ap)
467{
468        return ap->ops->check_status(ap);
469}
470
471
472/**
473 *      ata_pause - Flush writes and pause 400 nanoseconds.
474 *      @ap: Port to wait for.
475 *
476 *      LOCKING:
477 *      Inherited from caller.
478 */
479
480static inline void ata_pause(struct ata_port *ap)
481{
482        ata_altstatus(ap);
483        ndelay(400);
484}
485
486
487/**
488 *      ata_busy_wait - Wait for a port status register
489 *      @ap: Port to wait for.
490 *
491 *      Waits up to max*10 microseconds for the selected bits in the port's
492 *      status register to be cleared.
493 *      Returns final value of status register.
494 *
495 *      LOCKING:
496 *      Inherited from caller.
497 */
498
499static inline __u8 ata_busy_wait(struct ata_port *ap, unsigned int bits,
500                               unsigned int max)
501{
502        __u8 status;
503
504        do {
505                udelay(10);
506                status = ata_chk_status(ap);
507                max--;
508        } while ((status & bits) && (max > 0));
509
510        return status;
511}
512
513
514/**
515 *      ata_wait_idle - Wait for a port to be idle.
516 *      @ap: Port to wait for.
517 *
518 *      Waits up to 10ms for port's BUSY and DRQ signals to clear.
519 *      Returns final value of status register.
520 *
521 *      LOCKING:
522 *      Inherited from caller.
523 */
524
525static inline __u8 ata_wait_idle(struct ata_port *ap)
526{
527        __u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
528
529        if (status & (ATA_BUSY | ATA_DRQ)) {
530                unsigned long l = ap->ioaddr.status_addr;
531                printk(KERN_WARNING
532                       "ATA: abnormal status 0x%X on port 0x%lX\n",
533                       status, l);
534        }
535
536        return status;
537}
538
539static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
540{
541        qc->tf.ctl |= ATA_NIEN;
542}
543
544static inline struct ata_queued_cmd *ata_qc_from_tag (struct ata_port *ap,
545                                                      unsigned int tag)
546{
547        if (likely(ata_tag_valid(tag)))
548                return &ap->qcmd[tag];
549        return NULL;
550}
551
552static inline void ata_tf_init(struct ata_port *ap, struct ata_taskfile *tf, unsigned int device)
553{
554        memset(tf, 0, sizeof(*tf));
555
556        tf->ctl = ap->ctl;
557        if (device == 0)
558                tf->device = ATA_DEVICE_OBS;
559        else
560                tf->device = ATA_DEVICE_OBS | ATA_DEV1;
561}
562
563
564/**
565 *      ata_irq_on - Enable interrupts on a port.
566 *      @ap: Port on which interrupts are enabled.
567 *
568 *      Enable interrupts on a legacy IDE device using MMIO or PIO,
569 *      wait for idle, clear any pending interrupts.
570 *
571 *      LOCKING:
572 *      Inherited from caller.
573 */
574
575static inline __u8 ata_irq_on(struct ata_port *ap)
576{
577        struct ata_ioports *ioaddr = &ap->ioaddr;
578        __u8 tmp;
579
580        ap->ctl &= ~ATA_NIEN;
581        ap->last_ctl = ap->ctl;
582
583        if (ap->flags & ATA_FLAG_MMIO)
584                writeb(ap->ctl, (void *) ioaddr->ctl_addr);
585        else
586                outb(ap->ctl, ioaddr->ctl_addr);
587        tmp = ata_wait_idle(ap);
588
589        ap->ops->irq_clear(ap);
590
591        return tmp;
592}
593
594
595/**
596 *      ata_irq_ack - Acknowledge a device interrupt.
597 *      @ap: Port on which interrupts are enabled.
598 *
599 *      Wait up to 10 ms for legacy IDE device to become idle (BUSY
600 *      or BUSY+DRQ clear).  Obtain dma status and port status from
601 *      device.  Clear the interrupt.  Return port status.
602 *
603 *      LOCKING:
604 */
605
606static inline __u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq)
607{
608        unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
609        __u8 host_stat, post_stat, status;
610
611        status = ata_busy_wait(ap, bits, 1000);
612        if (status & bits)
613                DPRINTK("abnormal status 0x%X\n", status);
614
615        /* get controller status; clear intr, err bits */
616        if (ap->flags & ATA_FLAG_MMIO) {
617                void *mmio = (void *) ap->ioaddr.bmdma_addr;
618                host_stat = readb(mmio + ATA_DMA_STATUS);
619                writeb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
620                       mmio + ATA_DMA_STATUS);
621
622                post_stat = readb(mmio + ATA_DMA_STATUS);
623        } else {
624                host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
625                outb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
626                     ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
627
628                post_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
629        }
630
631        VPRINTK("irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n",
632                host_stat, post_stat, status);
633
634        return status;
635}
636
637static inline __u32 scr_read(struct ata_port *ap, unsigned int reg)
638{
639        return ap->ops->scr_read(ap, reg);
640}
641
642static inline void scr_write(struct ata_port *ap, unsigned int reg, __u32 val)
643{
644        ap->ops->scr_write(ap, reg, val);
645}
646
647static inline void scr_write_flush(struct ata_port *ap, unsigned int reg, 
648                                   __u32 val)
649{
650        ap->ops->scr_write(ap, reg, val);
651        (void) ap->ops->scr_read(ap, reg);
652}
653
654static inline unsigned int sata_dev_present(struct ata_port *ap)
655{
656        return ((scr_read(ap, SCR_STATUS) & 0xf) == 0x3) ? 1 : 0;
657}
658
659static inline int ata_try_flush_cache(struct ata_device *dev)
660{
661        return ata_id_wcache_enabled(dev->id) ||
662               ata_id_has_flush(dev->id) ||
663               ata_id_has_flush_ext(dev->id);
664}
665
666#endif /* __LINUX_LIBATA_H__ */
Note: See TracBrowser for help on using the repository browser.