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