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