2 libata-core.c - helper library for ATA
4 Copyright 2003-2004 Red Hat, Inc. All rights reserved.
5 Copyright 2003-2004 Jeff Garzik
7 The contents of this file are subject to the Open
8 Software License version 1.1 that can be found at
9 http://www.opensource.org/licenses/osl-1.1.txt and is included herein
12 Alternatively, the contents of this file may be used under the terms
13 of the GNU General Public License version 2 (the "GPL") as distributed
14 in the kernel source COPYING file, in which case the provisions of
15 the GPL are applicable instead of the above. If you wish to allow
16 the use of your version of this file only under the terms of the
17 GPL and not to allow others to use your version of this file under
18 the OSL, indicate your decision by deleting the provisions above and
19 replace them with the notice and other provisions required by the GPL.
20 If you do not delete the provisions above, a recipient may use your
21 version of this file under either the OSL or the GPL.
25 #include <linux/config.h>
26 #include <linux/kernel.h>
27 #include <linux/module.h>
28 #include <linux/pci.h>
29 #include <linux/init.h>
30 #include <linux/list.h>
32 #include <linux/highmem.h>
33 #include <linux/spinlock.h>
34 #include <linux/blkdev.h>
35 #include <linux/delay.h>
36 #include <linux/timer.h>
37 #include <linux/interrupt.h>
38 #include <linux/completion.h>
39 #include <linux/suspend.h>
40 #include <linux/workqueue.h>
41 #include <scsi/scsi.h>
43 #include "scsi_priv.h"
44 #include <scsi/scsi_host.h>
45 #include <linux/libata.h>
47 #include <asm/semaphore.h>
48 #include <asm/byteorder.h>
52 static unsigned int ata_busy_sleep (struct ata_port *ap,
53 unsigned long tmout_pat,
55 static void ata_set_mode(struct ata_port *ap);
56 static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev);
57 static unsigned int ata_get_mode_mask(struct ata_port *ap, int shift);
58 static int fgb(u32 bitmap);
59 static int ata_choose_xfer_mode(struct ata_port *ap,
61 unsigned int *xfer_shift_out);
62 static int ata_qc_complete_noop(struct ata_queued_cmd *qc, u8 drv_stat);
63 static void __ata_qc_complete(struct ata_queued_cmd *qc);
65 static unsigned int ata_unique_id = 1;
66 static struct workqueue_struct *ata_wq;
68 MODULE_AUTHOR("Jeff Garzik");
69 MODULE_DESCRIPTION("Library module for ATA devices");
70 MODULE_LICENSE("GPL");
71 MODULE_VERSION(DRV_VERSION);
74 * ata_tf_load - send taskfile registers to host controller
75 * @ap: Port to which output is sent
76 * @tf: ATA taskfile register set
78 * Outputs ATA taskfile to standard ATA host controller.
81 * Inherited from caller.
84 static void ata_tf_load_pio(struct ata_port *ap, struct ata_taskfile *tf)
86 struct ata_ioports *ioaddr = &ap->ioaddr;
87 unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
89 if (tf->ctl != ap->last_ctl) {
90 outb(tf->ctl, ioaddr->ctl_addr);
91 ap->last_ctl = tf->ctl;
95 if (is_addr && (tf->flags & ATA_TFLAG_LBA48)) {
96 outb(tf->hob_feature, ioaddr->feature_addr);
97 outb(tf->hob_nsect, ioaddr->nsect_addr);
98 outb(tf->hob_lbal, ioaddr->lbal_addr);
99 outb(tf->hob_lbam, ioaddr->lbam_addr);
100 outb(tf->hob_lbah, ioaddr->lbah_addr);
101 VPRINTK("hob: feat 0x%X nsect 0x%X, lba 0x%X 0x%X 0x%X\n",
110 outb(tf->feature, ioaddr->feature_addr);
111 outb(tf->nsect, ioaddr->nsect_addr);
112 outb(tf->lbal, ioaddr->lbal_addr);
113 outb(tf->lbam, ioaddr->lbam_addr);
114 outb(tf->lbah, ioaddr->lbah_addr);
115 VPRINTK("feat 0x%X nsect 0x%X lba 0x%X 0x%X 0x%X\n",
123 if (tf->flags & ATA_TFLAG_DEVICE) {
124 outb(tf->device, ioaddr->device_addr);
125 VPRINTK("device 0x%X\n", tf->device);
132 * ata_tf_load_mmio - send taskfile registers to host controller
133 * @ap: Port to which output is sent
134 * @tf: ATA taskfile register set
136 * Outputs ATA taskfile to standard ATA host controller using MMIO.
139 * Inherited from caller.
142 static void ata_tf_load_mmio(struct ata_port *ap, struct ata_taskfile *tf)
144 struct ata_ioports *ioaddr = &ap->ioaddr;
145 unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
147 if (tf->ctl != ap->last_ctl) {
148 writeb(tf->ctl, (void __iomem *) ap->ioaddr.ctl_addr);
149 ap->last_ctl = tf->ctl;
153 if (is_addr && (tf->flags & ATA_TFLAG_LBA48)) {
154 writeb(tf->hob_feature, (void __iomem *) ioaddr->feature_addr);
155 writeb(tf->hob_nsect, (void __iomem *) ioaddr->nsect_addr);
156 writeb(tf->hob_lbal, (void __iomem *) ioaddr->lbal_addr);
157 writeb(tf->hob_lbam, (void __iomem *) ioaddr->lbam_addr);
158 writeb(tf->hob_lbah, (void __iomem *) ioaddr->lbah_addr);
159 VPRINTK("hob: feat 0x%X nsect 0x%X, lba 0x%X 0x%X 0x%X\n",
168 writeb(tf->feature, (void __iomem *) ioaddr->feature_addr);
169 writeb(tf->nsect, (void __iomem *) ioaddr->nsect_addr);
170 writeb(tf->lbal, (void __iomem *) ioaddr->lbal_addr);
171 writeb(tf->lbam, (void __iomem *) ioaddr->lbam_addr);
172 writeb(tf->lbah, (void __iomem *) ioaddr->lbah_addr);
173 VPRINTK("feat 0x%X nsect 0x%X lba 0x%X 0x%X 0x%X\n",
181 if (tf->flags & ATA_TFLAG_DEVICE) {
182 writeb(tf->device, (void __iomem *) ioaddr->device_addr);
183 VPRINTK("device 0x%X\n", tf->device);
191 * ata_tf_load - send taskfile registers to host controller
192 * @ap: Port to which output is sent
193 * @tf: ATA taskfile register set
195 * Outputs ATA taskfile to standard ATA host controller using MMIO
196 * or PIO as indicated by the ATA_FLAG_MMIO flag.
197 * Writes the control, feature, nsect, lbal, lbam, and lbah registers.
198 * Optionally (ATA_TFLAG_LBA48) writes hob_feature, hob_nsect,
199 * hob_lbal, hob_lbam, and hob_lbah.
201 * This function waits for idle (!BUSY and !DRQ) after writing
202 * registers. If the control register has a new value, this
203 * function also waits for idle after writing control and before
204 * writing the remaining registers.
206 * May be used as the tf_load() entry in ata_port_operations.
209 * Inherited from caller.
211 void ata_tf_load(struct ata_port *ap, struct ata_taskfile *tf)
213 if (ap->flags & ATA_FLAG_MMIO)
214 ata_tf_load_mmio(ap, tf);
216 ata_tf_load_pio(ap, tf);
220 * ata_exec_command_pio - issue ATA command to host controller
221 * @ap: port to which command is being issued
222 * @tf: ATA taskfile register set
224 * Issues PIO write to ATA command register, with proper
225 * synchronization with interrupt handler / other threads.
228 * spin_lock_irqsave(host_set lock)
231 static void ata_exec_command_pio(struct ata_port *ap, struct ata_taskfile *tf)
233 DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
235 outb(tf->command, ap->ioaddr.command_addr);
241 * ata_exec_command_mmio - issue ATA command to host controller
242 * @ap: port to which command is being issued
243 * @tf: ATA taskfile register set
245 * Issues MMIO write to ATA command register, with proper
246 * synchronization with interrupt handler / other threads.
249 * spin_lock_irqsave(host_set lock)
252 static void ata_exec_command_mmio(struct ata_port *ap, struct ata_taskfile *tf)
254 DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
256 writeb(tf->command, (void __iomem *) ap->ioaddr.command_addr);
262 * ata_exec_command - issue ATA command to host controller
263 * @ap: port to which command is being issued
264 * @tf: ATA taskfile register set
266 * Issues PIO/MMIO write to ATA command register, with proper
267 * synchronization with interrupt handler / other threads.
270 * spin_lock_irqsave(host_set lock)
272 void ata_exec_command(struct ata_port *ap, struct ata_taskfile *tf)
274 if (ap->flags & ATA_FLAG_MMIO)
275 ata_exec_command_mmio(ap, tf);
277 ata_exec_command_pio(ap, tf);
281 * ata_exec - issue ATA command to host controller
282 * @ap: port to which command is being issued
283 * @tf: ATA taskfile register set
285 * Issues PIO/MMIO write to ATA command register, with proper
286 * synchronization with interrupt handler / other threads.
289 * Obtains host_set lock.
292 static inline void ata_exec(struct ata_port *ap, struct ata_taskfile *tf)
296 DPRINTK("ata%u: cmd 0x%X\n", ap->id, tf->command);
297 spin_lock_irqsave(&ap->host_set->lock, flags);
298 ap->ops->exec_command(ap, tf);
299 spin_unlock_irqrestore(&ap->host_set->lock, flags);
303 * ata_tf_to_host - issue ATA taskfile to host controller
304 * @ap: port to which command is being issued
305 * @tf: ATA taskfile register set
307 * Issues ATA taskfile register set to ATA host controller,
308 * with proper synchronization with interrupt handler and
312 * Obtains host_set lock.
315 static void ata_tf_to_host(struct ata_port *ap, struct ata_taskfile *tf)
317 ap->ops->tf_load(ap, tf);
323 * ata_tf_to_host_nolock - issue ATA taskfile to host controller
324 * @ap: port to which command is being issued
325 * @tf: ATA taskfile register set
327 * Issues ATA taskfile register set to ATA host controller,
328 * with proper synchronization with interrupt handler and
332 * spin_lock_irqsave(host_set lock)
335 void ata_tf_to_host_nolock(struct ata_port *ap, struct ata_taskfile *tf)
337 ap->ops->tf_load(ap, tf);
338 ap->ops->exec_command(ap, tf);
342 * ata_tf_read_pio - input device's ATA taskfile shadow registers
343 * @ap: Port from which input is read
344 * @tf: ATA taskfile register set for storing input
346 * Reads ATA taskfile registers for currently-selected device
350 * Inherited from caller.
353 static void ata_tf_read_pio(struct ata_port *ap, struct ata_taskfile *tf)
355 struct ata_ioports *ioaddr = &ap->ioaddr;
357 tf->nsect = inb(ioaddr->nsect_addr);
358 tf->lbal = inb(ioaddr->lbal_addr);
359 tf->lbam = inb(ioaddr->lbam_addr);
360 tf->lbah = inb(ioaddr->lbah_addr);
361 tf->device = inb(ioaddr->device_addr);
363 if (tf->flags & ATA_TFLAG_LBA48) {
364 outb(tf->ctl | ATA_HOB, ioaddr->ctl_addr);
365 tf->hob_feature = inb(ioaddr->error_addr);
366 tf->hob_nsect = inb(ioaddr->nsect_addr);
367 tf->hob_lbal = inb(ioaddr->lbal_addr);
368 tf->hob_lbam = inb(ioaddr->lbam_addr);
369 tf->hob_lbah = inb(ioaddr->lbah_addr);
374 * ata_tf_read_mmio - input device's ATA taskfile shadow registers
375 * @ap: Port from which input is read
376 * @tf: ATA taskfile register set for storing input
378 * Reads ATA taskfile registers for currently-selected device
382 * Inherited from caller.
385 static void ata_tf_read_mmio(struct ata_port *ap, struct ata_taskfile *tf)
387 struct ata_ioports *ioaddr = &ap->ioaddr;
389 tf->nsect = readb((void __iomem *)ioaddr->nsect_addr);
390 tf->lbal = readb((void __iomem *)ioaddr->lbal_addr);
391 tf->lbam = readb((void __iomem *)ioaddr->lbam_addr);
392 tf->lbah = readb((void __iomem *)ioaddr->lbah_addr);
393 tf->device = readb((void __iomem *)ioaddr->device_addr);
395 if (tf->flags & ATA_TFLAG_LBA48) {
396 writeb(tf->ctl | ATA_HOB, (void __iomem *) ap->ioaddr.ctl_addr);
397 tf->hob_feature = readb((void __iomem *)ioaddr->error_addr);
398 tf->hob_nsect = readb((void __iomem *)ioaddr->nsect_addr);
399 tf->hob_lbal = readb((void __iomem *)ioaddr->lbal_addr);
400 tf->hob_lbam = readb((void __iomem *)ioaddr->lbam_addr);
401 tf->hob_lbah = readb((void __iomem *)ioaddr->lbah_addr);
407 * ata_tf_read - input device's ATA taskfile shadow registers
408 * @ap: Port from which input is read
409 * @tf: ATA taskfile register set for storing input
411 * Reads ATA taskfile registers for currently-selected device
414 * Reads nsect, lbal, lbam, lbah, and device. If ATA_TFLAG_LBA48
415 * is set, also reads the hob registers.
417 * May be used as the tf_read() entry in ata_port_operations.
420 * Inherited from caller.
422 void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
424 if (ap->flags & ATA_FLAG_MMIO)
425 ata_tf_read_mmio(ap, tf);
427 ata_tf_read_pio(ap, tf);
431 * ata_check_status_pio - Read device status reg & clear interrupt
432 * @ap: port where the device is
434 * Reads ATA taskfile status register for currently-selected device
435 * and return its value. This also clears pending interrupts
439 * Inherited from caller.
441 static u8 ata_check_status_pio(struct ata_port *ap)
443 return inb(ap->ioaddr.status_addr);
447 * ata_check_status_mmio - Read device status reg & clear interrupt
448 * @ap: port where the device is
450 * Reads ATA taskfile status register for currently-selected device
451 * via MMIO and return its value. This also clears pending interrupts
455 * Inherited from caller.
457 static u8 ata_check_status_mmio(struct ata_port *ap)
459 return readb((void __iomem *) ap->ioaddr.status_addr);
464 * ata_check_status - Read device status reg & clear interrupt
465 * @ap: port where the device is
467 * Reads ATA taskfile status register for currently-selected device
468 * and return its value. This also clears pending interrupts
471 * May be used as the check_status() entry in ata_port_operations.
474 * Inherited from caller.
476 u8 ata_check_status(struct ata_port *ap)
478 if (ap->flags & ATA_FLAG_MMIO)
479 return ata_check_status_mmio(ap);
480 return ata_check_status_pio(ap);
485 * ata_altstatus - Read device alternate status reg
486 * @ap: port where the device is
488 * Reads ATA taskfile alternate status register for
489 * currently-selected device and return its value.
491 * Note: may NOT be used as the check_altstatus() entry in
492 * ata_port_operations.
495 * Inherited from caller.
497 u8 ata_altstatus(struct ata_port *ap)
499 if (ap->ops->check_altstatus)
500 return ap->ops->check_altstatus(ap);
502 if (ap->flags & ATA_FLAG_MMIO)
503 return readb((void __iomem *)ap->ioaddr.altstatus_addr);
504 return inb(ap->ioaddr.altstatus_addr);
509 * ata_chk_err - Read device error reg
510 * @ap: port where the device is
512 * Reads ATA taskfile error register for
513 * currently-selected device and return its value.
515 * Note: may NOT be used as the check_err() entry in
516 * ata_port_operations.
519 * Inherited from caller.
521 u8 ata_chk_err(struct ata_port *ap)
523 if (ap->ops->check_err)
524 return ap->ops->check_err(ap);
526 if (ap->flags & ATA_FLAG_MMIO) {
527 return readb((void __iomem *) ap->ioaddr.error_addr);
529 return inb(ap->ioaddr.error_addr);
533 * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
534 * @tf: Taskfile to convert
535 * @fis: Buffer into which data will output
536 * @pmp: Port multiplier port
538 * Converts a standard ATA taskfile to a Serial ATA
539 * FIS structure (Register - Host to Device).
542 * Inherited from caller.
545 void ata_tf_to_fis(struct ata_taskfile *tf, u8 *fis, u8 pmp)
547 fis[0] = 0x27; /* Register - Host to Device FIS */
548 fis[1] = (pmp & 0xf) | (1 << 7); /* Port multiplier number,
549 bit 7 indicates Command FIS */
550 fis[2] = tf->command;
551 fis[3] = tf->feature;
558 fis[8] = tf->hob_lbal;
559 fis[9] = tf->hob_lbam;
560 fis[10] = tf->hob_lbah;
561 fis[11] = tf->hob_feature;
564 fis[13] = tf->hob_nsect;
575 * ata_tf_from_fis - Convert SATA FIS to ATA taskfile
576 * @fis: Buffer from which data will be input
577 * @tf: Taskfile to output
579 * Converts a standard ATA taskfile to a Serial ATA
580 * FIS structure (Register - Host to Device).
583 * Inherited from caller.
586 void ata_tf_from_fis(u8 *fis, struct ata_taskfile *tf)
588 tf->command = fis[2]; /* status */
589 tf->feature = fis[3]; /* error */
596 tf->hob_lbal = fis[8];
597 tf->hob_lbam = fis[9];
598 tf->hob_lbah = fis[10];
601 tf->hob_nsect = fis[13];
605 * ata_prot_to_cmd - determine which read/write opcodes to use
606 * @protocol: ATA_PROT_xxx taskfile protocol
607 * @lba48: true is lba48 is present
609 * Given necessary input, determine which read/write commands
610 * to use to transfer data.
615 static int ata_prot_to_cmd(int protocol, int lba48)
617 int rcmd = 0, wcmd = 0;
622 rcmd = ATA_CMD_PIO_READ_EXT;
623 wcmd = ATA_CMD_PIO_WRITE_EXT;
625 rcmd = ATA_CMD_PIO_READ;
626 wcmd = ATA_CMD_PIO_WRITE;
632 rcmd = ATA_CMD_READ_EXT;
633 wcmd = ATA_CMD_WRITE_EXT;
636 wcmd = ATA_CMD_WRITE;
644 return rcmd | (wcmd << 8);
648 * ata_dev_set_protocol - set taskfile protocol and r/w commands
649 * @dev: device to examine and configure
651 * Examine the device configuration, after we have
652 * read the identify-device page and configured the
653 * data transfer mode. Set internal state related to
654 * the ATA taskfile protocol (pio, pio mult, dma, etc.)
655 * and calculate the proper read/write commands to use.
660 static void ata_dev_set_protocol(struct ata_device *dev)
662 int pio = (dev->flags & ATA_DFLAG_PIO);
663 int lba48 = (dev->flags & ATA_DFLAG_LBA48);
667 proto = dev->xfer_protocol = ATA_PROT_PIO;
669 proto = dev->xfer_protocol = ATA_PROT_DMA;
671 cmd = ata_prot_to_cmd(proto, lba48);
675 dev->read_cmd = cmd & 0xff;
676 dev->write_cmd = (cmd >> 8) & 0xff;
679 static const char * xfer_mode_str[] = {
699 * ata_udma_string - convert UDMA bit offset to string
700 * @mask: mask of bits supported; only highest bit counts.
702 * Determine string which represents the highest speed
703 * (highest bit in @udma_mask).
709 * Constant C string representing highest speed listed in
710 * @udma_mask, or the constant C string "<n/a>".
713 static const char *ata_mode_string(unsigned int mask)
717 for (i = 7; i >= 0; i--)
720 for (i = ATA_SHIFT_MWDMA + 2; i >= ATA_SHIFT_MWDMA; i--)
723 for (i = ATA_SHIFT_PIO + 4; i >= ATA_SHIFT_PIO; i--)
730 return xfer_mode_str[i];
734 * ata_pio_devchk - PATA device presence detection
735 * @ap: ATA channel to examine
736 * @device: Device to examine (starting at zero)
738 * This technique was originally described in
739 * Hale Landis's ATADRVR (www.ata-atapi.com), and
740 * later found its way into the ATA/ATAPI spec.
742 * Write a pattern to the ATA shadow registers,
743 * and if a device is present, it will respond by
744 * correctly storing and echoing back the
745 * ATA shadow register contents.
751 static unsigned int ata_pio_devchk(struct ata_port *ap,
754 struct ata_ioports *ioaddr = &ap->ioaddr;
757 ap->ops->dev_select(ap, device);
759 outb(0x55, ioaddr->nsect_addr);
760 outb(0xaa, ioaddr->lbal_addr);
762 outb(0xaa, ioaddr->nsect_addr);
763 outb(0x55, ioaddr->lbal_addr);
765 outb(0x55, ioaddr->nsect_addr);
766 outb(0xaa, ioaddr->lbal_addr);
768 nsect = inb(ioaddr->nsect_addr);
769 lbal = inb(ioaddr->lbal_addr);
771 if ((nsect == 0x55) && (lbal == 0xaa))
772 return 1; /* we found a device */
774 return 0; /* nothing found */
778 * ata_mmio_devchk - PATA device presence detection
779 * @ap: ATA channel to examine
780 * @device: Device to examine (starting at zero)
782 * This technique was originally described in
783 * Hale Landis's ATADRVR (www.ata-atapi.com), and
784 * later found its way into the ATA/ATAPI spec.
786 * Write a pattern to the ATA shadow registers,
787 * and if a device is present, it will respond by
788 * correctly storing and echoing back the
789 * ATA shadow register contents.
795 static unsigned int ata_mmio_devchk(struct ata_port *ap,
798 struct ata_ioports *ioaddr = &ap->ioaddr;
801 ap->ops->dev_select(ap, device);
803 writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
804 writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
806 writeb(0xaa, (void __iomem *) ioaddr->nsect_addr);
807 writeb(0x55, (void __iomem *) ioaddr->lbal_addr);
809 writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
810 writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
812 nsect = readb((void __iomem *) ioaddr->nsect_addr);
813 lbal = readb((void __iomem *) ioaddr->lbal_addr);
815 if ((nsect == 0x55) && (lbal == 0xaa))
816 return 1; /* we found a device */
818 return 0; /* nothing found */
822 * ata_devchk - PATA device presence detection
823 * @ap: ATA channel to examine
824 * @device: Device to examine (starting at zero)
826 * Dispatch ATA device presence detection, depending
827 * on whether we are using PIO or MMIO to talk to the
828 * ATA shadow registers.
834 static unsigned int ata_devchk(struct ata_port *ap,
837 if (ap->flags & ATA_FLAG_MMIO)
838 return ata_mmio_devchk(ap, device);
839 return ata_pio_devchk(ap, device);
843 * ata_dev_classify - determine device type based on ATA-spec signature
844 * @tf: ATA taskfile register set for device to be identified
846 * Determine from taskfile register contents whether a device is
847 * ATA or ATAPI, as per "Signature and persistence" section
848 * of ATA/PI spec (volume 1, sect 5.14).
854 * Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, or %ATA_DEV_UNKNOWN
855 * the event of failure.
858 unsigned int ata_dev_classify(struct ata_taskfile *tf)
860 /* Apple's open source Darwin code hints that some devices only
861 * put a proper signature into the LBA mid/high registers,
862 * So, we only check those. It's sufficient for uniqueness.
865 if (((tf->lbam == 0) && (tf->lbah == 0)) ||
866 ((tf->lbam == 0x3c) && (tf->lbah == 0xc3))) {
867 DPRINTK("found ATA device by sig\n");
871 if (((tf->lbam == 0x14) && (tf->lbah == 0xeb)) ||
872 ((tf->lbam == 0x69) && (tf->lbah == 0x96))) {
873 DPRINTK("found ATAPI device by sig\n");
874 return ATA_DEV_ATAPI;
877 DPRINTK("unknown device\n");
878 return ATA_DEV_UNKNOWN;
882 * ata_dev_try_classify - Parse returned ATA device signature
883 * @ap: ATA channel to examine
884 * @device: Device to examine (starting at zero)
886 * After an event -- SRST, E.D.D., or SATA COMRESET -- occurs,
887 * an ATA/ATAPI-defined set of values is placed in the ATA
888 * shadow registers, indicating the results of device detection
891 * Select the ATA device, and read the values from the ATA shadow
892 * registers. Then parse according to the Error register value,
893 * and the spec-defined values examined by ata_dev_classify().
899 static u8 ata_dev_try_classify(struct ata_port *ap, unsigned int device)
901 struct ata_device *dev = &ap->device[device];
902 struct ata_taskfile tf;
906 ap->ops->dev_select(ap, device);
908 memset(&tf, 0, sizeof(tf));
910 err = ata_chk_err(ap);
911 ap->ops->tf_read(ap, &tf);
913 dev->class = ATA_DEV_NONE;
915 /* see if device passed diags */
918 else if ((device == 0) && (err == 0x81))
923 /* determine if device if ATA or ATAPI */
924 class = ata_dev_classify(&tf);
925 if (class == ATA_DEV_UNKNOWN)
927 if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
936 * ata_dev_id_string - Convert IDENTIFY DEVICE page into string
937 * @id: IDENTIFY DEVICE results we will examine
938 * @s: string into which data is output
939 * @ofs: offset into identify device page
940 * @len: length of string to return. must be an even number.
942 * The strings in the IDENTIFY DEVICE page are broken up into
943 * 16-bit chunks. Run through the string, and output each
944 * 8-bit chunk linearly, regardless of platform.
950 void ata_dev_id_string(u16 *id, unsigned char *s,
951 unsigned int ofs, unsigned int len)
971 * ata_noop_dev_select - Select device 0/1 on ATA bus
972 * @ap: ATA channel to manipulate
973 * @device: ATA device (numbered from zero) to select
975 * This function performs no actual function.
977 * May be used as the dev_select() entry in ata_port_operations.
982 void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
988 * ata_std_dev_select - Select device 0/1 on ATA bus
989 * @ap: ATA channel to manipulate
990 * @device: ATA device (numbered from zero) to select
992 * Use the method defined in the ATA specification to
993 * make either device 0, or device 1, active on the
994 * ATA channel. Works with both PIO and MMIO.
996 * May be used as the dev_select() entry in ata_port_operations.
1002 void ata_std_dev_select (struct ata_port *ap, unsigned int device)
1007 tmp = ATA_DEVICE_OBS;
1009 tmp = ATA_DEVICE_OBS | ATA_DEV1;
1011 if (ap->flags & ATA_FLAG_MMIO) {
1012 writeb(tmp, (void __iomem *) ap->ioaddr.device_addr);
1014 outb(tmp, ap->ioaddr.device_addr);
1016 ata_pause(ap); /* needed; also flushes, for mmio */
1020 * ata_dev_select - Select device 0/1 on ATA bus
1021 * @ap: ATA channel to manipulate
1022 * @device: ATA device (numbered from zero) to select
1023 * @wait: non-zero to wait for Status register BSY bit to clear
1024 * @can_sleep: non-zero if context allows sleeping
1026 * Use the method defined in the ATA specification to
1027 * make either device 0, or device 1, active on the
1030 * This is a high-level version of ata_std_dev_select(),
1031 * which additionally provides the services of inserting
1032 * the proper pauses and status polling, where needed.
1038 void ata_dev_select(struct ata_port *ap, unsigned int device,
1039 unsigned int wait, unsigned int can_sleep)
1041 VPRINTK("ENTER, ata%u: device %u, wait %u\n",
1042 ap->id, device, wait);
1047 ap->ops->dev_select(ap, device);
1050 if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI)
1057 * ata_dump_id - IDENTIFY DEVICE info debugging output
1058 * @dev: Device whose IDENTIFY DEVICE page we will dump
1060 * Dump selected 16-bit words from a detected device's
1061 * IDENTIFY PAGE page.
1067 static inline void ata_dump_id(struct ata_device *dev)
1069 DPRINTK("49==0x%04x "
1079 DPRINTK("80==0x%04x "
1089 DPRINTK("88==0x%04x "
1096 * ata_dev_identify - obtain IDENTIFY x DEVICE page
1097 * @ap: port on which device we wish to probe resides
1098 * @device: device bus address, starting at zero
1100 * Following bus reset, we issue the IDENTIFY [PACKET] DEVICE
1101 * command, and read back the 512-byte device information page.
1102 * The device information page is fed to us via the standard
1103 * PIO-IN protocol, but we hand-code it here. (TODO: investigate
1104 * using standard PIO-IN paths)
1106 * After reading the device information page, we use several
1107 * bits of information from it to initialize data structures
1108 * that will be used during the lifetime of the ata_device.
1109 * Other data from the info page is used to disqualify certain
1110 * older ATA devices we do not wish to support.
1113 * Inherited from caller. Some functions called by this function
1114 * obtain the host_set lock.
1117 static void ata_dev_identify(struct ata_port *ap, unsigned int device)
1119 struct ata_device *dev = &ap->device[device];
1122 unsigned long xfer_modes;
1124 unsigned int using_edd;
1125 DECLARE_COMPLETION(wait);
1126 struct ata_queued_cmd *qc;
1127 unsigned long flags;
1130 if (!ata_dev_present(dev)) {
1131 DPRINTK("ENTER/EXIT (host %u, dev %u) -- nodev\n",
1136 if (ap->flags & (ATA_FLAG_SRST | ATA_FLAG_SATA_RESET))
1141 DPRINTK("ENTER, host %u, dev %u\n", ap->id, device);
1143 assert (dev->class == ATA_DEV_ATA || dev->class == ATA_DEV_ATAPI ||
1144 dev->class == ATA_DEV_NONE);
1146 ata_dev_select(ap, device, 1, 1); /* select device 0/1 */
1148 qc = ata_qc_new_init(ap, dev);
1151 ata_sg_init_one(qc, dev->id, sizeof(dev->id));
1152 qc->dma_dir = DMA_FROM_DEVICE;
1153 qc->tf.protocol = ATA_PROT_PIO;
1157 if (dev->class == ATA_DEV_ATA) {
1158 qc->tf.command = ATA_CMD_ID_ATA;
1159 DPRINTK("do ATA identify\n");
1161 qc->tf.command = ATA_CMD_ID_ATAPI;
1162 DPRINTK("do ATAPI identify\n");
1165 qc->waiting = &wait;
1166 qc->complete_fn = ata_qc_complete_noop;
1168 spin_lock_irqsave(&ap->host_set->lock, flags);
1169 rc = ata_qc_issue(qc);
1170 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1175 wait_for_completion(&wait);
1177 status = ata_chk_status(ap);
1178 if (status & ATA_ERR) {
1180 * arg! EDD works for all test cases, but seems to return
1181 * the ATA signature for some ATAPI devices. Until the
1182 * reason for this is found and fixed, we fix up the mess
1183 * here. If IDENTIFY DEVICE returns command aborted
1184 * (as ATAPI devices do), then we issue an
1185 * IDENTIFY PACKET DEVICE.
1187 * ATA software reset (SRST, the default) does not appear
1188 * to have this problem.
1190 if ((using_edd) && (qc->tf.command == ATA_CMD_ID_ATA)) {
1191 u8 err = ata_chk_err(ap);
1192 if (err & ATA_ABORTED) {
1193 dev->class = ATA_DEV_ATAPI;
1204 swap_buf_le16(dev->id, ATA_ID_WORDS);
1206 /* print device capabilities */
1207 printk(KERN_DEBUG "ata%u: dev %u cfg "
1208 "49:%04x 82:%04x 83:%04x 84:%04x 85:%04x 86:%04x 87:%04x 88:%04x\n",
1209 ap->id, device, dev->id[49],
1210 dev->id[82], dev->id[83], dev->id[84],
1211 dev->id[85], dev->id[86], dev->id[87],
1215 * common ATA, ATAPI feature tests
1218 /* we require LBA and DMA support (bits 8 & 9 of word 49) */
1219 if (!ata_id_has_dma(dev->id) || !ata_id_has_lba(dev->id)) {
1220 printk(KERN_DEBUG "ata%u: no dma/lba\n", ap->id);
1224 /* quick-n-dirty find max transfer mode; for printk only */
1225 xfer_modes = dev->id[ATA_ID_UDMA_MODES];
1227 xfer_modes = (dev->id[ATA_ID_MWDMA_MODES]) << ATA_SHIFT_MWDMA;
1229 xfer_modes = (dev->id[ATA_ID_PIO_MODES]) << (ATA_SHIFT_PIO + 3);
1230 xfer_modes |= (0x7 << ATA_SHIFT_PIO);
1235 /* ATA-specific feature tests */
1236 if (dev->class == ATA_DEV_ATA) {
1237 if (!ata_id_is_ata(dev->id)) /* sanity check */
1240 tmp = dev->id[ATA_ID_MAJOR_VER];
1241 for (i = 14; i >= 1; i--)
1245 /* we require at least ATA-3 */
1247 printk(KERN_DEBUG "ata%u: no ATA-3\n", ap->id);
1251 if (ata_id_has_lba48(dev->id)) {
1252 dev->flags |= ATA_DFLAG_LBA48;
1253 dev->n_sectors = ata_id_u64(dev->id, 100);
1255 dev->n_sectors = ata_id_u32(dev->id, 60);
1258 ap->host->max_cmd_len = 16;
1260 /* print device info to dmesg */
1261 printk(KERN_INFO "ata%u: dev %u ATA, max %s, %Lu sectors:%s\n",
1263 ata_mode_string(xfer_modes),
1264 (unsigned long long)dev->n_sectors,
1265 dev->flags & ATA_DFLAG_LBA48 ? " lba48" : "");
1268 /* ATAPI-specific feature tests */
1270 if (ata_id_is_ata(dev->id)) /* sanity check */
1273 rc = atapi_cdb_len(dev->id);
1274 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
1275 printk(KERN_WARNING "ata%u: unsupported CDB len\n", ap->id);
1278 ap->cdb_len = (unsigned int) rc;
1279 ap->host->max_cmd_len = (unsigned char) ap->cdb_len;
1281 /* print device info to dmesg */
1282 printk(KERN_INFO "ata%u: dev %u ATAPI, max %s\n",
1284 ata_mode_string(xfer_modes));
1287 DPRINTK("EXIT, drv_stat = 0x%x\n", ata_chk_status(ap));
1291 printk(KERN_WARNING "ata%u: dev %u not supported, ignoring\n",
1294 dev->class++; /* converts ATA_DEV_xxx into ATA_DEV_xxx_UNSUP */
1295 DPRINTK("EXIT, err\n");
1299 * ata_bus_probe - Reset and probe ATA bus
1302 * Master ATA bus probing function. Initiates a hardware-dependent
1303 * bus reset, then attempts to identify any devices found on
1307 * PCI/etc. bus probe sem.
1310 * Zero on success, non-zero on error.
1313 static int ata_bus_probe(struct ata_port *ap)
1315 unsigned int i, found = 0;
1317 ap->ops->phy_reset(ap);
1318 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1321 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1322 ata_dev_identify(ap, i);
1323 if (ata_dev_present(&ap->device[i])) {
1325 if (ap->ops->dev_config)
1326 ap->ops->dev_config(ap, &ap->device[i]);
1330 if ((!found) || (ap->flags & ATA_FLAG_PORT_DISABLED))
1331 goto err_out_disable;
1334 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1335 goto err_out_disable;
1340 ap->ops->port_disable(ap);
1346 * ata_port_probe - Mark port as enabled
1347 * @ap: Port for which we indicate enablement
1349 * Modify @ap data structure such that the system
1350 * thinks that the entire port is enabled.
1352 * LOCKING: host_set lock, or some other form of
1356 void ata_port_probe(struct ata_port *ap)
1358 ap->flags &= ~ATA_FLAG_PORT_DISABLED;
1362 * __sata_phy_reset - Wake/reset a low-level SATA PHY
1363 * @ap: SATA port associated with target SATA PHY.
1365 * This function issues commands to standard SATA Sxxx
1366 * PHY registers, to wake up the phy (and device), and
1367 * clear any reset condition.
1370 * PCI/etc. bus probe sem.
1373 void __sata_phy_reset(struct ata_port *ap)
1376 unsigned long timeout = jiffies + (HZ * 5);
1378 if (ap->flags & ATA_FLAG_SATA_RESET) {
1379 /* issue phy wake/reset */
1380 scr_write_flush(ap, SCR_CONTROL, 0x301);
1381 udelay(400); /* FIXME: a guess */
1383 scr_write_flush(ap, SCR_CONTROL, 0x300); /* phy wake/clear reset */
1385 /* wait for phy to become ready, if necessary */
1388 sstatus = scr_read(ap, SCR_STATUS);
1389 if ((sstatus & 0xf) != 1)
1391 } while (time_before(jiffies, timeout));
1393 /* TODO: phy layer with polling, timeouts, etc. */
1394 if (sata_dev_present(ap))
1397 sstatus = scr_read(ap, SCR_STATUS);
1398 printk(KERN_INFO "ata%u: no device found (phy stat %08x)\n",
1400 ata_port_disable(ap);
1403 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1406 if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
1407 ata_port_disable(ap);
1411 ap->cbl = ATA_CBL_SATA;
1415 * sata_phy_reset - Reset SATA bus.
1416 * @ap: SATA port associated with target SATA PHY.
1418 * This function resets the SATA bus, and then probes
1419 * the bus for devices.
1422 * PCI/etc. bus probe sem.
1425 void sata_phy_reset(struct ata_port *ap)
1427 __sata_phy_reset(ap);
1428 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1434 * ata_port_disable - Disable port.
1435 * @ap: Port to be disabled.
1437 * Modify @ap data structure such that the system
1438 * thinks that the entire port is disabled, and should
1439 * never attempt to probe or communicate with devices
1442 * LOCKING: host_set lock, or some other form of
1446 void ata_port_disable(struct ata_port *ap)
1448 ap->device[0].class = ATA_DEV_NONE;
1449 ap->device[1].class = ATA_DEV_NONE;
1450 ap->flags |= ATA_FLAG_PORT_DISABLED;
1456 } xfer_mode_classes[] = {
1457 { ATA_SHIFT_UDMA, XFER_UDMA_0 },
1458 { ATA_SHIFT_MWDMA, XFER_MW_DMA_0 },
1459 { ATA_SHIFT_PIO, XFER_PIO_0 },
1462 static inline u8 base_from_shift(unsigned int shift)
1466 for (i = 0; i < ARRAY_SIZE(xfer_mode_classes); i++)
1467 if (xfer_mode_classes[i].shift == shift)
1468 return xfer_mode_classes[i].base;
1473 static void ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
1478 if (!ata_dev_present(dev) || (ap->flags & ATA_FLAG_PORT_DISABLED))
1481 if (dev->xfer_shift == ATA_SHIFT_PIO)
1482 dev->flags |= ATA_DFLAG_PIO;
1484 ata_dev_set_xfermode(ap, dev);
1486 base = base_from_shift(dev->xfer_shift);
1487 ofs = dev->xfer_mode - base;
1488 idx = ofs + dev->xfer_shift;
1489 WARN_ON(idx >= ARRAY_SIZE(xfer_mode_str));
1491 DPRINTK("idx=%d xfer_shift=%u, xfer_mode=0x%x, base=0x%x, offset=%d\n",
1492 idx, dev->xfer_shift, (int)dev->xfer_mode, (int)base, ofs);
1494 printk(KERN_INFO "ata%u: dev %u configured for %s\n",
1495 ap->id, dev->devno, xfer_mode_str[idx]);
1498 static int ata_host_set_pio(struct ata_port *ap)
1504 mask = ata_get_mode_mask(ap, ATA_SHIFT_PIO);
1507 printk(KERN_WARNING "ata%u: no PIO support\n", ap->id);
1511 base = base_from_shift(ATA_SHIFT_PIO);
1512 xfer_mode = base + x;
1514 DPRINTK("base 0x%x xfer_mode 0x%x mask 0x%x x %d\n",
1515 (int)base, (int)xfer_mode, mask, x);
1517 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1518 struct ata_device *dev = &ap->device[i];
1519 if (ata_dev_present(dev)) {
1520 dev->pio_mode = xfer_mode;
1521 dev->xfer_mode = xfer_mode;
1522 dev->xfer_shift = ATA_SHIFT_PIO;
1523 if (ap->ops->set_piomode)
1524 ap->ops->set_piomode(ap, dev);
1531 static void ata_host_set_dma(struct ata_port *ap, u8 xfer_mode,
1532 unsigned int xfer_shift)
1536 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1537 struct ata_device *dev = &ap->device[i];
1538 if (ata_dev_present(dev)) {
1539 dev->dma_mode = xfer_mode;
1540 dev->xfer_mode = xfer_mode;
1541 dev->xfer_shift = xfer_shift;
1542 if (ap->ops->set_dmamode)
1543 ap->ops->set_dmamode(ap, dev);
1549 * ata_set_mode - Program timings and issue SET FEATURES - XFER
1550 * @ap: port on which timings will be programmed
1552 * Set ATA device disk transfer mode (PIO3, UDMA6, etc.).
1555 * PCI/etc. bus probe sem.
1558 static void ata_set_mode(struct ata_port *ap)
1560 unsigned int i, xfer_shift;
1564 /* step 1: always set host PIO timings */
1565 rc = ata_host_set_pio(ap);
1569 /* step 2: choose the best data xfer mode */
1570 xfer_mode = xfer_shift = 0;
1571 rc = ata_choose_xfer_mode(ap, &xfer_mode, &xfer_shift);
1575 /* step 3: if that xfer mode isn't PIO, set host DMA timings */
1576 if (xfer_shift != ATA_SHIFT_PIO)
1577 ata_host_set_dma(ap, xfer_mode, xfer_shift);
1579 /* step 4: update devices' xfer mode */
1580 ata_dev_set_mode(ap, &ap->device[0]);
1581 ata_dev_set_mode(ap, &ap->device[1]);
1583 if (ap->flags & ATA_FLAG_PORT_DISABLED)
1586 if (ap->ops->post_set_mode)
1587 ap->ops->post_set_mode(ap);
1589 for (i = 0; i < 2; i++) {
1590 struct ata_device *dev = &ap->device[i];
1591 ata_dev_set_protocol(dev);
1597 ata_port_disable(ap);
1601 * ata_busy_sleep - sleep until BSY clears, or timeout
1602 * @ap: port containing status register to be polled
1603 * @tmout_pat: impatience timeout
1604 * @tmout: overall timeout
1606 * Sleep until ATA Status register bit BSY clears,
1607 * or a timeout occurs.
1613 static unsigned int ata_busy_sleep (struct ata_port *ap,
1614 unsigned long tmout_pat,
1615 unsigned long tmout)
1617 unsigned long timer_start, timeout;
1620 status = ata_busy_wait(ap, ATA_BUSY, 300);
1621 timer_start = jiffies;
1622 timeout = timer_start + tmout_pat;
1623 while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
1625 status = ata_busy_wait(ap, ATA_BUSY, 3);
1628 if (status & ATA_BUSY)
1629 printk(KERN_WARNING "ata%u is slow to respond, "
1630 "please be patient\n", ap->id);
1632 timeout = timer_start + tmout;
1633 while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
1635 status = ata_chk_status(ap);
1638 if (status & ATA_BUSY) {
1639 printk(KERN_ERR "ata%u failed to respond (%lu secs)\n",
1640 ap->id, tmout / HZ);
1647 static void ata_bus_post_reset(struct ata_port *ap, unsigned int devmask)
1649 struct ata_ioports *ioaddr = &ap->ioaddr;
1650 unsigned int dev0 = devmask & (1 << 0);
1651 unsigned int dev1 = devmask & (1 << 1);
1652 unsigned long timeout;
1654 /* if device 0 was found in ata_devchk, wait for its
1658 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1660 /* if device 1 was found in ata_devchk, wait for
1661 * register access, then wait for BSY to clear
1663 timeout = jiffies + ATA_TMOUT_BOOT;
1667 ap->ops->dev_select(ap, 1);
1668 if (ap->flags & ATA_FLAG_MMIO) {
1669 nsect = readb((void __iomem *) ioaddr->nsect_addr);
1670 lbal = readb((void __iomem *) ioaddr->lbal_addr);
1672 nsect = inb(ioaddr->nsect_addr);
1673 lbal = inb(ioaddr->lbal_addr);
1675 if ((nsect == 1) && (lbal == 1))
1677 if (time_after(jiffies, timeout)) {
1681 msleep(50); /* give drive a breather */
1684 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1686 /* is all this really necessary? */
1687 ap->ops->dev_select(ap, 0);
1689 ap->ops->dev_select(ap, 1);
1691 ap->ops->dev_select(ap, 0);
1695 * ata_bus_edd - Issue EXECUTE DEVICE DIAGNOSTIC command.
1696 * @ap: Port to reset and probe
1698 * Use the EXECUTE DEVICE DIAGNOSTIC command to reset and
1699 * probe the bus. Not often used these days.
1702 * PCI/etc. bus probe sem.
1706 static unsigned int ata_bus_edd(struct ata_port *ap)
1708 struct ata_taskfile tf;
1710 /* set up execute-device-diag (bus reset) taskfile */
1711 /* also, take interrupts to a known state (disabled) */
1712 DPRINTK("execute-device-diag\n");
1713 ata_tf_init(ap, &tf, 0);
1715 tf.command = ATA_CMD_EDD;
1716 tf.protocol = ATA_PROT_NODATA;
1719 ata_tf_to_host(ap, &tf);
1721 /* spec says at least 2ms. but who knows with those
1722 * crazy ATAPI devices...
1726 return ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
1729 static unsigned int ata_bus_softreset(struct ata_port *ap,
1730 unsigned int devmask)
1732 struct ata_ioports *ioaddr = &ap->ioaddr;
1734 DPRINTK("ata%u: bus reset via SRST\n", ap->id);
1736 /* software reset. causes dev0 to be selected */
1737 if (ap->flags & ATA_FLAG_MMIO) {
1738 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1739 udelay(20); /* FIXME: flush */
1740 writeb(ap->ctl | ATA_SRST, (void __iomem *) ioaddr->ctl_addr);
1741 udelay(20); /* FIXME: flush */
1742 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1744 outb(ap->ctl, ioaddr->ctl_addr);
1746 outb(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
1748 outb(ap->ctl, ioaddr->ctl_addr);
1751 /* spec mandates ">= 2ms" before checking status.
1752 * We wait 150ms, because that was the magic delay used for
1753 * ATAPI devices in Hale Landis's ATADRVR, for the period of time
1754 * between when the ATA command register is written, and then
1755 * status is checked. Because waiting for "a while" before
1756 * checking status is fine, post SRST, we perform this magic
1757 * delay here as well.
1761 ata_bus_post_reset(ap, devmask);
1767 * ata_bus_reset - reset host port and associated ATA channel
1768 * @ap: port to reset
1770 * This is typically the first time we actually start issuing
1771 * commands to the ATA channel. We wait for BSY to clear, then
1772 * issue EXECUTE DEVICE DIAGNOSTIC command, polling for its
1773 * result. Determine what devices, if any, are on the channel
1774 * by looking at the device 0/1 error register. Look at the signature
1775 * stored in each device's taskfile registers, to determine if
1776 * the device is ATA or ATAPI.
1779 * PCI/etc. bus probe sem.
1780 * Obtains host_set lock.
1783 * Sets ATA_FLAG_PORT_DISABLED if bus reset fails.
1786 void ata_bus_reset(struct ata_port *ap)
1788 struct ata_ioports *ioaddr = &ap->ioaddr;
1789 unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
1791 unsigned int dev0, dev1 = 0, rc = 0, devmask = 0;
1793 DPRINTK("ENTER, host %u, port %u\n", ap->id, ap->port_no);
1795 /* determine if device 0/1 are present */
1796 if (ap->flags & ATA_FLAG_SATA_RESET)
1799 dev0 = ata_devchk(ap, 0);
1801 dev1 = ata_devchk(ap, 1);
1805 devmask |= (1 << 0);
1807 devmask |= (1 << 1);
1809 /* select device 0 again */
1810 ap->ops->dev_select(ap, 0);
1812 /* issue bus reset */
1813 if (ap->flags & ATA_FLAG_SRST)
1814 rc = ata_bus_softreset(ap, devmask);
1815 else if ((ap->flags & ATA_FLAG_SATA_RESET) == 0) {
1816 /* set up device control */
1817 if (ap->flags & ATA_FLAG_MMIO)
1818 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1820 outb(ap->ctl, ioaddr->ctl_addr);
1821 rc = ata_bus_edd(ap);
1828 * determine by signature whether we have ATA or ATAPI devices
1830 err = ata_dev_try_classify(ap, 0);
1831 if ((slave_possible) && (err != 0x81))
1832 ata_dev_try_classify(ap, 1);
1834 /* re-enable interrupts */
1835 if (ap->ioaddr.ctl_addr) /* FIXME: hack. create a hook instead */
1838 /* is double-select really necessary? */
1839 if (ap->device[1].class != ATA_DEV_NONE)
1840 ap->ops->dev_select(ap, 1);
1841 if (ap->device[0].class != ATA_DEV_NONE)
1842 ap->ops->dev_select(ap, 0);
1844 /* if no devices were detected, disable this port */
1845 if ((ap->device[0].class == ATA_DEV_NONE) &&
1846 (ap->device[1].class == ATA_DEV_NONE))
1849 if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
1850 /* set up device control for ATA_FLAG_SATA_RESET */
1851 if (ap->flags & ATA_FLAG_MMIO)
1852 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
1854 outb(ap->ctl, ioaddr->ctl_addr);
1861 printk(KERN_ERR "ata%u: disabling port\n", ap->id);
1862 ap->ops->port_disable(ap);
1867 static void ata_pr_blacklisted(struct ata_port *ap, struct ata_device *dev)
1869 printk(KERN_WARNING "ata%u: dev %u is on DMA blacklist, disabling DMA\n",
1870 ap->id, dev->devno);
1873 static const char * ata_dma_blacklist [] = {
1892 "Toshiba CD-ROM XM-6202B",
1894 "E-IDE CD-ROM CR-840",
1897 "SAMSUNG CD-ROM SC-148C",
1898 "SAMSUNG CD-ROM SC",
1900 "ATAPI CD-ROM DRIVE 40X MAXIMUM",
1904 static int ata_dma_blacklisted(struct ata_port *ap, struct ata_device *dev)
1906 unsigned char model_num[40];
1911 ata_dev_id_string(dev->id, model_num, ATA_ID_PROD_OFS,
1914 len = strnlen(s, sizeof(model_num));
1916 /* ATAPI specifies that empty space is blank-filled; remove blanks */
1917 while ((len > 0) && (s[len - 1] == ' ')) {
1922 for (i = 0; i < ARRAY_SIZE(ata_dma_blacklist); i++)
1923 if (!strncmp(ata_dma_blacklist[i], s, len))
1929 static unsigned int ata_get_mode_mask(struct ata_port *ap, int shift)
1931 struct ata_device *master, *slave;
1934 master = &ap->device[0];
1935 slave = &ap->device[1];
1937 assert (ata_dev_present(master) || ata_dev_present(slave));
1939 if (shift == ATA_SHIFT_UDMA) {
1940 mask = ap->udma_mask;
1941 if (ata_dev_present(master)) {
1942 mask &= (master->id[ATA_ID_UDMA_MODES] & 0xff);
1943 if (ata_dma_blacklisted(ap, master)) {
1945 ata_pr_blacklisted(ap, master);
1948 if (ata_dev_present(slave)) {
1949 mask &= (slave->id[ATA_ID_UDMA_MODES] & 0xff);
1950 if (ata_dma_blacklisted(ap, slave)) {
1952 ata_pr_blacklisted(ap, slave);
1956 else if (shift == ATA_SHIFT_MWDMA) {
1957 mask = ap->mwdma_mask;
1958 if (ata_dev_present(master)) {
1959 mask &= (master->id[ATA_ID_MWDMA_MODES] & 0x07);
1960 if (ata_dma_blacklisted(ap, master)) {
1962 ata_pr_blacklisted(ap, master);
1965 if (ata_dev_present(slave)) {
1966 mask &= (slave->id[ATA_ID_MWDMA_MODES] & 0x07);
1967 if (ata_dma_blacklisted(ap, slave)) {
1969 ata_pr_blacklisted(ap, slave);
1973 else if (shift == ATA_SHIFT_PIO) {
1974 mask = ap->pio_mask;
1975 if (ata_dev_present(master)) {
1976 /* spec doesn't return explicit support for
1977 * PIO0-2, so we fake it
1979 u16 tmp_mode = master->id[ATA_ID_PIO_MODES] & 0x03;
1984 if (ata_dev_present(slave)) {
1985 /* spec doesn't return explicit support for
1986 * PIO0-2, so we fake it
1988 u16 tmp_mode = slave->id[ATA_ID_PIO_MODES] & 0x03;
1995 mask = 0xffffffff; /* shut up compiler warning */
2002 /* find greatest bit */
2003 static int fgb(u32 bitmap)
2008 for (i = 0; i < 32; i++)
2009 if (bitmap & (1 << i))
2016 * ata_choose_xfer_mode - attempt to find best transfer mode
2017 * @ap: Port for which an xfer mode will be selected
2018 * @xfer_mode_out: (output) SET FEATURES - XFER MODE code
2019 * @xfer_shift_out: (output) bit shift that selects this mode
2021 * Based on host and device capabilities, determine the
2022 * maximum transfer mode that is amenable to all.
2025 * PCI/etc. bus probe sem.
2028 * Zero on success, negative on error.
2031 static int ata_choose_xfer_mode(struct ata_port *ap,
2033 unsigned int *xfer_shift_out)
2035 unsigned int mask, shift;
2038 for (i = 0; i < ARRAY_SIZE(xfer_mode_classes); i++) {
2039 shift = xfer_mode_classes[i].shift;
2040 mask = ata_get_mode_mask(ap, shift);
2044 *xfer_mode_out = xfer_mode_classes[i].base + x;
2045 *xfer_shift_out = shift;
2054 * ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
2055 * @ap: Port associated with device @dev
2056 * @dev: Device to which command will be sent
2058 * Issue SET FEATURES - XFER MODE command to device @dev
2062 * PCI/etc. bus probe sem.
2065 static void ata_dev_set_xfermode(struct ata_port *ap, struct ata_device *dev)
2067 DECLARE_COMPLETION(wait);
2068 struct ata_queued_cmd *qc;
2070 unsigned long flags;
2072 /* set up set-features taskfile */
2073 DPRINTK("set features - xfer mode\n");
2075 qc = ata_qc_new_init(ap, dev);
2078 qc->tf.command = ATA_CMD_SET_FEATURES;
2079 qc->tf.feature = SETFEATURES_XFER;
2080 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2081 qc->tf.protocol = ATA_PROT_NODATA;
2082 qc->tf.nsect = dev->xfer_mode;
2084 qc->waiting = &wait;
2085 qc->complete_fn = ata_qc_complete_noop;
2087 spin_lock_irqsave(&ap->host_set->lock, flags);
2088 rc = ata_qc_issue(qc);
2089 spin_unlock_irqrestore(&ap->host_set->lock, flags);
2092 ata_port_disable(ap);
2094 wait_for_completion(&wait);
2100 * ata_sg_clean - Unmap DMA memory associated with command
2101 * @qc: Command containing DMA memory to be released
2103 * Unmap all mapped DMA memory associated with this command.
2106 * spin_lock_irqsave(host_set lock)
2109 static void ata_sg_clean(struct ata_queued_cmd *qc)
2111 struct ata_port *ap = qc->ap;
2112 struct scatterlist *sg = qc->sg;
2113 int dir = qc->dma_dir;
2115 assert(qc->flags & ATA_QCFLAG_DMAMAP);
2118 if (qc->flags & ATA_QCFLAG_SINGLE)
2119 assert(qc->n_elem == 1);
2121 DPRINTK("unmapping %u sg elements\n", qc->n_elem);
2123 if (qc->flags & ATA_QCFLAG_SG)
2124 dma_unmap_sg(ap->host_set->dev, sg, qc->n_elem, dir);
2126 dma_unmap_single(ap->host_set->dev, sg_dma_address(&sg[0]),
2127 sg_dma_len(&sg[0]), dir);
2129 qc->flags &= ~ATA_QCFLAG_DMAMAP;
2134 * ata_fill_sg - Fill PCI IDE PRD table
2135 * @qc: Metadata associated with taskfile to be transferred
2137 * Fill PCI IDE PRD (scatter-gather) table with segments
2138 * associated with the current disk command.
2141 * spin_lock_irqsave(host_set lock)
2144 static void ata_fill_sg(struct ata_queued_cmd *qc)
2146 struct scatterlist *sg = qc->sg;
2147 struct ata_port *ap = qc->ap;
2148 unsigned int idx, nelem;
2151 assert(qc->n_elem > 0);
2154 for (nelem = qc->n_elem; nelem; nelem--,sg++) {
2158 /* determine if physical DMA addr spans 64K boundary.
2159 * Note h/w doesn't support 64-bit, so we unconditionally
2160 * truncate dma_addr_t to u32.
2162 addr = (u32) sg_dma_address(sg);
2163 sg_len = sg_dma_len(sg);
2166 offset = addr & 0xffff;
2168 if ((offset + sg_len) > 0x10000)
2169 len = 0x10000 - offset;
2171 ap->prd[idx].addr = cpu_to_le32(addr);
2172 ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
2173 VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
2182 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
2185 * ata_check_atapi_dma - Check whether ATAPI DMA can be supported
2186 * @qc: Metadata associated with taskfile to check
2188 * Allow low-level driver to filter ATA PACKET commands, returning
2189 * a status indicating whether or not it is OK to use DMA for the
2190 * supplied PACKET command.
2193 * spin_lock_irqsave(host_set lock)
2195 * RETURNS: 0 when ATAPI DMA can be used
2198 int ata_check_atapi_dma(struct ata_queued_cmd *qc)
2200 struct ata_port *ap = qc->ap;
2201 int rc = 0; /* Assume ATAPI DMA is OK by default */
2203 if (ap->ops->check_atapi_dma)
2204 rc = ap->ops->check_atapi_dma(qc);
2209 * ata_qc_prep - Prepare taskfile for submission
2210 * @qc: Metadata associated with taskfile to be prepared
2212 * Prepare ATA taskfile for submission.
2215 * spin_lock_irqsave(host_set lock)
2217 void ata_qc_prep(struct ata_queued_cmd *qc)
2219 if (!(qc->flags & ATA_QCFLAG_DMAMAP))
2226 * ata_sg_init_one - Associate command with memory buffer
2227 * @qc: Command to be associated
2228 * @buf: Memory buffer
2229 * @buflen: Length of memory buffer, in bytes.
2231 * Initialize the data-related elements of queued_cmd @qc
2232 * to point to a single memory buffer, @buf of byte length @buflen.
2235 * spin_lock_irqsave(host_set lock)
2241 * ata_sg_init_one - Prepare a one-entry scatter-gather list.
2242 * @qc: Queued command
2243 * @buf: transfer buffer
2244 * @buflen: length of buf
2246 * Builds a single-entry scatter-gather list to initiate a
2247 * transfer utilizing the specified buffer.
2251 void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
2253 struct scatterlist *sg;
2255 qc->flags |= ATA_QCFLAG_SINGLE;
2257 memset(&qc->sgent, 0, sizeof(qc->sgent));
2258 qc->sg = &qc->sgent;
2263 sg->page = virt_to_page(buf);
2264 sg->offset = (unsigned long) buf & ~PAGE_MASK;
2265 sg->length = buflen;
2269 * ata_sg_init - Associate command with scatter-gather table.
2270 * @qc: Command to be associated
2271 * @sg: Scatter-gather table.
2272 * @n_elem: Number of elements in s/g table.
2274 * Initialize the data-related elements of queued_cmd @qc
2275 * to point to a scatter-gather table @sg, containing @n_elem
2279 * spin_lock_irqsave(host_set lock)
2284 * ata_sg_init - Assign a scatter gather list to a queued command
2285 * @qc: Queued command
2286 * @sg: Scatter-gather list
2287 * @n_elem: length of sg list
2289 * Attaches a scatter-gather list to a queued command.
2294 void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
2295 unsigned int n_elem)
2297 qc->flags |= ATA_QCFLAG_SG;
2299 qc->n_elem = n_elem;
2303 * ata_sg_setup_one - DMA-map the memory buffer associated with a command.
2304 * @qc: Command with memory buffer to be mapped.
2306 * DMA-map the memory buffer associated with queued_cmd @qc.
2309 * spin_lock_irqsave(host_set lock)
2312 * Zero on success, negative on error.
2315 static int ata_sg_setup_one(struct ata_queued_cmd *qc)
2317 struct ata_port *ap = qc->ap;
2318 int dir = qc->dma_dir;
2319 struct scatterlist *sg = qc->sg;
2320 dma_addr_t dma_address;
2322 dma_address = dma_map_single(ap->host_set->dev, qc->buf_virt,
2324 if (dma_mapping_error(dma_address))
2327 sg_dma_address(sg) = dma_address;
2328 sg_dma_len(sg) = sg->length;
2330 DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
2331 qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
2337 * ata_sg_setup - DMA-map the scatter-gather table associated with a command.
2338 * @qc: Command with scatter-gather table to be mapped.
2340 * DMA-map the scatter-gather table associated with queued_cmd @qc.
2343 * spin_lock_irqsave(host_set lock)
2346 * Zero on success, negative on error.
2350 static int ata_sg_setup(struct ata_queued_cmd *qc)
2352 struct ata_port *ap = qc->ap;
2353 struct scatterlist *sg = qc->sg;
2356 VPRINTK("ENTER, ata%u\n", ap->id);
2357 assert(qc->flags & ATA_QCFLAG_SG);
2360 n_elem = dma_map_sg(ap->host_set->dev, sg, qc->n_elem, dir);
2364 DPRINTK("%d sg elements mapped\n", n_elem);
2366 qc->n_elem = n_elem;
2376 * None. (executing in kernel thread context)
2382 static unsigned long ata_pio_poll(struct ata_port *ap)
2385 unsigned int poll_state = PIO_ST_UNKNOWN;
2386 unsigned int reg_state = PIO_ST_UNKNOWN;
2387 const unsigned int tmout_state = PIO_ST_TMOUT;
2389 switch (ap->pio_task_state) {
2392 poll_state = PIO_ST_POLL;
2396 case PIO_ST_LAST_POLL:
2397 poll_state = PIO_ST_LAST_POLL;
2398 reg_state = PIO_ST_LAST;
2405 status = ata_chk_status(ap);
2406 if (status & ATA_BUSY) {
2407 if (time_after(jiffies, ap->pio_task_timeout)) {
2408 ap->pio_task_state = tmout_state;
2411 ap->pio_task_state = poll_state;
2412 return ATA_SHORT_PAUSE;
2415 ap->pio_task_state = reg_state;
2420 * ata_pio_complete -
2424 * None. (executing in kernel thread context)
2427 static void ata_pio_complete (struct ata_port *ap)
2429 struct ata_queued_cmd *qc;
2433 * This is purely hueristic. This is a fast path.
2434 * Sometimes when we enter, BSY will be cleared in
2435 * a chk-status or two. If not, the drive is probably seeking
2436 * or something. Snooze for a couple msecs, then
2437 * chk-status again. If still busy, fall back to
2438 * PIO_ST_POLL state.
2440 drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
2441 if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
2443 drv_stat = ata_busy_wait(ap, ATA_BUSY | ATA_DRQ, 10);
2444 if (drv_stat & (ATA_BUSY | ATA_DRQ)) {
2445 ap->pio_task_state = PIO_ST_LAST_POLL;
2446 ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
2451 drv_stat = ata_wait_idle(ap);
2452 if (!ata_ok(drv_stat)) {
2453 ap->pio_task_state = PIO_ST_ERR;
2457 qc = ata_qc_from_tag(ap, ap->active_tag);
2460 ap->pio_task_state = PIO_ST_IDLE;
2464 ata_qc_complete(qc, drv_stat);
2470 * @buf: Buffer to swap
2471 * @buf_words: Number of 16-bit words in buffer.
2473 * Swap halves of 16-bit words if needed to convert from
2474 * little-endian byte order to native cpu byte order, or
2479 void swap_buf_le16(u16 *buf, unsigned int buf_words)
2484 for (i = 0; i < buf_words; i++)
2485 buf[i] = le16_to_cpu(buf[i]);
2486 #endif /* __BIG_ENDIAN */
2489 static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
2490 unsigned int buflen, int write_data)
2493 unsigned int words = buflen >> 1;
2494 u16 *buf16 = (u16 *) buf;
2495 void __iomem *mmio = (void __iomem *)ap->ioaddr.data_addr;
2498 for (i = 0; i < words; i++)
2499 writew(le16_to_cpu(buf16[i]), mmio);
2501 for (i = 0; i < words; i++)
2502 buf16[i] = cpu_to_le16(readw(mmio));
2506 static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
2507 unsigned int buflen, int write_data)
2509 unsigned int dwords = buflen >> 1;
2512 outsw(ap->ioaddr.data_addr, buf, dwords);
2514 insw(ap->ioaddr.data_addr, buf, dwords);
2517 static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
2518 unsigned int buflen, int do_write)
2520 if (ap->flags & ATA_FLAG_MMIO)
2521 ata_mmio_data_xfer(ap, buf, buflen, do_write);
2523 ata_pio_data_xfer(ap, buf, buflen, do_write);
2526 static void ata_pio_sector(struct ata_queued_cmd *qc)
2528 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
2529 struct scatterlist *sg = qc->sg;
2530 struct ata_port *ap = qc->ap;
2532 unsigned int offset;
2535 if (qc->cursect == (qc->nsect - 1))
2536 ap->pio_task_state = PIO_ST_LAST;
2538 page = sg[qc->cursg].page;
2539 offset = sg[qc->cursg].offset + qc->cursg_ofs * ATA_SECT_SIZE;
2541 /* get the current page and offset */
2542 page = nth_page(page, (offset >> PAGE_SHIFT));
2543 offset %= PAGE_SIZE;
2545 buf = kmap(page) + offset;
2550 if ((qc->cursg_ofs * ATA_SECT_SIZE) == (&sg[qc->cursg])->length) {
2555 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
2557 /* do the actual data transfer */
2558 do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
2559 ata_data_xfer(ap, buf, ATA_SECT_SIZE, do_write);
2564 static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
2566 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
2567 struct scatterlist *sg = qc->sg;
2568 struct ata_port *ap = qc->ap;
2571 unsigned int offset, count;
2573 if (qc->curbytes == qc->nbytes - bytes)
2574 ap->pio_task_state = PIO_ST_LAST;
2577 sg = &qc->sg[qc->cursg];
2580 offset = sg->offset + qc->cursg_ofs;
2582 /* get the current page and offset */
2583 page = nth_page(page, (offset >> PAGE_SHIFT));
2584 offset %= PAGE_SIZE;
2586 /* don't overrun current sg */
2587 count = min(sg->length - qc->cursg_ofs, bytes);
2589 /* don't cross page boundaries */
2590 count = min(count, (unsigned int)PAGE_SIZE - offset);
2592 buf = kmap(page) + offset;
2595 qc->curbytes += count;
2596 qc->cursg_ofs += count;
2598 if (qc->cursg_ofs == sg->length) {
2603 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
2605 /* do the actual data transfer */
2606 ata_data_xfer(ap, buf, count, do_write);
2615 static void atapi_pio_bytes(struct ata_queued_cmd *qc)
2617 struct ata_port *ap = qc->ap;
2618 struct ata_device *dev = qc->dev;
2619 unsigned int ireason, bc_lo, bc_hi, bytes;
2620 int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
2622 ap->ops->tf_read(ap, &qc->tf);
2623 ireason = qc->tf.nsect;
2624 bc_lo = qc->tf.lbam;
2625 bc_hi = qc->tf.lbah;
2626 bytes = (bc_hi << 8) | bc_lo;
2628 /* shall be cleared to zero, indicating xfer of data */
2629 if (ireason & (1 << 0))
2632 /* make sure transfer direction matches expected */
2633 i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0;
2634 if (do_write != i_write)
2637 __atapi_pio_bytes(qc, bytes);
2642 printk(KERN_INFO "ata%u: dev %u: ATAPI check failed\n",
2643 ap->id, dev->devno);
2644 ap->pio_task_state = PIO_ST_ERR;
2652 * None. (executing in kernel thread context)
2655 static void ata_pio_block(struct ata_port *ap)
2657 struct ata_queued_cmd *qc;
2661 * This is purely hueristic. This is a fast path.
2662 * Sometimes when we enter, BSY will be cleared in
2663 * a chk-status or two. If not, the drive is probably seeking
2664 * or something. Snooze for a couple msecs, then
2665 * chk-status again. If still busy, fall back to
2666 * PIO_ST_POLL state.
2668 status = ata_busy_wait(ap, ATA_BUSY, 5);
2669 if (status & ATA_BUSY) {
2671 status = ata_busy_wait(ap, ATA_BUSY, 10);
2672 if (status & ATA_BUSY) {
2673 ap->pio_task_state = PIO_ST_POLL;
2674 ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
2679 qc = ata_qc_from_tag(ap, ap->active_tag);
2682 if (is_atapi_taskfile(&qc->tf)) {
2683 /* no more data to transfer or unsupported ATAPI command */
2684 if ((status & ATA_DRQ) == 0) {
2685 ap->pio_task_state = PIO_ST_IDLE;
2689 ata_qc_complete(qc, status);
2693 atapi_pio_bytes(qc);
2695 /* handle BSY=0, DRQ=0 as error */
2696 if ((status & ATA_DRQ) == 0) {
2697 ap->pio_task_state = PIO_ST_ERR;
2705 static void ata_pio_error(struct ata_port *ap)
2707 struct ata_queued_cmd *qc;
2710 qc = ata_qc_from_tag(ap, ap->active_tag);
2713 drv_stat = ata_chk_status(ap);
2714 printk(KERN_WARNING "ata%u: PIO error, drv_stat 0x%x\n",
2717 ap->pio_task_state = PIO_ST_IDLE;
2721 ata_qc_complete(qc, drv_stat | ATA_ERR);
2724 static void ata_pio_task(void *_data)
2726 struct ata_port *ap = _data;
2727 unsigned long timeout = 0;
2729 switch (ap->pio_task_state) {
2738 ata_pio_complete(ap);
2742 case PIO_ST_LAST_POLL:
2743 timeout = ata_pio_poll(ap);
2753 queue_delayed_work(ata_wq, &ap->pio_task,
2756 queue_work(ata_wq, &ap->pio_task);
2759 static void atapi_request_sense(struct ata_port *ap, struct ata_device *dev,
2760 struct scsi_cmnd *cmd)
2762 DECLARE_COMPLETION(wait);
2763 struct ata_queued_cmd *qc;
2764 unsigned long flags;
2767 DPRINTK("ATAPI request sense\n");
2769 qc = ata_qc_new_init(ap, dev);
2772 /* FIXME: is this needed? */
2773 memset(cmd->sense_buffer, 0, sizeof(cmd->sense_buffer));
2775 ata_sg_init_one(qc, cmd->sense_buffer, sizeof(cmd->sense_buffer));
2776 qc->dma_dir = DMA_FROM_DEVICE;
2778 memset(&qc->cdb, 0, ap->cdb_len);
2779 qc->cdb[0] = REQUEST_SENSE;
2780 qc->cdb[4] = SCSI_SENSE_BUFFERSIZE;
2782 qc->tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2783 qc->tf.command = ATA_CMD_PACKET;
2785 qc->tf.protocol = ATA_PROT_ATAPI;
2786 qc->tf.lbam = (8 * 1024) & 0xff;
2787 qc->tf.lbah = (8 * 1024) >> 8;
2788 qc->nbytes = SCSI_SENSE_BUFFERSIZE;
2790 qc->waiting = &wait;
2791 qc->complete_fn = ata_qc_complete_noop;
2793 spin_lock_irqsave(&ap->host_set->lock, flags);
2794 rc = ata_qc_issue(qc);
2795 spin_unlock_irqrestore(&ap->host_set->lock, flags);
2798 ata_port_disable(ap);
2800 wait_for_completion(&wait);
2806 * ata_qc_timeout - Handle timeout of queued command
2807 * @qc: Command that timed out
2809 * Some part of the kernel (currently, only the SCSI layer)
2810 * has noticed that the active command on port @ap has not
2811 * completed after a specified length of time. Handle this
2812 * condition by disabling DMA (if necessary) and completing
2813 * transactions, with error if necessary.
2815 * This also handles the case of the "lost interrupt", where
2816 * for some reason (possibly hardware bug, possibly driver bug)
2817 * an interrupt was not delivered to the driver, even though the
2818 * transaction completed successfully.
2821 * Inherited from SCSI layer (none, can sleep)
2824 static void ata_qc_timeout(struct ata_queued_cmd *qc)
2826 struct ata_port *ap = qc->ap;
2827 struct ata_device *dev = qc->dev;
2828 u8 host_stat = 0, drv_stat;
2832 /* FIXME: doesn't this conflict with timeout handling? */
2833 if (qc->dev->class == ATA_DEV_ATAPI && qc->scsicmd) {
2834 struct scsi_cmnd *cmd = qc->scsicmd;
2836 if (!scsi_eh_eflags_chk(cmd, SCSI_EH_CANCEL_CMD)) {
2838 /* finish completing original command */
2839 __ata_qc_complete(qc);
2841 atapi_request_sense(ap, dev, cmd);
2843 cmd->result = (CHECK_CONDITION << 1) | (DID_OK << 16);
2844 scsi_finish_command(cmd);
2850 /* hack alert! We cannot use the supplied completion
2851 * function from inside the ->eh_strategy_handler() thread.
2852 * libata is the only user of ->eh_strategy_handler() in
2853 * any kernel, so the default scsi_done() assumes it is
2854 * not being called from the SCSI EH.
2856 qc->scsidone = scsi_finish_command;
2858 switch (qc->tf.protocol) {
2861 case ATA_PROT_ATAPI_DMA:
2862 host_stat = ap->ops->bmdma_status(ap);
2864 /* before we do anything else, clear DMA-Start bit */
2865 ap->ops->bmdma_stop(ap);
2871 drv_stat = ata_chk_status(ap);
2873 /* ack bmdma irq events */
2874 ap->ops->irq_clear(ap);
2876 printk(KERN_ERR "ata%u: command 0x%x timeout, stat 0x%x host_stat 0x%x\n",
2877 ap->id, qc->tf.command, drv_stat, host_stat);
2879 /* complete taskfile transaction */
2880 ata_qc_complete(qc, drv_stat);
2888 * ata_eng_timeout - Handle timeout of queued command
2889 * @ap: Port on which timed-out command is active
2891 * Some part of the kernel (currently, only the SCSI layer)
2892 * has noticed that the active command on port @ap has not
2893 * completed after a specified length of time. Handle this
2894 * condition by disabling DMA (if necessary) and completing
2895 * transactions, with error if necessary.
2897 * This also handles the case of the "lost interrupt", where
2898 * for some reason (possibly hardware bug, possibly driver bug)
2899 * an interrupt was not delivered to the driver, even though the
2900 * transaction completed successfully.
2903 * Inherited from SCSI layer (none, can sleep)
2906 void ata_eng_timeout(struct ata_port *ap)
2908 struct ata_queued_cmd *qc;
2912 qc = ata_qc_from_tag(ap, ap->active_tag);
2914 printk(KERN_ERR "ata%u: BUG: timeout without command\n",
2926 * ata_qc_new - Request an available ATA command, for queueing
2927 * @ap: Port associated with device @dev
2928 * @dev: Device from whom we request an available command structure
2934 static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
2936 struct ata_queued_cmd *qc = NULL;
2939 for (i = 0; i < ATA_MAX_QUEUE; i++)
2940 if (!test_and_set_bit(i, &ap->qactive)) {
2941 qc = ata_qc_from_tag(ap, i);
2952 * ata_qc_new_init - Request an available ATA command, and initialize it
2953 * @ap: Port associated with device @dev
2954 * @dev: Device from whom we request an available command structure
2960 struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
2961 struct ata_device *dev)
2963 struct ata_queued_cmd *qc;
2965 qc = ata_qc_new(ap);
2972 qc->cursect = qc->cursg = qc->cursg_ofs = 0;
2974 qc->nbytes = qc->curbytes = 0;
2976 ata_tf_init(ap, &qc->tf, dev->devno);
2978 if (dev->flags & ATA_DFLAG_LBA48)
2979 qc->tf.flags |= ATA_TFLAG_LBA48;
2985 static int ata_qc_complete_noop(struct ata_queued_cmd *qc, u8 drv_stat)
2990 static void __ata_qc_complete(struct ata_queued_cmd *qc)
2992 struct ata_port *ap = qc->ap;
2993 unsigned int tag, do_clear = 0;
2997 if (likely(ata_tag_valid(tag))) {
2998 if (tag == ap->active_tag)
2999 ap->active_tag = ATA_TAG_POISON;
3000 qc->tag = ATA_TAG_POISON;
3005 struct completion *waiting = qc->waiting;
3010 if (likely(do_clear))
3011 clear_bit(tag, &ap->qactive);
3015 * ata_qc_free - free unused ata_queued_cmd
3016 * @qc: Command to complete
3018 * Designed to free unused ata_queued_cmd object
3019 * in case something prevents using it.
3022 * spin_lock_irqsave(host_set lock)
3025 void ata_qc_free(struct ata_queued_cmd *qc)
3027 assert(qc != NULL); /* ata_qc_from_tag _might_ return NULL */
3028 assert(qc->waiting == NULL); /* nothing should be waiting */
3030 __ata_qc_complete(qc);
3034 * ata_qc_complete - Complete an active ATA command
3035 * @qc: Command to complete
3036 * @drv_stat: ATA Status register contents
3038 * Indicate to the mid and upper layers that an ATA
3039 * command has completed, with either an ok or not-ok status.
3042 * spin_lock_irqsave(host_set lock)
3046 void ata_qc_complete(struct ata_queued_cmd *qc, u8 drv_stat)
3050 assert(qc != NULL); /* ata_qc_from_tag _might_ return NULL */
3051 assert(qc->flags & ATA_QCFLAG_ACTIVE);
3053 if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
3056 /* call completion callback */
3057 rc = qc->complete_fn(qc, drv_stat);
3058 qc->flags &= ~ATA_QCFLAG_ACTIVE;
3060 /* if callback indicates not to complete command (non-zero),
3061 * return immediately
3066 __ata_qc_complete(qc);
3071 static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
3073 struct ata_port *ap = qc->ap;
3075 switch (qc->tf.protocol) {
3077 case ATA_PROT_ATAPI_DMA:
3080 case ATA_PROT_ATAPI:
3082 case ATA_PROT_PIO_MULT:
3083 if (ap->flags & ATA_FLAG_PIO_DMA)
3096 * ata_qc_issue - issue taskfile to device
3097 * @qc: command to issue to device
3099 * Prepare an ATA command to submission to device.
3100 * This includes mapping the data into a DMA-able
3101 * area, filling in the S/G table, and finally
3102 * writing the taskfile to hardware, starting the command.
3105 * spin_lock_irqsave(host_set lock)
3108 * Zero on success, negative on error.
3111 int ata_qc_issue(struct ata_queued_cmd *qc)
3113 struct ata_port *ap = qc->ap;
3115 if (ata_should_dma_map(qc)) {
3116 if (qc->flags & ATA_QCFLAG_SG) {
3117 if (ata_sg_setup(qc))
3119 } else if (qc->flags & ATA_QCFLAG_SINGLE) {
3120 if (ata_sg_setup_one(qc))
3124 qc->flags &= ~ATA_QCFLAG_DMAMAP;
3127 ap->ops->qc_prep(qc);
3129 qc->ap->active_tag = qc->tag;
3130 qc->flags |= ATA_QCFLAG_ACTIVE;
3132 return ap->ops->qc_issue(qc);
3140 * ata_qc_issue_prot - issue taskfile to device in proto-dependent manner
3141 * @qc: command to issue to device
3143 * Using various libata functions and hooks, this function
3144 * starts an ATA command. ATA commands are grouped into
3145 * classes called "protocols", and issuing each type of protocol
3146 * is slightly different.
3148 * May be used as the qc_issue() entry in ata_port_operations.
3151 * spin_lock_irqsave(host_set lock)
3154 * Zero on success, negative on error.
3157 int ata_qc_issue_prot(struct ata_queued_cmd *qc)
3159 struct ata_port *ap = qc->ap;
3161 ata_dev_select(ap, qc->dev->devno, 1, 0);
3163 switch (qc->tf.protocol) {
3164 case ATA_PROT_NODATA:
3165 ata_tf_to_host_nolock(ap, &qc->tf);
3169 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
3170 ap->ops->bmdma_setup(qc); /* set up bmdma */
3171 ap->ops->bmdma_start(qc); /* initiate bmdma */
3174 case ATA_PROT_PIO: /* load tf registers, initiate polling pio */
3175 ata_qc_set_polling(qc);
3176 ata_tf_to_host_nolock(ap, &qc->tf);
3177 ap->pio_task_state = PIO_ST;
3178 queue_work(ata_wq, &ap->pio_task);
3181 case ATA_PROT_ATAPI:
3182 ata_qc_set_polling(qc);
3183 ata_tf_to_host_nolock(ap, &qc->tf);
3184 queue_work(ata_wq, &ap->packet_task);
3187 case ATA_PROT_ATAPI_NODATA:
3188 ata_tf_to_host_nolock(ap, &qc->tf);
3189 queue_work(ata_wq, &ap->packet_task);
3192 case ATA_PROT_ATAPI_DMA:
3193 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
3194 ap->ops->bmdma_setup(qc); /* set up bmdma */
3195 queue_work(ata_wq, &ap->packet_task);
3207 * ata_bmdma_setup_mmio - Set up PCI IDE BMDMA transaction
3208 * @qc: Info associated with this ATA transaction.
3211 * spin_lock_irqsave(host_set lock)
3214 static void ata_bmdma_setup_mmio (struct ata_queued_cmd *qc)
3216 struct ata_port *ap = qc->ap;
3217 unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
3219 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
3221 /* load PRD table addr. */
3222 mb(); /* make sure PRD table writes are visible to controller */
3223 writel(ap->prd_dma, mmio + ATA_DMA_TABLE_OFS);
3225 /* specify data direction, triple-check start bit is clear */
3226 dmactl = readb(mmio + ATA_DMA_CMD);
3227 dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
3229 dmactl |= ATA_DMA_WR;
3230 writeb(dmactl, mmio + ATA_DMA_CMD);
3232 /* issue r/w command */
3233 ap->ops->exec_command(ap, &qc->tf);
3237 * ata_bmdma_start - Start a PCI IDE BMDMA transaction
3238 * @qc: Info associated with this ATA transaction.
3241 * spin_lock_irqsave(host_set lock)
3244 static void ata_bmdma_start_mmio (struct ata_queued_cmd *qc)
3246 struct ata_port *ap = qc->ap;
3247 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
3250 /* start host DMA transaction */
3251 dmactl = readb(mmio + ATA_DMA_CMD);
3252 writeb(dmactl | ATA_DMA_START, mmio + ATA_DMA_CMD);
3254 /* Strictly, one may wish to issue a readb() here, to
3255 * flush the mmio write. However, control also passes
3256 * to the hardware at this point, and it will interrupt
3257 * us when we are to resume control. So, in effect,
3258 * we don't care when the mmio write flushes.
3259 * Further, a read of the DMA status register _immediately_
3260 * following the write may not be what certain flaky hardware
3261 * is expected, so I think it is best to not add a readb()
3262 * without first all the MMIO ATA cards/mobos.
3263 * Or maybe I'm just being paranoid.
3268 * ata_bmdma_setup_pio - Set up PCI IDE BMDMA transaction (PIO)
3269 * @qc: Info associated with this ATA transaction.
3272 * spin_lock_irqsave(host_set lock)
3275 static void ata_bmdma_setup_pio (struct ata_queued_cmd *qc)
3277 struct ata_port *ap = qc->ap;
3278 unsigned int rw = (qc->tf.flags & ATA_TFLAG_WRITE);
3281 /* load PRD table addr. */
3282 outl(ap->prd_dma, ap->ioaddr.bmdma_addr + ATA_DMA_TABLE_OFS);
3284 /* specify data direction, triple-check start bit is clear */
3285 dmactl = inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3286 dmactl &= ~(ATA_DMA_WR | ATA_DMA_START);
3288 dmactl |= ATA_DMA_WR;
3289 outb(dmactl, ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3291 /* issue r/w command */
3292 ap->ops->exec_command(ap, &qc->tf);
3296 * ata_bmdma_start_pio - Start a PCI IDE BMDMA transaction (PIO)
3297 * @qc: Info associated with this ATA transaction.
3300 * spin_lock_irqsave(host_set lock)
3303 static void ata_bmdma_start_pio (struct ata_queued_cmd *qc)
3305 struct ata_port *ap = qc->ap;
3308 /* start host DMA transaction */
3309 dmactl = inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3310 outb(dmactl | ATA_DMA_START,
3311 ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3316 * ata_bmdma_start - Start a PCI IDE BMDMA transaction
3317 * @qc: Info associated with this ATA transaction.
3319 * Writes the ATA_DMA_START flag to the DMA command register.
3321 * May be used as the bmdma_start() entry in ata_port_operations.
3324 * spin_lock_irqsave(host_set lock)
3326 void ata_bmdma_start(struct ata_queued_cmd *qc)
3328 if (qc->ap->flags & ATA_FLAG_MMIO)
3329 ata_bmdma_start_mmio(qc);
3331 ata_bmdma_start_pio(qc);
3336 * ata_bmdma_setup - Set up PCI IDE BMDMA transaction
3337 * @qc: Info associated with this ATA transaction.
3339 * Writes address of PRD table to device's PRD Table Address
3340 * register, sets the DMA control register, and calls
3341 * ops->exec_command() to start the transfer.
3343 * May be used as the bmdma_setup() entry in ata_port_operations.
3346 * spin_lock_irqsave(host_set lock)
3348 void ata_bmdma_setup(struct ata_queued_cmd *qc)
3350 if (qc->ap->flags & ATA_FLAG_MMIO)
3351 ata_bmdma_setup_mmio(qc);
3353 ata_bmdma_setup_pio(qc);
3358 * ata_bmdma_irq_clear - Clear PCI IDE BMDMA interrupt.
3359 * @ap: Port associated with this ATA transaction.
3361 * Clear interrupt and error flags in DMA status register.
3363 * May be used as the irq_clear() entry in ata_port_operations.
3366 * spin_lock_irqsave(host_set lock)
3369 void ata_bmdma_irq_clear(struct ata_port *ap)
3371 if (ap->flags & ATA_FLAG_MMIO) {
3372 void __iomem *mmio = ((void __iomem *) ap->ioaddr.bmdma_addr) + ATA_DMA_STATUS;
3373 writeb(readb(mmio), mmio);
3375 unsigned long addr = ap->ioaddr.bmdma_addr + ATA_DMA_STATUS;
3376 outb(inb(addr), addr);
3383 * ata_bmdma_status - Read PCI IDE BMDMA status
3384 * @ap: Port associated with this ATA transaction.
3386 * Read and return BMDMA status register.
3388 * May be used as the bmdma_status() entry in ata_port_operations.
3391 * spin_lock_irqsave(host_set lock)
3394 u8 ata_bmdma_status(struct ata_port *ap)
3397 if (ap->flags & ATA_FLAG_MMIO) {
3398 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
3399 host_stat = readb(mmio + ATA_DMA_STATUS);
3401 host_stat = inb(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);
3407 * ata_bmdma_stop - Stop PCI IDE BMDMA transfer
3408 * @ap: Port associated with this ATA transaction.
3410 * Clears the ATA_DMA_START flag in the dma control register
3412 * May be used as the bmdma_stop() entry in ata_port_operations.
3415 * spin_lock_irqsave(host_set lock)
3418 void ata_bmdma_stop(struct ata_port *ap)
3420 if (ap->flags & ATA_FLAG_MMIO) {
3421 void __iomem *mmio = (void __iomem *) ap->ioaddr.bmdma_addr;
3423 /* clear start/stop bit */
3424 writeb(readb(mmio + ATA_DMA_CMD) & ~ATA_DMA_START,
3425 mmio + ATA_DMA_CMD);
3427 /* clear start/stop bit */
3428 outb(inb(ap->ioaddr.bmdma_addr + ATA_DMA_CMD) & ~ATA_DMA_START,
3429 ap->ioaddr.bmdma_addr + ATA_DMA_CMD);
3432 /* one-PIO-cycle guaranteed wait, per spec, for HDMA1:0 transition */
3433 ata_altstatus(ap); /* dummy read */
3437 * ata_host_intr - Handle host interrupt for given (port, task)
3438 * @ap: Port on which interrupt arrived (possibly...)
3439 * @qc: Taskfile currently active in engine
3441 * Handle host interrupt for given queued command. Currently,
3442 * only DMA interrupts are handled. All other commands are
3443 * handled via polling with interrupts disabled (nIEN bit).
3446 * spin_lock_irqsave(host_set lock)
3449 * One if interrupt was handled, zero if not (shared irq).
3452 inline unsigned int ata_host_intr (struct ata_port *ap,
3453 struct ata_queued_cmd *qc)
3455 u8 status, host_stat;
3457 switch (qc->tf.protocol) {
3460 case ATA_PROT_ATAPI_DMA:
3461 case ATA_PROT_ATAPI:
3462 /* check status of DMA engine */
3463 host_stat = ap->ops->bmdma_status(ap);
3464 VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat);
3466 /* if it's not our irq... */
3467 if (!(host_stat & ATA_DMA_INTR))
3470 /* before we do anything else, clear DMA-Start bit */
3471 ap->ops->bmdma_stop(ap);
3475 case ATA_PROT_ATAPI_NODATA:
3476 case ATA_PROT_NODATA:
3477 /* check altstatus */
3478 status = ata_altstatus(ap);
3479 if (status & ATA_BUSY)
3482 /* check main status, clearing INTRQ */
3483 status = ata_chk_status(ap);
3484 if (unlikely(status & ATA_BUSY))
3486 DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n",
3487 ap->id, qc->tf.protocol, status);
3489 /* ack bmdma irq events */
3490 ap->ops->irq_clear(ap);
3492 /* complete taskfile transaction */
3493 ata_qc_complete(qc, status);
3500 return 1; /* irq handled */
3503 ap->stats.idle_irq++;
3506 if ((ap->stats.idle_irq % 1000) == 0) {
3508 ata_irq_ack(ap, 0); /* debug trap */
3509 printk(KERN_WARNING "ata%d: irq trap\n", ap->id);
3512 return 0; /* irq not handled */
3516 * ata_interrupt - Default ATA host interrupt handler
3517 * @irq: irq line (unused)
3518 * @dev_instance: pointer to our ata_host_set information structure
3521 * Default interrupt handler for PCI IDE devices. Calls
3522 * ata_host_intr() for each port that is not disabled.
3525 * Obtains host_set lock during operation.
3528 * IRQ_NONE or IRQ_HANDLED.
3532 irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
3534 struct ata_host_set *host_set = dev_instance;
3536 unsigned int handled = 0;
3537 unsigned long flags;
3539 /* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */
3540 spin_lock_irqsave(&host_set->lock, flags);
3542 for (i = 0; i < host_set->n_ports; i++) {
3543 struct ata_port *ap;
3545 ap = host_set->ports[i];
3546 if (ap && (!(ap->flags & ATA_FLAG_PORT_DISABLED))) {
3547 struct ata_queued_cmd *qc;
3549 qc = ata_qc_from_tag(ap, ap->active_tag);
3550 if (qc && (!(qc->tf.ctl & ATA_NIEN)) &&
3551 (qc->flags & ATA_QCFLAG_ACTIVE))
3552 handled |= ata_host_intr(ap, qc);
3556 spin_unlock_irqrestore(&host_set->lock, flags);
3558 return IRQ_RETVAL(handled);
3562 * atapi_packet_task - Write CDB bytes to hardware
3563 * @_data: Port to which ATAPI device is attached.
3565 * When device has indicated its readiness to accept
3566 * a CDB, this function is called. Send the CDB.
3567 * If DMA is to be performed, exit immediately.
3568 * Otherwise, we are in polling mode, so poll
3569 * status under operation succeeds or fails.
3572 * Kernel thread context (may sleep)
3575 static void atapi_packet_task(void *_data)
3577 struct ata_port *ap = _data;
3578 struct ata_queued_cmd *qc;
3581 qc = ata_qc_from_tag(ap, ap->active_tag);
3583 assert(qc->flags & ATA_QCFLAG_ACTIVE);
3585 /* sleep-wait for BSY to clear */
3586 DPRINTK("busy wait\n");
3587 if (ata_busy_sleep(ap, ATA_TMOUT_CDB_QUICK, ATA_TMOUT_CDB))
3590 /* make sure DRQ is set */
3591 status = ata_chk_status(ap);
3592 if ((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ)
3596 DPRINTK("send cdb\n");
3597 assert(ap->cdb_len >= 12);
3598 ata_data_xfer(ap, qc->cdb, ap->cdb_len, 1);
3600 /* if we are DMA'ing, irq handler takes over from here */
3601 if (qc->tf.protocol == ATA_PROT_ATAPI_DMA)
3602 ap->ops->bmdma_start(qc); /* initiate bmdma */
3604 /* non-data commands are also handled via irq */
3605 else if (qc->tf.protocol == ATA_PROT_ATAPI_NODATA) {
3609 /* PIO commands are handled by polling */
3611 ap->pio_task_state = PIO_ST;
3612 queue_work(ata_wq, &ap->pio_task);
3618 ata_qc_complete(qc, ATA_ERR);
3623 * ata_port_start - Set port up for dma.
3624 * @ap: Port to initialize
3626 * Called just after data structures for each port are
3627 * initialized. Allocates space for PRD table.
3629 * May be used as the port_start() entry in ata_port_operations.
3634 int ata_port_start (struct ata_port *ap)
3636 struct device *dev = ap->host_set->dev;
3638 ap->prd = dma_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, GFP_KERNEL);
3642 DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd, (unsigned long long) ap->prd_dma);
3649 * ata_port_stop - Undo ata_port_start()
3650 * @ap: Port to shut down
3652 * Frees the PRD table.
3654 * May be used as the port_stop() entry in ata_port_operations.
3659 void ata_port_stop (struct ata_port *ap)
3661 struct device *dev = ap->host_set->dev;
3663 dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
3666 void ata_host_stop (struct ata_host_set *host_set)
3668 if (host_set->mmio_base)
3669 iounmap(host_set->mmio_base);
3674 * ata_host_remove - Unregister SCSI host structure with upper layers
3675 * @ap: Port to unregister
3676 * @do_unregister: 1 if we fully unregister, 0 to just stop the port
3681 static void ata_host_remove(struct ata_port *ap, unsigned int do_unregister)
3683 struct Scsi_Host *sh = ap->host;
3688 scsi_remove_host(sh);
3690 ap->ops->port_stop(ap);
3694 * ata_host_init - Initialize an ata_port structure
3695 * @ap: Structure to initialize
3696 * @host: associated SCSI mid-layer structure
3697 * @host_set: Collection of hosts to which @ap belongs
3698 * @ent: Probe information provided by low-level driver
3699 * @port_no: Port number associated with this ata_port
3701 * Initialize a new ata_port structure, and its associated
3705 * Inherited from caller.
3709 static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
3710 struct ata_host_set *host_set,
3711 struct ata_probe_ent *ent, unsigned int port_no)
3717 host->max_channel = 1;
3718 host->unique_id = ata_unique_id++;
3719 host->max_cmd_len = 12;
3720 scsi_set_device(host, ent->dev);
3721 scsi_assign_lock(host, &host_set->lock);
3723 ap->flags = ATA_FLAG_PORT_DISABLED;
3724 ap->id = host->unique_id;
3726 ap->ctl = ATA_DEVCTL_OBS;
3727 ap->host_set = host_set;
3728 ap->port_no = port_no;
3730 ent->legacy_mode ? ent->hard_port_no : port_no;
3731 ap->pio_mask = ent->pio_mask;
3732 ap->mwdma_mask = ent->mwdma_mask;
3733 ap->udma_mask = ent->udma_mask;
3734 ap->flags |= ent->host_flags;
3735 ap->flags |= ent->port_flags[port_no];
3736 ap->ops = ent->port_ops;
3737 ap->cbl = ATA_CBL_NONE;
3738 ap->active_tag = ATA_TAG_POISON;
3739 ap->last_ctl = 0xFF;
3741 INIT_WORK(&ap->packet_task, atapi_packet_task, ap);
3742 INIT_WORK(&ap->pio_task, ata_pio_task, ap);
3744 for (i = 0; i < ATA_MAX_DEVICES; i++)
3745 ap->device[i].devno = i;
3748 ap->stats.unhandled_irq = 1;
3749 ap->stats.idle_irq = 1;
3752 memcpy(&ap->ioaddr, &ent->port[port_no], sizeof(struct ata_ioports));
3756 * ata_host_add - Attach low-level ATA driver to system
3757 * @ent: Information provided by low-level driver
3758 * @host_set: Collections of ports to which we add
3759 * @port_no: Port number associated with this host
3761 * Attach low-level ATA driver to system.
3764 * PCI/etc. bus probe sem.
3767 * New ata_port on success, for NULL on error.
3771 static struct ata_port * ata_host_add(struct ata_probe_ent *ent,
3772 struct ata_host_set *host_set,
3773 unsigned int port_no)
3775 struct Scsi_Host *host;
3776 struct ata_port *ap;
3780 host = scsi_host_alloc(ent->sht, sizeof(struct ata_port));
3784 ap = (struct ata_port *) &host->hostdata[0];
3786 ata_host_init(ap, host, host_set, ent, port_no);
3788 rc = ap->ops->port_start(ap);
3795 scsi_host_put(host);
3800 * ata_device_add - Register hardware device with ATA and SCSI layers
3801 * @ent: Probe information describing hardware device to be registered
3803 * This function processes the information provided in the probe
3804 * information struct @ent, allocates the necessary ATA and SCSI
3805 * host information structures, initializes them, and registers
3806 * everything with requisite kernel subsystems.
3808 * This function requests irqs, probes the ATA bus, and probes
3812 * PCI/etc. bus probe sem.
3815 * Number of ports registered. Zero on error (no ports registered).
3819 int ata_device_add(struct ata_probe_ent *ent)
3821 unsigned int count = 0, i;
3822 struct device *dev = ent->dev;
3823 struct ata_host_set *host_set;
3826 /* alloc a container for our list of ATA ports (buses) */
3827 host_set = kmalloc(sizeof(struct ata_host_set) +
3828 (ent->n_ports * sizeof(void *)), GFP_KERNEL);
3831 memset(host_set, 0, sizeof(struct ata_host_set) + (ent->n_ports * sizeof(void *)));
3832 spin_lock_init(&host_set->lock);
3834 host_set->dev = dev;
3835 host_set->n_ports = ent->n_ports;
3836 host_set->irq = ent->irq;
3837 host_set->mmio_base = ent->mmio_base;
3838 host_set->private_data = ent->private_data;
3839 host_set->ops = ent->port_ops;
3841 /* register each port bound to this device */
3842 for (i = 0; i < ent->n_ports; i++) {
3843 struct ata_port *ap;
3844 unsigned long xfer_mode_mask;
3846 ap = ata_host_add(ent, host_set, i);
3850 host_set->ports[i] = ap;
3851 xfer_mode_mask =(ap->udma_mask << ATA_SHIFT_UDMA) |
3852 (ap->mwdma_mask << ATA_SHIFT_MWDMA) |
3853 (ap->pio_mask << ATA_SHIFT_PIO);
3855 /* print per-port info to dmesg */
3856 printk(KERN_INFO "ata%u: %cATA max %s cmd 0x%lX ctl 0x%lX "
3857 "bmdma 0x%lX irq %lu\n",
3859 ap->flags & ATA_FLAG_SATA ? 'S' : 'P',
3860 ata_mode_string(xfer_mode_mask),
3861 ap->ioaddr.cmd_addr,
3862 ap->ioaddr.ctl_addr,
3863 ap->ioaddr.bmdma_addr,
3867 host_set->ops->irq_clear(ap);
3876 /* obtain irq, that is shared between channels */
3877 if (request_irq(ent->irq, ent->port_ops->irq_handler, ent->irq_flags,
3878 DRV_NAME, host_set))
3881 /* perform each probe synchronously */
3882 DPRINTK("probe begin\n");
3883 for (i = 0; i < count; i++) {
3884 struct ata_port *ap;
3887 ap = host_set->ports[i];
3889 DPRINTK("ata%u: probe begin\n", ap->id);
3890 rc = ata_bus_probe(ap);
3891 DPRINTK("ata%u: probe end\n", ap->id);
3894 /* FIXME: do something useful here?
3895 * Current libata behavior will
3896 * tear down everything when
3897 * the module is removed
3898 * or the h/w is unplugged.
3902 rc = scsi_add_host(ap->host, dev);
3904 printk(KERN_ERR "ata%u: scsi_add_host failed\n",
3906 /* FIXME: do something useful here */
3907 /* FIXME: handle unconditional calls to
3908 * scsi_scan_host and ata_host_remove, below,
3914 /* probes are done, now scan each port's disk(s) */
3915 DPRINTK("probe begin\n");
3916 for (i = 0; i < count; i++) {
3917 struct ata_port *ap = host_set->ports[i];
3919 scsi_scan_host(ap->host);
3922 dev_set_drvdata(dev, host_set);
3924 VPRINTK("EXIT, returning %u\n", ent->n_ports);
3925 return ent->n_ports; /* success */
3928 for (i = 0; i < count; i++) {
3929 ata_host_remove(host_set->ports[i], 1);
3930 scsi_host_put(host_set->ports[i]->host);
3933 VPRINTK("EXIT, returning 0\n");
3938 * ata_scsi_release - SCSI layer callback hook for host unload
3939 * @host: libata host to be unloaded
3941 * Performs all duties necessary to shut down a libata port...
3942 * Kill port kthread, disable port, and release resources.
3945 * Inherited from SCSI layer.
3951 int ata_scsi_release(struct Scsi_Host *host)
3953 struct ata_port *ap = (struct ata_port *) &host->hostdata[0];
3957 ap->ops->port_disable(ap);
3958 ata_host_remove(ap, 0);
3965 * ata_std_ports - initialize ioaddr with standard port offsets.
3966 * @ioaddr: IO address structure to be initialized
3968 * Utility function which initializes data_addr, error_addr,
3969 * feature_addr, nsect_addr, lbal_addr, lbam_addr, lbah_addr,
3970 * device_addr, status_addr, and command_addr to standard offsets
3971 * relative to cmd_addr.
3973 * Does not set ctl_addr, altstatus_addr, bmdma_addr, or scr_addr.
3976 void ata_std_ports(struct ata_ioports *ioaddr)
3978 ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA;
3979 ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR;
3980 ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE;
3981 ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT;
3982 ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL;
3983 ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM;
3984 ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH;
3985 ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE;
3986 ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS;
3987 ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
3990 static struct ata_probe_ent *
3991 ata_probe_ent_alloc(struct device *dev, struct ata_port_info *port)
3993 struct ata_probe_ent *probe_ent;
3995 probe_ent = kmalloc(sizeof(*probe_ent), GFP_KERNEL);
3997 printk(KERN_ERR DRV_NAME "(%s): out of memory\n",
3998 kobject_name(&(dev->kobj)));
4002 memset(probe_ent, 0, sizeof(*probe_ent));
4004 INIT_LIST_HEAD(&probe_ent->node);
4005 probe_ent->dev = dev;
4007 probe_ent->sht = port->sht;
4008 probe_ent->host_flags = port->host_flags;
4009 probe_ent->pio_mask = port->pio_mask;
4010 probe_ent->mwdma_mask = port->mwdma_mask;
4011 probe_ent->udma_mask = port->udma_mask;
4012 probe_ent->port_ops = port->port_ops;
4020 * ata_pci_init_native_mode - Initialize native-mode driver
4021 * @pdev: pci device to be initialized
4022 * @port: array[2] of pointers to port info structures.
4024 * Utility function which allocates and initializes an
4025 * ata_probe_ent structure for a standard dual-port
4026 * PIO-based IDE controller. The returned ata_probe_ent
4027 * structure can be passed to ata_device_add(). The returned
4028 * ata_probe_ent structure should then be freed with kfree().
4032 struct ata_probe_ent *
4033 ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port)
4035 struct ata_probe_ent *probe_ent =
4036 ata_probe_ent_alloc(pci_dev_to_dev(pdev), port[0]);
4040 probe_ent->n_ports = 2;
4041 probe_ent->irq = pdev->irq;
4042 probe_ent->irq_flags = SA_SHIRQ;
4044 probe_ent->port[0].cmd_addr = pci_resource_start(pdev, 0);
4045 probe_ent->port[0].altstatus_addr =
4046 probe_ent->port[0].ctl_addr =
4047 pci_resource_start(pdev, 1) | ATA_PCI_CTL_OFS;
4048 probe_ent->port[0].bmdma_addr = pci_resource_start(pdev, 4);
4050 probe_ent->port[1].cmd_addr = pci_resource_start(pdev, 2);
4051 probe_ent->port[1].altstatus_addr =
4052 probe_ent->port[1].ctl_addr =
4053 pci_resource_start(pdev, 3) | ATA_PCI_CTL_OFS;
4054 probe_ent->port[1].bmdma_addr = pci_resource_start(pdev, 4) + 8;
4056 ata_std_ports(&probe_ent->port[0]);
4057 ata_std_ports(&probe_ent->port[1]);
4062 static struct ata_probe_ent *
4063 ata_pci_init_legacy_mode(struct pci_dev *pdev, struct ata_port_info **port,
4064 struct ata_probe_ent **ppe2)
4066 struct ata_probe_ent *probe_ent, *probe_ent2;
4068 probe_ent = ata_probe_ent_alloc(pci_dev_to_dev(pdev), port[0]);
4071 probe_ent2 = ata_probe_ent_alloc(pci_dev_to_dev(pdev), port[1]);
4077 probe_ent->n_ports = 1;
4078 probe_ent->irq = 14;
4080 probe_ent->hard_port_no = 0;
4081 probe_ent->legacy_mode = 1;
4083 probe_ent2->n_ports = 1;
4084 probe_ent2->irq = 15;
4086 probe_ent2->hard_port_no = 1;
4087 probe_ent2->legacy_mode = 1;
4089 probe_ent->port[0].cmd_addr = 0x1f0;
4090 probe_ent->port[0].altstatus_addr =
4091 probe_ent->port[0].ctl_addr = 0x3f6;
4092 probe_ent->port[0].bmdma_addr = pci_resource_start(pdev, 4);
4094 probe_ent2->port[0].cmd_addr = 0x170;
4095 probe_ent2->port[0].altstatus_addr =
4096 probe_ent2->port[0].ctl_addr = 0x376;
4097 probe_ent2->port[0].bmdma_addr = pci_resource_start(pdev, 4)+8;
4099 ata_std_ports(&probe_ent->port[0]);
4100 ata_std_ports(&probe_ent2->port[0]);
4107 * ata_pci_init_one - Initialize/register PCI IDE host controller
4108 * @pdev: Controller to be initialized
4109 * @port_info: Information from low-level host driver
4110 * @n_ports: Number of ports attached to host controller
4112 * This is a helper function which can be called from a driver's
4113 * xxx_init_one() probe function if the hardware uses traditional
4114 * IDE taskfile registers.
4116 * This function calls pci_enable_device(), reserves its register
4117 * regions, sets the dma mask, enables bus master mode, and calls
4121 * Inherited from PCI layer (may sleep).
4124 * Zero on success, negative on errno-based value on error.
4128 int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
4129 unsigned int n_ports)
4131 struct ata_probe_ent *probe_ent, *probe_ent2 = NULL;
4132 struct ata_port_info *port[2];
4134 unsigned int legacy_mode = 0;
4135 int disable_dev_on_err = 1;
4140 port[0] = port_info[0];
4142 port[1] = port_info[1];
4146 if ((port[0]->host_flags & ATA_FLAG_NO_LEGACY) == 0
4147 && (pdev->class >> 8) == PCI_CLASS_STORAGE_IDE) {
4148 /* TODO: support transitioning to native mode? */
4149 pci_read_config_byte(pdev, PCI_CLASS_PROG, &tmp8);
4150 mask = (1 << 2) | (1 << 0);
4151 if ((tmp8 & mask) != mask)
4152 legacy_mode = (1 << 3);
4156 if ((!legacy_mode) && (n_ports > 1)) {
4157 printk(KERN_ERR "ata: BUG: native mode, n_ports > 1\n");
4161 rc = pci_enable_device(pdev);
4165 rc = pci_request_regions(pdev, DRV_NAME);
4167 disable_dev_on_err = 0;
4172 if (!request_region(0x1f0, 8, "libata")) {
4173 struct resource *conflict, res;
4175 res.end = 0x1f0 + 8 - 1;
4176 conflict = ____request_resource(&ioport_resource, &res);
4177 if (!strcmp(conflict->name, "libata"))
4178 legacy_mode |= (1 << 0);
4180 disable_dev_on_err = 0;
4181 printk(KERN_WARNING "ata: 0x1f0 IDE port busy\n");
4184 legacy_mode |= (1 << 0);
4186 if (!request_region(0x170, 8, "libata")) {
4187 struct resource *conflict, res;
4189 res.end = 0x170 + 8 - 1;
4190 conflict = ____request_resource(&ioport_resource, &res);
4191 if (!strcmp(conflict->name, "libata"))
4192 legacy_mode |= (1 << 1);
4194 disable_dev_on_err = 0;
4195 printk(KERN_WARNING "ata: 0x170 IDE port busy\n");
4198 legacy_mode |= (1 << 1);
4201 /* we have legacy mode, but all ports are unavailable */
4202 if (legacy_mode == (1 << 3)) {
4204 goto err_out_regions;
4207 rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
4209 goto err_out_regions;
4210 rc = pci_set_consistent_dma_mask(pdev, ATA_DMA_MASK);
4212 goto err_out_regions;
4215 probe_ent = ata_pci_init_legacy_mode(pdev, port, &probe_ent2);
4217 probe_ent = ata_pci_init_native_mode(pdev, port);
4220 goto err_out_regions;
4223 pci_set_master(pdev);
4225 /* FIXME: check ata_device_add return */
4227 if (legacy_mode & (1 << 0))
4228 ata_device_add(probe_ent);
4229 if (legacy_mode & (1 << 1))
4230 ata_device_add(probe_ent2);
4232 ata_device_add(probe_ent);
4240 if (legacy_mode & (1 << 0))
4241 release_region(0x1f0, 8);
4242 if (legacy_mode & (1 << 1))
4243 release_region(0x170, 8);
4244 pci_release_regions(pdev);
4246 if (disable_dev_on_err)
4247 pci_disable_device(pdev);
4252 * ata_pci_remove_one - PCI layer callback for device removal
4253 * @pdev: PCI device that was removed
4255 * PCI layer indicates to libata via this hook that
4256 * hot-unplug or module unload event has occured.
4257 * Handle this by unregistering all objects associated
4258 * with this PCI device. Free those objects. Then finally
4259 * release PCI resources and disable device.
4262 * Inherited from PCI layer (may sleep).
4265 void ata_pci_remove_one (struct pci_dev *pdev)
4267 struct device *dev = pci_dev_to_dev(pdev);
4268 struct ata_host_set *host_set = dev_get_drvdata(dev);
4269 struct ata_port *ap;
4272 for (i = 0; i < host_set->n_ports; i++) {
4273 ap = host_set->ports[i];
4275 scsi_remove_host(ap->host);
4278 free_irq(host_set->irq, host_set);
4280 for (i = 0; i < host_set->n_ports; i++) {
4281 ap = host_set->ports[i];
4283 ata_scsi_release(ap->host);
4285 if ((ap->flags & ATA_FLAG_NO_LEGACY) == 0) {
4286 struct ata_ioports *ioaddr = &ap->ioaddr;
4288 if (ioaddr->cmd_addr == 0x1f0)
4289 release_region(0x1f0, 8);
4290 else if (ioaddr->cmd_addr == 0x170)
4291 release_region(0x170, 8);
4294 scsi_host_put(ap->host);
4297 if (host_set->ops->host_stop)
4298 host_set->ops->host_stop(host_set);
4302 pci_release_regions(pdev);
4303 pci_disable_device(pdev);
4304 dev_set_drvdata(dev, NULL);
4307 /* move to PCI subsystem */
4308 int pci_test_config_bits(struct pci_dev *pdev, struct pci_bits *bits)
4310 unsigned long tmp = 0;
4312 switch (bits->width) {
4315 pci_read_config_byte(pdev, bits->reg, &tmp8);
4321 pci_read_config_word(pdev, bits->reg, &tmp16);
4327 pci_read_config_dword(pdev, bits->reg, &tmp32);
4338 return (tmp == bits->val) ? 1 : 0;
4340 #endif /* CONFIG_PCI */
4343 static int __init ata_init(void)
4345 ata_wq = create_workqueue("ata");
4349 printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
4353 static void __exit ata_exit(void)
4355 destroy_workqueue(ata_wq);
4358 module_init(ata_init);
4359 module_exit(ata_exit);
4362 * libata is essentially a library of internal helper functions for
4363 * low-level ATA host controller drivers. As such, the API/ABI is
4364 * likely to change as new drivers are added and updated.
4365 * Do not depend on ABI/API stability.
4368 EXPORT_SYMBOL_GPL(ata_std_bios_param);
4369 EXPORT_SYMBOL_GPL(ata_std_ports);
4370 EXPORT_SYMBOL_GPL(ata_device_add);
4371 EXPORT_SYMBOL_GPL(ata_sg_init);
4372 EXPORT_SYMBOL_GPL(ata_sg_init_one);
4373 EXPORT_SYMBOL_GPL(ata_qc_complete);
4374 EXPORT_SYMBOL_GPL(ata_qc_issue_prot);
4375 EXPORT_SYMBOL_GPL(ata_eng_timeout);
4376 EXPORT_SYMBOL_GPL(ata_tf_load);
4377 EXPORT_SYMBOL_GPL(ata_tf_read);
4378 EXPORT_SYMBOL_GPL(ata_noop_dev_select);
4379 EXPORT_SYMBOL_GPL(ata_std_dev_select);
4380 EXPORT_SYMBOL_GPL(ata_tf_to_fis);
4381 EXPORT_SYMBOL_GPL(ata_tf_from_fis);
4382 EXPORT_SYMBOL_GPL(ata_check_status);
4383 EXPORT_SYMBOL_GPL(ata_altstatus);
4384 EXPORT_SYMBOL_GPL(ata_chk_err);
4385 EXPORT_SYMBOL_GPL(ata_exec_command);
4386 EXPORT_SYMBOL_GPL(ata_port_start);
4387 EXPORT_SYMBOL_GPL(ata_port_stop);
4388 EXPORT_SYMBOL_GPL(ata_host_stop);
4389 EXPORT_SYMBOL_GPL(ata_interrupt);
4390 EXPORT_SYMBOL_GPL(ata_qc_prep);
4391 EXPORT_SYMBOL_GPL(ata_bmdma_setup);
4392 EXPORT_SYMBOL_GPL(ata_bmdma_start);
4393 EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
4394 EXPORT_SYMBOL_GPL(ata_bmdma_status);
4395 EXPORT_SYMBOL_GPL(ata_bmdma_stop);
4396 EXPORT_SYMBOL_GPL(ata_port_probe);
4397 EXPORT_SYMBOL_GPL(sata_phy_reset);
4398 EXPORT_SYMBOL_GPL(__sata_phy_reset);
4399 EXPORT_SYMBOL_GPL(ata_bus_reset);
4400 EXPORT_SYMBOL_GPL(ata_port_disable);
4401 EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
4402 EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
4403 EXPORT_SYMBOL_GPL(ata_scsi_error);
4404 EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
4405 EXPORT_SYMBOL_GPL(ata_scsi_release);
4406 EXPORT_SYMBOL_GPL(ata_host_intr);
4407 EXPORT_SYMBOL_GPL(ata_dev_classify);
4408 EXPORT_SYMBOL_GPL(ata_dev_id_string);
4409 EXPORT_SYMBOL_GPL(ata_scsi_simulate);
4412 EXPORT_SYMBOL_GPL(pci_test_config_bits);
4413 EXPORT_SYMBOL_GPL(ata_pci_init_native_mode);
4414 EXPORT_SYMBOL_GPL(ata_pci_init_one);
4415 EXPORT_SYMBOL_GPL(ata_pci_remove_one);
4416 #endif /* CONFIG_PCI */