Merge upstream kernel changes into 'C/H/S support' branch of libata.
[GitHub/exynos8895/android_kernel_samsung_universal8895.git] / 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 <linux/pci.h>
29 #include <asm/io.h>
30 #include <linux/ata.h>
31 #include <linux/workqueue.h>
32
33 /*
34 * compile-time options
35 */
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 /* move to PCI layer? */
73 static inline struct device *pci_dev_to_dev(struct pci_dev *pdev)
74 {
75 return &pdev->dev;
76 }
77
78 enum {
79 /* various global constants */
80 LIBATA_MAX_PRD = ATA_MAX_PRD / 2,
81 ATA_MAX_PORTS = 8,
82 ATA_DEF_QUEUE = 1,
83 ATA_MAX_QUEUE = 1,
84 ATA_MAX_SECTORS = 200, /* FIXME */
85 ATA_MAX_BUS = 2,
86 ATA_DEF_BUSY_WAIT = 10000,
87 ATA_SHORT_PAUSE = (HZ >> 6) + 1,
88
89 ATA_SHT_EMULATED = 1,
90 ATA_SHT_CMD_PER_LUN = 1,
91 ATA_SHT_THIS_ID = -1,
92 ATA_SHT_USE_CLUSTERING = 0,
93
94 /* struct ata_device stuff */
95 ATA_DFLAG_LBA48 = (1 << 0), /* device supports LBA48 */
96 ATA_DFLAG_PIO = (1 << 1), /* device currently in PIO mode */
97 ATA_DFLAG_LOCK_SECTORS = (1 << 2), /* don't adjust max_sectors */
98 ATA_DFLAG_LBA = (1 << 3), /* device supports LBA */
99
100 ATA_DEV_UNKNOWN = 0, /* unknown device */
101 ATA_DEV_ATA = 1, /* ATA device */
102 ATA_DEV_ATA_UNSUP = 2, /* ATA device (unsupported) */
103 ATA_DEV_ATAPI = 3, /* ATAPI device */
104 ATA_DEV_ATAPI_UNSUP = 4, /* ATAPI device (unsupported) */
105 ATA_DEV_NONE = 5, /* no device */
106
107 /* struct ata_port flags */
108 ATA_FLAG_SLAVE_POSS = (1 << 1), /* host supports slave dev */
109 /* (doesn't imply presence) */
110 ATA_FLAG_PORT_DISABLED = (1 << 2), /* port is disabled, ignore it */
111 ATA_FLAG_SATA = (1 << 3),
112 ATA_FLAG_NO_LEGACY = (1 << 4), /* no legacy mode check */
113 ATA_FLAG_SRST = (1 << 5), /* use ATA SRST, not E.D.D. */
114 ATA_FLAG_MMIO = (1 << 6), /* use MMIO, not PIO */
115 ATA_FLAG_SATA_RESET = (1 << 7), /* use COMRESET */
116 ATA_FLAG_PIO_DMA = (1 << 8), /* PIO cmds via DMA */
117
118 ATA_QCFLAG_ACTIVE = (1 << 1), /* cmd not yet ack'd to scsi lyer */
119 ATA_QCFLAG_SG = (1 << 3), /* have s/g table? */
120 ATA_QCFLAG_SINGLE = (1 << 4), /* no s/g, just a single buffer */
121 ATA_QCFLAG_DMAMAP = ATA_QCFLAG_SG | ATA_QCFLAG_SINGLE,
122
123 /* various lengths of time */
124 ATA_TMOUT_EDD = 5 * HZ, /* hueristic */
125 ATA_TMOUT_PIO = 30 * HZ,
126 ATA_TMOUT_BOOT = 30 * HZ, /* hueristic */
127 ATA_TMOUT_BOOT_QUICK = 7 * HZ, /* hueristic */
128 ATA_TMOUT_CDB = 30 * HZ,
129 ATA_TMOUT_CDB_QUICK = 5 * HZ,
130
131 /* ATA bus states */
132 BUS_UNKNOWN = 0,
133 BUS_DMA = 1,
134 BUS_IDLE = 2,
135 BUS_NOINTR = 3,
136 BUS_NODATA = 4,
137 BUS_TIMER = 5,
138 BUS_PIO = 6,
139 BUS_EDD = 7,
140 BUS_IDENTIFY = 8,
141 BUS_PACKET = 9,
142
143 /* SATA port states */
144 PORT_UNKNOWN = 0,
145 PORT_ENABLED = 1,
146 PORT_DISABLED = 2,
147
148 /* encoding various smaller bitmaps into a single
149 * unsigned long bitmap
150 */
151 ATA_SHIFT_UDMA = 0,
152 ATA_SHIFT_MWDMA = 8,
153 ATA_SHIFT_PIO = 11,
154 };
155
156 enum pio_task_states {
157 PIO_ST_UNKNOWN,
158 PIO_ST_IDLE,
159 PIO_ST_POLL,
160 PIO_ST_TMOUT,
161 PIO_ST,
162 PIO_ST_LAST,
163 PIO_ST_LAST_POLL,
164 PIO_ST_ERR,
165 };
166
167 /* forward declarations */
168 struct scsi_device;
169 struct ata_port_operations;
170 struct ata_port;
171 struct ata_queued_cmd;
172
173 /* typedefs */
174 typedef int (*ata_qc_cb_t) (struct ata_queued_cmd *qc, u8 drv_stat);
175
176 struct ata_ioports {
177 unsigned long cmd_addr;
178 unsigned long data_addr;
179 unsigned long error_addr;
180 unsigned long feature_addr;
181 unsigned long nsect_addr;
182 unsigned long lbal_addr;
183 unsigned long lbam_addr;
184 unsigned long lbah_addr;
185 unsigned long device_addr;
186 unsigned long status_addr;
187 unsigned long command_addr;
188 unsigned long altstatus_addr;
189 unsigned long ctl_addr;
190 unsigned long bmdma_addr;
191 unsigned long scr_addr;
192 };
193
194 struct ata_probe_ent {
195 struct list_head node;
196 struct device *dev;
197 struct ata_port_operations *port_ops;
198 Scsi_Host_Template *sht;
199 struct ata_ioports port[ATA_MAX_PORTS];
200 unsigned int n_ports;
201 unsigned int hard_port_no;
202 unsigned int pio_mask;
203 unsigned int mwdma_mask;
204 unsigned int udma_mask;
205 unsigned int legacy_mode;
206 unsigned long irq;
207 unsigned int irq_flags;
208 unsigned long host_flags;
209 void __iomem *mmio_base;
210 void *private_data;
211 };
212
213 struct ata_host_set {
214 spinlock_t lock;
215 struct device *dev;
216 unsigned long irq;
217 void __iomem *mmio_base;
218 unsigned int n_ports;
219 void *private_data;
220 struct ata_port_operations *ops;
221 struct ata_port * ports[0];
222 };
223
224 struct ata_queued_cmd {
225 struct ata_port *ap;
226 struct ata_device *dev;
227
228 struct scsi_cmnd *scsicmd;
229 void (*scsidone)(struct scsi_cmnd *);
230
231 struct ata_taskfile tf;
232 u8 cdb[ATAPI_CDB_LEN];
233
234 unsigned long flags; /* ATA_QCFLAG_xxx */
235 unsigned int tag;
236 unsigned int n_elem;
237
238 int dma_dir;
239
240 unsigned int nsect;
241 unsigned int cursect;
242
243 unsigned int nbytes;
244 unsigned int curbytes;
245
246 unsigned int cursg;
247 unsigned int cursg_ofs;
248
249 struct scatterlist sgent;
250 void *buf_virt;
251
252 struct scatterlist *sg;
253
254 ata_qc_cb_t complete_fn;
255
256 struct completion *waiting;
257
258 void *private_data;
259 };
260
261 struct ata_host_stats {
262 unsigned long unhandled_irq;
263 unsigned long idle_irq;
264 unsigned long rw_reqbuf;
265 };
266
267 struct ata_device {
268 u64 n_sectors; /* size of device, if ATA */
269 unsigned long flags; /* ATA_DFLAG_xxx */
270 unsigned int class; /* ATA_DEV_xxx */
271 unsigned int devno; /* 0 or 1 */
272 u16 id[ATA_ID_WORDS]; /* IDENTIFY xxx DEVICE data */
273 u8 pio_mode;
274 u8 dma_mode;
275 u8 xfer_mode;
276 unsigned int xfer_shift; /* ATA_SHIFT_xxx */
277
278 /* cache info about current transfer mode */
279 u8 xfer_protocol; /* taskfile xfer protocol */
280 u8 read_cmd; /* opcode to use on read */
281 u8 write_cmd; /* opcode to use on write */
282
283 /* for CHS addressing */
284 u16 cylinders; /* Number of cylinders */
285 u16 heads; /* Number of heads */
286 u16 sectors; /* Number of sectors per track */
287 };
288
289 struct ata_port {
290 struct Scsi_Host *host; /* our co-allocated scsi host */
291 struct ata_port_operations *ops;
292 unsigned long flags; /* ATA_FLAG_xxx */
293 unsigned int id; /* unique id req'd by scsi midlyr */
294 unsigned int port_no; /* unique port #; from zero */
295 unsigned int hard_port_no; /* hardware port #; from zero */
296
297 struct ata_prd *prd; /* our SG list */
298 dma_addr_t prd_dma; /* and its DMA mapping */
299
300 struct ata_ioports ioaddr; /* ATA cmd/ctl/dma register blocks */
301
302 u8 ctl; /* cache of ATA control register */
303 u8 last_ctl; /* Cache last written value */
304 unsigned int bus_state;
305 unsigned int port_state;
306 unsigned int pio_mask;
307 unsigned int mwdma_mask;
308 unsigned int udma_mask;
309 unsigned int cbl; /* cable type; ATA_CBL_xxx */
310 unsigned int cdb_len;
311
312 struct ata_device device[ATA_MAX_DEVICES];
313
314 struct ata_queued_cmd qcmd[ATA_MAX_QUEUE];
315 unsigned long qactive;
316 unsigned int active_tag;
317
318 struct ata_host_stats stats;
319 struct ata_host_set *host_set;
320
321 struct work_struct packet_task;
322
323 struct work_struct pio_task;
324 unsigned int pio_task_state;
325 unsigned long pio_task_timeout;
326
327 void *private_data;
328 };
329
330 struct ata_port_operations {
331 void (*port_disable) (struct ata_port *);
332
333 void (*dev_config) (struct ata_port *, struct ata_device *);
334
335 void (*set_piomode) (struct ata_port *, struct ata_device *);
336 void (*set_dmamode) (struct ata_port *, struct ata_device *);
337
338 void (*tf_load) (struct ata_port *ap, struct ata_taskfile *tf);
339 void (*tf_read) (struct ata_port *ap, struct ata_taskfile *tf);
340
341 void (*exec_command)(struct ata_port *ap, struct ata_taskfile *tf);
342 u8 (*check_status)(struct ata_port *ap);
343 u8 (*check_altstatus)(struct ata_port *ap);
344 u8 (*check_err)(struct ata_port *ap);
345 void (*dev_select)(struct ata_port *ap, unsigned int device);
346
347 void (*phy_reset) (struct ata_port *ap);
348 void (*post_set_mode) (struct ata_port *ap);
349
350 int (*check_atapi_dma) (struct ata_queued_cmd *qc);
351
352 void (*bmdma_setup) (struct ata_queued_cmd *qc);
353 void (*bmdma_start) (struct ata_queued_cmd *qc);
354
355 void (*qc_prep) (struct ata_queued_cmd *qc);
356 int (*qc_issue) (struct ata_queued_cmd *qc);
357
358 void (*eng_timeout) (struct ata_port *ap);
359
360 irqreturn_t (*irq_handler)(int, void *, struct pt_regs *);
361 void (*irq_clear) (struct ata_port *);
362
363 u32 (*scr_read) (struct ata_port *ap, unsigned int sc_reg);
364 void (*scr_write) (struct ata_port *ap, unsigned int sc_reg,
365 u32 val);
366
367 int (*port_start) (struct ata_port *ap);
368 void (*port_stop) (struct ata_port *ap);
369
370 void (*host_stop) (struct ata_host_set *host_set);
371
372 void (*bmdma_stop) (struct ata_port *ap);
373 u8 (*bmdma_status) (struct ata_port *ap);
374 };
375
376 struct ata_port_info {
377 Scsi_Host_Template *sht;
378 unsigned long host_flags;
379 unsigned long pio_mask;
380 unsigned long mwdma_mask;
381 unsigned long udma_mask;
382 struct ata_port_operations *port_ops;
383 };
384
385
386 extern void ata_port_probe(struct ata_port *);
387 extern void __sata_phy_reset(struct ata_port *ap);
388 extern void sata_phy_reset(struct ata_port *ap);
389 extern void ata_bus_reset(struct ata_port *ap);
390 extern void ata_port_disable(struct ata_port *);
391 extern void ata_std_ports(struct ata_ioports *ioaddr);
392 #ifdef CONFIG_PCI
393 extern int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
394 unsigned int n_ports);
395 extern void ata_pci_remove_one (struct pci_dev *pdev);
396 #endif /* CONFIG_PCI */
397 extern int ata_device_add(struct ata_probe_ent *ent);
398 extern int ata_scsi_detect(Scsi_Host_Template *sht);
399 extern int ata_scsi_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
400 extern int ata_scsi_queuecmd(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *));
401 extern int ata_scsi_error(struct Scsi_Host *host);
402 extern int ata_scsi_release(struct Scsi_Host *host);
403 extern unsigned int ata_host_intr(struct ata_port *ap, struct ata_queued_cmd *qc);
404 /*
405 * Default driver ops implementations
406 */
407 extern void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf);
408 extern void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
409 extern void ata_tf_to_fis(struct ata_taskfile *tf, u8 *fis, u8 pmp);
410 extern void ata_tf_from_fis(u8 *fis, struct ata_taskfile *tf);
411 extern void ata_noop_dev_select (struct ata_port *ap, unsigned int device);
412 extern void ata_std_dev_select (struct ata_port *ap, unsigned int device);
413 extern u8 ata_check_status(struct ata_port *ap);
414 extern u8 ata_altstatus(struct ata_port *ap);
415 extern u8 ata_chk_err(struct ata_port *ap);
416 extern void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf);
417 extern int ata_port_start (struct ata_port *ap);
418 extern void ata_port_stop (struct ata_port *ap);
419 extern void ata_host_stop (struct ata_host_set *host_set);
420 extern irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs);
421 extern void ata_qc_prep(struct ata_queued_cmd *qc);
422 extern int ata_qc_issue_prot(struct ata_queued_cmd *qc);
423 extern void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf,
424 unsigned int buflen);
425 extern void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
426 unsigned int n_elem);
427 extern unsigned int ata_dev_classify(struct ata_taskfile *tf);
428 extern void ata_dev_id_string(u16 *id, unsigned char *s,
429 unsigned int ofs, unsigned int len);
430 extern void ata_dev_config(struct ata_port *ap, unsigned int i);
431 extern void ata_bmdma_setup (struct ata_queued_cmd *qc);
432 extern void ata_bmdma_start (struct ata_queued_cmd *qc);
433 extern void ata_bmdma_stop(struct ata_port *ap);
434 extern u8 ata_bmdma_status(struct ata_port *ap);
435 extern void ata_bmdma_irq_clear(struct ata_port *ap);
436 extern void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat);
437 extern void ata_eng_timeout(struct ata_port *ap);
438 extern void ata_scsi_simulate(u16 *id, struct scsi_cmnd *cmd,
439 void (*done)(struct scsi_cmnd *));
440 extern int ata_std_bios_param(struct scsi_device *sdev,
441 struct block_device *bdev,
442 sector_t capacity, int geom[]);
443 extern int ata_scsi_slave_config(struct scsi_device *sdev);
444
445
446 #ifdef CONFIG_PCI
447 struct pci_bits {
448 unsigned int reg; /* PCI config register to read */
449 unsigned int width; /* 1 (8 bit), 2 (16 bit), 4 (32 bit) */
450 unsigned long mask;
451 unsigned long val;
452 };
453
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);
457
458 #endif /* CONFIG_PCI */
459
460
461 static inline unsigned int ata_tag_valid(unsigned int tag)
462 {
463 return (tag < ATA_MAX_QUEUE) ? 1 : 0;
464 }
465
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 }
471
472 static inline u8 ata_chk_status(struct ata_port *ap)
473 {
474 return ap->ops->check_status(ap);
475 }
476
477
478 /**
479 * ata_pause - Flush writes and pause 400 nanoseconds.
480 * @ap: Port to wait for.
481 *
482 * LOCKING:
483 * Inherited from caller.
484 */
485
486 static inline void ata_pause(struct ata_port *ap)
487 {
488 ata_altstatus(ap);
489 ndelay(400);
490 }
491
492
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 */
504
505 static inline u8 ata_busy_wait(struct ata_port *ap, unsigned int bits,
506 unsigned int max)
507 {
508 u8 status;
509
510 do {
511 udelay(10);
512 status = ata_chk_status(ap);
513 max--;
514 } while ((status & bits) && (max > 0));
515
516 return status;
517 }
518
519
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 */
530
531 static inline u8 ata_wait_idle(struct ata_port *ap)
532 {
533 u8 status = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 1000);
534
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%lX\n",
539 status, l);
540 }
541
542 return status;
543 }
544
545 static inline void ata_qc_set_polling(struct ata_queued_cmd *qc)
546 {
547 qc->tf.ctl |= ATA_NIEN;
548 }
549
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 }
557
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));
561
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 }
568
569
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 */
580
581 static inline u8 ata_irq_on(struct ata_port *ap)
582 {
583 struct ata_ioports *ioaddr = &ap->ioaddr;
584 u8 tmp;
585
586 ap->ctl &= ~ATA_NIEN;
587 ap->last_ctl = ap->ctl;
588
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);
594
595 ap->ops->irq_clear(ap);
596
597 return tmp;
598 }
599
600
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 */
611
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;
616
617 status = ata_busy_wait(ap, bits, 1000);
618 if (status & bits)
619 DPRINTK("abnormal status 0x%X\n", status);
620
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);
627
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);
633
634 post_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
635 }
636
637 VPRINTK("irq ack: host_stat 0x%X, new host_stat 0x%X, drv_stat 0x%X\n",
638 host_stat, post_stat, status);
639
640 return status;
641 }
642
643 static inline u32 scr_read(struct ata_port *ap, unsigned int reg)
644 {
645 return ap->ops->scr_read(ap, reg);
646 }
647
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 }
652
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 }
659
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 }
664
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 }
671
672 #endif /* __LINUX_LIBATA_H__ */