include/linux/libata.h

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