include/linux/libata.h

   1 /*
   2    Copyright 2003 Red Hat, Inc.  All rights reserved.
   3    Copyright 2003 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
  31
  32 /*
  33  * compile-time options
  34  */
  35 #undef ATA_FORCE_PIO            /* do not configure or use DMA */
  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
  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         ATA_MAX_PORTS           = 8,
  74         ATA_DEF_QUEUE           = 1,
  75         ATA_MAX_QUEUE           = 1,
  76         ATA_MAX_SECTORS         = 200,  /* FIXME */
  77         ATA_MAX_BUS             = 2,
  78         ATA_DEF_BUSY_WAIT       = 10000,
  79         ATA_SHORT_PAUSE         = (HZ >> 6) + 1,
  80
  81         ATA_SHT_EMULATED        = 1,
  82         ATA_SHT_CMD_PER_LUN     = 1,
  83         ATA_SHT_THIS_ID         = -1,
  84         ATA_SHT_USE_CLUSTERING  = 1,
  85
  86         /* struct ata_device stuff */
  87         ATA_DFLAG_LBA48         = (1 << 0), /* device supports LBA48 */
  88         ATA_DFLAG_PIO           = (1 << 1), /* device currently in PIO mode */
  89         ATA_DFLAG_MASTER        = (1 << 2), /* is device 0? */
  90         ATA_DFLAG_WCACHE        = (1 << 3), /* has write cache we can
  91                                              * (hopefully) flush? */
  92
  93         ATA_DEV_UNKNOWN         = 0,    /* unknown device */
  94         ATA_DEV_ATA             = 1,    /* ATA device */
  95         ATA_DEV_ATA_UNSUP       = 2,    /* ATA device (unsupported) */
  96         ATA_DEV_ATAPI           = 3,    /* ATAPI device */
  97         ATA_DEV_ATAPI_UNSUP     = 4,    /* ATAPI device (unsupported) */
  98         ATA_DEV_NONE            = 5,    /* no device */
  99
 100         /* struct ata_port flags */
 101         ATA_FLAG_SLAVE_POSS     = (1 << 1), /* host supports slave dev */
 102                                             /* (doesn't imply presence) */
 103         ATA_FLAG_PORT_DISABLED  = (1 << 2), /* port is disabled, ignore it */
 104         ATA_FLAG_SATA           = (1 << 3),
 105         ATA_FLAG_NO_LEGACY      = (1 << 4), /* no legacy mode check */
 106         ATA_FLAG_SRST           = (1 << 5), /* use ATA SRST, not E.D.D. */
 107         ATA_FLAG_MMIO           = (1 << 6), /* use MMIO, not PIO */
 108         ATA_FLAG_SATA_RESET     = (1 << 7), /* use COMRESET */
 109
 110         /* struct ata_taskfile flags */
 111         ATA_TFLAG_LBA48         = (1 << 0),
 112         ATA_TFLAG_ISADDR        = (1 << 1), /* enable r/w to nsect/lba regs */
 113         ATA_TFLAG_DEVICE        = (1 << 2), /* enable r/w to device reg */
 114
 115         ATA_QCFLAG_WRITE        = (1 << 0), /* read==0, write==1 */
 116         ATA_QCFLAG_ACTIVE       = (1 << 1), /* cmd not yet ack'd to scsi lyer */
 117         ATA_QCFLAG_DMA          = (1 << 2), /* data delivered via DMA */
 118         ATA_QCFLAG_ATAPI        = (1 << 3), /* is ATAPI packet command? */
 119         ATA_QCFLAG_SG           = (1 << 4), /* have s/g table? */
 120         ATA_QCFLAG_POLL         = (1 << 5), /* polling, no interrupts */
 121
 122         /* struct ata_engine atomic flags (use test_bit, etc.) */
 123         ATA_EFLG_ACTIVE         = 0,    /* engine is active */
 124
 125         /* various lengths of time */
 126         ATA_TMOUT_EDD           = 5 * HZ,       /* hueristic */
 127         ATA_TMOUT_PIO           = 30 * HZ,
 128         ATA_TMOUT_BOOT          = 30 * HZ,      /* hueristic */
 129         ATA_TMOUT_BOOT_QUICK    = 7 * HZ,       /* hueristic */
 130         ATA_TMOUT_CDB           = 30 * HZ,
 131         ATA_TMOUT_CDB_QUICK     = 5 * HZ,
 132
 133         /* ATA bus states */
 134         BUS_UNKNOWN             = 0,
 135         BUS_DMA                 = 1,
 136         BUS_IDLE                = 2,
 137         BUS_NOINTR              = 3,
 138         BUS_NODATA              = 4,
 139         BUS_TIMER               = 5,
 140         BUS_PIO                 = 6,
 141         BUS_EDD                 = 7,
 142         BUS_IDENTIFY            = 8,
 143         BUS_PACKET              = 9,
 144
 145         /* thread states */
 146         THR_UNKNOWN             = 0,
 147         THR_PORT_RESET          = (THR_UNKNOWN + 1),
 148         THR_AWAIT_DEATH         = (THR_PORT_RESET + 1),
 149         THR_PROBE_FAILED        = (THR_AWAIT_DEATH + 1),
 150         THR_IDLE                = (THR_PROBE_FAILED + 1),
 151         THR_PROBE_SUCCESS       = (THR_IDLE + 1),
 152         THR_PROBE_START         = (THR_PROBE_SUCCESS + 1),
 153         THR_PIO_POLL            = (THR_PROBE_START + 1),
 154         THR_PIO_TMOUT           = (THR_PIO_POLL + 1),
 155         THR_PIO                 = (THR_PIO_TMOUT + 1),
 156         THR_PIO_LAST            = (THR_PIO + 1),
 157         THR_PIO_LAST_POLL       = (THR_PIO_LAST + 1),
 158         THR_PIO_ERR             = (THR_PIO_LAST_POLL + 1),
 159         THR_PACKET              = (THR_PIO_ERR + 1),
 160
 161         /* SATA port states */
 162         PORT_UNKNOWN            = 0,
 163         PORT_ENABLED            = 1,
 164         PORT_DISABLED           = 2,
 165
 166         /* ata_qc_cb_t flags - note uses above ATA_QCFLAG_xxx namespace,
 167          * but not numberspace
 168          */
 169         ATA_QCFLAG_TIMEOUT      = (1 << 0),
 170 };
 171
 172 /* forward declarations */
 173 struct scsi_device;
 174 struct ata_port_operations;
 175 struct ata_port;
 176 struct ata_queued_cmd;
 177
 178 /* typedefs */
 179 typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc, unsigned int flags);
 180
 181 struct ata_ioports {
 182         unsigned long           cmd_addr;
 183         unsigned long           data_addr;
 184         unsigned long           error_addr;
 185         unsigned long           nsect_addr;
 186         unsigned long           lbal_addr;
 187         unsigned long           lbam_addr;
 188         unsigned long           lbah_addr;
 189         unsigned long           device_addr;
 190         unsigned long           cmdstat_addr;
 191         unsigned long           ctl_addr;
 192         unsigned long           bmdma_addr;
 193         unsigned long           scr_addr;
 194 };
 195
 196 struct ata_probe_ent {
 197         struct list_head        node;
 198         struct pci_dev          *pdev;
 199         struct ata_port_operations      *port_ops;
 200         Scsi_Host_Template      *sht;
 201         struct ata_ioports      port[ATA_MAX_PORTS];
 202         unsigned int            n_ports;
 203         unsigned int            pio_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                    *mmio_base;
 210         void                    *private_data;
 211 };
 212
 213 struct ata_host_set {
 214         spinlock_t              lock;
 215         struct pci_dev          *pdev;
 216         unsigned long           irq;
 217         void                    *mmio_base;
 218         unsigned int            n_ports;
 219         void                    *private_data;
 220         struct ata_port *       ports[0];
 221 };
 222
 223 struct ata_taskfile {
 224         unsigned long           flags;          /* ATA_TFLAG_xxx */
 225         u8                      protocol;       /* ATA_PROT_xxx */
 226
 227         u8                      ctl;            /* control reg */
 228
 229         u8                      hob_feature;    /* additional data */
 230         u8                      hob_nsect;      /* to support LBA48 */
 231         u8                      hob_lbal;
 232         u8                      hob_lbam;
 233         u8                      hob_lbah;
 234
 235         u8                      feature;
 236         u8                      nsect;
 237         u8                      lbal;
 238         u8                      lbam;
 239         u8                      lbah;
 240
 241         u8                      device;
 242
 243         u8                      command;        /* IO operation */
 244 };
 245
 246 struct ata_queued_cmd {
 247         struct ata_port         *ap;
 248         struct ata_device       *dev;
 249
 250         struct scsi_cmnd                *scsicmd;
 251         void                    (*scsidone)(struct scsi_cmnd *);
 252
 253         struct list_head        node;
 254         unsigned long           flags;          /* ATA_QCFLAG_xxx */
 255         unsigned int            tag;
 256         unsigned int            n_elem;
 257         unsigned int            nsect;
 258         unsigned int            cursect;
 259         unsigned int            cursg;
 260         unsigned int            cursg_ofs;
 261         struct ata_taskfile     tf;
 262         struct scatterlist      sgent;
 263
 264         struct scatterlist      *sg;
 265
 266         ata_qc_cb_t             callback;
 267
 268         struct semaphore        sem;
 269
 270         void                    *private_data;
 271 };
 272
 273 struct ata_host_stats {
 274         unsigned long           unhandled_irq;
 275         unsigned long           idle_irq;
 276         unsigned long           rw_reqbuf;
 277 };
 278
 279 struct ata_device {
 280         u64                     n_sectors;      /* size of device, if ATA */
 281         unsigned long           flags;          /* ATA_DFLAG_xxx */
 282         unsigned int            class;          /* ATA_DEV_xxx */
 283         unsigned int            devno;          /* 0 or 1 */
 284         u16                     id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
 285         unsigned int            pio_mode;
 286         unsigned int            udma_mode;
 287
 288         unsigned char           vendor[8];      /* space-padded, not ASCIIZ */
 289         unsigned char           product[32];    /* WARNING: shorter than
 290                                                  * ATAPI7 spec size, 40 ASCII
 291                                                  * characters
 292                                                  */
 293 };
 294
 295 struct ata_engine {
 296         unsigned long           flags;
 297         struct list_head        q;
 298 };
 299
 300 struct ata_port {
 301         struct Scsi_Host        *host;  /* our co-allocated scsi host */
 302         struct ata_port_operations      *ops;
 303         unsigned long           flags;  /* ATA_FLAG_xxx */
 304         unsigned int            id;     /* unique id req'd by scsi midlyr */
 305         unsigned int            port_no; /* unique port #; from zero */
 306
 307         struct ata_prd          *prd;    /* our SG list */
 308         dma_addr_t              prd_dma; /* and its DMA mapping */
 309
 310         struct ata_ioports      ioaddr; /* ATA cmd/ctl/dma register blocks */
 311
 312         u8                      ctl;    /* cache of ATA control register */
 313         u8                      last_ctl;       /* Cache last written value */
 314         unsigned int            bus_state;
 315         unsigned int            port_state;
 316         unsigned int            pio_mask;
 317         unsigned int            udma_mask;
 318         unsigned int            cbl;    /* cable type; ATA_CBL_xxx */
 319
 320         struct ata_engine       eng;
 321
 322         struct ata_device       device[ATA_MAX_DEVICES];
 323
 324         struct ata_queued_cmd   qcmd[ATA_MAX_QUEUE];
 325         unsigned long           qactive;
 326         unsigned int            active_tag;
 327
 328         struct ata_host_stats   stats;
 329         struct ata_host_set     *host_set;
 330
 331         struct semaphore        sem;
 332         struct semaphore        probe_sem;
 333
 334         unsigned int            thr_state;
 335         int                     time_to_die;
 336         pid_t                   thr_pid;
 337         struct completion       thr_exited;
 338         struct semaphore        thr_sem;
 339         struct timer_list       thr_timer;
 340         unsigned long           thr_timeout;
 341
 342         void                    *private_data;
 343 };
 344
 345 struct ata_port_operations {
 346         void (*port_disable) (struct ata_port *);
 347
 348         void (*dev_config) (struct ata_port *, struct ata_device *);
 349
 350         void (*set_piomode) (struct ata_port *, struct ata_device *,
 351                              unsigned int);
 352         void (*set_udmamode) (struct ata_port *, struct ata_device *,
 353                              unsigned int);
 354
 355         void (*tf_load) (struct ata_port *ap, struct ata_taskfile *tf);
 356         void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);
 357
 358         void (*exec_command)(struct ata_port *ap, struct ata_taskfile *tf);
 359         u8   (*check_status)(struct ata_port *ap);
 360
 361         void (*phy_reset) (struct ata_port *ap);
 362         void (*phy_config) (struct ata_port *ap);
 363
 364         void (*bmdma_start) (struct ata_queued_cmd *qc);
 365         void (*fill_sg) (struct ata_queued_cmd *qc);
 366         void (*eng_timeout) (struct ata_port *ap);
 367
 368         irqreturn_t (*irq_handler)(int, void *, struct pt_regs *);
 369
 370         u32 (*scr_read) (struct ata_port *ap, unsigned int sc_reg);
 371         void (*scr_write) (struct ata_port *ap, unsigned int sc_reg,
 372                            u32 val);
 373
 374         int (*port_start) (struct ata_port *ap);
 375         void (*port_stop) (struct ata_port *ap);
 376
 377         void (*host_stop) (struct ata_host_set *host_set);
 378 };
 379
 380 struct ata_port_info {
 381         Scsi_Host_Template      *sht;
 382         unsigned long           host_flags;
 383         unsigned long           pio_mask;
 384         unsigned long           udma_mask;
 385         struct ata_port_operations      *port_ops;
 386 };
 387
 388 struct pci_bits {
 389         unsigned int            reg;    /* PCI config register to read */
 390         unsigned int            width;  /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
 391         unsigned long           mask;
 392         unsigned long           val;
 393 };
 394
 395 extern void ata_port_probe(struct ata_port *);
 396 extern void pata_phy_config(struct ata_port *ap);
 397 extern void sata_phy_reset(struct ata_port *ap);
 398 extern void ata_bus_reset(struct ata_port *ap);
 399 extern void ata_port_disable(struct ata_port *);
 400 extern void ata_std_ports(struct ata_ioports *ioaddr);
 401 extern int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
 402                              unsigned int n_ports);
 403 extern void ata_pci_remove_one (struct pci_dev *pdev);
 404 extern int ata_device_add(struct ata_probe_ent *ent);
 405 extern int ata_scsi_detect(Scsi_Host_Template *sht);
 406 extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
 407 extern int ata_scsi_error(struct Scsi_Host *host);
 408 extern int ata_scsi_release(struct Scsi_Host *host);
 409 extern int ata_scsi_slave_config(struct scsi_device *sdev);
 410 /*
 411  * Default driver ops implementations
 412  */
 413 extern void ata_tf_load_pio(struct ata_port *ap, struct ata_taskfile *tf);
 414 extern void ata_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf);
 415 extern void ata_tf_read_pio(struct ata_port *ap, struct ata_taskfile *tf);
 416 extern void ata_tf_read_mmio(struct ata_port *ap, struct ata_taskfile *tf);
 417 extern u8 ata_check_status_pio(struct ata_port *ap);
 418 extern u8 ata_check_status_mmio(struct ata_port *ap);
 419 extern void ata_exec_command_pio(struct ata_port *ap, struct ata_taskfile *tf);
 420 extern void ata_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf);
 421 extern int ata_port_start (struct ata_port *ap);
 422 extern void ata_port_stop (struct ata_port *ap);
 423 extern irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs);
 424 extern void ata_fill_sg(struct ata_queued_cmd *qc);
 425 extern void ata_bmdma_start_mmio (struct ata_queued_cmd *qc);
 426 extern void ata_bmdma_start_pio (struct ata_queued_cmd *qc);
 427 extern int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits);
 428 extern void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat, unsigned int done_late);
 429 extern void ata_eng_timeout(struct ata_port *ap);
 430 extern int ata_std_bios_param(struct scsi_device *sdev,
 431                               struct block_device *bdev,
 432                               sector_t capacity, int geom[]);
 433
 434
 435 static inline unsigned long msecs_to_jiffies(unsigned long msecs)
 436 {
 437         return ((HZ * msecs + 999) / 1000);
 438 }
 439
 440 static inline unsigned int ata_tag_valid(unsigned int tag)
 441 {
 442         return (tag < ATA_MAX_QUEUE) ? 1 : 0;
 443 }
 444
 445 static inline unsigned int ata_dev_present(struct ata_device *dev)
 446 {
 447         return ((dev->class == ATA_DEV_ATA) ||
 448                 (dev->class == ATA_DEV_ATAPI));
 449 }
 450
 451 static inline u8 ata_chk_err(struct ata_port *ap)
 452 {
 453         if (ap->flags & ATA_FLAG_MMIO) {
 454                 return readb((void *) ap->ioaddr.error_addr);
 455         }
 456         return inb(ap->ioaddr.error_addr);
 457 }
 458
 459 static inline u8 ata_chk_status(struct ata_port *ap)
 460 {
 461         return ap->ops->check_status(ap);
 462 }
 463
 464 static inline u8 ata_altstatus(struct ata_port *ap)
 465 {
 466         if (ap->flags & ATA_FLAG_MMIO)
 467                 return readb(ap->ioaddr.ctl_addr);
 468         return inb(ap->ioaddr.ctl_addr);
 469 }
 470
 471 static inline void ata_pause(struct ata_port *ap)
 472 {
 473         ata_altstatus(ap);
 474         ndelay(400);
 475 }
 476
 477 static inline u8 ata_busy_wait(struct ata_port *ap, unsigned int bits,
 478                                unsigned int max)
 479 {
 480         u8 status;
 481
 482         do {
 483                 udelay(10);
 484                 status = ata_chk_status(ap);
 485                 max--;
 486         } while ((status & bits) && (max > 0));
 487
 488         return status;
 489 }
 490
 491 static inline u8 ata_wait_idle(struct ata_port *ap)
 492 {
 493         u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
 494
 495         if (status & (ATA_BUSY | ATA_DRQ)) {
 496                 unsigned long l = ap->ioaddr.cmdstat_addr;
 497                 printk(KERN_WARNING
 498                        "ATA: abnormal status 0x%X on port 0x%lX\n",
 499                        status, l);
 500         }
 501
 502         return status;
 503 }
 504
 505 static inline struct ata_queued_cmd *ata_qc_from_tag (struct ata_port *ap,
 506                                                       unsigned int tag)
 507 {
 508         if (likely(ata_tag_valid(tag)))
 509                 return &ap->qcmd[tag];
 510         return NULL;
 511 }
 512
 513 static inline void ata_tf_init(struct ata_port *ap, struct ata_taskfile *tf, unsigned int device)
 514 {
 515         memset(tf, 0, sizeof(*tf));
 516
 517         tf->ctl = ap->ctl;
 518         if (device == 0)
 519                 tf->device = ATA_DEVICE_OBS;
 520         else
 521                 tf->device = ATA_DEVICE_OBS | ATA_DEV1;
 522 }
 523
 524 static inline u8 ata_irq_on(struct ata_port *ap)
 525 {
 526         struct ata_ioports *ioaddr = &ap->ioaddr;
 527
 528         ap->ctl &= ~ATA_NIEN;
 529         ap->last_ctl = ap->ctl;
 530
 531         if (ap->flags & ATA_FLAG_MMIO)
 532                 writeb(ap->ctl, ioaddr->ctl_addr);
 533         else
 534                 outb(ap->ctl, ioaddr->ctl_addr);
 535         return ata_wait_idle(ap);
 536 }
 537
 538 static inline u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq)
 539 {
 540         unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
 541         u8 host_stat, post_stat, status;
 542
 543         status = ata_busy_wait(ap, bits, 1000);
 544         if (status & bits)
 545                 DPRINTK("abnormal status 0x%X\n", status);
 546
 547         /* get controller status; clear intr, err bits */
 548         if (ap->flags & ATA_FLAG_MMIO) {
 549                 void *mmio = (void *) ap->ioaddr.bmdma_addr;
 550                 host_stat = readb(mmio + ATA_DMA_STATUS);
 551                 writeb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
 552                        mmio + ATA_DMA_STATUS);
 553
 554                 post_stat = readb(mmio + ATA_DMA_STATUS);
 555         } else {
 556                 host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 557                 outb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
 558                      ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 559
 560                 post_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 561         }
 562
 563         VPRINTK("irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n",
 564                 host_stat, post_stat, status);
 565
 566         return status;
 567 }
 568
 569 static inline u32 scr_read(struct ata_port *ap, unsigned int reg)
 570 {
 571         return ap->ops->scr_read(ap, reg);
 572 }
 573
 574 static inline void scr_write(struct ata_port *ap, unsigned int reg, u32 val)
 575 {
 576         ap->ops->scr_write(ap, reg, val);
 577 }
 578
 579 static inline unsigned int sata_dev_present(struct ata_port *ap)
 580 {
 581         return ((scr_read(ap, SCR_STATUS) & 0xf) == 0x3) ? 1 : 0;
 582 }
 583
 584 #endif /* __LINUX_LIBATA_H__ */