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