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