?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MOXA linux-2.6.x / linux-2.6.9-uc0 from sdlinux-moxaart.tgz
[linux-2.6.9-moxart.git] / include / linux / libata.h
blob171b06794ada1eff86381df2ff505b0c797ad693
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__ */
MOXA 2.6.9 from sdlinux-moxaart.tgz