git.oblomov.eu Git - linux-2.6/blob - 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         ATA_FLAG_NOINTR         = (1 << 9), /* FIXME: Remove this once
 117                                              * proper HSM is in place. */
 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
 157 enum 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 */
 169 struct scsi_device;
 170 struct ata_port_operations;
 171 struct ata_port;
 172 struct ata_queued_cmd;
 173
 174 /* typedefs */
 175 typedef int (*ata_qc_cb_t) (struct ata_queued_cmd *qc, u8 drv_stat);
 176
 177 struct 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
 195 struct 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 __iomem            *mmio_base;
 211         void                    *private_data;
 212 };
 213
 214 struct ata_host_set {
 215         spinlock_t              lock;
 216         struct device           *dev;
 217         unsigned long           irq;
 218         void __iomem            *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
 225 struct 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
 262 struct ata_host_stats {
 263         unsigned long           unhandled_irq;
 264         unsigned long           idle_irq;
 265         unsigned long           rw_reqbuf;
 266 };
 267
 268 struct 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
 285 struct 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
 326 struct 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_queued_cmd *qc);
 369         u8   (*bmdma_status) (struct ata_port *ap);
 370 };
 371
 372 struct 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
 382 extern void ata_port_probe(struct ata_port *);
 383 extern void __sata_phy_reset(struct ata_port *ap);
 384 extern void sata_phy_reset(struct ata_port *ap);
 385 extern void ata_bus_reset(struct ata_port *ap);
 386 extern void ata_port_disable(struct ata_port *);
 387 extern void ata_std_ports(struct ata_ioports *ioaddr);
 388 #ifdef CONFIG_PCI
 389 extern int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
 390                              unsigned int n_ports);
 391 extern void ata_pci_remove_one (struct pci_dev *pdev);
 392 #endif /* CONFIG_PCI */
 393 extern int ata_device_add(struct ata_probe_ent *ent);
 394 extern int ata_scsi_detect(Scsi_Host_Template *sht);
 395 extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
 396 extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
 397 extern int ata_scsi_error(struct Scsi_Host *host);
 398 extern int ata_scsi_release(struct Scsi_Host *host);
 399 extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
 400 /*
 401  * Default driver ops implementations
 402  */
 403 extern void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf);
 404 extern void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
 405 extern void ata_tf_to_fis(struct ata_taskfile *tf, u8 *fis, u8 pmp);
 406 extern void ata_tf_from_fis(u8 *fis, struct ata_taskfile *tf);
 407 extern void ata_noop_dev_select (struct ata_port *ap, unsigned int device);
 408 extern void ata_std_dev_select (struct ata_port *ap, unsigned int device);
 409 extern u8 ata_check_status(struct ata_port *ap);
 410 extern u8 ata_altstatus(struct ata_port *ap);
 411 extern u8 ata_chk_err(struct ata_port *ap);
 412 extern void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf);
 413 extern int ata_port_start (struct ata_port *ap);
 414 extern void ata_port_stop (struct ata_port *ap);
 415 extern void ata_host_stop (struct ata_host_set *host_set);
 416 extern irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs);
 417 extern void ata_qc_prep(struct ata_queued_cmd *qc);
 418 extern int ata_qc_issue_prot(struct ata_queued_cmd *qc);
 419 extern void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf,
 420                 unsigned int buflen);
 421 extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
 422                  unsigned int n_elem);
 423 extern unsigned int ata_dev_classify(struct ata_taskfile *tf);
 424 extern void ata_dev_id_string(u16 *id, unsigned char *s,
 425                               unsigned int ofs, unsigned int len);
 426 extern void ata_dev_config(struct ata_port *ap, unsigned int i);
 427 extern void ata_bmdma_setup (struct ata_queued_cmd *qc);
 428 extern void ata_bmdma_start (struct ata_queued_cmd *qc);
 429 extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
 430 extern u8   ata_bmdma_status(struct ata_port *ap);
 431 extern void ata_bmdma_irq_clear(struct ata_port *ap);
 432 extern void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat);
 433 extern void ata_eng_timeout(struct ata_port *ap);
 434 extern void ata_scsi_simulate(u16 *id, struct scsi_cmnd *cmd,
 435                               void (*done)(struct scsi_cmnd *));
 436 extern int ata_std_bios_param(struct scsi_device *sdev,
 437                               struct block_device *bdev,
 438                               sector_t capacity, int geom[]);
 439 extern int ata_scsi_slave_config(struct scsi_device *sdev);
 440
 441
 442 #ifdef CONFIG_PCI
 443 struct pci_bits {
 444         unsigned int            reg;    /* PCI config register to read */
 445         unsigned int            width;  /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
 446         unsigned long           mask;
 447         unsigned long           val;
 448 };
 449
 450 extern struct ata_probe_ent *
 451 ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port);
 452 extern int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits);
 453
 454 #endif /* CONFIG_PCI */
 455
 456
 457 static inline unsigned int ata_tag_valid(unsigned int tag)
 458 {
 459         return (tag < ATA_MAX_QUEUE) ? 1 : 0;
 460 }
 461
 462 static inline unsigned int ata_dev_present(struct ata_device *dev)
 463 {
 464         return ((dev->class == ATA_DEV_ATA) ||
 465                 (dev->class == ATA_DEV_ATAPI));
 466 }
 467
 468 static inline u8 ata_chk_status(struct ata_port *ap)
 469 {
 470         return ap->ops->check_status(ap);
 471 }
 472
 473
 474 /**
 475  *      ata_pause - Flush writes and pause 400 nanoseconds.
 476  *      @ap: Port to wait for.
 477  *
 478  *      LOCKING:
 479  *      Inherited from caller.
 480  */
 481
 482 static inline void ata_pause(struct ata_port *ap)
 483 {
 484         ata_altstatus(ap);
 485         ndelay(400);
 486 }
 487
 488
 489 /**
 490  *      ata_busy_wait - Wait for a port status register
 491  *      @ap: Port to wait for.
 492  *
 493  *      Waits up to max*10 microseconds for the selected bits in the port's
 494  *      status register to be cleared.
 495  *      Returns final value of status register.
 496  *
 497  *      LOCKING:
 498  *      Inherited from caller.
 499  */
 500
 501 static inline u8 ata_busy_wait(struct ata_port *ap, unsigned int bits,
 502                                unsigned int max)
 503 {
 504         u8 status;
 505
 506         do {
 507                 udelay(10);
 508                 status = ata_chk_status(ap);
 509                 max--;
 510         } while ((status & bits) && (max > 0));
 511
 512         return status;
 513 }
 514
 515
 516 /**
 517  *      ata_wait_idle - Wait for a port to be idle.
 518  *      @ap: Port to wait for.
 519  *
 520  *      Waits up to 10ms for port's BUSY and DRQ signals to clear.
 521  *      Returns final value of status register.
 522  *
 523  *      LOCKING:
 524  *      Inherited from caller.
 525  */
 526
 527 static inline u8 ata_wait_idle(struct ata_port *ap)
 528 {
 529         u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
 530
 531         if (status & (ATA_BUSY | ATA_DRQ)) {
 532                 unsigned long l = ap->ioaddr.status_addr;
 533                 printk(KERN_WARNING
 534                        "ATA: abnormal status 0x%X on port 0x%lX\n",
 535                        status, l);
 536         }
 537
 538         return status;
 539 }
 540
 541 static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
 542 {
 543         qc->tf.ctl |= ATA_NIEN;
 544 }
 545
 546 static inline struct ata_queued_cmd *ata_qc_from_tag (struct ata_port *ap,
 547                                                       unsigned int tag)
 548 {
 549         if (likely(ata_tag_valid(tag)))
 550                 return &ap->qcmd[tag];
 551         return NULL;
 552 }
 553
 554 static inline void ata_tf_init(struct ata_port *ap, struct ata_taskfile *tf, unsigned int device)
 555 {
 556         memset(tf, 0, sizeof(*tf));
 557
 558         tf->ctl = ap->ctl;
 559         if (device == 0)
 560                 tf->device = ATA_DEVICE_OBS;
 561         else
 562                 tf->device = ATA_DEVICE_OBS | ATA_DEV1;
 563 }
 564
 565
 566 /**
 567  *      ata_irq_on - Enable interrupts on a port.
 568  *      @ap: Port on which interrupts are enabled.
 569  *
 570  *      Enable interrupts on a legacy IDE device using MMIO or PIO,
 571  *      wait for idle, clear any pending interrupts.
 572  *
 573  *      LOCKING:
 574  *      Inherited from caller.
 575  */
 576
 577 static inline u8 ata_irq_on(struct ata_port *ap)
 578 {
 579         struct ata_ioports *ioaddr = &ap->ioaddr;
 580         u8 tmp;
 581
 582         ap->ctl &= ~ATA_NIEN;
 583         ap->last_ctl = ap->ctl;
 584
 585         if (ap->flags & ATA_FLAG_MMIO)
 586                 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
 587         else
 588                 outb(ap->ctl, ioaddr->ctl_addr);
 589         tmp = ata_wait_idle(ap);
 590
 591         ap->ops->irq_clear(ap);
 592
 593         return tmp;
 594 }
 595
 596
 597 /**
 598  *      ata_irq_ack - Acknowledge a device interrupt.
 599  *      @ap: Port on which interrupts are enabled.
 600  *
 601  *      Wait up to 10 ms for legacy IDE device to become idle (BUSY
 602  *      or BUSY+DRQ clear).  Obtain dma status and port status from
 603  *      device.  Clear the interrupt.  Return port status.
 604  *
 605  *      LOCKING:
 606  */
 607
 608 static inline u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq)
 609 {
 610         unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
 611         u8 host_stat, post_stat, status;
 612
 613         status = ata_busy_wait(ap, bits, 1000);
 614         if (status & bits)
 615                 DPRINTK("abnormal status 0x%X\n", status);
 616
 617         /* get controller status; clear intr, err bits */
 618         if (ap->flags & ATA_FLAG_MMIO) {
 619                 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
 620                 host_stat = readb(mmio + ATA_DMA_STATUS);
 621                 writeb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
 622                        mmio + ATA_DMA_STATUS);
 623
 624                 post_stat = readb(mmio + ATA_DMA_STATUS);
 625         } else {
 626                 host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 627                 outb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
 628                      ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 629
 630                 post_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 631         }
 632
 633         VPRINTK("irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n",
 634                 host_stat, post_stat, status);
 635
 636         return status;
 637 }
 638
 639 static inline u32 scr_read(struct ata_port *ap, unsigned int reg)
 640 {
 641         return ap->ops->scr_read(ap, reg);
 642 }
 643
 644 static inline void scr_write(struct ata_port *ap, unsigned int reg, u32 val)
 645 {
 646         ap->ops->scr_write(ap, reg, val);
 647 }
 648
 649 static inline void scr_write_flush(struct ata_port *ap, unsigned int reg,
 650                                    u32 val)
 651 {
 652         ap->ops->scr_write(ap, reg, val);
 653         (void) ap->ops->scr_read(ap, reg);
 654 }
 655
 656 static inline unsigned int sata_dev_present(struct ata_port *ap)
 657 {
 658         return ((scr_read(ap, SCR_STATUS) & 0xf) == 0x3) ? 1 : 0;
 659 }
 660
 661 static inline int ata_try_flush_cache(struct ata_device *dev)
 662 {
 663         return ata_id_wcache_enabled(dev->id) ||
 664                ata_id_has_flush(dev->id) ||
 665                ata_id_has_flush_ext(dev->id);
 666 }
 667
 668 #endif /* __LINUX_LIBATA_H__ */