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         ATA_DFLAG_LBA           = (1 << 3), /* device supports LBA */
  99
 100         ATA_DEV_UNKNOWN         = 0,    /* unknown device */
 101         ATA_DEV_ATA             = 1,    /* ATA device */
 102         ATA_DEV_ATA_UNSUP       = 2,    /* ATA device (unsupported) */
 103         ATA_DEV_ATAPI           = 3,    /* ATAPI device */
 104         ATA_DEV_ATAPI_UNSUP     = 4,    /* ATAPI device (unsupported) */
 105         ATA_DEV_NONE            = 5,    /* no device */
 106
 107         /* struct ata_port flags */
 108         ATA_FLAG_SLAVE_POSS     = (1 << 1), /* host supports slave dev */
 109                                             /* (doesn't imply presence) */
 110         ATA_FLAG_PORT_DISABLED  = (1 << 2), /* port is disabled, ignore it */
 111         ATA_FLAG_SATA           = (1 << 3),
 112         ATA_FLAG_NO_LEGACY      = (1 << 4), /* no legacy mode check */
 113         ATA_FLAG_SRST           = (1 << 5), /* use ATA SRST, not E.D.D. */
 114         ATA_FLAG_MMIO           = (1 << 6), /* use MMIO, not PIO */
 115         ATA_FLAG_SATA_RESET     = (1 << 7), /* use COMRESET */
 116         ATA_FLAG_PIO_DMA        = (1 << 8), /* PIO cmds via DMA */
 117
 118         ATA_QCFLAG_ACTIVE       = (1 << 1), /* cmd not yet ack'd to scsi lyer */
 119         ATA_QCFLAG_SG           = (1 << 3), /* have s/g table? */
 120         ATA_QCFLAG_SINGLE       = (1 << 4), /* no s/g, just a single buffer */
 121         ATA_QCFLAG_DMAMAP       = ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE,
 122
 123         /* various lengths of time */
 124         ATA_TMOUT_EDD           = 5 * HZ,       /* hueristic */
 125         ATA_TMOUT_PIO           = 30 * HZ,
 126         ATA_TMOUT_BOOT          = 30 * HZ,      /* hueristic */
 127         ATA_TMOUT_BOOT_QUICK    = 7 * HZ,       /* hueristic */
 128         ATA_TMOUT_CDB           = 30 * HZ,
 129         ATA_TMOUT_CDB_QUICK     = 5 * HZ,
 130
 131         /* ATA bus states */
 132         BUS_UNKNOWN             = 0,
 133         BUS_DMA                 = 1,
 134         BUS_IDLE                = 2,
 135         BUS_NOINTR              = 3,
 136         BUS_NODATA              = 4,
 137         BUS_TIMER               = 5,
 138         BUS_PIO                 = 6,
 139         BUS_EDD                 = 7,
 140         BUS_IDENTIFY            = 8,
 141         BUS_PACKET              = 9,
 142
 143         /* SATA port states */
 144         PORT_UNKNOWN            = 0,
 145         PORT_ENABLED            = 1,
 146         PORT_DISABLED           = 2,
 147
 148         /* encoding various smaller bitmaps into a single
 149          * unsigned long bitmap
 150          */
 151         ATA_SHIFT_UDMA          = 0,
 152         ATA_SHIFT_MWDMA         = 8,
 153         ATA_SHIFT_PIO           = 11,
 154 };
 155
 156 enum pio_task_states {
 157         PIO_ST_UNKNOWN,
 158         PIO_ST_IDLE,
 159         PIO_ST_POLL,
 160         PIO_ST_TMOUT,
 161         PIO_ST,
 162         PIO_ST_LAST,
 163         PIO_ST_LAST_POLL,
 164         PIO_ST_ERR,
 165 };
 166
 167 /* forward declarations */
 168 struct scsi_device;
 169 struct ata_port_operations;
 170 struct ata_port;
 171 struct ata_queued_cmd;
 172
 173 /* typedefs */
 174 typedef int (*ata_qc_cb_t) (struct ata_queued_cmd *qc, u8 drv_stat);
 175
 176 struct ata_ioports {
 177         unsigned long           cmd_addr;
 178         unsigned long           data_addr;
 179         unsigned long           error_addr;
 180         unsigned long           feature_addr;
 181         unsigned long           nsect_addr;
 182         unsigned long           lbal_addr;
 183         unsigned long           lbam_addr;
 184         unsigned long           lbah_addr;
 185         unsigned long           device_addr;
 186         unsigned long           status_addr;
 187         unsigned long           command_addr;
 188         unsigned long           altstatus_addr;
 189         unsigned long           ctl_addr;
 190         unsigned long           bmdma_addr;
 191         unsigned long           scr_addr;
 192 };
 193
 194 struct ata_probe_ent {
 195         struct list_head        node;
 196         struct device           *dev;
 197         struct ata_port_operations      *port_ops;
 198         Scsi_Host_Template      *sht;
 199         struct ata_ioports      port[ATA_MAX_PORTS];
 200         unsigned int            n_ports;
 201         unsigned int            hard_port_no;
 202         unsigned int            pio_mask;
 203         unsigned int            mwdma_mask;
 204         unsigned int            udma_mask;
 205         unsigned int            legacy_mode;
 206         unsigned long           irq;
 207         unsigned int            irq_flags;
 208         unsigned long           host_flags;
 209         void __iomem            *mmio_base;
 210         void                    *private_data;
 211 };
 212
 213 struct ata_host_set {
 214         spinlock_t              lock;
 215         struct device           *dev;
 216         unsigned long           irq;
 217         void __iomem            *mmio_base;
 218         unsigned int            n_ports;
 219         void                    *private_data;
 220         struct ata_port_operations *ops;
 221         struct ata_port *       ports[0];
 222 };
 223
 224 struct ata_queued_cmd {
 225         struct ata_port         *ap;
 226         struct ata_device       *dev;
 227
 228         struct scsi_cmnd        *scsicmd;
 229         void                    (*scsidone)(struct scsi_cmnd *);
 230
 231         struct ata_taskfile     tf;
 232         u8                      cdb[ATAPI_CDB_LEN];
 233
 234         unsigned long           flags;          /* ATA_QCFLAG_xxx */
 235         unsigned int            tag;
 236         unsigned int            n_elem;
 237
 238         int                     dma_dir;
 239
 240         unsigned int            nsect;
 241         unsigned int            cursect;
 242
 243         unsigned int            nbytes;
 244         unsigned int            curbytes;
 245
 246         unsigned int            cursg;
 247         unsigned int            cursg_ofs;
 248
 249         struct scatterlist      sgent;
 250         void                    *buf_virt;
 251
 252         struct scatterlist      *sg;
 253
 254         ata_qc_cb_t             complete_fn;
 255
 256         struct completion       *waiting;
 257
 258         void                    *private_data;
 259 };
 260
 261 struct ata_host_stats {
 262         unsigned long           unhandled_irq;
 263         unsigned long           idle_irq;
 264         unsigned long           rw_reqbuf;
 265 };
 266
 267 struct ata_device {
 268         u64                     n_sectors;      /* size of device, if ATA */
 269         unsigned long           flags;          /* ATA_DFLAG_xxx */
 270         unsigned int            class;          /* ATA_DEV_xxx */
 271         unsigned int            devno;          /* 0 or 1 */
 272         u16                     id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
 273         u8                      pio_mode;
 274         u8                      dma_mode;
 275         u8                      xfer_mode;
 276         unsigned int            xfer_shift;     /* ATA_SHIFT_xxx */
 277
 278         /* cache info about current transfer mode */
 279         u8                      xfer_protocol;  /* taskfile xfer protocol */
 280         u8                      read_cmd;       /* opcode to use on read */
 281         u8                      write_cmd;      /* opcode to use on write */
 282
 283         /* for CHS addressing */
 284         u16                     cylinders;      /* Number of cylinders */
 285         u16                     heads;          /* Number of heads */
 286         u16                     sectors;        /* Number of sectors per track */
 287 };
 288
 289 struct ata_port {
 290         struct Scsi_Host        *host;  /* our co-allocated scsi host */
 291         struct ata_port_operations      *ops;
 292         unsigned long           flags;  /* ATA_FLAG_xxx */
 293         unsigned int            id;     /* unique id req'd by scsi midlyr */
 294         unsigned int            port_no; /* unique port #; from zero */
 295         unsigned int            hard_port_no;   /* hardware port #; from zero */
 296
 297         struct ata_prd          *prd;    /* our SG list */
 298         dma_addr_t              prd_dma; /* and its DMA mapping */
 299
 300         struct ata_ioports      ioaddr; /* ATA cmd/ctl/dma register blocks */
 301
 302         u8                      ctl;    /* cache of ATA control register */
 303         u8                      last_ctl;       /* Cache last written value */
 304         unsigned int            bus_state;
 305         unsigned int            port_state;
 306         unsigned int            pio_mask;
 307         unsigned int            mwdma_mask;
 308         unsigned int            udma_mask;
 309         unsigned int            cbl;    /* cable type; ATA_CBL_xxx */
 310         unsigned int            cdb_len;
 311
 312         struct ata_device       device[ATA_MAX_DEVICES];
 313
 314         struct ata_queued_cmd   qcmd[ATA_MAX_QUEUE];
 315         unsigned long           qactive;
 316         unsigned int            active_tag;
 317
 318         struct ata_host_stats   stats;
 319         struct ata_host_set     *host_set;
 320
 321         struct work_struct      packet_task;
 322
 323         struct work_struct      pio_task;
 324         unsigned int            pio_task_state;
 325         unsigned long           pio_task_timeout;
 326
 327         void                    *private_data;
 328 };
 329
 330 struct ata_port_operations {
 331         void (*port_disable) (struct ata_port *);
 332
 333         void (*dev_config) (struct ata_port *, struct ata_device *);
 334
 335         void (*set_piomode) (struct ata_port *, struct ata_device *);
 336         void (*set_dmamode) (struct ata_port *, struct ata_device *);
 337
 338         void (*tf_load) (struct ata_port *ap, struct ata_taskfile *tf);
 339         void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);
 340
 341         void (*exec_command)(struct ata_port *ap, struct ata_taskfile *tf);
 342         u8   (*check_status)(struct ata_port *ap);
 343         u8   (*check_altstatus)(struct ata_port *ap);
 344         u8   (*check_err)(struct ata_port *ap);
 345         void (*dev_select)(struct ata_port *ap, unsigned int device);
 346
 347         void (*phy_reset) (struct ata_port *ap);
 348         void (*post_set_mode) (struct ata_port *ap);
 349
 350         int (*check_atapi_dma) (struct ata_queued_cmd *qc);
 351
 352         void (*bmdma_setup) (struct ata_queued_cmd *qc);
 353         void (*bmdma_start) (struct ata_queued_cmd *qc);
 354
 355         void (*qc_prep) (struct ata_queued_cmd *qc);
 356         int (*qc_issue) (struct ata_queued_cmd *qc);
 357
 358         void (*eng_timeout) (struct ata_port *ap);
 359
 360         irqreturn_t (*irq_handler)(int, void *, struct pt_regs *);
 361         void (*irq_clear) (struct ata_port *);
 362
 363         u32 (*scr_read) (struct ata_port *ap, unsigned int sc_reg);
 364         void (*scr_write) (struct ata_port *ap, unsigned int sc_reg,
 365                            u32 val);
 366
 367         int (*port_start) (struct ata_port *ap);
 368         void (*port_stop) (struct ata_port *ap);
 369
 370         void (*host_stop) (struct ata_host_set *host_set);
 371
 372         void (*bmdma_stop) (struct ata_port *ap);
 373         u8   (*bmdma_status) (struct ata_port *ap);
 374 };
 375
 376 struct ata_port_info {
 377         Scsi_Host_Template      *sht;
 378         unsigned long           host_flags;
 379         unsigned long           pio_mask;
 380         unsigned long           mwdma_mask;
 381         unsigned long           udma_mask;
 382         struct ata_port_operations      *port_ops;
 383 };
 384
 385
 386 extern void ata_port_probe(struct ata_port *);
 387 extern void __sata_phy_reset(struct ata_port *ap);
 388 extern void sata_phy_reset(struct ata_port *ap);
 389 extern void ata_bus_reset(struct ata_port *ap);
 390 extern void ata_port_disable(struct ata_port *);
 391 extern void ata_std_ports(struct ata_ioports *ioaddr);
 392 #ifdef CONFIG_PCI
 393 extern int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
 394                              unsigned int n_ports);
 395 extern void ata_pci_remove_one (struct pci_dev *pdev);
 396 #endif /* CONFIG_PCI */
 397 extern int ata_device_add(struct ata_probe_ent *ent);
 398 extern int ata_scsi_detect(Scsi_Host_Template *sht);
 399 extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
 400 extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
 401 extern int ata_scsi_error(struct Scsi_Host *host);
 402 extern int ata_scsi_release(struct Scsi_Host *host);
 403 extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
 404 /*
 405  * Default driver ops implementations
 406  */
 407 extern void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf);
 408 extern void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
 409 extern void ata_tf_to_fis(struct ata_taskfile *tf, u8 *fis, u8 pmp);
 410 extern void ata_tf_from_fis(u8 *fis, struct ata_taskfile *tf);
 411 extern void ata_noop_dev_select (struct ata_port *ap, unsigned int device);
 412 extern void ata_std_dev_select (struct ata_port *ap, unsigned int device);
 413 extern u8 ata_check_status(struct ata_port *ap);
 414 extern u8 ata_altstatus(struct ata_port *ap);
 415 extern u8 ata_chk_err(struct ata_port *ap);
 416 extern void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf);
 417 extern int ata_port_start (struct ata_port *ap);
 418 extern void ata_port_stop (struct ata_port *ap);
 419 extern void ata_host_stop (struct ata_host_set *host_set);
 420 extern irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs);
 421 extern void ata_qc_prep(struct ata_queued_cmd *qc);
 422 extern int ata_qc_issue_prot(struct ata_queued_cmd *qc);
 423 extern void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf,
 424                 unsigned int buflen);
 425 extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
 426                  unsigned int n_elem);
 427 extern unsigned int ata_dev_classify(struct ata_taskfile *tf);
 428 extern void ata_dev_id_string(u16 *id, unsigned char *s,
 429                               unsigned int ofs, unsigned int len);
 430 extern void ata_dev_config(struct ata_port *ap, unsigned int i);
 431 extern void ata_bmdma_setup (struct ata_queued_cmd *qc);
 432 extern void ata_bmdma_start (struct ata_queued_cmd *qc);
 433 extern void ata_bmdma_stop(struct ata_port *ap);
 434 extern u8   ata_bmdma_status(struct ata_port *ap);
 435 extern void ata_bmdma_irq_clear(struct ata_port *ap);
 436 extern void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat);
 437 extern void ata_eng_timeout(struct ata_port *ap);
 438 extern void ata_scsi_simulate(u16 *id, struct scsi_cmnd *cmd,
 439                               void (*done)(struct scsi_cmnd *));
 440 extern int ata_std_bios_param(struct scsi_device *sdev,
 441                               struct block_device *bdev,
 442                               sector_t capacity, int geom[]);
 443 extern int ata_scsi_slave_config(struct scsi_device *sdev);
 444
 445
 446 #ifdef CONFIG_PCI
 447 struct pci_bits {
 448         unsigned int            reg;    /* PCI config register to read */
 449         unsigned int            width;  /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
 450         unsigned long           mask;
 451         unsigned long           val;
 452 };
 453
 454 extern struct ata_probe_ent *
 455 ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port);
 456 extern int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits);
 457
 458 #endif /* CONFIG_PCI */
 459
 460
 461 static inline unsigned int ata_tag_valid(unsigned int tag)
 462 {
 463         return (tag < ATA_MAX_QUEUE) ? 1 : 0;
 464 }
 465
 466 static inline unsigned int ata_dev_present(struct ata_device *dev)
 467 {
 468         return ((dev->class == ATA_DEV_ATA) ||
 469                 (dev->class == ATA_DEV_ATAPI));
 470 }
 471
 472 static inline u8 ata_chk_status(struct ata_port *ap)
 473 {
 474         return ap->ops->check_status(ap);
 475 }
 476
 477
 478 /**
 479  *      ata_pause - Flush writes and pause 400 nanoseconds.
 480  *      @ap: Port to wait for.
 481  *
 482  *      LOCKING:
 483  *      Inherited from caller.
 484  */
 485
 486 static inline void ata_pause(struct ata_port *ap)
 487 {
 488         ata_altstatus(ap);
 489         ndelay(400);
 490 }
 491
 492
 493 /**
 494  *      ata_busy_wait - Wait for a port status register
 495  *      @ap: Port to wait for.
 496  *
 497  *      Waits up to max*10 microseconds for the selected bits in the port's
 498  *      status register to be cleared.
 499  *      Returns final value of status register.
 500  *
 501  *      LOCKING:
 502  *      Inherited from caller.
 503  */
 504
 505 static inline u8 ata_busy_wait(struct ata_port *ap, unsigned int bits,
 506                                unsigned int max)
 507 {
 508         u8 status;
 509
 510         do {
 511                 udelay(10);
 512                 status = ata_chk_status(ap);
 513                 max--;
 514         } while ((status & bits) && (max > 0));
 515
 516         return status;
 517 }
 518
 519
 520 /**
 521  *      ata_wait_idle - Wait for a port to be idle.
 522  *      @ap: Port to wait for.
 523  *
 524  *      Waits up to 10ms for port's BUSY and DRQ signals to clear.
 525  *      Returns final value of status register.
 526  *
 527  *      LOCKING:
 528  *      Inherited from caller.
 529  */
 530
 531 static inline u8 ata_wait_idle(struct ata_port *ap)
 532 {
 533         u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
 534
 535         if (status & (ATA_BUSY | ATA_DRQ)) {
 536                 unsigned long l = ap->ioaddr.status_addr;
 537                 printk(KERN_WARNING
 538                        "ATA: abnormal status 0x%X on port 0x%lX\n",
 539                        status, l);
 540         }
 541
 542         return status;
 543 }
 544
 545 static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
 546 {
 547         qc->tf.ctl |= ATA_NIEN;
 548 }
 549
 550 static inline struct ata_queued_cmd *ata_qc_from_tag (struct ata_port *ap,
 551                                                       unsigned int tag)
 552 {
 553         if (likely(ata_tag_valid(tag)))
 554                 return &ap->qcmd[tag];
 555         return NULL;
 556 }
 557
 558 static inline void ata_tf_init(struct ata_port *ap, struct ata_taskfile *tf, unsigned int device)
 559 {
 560         memset(tf, 0, sizeof(*tf));
 561
 562         tf->ctl = ap->ctl;
 563         if (device == 0)
 564                 tf->device = ATA_DEVICE_OBS;
 565         else
 566                 tf->device = ATA_DEVICE_OBS | ATA_DEV1;
 567 }
 568
 569
 570 /**
 571  *      ata_irq_on - Enable interrupts on a port.
 572  *      @ap: Port on which interrupts are enabled.
 573  *
 574  *      Enable interrupts on a legacy IDE device using MMIO or PIO,
 575  *      wait for idle, clear any pending interrupts.
 576  *
 577  *      LOCKING:
 578  *      Inherited from caller.
 579  */
 580
 581 static inline u8 ata_irq_on(struct ata_port *ap)
 582 {
 583         struct ata_ioports *ioaddr = &ap->ioaddr;
 584         u8 tmp;
 585
 586         ap->ctl &= ~ATA_NIEN;
 587         ap->last_ctl = ap->ctl;
 588
 589         if (ap->flags & ATA_FLAG_MMIO)
 590                 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
 591         else
 592                 outb(ap->ctl, ioaddr->ctl_addr);
 593         tmp = ata_wait_idle(ap);
 594
 595         ap->ops->irq_clear(ap);
 596
 597         return tmp;
 598 }
 599
 600
 601 /**
 602  *      ata_irq_ack - Acknowledge a device interrupt.
 603  *      @ap: Port on which interrupts are enabled.
 604  *
 605  *      Wait up to 10 ms for legacy IDE device to become idle (BUSY
 606  *      or BUSY+DRQ clear).  Obtain dma status and port status from
 607  *      device.  Clear the interrupt.  Return port status.
 608  *
 609  *      LOCKING:
 610  */
 611
 612 static inline u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq)
 613 {
 614         unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
 615         u8 host_stat, post_stat, status;
 616
 617         status = ata_busy_wait(ap, bits, 1000);
 618         if (status & bits)
 619                 DPRINTK("abnormal status 0x%X\n", status);
 620
 621         /* get controller status; clear intr, err bits */
 622         if (ap->flags & ATA_FLAG_MMIO) {
 623                 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
 624                 host_stat = readb(mmio + ATA_DMA_STATUS);
 625                 writeb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
 626                        mmio + ATA_DMA_STATUS);
 627
 628                 post_stat = readb(mmio + ATA_DMA_STATUS);
 629         } else {
 630                 host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 631                 outb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
 632                      ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 633
 634                 post_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 635         }
 636
 637         VPRINTK("irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n",
 638                 host_stat, post_stat, status);
 639
 640         return status;
 641 }
 642
 643 static inline u32 scr_read(struct ata_port *ap, unsigned int reg)
 644 {
 645         return ap->ops->scr_read(ap, reg);
 646 }
 647
 648 static inline void scr_write(struct ata_port *ap, unsigned int reg, u32 val)
 649 {
 650         ap->ops->scr_write(ap, reg, val);
 651 }
 652
 653 static inline void scr_write_flush(struct ata_port *ap, unsigned int reg,
 654                                    u32 val)
 655 {
 656         ap->ops->scr_write(ap, reg, val);
 657         (void) ap->ops->scr_read(ap, reg);
 658 }
 659
 660 static inline unsigned int sata_dev_present(struct ata_port *ap)
 661 {
 662         return ((scr_read(ap, SCR_STATUS) & 0xf) == 0x3) ? 1 : 0;
 663 }
 664
 665 static inline int ata_try_flush_cache(struct ata_device *dev)
 666 {
 667         return ata_id_wcache_enabled(dev->id) ||
 668                ata_id_has_flush(dev->id) ||
 669                ata_id_has_flush_ext(dev->id);
 670 }
 671
 672 #endif /* __LINUX_LIBATA_H__ */