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