开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
libata.h
资源名称：arm_cross-3.4.4.tar.gz　[点击查看]
上传用户：szlgq88
上传日期：2009-04-28
资源大小：48287k
文件大小：18k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

libata.h：源码内容
  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.  */
  26. #ifndef __LINUX_LIBATA_H__
  27. #define __LINUX_LIBATA_H__
  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>
  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 */
  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 */
  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=%dn", 
  67.         #expr,__FILE__,__FUNCTION__,__LINE__);          
  68.         }
  69. #endif
  71. /* defines only for the constants which don't work well as enums */
  72. #define ATA_TAG_POISON 0xfafbfcfdU
  74. /* move to PCI layer? */
  75. static inline struct device *pci_dev_to_dev(struct pci_dev *pdev)
  76. {
  77. return &pdev->dev;
  78. }
  80. enum {
  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,
  91. ATA_SHT_EMULATED = 1,
  92. ATA_SHT_CMD_PER_LUN = 1,
  93. ATA_SHT_THIS_ID = -1,
  94. ATA_SHT_USE_CLUSTERING = 0,
  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 */
  101. ATA_DEV_UNKNOWN = 0, /* unknown device */
  102. ATA_DEV_ATA = 1, /* ATA device */
  103. ATA_DEV_ATA_UNSUP = 2, /* ATA device (unsupported) */
  104. ATA_DEV_ATAPI = 3, /* ATAPI device */
  105. ATA_DEV_ATAPI_UNSUP = 4, /* ATAPI device (unsupported) */
  106. ATA_DEV_NONE = 5, /* no device */
  108. /* struct ata_port flags */
  109. ATA_FLAG_SLAVE_POSS = (1 << 1), /* host supports slave dev */
  110.     /* (doesn't imply presence) */
  111. ATA_FLAG_PORT_DISABLED = (1 << 2), /* port is disabled, ignore it */
  112. ATA_FLAG_SATA = (1 << 3),
  113. ATA_FLAG_NO_LEGACY = (1 << 4), /* no legacy mode check */
  114. ATA_FLAG_SRST = (1 << 5), /* use ATA SRST, not E.D.D. */
  115. ATA_FLAG_MMIO = (1 << 6), /* use MMIO, not PIO */
  116. ATA_FLAG_SATA_RESET = (1 << 7), /* use COMRESET */
  117. ATA_FLAG_PIO_DMA = (1 << 8), /* PIO cmds via DMA */
  118. ATA_FLAG_NOINTR = (1 << 9), /* FIXME: Remove this once
  119.      * proper HSM is in place. */
  121. ATA_QCFLAG_ACTIVE = (1 << 1), /* cmd not yet ack'd to scsi lyer */
  122. ATA_QCFLAG_SG = (1 << 3), /* have s/g table? */
  123. ATA_QCFLAG_SINGLE = (1 << 4), /* no s/g, just a single buffer */
  124. ATA_QCFLAG_DMAMAP = ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE,
  126. /* various lengths of time */
  127. ATA_TMOUT_EDD = 5 * HZ, /* hueristic */
  128. ATA_TMOUT_PIO = 30 * HZ,
  129. ATA_TMOUT_BOOT = 30 * HZ, /* hueristic */
  130. ATA_TMOUT_BOOT_QUICK = 7 * HZ, /* hueristic */
  131. ATA_TMOUT_CDB = 30 * HZ,
  132. ATA_TMOUT_CDB_QUICK = 5 * HZ,
  134. /* ATA bus states */
  135. BUS_UNKNOWN = 0,
  136. BUS_DMA = 1,
  137. BUS_IDLE = 2,
  138. BUS_NOINTR = 3,
  139. BUS_NODATA = 4,
  140. BUS_TIMER = 5,
  141. BUS_PIO = 6,
  142. BUS_EDD = 7,
  143. BUS_IDENTIFY = 8,
  144. BUS_PACKET = 9,
  146. /* SATA port states */
  147. PORT_UNKNOWN = 0,
  148. PORT_ENABLED = 1,
  149. PORT_DISABLED = 2,
  151. /* encoding various smaller bitmaps into a single
  152.  * unsigned long bitmap
  153.  */
  154. ATA_SHIFT_UDMA = 0,
  155. ATA_SHIFT_MWDMA = 8,
  156. ATA_SHIFT_PIO = 11,
  157. };
  159. enum pio_task_states {
  160. PIO_ST_UNKNOWN,
  161. PIO_ST_IDLE,
  162. PIO_ST_POLL,
  163. PIO_ST_TMOUT,
  164. PIO_ST,
  165. PIO_ST_LAST,
  166. PIO_ST_LAST_POLL,
  167. PIO_ST_ERR,
  168. };
  170. /* forward declarations */
  171. struct scsi_device;
  172. struct ata_port_operations;
  173. struct ata_port;
  174. struct ata_queued_cmd;
  176. /* typedefs */
  177. typedef int (*ata_qc_cb_t) (struct ata_queued_cmd *qc, u8 drv_stat);
  179. struct ata_ioports {
  180. unsigned long cmd_addr;
  181. unsigned long data_addr;
  182. unsigned long error_addr;
  183. unsigned long feature_addr;
  184. unsigned long nsect_addr;
  185. unsigned long lbal_addr;
  186. unsigned long lbam_addr;
  187. unsigned long lbah_addr;
  188. unsigned long device_addr;
  189. unsigned long status_addr;
  190. unsigned long command_addr;
  191. unsigned long altstatus_addr;
  192. unsigned long ctl_addr;
  193. unsigned long bmdma_addr;
  194. unsigned long scr_addr;
  195. };
  197. struct ata_probe_ent {
  198. struct list_head node;
  199. struct device  *dev;
  200. struct ata_port_operations *port_ops;
  201. Scsi_Host_Template *sht;
  202. struct ata_ioports port[ATA_MAX_PORTS];
  203. unsigned int n_ports;
  204. unsigned int hard_port_no;
  205. unsigned int pio_mask;
  206. unsigned int mwdma_mask;
  207. unsigned int udma_mask;
  208. unsigned int legacy_mode;
  209. unsigned long irq;
  210. unsigned int irq_flags;
  211. unsigned long host_flags;
  212. void __iomem *mmio_base;
  213. void *private_data;
  214. };
  216. struct ata_host_set {
  217. spinlock_t lock;
  218. struct device  *dev;
  219. unsigned long irq;
  220. void __iomem *mmio_base;
  221. unsigned int n_ports;
  222. void *private_data;
  223. struct ata_port_operations *ops;
  224. struct ata_port * ports[0];
  225. };
  227. struct ata_queued_cmd {
  228. struct ata_port *ap;
  229. struct ata_device *dev;
  231. struct scsi_cmnd *scsicmd;
  232. void (*scsidone)(struct scsi_cmnd *);
  234. struct ata_taskfile tf;
  235. u8 cdb[ATAPI_CDB_LEN];
  237. unsigned long flags; /* ATA_QCFLAG_xxx */
  238. unsigned int tag;
  239. unsigned int n_elem;
  241. int dma_dir;
  243. unsigned int nsect;
  244. unsigned int cursect;
  246. unsigned int nbytes;
  247. unsigned int curbytes;
  249. unsigned int cursg;
  250. unsigned int cursg_ofs;
  252. struct scatterlist sgent;
  253. void *buf_virt;
  255. struct scatterlist *sg;
  257. ata_qc_cb_t complete_fn;
  259. struct completion *waiting;
  261. void *private_data;
  262. };
  264. struct ata_host_stats {
  265. unsigned long unhandled_irq;
  266. unsigned long idle_irq;
  267. unsigned long rw_reqbuf;
  268. };
  270. struct ata_device {
  271. u64 n_sectors; /* size of device, if ATA */
  272. unsigned long flags; /* ATA_DFLAG_xxx */
  273. unsigned int class; /* ATA_DEV_xxx */
  274. unsigned int devno; /* 0 or 1 */
  275. u16 id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
  276. u8 pio_mode;
  277. u8 dma_mode;
  278. u8 xfer_mode;
  279. unsigned int xfer_shift; /* ATA_SHIFT_xxx */
  281. /* cache info about current transfer mode */
  282. u8 xfer_protocol; /* taskfile xfer protocol */
  283. u8 read_cmd; /* opcode to use on read */
  284. u8 write_cmd; /* opcode to use on write */
  285. };
  287. struct ata_port {
  288. struct Scsi_Host *host; /* our co-allocated scsi host */
  289. struct ata_port_operations *ops;
  290. unsigned long flags; /* ATA_FLAG_xxx */
  291. unsigned int id; /* unique id req'd by scsi midlyr */
  292. unsigned int port_no; /* unique port #; from zero */
  293. unsigned int hard_port_no; /* hardware port #; from zero */
  295. struct ata_prd *prd;  /* our SG list */
  296. dma_addr_t prd_dma; /* and its DMA mapping */
  298. struct ata_ioports ioaddr; /* ATA cmd/ctl/dma register blocks */
  300. u8 ctl; /* cache of ATA control register */
  301. u8 last_ctl; /* Cache last written value */
  302. unsigned int bus_state;
  303. unsigned int port_state;
  304. unsigned int pio_mask;
  305. unsigned int mwdma_mask;
  306. unsigned int udma_mask;
  307. unsigned int cbl; /* cable type; ATA_CBL_xxx */
  308. unsigned int cdb_len;
  310. struct ata_device device[ATA_MAX_DEVICES];
  312. struct ata_queued_cmd qcmd[ATA_MAX_QUEUE];
  313. unsigned long qactive;
  314. unsigned int active_tag;
  316. struct ata_host_stats stats;
  317. struct ata_host_set *host_set;
  319. struct work_struct packet_task;
  321. struct work_struct pio_task;
  322. unsigned int pio_task_state;
  323. unsigned long pio_task_timeout;
  325. void *private_data;
  326. };
  328. struct ata_port_operations {
  329. void (*port_disable) (struct ata_port *);
  331. void (*dev_config) (struct ata_port *, struct ata_device *);
  333. void (*set_piomode) (struct ata_port *, struct ata_device *);
  334. void (*set_dmamode) (struct ata_port *, struct ata_device *);
  336. void (*tf_load) (struct ata_port *ap, struct ata_taskfile *tf);
  337. void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);
  339. void (*exec_command)(struct ata_port *ap, struct ata_taskfile *tf);
  340. u8   (*check_status)(struct ata_port *ap);
  341. u8   (*check_altstatus)(struct ata_port *ap);
  342. u8   (*check_err)(struct ata_port *ap);
  343. void (*dev_select)(struct ata_port *ap, unsigned int device);
  345. void (*phy_reset) (struct ata_port *ap);
  346. void (*post_set_mode) (struct ata_port *ap);
  348. int (*check_atapi_dma) (struct ata_queued_cmd *qc);
  350. void (*bmdma_setup) (struct ata_queued_cmd *qc);
  351. void (*bmdma_start) (struct ata_queued_cmd *qc);
  353. void (*qc_prep) (struct ata_queued_cmd *qc);
  354. int (*qc_issue) (struct ata_queued_cmd *qc);
  356. void (*eng_timeout) (struct ata_port *ap);
  358. irqreturn_t (*irq_handler)(int, void *, struct pt_regs *);
  359. void (*irq_clear) (struct ata_port *);
  361. u32 (*scr_read) (struct ata_port *ap, unsigned int sc_reg);
  362. void (*scr_write) (struct ata_port *ap, unsigned int sc_reg,
  363.    u32 val);
  365. int (*port_start) (struct ata_port *ap);
  366. void (*port_stop) (struct ata_port *ap);
  368. void (*host_stop) (struct ata_host_set *host_set);
  370. void (*bmdma_stop) (struct ata_queued_cmd *qc);
  371. u8   (*bmdma_status) (struct ata_port *ap);
  372. };
  374. struct ata_port_info {
  375. Scsi_Host_Template *sht;
  376. unsigned long host_flags;
  377. unsigned long pio_mask;
  378. unsigned long mwdma_mask;
  379. unsigned long udma_mask;
  380. struct ata_port_operations *port_ops;
  381. };
  384. extern void ata_port_probe(struct ata_port *);
  385. extern void __sata_phy_reset(struct ata_port *ap);
  386. extern void sata_phy_reset(struct ata_port *ap);
  387. extern void ata_bus_reset(struct ata_port *ap);
  388. extern void ata_port_disable(struct ata_port *);
  389. extern void ata_std_ports(struct ata_ioports *ioaddr);
  390. #ifdef CONFIG_PCI
  391. extern int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
  392.      unsigned int n_ports);
  393. extern void ata_pci_remove_one (struct pci_dev *pdev);
  394. #endif /* CONFIG_PCI */
  395. extern int ata_device_add(struct ata_probe_ent *ent);
  396. extern void ata_host_set_remove(struct ata_host_set *host_set);
  397. extern int ata_scsi_detect(Scsi_Host_Template *sht);
  398. extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
  399. extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
  400. extern int ata_scsi_error(struct Scsi_Host *host);
  401. extern int ata_scsi_release(struct Scsi_Host *host);
  402. extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
  403. /*
  404.  * Default driver ops implementations
  405.  */
  406. extern void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf);
  407. extern void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
  408. extern void ata_tf_to_fis(struct ata_taskfile *tf, u8 *fis, u8 pmp);
  409. extern void ata_tf_from_fis(u8 *fis, struct ata_taskfile *tf);
  410. extern void ata_noop_dev_select (struct ata_port *ap, unsigned int device);
  411. extern void ata_std_dev_select (struct ata_port *ap, unsigned int device);
  412. extern u8 ata_check_status(struct ata_port *ap);
  413. extern u8 ata_altstatus(struct ata_port *ap);
  414. extern u8 ata_chk_err(struct ata_port *ap);
  415. extern void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf);
  416. extern int ata_port_start (struct ata_port *ap);
  417. extern void ata_port_stop (struct ata_port *ap);
  418. extern void ata_host_stop (struct ata_host_set *host_set);
  419. extern irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs);
  420. extern void ata_qc_prep(struct ata_queued_cmd *qc);
  421. extern int ata_qc_issue_prot(struct ata_queued_cmd *qc);
  422. extern void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf,
  423. unsigned int buflen);
  424. extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
  425.  unsigned int n_elem);
  426. extern unsigned int ata_dev_classify(struct ata_taskfile *tf);
  427. extern void ata_dev_id_string(u16 *id, unsigned char *s,
  428.       unsigned int ofs, unsigned int len);
  429. extern void ata_dev_config(struct ata_port *ap, unsigned int i);
  430. extern void ata_bmdma_setup (struct ata_queued_cmd *qc);
  431. extern void ata_bmdma_start (struct ata_queued_cmd *qc);
  432. extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
  433. extern u8   ata_bmdma_status(struct ata_port *ap);
  434. extern void ata_bmdma_irq_clear(struct ata_port *ap);
  435. extern void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat);
  436. extern void ata_eng_timeout(struct ata_port *ap);
  437. extern void ata_scsi_simulate(u16 *id, struct scsi_cmnd *cmd,
  438.       void (*done)(struct scsi_cmnd *));
  439. extern int ata_std_bios_param(struct scsi_device *sdev,
  440.       struct block_device *bdev,
  441.       sector_t capacity, int geom[]);
  442. extern int ata_scsi_slave_config(struct scsi_device *sdev);
  445. #ifdef CONFIG_PCI
  446. struct pci_bits {
  447. unsigned int reg; /* PCI config register to read */
  448. unsigned int width; /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
  449. unsigned long mask;
  450. unsigned long val;
  451. };
  453. extern void ata_pci_host_stop (struct ata_host_set *host_set);
  454. extern struct ata_probe_ent *
  455. ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port);
  456. extern int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits);
  458. #endif /* CONFIG_PCI */
  461. static inline unsigned int ata_tag_valid(unsigned int tag)
  462. {
  463. return (tag < ATA_MAX_QUEUE) ? 1 : 0;
  464. }
  466. static inline unsigned int ata_dev_present(struct ata_device *dev)
  467. {
  468. return ((dev->class == ATA_DEV_ATA) ||
  469. (dev->class == ATA_DEV_ATAPI));
  470. }
  472. static inline u8 ata_chk_status(struct ata_port *ap)
  473. {
  474. return ap->ops->check_status(ap);
  475. }
  478. /**
  479.  * ata_pause - Flush writes and pause 400 nanoseconds.
  480.  * @ap: Port to wait for.
  481.  *
  482.  * LOCKING:
  483.  * Inherited from caller.
  484.  */
  486. static inline void ata_pause(struct ata_port *ap)
  487. {
  488. ata_altstatus(ap);
  489. ndelay(400);
  490. }
  493. /**
  494.  * ata_busy_wait - Wait for a port status register
  495.  * @ap: Port to wait for.
  496.  *
  497.  * Waits up to max*10 microseconds for the selected bits in the port's
  498.  * status register to be cleared.
  499.  * Returns final value of status register.
  500.  *
  501.  * LOCKING:
  502.  * Inherited from caller.
  503.  */
  505. static inline u8 ata_busy_wait(struct ata_port *ap, unsigned int bits,
  506.        unsigned int max)
  507. {
  508. u8 status;
  510. do {
  511. udelay(10);
  512. status = ata_chk_status(ap);
  513. max--;
  514. } while ((status & bits) && (max > 0));
  516. return status;
  517. }
  520. /**
  521.  * ata_wait_idle - Wait for a port to be idle.
  522.  * @ap: Port to wait for.
  523.  *
  524.  * Waits up to 10ms for port's BUSY and DRQ signals to clear.
  525.  * Returns final value of status register.
  526.  *
  527.  * LOCKING:
  528.  * Inherited from caller.
  529.  */
  531. static inline u8 ata_wait_idle(struct ata_port *ap)
  532. {
  533. u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
  535. if (status & (ATA_BUSY | ATA_DRQ)) {
  536. unsigned long l = ap->ioaddr.status_addr;
  537. printk(KERN_WARNING
  538.        "ATA: abnormal status 0x%X on port 0x%lXn",
  539.        status, l);
  540. }
  542. return status;
  543. }
  545. static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
  546. {
  547. qc->tf.ctl |= ATA_NIEN;
  548. }
  550. static inline struct ata_queued_cmd *ata_qc_from_tag (struct ata_port *ap,
  551.       unsigned int tag)
  552. {
  553. if (likely(ata_tag_valid(tag)))
  554. return &ap->qcmd[tag];
  555. return NULL;
  556. }
  558. static inline void ata_tf_init(struct ata_port *ap, struct ata_taskfile *tf, unsigned int device)
  559. {
  560. memset(tf, 0, sizeof(*tf));
  562. tf->ctl = ap->ctl;
  563. if (device == 0)
  564. tf->device = ATA_DEVICE_OBS;
  565. else
  566. tf->device = ATA_DEVICE_OBS | ATA_DEV1;
  567. }
  570. /**
  571.  * ata_irq_on - Enable interrupts on a port.
  572.  * @ap: Port on which interrupts are enabled.
  573.  *
  574.  * Enable interrupts on a legacy IDE device using MMIO or PIO,
  575.  * wait for idle, clear any pending interrupts.
  576.  *
  577.  * LOCKING:
  578.  * Inherited from caller.
  579.  */
  581. static inline u8 ata_irq_on(struct ata_port *ap)
  582. {
  583. struct ata_ioports *ioaddr = &ap->ioaddr;
  584. u8 tmp;
  586. ap->ctl &= ~ATA_NIEN;
  587. ap->last_ctl = ap->ctl;
  589. if (ap->flags & ATA_FLAG_MMIO)
  590. writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
  591. else
  592. outb(ap->ctl, ioaddr->ctl_addr);
  593. tmp = ata_wait_idle(ap);
  595. ap->ops->irq_clear(ap);
  597. return tmp;
  598. }
  601. /**
  602.  * ata_irq_ack - Acknowledge a device interrupt.
  603.  * @ap: Port on which interrupts are enabled.
  604.  *
  605.  * Wait up to 10 ms for legacy IDE device to become idle (BUSY
  606.  * or BUSY+DRQ clear).  Obtain dma status and port status from
  607.  * device.  Clear the interrupt.  Return port status.
  608.  *
  609.  * LOCKING:
  610.  */
  612. static inline u8 ata_irq_ack(struct ata_port *ap, unsigned int chk_drq)
  613. {
  614. unsigned int bits = chk_drq ? ATA_BUSY | ATA_DRQ : ATA_BUSY;
  615. u8 host_stat, post_stat, status;
  617. status = ata_busy_wait(ap, bits, 1000);
  618. if (status & bits)
  619. DPRINTK("abnormal status 0x%Xn", status);
  621. /* get controller status; clear intr, err bits */
  622. if (ap->flags & ATA_FLAG_MMIO) {
  623. void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
  624. host_stat = readb(mmio + ATA_DMA_STATUS);
  625. writeb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
  626.        mmio + ATA_DMA_STATUS);
  628. post_stat = readb(mmio + ATA_DMA_STATUS);
  629. } else {
  630. host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
  631. outb(host_stat | ATA_DMA_INTR | ATA_DMA_ERR,
  632.      ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
  634. post_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
  635. }
  637. VPRINTK("irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%Xn",
  638. host_stat, post_stat, status);
  640. return status;
  641. }
  643. static inline u32 scr_read(struct ata_port *ap, unsigned int reg)
  644. {
  645. return ap->ops->scr_read(ap, reg);
  646. }
  648. static inline void scr_write(struct ata_port *ap, unsigned int reg, u32 val)
  649. {
  650. ap->ops->scr_write(ap, reg, val);
  651. }
  653. static inline void scr_write_flush(struct ata_port *ap, unsigned int reg,
  654.    u32 val)
  655. {
  656. ap->ops->scr_write(ap, reg, val);
  657. (void) ap->ops->scr_read(ap, reg);
  658. }
  660. static inline unsigned int sata_dev_present(struct ata_port *ap)
  661. {
  662. return ((scr_read(ap, SCR_STATUS) & 0xf) == 0x3) ? 1 : 0;
  663. }
  665. static inline int ata_try_flush_cache(struct ata_device *dev)
  666. {
  667. return ata_id_wcache_enabled(dev->id) ||
  668.        ata_id_has_flush(dev->id) ||
  669.        ata_id_has_flush_ext(dev->id);
  670. }
  672. #endif /* __LINUX_LIBATA_H__ */