include/linux/libata.h

   1 /*
   2    Copyright 2003-2004 Red Hat, Inc.  All rights reserved.
   3    Copyright 2003-2004 Jeff Garzik
   4
   5    The contents of this file are subject to the Open
   6    Software License version 1.1 that can be found at
   7    http://www.opensource.org/licenses/osl-1.1.txt and is included herein
   8    by reference.
   9
  10    Alternatively, the contents of this file may be used under the terms
  11    of the GNU General Public License version 2 (the "GPL") as distributed
  12    in the kernel source COPYING file, in which case the provisions of
  13    the GPL are applicable instead of the above.  If you wish to allow
  14    the use of your version of this file only under the terms of the
  15    GPL and not to allow others to use your version of this file under
  16    the OSL, indicate your decision by deleting the provisions above and
  17    replace them with the notice and other provisions required by the GPL.
  18    If you do not delete the provisions above, a recipient may use your
  19    version of this file under either the OSL or the GPL.
  20
  21  */
  22
  23 #ifndef __LINUX_LIBATA_H__
  24 #define __LINUX_LIBATA_H__
  25
  26 #include <linux/delay.h>
  27 #include <linux/interrupt.h>
  28 #include <asm/io.h>
  29 #include <linux/ata.h>
  30 #include <linux/workqueue.h>
  31
  32 /*
  33  * compile-time options
  34  */
  35 #undef ATA_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 #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 #undef PORT_UNKNOWN
  73 enum {
  74         /* various global constants */
  75         LIBATA_MAX_PRD          = ATA_MAX_PRD / 2,
  76         ATA_MAX_PORTS           = 8,
  77         ATA_DEF_QUEUE           = 1,
  78         ATA_MAX_QUEUE           = 1,
  79         ATA_MAX_SECTORS         = 200,  /* FIXME */
  80         ATA_MAX_BUS             = 2,
  81         ATA_DEF_BUSY_WAIT       = 10000,
  82         ATA_SHORT_PAUSE         = (HZ >> 6) + 1,
  83
  84         ATA_SHT_EMULATED        = 1,
  85         ATA_SHT_CMD_PER_LUN     = 1,
  86         ATA_SHT_THIS_ID         = -1,
  87         ATA_SHT_USE_CLUSTERING  = 0,
  88
  89         /* struct ata_device stuff */
  90         ATA_DFLAG_LBA48         = (1 << 0), /* device supports LBA48 */
  91         ATA_DFLAG_PIO           = (1 << 1), /* device currently in PIO mode */
  92         ATA_DFLAG_MASTER        = (1 << 2), /* is device 0? */
  93         ATA_DFLAG_WCACHE        = (1 << 3), /* has write cache we can
  94                                              * (hopefully) flush? */
  95         ATA_DFLAG_LOCK_SECTORS  = (1 << 4), /* don't adjust max_sectors */
  96
  97         ATA_DEV_UNKNOWN         = 0,    /* unknown device */
  98         ATA_DEV_ATA             = 1,    /* ATA device */
  99         ATA_DEV_ATA_UNSUP       = 2,    /* ATA device (unsupported) */
 100         ATA_DEV_ATAPI           = 3,    /* ATAPI device */
 101         ATA_DEV_ATAPI_UNSUP     = 4,    /* ATAPI device (unsupported) */
 102         ATA_DEV_NONE            = 5,    /* no device */
 103
 104         /* struct ata_port flags */
 105         ATA_FLAG_SLAVE_POSS     = (1 << 1), /* host supports slave dev */
 106                                             /* (doesn't imply presence) */
 107         ATA_FLAG_PORT_DISABLED  = (1 << 2), /* port is disabled, ignore it */
 108         ATA_FLAG_SATA           = (1 << 3),
 109         ATA_FLAG_NO_LEGACY      = (1 << 4), /* no legacy mode check */
 110         ATA_FLAG_SRST           = (1 << 5), /* use ATA SRST, not E.D.D. */
 111         ATA_FLAG_MMIO           = (1 << 6), /* use MMIO, not PIO */
 112         ATA_FLAG_SATA_RESET     = (1 << 7), /* use COMRESET */
 113
 114         ATA_QCFLAG_ACTIVE       = (1 << 1), /* cmd not yet ack'd to scsi lyer */
 115         ATA_QCFLAG_DMA          = (1 << 2), /* data delivered via DMA */
 116         ATA_QCFLAG_SG           = (1 << 3), /* have s/g table? */
 117         ATA_QCFLAG_SINGLE       = (1 << 4), /* no s/g, just a single buffer */
 118         ATA_QCFLAG_DMAMAP       = ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE,
 119
 120         /* various lengths of time */
 121         ATA_TMOUT_EDD           = 5 * HZ,       /* hueristic */
 122         ATA_TMOUT_PIO           = 30 * HZ,
 123         ATA_TMOUT_BOOT          = 30 * HZ,      /* hueristic */
 124         ATA_TMOUT_BOOT_QUICK    = 7 * HZ,       /* hueristic */
 125         ATA_TMOUT_CDB           = 30 * HZ,
 126         ATA_TMOUT_CDB_QUICK     = 5 * HZ,
 127
 128         /* ATA bus states */
 129         BUS_UNKNOWN             = 0,
 130         BUS_DMA                 = 1,
 131         BUS_IDLE                = 2,
 132         BUS_NOINTR              = 3,
 133         BUS_NODATA              = 4,
 134         BUS_TIMER               = 5,
 135         BUS_PIO                 = 6,
 136         BUS_EDD                 = 7,
 137         BUS_IDENTIFY            = 8,
 138         BUS_PACKET              = 9,
 139
 140         /* SATA port states */
 141         PORT_UNKNOWN            = 0,
 142         PORT_ENABLED            = 1,
 143         PORT_DISABLED           = 2,
 144 };
 145
 146 enum pio_task_states {
 147         PIO_ST_UNKNOWN,
 148         PIO_ST_IDLE,
 149         PIO_ST_POLL,
 150         PIO_ST_TMOUT,
 151         PIO_ST,
 152         PIO_ST_LAST,
 153         PIO_ST_LAST_POLL,
 154         PIO_ST_ERR,
 155 };
 156
 157 /* forward declarations */
 158 struct scsi_device;
 159 struct ata_port_operations;
 160 struct ata_port;
 161 struct ata_queued_cmd;
 162
 163 /* typedefs */
 164 typedef int (*ata_qc_cb_t) (struct ata_queued_cmd *qc, u8 drv_stat);
 165
 166 struct ata_ioports {
 167         unsigned long           cmd_addr;
 168         unsigned long           data_addr;
 169         unsigned long           error_addr;
 170         unsigned long           feature_addr;
 171         unsigned long           nsect_addr;
 172         unsigned long           lbal_addr;
 173         unsigned long           lbam_addr;
 174         unsigned long           lbah_addr;
 175         unsigned long           device_addr;
 176         unsigned long           status_addr;
 177         unsigned long           command_addr;
 178         unsigned long           altstatus_addr;
 179         unsigned long           ctl_addr;
 180         unsigned long           bmdma_addr;
 181         unsigned long           scr_addr;
 182 };
 183
 184 struct ata_probe_ent {
 185         struct list_head        node;
 186         struct pci_dev          *pdev;
 187         struct ata_port_operations      *port_ops;
 188         Scsi_Host_Template      *sht;
 189         struct ata_ioports      port[ATA_MAX_PORTS];
 190         unsigned int            n_ports;
 191         unsigned int            pio_mask;
 192         unsigned int            udma_mask;
 193         unsigned int            legacy_mode;
 194         unsigned long           irq;
 195         unsigned int            irq_flags;
 196         unsigned long           host_flags;
 197         void                    *mmio_base;
 198         void                    *private_data;
 199 };
 200
 201 struct ata_host_set {
 202         spinlock_t              lock;
 203         struct pci_dev          *pdev;
 204         unsigned long           irq;
 205         void                    *mmio_base;
 206         unsigned int            n_ports;
 207         void                    *private_data;
 208         struct ata_port_operations *ops;
 209         struct ata_port *       ports[0];
 210 };
 211
 212 struct ata_queued_cmd {
 213         struct ata_port         *ap;
 214         struct ata_device       *dev;
 215
 216         struct scsi_cmnd        *scsicmd;
 217         void                    (*scsidone)(struct scsi_cmnd *);
 218
 219         unsigned long           flags;          /* ATA_QCFLAG_xxx */
 220         unsigned int            tag;
 221         unsigned int            n_elem;
 222
 223         int                     pci_dma_dir;
 224
 225         unsigned int            nsect;
 226         unsigned int            cursect;
 227         unsigned int            cursg;
 228         unsigned int            cursg_ofs;
 229
 230         struct ata_taskfile     tf;
 231         struct scatterlist      sgent;
 232         void                    *buf_virt;
 233
 234         struct scatterlist      *sg;
 235
 236         ata_qc_cb_t             complete_fn;
 237
 238         struct completion       *waiting;
 239
 240         void                    *private_data;
 241 };
 242
 243 struct ata_host_stats {
 244         unsigned long           unhandled_irq;
 245         unsigned long           idle_irq;
 246         unsigned long           rw_reqbuf;
 247 };
 248
 249 struct ata_device {
 250         u64                     n_sectors;      /* size of device, if ATA */
 251         unsigned long           flags;          /* ATA_DFLAG_xxx */
 252         unsigned int            class;          /* ATA_DEV_xxx */
 253         unsigned int            devno;          /* 0 or 1 */
 254         u16                     id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
 255         unsigned int            pio_mode;
 256         unsigned int            udma_mode;
 257
 258         /* cache info about current transfer mode */
 259         u8                      xfer_protocol;  /* taskfile xfer protocol */
 260         u8                      read_cmd;       /* opcode to use on read */
 261         u8                      write_cmd;      /* opcode to use on write */
 262 };
 263
 264 struct ata_port {
 265         struct Scsi_Host        *host;  /* our co-allocated scsi host */
 266         struct ata_port_operations      *ops;
 267         unsigned long           flags;  /* ATA_FLAG_xxx */
 268         unsigned int            id;     /* unique id req'd by scsi midlyr */
 269         unsigned int            port_no; /* unique port #; from zero */
 270
 271         struct ata_prd          *prd;    /* our SG list */
 272         dma_addr_t              prd_dma; /* and its DMA mapping */
 273
 274         struct ata_ioports      ioaddr; /* ATA cmd/ctl/dma register blocks */
 275
 276         u8                      ctl;    /* cache of ATA control register */
 277         u8                      last_ctl;       /* Cache last written value */
 278         unsigned int            bus_state;
 279         unsigned int            port_state;
 280         unsigned int            pio_mask;
 281         unsigned int            udma_mask;
 282         unsigned int            cbl;    /* cable type; ATA_CBL_xxx */
 283
 284         struct ata_device       device[ATA_MAX_DEVICES];
 285
 286         struct ata_queued_cmd   qcmd[ATA_MAX_QUEUE];
 287         unsigned long           qactive;
 288         unsigned int            active_tag;
 289
 290         struct ata_host_stats   stats;
 291         struct ata_host_set     *host_set;
 292
 293         struct work_struct      packet_task;
 294
 295         struct work_struct      pio_task;
 296         unsigned int            pio_task_state;
 297         unsigned long           pio_task_timeout;
 298
 299         void                    *private_data;
 300 };
 301
 302 struct ata_port_operations {
 303         void (*port_disable) (struct ata_port *);
 304
 305         void (*dev_config) (struct ata_port *, struct ata_device *);
 306
 307         void (*set_piomode) (struct ata_port *, struct ata_device *,
 308                              unsigned int);
 309         void (*set_udmamode) (struct ata_port *, struct ata_device *,
 310                              unsigned int);
 311
 312         void (*tf_load) (struct ata_port *ap, struct ata_taskfile *tf);
 313         void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);
 314
 315         void (*exec_command)(struct ata_port *ap, struct ata_taskfile *tf);
 316         u8   (*check_status)(struct ata_port *ap);
 317
 318         void (*phy_reset) (struct ata_port *ap);
 319         void (*post_set_mode) (struct ata_port *ap);
 320
 321         void (*bmdma_setup) (struct ata_queued_cmd *qc);
 322         void (*bmdma_start) (struct ata_queued_cmd *qc);
 323
 324         void (*qc_prep) (struct ata_queued_cmd *qc);
 325         int (*qc_issue) (struct ata_queued_cmd *qc);
 326
 327         void (*eng_timeout) (struct ata_port *ap);
 328
 329         irqreturn_t (*irq_handler)(int, void *, struct pt_regs *);
 330         void (*irq_clear) (struct ata_port *);
 331
 332         u32 (*scr_read) (struct ata_port *ap, unsigned int sc_reg);
 333         void (*scr_write) (struct ata_port *ap, unsigned int sc_reg,
 334                            u32 val);
 335
 336         int (*port_start) (struct ata_port *ap);
 337         void (*port_stop) (struct ata_port *ap);
 338
 339         void (*host_stop) (struct ata_host_set *host_set);
 340 };
 341
 342 struct ata_port_info {
 343         Scsi_Host_Template      *sht;
 344         unsigned long           host_flags;
 345         unsigned long           pio_mask;
 346         unsigned long           udma_mask;
 347         struct ata_port_operations      *port_ops;
 348 };
 349
 350 struct pci_bits {
 351         unsigned int            reg;    /* PCI config register to read */
 352         unsigned int            width;  /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
 353         unsigned long           mask;
 354         unsigned long           val;
 355 };
 356
 357 extern void ata_port_probe(struct ata_port *);
 358 extern void sata_phy_reset(struct ata_port *ap);
 359 extern void ata_bus_reset(struct ata_port *ap);
 360 extern void ata_port_disable(struct ata_port *);
 361 extern void ata_std_ports(struct ata_ioports *ioaddr);
 362 extern int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
 363                              unsigned int n_ports);
 364 extern void ata_pci_remove_one (struct pci_dev *pdev);
 365 extern int ata_device_add(struct ata_probe_ent *ent);
 366 extern int ata_scsi_detect(Scsi_Host_Template *sht);
 367 extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
 368 extern int ata_scsi_error(struct Scsi_Host *host);
 369 extern int ata_scsi_release(struct Scsi_Host *host);
 370 extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
 371 /*
 372  * Default driver ops implementations
 373  */
 374 extern void ata_tf_load_pio(struct ata_port *ap, struct ata_taskfile *tf);
 375 extern void ata_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf);
 376 extern void ata_tf_read_pio(struct ata_port *ap, struct ata_taskfile *tf);
 377 extern void ata_tf_read_mmio(struct ata_port *ap, struct ata_taskfile *tf);
 378 extern void ata_tf_to_fis(struct ata_taskfile *tf, u8 *fis, u8 pmp);
 379 extern void ata_tf_from_fis(u8 *fis, struct ata_taskfile *tf);
 380 extern u8 ata_check_status_pio(struct ata_port *ap);
 381 extern u8 ata_check_status_mmio(struct ata_port *ap);
 382 extern void ata_exec_command_pio(struct ata_port *ap, struct ata_taskfile *tf);
 383 extern void ata_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf);
 384 extern int ata_port_start (struct ata_port *ap);
 385 extern void ata_port_stop (struct ata_port *ap);
 386 extern irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs);
 387 extern void ata_qc_prep(struct ata_queued_cmd *qc);
 388 extern int ata_qc_issue_prot(struct ata_queued_cmd *qc);
 389 extern void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf,
 390                 unsigned int buflen);
 391 extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
 392                  unsigned int n_elem);
 393 extern void ata_dev_id_string(struct ata_device *dev, unsigned char *s,
 394                               unsigned int ofs, unsigned int len);
 395 extern void ata_bmdma_setup_mmio (struct ata_queued_cmd *qc);
 396 extern void ata_bmdma_start_mmio (struct ata_queued_cmd *qc);
 397 extern void ata_bmdma_setup_pio (struct ata_queued_cmd *qc);
 398 extern void ata_bmdma_start_pio (struct ata_queued_cmd *qc);
 399 extern void ata_bmdma_irq_clear(struct ata_port *ap);
 400 extern int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits);
 401 extern void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat);
 402 extern void ata_eng_timeout(struct ata_port *ap);
 403 extern int ata_std_bios_param(struct scsi_device *sdev,
 404                               struct block_device *bdev,
 405                               sector_t capacity, int geom[]);
 406 extern int ata_scsi_slave_config(struct scsi_device *sdev);
 407
 408
 409 static inline unsigned int ata_tag_valid(unsigned int tag)
 410 {
 411         return (tag < ATA_MAX_QUEUE) ? 1 : 0;
 412 }
 413
 414 static inline unsigned int ata_dev_present(struct ata_device *dev)
 415 {
 416         return ((dev->class == ATA_DEV_ATA) ||
 417                 (dev->class == ATA_DEV_ATAPI));
 418 }
 419
 420 static inline u8 ata_chk_err(struct ata_port *ap)
 421 {
 422         if (ap->flags & ATA_FLAG_MMIO) {
 423                 return readb((void *) ap->ioaddr.error_addr);
 424         }
 425         return inb(ap->ioaddr.error_addr);
 426 }
 427
 428 static inline u8 ata_chk_status(struct ata_port *ap)
 429 {
 430         return ap->ops->check_status(ap);
 431 }
 432
 433 static inline u8 ata_altstatus(struct ata_port *ap)
 434 {
 435         if (ap->flags & ATA_FLAG_MMIO)
 436                 return readb(ap->ioaddr.altstatus_addr);
 437         return inb(ap->ioaddr.altstatus_addr);
 438 }
 439
 440 static inline void ata_pause(struct ata_port *ap)
 441 {
 442         ata_altstatus(ap);
 443         ndelay(400);
 444 }
 445
 446 static inline u8 ata_busy_wait(struct ata_port *ap, unsigned int bits,
 447                                unsigned int max)
 448 {
 449         u8 status;
 450
 451         do {
 452                 udelay(10);
 453                 status = ata_chk_status(ap);
 454                 max--;
 455         } while ((status & bits) && (max > 0));
 456
 457         return status;
 458 }
 459
 460 static inline u8 ata_wait_idle(struct ata_port *ap)
 461 {
 462         u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
 463
 464         if (status & (ATA_BUSY | ATA_DRQ)) {
 465                 unsigned long l = ap->ioaddr.status_addr;
 466                 printk(KERN_WARNING
 467                        "ATA: abnormal status 0x%X on port 0x%lX\n",
 468                        status, l);
 469         }
 470
 471         return status;
 472 }
 473
 474 static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
 475 {
 476         qc->flags &= ~ATA_QCFLAG_DMA;
 477         qc->tf.ctl |= ATA_NIEN;
 478 }
 479
 480 static inline struct ata_queued_cmd *ata_qc_from_tag (struct ata_port *ap,
 481                                                       unsigned int tag)
 482 {
 483         if (likely(ata_tag_valid(tag)))
 484                 return &ap->qcmd[tag];
 485         return NULL;
 486 }
 487
 488 static inline void ata_tf_init(struct ata_port *ap, struct ata_taskfile *tf, unsigned int device)
 489 {
 490         memset(tf, 0, sizeof(*tf));
 491
 492         tf->ctl = ap->ctl;
 493         if (device == 0)
 494                 tf->device = ATA_DEVICE_OBS;
 495         else
 496                 tf->device = ATA_DEVICE_OBS | ATA_DEV1;
 497 }
 498
 499 static inline u8 ata_irq_on(struct ata_port *ap)
 500 {
 501         struct ata_ioports *ioaddr = &ap->ioaddr;
 502         u8 tmp;
 503
 504         ap->ctl &= ~ATA_NIEN;
 505         ap->last_ctl = ap->ctl;
 506
 507         if (ap->flags & ATA_FLAG_MMIO)
 508                 writeb(ap->ctl, ioaddr->ctl_addr);
 509         else
 510                 outb(ap->ctl, ioaddr->ctl_addr);
 511         tmp = ata_wait_idle(ap);
 512
 513         ap->ops->irq_clear(ap);
 514
 515         return tmp;
 516 }
 517
 518 static inline u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq)
 519 {
 520         unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
 521         u8 host_stat, post_stat, status;
 522
 523         status = ata_busy_wait(ap, bits, 1000);
 524         if (status & bits)
 525                 DPRINTK("abnormal status 0x%X\n", status);
 526
 527         /* get controller status; clear intr, err bits */
 528         if (ap->flags & ATA_FLAG_MMIO) {
 529                 void *mmio = (void *) ap->ioaddr.bmdma_addr;
 530                 host_stat = readb(mmio + ATA_DMA_STATUS);
 531                 writeb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
 532                        mmio + ATA_DMA_STATUS);
 533
 534                 post_stat = readb(mmio + ATA_DMA_STATUS);
 535         } else {
 536                 host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 537                 outb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
 538                      ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 539
 540                 post_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 541         }
 542
 543         VPRINTK("irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n",
 544                 host_stat, post_stat, status);
 545
 546         return status;
 547 }
 548
 549 static inline u32 scr_read(struct ata_port *ap, unsigned int reg)
 550 {
 551         return ap->ops->scr_read(ap, reg);
 552 }
 553
 554 static inline void scr_write(struct ata_port *ap, unsigned int reg, u32 val)
 555 {
 556         ap->ops->scr_write(ap, reg, val);
 557 }
 558
 559 static inline unsigned int sata_dev_present(struct ata_port *ap)
 560 {
 561         return ((scr_read(ap, SCR_STATUS) & 0xf) == 0x3) ? 1 : 0;
 562 }
 563
 564 static inline void ata_bmdma_stop(struct ata_port *ap)
 565 {
 566         if (ap->flags & ATA_FLAG_MMIO) {
 567                 void *mmio = (void *) ap->ioaddr.bmdma_addr;
 568
 569                 /* clear start/stop bit */
 570                 writeb(readb(mmio + ATA_DMA_CMD) & ~ATA_DMA_START,
 571                       mmio + ATA_DMA_CMD);
 572         } else {
 573                 /* clear start/stop bit */
 574                 outb(inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD) & ~ATA_DMA_START,
 575                     ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
 576         }
 577
 578         /* one-PIO-cycle guaranteed wait, per spec, for HDMA1:0 transition */
 579         ata_altstatus(ap);            /* dummy read */
 580 }
 581
 582 static inline void ata_bmdma_ack_irq(struct ata_port *ap)
 583 {
 584         if (ap->flags & ATA_FLAG_MMIO) {
 585                 void *mmio = ((void *) ap->ioaddr.bmdma_addr) + ATA_DMA_STATUS;
 586                 writeb(readb(mmio), mmio);
 587         } else {
 588                 unsigned long addr = ap->ioaddr.bmdma_addr + ATA_DMA_STATUS;
 589                 outb(inb(addr), addr);
 590         }
 591 }
 592
 593 static inline u8 ata_bmdma_status(struct ata_port *ap)
 594 {
 595         u8 host_stat;
 596         if (ap->flags & ATA_FLAG_MMIO) {
 597                 void *mmio = (void *) ap->ioaddr.bmdma_addr;
 598                 host_stat = readb(mmio + ATA_DMA_STATUS);
 599         } else
 600                 host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
 601         return host_stat;
 602 }
 603
 604 #endif /* __LINUX_LIBATA_H__ */