libata.h revision 67846b30171cc4d706125f630193a76a26bb334a
1/* 2 * Copyright 2003-2005 Red Hat, Inc. All rights reserved. 3 * Copyright 2003-2005 Jeff Garzik 4 * 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2, or (at your option) 9 * any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; see the file COPYING. If not, write to 18 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 19 * 20 * 21 * libata documentation is available via 'make {ps|pdf}docs', 22 * as Documentation/DocBook/libata.* 23 * 24 */ 25 26#ifndef __LINUX_LIBATA_H__ 27#define __LINUX_LIBATA_H__ 28 29#include <linux/delay.h> 30#include <linux/interrupt.h> 31#include <linux/pci.h> 32#include <asm/io.h> 33#include <linux/ata.h> 34#include <linux/workqueue.h> 35 36/* 37 * compile-time options 38 */ 39#undef ATA_DEBUG /* debugging output */ 40#undef ATA_VERBOSE_DEBUG /* yet more debugging output */ 41#undef ATA_IRQ_TRAP /* define to ack screaming irqs */ 42#undef ATA_NDEBUG /* define to disable quick runtime checks */ 43#undef ATA_ENABLE_PATA /* define to enable PATA support in some 44 * low-level drivers */ 45#undef ATAPI_ENABLE_DMADIR /* enables ATAPI DMADIR bridge support */ 46 47 48/* note: prints function name for you */ 49#ifdef ATA_DEBUG 50#define DPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args) 51#ifdef ATA_VERBOSE_DEBUG 52#define VPRINTK(fmt, args...) printk(KERN_ERR "%s: " fmt, __FUNCTION__, ## args) 53#else 54#define VPRINTK(fmt, args...) 55#endif /* ATA_VERBOSE_DEBUG */ 56#else 57#define DPRINTK(fmt, args...) 58#define VPRINTK(fmt, args...) 59#endif /* ATA_DEBUG */ 60 61#ifdef ATA_NDEBUG 62#define assert(expr) 63#else 64#define assert(expr) \ 65 if(unlikely(!(expr))) { \ 66 printk(KERN_ERR "Assertion failed! %s,%s,%s,line=%d\n", \ 67 #expr,__FILE__,__FUNCTION__,__LINE__); \ 68 } 69#endif 70 71/* defines only for the constants which don't work well as enums */ 72#define ATA_TAG_POISON 0xfafbfcfdU 73 74/* move to PCI layer? */ 75static inline struct device *pci_dev_to_dev(struct pci_dev *pdev) 76{ 77 return &pdev->dev; 78} 79 80enum { 81 /* various global constants */ 82 LIBATA_MAX_PRD = ATA_MAX_PRD / 2, 83 ATA_MAX_PORTS = 8, 84 ATA_DEF_QUEUE = 1, 85 ATA_MAX_QUEUE = 1, 86 ATA_MAX_SECTORS = 200, /* FIXME */ 87 ATA_MAX_BUS = 2, 88 ATA_DEF_BUSY_WAIT = 10000, 89 ATA_SHORT_PAUSE = (HZ >> 6) + 1, 90 91 ATA_SHT_EMULATED = 1, 92 ATA_SHT_CMD_PER_LUN = 1, 93 ATA_SHT_THIS_ID = -1, 94 ATA_SHT_USE_CLUSTERING = 0, 95 96 /* struct ata_device stuff */ 97 ATA_DFLAG_LBA48 = (1 << 0), /* device supports LBA48 */ 98 ATA_DFLAG_PIO = (1 << 1), /* device currently in PIO mode */ 99 ATA_DFLAG_LOCK_SECTORS = (1 << 2), /* don't adjust max_sectors */ 100 ATA_DFLAG_LBA = (1 << 3), /* device supports LBA */ 101 102 ATA_DEV_UNKNOWN = 0, /* unknown device */ 103 ATA_DEV_ATA = 1, /* ATA device */ 104 ATA_DEV_ATA_UNSUP = 2, /* ATA device (unsupported) */ 105 ATA_DEV_ATAPI = 3, /* ATAPI device */ 106 ATA_DEV_ATAPI_UNSUP = 4, /* ATAPI device (unsupported) */ 107 ATA_DEV_NONE = 5, /* no device */ 108 109 /* struct ata_port flags */ 110 ATA_FLAG_SLAVE_POSS = (1 << 1), /* host supports slave dev */ 111 /* (doesn't imply presence) */ 112 ATA_FLAG_PORT_DISABLED = (1 << 2), /* port is disabled, ignore it */ 113 ATA_FLAG_SATA = (1 << 3), 114 ATA_FLAG_NO_LEGACY = (1 << 4), /* no legacy mode check */ 115 ATA_FLAG_SRST = (1 << 5), /* use ATA SRST, not E.D.D. */ 116 ATA_FLAG_MMIO = (1 << 6), /* use MMIO, not PIO */ 117 ATA_FLAG_SATA_RESET = (1 << 7), /* use COMRESET */ 118 ATA_FLAG_PIO_DMA = (1 << 8), /* PIO cmds via DMA */ 119 ATA_FLAG_NOINTR = (1 << 9), /* FIXME: Remove this once 120 * proper HSM is in place. */ 121 122 ATA_QCFLAG_ACTIVE = (1 << 1), /* cmd not yet ack'd to scsi lyer */ 123 ATA_QCFLAG_SG = (1 << 3), /* have s/g table? */ 124 ATA_QCFLAG_SINGLE = (1 << 4), /* no s/g, just a single buffer */ 125 ATA_QCFLAG_DMAMAP = ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE, 126 127 /* various lengths of time */ 128 ATA_TMOUT_EDD = 5 * HZ, /* hueristic */ 129 ATA_TMOUT_PIO = 30 * HZ, 130 ATA_TMOUT_BOOT = 30 * HZ, /* hueristic */ 131 ATA_TMOUT_BOOT_QUICK = 7 * HZ, /* hueristic */ 132 ATA_TMOUT_CDB = 30 * HZ, 133 ATA_TMOUT_CDB_QUICK = 5 * HZ, 134 135 /* ATA bus states */ 136 BUS_UNKNOWN = 0, 137 BUS_DMA = 1, 138 BUS_IDLE = 2, 139 BUS_NOINTR = 3, 140 BUS_NODATA = 4, 141 BUS_TIMER = 5, 142 BUS_PIO = 6, 143 BUS_EDD = 7, 144 BUS_IDENTIFY = 8, 145 BUS_PACKET = 9, 146 147 /* SATA port states */ 148 PORT_UNKNOWN = 0, 149 PORT_ENABLED = 1, 150 PORT_DISABLED = 2, 151 152 /* encoding various smaller bitmaps into a single 153 * unsigned long bitmap 154 */ 155 ATA_SHIFT_UDMA = 0, 156 ATA_SHIFT_MWDMA = 8, 157 ATA_SHIFT_PIO = 11, 158 159 /* Masks for port functions */ 160 ATA_PORT_PRIMARY = (1 << 0), 161 ATA_PORT_SECONDARY = (1 << 1), 162}; 163 164enum hsm_task_states { 165 HSM_ST_UNKNOWN, 166 HSM_ST_IDLE, 167 HSM_ST_POLL, 168 HSM_ST_TMOUT, 169 HSM_ST, 170 HSM_ST_LAST, 171 HSM_ST_LAST_POLL, 172 HSM_ST_ERR, 173}; 174 175/* forward declarations */ 176struct scsi_device; 177struct ata_port_operations; 178struct ata_port; 179struct ata_queued_cmd; 180 181/* typedefs */ 182typedef int (*ata_qc_cb_t) (struct ata_queued_cmd *qc, u8 drv_stat); 183 184struct ata_ioports { 185 unsigned long cmd_addr; 186 unsigned long data_addr; 187 unsigned long error_addr; 188 unsigned long feature_addr; 189 unsigned long nsect_addr; 190 unsigned long lbal_addr; 191 unsigned long lbam_addr; 192 unsigned long lbah_addr; 193 unsigned long device_addr; 194 unsigned long status_addr; 195 unsigned long command_addr; 196 unsigned long altstatus_addr; 197 unsigned long ctl_addr; 198 unsigned long bmdma_addr; 199 unsigned long scr_addr; 200}; 201 202struct ata_probe_ent { 203 struct list_head node; 204 struct device *dev; 205 struct ata_port_operations *port_ops; 206 Scsi_Host_Template *sht; 207 struct ata_ioports port[ATA_MAX_PORTS]; 208 unsigned int n_ports; 209 unsigned int hard_port_no; 210 unsigned int pio_mask; 211 unsigned int mwdma_mask; 212 unsigned int udma_mask; 213 unsigned int legacy_mode; 214 unsigned long irq; 215 unsigned int irq_flags; 216 unsigned long host_flags; 217 void __iomem *mmio_base; 218 void *private_data; 219}; 220 221struct ata_host_set { 222 spinlock_t lock; 223 struct device *dev; 224 unsigned long irq; 225 void __iomem *mmio_base; 226 unsigned int n_ports; 227 void *private_data; 228 struct ata_port_operations *ops; 229 struct ata_port * ports[0]; 230}; 231 232struct ata_queued_cmd { 233 struct ata_port *ap; 234 struct ata_device *dev; 235 236 struct scsi_cmnd *scsicmd; 237 void (*scsidone)(struct scsi_cmnd *); 238 239 struct ata_taskfile tf; 240 u8 cdb[ATAPI_CDB_LEN]; 241 242 unsigned long flags; /* ATA_QCFLAG_xxx */ 243 unsigned int tag; 244 unsigned int n_elem; 245 246 int dma_dir; 247 248 unsigned int nsect; 249 unsigned int cursect; 250 251 unsigned int nbytes; 252 unsigned int curbytes; 253 254 unsigned int cursg; 255 unsigned int cursg_ofs; 256 257 struct scatterlist sgent; 258 void *buf_virt; 259 260 struct scatterlist *sg; 261 262 ata_qc_cb_t complete_fn; 263 264 struct completion *waiting; 265 266 void *private_data; 267}; 268 269struct ata_host_stats { 270 unsigned long unhandled_irq; 271 unsigned long idle_irq; 272 unsigned long rw_reqbuf; 273}; 274 275struct ata_device { 276 u64 n_sectors; /* size of device, if ATA */ 277 unsigned long flags; /* ATA_DFLAG_xxx */ 278 unsigned int class; /* ATA_DEV_xxx */ 279 unsigned int devno; /* 0 or 1 */ 280 u16 id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */ 281 u8 pio_mode; 282 u8 dma_mode; 283 u8 xfer_mode; 284 unsigned int xfer_shift; /* ATA_SHIFT_xxx */ 285 286 /* cache info about current transfer mode */ 287 u8 xfer_protocol; /* taskfile xfer protocol */ 288 u8 read_cmd; /* opcode to use on read */ 289 u8 write_cmd; /* opcode to use on write */ 290 291 /* for CHS addressing */ 292 u16 cylinders; /* Number of cylinders */ 293 u16 heads; /* Number of heads */ 294 u16 sectors; /* Number of sectors per track */ 295}; 296 297struct ata_port { 298 struct Scsi_Host *host; /* our co-allocated scsi host */ 299 struct ata_port_operations *ops; 300 unsigned long flags; /* ATA_FLAG_xxx */ 301 unsigned int id; /* unique id req'd by scsi midlyr */ 302 unsigned int port_no; /* unique port #; from zero */ 303 unsigned int hard_port_no; /* hardware port #; from zero */ 304 305 struct ata_prd *prd; /* our SG list */ 306 dma_addr_t prd_dma; /* and its DMA mapping */ 307 308 struct ata_ioports ioaddr; /* ATA cmd/ctl/dma register blocks */ 309 310 u8 ctl; /* cache of ATA control register */ 311 u8 last_ctl; /* Cache last written value */ 312 unsigned int bus_state; 313 unsigned int port_state; 314 unsigned int pio_mask; 315 unsigned int mwdma_mask; 316 unsigned int udma_mask; 317 unsigned int cbl; /* cable type; ATA_CBL_xxx */ 318 unsigned int cdb_len; 319 320 struct ata_device device[ATA_MAX_DEVICES]; 321 322 struct ata_queued_cmd qcmd[ATA_MAX_QUEUE]; 323 unsigned long qactive; 324 unsigned int active_tag; 325 326 struct ata_host_stats stats; 327 struct ata_host_set *host_set; 328 329 struct work_struct packet_task; 330 331 struct work_struct pio_task; 332 unsigned int hsm_task_state; 333 unsigned long pio_task_timeout; 334 335 void *private_data; 336}; 337 338struct ata_port_operations { 339 void (*port_disable) (struct ata_port *); 340 341 void (*dev_config) (struct ata_port *, struct ata_device *); 342 343 void (*set_piomode) (struct ata_port *, struct ata_device *); 344 void (*set_dmamode) (struct ata_port *, struct ata_device *); 345 346 void (*tf_load) (struct ata_port *ap, struct ata_taskfile *tf); 347 void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf); 348 349 void (*exec_command)(struct ata_port *ap, struct ata_taskfile *tf); 350 u8 (*check_status)(struct ata_port *ap); 351 u8 (*check_altstatus)(struct ata_port *ap); 352 u8 (*check_err)(struct ata_port *ap); 353 void (*dev_select)(struct ata_port *ap, unsigned int device); 354 355 void (*phy_reset) (struct ata_port *ap); 356 void (*post_set_mode) (struct ata_port *ap); 357 358 int (*check_atapi_dma) (struct ata_queued_cmd *qc); 359 360 void (*bmdma_setup) (struct ata_queued_cmd *qc); 361 void (*bmdma_start) (struct ata_queued_cmd *qc); 362 363 void (*qc_prep) (struct ata_queued_cmd *qc); 364 int (*qc_issue) (struct ata_queued_cmd *qc); 365 366 void (*eng_timeout) (struct ata_port *ap); 367 368 irqreturn_t (*irq_handler)(int, void *, struct pt_regs *); 369 void (*irq_clear) (struct ata_port *); 370 371 u32 (*scr_read) (struct ata_port *ap, unsigned int sc_reg); 372 void (*scr_write) (struct ata_port *ap, unsigned int sc_reg, 373 u32 val); 374 375 int (*port_start) (struct ata_port *ap); 376 void (*port_stop) (struct ata_port *ap); 377 378 void (*host_stop) (struct ata_host_set *host_set); 379 380 void (*bmdma_stop) (struct ata_queued_cmd *qc); 381 u8 (*bmdma_status) (struct ata_port *ap); 382}; 383 384struct ata_port_info { 385 Scsi_Host_Template *sht; 386 unsigned long host_flags; 387 unsigned long pio_mask; 388 unsigned long mwdma_mask; 389 unsigned long udma_mask; 390 struct ata_port_operations *port_ops; 391}; 392 393 394extern void ata_port_probe(struct ata_port *); 395extern void __sata_phy_reset(struct ata_port *ap); 396extern void sata_phy_reset(struct ata_port *ap); 397extern void ata_bus_reset(struct ata_port *ap); 398extern void ata_port_disable(struct ata_port *); 399extern void ata_std_ports(struct ata_ioports *ioaddr); 400#ifdef CONFIG_PCI 401extern int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info, 402 unsigned int n_ports); 403extern void ata_pci_remove_one (struct pci_dev *pdev); 404#endif /* CONFIG_PCI */ 405extern int ata_device_add(struct ata_probe_ent *ent); 406extern void ata_host_set_remove(struct ata_host_set *host_set); 407extern int ata_scsi_detect(Scsi_Host_Template *sht); 408extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg); 409extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *)); 410extern int ata_scsi_error(struct Scsi_Host *host); 411extern int ata_scsi_release(struct Scsi_Host *host); 412extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc); 413extern int ata_ratelimit(void); 414 415/* 416 * Default driver ops implementations 417 */ 418extern void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf); 419extern void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf); 420extern void ata_tf_to_fis(struct ata_taskfile *tf, u8 *fis, u8 pmp); 421extern void ata_tf_from_fis(u8 *fis, struct ata_taskfile *tf); 422extern void ata_noop_dev_select (struct ata_port *ap, unsigned int device); 423extern void ata_std_dev_select (struct ata_port *ap, unsigned int device); 424extern u8 ata_check_status(struct ata_port *ap); 425extern u8 ata_altstatus(struct ata_port *ap); 426extern u8 ata_chk_err(struct ata_port *ap); 427extern void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf); 428extern int ata_port_start (struct ata_port *ap); 429extern void ata_port_stop (struct ata_port *ap); 430extern void ata_host_stop (struct ata_host_set *host_set); 431extern irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs); 432extern void ata_qc_prep(struct ata_queued_cmd *qc); 433extern int ata_qc_issue_prot(struct ata_queued_cmd *qc); 434extern void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, 435 unsigned int buflen); 436extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg, 437 unsigned int n_elem); 438extern unsigned int ata_dev_classify(struct ata_taskfile *tf); 439extern void ata_dev_id_string(u16 *id, unsigned char *s, 440 unsigned int ofs, unsigned int len); 441extern void ata_dev_config(struct ata_port *ap, unsigned int i); 442extern void ata_bmdma_setup (struct ata_queued_cmd *qc); 443extern void ata_bmdma_start (struct ata_queued_cmd *qc); 444extern void ata_bmdma_stop(struct ata_queued_cmd *qc); 445extern u8 ata_bmdma_status(struct ata_port *ap); 446extern void ata_bmdma_irq_clear(struct ata_port *ap); 447extern void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat); 448extern void ata_eng_timeout(struct ata_port *ap); 449extern void ata_scsi_simulate(u16 *id, struct scsi_cmnd *cmd, 450 void (*done)(struct scsi_cmnd *)); 451extern int ata_std_bios_param(struct scsi_device *sdev, 452 struct block_device *bdev, 453 sector_t capacity, int geom[]); 454extern int ata_scsi_slave_config(struct scsi_device *sdev); 455 456 457#ifdef CONFIG_PCI 458struct pci_bits { 459 unsigned int reg; /* PCI config register to read */ 460 unsigned int width; /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */ 461 unsigned long mask; 462 unsigned long val; 463}; 464 465extern void ata_pci_host_stop (struct ata_host_set *host_set); 466extern struct ata_probe_ent * 467ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port, int portmask); 468extern int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits); 469 470#endif /* CONFIG_PCI */ 471 472 473static inline unsigned int ata_tag_valid(unsigned int tag) 474{ 475 return (tag < ATA_MAX_QUEUE) ? 1 : 0; 476} 477 478static inline unsigned int ata_dev_present(struct ata_device *dev) 479{ 480 return ((dev->class == ATA_DEV_ATA) || 481 (dev->class == ATA_DEV_ATAPI)); 482} 483 484static inline u8 ata_chk_status(struct ata_port *ap) 485{ 486 return ap->ops->check_status(ap); 487} 488 489 490/** 491 * ata_pause - Flush writes and pause 400 nanoseconds. 492 * @ap: Port to wait for. 493 * 494 * LOCKING: 495 * Inherited from caller. 496 */ 497 498static inline void ata_pause(struct ata_port *ap) 499{ 500 ata_altstatus(ap); 501 ndelay(400); 502} 503 504 505/** 506 * ata_busy_wait - Wait for a port status register 507 * @ap: Port to wait for. 508 * 509 * Waits up to max*10 microseconds for the selected bits in the port's 510 * status register to be cleared. 511 * Returns final value of status register. 512 * 513 * LOCKING: 514 * Inherited from caller. 515 */ 516 517static inline u8 ata_busy_wait(struct ata_port *ap, unsigned int bits, 518 unsigned int max) 519{ 520 u8 status; 521 522 do { 523 udelay(10); 524 status = ata_chk_status(ap); 525 max--; 526 } while ((status & bits) && (max > 0)); 527 528 return status; 529} 530 531 532/** 533 * ata_wait_idle - Wait for a port to be idle. 534 * @ap: Port to wait for. 535 * 536 * Waits up to 10ms for port's BUSY and DRQ signals to clear. 537 * Returns final value of status register. 538 * 539 * LOCKING: 540 * Inherited from caller. 541 */ 542 543static inline u8 ata_wait_idle(struct ata_port *ap) 544{ 545 u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000); 546 547 if (status & (ATA_BUSY | ATA_DRQ)) { 548 unsigned long l = ap->ioaddr.status_addr; 549 printk(KERN_WARNING 550 "ATA: abnormal status 0x%X on port 0x%lX\n", 551 status, l); 552 } 553 554 return status; 555} 556 557static inline void ata_qc_set_polling(struct ata_queued_cmd *qc) 558{ 559 qc->tf.ctl |= ATA_NIEN; 560} 561 562static inline struct ata_queued_cmd *ata_qc_from_tag (struct ata_port *ap, 563 unsigned int tag) 564{ 565 if (likely(ata_tag_valid(tag))) 566 return &ap->qcmd[tag]; 567 return NULL; 568} 569 570static inline void ata_tf_init(struct ata_port *ap, struct ata_taskfile *tf, unsigned int device) 571{ 572 memset(tf, 0, sizeof(*tf)); 573 574 tf->ctl = ap->ctl; 575 if (device == 0) 576 tf->device = ATA_DEVICE_OBS; 577 else 578 tf->device = ATA_DEVICE_OBS | ATA_DEV1; 579} 580 581 582/** 583 * ata_irq_on - Enable interrupts on a port. 584 * @ap: Port on which interrupts are enabled. 585 * 586 * Enable interrupts on a legacy IDE device using MMIO or PIO, 587 * wait for idle, clear any pending interrupts. 588 * 589 * LOCKING: 590 * Inherited from caller. 591 */ 592 593static inline u8 ata_irq_on(struct ata_port *ap) 594{ 595 struct ata_ioports *ioaddr = &ap->ioaddr; 596 u8 tmp; 597 598 ap->ctl &= ~ATA_NIEN; 599 ap->last_ctl = ap->ctl; 600 601 if (ap->flags & ATA_FLAG_MMIO) 602 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr); 603 else 604 outb(ap->ctl, ioaddr->ctl_addr); 605 tmp = ata_wait_idle(ap); 606 607 ap->ops->irq_clear(ap); 608 609 return tmp; 610} 611 612 613/** 614 * ata_irq_ack - Acknowledge a device interrupt. 615 * @ap: Port on which interrupts are enabled. 616 * 617 * Wait up to 10 ms for legacy IDE device to become idle (BUSY 618 * or BUSY+DRQ clear). Obtain dma status and port status from 619 * device. Clear the interrupt. Return port status. 620 * 621 * LOCKING: 622 */ 623 624static inline u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq) 625{ 626 unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY; 627 u8 host_stat, post_stat, status; 628 629 status = ata_busy_wait(ap, bits, 1000); 630 if (status & bits) 631 DPRINTK("abnormal status 0x%X\n", status); 632 633 /* get controller status; clear intr, err bits */ 634 if (ap->flags & ATA_FLAG_MMIO) { 635 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr; 636 host_stat = readb(mmio + ATA_DMA_STATUS); 637 writeb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR, 638 mmio + ATA_DMA_STATUS); 639 640 post_stat = readb(mmio + ATA_DMA_STATUS); 641 } else { 642 host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS); 643 outb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR, 644 ap->ioaddr.bmdma_addr + ATA_DMA_STATUS); 645 646 post_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS); 647 } 648 649 VPRINTK("irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n", 650 host_stat, post_stat, status); 651 652 return status; 653} 654 655static inline u32 scr_read(struct ata_port *ap, unsigned int reg) 656{ 657 return ap->ops->scr_read(ap, reg); 658} 659 660static inline void scr_write(struct ata_port *ap, unsigned int reg, u32 val) 661{ 662 ap->ops->scr_write(ap, reg, val); 663} 664 665static inline void scr_write_flush(struct ata_port *ap, unsigned int reg, 666 u32 val) 667{ 668 ap->ops->scr_write(ap, reg, val); 669 (void) ap->ops->scr_read(ap, reg); 670} 671 672static inline unsigned int sata_dev_present(struct ata_port *ap) 673{ 674 return ((scr_read(ap, SCR_STATUS) & 0xf) == 0x3) ? 1 : 0; 675} 676 677static inline int ata_try_flush_cache(struct ata_device *dev) 678{ 679 return ata_id_wcache_enabled(dev->id) || 680 ata_id_has_flush(dev->id) || 681 ata_id_has_flush_ext(dev->id); 682} 683 684#endif /* __LINUX_LIBATA_H__ */ 685