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
  31 /*
  32  * compile-time options
  33  */
  34 #undef ATA_FORCE_PIO            /* do not configure or use DMA */
  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
  43
  44 /* note: prints function name for you */
  45 #ifdef ATA_DEBUG
  46 #define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
  47 #ifdef ATA_VERBOSE_DEBUG
  48 #define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args)
  49 #else
  50 #define VPRINTK(fmt, args...)
  51 #endif  /* ATA_VERBOSE_DEBUG */
  52 #else
  53 #define DPRINTK(fmt, args...)
  54 #define VPRINTK(fmt, args...)
  55 #endif  /* ATA_DEBUG */
  56
  57 #ifdef ATA_NDEBUG
  58 #define assert(expr)
  59 #else
  60 #define assert(expr) \
  61         if(unlikely(!(expr))) {                                   \
  62         printk(KERN_ERR "Assertion failed! %s,%s,%s,line=%d\n", \
  63         #expr,__FILE__,__FUNCTION__,__LINE__);          \
  64         }
  65 #endif
  66
  67 /* defines only for the constants which don't work well as enums */
  68 #define ATA_TAG_POISON          0xfafbfcfdU
  69
  70 enum {
  71         /* various global constants */
  72         LIBATA_MAX_PRD          = ATA_MAX_PRD / 2,
  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  = 0,
  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         ATA_QCFLAG_ACTIVE       = (1 << 1), /* cmd not yet ack'd to scsi lyer */
 111         ATA_QCFLAG_DMA          = (1 << 2), /* data delivered via DMA */
 112         ATA_QCFLAG_ATAPI        = (1 << 3), /* is ATAPI packet command? */
 113         ATA_QCFLAG_SG           = (1 << 4), /* have s/g table? */
 114         ATA_QCFLAG_POLL         = (1 << 5), /* polling, no interrupts */
 115
 116         /* struct ata_engine atomic flags (use test_bit, etc.) */
 117         ATA_EFLG_ACTIVE         = 0,    /* engine is active */
 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         /* thread states */
 140         THR_UNKNOWN             = 0,
 141         THR_PORT_RESET          = (THR_UNKNOWN + 1),
 142         THR_AWAIT_DEATH         = (THR_PORT_RESET + 1),
 143         THR_PROBE_FAILED        = (THR_AWAIT_DEATH + 1),
 144         THR_IDLE                = (THR_PROBE_FAILED + 1),
 145         THR_PROBE_SUCCESS       = (THR_IDLE + 1),
 146         THR_PROBE_START         = (THR_PROBE_SUCCESS + 1),
 147         THR_PIO_POLL            = (THR_PROBE_START + 1),
 148         THR_PIO_TMOUT           = (THR_PIO_POLL + 1),
 149         THR_PIO                 = (THR_PIO_TMOUT + 1),
 150         THR_PIO_LAST            = (THR_PIO + 1),
 151         THR_PIO_LAST_POLL       = (THR_PIO_LAST + 1),
 152         THR_PIO_ERR             = (THR_PIO_LAST_POLL + 1),
 153         THR_PACKET              = (THR_PIO_ERR + 1),
 154
 155         /* SATA port states */
 156         PORT_UNKNOWN            = 0,
 157         PORT_ENABLED            = 1,
 158         PORT_DISABLED           = 2,
 159
 160         /* ata_qc_cb_t flags - note uses above ATA_QCFLAG_xxx namespace,
 161          * but not numberspace
 162          */
 163         ATA_QCFLAG_TIMEOUT      = (1 << 0),
 164 };
 165
 166 /* forward declarations */
 167 struct scsi_device;
 168 struct ata_port_operations;
 169 struct ata_port;
 170 struct ata_queued_cmd;
 171
 172 /* typedefs */
 173 typedef void (*ata_qc_cb_t) (struct ata_queued_cmd *qc, unsigned int flags);
 174
 175 struct ata_ioports {
 176         unsigned long           cmd_addr;
 177         unsigned long           data_addr;
 178         unsigned long           error_addr;
 179         unsigned long           feature_addr;
 180         unsigned long           nsect_addr;
 181         unsigned long           lbal_addr;
 182         unsigned long           lbam_addr;
 183         unsigned long           lbah_addr;
 184         unsigned long           device_addr;
 185         unsigned long           status_addr;
 186         unsigned long           command_addr;
 187         unsigned long           altstatus_addr;
 188         unsigned long           ctl_addr;
 189         unsigned long           bmdma_addr;
 190         unsigned long           scr_addr;
 191 };
 192
 193 struct ata_probe_ent {
 194         struct list_head        node;
 195         struct pci_dev          *pdev;
 196         struct ata_port_operations      *port_ops;
 197         Scsi_Host_Template      *sht;
 198         struct ata_ioports      port[ATA_MAX_PORTS];
 199         unsigned int            n_ports;
 200         unsigned int            pio_mask;
 201         unsigned int            udma_mask;
 202         unsigned int            legacy_mode;
 203         unsigned long           irq;
 204         unsigned int            irq_flags;
 205         unsigned long           host_flags;
 206         void                    *mmio_base;
 207         void                    *private_data;
 208 };
 209
 210 struct ata_host_set {
 211         spinlock_t              lock;
 212         struct pci_dev          *pdev;
 213         unsigned long           irq;
 214         void                    *mmio_base;
 215         unsigned int            n_ports;
 216         void                    *private_data;
 217         struct ata_port *       ports[0];
 218 };
 219
 220 struct ata_queued_cmd {
 221         struct ata_port         *ap;
 222         struct ata_device       *dev;
 223
 224         struct scsi_cmnd        *scsicmd;
 225         void                    (*scsidone)(struct scsi_cmnd *);
 226
 227         struct list_head        node;
 228         unsigned long           flags;          /* ATA_QCFLAG_xxx */
 229         unsigned int            tag;
 230         unsigned int            n_elem;
 231         unsigned int            nsect;
 232         unsigned int            cursect;
 233         unsigned int            cursg;
 234         unsigned int            cursg_ofs;
 235         struct ata_taskfile     tf;
 236         struct scatterlist      sgent;
 237
 238         struct scatterlist      *sg;
 239
 240         ata_qc_cb_t             callback;
 241
 242         struct semaphore        sem;
 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         unsigned int            pio_mode;
 260         unsigned int            udma_mode;
 261
 262         unsigned char           vendor[8];      /* space-padded, not ASCIIZ */
 263         unsigned char           product[32];    /* WARNING: shorter than
 264                                                  * ATAPI7 spec size, 40 ASCII
 265                                                  * characters
 266                                                  */
 267
 268         /* cache info about current transfer mode */
 269         u8                      xfer_protocol;  /* taskfile xfer protocol */
 270         u8                      read_cmd;       /* opcode to use on read */
 271         u8                      write_cmd;      /* opcode to use on write */
 272 };
 273
 274 struct ata_engine {
 275         unsigned long           flags;
 276         struct list_head        q;
 277 };
 278
 279 struct ata_port {
 280         struct Scsi_Host        *host;  /* our co-allocated scsi host */
 281         struct ata_port_operations      *ops;
 282         unsigned long           flags;  /* ATA_FLAG_xxx */
 283         unsigned int            id;     /* unique id req'd by scsi midlyr */
 284         unsigned int            port_no; /* unique port #; from zero */
 285
 286         struct ata_prd          *prd;    /* our SG list */
 287         dma_addr_t              prd_dma; /* and its DMA mapping */
 288
 289         struct ata_ioports      ioaddr; /* ATA cmd/ctl/dma register blocks */
 290
 291         u8                      ctl;    /* cache of ATA control register */
 292         u8                      last_ctl;       /* Cache last written value */
 293         unsigned int            bus_state;
 294         unsigned int            port_state;
 295         unsigned int            pio_mask;
 296         unsigned int            udma_mask;
 297         unsigned int            cbl;    /* cable type; ATA_CBL_xxx */
 298
 299         struct ata_engine       eng;
 300
 301         struct ata_device       device[ATA_MAX_DEVICES];
 302
 303         struct ata_queued_cmd   qcmd[ATA_MAX_QUEUE];
 304         unsigned long           qactive;
 305         unsigned int            active_tag;
 306
 307         struct ata_host_stats   stats;
 308         struct ata_host_set     *host_set;
 309
 310         struct semaphore        sem;
 311         struct semaphore        probe_sem;
 312
 313         unsigned int            thr_state;
 314         int                     time_to_die;
 315         pid_t                   thr_pid;
 316         struct completion       thr_exited;
 317         struct semaphore        thr_sem;
 318         struct timer_list       thr_timer;
 319         unsigned long           thr_timeout;
 320
 321         void                    *private_data;
 322 };
 323
 324 struct ata_port_operations {
 325         void (*port_disable) (struct ata_port *);
 326
 327         void (*dev_config) (struct ata_port *, struct ata_device *);
 328
 329         void (*set_piomode) (struct ata_port *, struct ata_device *,
 330                              unsigned int);
 331         void (*set_udmamode) (struct ata_port *, struct ata_device *,
 332                              unsigned int);
 333
 334         void (*tf_load) (struct ata_port *ap, struct ata_taskfile *tf);
 335         void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);
 336
 337         void (*exec_command)(struct ata_port *ap, struct ata_taskfile *tf);
 338         u8   (*check_status)(struct ata_port *ap);
 339
 340         void (*phy_reset) (struct ata_port *ap);
 341         void (*post_set_mode) (struct ata_port *ap);
 342
 343         void (*bmdma_start) (struct ata_queued_cmd *qc);
 344         void (*fill_sg) (struct ata_queued_cmd *qc);
 345         void (*eng_timeout) (struct ata_port *ap);
 346
 347         irqreturn_t (*irq_handler)(int, void *, struct pt_regs *);
 348
 349         u32 (*scr_read) (struct ata_port *ap, unsigned int sc_reg);
 350         void (*scr_write) (struct ata_port *ap, unsigned int sc_reg,
 351                            u32 val);
 352
 353         int (*port_start) (struct ata_port *ap);
 354         void (*port_stop) (struct ata_port *ap);
 355
 356         void (*host_stop) (struct ata_host_set *host_set);
 357 };
 358
 359 struct ata_port_info {
 360         Scsi_Host_Template      *sht;
 361         unsigned long           host_flags;
 362         unsigned long           pio_mask;
 363         unsigned long           udma_mask;
 364         struct ata_port_operations      *port_ops;
 365 };
 366
 367 struct pci_bits {
 368         unsigned int            reg;    /* PCI config register to read */
 369         unsigned int            width;  /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
 370         unsigned long           mask;
 371         unsigned long           val;
 372 };
 373
 374 extern void ata_port_probe(struct ata_port *);
 375 extern void sata_phy_reset(struct ata_port *ap);
 376 extern void ata_bus_reset(struct ata_port *ap);
 377 extern void ata_port_disable(struct ata_port *);
 378 extern void ata_std_ports(struct ata_ioports *ioaddr);
 379 extern int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
 380                              unsigned int n_ports);
 381 extern void ata_pci_remove_one (struct pci_dev *pdev);
 382 extern int ata_device_add(struct ata_probe_ent *ent);
 383 extern int ata_scsi_detect(Scsi_Host_Template *sht);
 384 extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
 385 extern int ata_scsi_error(struct Scsi_Host *host);
 386 extern int ata_scsi_release(struct Scsi_Host *host);
 387 extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
 388 /*
 389  * Default driver ops implementations
 390  */
 391 extern void ata_tf_load_pio(struct ata_port *ap, struct ata_taskfile *tf);
 392 extern void ata_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf);
 393 extern void ata_tf_read_pio(struct ata_port *ap, struct ata_taskfile *tf);
 394 extern void ata_tf_read_mmio(struct ata_port *ap, struct ata_taskfile *tf);
 395 extern u8 ata_check_status_pio(struct ata_port *ap);
 396 extern u8 ata_check_status_mmio(struct ata_port *ap);
 397 extern void ata_exec_command_pio(struct ata_port *ap, struct ata_taskfile *tf);
 398 extern void ata_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf);
 399 extern int ata_port_start (struct ata_port *ap);
 400 extern void ata_port_stop (struct ata_port *ap);
 401 extern irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs);
 402 extern void ata_fill_sg(struct ata_queued_cmd *qc);
 403 extern void ata_bmdma_start_mmio (struct ata_queued_cmd *qc);
 404 extern void ata_bmdma_start_pio (struct ata_queued_cmd *qc);
 405 extern int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits);
 406 extern void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat, unsigned int done_late);
 407 extern void ata_eng_timeout(struct ata_port *ap);
 408 extern int ata_std_bios_param(struct scsi_device *sdev,
 409                               struct block_device *bdev,
 410                               sector_t capacity, int geom[]);
 411 extern int ata_scsi_slave_config(struct scsi_device *sdev);
 412
 413
 414 static inline unsigned long msecs_to_jiffies(unsigned long msecs)
 415 {
 416         return ((HZ * msecs + 999) / 1000);
 417 }
 418
 419 static inline unsigned int ata_tag_valid(unsigned int tag)
 420 {
 421         return (tag < ATA_MAX_QUEUE) ? 1 : 0;
 422 }
 423
 424 static inline unsigned int ata_dev_present(struct ata_device *dev)
 425 {
 426         return ((dev->class == ATA_DEV_ATA) ||
 427                 (dev->class == ATA_DEV_ATAPI));
 428 }
 429
 430 static inline u8 ata_chk_err(struct ata_port *ap)
 431 {
 432         if (ap->flags & ATA_FLAG_MMIO) {
 433                 return readb((void *) ap->ioaddr.error_addr);
 434         }
 435         return inb(ap->ioaddr.error_addr);
 436 }
 437
 438 static inline u8 ata_chk_status(struct ata_port *ap)
 439 {
 440         return ap->ops->check_status(ap);
 441 }
 442
 443 static inline u8 ata_altstatus(struct ata_port *ap)
 444 {
 445         if (ap->flags & ATA_FLAG_MMIO)
 446                 return readb(ap->ioaddr.altstatus_addr);
 447         return inb(ap->ioaddr.altstatus_addr);
 448 }
 449
 450 static inline void ata_pause(struct ata_port *ap)
 451 {
 452         ata_altstatus(ap);
 453         ndelay(400);
 454 }
 455
 456 static inline u8 ata_busy_wait(struct ata_port *ap, unsigned int bits,
 457                                unsigned int max)
 458 {
 459         u8 status;
 460
 461         do {
 462                 udelay(10);
 463                 status = ata_chk_status(ap);
 464                 max--;
 465         } while ((status & bits) && (max > 0));
 466
 467         return status;
 468 }
 469
 470 static inline u8 ata_wait_idle(struct ata_port *ap)
 471 {
 472         u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
 473
 474         if (status & (ATA_BUSY | ATA_DRQ)) {
 475                 unsigned long l = ap->ioaddr.status_addr;
 476                 printk(KERN_WARNING
 477                        "ATA: abnormal status 0x%X on port 0x%lX\n",
 478                        status, l);
 479         }
 480
 481         return status;
 482 }
 483
 484 static inline struct ata_queued_cmd *ata_qc_from_tag (struct ata_port *ap,
 485                                                       unsigned int tag)
 486 {
 487         if (likely(ata_tag_valid(tag)))
 488                 return &ap->qcmd[tag];
 489         return NULL;
 490 }
 491
 492 static inline void ata_tf_init(struct ata_port *ap, struct ata_taskfile *tf, unsigned int device)
 493 {
 494         memset(tf, 0, sizeof(*tf));
 495
 496         tf->ctl = ap->ctl;
 497         if (device == 0)
 498                 tf->device = ATA_DEVICE_OBS;
 499         else
 500                 tf->device = ATA_DEVICE_OBS | ATA_DEV1;
 501 }
 502
 503 static inline u8 ata_irq_on(struct ata_port *ap)
 504 {
 505         struct ata_ioports *ioaddr = &ap->ioaddr;
 506
 507         ap->ctl &= ~ATA_NIEN;
 508         ap->last_ctl = ap->ctl;
 509
 510         if (ap->flags & ATA_FLAG_MMIO)
 511                 writeb(ap->ctl, ioaddr->ctl_addr);
 512         else
 513                 outb(ap->ctl, ioaddr->ctl_addr);
 514         return ata_wait_idle(ap);
 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 #endif /* __LINUX_LIBATA_H__ */