2 * libata-core.c - helper library for ATA
4 * Maintained by: Jeff Garzik <jgarzik@pobox.com>
5 * Please ALWAYS copy linux-ide@vger.kernel.org
8 * Copyright 2003-2004 Red Hat, Inc. All rights reserved.
9 * Copyright 2003-2004 Jeff Garzik
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2, or (at your option)
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; see the file COPYING. If not, write to
24 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
27 * libata documentation is available via 'make {ps|pdf}docs',
28 * as Documentation/DocBook/libata.*
30 * Hardware documentation available from http://www.t13.org/ and
31 * http://www.sata-io.org/
35 #include <linux/config.h>
36 #include <linux/kernel.h>
37 #include <linux/module.h>
38 #include <linux/pci.h>
39 #include <linux/init.h>
40 #include <linux/list.h>
42 #include <linux/highmem.h>
43 #include <linux/spinlock.h>
44 #include <linux/blkdev.h>
45 #include <linux/delay.h>
46 #include <linux/timer.h>
47 #include <linux/interrupt.h>
48 #include <linux/completion.h>
49 #include <linux/suspend.h>
50 #include <linux/workqueue.h>
51 #include <linux/jiffies.h>
52 #include <linux/scatterlist.h>
53 #include <scsi/scsi.h>
54 #include "scsi_priv.h"
55 #include <scsi/scsi_cmnd.h>
56 #include <scsi/scsi_host.h>
57 #include <linux/libata.h>
59 #include <asm/semaphore.h>
60 #include <asm/byteorder.h>
64 static unsigned int ata_dev_init_params(struct ata_port *ap,
65 struct ata_device *dev,
68 static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
69 struct ata_device *dev);
70 static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev);
72 static unsigned int ata_unique_id = 1;
73 static struct workqueue_struct *ata_wq;
75 int atapi_enabled = 1;
76 module_param(atapi_enabled, int, 0444);
77 MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)");
80 module_param(atapi_dmadir, int, 0444);
81 MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off, 1=on)");
84 module_param_named(fua, libata_fua, int, 0444);
85 MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");
87 MODULE_AUTHOR("Jeff Garzik");
88 MODULE_DESCRIPTION("Library module for ATA devices");
89 MODULE_LICENSE("GPL");
90 MODULE_VERSION(DRV_VERSION);
94 * ata_tf_to_fis - Convert ATA taskfile to SATA FIS structure
95 * @tf: Taskfile to convert
96 * @fis: Buffer into which data will output
97 * @pmp: Port multiplier port
99 * Converts a standard ATA taskfile to a Serial ATA
100 * FIS structure (Register - Host to Device).
103 * Inherited from caller.
106 void ata_tf_to_fis(const struct ata_taskfile *tf, u8 *fis, u8 pmp)
108 fis[0] = 0x27; /* Register - Host to Device FIS */
109 fis[1] = (pmp & 0xf) | (1 << 7); /* Port multiplier number,
110 bit 7 indicates Command FIS */
111 fis[2] = tf->command;
112 fis[3] = tf->feature;
119 fis[8] = tf->hob_lbal;
120 fis[9] = tf->hob_lbam;
121 fis[10] = tf->hob_lbah;
122 fis[11] = tf->hob_feature;
125 fis[13] = tf->hob_nsect;
136 * ata_tf_from_fis - Convert SATA FIS to ATA taskfile
137 * @fis: Buffer from which data will be input
138 * @tf: Taskfile to output
140 * Converts a serial ATA FIS structure to a standard ATA taskfile.
143 * Inherited from caller.
146 void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf)
148 tf->command = fis[2]; /* status */
149 tf->feature = fis[3]; /* error */
156 tf->hob_lbal = fis[8];
157 tf->hob_lbam = fis[9];
158 tf->hob_lbah = fis[10];
161 tf->hob_nsect = fis[13];
164 static const u8 ata_rw_cmds[] = {
168 ATA_CMD_READ_MULTI_EXT,
169 ATA_CMD_WRITE_MULTI_EXT,
173 ATA_CMD_WRITE_MULTI_FUA_EXT,
177 ATA_CMD_PIO_READ_EXT,
178 ATA_CMD_PIO_WRITE_EXT,
191 ATA_CMD_WRITE_FUA_EXT
195 * ata_rwcmd_protocol - set taskfile r/w commands and protocol
196 * @qc: command to examine and configure
198 * Examine the device configuration and tf->flags to calculate
199 * the proper read/write commands and protocol to use.
204 int ata_rwcmd_protocol(struct ata_queued_cmd *qc)
206 struct ata_taskfile *tf = &qc->tf;
207 struct ata_device *dev = qc->dev;
210 int index, fua, lba48, write;
212 fua = (tf->flags & ATA_TFLAG_FUA) ? 4 : 0;
213 lba48 = (tf->flags & ATA_TFLAG_LBA48) ? 2 : 0;
214 write = (tf->flags & ATA_TFLAG_WRITE) ? 1 : 0;
216 if (dev->flags & ATA_DFLAG_PIO) {
217 tf->protocol = ATA_PROT_PIO;
218 index = dev->multi_count ? 0 : 8;
219 } else if (lba48 && (qc->ap->flags & ATA_FLAG_PIO_LBA48)) {
220 /* Unable to use DMA due to host limitation */
221 tf->protocol = ATA_PROT_PIO;
222 index = dev->multi_count ? 0 : 8;
224 tf->protocol = ATA_PROT_DMA;
228 cmd = ata_rw_cmds[index + fua + lba48 + write];
237 * ata_pack_xfermask - Pack pio, mwdma and udma masks into xfer_mask
238 * @pio_mask: pio_mask
239 * @mwdma_mask: mwdma_mask
240 * @udma_mask: udma_mask
242 * Pack @pio_mask, @mwdma_mask and @udma_mask into a single
243 * unsigned int xfer_mask.
251 static unsigned int ata_pack_xfermask(unsigned int pio_mask,
252 unsigned int mwdma_mask,
253 unsigned int udma_mask)
255 return ((pio_mask << ATA_SHIFT_PIO) & ATA_MASK_PIO) |
256 ((mwdma_mask << ATA_SHIFT_MWDMA) & ATA_MASK_MWDMA) |
257 ((udma_mask << ATA_SHIFT_UDMA) & ATA_MASK_UDMA);
261 * ata_unpack_xfermask - Unpack xfer_mask into pio, mwdma and udma masks
262 * @xfer_mask: xfer_mask to unpack
263 * @pio_mask: resulting pio_mask
264 * @mwdma_mask: resulting mwdma_mask
265 * @udma_mask: resulting udma_mask
267 * Unpack @xfer_mask into @pio_mask, @mwdma_mask and @udma_mask.
268 * Any NULL distination masks will be ignored.
270 static void ata_unpack_xfermask(unsigned int xfer_mask,
271 unsigned int *pio_mask,
272 unsigned int *mwdma_mask,
273 unsigned int *udma_mask)
276 *pio_mask = (xfer_mask & ATA_MASK_PIO) >> ATA_SHIFT_PIO;
278 *mwdma_mask = (xfer_mask & ATA_MASK_MWDMA) >> ATA_SHIFT_MWDMA;
280 *udma_mask = (xfer_mask & ATA_MASK_UDMA) >> ATA_SHIFT_UDMA;
283 static const struct ata_xfer_ent {
287 { ATA_SHIFT_PIO, ATA_BITS_PIO, XFER_PIO_0 },
288 { ATA_SHIFT_MWDMA, ATA_BITS_MWDMA, XFER_MW_DMA_0 },
289 { ATA_SHIFT_UDMA, ATA_BITS_UDMA, XFER_UDMA_0 },
294 * ata_xfer_mask2mode - Find matching XFER_* for the given xfer_mask
295 * @xfer_mask: xfer_mask of interest
297 * Return matching XFER_* value for @xfer_mask. Only the highest
298 * bit of @xfer_mask is considered.
304 * Matching XFER_* value, 0 if no match found.
306 static u8 ata_xfer_mask2mode(unsigned int xfer_mask)
308 int highbit = fls(xfer_mask) - 1;
309 const struct ata_xfer_ent *ent;
311 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
312 if (highbit >= ent->shift && highbit < ent->shift + ent->bits)
313 return ent->base + highbit - ent->shift;
318 * ata_xfer_mode2mask - Find matching xfer_mask for XFER_*
319 * @xfer_mode: XFER_* of interest
321 * Return matching xfer_mask for @xfer_mode.
327 * Matching xfer_mask, 0 if no match found.
329 static unsigned int ata_xfer_mode2mask(u8 xfer_mode)
331 const struct ata_xfer_ent *ent;
333 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
334 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
335 return 1 << (ent->shift + xfer_mode - ent->base);
340 * ata_xfer_mode2shift - Find matching xfer_shift for XFER_*
341 * @xfer_mode: XFER_* of interest
343 * Return matching xfer_shift for @xfer_mode.
349 * Matching xfer_shift, -1 if no match found.
351 static int ata_xfer_mode2shift(unsigned int xfer_mode)
353 const struct ata_xfer_ent *ent;
355 for (ent = ata_xfer_tbl; ent->shift >= 0; ent++)
356 if (xfer_mode >= ent->base && xfer_mode < ent->base + ent->bits)
362 * ata_mode_string - convert xfer_mask to string
363 * @xfer_mask: mask of bits supported; only highest bit counts.
365 * Determine string which represents the highest speed
366 * (highest bit in @modemask).
372 * Constant C string representing highest speed listed in
373 * @mode_mask, or the constant C string "<n/a>".
375 static const char *ata_mode_string(unsigned int xfer_mask)
377 static const char * const xfer_mode_str[] = {
397 highbit = fls(xfer_mask) - 1;
398 if (highbit >= 0 && highbit < ARRAY_SIZE(xfer_mode_str))
399 return xfer_mode_str[highbit];
403 static const char *sata_spd_string(unsigned int spd)
405 static const char * const spd_str[] = {
410 if (spd == 0 || (spd - 1) >= ARRAY_SIZE(spd_str))
412 return spd_str[spd - 1];
415 void ata_dev_disable(struct ata_port *ap, struct ata_device *dev)
417 if (ata_dev_enabled(dev)) {
418 printk(KERN_WARNING "ata%u: dev %u disabled\n",
425 * ata_pio_devchk - PATA device presence detection
426 * @ap: ATA channel to examine
427 * @device: Device to examine (starting at zero)
429 * This technique was originally described in
430 * Hale Landis's ATADRVR (www.ata-atapi.com), and
431 * later found its way into the ATA/ATAPI spec.
433 * Write a pattern to the ATA shadow registers,
434 * and if a device is present, it will respond by
435 * correctly storing and echoing back the
436 * ATA shadow register contents.
442 static unsigned int ata_pio_devchk(struct ata_port *ap,
445 struct ata_ioports *ioaddr = &ap->ioaddr;
448 ap->ops->dev_select(ap, device);
450 outb(0x55, ioaddr->nsect_addr);
451 outb(0xaa, ioaddr->lbal_addr);
453 outb(0xaa, ioaddr->nsect_addr);
454 outb(0x55, ioaddr->lbal_addr);
456 outb(0x55, ioaddr->nsect_addr);
457 outb(0xaa, ioaddr->lbal_addr);
459 nsect = inb(ioaddr->nsect_addr);
460 lbal = inb(ioaddr->lbal_addr);
462 if ((nsect == 0x55) && (lbal == 0xaa))
463 return 1; /* we found a device */
465 return 0; /* nothing found */
469 * ata_mmio_devchk - PATA device presence detection
470 * @ap: ATA channel to examine
471 * @device: Device to examine (starting at zero)
473 * This technique was originally described in
474 * Hale Landis's ATADRVR (www.ata-atapi.com), and
475 * later found its way into the ATA/ATAPI spec.
477 * Write a pattern to the ATA shadow registers,
478 * and if a device is present, it will respond by
479 * correctly storing and echoing back the
480 * ATA shadow register contents.
486 static unsigned int ata_mmio_devchk(struct ata_port *ap,
489 struct ata_ioports *ioaddr = &ap->ioaddr;
492 ap->ops->dev_select(ap, device);
494 writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
495 writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
497 writeb(0xaa, (void __iomem *) ioaddr->nsect_addr);
498 writeb(0x55, (void __iomem *) ioaddr->lbal_addr);
500 writeb(0x55, (void __iomem *) ioaddr->nsect_addr);
501 writeb(0xaa, (void __iomem *) ioaddr->lbal_addr);
503 nsect = readb((void __iomem *) ioaddr->nsect_addr);
504 lbal = readb((void __iomem *) ioaddr->lbal_addr);
506 if ((nsect == 0x55) && (lbal == 0xaa))
507 return 1; /* we found a device */
509 return 0; /* nothing found */
513 * ata_devchk - PATA device presence detection
514 * @ap: ATA channel to examine
515 * @device: Device to examine (starting at zero)
517 * Dispatch ATA device presence detection, depending
518 * on whether we are using PIO or MMIO to talk to the
519 * ATA shadow registers.
525 static unsigned int ata_devchk(struct ata_port *ap,
528 if (ap->flags & ATA_FLAG_MMIO)
529 return ata_mmio_devchk(ap, device);
530 return ata_pio_devchk(ap, device);
534 * ata_dev_classify - determine device type based on ATA-spec signature
535 * @tf: ATA taskfile register set for device to be identified
537 * Determine from taskfile register contents whether a device is
538 * ATA or ATAPI, as per "Signature and persistence" section
539 * of ATA/PI spec (volume 1, sect 5.14).
545 * Device type, %ATA_DEV_ATA, %ATA_DEV_ATAPI, or %ATA_DEV_UNKNOWN
546 * the event of failure.
549 unsigned int ata_dev_classify(const struct ata_taskfile *tf)
551 /* Apple's open source Darwin code hints that some devices only
552 * put a proper signature into the LBA mid/high registers,
553 * So, we only check those. It's sufficient for uniqueness.
556 if (((tf->lbam == 0) && (tf->lbah == 0)) ||
557 ((tf->lbam == 0x3c) && (tf->lbah == 0xc3))) {
558 DPRINTK("found ATA device by sig\n");
562 if (((tf->lbam == 0x14) && (tf->lbah == 0xeb)) ||
563 ((tf->lbam == 0x69) && (tf->lbah == 0x96))) {
564 DPRINTK("found ATAPI device by sig\n");
565 return ATA_DEV_ATAPI;
568 DPRINTK("unknown device\n");
569 return ATA_DEV_UNKNOWN;
573 * ata_dev_try_classify - Parse returned ATA device signature
574 * @ap: ATA channel to examine
575 * @device: Device to examine (starting at zero)
576 * @r_err: Value of error register on completion
578 * After an event -- SRST, E.D.D., or SATA COMRESET -- occurs,
579 * an ATA/ATAPI-defined set of values is placed in the ATA
580 * shadow registers, indicating the results of device detection
583 * Select the ATA device, and read the values from the ATA shadow
584 * registers. Then parse according to the Error register value,
585 * and the spec-defined values examined by ata_dev_classify().
591 * Device type - %ATA_DEV_ATA, %ATA_DEV_ATAPI or %ATA_DEV_NONE.
595 ata_dev_try_classify(struct ata_port *ap, unsigned int device, u8 *r_err)
597 struct ata_taskfile tf;
601 ap->ops->dev_select(ap, device);
603 memset(&tf, 0, sizeof(tf));
605 ap->ops->tf_read(ap, &tf);
610 /* see if device passed diags */
613 else if ((device == 0) && (err == 0x81))
618 /* determine if device is ATA or ATAPI */
619 class = ata_dev_classify(&tf);
621 if (class == ATA_DEV_UNKNOWN)
623 if ((class == ATA_DEV_ATA) && (ata_chk_status(ap) == 0))
629 * ata_id_string - Convert IDENTIFY DEVICE page into string
630 * @id: IDENTIFY DEVICE results we will examine
631 * @s: string into which data is output
632 * @ofs: offset into identify device page
633 * @len: length of string to return. must be an even number.
635 * The strings in the IDENTIFY DEVICE page are broken up into
636 * 16-bit chunks. Run through the string, and output each
637 * 8-bit chunk linearly, regardless of platform.
643 void ata_id_string(const u16 *id, unsigned char *s,
644 unsigned int ofs, unsigned int len)
663 * ata_id_c_string - Convert IDENTIFY DEVICE page into C string
664 * @id: IDENTIFY DEVICE results we will examine
665 * @s: string into which data is output
666 * @ofs: offset into identify device page
667 * @len: length of string to return. must be an odd number.
669 * This function is identical to ata_id_string except that it
670 * trims trailing spaces and terminates the resulting string with
671 * null. @len must be actual maximum length (even number) + 1.
676 void ata_id_c_string(const u16 *id, unsigned char *s,
677 unsigned int ofs, unsigned int len)
683 ata_id_string(id, s, ofs, len - 1);
685 p = s + strnlen(s, len - 1);
686 while (p > s && p[-1] == ' ')
691 static u64 ata_id_n_sectors(const u16 *id)
693 if (ata_id_has_lba(id)) {
694 if (ata_id_has_lba48(id))
695 return ata_id_u64(id, 100);
697 return ata_id_u32(id, 60);
699 if (ata_id_current_chs_valid(id))
700 return ata_id_u32(id, 57);
702 return id[1] * id[3] * id[6];
707 * ata_noop_dev_select - Select device 0/1 on ATA bus
708 * @ap: ATA channel to manipulate
709 * @device: ATA device (numbered from zero) to select
711 * This function performs no actual function.
713 * May be used as the dev_select() entry in ata_port_operations.
718 void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
724 * ata_std_dev_select - Select device 0/1 on ATA bus
725 * @ap: ATA channel to manipulate
726 * @device: ATA device (numbered from zero) to select
728 * Use the method defined in the ATA specification to
729 * make either device 0, or device 1, active on the
730 * ATA channel. Works with both PIO and MMIO.
732 * May be used as the dev_select() entry in ata_port_operations.
738 void ata_std_dev_select (struct ata_port *ap, unsigned int device)
743 tmp = ATA_DEVICE_OBS;
745 tmp = ATA_DEVICE_OBS | ATA_DEV1;
747 if (ap->flags & ATA_FLAG_MMIO) {
748 writeb(tmp, (void __iomem *) ap->ioaddr.device_addr);
750 outb(tmp, ap->ioaddr.device_addr);
752 ata_pause(ap); /* needed; also flushes, for mmio */
756 * ata_dev_select - Select device 0/1 on ATA bus
757 * @ap: ATA channel to manipulate
758 * @device: ATA device (numbered from zero) to select
759 * @wait: non-zero to wait for Status register BSY bit to clear
760 * @can_sleep: non-zero if context allows sleeping
762 * Use the method defined in the ATA specification to
763 * make either device 0, or device 1, active on the
766 * This is a high-level version of ata_std_dev_select(),
767 * which additionally provides the services of inserting
768 * the proper pauses and status polling, where needed.
774 void ata_dev_select(struct ata_port *ap, unsigned int device,
775 unsigned int wait, unsigned int can_sleep)
777 VPRINTK("ENTER, ata%u: device %u, wait %u\n",
778 ap->id, device, wait);
783 ap->ops->dev_select(ap, device);
786 if (can_sleep && ap->device[device].class == ATA_DEV_ATAPI)
793 * ata_dump_id - IDENTIFY DEVICE info debugging output
794 * @id: IDENTIFY DEVICE page to dump
796 * Dump selected 16-bit words from the given IDENTIFY DEVICE
803 static inline void ata_dump_id(const u16 *id)
805 DPRINTK("49==0x%04x "
815 DPRINTK("80==0x%04x "
825 DPRINTK("88==0x%04x "
832 * ata_id_xfermask - Compute xfermask from the given IDENTIFY data
833 * @id: IDENTIFY data to compute xfer mask from
835 * Compute the xfermask for this device. This is not as trivial
836 * as it seems if we must consider early devices correctly.
838 * FIXME: pre IDE drive timing (do we care ?).
846 static unsigned int ata_id_xfermask(const u16 *id)
848 unsigned int pio_mask, mwdma_mask, udma_mask;
850 /* Usual case. Word 53 indicates word 64 is valid */
851 if (id[ATA_ID_FIELD_VALID] & (1 << 1)) {
852 pio_mask = id[ATA_ID_PIO_MODES] & 0x03;
856 /* If word 64 isn't valid then Word 51 high byte holds
857 * the PIO timing number for the maximum. Turn it into
860 pio_mask = (2 << (id[ATA_ID_OLD_PIO_MODES] & 0xFF)) - 1 ;
862 /* But wait.. there's more. Design your standards by
863 * committee and you too can get a free iordy field to
864 * process. However its the speeds not the modes that
865 * are supported... Note drivers using the timing API
866 * will get this right anyway
870 mwdma_mask = id[ATA_ID_MWDMA_MODES] & 0x07;
873 if (id[ATA_ID_FIELD_VALID] & (1 << 2))
874 udma_mask = id[ATA_ID_UDMA_MODES] & 0xff;
876 return ata_pack_xfermask(pio_mask, mwdma_mask, udma_mask);
880 * ata_port_queue_task - Queue port_task
881 * @ap: The ata_port to queue port_task for
883 * Schedule @fn(@data) for execution after @delay jiffies using
884 * port_task. There is one port_task per port and it's the
885 * user(low level driver)'s responsibility to make sure that only
886 * one task is active at any given time.
888 * libata core layer takes care of synchronization between
889 * port_task and EH. ata_port_queue_task() may be ignored for EH
893 * Inherited from caller.
895 void ata_port_queue_task(struct ata_port *ap, void (*fn)(void *), void *data,
900 if (ap->flags & ATA_FLAG_FLUSH_PORT_TASK)
903 PREPARE_WORK(&ap->port_task, fn, data);
906 rc = queue_work(ata_wq, &ap->port_task);
908 rc = queue_delayed_work(ata_wq, &ap->port_task, delay);
910 /* rc == 0 means that another user is using port task */
915 * ata_port_flush_task - Flush port_task
916 * @ap: The ata_port to flush port_task for
918 * After this function completes, port_task is guranteed not to
919 * be running or scheduled.
922 * Kernel thread context (may sleep)
924 void ata_port_flush_task(struct ata_port *ap)
930 spin_lock_irqsave(&ap->host_set->lock, flags);
931 ap->flags |= ATA_FLAG_FLUSH_PORT_TASK;
932 spin_unlock_irqrestore(&ap->host_set->lock, flags);
934 DPRINTK("flush #1\n");
935 flush_workqueue(ata_wq);
938 * At this point, if a task is running, it's guaranteed to see
939 * the FLUSH flag; thus, it will never queue pio tasks again.
942 if (!cancel_delayed_work(&ap->port_task)) {
943 DPRINTK("flush #2\n");
944 flush_workqueue(ata_wq);
947 spin_lock_irqsave(&ap->host_set->lock, flags);
948 ap->flags &= ~ATA_FLAG_FLUSH_PORT_TASK;
949 spin_unlock_irqrestore(&ap->host_set->lock, flags);
954 void ata_qc_complete_internal(struct ata_queued_cmd *qc)
956 struct completion *waiting = qc->private_data;
958 qc->ap->ops->tf_read(qc->ap, &qc->tf);
963 * ata_exec_internal - execute libata internal command
964 * @ap: Port to which the command is sent
965 * @dev: Device to which the command is sent
966 * @tf: Taskfile registers for the command and the result
967 * @cdb: CDB for packet command
968 * @dma_dir: Data tranfer direction of the command
969 * @buf: Data buffer of the command
970 * @buflen: Length of data buffer
972 * Executes libata internal command with timeout. @tf contains
973 * command on entry and result on return. Timeout and error
974 * conditions are reported via return value. No recovery action
975 * is taken after a command times out. It's caller's duty to
976 * clean up after timeout.
979 * None. Should be called with kernel context, might sleep.
982 unsigned ata_exec_internal(struct ata_port *ap, struct ata_device *dev,
983 struct ata_taskfile *tf, const u8 *cdb,
984 int dma_dir, void *buf, unsigned int buflen)
986 u8 command = tf->command;
987 struct ata_queued_cmd *qc;
988 DECLARE_COMPLETION(wait);
990 unsigned int err_mask;
992 spin_lock_irqsave(&ap->host_set->lock, flags);
994 qc = ata_qc_new_init(ap, dev);
999 memcpy(qc->cdb, cdb, ATAPI_CDB_LEN);
1000 qc->dma_dir = dma_dir;
1001 if (dma_dir != DMA_NONE) {
1002 ata_sg_init_one(qc, buf, buflen);
1003 qc->nsect = buflen / ATA_SECT_SIZE;
1006 qc->private_data = &wait;
1007 qc->complete_fn = ata_qc_complete_internal;
1011 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1013 if (!wait_for_completion_timeout(&wait, ATA_TMOUT_INTERNAL)) {
1014 ata_port_flush_task(ap);
1016 spin_lock_irqsave(&ap->host_set->lock, flags);
1018 /* We're racing with irq here. If we lose, the
1019 * following test prevents us from completing the qc
1020 * again. If completion irq occurs after here but
1021 * before the caller cleans up, it will result in a
1022 * spurious interrupt. We can live with that.
1024 if (qc->flags & ATA_QCFLAG_ACTIVE) {
1025 qc->err_mask = AC_ERR_TIMEOUT;
1026 ata_qc_complete(qc);
1027 printk(KERN_WARNING "ata%u: qc timeout (cmd 0x%x)\n",
1031 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1035 spin_lock_irqsave(&ap->host_set->lock, flags);
1038 err_mask = qc->err_mask;
1042 /* XXX - Some LLDDs (sata_mv) disable port on command failure.
1043 * Until those drivers are fixed, we detect the condition
1044 * here, fail the command with AC_ERR_SYSTEM and reenable the
1047 * Note that this doesn't change any behavior as internal
1048 * command failure results in disabling the device in the
1049 * higher layer for LLDDs without new reset/EH callbacks.
1051 * Kill the following code as soon as those drivers are fixed.
1053 if (ap->flags & ATA_FLAG_DISABLED) {
1054 err_mask |= AC_ERR_SYSTEM;
1058 spin_unlock_irqrestore(&ap->host_set->lock, flags);
1064 * ata_pio_need_iordy - check if iordy needed
1067 * Check if the current speed of the device requires IORDY. Used
1068 * by various controllers for chip configuration.
1071 unsigned int ata_pio_need_iordy(const struct ata_device *adev)
1074 int speed = adev->pio_mode - XFER_PIO_0;
1081 /* If we have no drive specific rule, then PIO 2 is non IORDY */
1083 if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE */
1084 pio = adev->id[ATA_ID_EIDE_PIO];
1085 /* Is the speed faster than the drive allows non IORDY ? */
1087 /* This is cycle times not frequency - watch the logic! */
1088 if (pio > 240) /* PIO2 is 240nS per cycle */
1097 * ata_dev_read_id - Read ID data from the specified device
1098 * @ap: port on which target device resides
1099 * @dev: target device
1100 * @p_class: pointer to class of the target device (may be changed)
1101 * @post_reset: is this read ID post-reset?
1102 * @id: buffer to read IDENTIFY data into
1104 * Read ID data from the specified device. ATA_CMD_ID_ATA is
1105 * performed on ATA devices and ATA_CMD_ID_ATAPI on ATAPI
1106 * devices. This function also issues ATA_CMD_INIT_DEV_PARAMS
1107 * for pre-ATA4 drives.
1110 * Kernel thread context (may sleep)
1113 * 0 on success, -errno otherwise.
1115 static int ata_dev_read_id(struct ata_port *ap, struct ata_device *dev,
1116 unsigned int *p_class, int post_reset, u16 *id)
1118 unsigned int class = *p_class;
1119 struct ata_taskfile tf;
1120 unsigned int err_mask = 0;
1124 DPRINTK("ENTER, host %u, dev %u\n", ap->id, dev->devno);
1126 ata_dev_select(ap, dev->devno, 1, 1); /* select device 0/1 */
1129 ata_tf_init(ap, &tf, dev->devno);
1133 tf.command = ATA_CMD_ID_ATA;
1136 tf.command = ATA_CMD_ID_ATAPI;
1140 reason = "unsupported class";
1144 tf.protocol = ATA_PROT_PIO;
1146 err_mask = ata_exec_internal(ap, dev, &tf, NULL, DMA_FROM_DEVICE,
1147 id, sizeof(id[0]) * ATA_ID_WORDS);
1150 reason = "I/O error";
1154 swap_buf_le16(id, ATA_ID_WORDS);
1157 if ((class == ATA_DEV_ATA) != (ata_id_is_ata(id) | ata_id_is_cfa(id))) {
1159 reason = "device reports illegal type";
1163 if (post_reset && class == ATA_DEV_ATA) {
1165 * The exact sequence expected by certain pre-ATA4 drives is:
1168 * INITIALIZE DEVICE PARAMETERS
1170 * Some drives were very specific about that exact sequence.
1172 if (ata_id_major_version(id) < 4 || !ata_id_has_lba(id)) {
1173 err_mask = ata_dev_init_params(ap, dev, id[3], id[6]);
1176 reason = "INIT_DEV_PARAMS failed";
1180 /* current CHS translation info (id[53-58]) might be
1181 * changed. reread the identify device info.
1193 printk(KERN_WARNING "ata%u: dev %u failed to IDENTIFY (%s)\n",
1194 ap->id, dev->devno, reason);
1198 static inline u8 ata_dev_knobble(const struct ata_port *ap,
1199 struct ata_device *dev)
1201 return ((ap->cbl == ATA_CBL_SATA) && (!ata_id_is_sata(dev->id)));
1205 * ata_dev_configure - Configure the specified ATA/ATAPI device
1206 * @ap: Port on which target device resides
1207 * @dev: Target device to configure
1208 * @print_info: Enable device info printout
1210 * Configure @dev according to @dev->id. Generic and low-level
1211 * driver specific fixups are also applied.
1214 * Kernel thread context (may sleep)
1217 * 0 on success, -errno otherwise
1219 static int ata_dev_configure(struct ata_port *ap, struct ata_device *dev,
1222 const u16 *id = dev->id;
1223 unsigned int xfer_mask;
1226 if (!ata_dev_enabled(dev)) {
1227 DPRINTK("ENTER/EXIT (host %u, dev %u) -- nodev\n",
1228 ap->id, dev->devno);
1232 DPRINTK("ENTER, host %u, dev %u\n", ap->id, dev->devno);
1234 /* print device capabilities */
1236 printk(KERN_DEBUG "ata%u: dev %u cfg 49:%04x 82:%04x 83:%04x "
1237 "84:%04x 85:%04x 86:%04x 87:%04x 88:%04x\n",
1238 ap->id, dev->devno, id[49], id[82], id[83],
1239 id[84], id[85], id[86], id[87], id[88]);
1241 /* initialize to-be-configured parameters */
1242 dev->flags &= ~ATA_DFLAG_CFG_MASK;
1243 dev->max_sectors = 0;
1251 * common ATA, ATAPI feature tests
1254 /* find max transfer mode; for printk only */
1255 xfer_mask = ata_id_xfermask(id);
1259 /* ATA-specific feature tests */
1260 if (dev->class == ATA_DEV_ATA) {
1261 dev->n_sectors = ata_id_n_sectors(id);
1263 if (ata_id_has_lba(id)) {
1264 const char *lba_desc;
1267 dev->flags |= ATA_DFLAG_LBA;
1268 if (ata_id_has_lba48(id)) {
1269 dev->flags |= ATA_DFLAG_LBA48;
1273 /* print device info to dmesg */
1275 printk(KERN_INFO "ata%u: dev %u ATA-%d, "
1276 "max %s, %Lu sectors: %s\n",
1278 ata_id_major_version(id),
1279 ata_mode_string(xfer_mask),
1280 (unsigned long long)dev->n_sectors,
1285 /* Default translation */
1286 dev->cylinders = id[1];
1288 dev->sectors = id[6];
1290 if (ata_id_current_chs_valid(id)) {
1291 /* Current CHS translation is valid. */
1292 dev->cylinders = id[54];
1293 dev->heads = id[55];
1294 dev->sectors = id[56];
1297 /* print device info to dmesg */
1299 printk(KERN_INFO "ata%u: dev %u ATA-%d, "
1300 "max %s, %Lu sectors: CHS %u/%u/%u\n",
1302 ata_id_major_version(id),
1303 ata_mode_string(xfer_mask),
1304 (unsigned long long)dev->n_sectors,
1305 dev->cylinders, dev->heads, dev->sectors);
1311 /* ATAPI-specific feature tests */
1312 else if (dev->class == ATA_DEV_ATAPI) {
1313 rc = atapi_cdb_len(id);
1314 if ((rc < 12) || (rc > ATAPI_CDB_LEN)) {
1315 printk(KERN_WARNING "ata%u: unsupported CDB len\n", ap->id);
1319 dev->cdb_len = (unsigned int) rc;
1321 /* print device info to dmesg */
1323 printk(KERN_INFO "ata%u: dev %u ATAPI, max %s\n",
1324 ap->id, dev->devno, ata_mode_string(xfer_mask));
1327 ap->host->max_cmd_len = 0;
1328 for (i = 0; i < ATA_MAX_DEVICES; i++)
1329 ap->host->max_cmd_len = max_t(unsigned int,
1330 ap->host->max_cmd_len,
1331 ap->device[i].cdb_len);
1333 /* limit bridge transfers to udma5, 200 sectors */
1334 if (ata_dev_knobble(ap, dev)) {
1336 printk(KERN_INFO "ata%u(%u): applying bridge limits\n",
1337 ap->id, dev->devno);
1338 dev->udma_mask &= ATA_UDMA5;
1339 dev->max_sectors = ATA_MAX_SECTORS;
1342 if (ap->ops->dev_config)
1343 ap->ops->dev_config(ap, dev);
1345 DPRINTK("EXIT, drv_stat = 0x%x\n", ata_chk_status(ap));
1349 DPRINTK("EXIT, err\n");
1354 * ata_bus_probe - Reset and probe ATA bus
1357 * Master ATA bus probing function. Initiates a hardware-dependent
1358 * bus reset, then attempts to identify any devices found on
1362 * PCI/etc. bus probe sem.
1365 * Zero on success, negative errno otherwise.
1368 static int ata_bus_probe(struct ata_port *ap)
1370 unsigned int classes[ATA_MAX_DEVICES];
1371 int tries[ATA_MAX_DEVICES];
1372 int i, rc, down_xfermask;
1373 struct ata_device *dev;
1377 for (i = 0; i < ATA_MAX_DEVICES; i++)
1378 tries[i] = ATA_PROBE_MAX_TRIES;
1383 /* reset and determine device classes */
1384 for (i = 0; i < ATA_MAX_DEVICES; i++)
1385 classes[i] = ATA_DEV_UNKNOWN;
1387 if (ap->ops->probe_reset) {
1388 rc = ap->ops->probe_reset(ap, classes);
1390 printk("ata%u: reset failed (errno=%d)\n", ap->id, rc);
1394 ap->ops->phy_reset(ap);
1396 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1397 if (!(ap->flags & ATA_FLAG_DISABLED))
1398 classes[i] = ap->device[i].class;
1399 ap->device[i].class = ATA_DEV_UNKNOWN;
1405 for (i = 0; i < ATA_MAX_DEVICES; i++)
1406 if (classes[i] == ATA_DEV_UNKNOWN)
1407 classes[i] = ATA_DEV_NONE;
1409 /* read IDENTIFY page and configure devices */
1410 for (i = 0; i < ATA_MAX_DEVICES; i++) {
1411 dev = &ap->device[i];
1414 dev->class = classes[i];
1416 if (!ata_dev_enabled(dev))
1419 rc = ata_dev_read_id(ap, dev, &dev->class, 1, dev->id);
1423 rc = ata_dev_configure(ap, dev, 1);
1428 /* configure transfer mode */
1429 if (ap->ops->set_mode) {
1430 /* FIXME: make ->set_mode handle no device case and
1431 * return error code and failing device on failure as
1432 * ata_set_mode() does.
1434 for (i = 0; i < ATA_MAX_DEVICES; i++)
1435 if (ata_dev_enabled(&ap->device[i])) {
1436 ap->ops->set_mode(ap);
1441 rc = ata_set_mode(ap, &dev);
1448 for (i = 0; i < ATA_MAX_DEVICES; i++)
1449 if (ata_dev_enabled(&ap->device[i]))
1452 /* no device present, disable port */
1453 ata_port_disable(ap);
1454 ap->ops->port_disable(ap);
1461 tries[dev->devno] = 0;
1464 sata_down_spd_limit(ap);
1467 tries[dev->devno]--;
1468 if (down_xfermask &&
1469 ata_down_xfermask_limit(ap, dev, tries[dev->devno] == 1))
1470 tries[dev->devno] = 0;
1473 if (!tries[dev->devno]) {
1474 ata_down_xfermask_limit(ap, dev, 1);
1475 ata_dev_disable(ap, dev);
1482 * ata_port_probe - Mark port as enabled
1483 * @ap: Port for which we indicate enablement
1485 * Modify @ap data structure such that the system
1486 * thinks that the entire port is enabled.
1488 * LOCKING: host_set lock, or some other form of
1492 void ata_port_probe(struct ata_port *ap)
1494 ap->flags &= ~ATA_FLAG_DISABLED;
1498 * sata_print_link_status - Print SATA link status
1499 * @ap: SATA port to printk link status about
1501 * This function prints link speed and status of a SATA link.
1506 static void sata_print_link_status(struct ata_port *ap)
1508 u32 sstatus, scontrol, tmp;
1510 if (!ap->ops->scr_read)
1513 sstatus = scr_read(ap, SCR_STATUS);
1514 scontrol = scr_read(ap, SCR_CONTROL);
1516 if (sata_dev_present(ap)) {
1517 tmp = (sstatus >> 4) & 0xf;
1519 "ata%u: SATA link up %s (SStatus %X SControl %X)\n",
1520 ap->id, sata_spd_string(tmp), sstatus, scontrol);
1523 "ata%u: SATA link down (SStatus %X SControl %X)\n",
1524 ap->id, sstatus, scontrol);
1529 * __sata_phy_reset - Wake/reset a low-level SATA PHY
1530 * @ap: SATA port associated with target SATA PHY.
1532 * This function issues commands to standard SATA Sxxx
1533 * PHY registers, to wake up the phy (and device), and
1534 * clear any reset condition.
1537 * PCI/etc. bus probe sem.
1540 void __sata_phy_reset(struct ata_port *ap)
1543 unsigned long timeout = jiffies + (HZ * 5);
1545 if (ap->flags & ATA_FLAG_SATA_RESET) {
1546 /* issue phy wake/reset */
1547 scr_write_flush(ap, SCR_CONTROL, 0x301);
1548 /* Couldn't find anything in SATA I/II specs, but
1549 * AHCI-1.1 10.4.2 says at least 1 ms. */
1552 scr_write_flush(ap, SCR_CONTROL, 0x300); /* phy wake/clear reset */
1554 /* wait for phy to become ready, if necessary */
1557 sstatus = scr_read(ap, SCR_STATUS);
1558 if ((sstatus & 0xf) != 1)
1560 } while (time_before(jiffies, timeout));
1562 /* print link status */
1563 sata_print_link_status(ap);
1565 /* TODO: phy layer with polling, timeouts, etc. */
1566 if (sata_dev_present(ap))
1569 ata_port_disable(ap);
1571 if (ap->flags & ATA_FLAG_DISABLED)
1574 if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
1575 ata_port_disable(ap);
1579 ap->cbl = ATA_CBL_SATA;
1583 * sata_phy_reset - Reset SATA bus.
1584 * @ap: SATA port associated with target SATA PHY.
1586 * This function resets the SATA bus, and then probes
1587 * the bus for devices.
1590 * PCI/etc. bus probe sem.
1593 void sata_phy_reset(struct ata_port *ap)
1595 __sata_phy_reset(ap);
1596 if (ap->flags & ATA_FLAG_DISABLED)
1602 * ata_dev_pair - return other device on cable
1606 * Obtain the other device on the same cable, or if none is
1607 * present NULL is returned
1610 struct ata_device *ata_dev_pair(struct ata_port *ap, struct ata_device *adev)
1612 struct ata_device *pair = &ap->device[1 - adev->devno];
1613 if (!ata_dev_enabled(pair))
1619 * ata_port_disable - Disable port.
1620 * @ap: Port to be disabled.
1622 * Modify @ap data structure such that the system
1623 * thinks that the entire port is disabled, and should
1624 * never attempt to probe or communicate with devices
1627 * LOCKING: host_set lock, or some other form of
1631 void ata_port_disable(struct ata_port *ap)
1633 ap->device[0].class = ATA_DEV_NONE;
1634 ap->device[1].class = ATA_DEV_NONE;
1635 ap->flags |= ATA_FLAG_DISABLED;
1639 * sata_down_spd_limit - adjust SATA spd limit downward
1640 * @ap: Port to adjust SATA spd limit for
1642 * Adjust SATA spd limit of @ap downward. Note that this
1643 * function only adjusts the limit. The change must be applied
1644 * using sata_set_spd().
1647 * Inherited from caller.
1650 * 0 on success, negative errno on failure
1652 int sata_down_spd_limit(struct ata_port *ap)
1657 if (ap->cbl != ATA_CBL_SATA || !ap->ops->scr_read)
1660 mask = ap->sata_spd_limit;
1663 highbit = fls(mask) - 1;
1664 mask &= ~(1 << highbit);
1666 spd = (scr_read(ap, SCR_STATUS) >> 4) & 0xf;
1670 mask &= (1 << spd) - 1;
1674 ap->sata_spd_limit = mask;
1676 printk(KERN_WARNING "ata%u: limiting SATA link speed to %s\n",
1677 ap->id, sata_spd_string(fls(mask)));
1682 static int __sata_set_spd_needed(struct ata_port *ap, u32 *scontrol)
1686 if (ap->sata_spd_limit == UINT_MAX)
1689 limit = fls(ap->sata_spd_limit);
1691 spd = (*scontrol >> 4) & 0xf;
1692 *scontrol = (*scontrol & ~0xf0) | ((limit & 0xf) << 4);
1694 return spd != limit;
1698 * sata_set_spd_needed - is SATA spd configuration needed
1699 * @ap: Port in question
1701 * Test whether the spd limit in SControl matches
1702 * @ap->sata_spd_limit. This function is used to determine
1703 * whether hardreset is necessary to apply SATA spd
1707 * Inherited from caller.
1710 * 1 if SATA spd configuration is needed, 0 otherwise.
1712 int sata_set_spd_needed(struct ata_port *ap)
1716 if (ap->cbl != ATA_CBL_SATA || !ap->ops->scr_read)
1719 scontrol = scr_read(ap, SCR_CONTROL);
1721 return __sata_set_spd_needed(ap, &scontrol);
1725 * sata_set_spd - set SATA spd according to spd limit
1726 * @ap: Port to set SATA spd for
1728 * Set SATA spd of @ap according to sata_spd_limit.
1731 * Inherited from caller.
1734 * 0 if spd doesn't need to be changed, 1 if spd has been
1735 * changed. -EOPNOTSUPP if SCR registers are inaccessible.
1737 int sata_set_spd(struct ata_port *ap)
1741 if (ap->cbl != ATA_CBL_SATA || !ap->ops->scr_read)
1744 scontrol = scr_read(ap, SCR_CONTROL);
1745 if (!__sata_set_spd_needed(ap, &scontrol))
1748 scr_write(ap, SCR_CONTROL, scontrol);
1753 * This mode timing computation functionality is ported over from
1754 * drivers/ide/ide-timing.h and was originally written by Vojtech Pavlik
1757 * PIO 0-5, MWDMA 0-2 and UDMA 0-6 timings (in nanoseconds).
1758 * These were taken from ATA/ATAPI-6 standard, rev 0a, except
1759 * for PIO 5, which is a nonstandard extension and UDMA6, which
1760 * is currently supported only by Maxtor drives.
1763 static const struct ata_timing ata_timing[] = {
1765 { XFER_UDMA_6, 0, 0, 0, 0, 0, 0, 0, 15 },
1766 { XFER_UDMA_5, 0, 0, 0, 0, 0, 0, 0, 20 },
1767 { XFER_UDMA_4, 0, 0, 0, 0, 0, 0, 0, 30 },
1768 { XFER_UDMA_3, 0, 0, 0, 0, 0, 0, 0, 45 },
1770 { XFER_UDMA_2, 0, 0, 0, 0, 0, 0, 0, 60 },
1771 { XFER_UDMA_1, 0, 0, 0, 0, 0, 0, 0, 80 },
1772 { XFER_UDMA_0, 0, 0, 0, 0, 0, 0, 0, 120 },
1774 /* { XFER_UDMA_SLOW, 0, 0, 0, 0, 0, 0, 0, 150 }, */
1776 { XFER_MW_DMA_2, 25, 0, 0, 0, 70, 25, 120, 0 },
1777 { XFER_MW_DMA_1, 45, 0, 0, 0, 80, 50, 150, 0 },
1778 { XFER_MW_DMA_0, 60, 0, 0, 0, 215, 215, 480, 0 },
1780 { XFER_SW_DMA_2, 60, 0, 0, 0, 120, 120, 240, 0 },
1781 { XFER_SW_DMA_1, 90, 0, 0, 0, 240, 240, 480, 0 },
1782 { XFER_SW_DMA_0, 120, 0, 0, 0, 480, 480, 960, 0 },
1784 /* { XFER_PIO_5, 20, 50, 30, 100, 50, 30, 100, 0 }, */
1785 { XFER_PIO_4, 25, 70, 25, 120, 70, 25, 120, 0 },
1786 { XFER_PIO_3, 30, 80, 70, 180, 80, 70, 180, 0 },
1788 { XFER_PIO_2, 30, 290, 40, 330, 100, 90, 240, 0 },
1789 { XFER_PIO_1, 50, 290, 93, 383, 125, 100, 383, 0 },
1790 { XFER_PIO_0, 70, 290, 240, 600, 165, 150, 600, 0 },
1792 /* { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960, 0 }, */
1797 #define ENOUGH(v,unit) (((v)-1)/(unit)+1)
1798 #define EZ(v,unit) ((v)?ENOUGH(v,unit):0)
1800 static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT)
1802 q->setup = EZ(t->setup * 1000, T);
1803 q->act8b = EZ(t->act8b * 1000, T);
1804 q->rec8b = EZ(t->rec8b * 1000, T);
1805 q->cyc8b = EZ(t->cyc8b * 1000, T);
1806 q->active = EZ(t->active * 1000, T);
1807 q->recover = EZ(t->recover * 1000, T);
1808 q->cycle = EZ(t->cycle * 1000, T);
1809 q->udma = EZ(t->udma * 1000, UT);
1812 void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
1813 struct ata_timing *m, unsigned int what)
1815 if (what & ATA_TIMING_SETUP ) m->setup = max(a->setup, b->setup);
1816 if (what & ATA_TIMING_ACT8B ) m->act8b = max(a->act8b, b->act8b);
1817 if (what & ATA_TIMING_REC8B ) m->rec8b = max(a->rec8b, b->rec8b);
1818 if (what & ATA_TIMING_CYC8B ) m->cyc8b = max(a->cyc8b, b->cyc8b);
1819 if (what & ATA_TIMING_ACTIVE ) m->active = max(a->active, b->active);
1820 if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover);
1821 if (what & ATA_TIMING_CYCLE ) m->cycle = max(a->cycle, b->cycle);
1822 if (what & ATA_TIMING_UDMA ) m->udma = max(a->udma, b->udma);
1825 static const struct ata_timing* ata_timing_find_mode(unsigned short speed)
1827 const struct ata_timing *t;
1829 for (t = ata_timing; t->mode != speed; t++)
1830 if (t->mode == 0xFF)
1835 int ata_timing_compute(struct ata_device *adev, unsigned short speed,
1836 struct ata_timing *t, int T, int UT)
1838 const struct ata_timing *s;
1839 struct ata_timing p;
1845 if (!(s = ata_timing_find_mode(speed)))
1848 memcpy(t, s, sizeof(*s));
1851 * If the drive is an EIDE drive, it can tell us it needs extended
1852 * PIO/MW_DMA cycle timing.
1855 if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */
1856 memset(&p, 0, sizeof(p));
1857 if(speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) {
1858 if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO];
1859 else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY];
1860 } else if(speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) {
1861 p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN];
1863 ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B);
1867 * Convert the timing to bus clock counts.
1870 ata_timing_quantize(t, t, T, UT);
1873 * Even in DMA/UDMA modes we still use PIO access for IDENTIFY,
1874 * S.M.A.R.T * and some other commands. We have to ensure that the
1875 * DMA cycle timing is slower/equal than the fastest PIO timing.
1878 if (speed > XFER_PIO_4) {
1879 ata_timing_compute(adev, adev->pio_mode, &p, T, UT);
1880 ata_timing_merge(&p, t, t, ATA_TIMING_ALL);
1884 * Lengthen active & recovery time so that cycle time is correct.
1887 if (t->act8b + t->rec8b < t->cyc8b) {
1888 t->act8b += (t->cyc8b - (t->act8b + t->rec8b)) / 2;
1889 t->rec8b = t->cyc8b - t->act8b;
1892 if (t->active + t->recover < t->cycle) {
1893 t->active += (t->cycle - (t->active + t->recover)) / 2;
1894 t->recover = t->cycle - t->active;
1901 * ata_down_xfermask_limit - adjust dev xfer masks downward
1902 * @ap: Port associated with device @dev
1903 * @dev: Device to adjust xfer masks
1904 * @force_pio0: Force PIO0
1906 * Adjust xfer masks of @dev downward. Note that this function
1907 * does not apply the change. Invoking ata_set_mode() afterwards
1908 * will apply the limit.
1911 * Inherited from caller.
1914 * 0 on success, negative errno on failure
1916 int ata_down_xfermask_limit(struct ata_port *ap, struct ata_device *dev,
1919 unsigned long xfer_mask;
1922 xfer_mask = ata_pack_xfermask(dev->pio_mask, dev->mwdma_mask,
1927 /* don't gear down to MWDMA from UDMA, go directly to PIO */
1928 if (xfer_mask & ATA_MASK_UDMA)
1929 xfer_mask &= ~ATA_MASK_MWDMA;
1931 highbit = fls(xfer_mask) - 1;
1932 xfer_mask &= ~(1 << highbit);
1934 xfer_mask &= 1 << ATA_SHIFT_PIO;
1938 ata_unpack_xfermask(xfer_mask, &dev->pio_mask, &dev->mwdma_mask,
1941 printk(KERN_WARNING "ata%u: dev %u limiting speed to %s\n",
1942 ap->id, dev->devno, ata_mode_string(xfer_mask));
1950 static int ata_dev_set_mode(struct ata_port *ap, struct ata_device *dev)
1952 unsigned int err_mask;
1955 dev->flags &= ~ATA_DFLAG_PIO;
1956 if (dev->xfer_shift == ATA_SHIFT_PIO)
1957 dev->flags |= ATA_DFLAG_PIO;
1959 err_mask = ata_dev_set_xfermode(ap, dev);
1962 "ata%u: failed to set xfermode (err_mask=0x%x)\n",
1967 rc = ata_dev_revalidate(ap, dev, 0);
1971 DPRINTK("xfer_shift=%u, xfer_mode=0x%x\n",
1972 dev->xfer_shift, (int)dev->xfer_mode);
1974 printk(KERN_INFO "ata%u: dev %u configured for %s\n",
1976 ata_mode_string(ata_xfer_mode2mask(dev->xfer_mode)));
1981 * ata_set_mode - Program timings and issue SET FEATURES - XFER
1982 * @ap: port on which timings will be programmed
1983 * @r_failed_dev: out paramter for failed device
1985 * Set ATA device disk transfer mode (PIO3, UDMA6, etc.). If
1986 * ata_set_mode() fails, pointer to the failing device is
1987 * returned in @r_failed_dev.
1990 * PCI/etc. bus probe sem.
1993 * 0 on success, negative errno otherwise
1995 int ata_set_mode(struct ata_port *ap, struct ata_device **r_failed_dev)
1997 struct ata_device *dev;
1998 int i, rc = 0, used_dma = 0, found = 0;
2000 /* step 1: calculate xfer_mask */
2001 for (i = 0; i < ATA_MAX_DEVICES; i++) {
2002 unsigned int pio_mask, dma_mask;
2004 dev = &ap->device[i];
2006 if (!ata_dev_enabled(dev))
2009 ata_dev_xfermask(ap, dev);
2011 pio_mask = ata_pack_xfermask(dev->pio_mask, 0, 0);
2012 dma_mask = ata_pack_xfermask(0, dev->mwdma_mask, dev->udma_mask);
2013 dev->pio_mode = ata_xfer_mask2mode(pio_mask);
2014 dev->dma_mode = ata_xfer_mask2mode(dma_mask);
2023 /* step 2: always set host PIO timings */
2024 for (i = 0; i < ATA_MAX_DEVICES; i++) {
2025 dev = &ap->device[i];
2026 if (!ata_dev_enabled(dev))
2029 if (!dev->pio_mode) {
2030 printk(KERN_WARNING "ata%u: dev %u no PIO support\n",
2031 ap->id, dev->devno);
2036 dev->xfer_mode = dev->pio_mode;
2037 dev->xfer_shift = ATA_SHIFT_PIO;
2038 if (ap->ops->set_piomode)
2039 ap->ops->set_piomode(ap, dev);
2042 /* step 3: set host DMA timings */
2043 for (i = 0; i < ATA_MAX_DEVICES; i++) {
2044 dev = &ap->device[i];
2046 if (!ata_dev_enabled(dev) || !dev->dma_mode)
2049 dev->xfer_mode = dev->dma_mode;
2050 dev->xfer_shift = ata_xfer_mode2shift(dev->dma_mode);
2051 if (ap->ops->set_dmamode)
2052 ap->ops->set_dmamode(ap, dev);
2055 /* step 4: update devices' xfer mode */
2056 for (i = 0; i < ATA_MAX_DEVICES; i++) {
2057 dev = &ap->device[i];
2059 if (!ata_dev_enabled(dev))
2062 rc = ata_dev_set_mode(ap, dev);
2067 /* Record simplex status. If we selected DMA then the other
2068 * host channels are not permitted to do so.
2070 if (used_dma && (ap->host_set->flags & ATA_HOST_SIMPLEX))
2071 ap->host_set->simplex_claimed = 1;
2073 /* step5: chip specific finalisation */
2074 if (ap->ops->post_set_mode)
2075 ap->ops->post_set_mode(ap);
2079 *r_failed_dev = dev;
2084 * ata_tf_to_host - issue ATA taskfile to host controller
2085 * @ap: port to which command is being issued
2086 * @tf: ATA taskfile register set
2088 * Issues ATA taskfile register set to ATA host controller,
2089 * with proper synchronization with interrupt handler and
2093 * spin_lock_irqsave(host_set lock)
2096 static inline void ata_tf_to_host(struct ata_port *ap,
2097 const struct ata_taskfile *tf)
2099 ap->ops->tf_load(ap, tf);
2100 ap->ops->exec_command(ap, tf);
2104 * ata_busy_sleep - sleep until BSY clears, or timeout
2105 * @ap: port containing status register to be polled
2106 * @tmout_pat: impatience timeout
2107 * @tmout: overall timeout
2109 * Sleep until ATA Status register bit BSY clears,
2110 * or a timeout occurs.
2115 unsigned int ata_busy_sleep (struct ata_port *ap,
2116 unsigned long tmout_pat, unsigned long tmout)
2118 unsigned long timer_start, timeout;
2121 status = ata_busy_wait(ap, ATA_BUSY, 300);
2122 timer_start = jiffies;
2123 timeout = timer_start + tmout_pat;
2124 while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
2126 status = ata_busy_wait(ap, ATA_BUSY, 3);
2129 if (status & ATA_BUSY)
2130 printk(KERN_WARNING "ata%u is slow to respond, "
2131 "please be patient\n", ap->id);
2133 timeout = timer_start + tmout;
2134 while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
2136 status = ata_chk_status(ap);
2139 if (status & ATA_BUSY) {
2140 printk(KERN_ERR "ata%u failed to respond (%lu secs)\n",
2141 ap->id, tmout / HZ);
2148 static void ata_bus_post_reset(struct ata_port *ap, unsigned int devmask)
2150 struct ata_ioports *ioaddr = &ap->ioaddr;
2151 unsigned int dev0 = devmask & (1 << 0);
2152 unsigned int dev1 = devmask & (1 << 1);
2153 unsigned long timeout;
2155 /* if device 0 was found in ata_devchk, wait for its
2159 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2161 /* if device 1 was found in ata_devchk, wait for
2162 * register access, then wait for BSY to clear
2164 timeout = jiffies + ATA_TMOUT_BOOT;
2168 ap->ops->dev_select(ap, 1);
2169 if (ap->flags & ATA_FLAG_MMIO) {
2170 nsect = readb((void __iomem *) ioaddr->nsect_addr);
2171 lbal = readb((void __iomem *) ioaddr->lbal_addr);
2173 nsect = inb(ioaddr->nsect_addr);
2174 lbal = inb(ioaddr->lbal_addr);
2176 if ((nsect == 1) && (lbal == 1))
2178 if (time_after(jiffies, timeout)) {
2182 msleep(50); /* give drive a breather */
2185 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2187 /* is all this really necessary? */
2188 ap->ops->dev_select(ap, 0);
2190 ap->ops->dev_select(ap, 1);
2192 ap->ops->dev_select(ap, 0);
2195 static unsigned int ata_bus_softreset(struct ata_port *ap,
2196 unsigned int devmask)
2198 struct ata_ioports *ioaddr = &ap->ioaddr;
2200 DPRINTK("ata%u: bus reset via SRST\n", ap->id);
2202 /* software reset. causes dev0 to be selected */
2203 if (ap->flags & ATA_FLAG_MMIO) {
2204 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2205 udelay(20); /* FIXME: flush */
2206 writeb(ap->ctl | ATA_SRST, (void __iomem *) ioaddr->ctl_addr);
2207 udelay(20); /* FIXME: flush */
2208 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2210 outb(ap->ctl, ioaddr->ctl_addr);
2212 outb(ap->ctl | ATA_SRST, ioaddr->ctl_addr);
2214 outb(ap->ctl, ioaddr->ctl_addr);
2217 /* spec mandates ">= 2ms" before checking status.
2218 * We wait 150ms, because that was the magic delay used for
2219 * ATAPI devices in Hale Landis's ATADRVR, for the period of time
2220 * between when the ATA command register is written, and then
2221 * status is checked. Because waiting for "a while" before
2222 * checking status is fine, post SRST, we perform this magic
2223 * delay here as well.
2225 * Old drivers/ide uses the 2mS rule and then waits for ready
2229 /* Before we perform post reset processing we want to see if
2230 * the bus shows 0xFF because the odd clown forgets the D7
2231 * pulldown resistor.
2233 if (ata_check_status(ap) == 0xFF) {
2234 printk(KERN_ERR "ata%u: SRST failed (status 0xFF)\n", ap->id);
2235 return AC_ERR_OTHER;
2238 ata_bus_post_reset(ap, devmask);
2244 * ata_bus_reset - reset host port and associated ATA channel
2245 * @ap: port to reset
2247 * This is typically the first time we actually start issuing
2248 * commands to the ATA channel. We wait for BSY to clear, then
2249 * issue EXECUTE DEVICE DIAGNOSTIC command, polling for its
2250 * result. Determine what devices, if any, are on the channel
2251 * by looking at the device 0/1 error register. Look at the signature
2252 * stored in each device's taskfile registers, to determine if
2253 * the device is ATA or ATAPI.
2256 * PCI/etc. bus probe sem.
2257 * Obtains host_set lock.
2260 * Sets ATA_FLAG_DISABLED if bus reset fails.
2263 void ata_bus_reset(struct ata_port *ap)
2265 struct ata_ioports *ioaddr = &ap->ioaddr;
2266 unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
2268 unsigned int dev0, dev1 = 0, devmask = 0;
2270 DPRINTK("ENTER, host %u, port %u\n", ap->id, ap->port_no);
2272 /* determine if device 0/1 are present */
2273 if (ap->flags & ATA_FLAG_SATA_RESET)
2276 dev0 = ata_devchk(ap, 0);
2278 dev1 = ata_devchk(ap, 1);
2282 devmask |= (1 << 0);
2284 devmask |= (1 << 1);
2286 /* select device 0 again */
2287 ap->ops->dev_select(ap, 0);
2289 /* issue bus reset */
2290 if (ap->flags & ATA_FLAG_SRST)
2291 if (ata_bus_softreset(ap, devmask))
2295 * determine by signature whether we have ATA or ATAPI devices
2297 ap->device[0].class = ata_dev_try_classify(ap, 0, &err);
2298 if ((slave_possible) && (err != 0x81))
2299 ap->device[1].class = ata_dev_try_classify(ap, 1, &err);
2301 /* re-enable interrupts */
2302 if (ap->ioaddr.ctl_addr) /* FIXME: hack. create a hook instead */
2305 /* is double-select really necessary? */
2306 if (ap->device[1].class != ATA_DEV_NONE)
2307 ap->ops->dev_select(ap, 1);
2308 if (ap->device[0].class != ATA_DEV_NONE)
2309 ap->ops->dev_select(ap, 0);
2311 /* if no devices were detected, disable this port */
2312 if ((ap->device[0].class == ATA_DEV_NONE) &&
2313 (ap->device[1].class == ATA_DEV_NONE))
2316 if (ap->flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST)) {
2317 /* set up device control for ATA_FLAG_SATA_RESET */
2318 if (ap->flags & ATA_FLAG_MMIO)
2319 writeb(ap->ctl, (void __iomem *) ioaddr->ctl_addr);
2321 outb(ap->ctl, ioaddr->ctl_addr);
2328 printk(KERN_ERR "ata%u: disabling port\n", ap->id);
2329 ap->ops->port_disable(ap);
2334 static int sata_phy_resume(struct ata_port *ap)
2336 unsigned long timeout = jiffies + (HZ * 5);
2337 u32 scontrol, sstatus;
2339 scontrol = scr_read(ap, SCR_CONTROL);
2340 scontrol = (scontrol & 0x0f0) | 0x300;
2341 scr_write_flush(ap, SCR_CONTROL, scontrol);
2343 /* Wait for phy to become ready, if necessary. */
2346 sstatus = scr_read(ap, SCR_STATUS);
2347 if ((sstatus & 0xf) != 1)
2349 } while (time_before(jiffies, timeout));
2355 * ata_std_probeinit - initialize probing
2356 * @ap: port to be probed
2358 * @ap is about to be probed. Initialize it. This function is
2359 * to be used as standard callback for ata_drive_probe_reset().
2361 * NOTE!!! Do not use this function as probeinit if a low level
2362 * driver implements only hardreset. Just pass NULL as probeinit
2363 * in that case. Using this function is probably okay but doing
2364 * so makes reset sequence different from the original
2365 * ->phy_reset implementation and Jeff nervous. :-P
2367 void ata_std_probeinit(struct ata_port *ap)
2369 if ((ap->flags & ATA_FLAG_SATA) && ap->ops->scr_read) {
2372 /* set cable type and resume link */
2373 ap->cbl = ATA_CBL_SATA;
2374 sata_phy_resume(ap);
2376 /* init sata_spd_limit to the current value */
2377 spd = (scr_read(ap, SCR_CONTROL) & 0xf0) >> 4;
2379 ap->sata_spd_limit &= (1 << spd) - 1;
2381 /* wait for device */
2382 if (sata_dev_present(ap))
2383 ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT);
2388 * ata_std_softreset - reset host port via ATA SRST
2389 * @ap: port to reset
2390 * @classes: resulting classes of attached devices
2392 * Reset host port using ATA SRST. This function is to be used
2393 * as standard callback for ata_drive_*_reset() functions.
2396 * Kernel thread context (may sleep)
2399 * 0 on success, -errno otherwise.
2401 int ata_std_softreset(struct ata_port *ap, unsigned int *classes)
2403 unsigned int slave_possible = ap->flags & ATA_FLAG_SLAVE_POSS;
2404 unsigned int devmask = 0, err_mask;
2409 if (ap->ops->scr_read && !sata_dev_present(ap)) {
2410 classes[0] = ATA_DEV_NONE;
2414 /* determine if device 0/1 are present */
2415 if (ata_devchk(ap, 0))
2416 devmask |= (1 << 0);
2417 if (slave_possible && ata_devchk(ap, 1))
2418 devmask |= (1 << 1);
2420 /* select device 0 again */
2421 ap->ops->dev_select(ap, 0);
2423 /* issue bus reset */
2424 DPRINTK("about to softreset, devmask=%x\n", devmask);
2425 err_mask = ata_bus_softreset(ap, devmask);
2427 printk(KERN_ERR "ata%u: SRST failed (err_mask=0x%x)\n",
2432 /* determine by signature whether we have ATA or ATAPI devices */
2433 classes[0] = ata_dev_try_classify(ap, 0, &err);
2434 if (slave_possible && err != 0x81)
2435 classes[1] = ata_dev_try_classify(ap, 1, &err);
2438 DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
2443 * sata_std_hardreset - reset host port via SATA phy reset
2444 * @ap: port to reset
2445 * @class: resulting class of attached device
2447 * SATA phy-reset host port using DET bits of SControl register.
2448 * This function is to be used as standard callback for
2449 * ata_drive_*_reset().
2452 * Kernel thread context (may sleep)
2455 * 0 on success, -errno otherwise.
2457 int sata_std_hardreset(struct ata_port *ap, unsigned int *class)
2463 if (sata_set_spd_needed(ap)) {
2464 /* SATA spec says nothing about how to reconfigure
2465 * spd. To be on the safe side, turn off phy during
2466 * reconfiguration. This works for at least ICH7 AHCI
2469 scontrol = scr_read(ap, SCR_CONTROL);
2470 scontrol = (scontrol & 0x0f0) | 0x302;
2471 scr_write_flush(ap, SCR_CONTROL, scontrol);
2476 /* issue phy wake/reset */
2477 scontrol = scr_read(ap, SCR_CONTROL);
2478 scontrol = (scontrol & 0x0f0) | 0x301;
2479 scr_write_flush(ap, SCR_CONTROL, scontrol);
2481 /* Couldn't find anything in SATA I/II specs, but AHCI-1.1
2482 * 10.4.2 says at least 1 ms.
2486 /* bring phy back */
2487 sata_phy_resume(ap);
2489 /* TODO: phy layer with polling, timeouts, etc. */
2490 if (!sata_dev_present(ap)) {
2491 *class = ATA_DEV_NONE;
2492 DPRINTK("EXIT, link offline\n");
2496 if (ata_busy_sleep(ap, ATA_TMOUT_BOOT_QUICK, ATA_TMOUT_BOOT)) {
2498 "ata%u: COMRESET failed (device not ready)\n", ap->id);
2502 ap->ops->dev_select(ap, 0); /* probably unnecessary */
2504 *class = ata_dev_try_classify(ap, 0, NULL);
2506 DPRINTK("EXIT, class=%u\n", *class);
2511 * ata_std_postreset - standard postreset callback
2512 * @ap: the target ata_port
2513 * @classes: classes of attached devices
2515 * This function is invoked after a successful reset. Note that
2516 * the device might have been reset more than once using
2517 * different reset methods before postreset is invoked.
2519 * This function is to be used as standard callback for
2520 * ata_drive_*_reset().
2523 * Kernel thread context (may sleep)
2525 void ata_std_postreset(struct ata_port *ap, unsigned int *classes)
2529 /* print link status */
2530 if (ap->cbl == ATA_CBL_SATA)
2531 sata_print_link_status(ap);
2533 /* re-enable interrupts */
2534 if (ap->ioaddr.ctl_addr) /* FIXME: hack. create a hook instead */
2537 /* is double-select really necessary? */
2538 if (classes[0] != ATA_DEV_NONE)
2539 ap->ops->dev_select(ap, 1);
2540 if (classes[1] != ATA_DEV_NONE)
2541 ap->ops->dev_select(ap, 0);
2543 /* bail out if no device is present */
2544 if (classes[0] == ATA_DEV_NONE && classes[1] == ATA_DEV_NONE) {
2545 DPRINTK("EXIT, no device\n");
2549 /* set up device control */
2550 if (ap->ioaddr.ctl_addr) {
2551 if (ap->flags & ATA_FLAG_MMIO)
2552 writeb(ap->ctl, (void __iomem *) ap->ioaddr.ctl_addr);
2554 outb(ap->ctl, ap->ioaddr.ctl_addr);
2561 * ata_std_probe_reset - standard probe reset method
2562 * @ap: prot to perform probe-reset
2563 * @classes: resulting classes of attached devices
2565 * The stock off-the-shelf ->probe_reset method.
2568 * Kernel thread context (may sleep)
2571 * 0 on success, -errno otherwise.
2573 int ata_std_probe_reset(struct ata_port *ap, unsigned int *classes)
2575 ata_reset_fn_t hardreset;
2578 if (ap->cbl == ATA_CBL_SATA && ap->ops->scr_read)
2579 hardreset = sata_std_hardreset;
2581 return ata_drive_probe_reset(ap, ata_std_probeinit,
2582 ata_std_softreset, hardreset,
2583 ata_std_postreset, classes);
2586 int ata_do_reset(struct ata_port *ap, ata_reset_fn_t reset,
2587 ata_postreset_fn_t postreset, unsigned int *classes)
2591 for (i = 0; i < ATA_MAX_DEVICES; i++)
2592 classes[i] = ATA_DEV_UNKNOWN;
2594 rc = reset(ap, classes);
2598 /* If any class isn't ATA_DEV_UNKNOWN, consider classification
2599 * is complete and convert all ATA_DEV_UNKNOWN to
2602 for (i = 0; i < ATA_MAX_DEVICES; i++)
2603 if (classes[i] != ATA_DEV_UNKNOWN)
2606 if (i < ATA_MAX_DEVICES)
2607 for (i = 0; i < ATA_MAX_DEVICES; i++)
2608 if (classes[i] == ATA_DEV_UNKNOWN)
2609 classes[i] = ATA_DEV_NONE;
2612 postreset(ap, classes);
2618 * ata_drive_probe_reset - Perform probe reset with given methods
2619 * @ap: port to reset
2620 * @probeinit: probeinit method (can be NULL)
2621 * @softreset: softreset method (can be NULL)
2622 * @hardreset: hardreset method (can be NULL)
2623 * @postreset: postreset method (can be NULL)
2624 * @classes: resulting classes of attached devices
2626 * Reset the specified port and classify attached devices using
2627 * given methods. This function prefers softreset but tries all
2628 * possible reset sequences to reset and classify devices. This
2629 * function is intended to be used for constructing ->probe_reset
2630 * callback by low level drivers.
2632 * Reset methods should follow the following rules.
2634 * - Return 0 on sucess, -errno on failure.
2635 * - If classification is supported, fill classes[] with
2636 * recognized class codes.
2637 * - If classification is not supported, leave classes[] alone.
2640 * Kernel thread context (may sleep)
2643 * 0 on success, -EINVAL if no reset method is avaliable, -ENODEV
2644 * if classification fails, and any error code from reset
2647 int ata_drive_probe_reset(struct ata_port *ap, ata_probeinit_fn_t probeinit,
2648 ata_reset_fn_t softreset, ata_reset_fn_t hardreset,
2649 ata_postreset_fn_t postreset, unsigned int *classes)
2656 if (softreset && !sata_set_spd_needed(ap)) {
2657 rc = ata_do_reset(ap, softreset, postreset, classes);
2658 if (rc == 0 && classes[0] != ATA_DEV_UNKNOWN)
2660 printk(KERN_INFO "ata%u: softreset failed, will try "
2661 "hardreset in 5 secs\n", ap->id);
2669 rc = ata_do_reset(ap, hardreset, postreset, classes);
2671 if (classes[0] != ATA_DEV_UNKNOWN)
2676 if (sata_down_spd_limit(ap))
2679 printk(KERN_INFO "ata%u: hardreset failed, will retry "
2680 "in 5 secs\n", ap->id);
2685 printk(KERN_INFO "ata%u: hardreset succeeded without "
2686 "classification, will retry softreset in 5 secs\n",
2690 rc = ata_do_reset(ap, softreset, postreset, classes);
2694 if (rc == 0 && classes[0] == ATA_DEV_UNKNOWN)
2700 * ata_dev_same_device - Determine whether new ID matches configured device
2701 * @ap: port on which the device to compare against resides
2702 * @dev: device to compare against
2703 * @new_class: class of the new device
2704 * @new_id: IDENTIFY page of the new device
2706 * Compare @new_class and @new_id against @dev and determine
2707 * whether @dev is the device indicated by @new_class and
2714 * 1 if @dev matches @new_class and @new_id, 0 otherwise.
2716 static int ata_dev_same_device(struct ata_port *ap, struct ata_device *dev,
2717 unsigned int new_class, const u16 *new_id)
2719 const u16 *old_id = dev->id;
2720 unsigned char model[2][41], serial[2][21];
2723 if (dev->class != new_class) {
2725 "ata%u: dev %u class mismatch %d != %d\n",
2726 ap->id, dev->devno, dev->class, new_class);
2730 ata_id_c_string(old_id, model[0], ATA_ID_PROD_OFS, sizeof(model[0]));
2731 ata_id_c_string(new_id, model[1], ATA_ID_PROD_OFS, sizeof(model[1]));
2732 ata_id_c_string(old_id, serial[0], ATA_ID_SERNO_OFS, sizeof(serial[0]));
2733 ata_id_c_string(new_id, serial[1], ATA_ID_SERNO_OFS, sizeof(serial[1]));
2734 new_n_sectors = ata_id_n_sectors(new_id);
2736 if (strcmp(model[0], model[1])) {
2738 "ata%u: dev %u model number mismatch '%s' != '%s'\n",
2739 ap->id, dev->devno, model[0], model[1]);
2743 if (strcmp(serial[0], serial[1])) {
2745 "ata%u: dev %u serial number mismatch '%s' != '%s'\n",
2746 ap->id, dev->devno, serial[0], serial[1]);
2750 if (dev->class == ATA_DEV_ATA && dev->n_sectors != new_n_sectors) {
2752 "ata%u: dev %u n_sectors mismatch %llu != %llu\n",
2753 ap->id, dev->devno, (unsigned long long)dev->n_sectors,
2754 (unsigned long long)new_n_sectors);
2762 * ata_dev_revalidate - Revalidate ATA device
2763 * @ap: port on which the device to revalidate resides
2764 * @dev: device to revalidate
2765 * @post_reset: is this revalidation after reset?
2767 * Re-read IDENTIFY page and make sure @dev is still attached to
2771 * Kernel thread context (may sleep)
2774 * 0 on success, negative errno otherwise
2776 int ata_dev_revalidate(struct ata_port *ap, struct ata_device *dev,
2779 unsigned int class = dev->class;
2780 u16 *id = (void *)ap->sector_buf;
2783 if (!ata_dev_enabled(dev)) {
2789 rc = ata_dev_read_id(ap, dev, &class, post_reset, id);
2793 /* is the device still there? */
2794 if (!ata_dev_same_device(ap, dev, class, id)) {
2799 memcpy(dev->id, id, sizeof(id[0]) * ATA_ID_WORDS);
2801 /* configure device according to the new ID */
2802 rc = ata_dev_configure(ap, dev, 0);
2807 printk(KERN_ERR "ata%u: dev %u revalidation failed (errno=%d)\n",
2808 ap->id, dev->devno, rc);
2812 static const char * const ata_dma_blacklist [] = {
2813 "WDC AC11000H", NULL,
2814 "WDC AC22100H", NULL,
2815 "WDC AC32500H", NULL,
2816 "WDC AC33100H", NULL,
2817 "WDC AC31600H", NULL,
2818 "WDC AC32100H", "24.09P07",
2819 "WDC AC23200L", "21.10N21",
2820 "Compaq CRD-8241B", NULL,
2825 "SanDisk SDP3B", NULL,
2826 "SanDisk SDP3B-64", NULL,
2827 "SANYO CD-ROM CRD", NULL,
2828 "HITACHI CDR-8", NULL,
2829 "HITACHI CDR-8335", NULL,
2830 "HITACHI CDR-8435", NULL,
2831 "Toshiba CD-ROM XM-6202B", NULL,
2832 "TOSHIBA CD-ROM XM-1702BC", NULL,
2834 "E-IDE CD-ROM CR-840", NULL,
2835 "CD-ROM Drive/F5A", NULL,
2836 "WPI CDD-820", NULL,
2837 "SAMSUNG CD-ROM SC-148C", NULL,
2838 "SAMSUNG CD-ROM SC", NULL,
2839 "SanDisk SDP3B-64", NULL,
2840 "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,
2841 "_NEC DV5800A", NULL,
2842 "SAMSUNG CD-ROM SN-124", "N001"
2845 static int ata_strim(char *s, size_t len)
2847 len = strnlen(s, len);
2849 /* ATAPI specifies that empty space is blank-filled; remove blanks */
2850 while ((len > 0) && (s[len - 1] == ' ')) {
2857 static int ata_dma_blacklisted(const struct ata_device *dev)
2859 unsigned char model_num[40];
2860 unsigned char model_rev[16];
2861 unsigned int nlen, rlen;
2864 ata_id_string(dev->id, model_num, ATA_ID_PROD_OFS,
2866 ata_id_string(dev->id, model_rev, ATA_ID_FW_REV_OFS,
2868 nlen = ata_strim(model_num, sizeof(model_num));
2869 rlen = ata_strim(model_rev, sizeof(model_rev));
2871 for (i = 0; i < ARRAY_SIZE(ata_dma_blacklist); i += 2) {
2872 if (!strncmp(ata_dma_blacklist[i], model_num, nlen)) {
2873 if (ata_dma_blacklist[i+1] == NULL)
2875 if (!strncmp(ata_dma_blacklist[i], model_rev, rlen))
2883 * ata_dev_xfermask - Compute supported xfermask of the given device
2884 * @ap: Port on which the device to compute xfermask for resides
2885 * @dev: Device to compute xfermask for
2887 * Compute supported xfermask of @dev and store it in
2888 * dev->*_mask. This function is responsible for applying all
2889 * known limits including host controller limits, device
2892 * FIXME: The current implementation limits all transfer modes to
2893 * the fastest of the lowested device on the port. This is not
2894 * required on most controllers.
2899 static void ata_dev_xfermask(struct ata_port *ap, struct ata_device *dev)
2901 struct ata_host_set *hs = ap->host_set;
2902 unsigned long xfer_mask;
2905 xfer_mask = ata_pack_xfermask(ap->pio_mask,
2906 ap->mwdma_mask, ap->udma_mask);
2908 /* Apply cable rule here. Don't apply it early because when
2909 * we handle hot plug the cable type can itself change.
2911 if (ap->cbl == ATA_CBL_PATA40)
2912 xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
2914 /* FIXME: Use port-wide xfermask for now */
2915 for (i = 0; i < ATA_MAX_DEVICES; i++) {
2916 struct ata_device *d = &ap->device[i];
2918 if (ata_dev_absent(d))
2921 if (ata_dev_disabled(d)) {
2922 /* to avoid violating device selection timing */
2923 xfer_mask &= ata_pack_xfermask(d->pio_mask,
2924 UINT_MAX, UINT_MAX);
2928 xfer_mask &= ata_pack_xfermask(d->pio_mask,
2929 d->mwdma_mask, d->udma_mask);
2930 xfer_mask &= ata_id_xfermask(d->id);
2931 if (ata_dma_blacklisted(d))
2932 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
2935 if (ata_dma_blacklisted(dev))
2936 printk(KERN_WARNING "ata%u: dev %u is on DMA blacklist, "
2937 "disabling DMA\n", ap->id, dev->devno);
2939 if (hs->flags & ATA_HOST_SIMPLEX) {
2940 if (hs->simplex_claimed)
2941 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
2944 if (ap->ops->mode_filter)
2945 xfer_mask = ap->ops->mode_filter(ap, dev, xfer_mask);
2947 ata_unpack_xfermask(xfer_mask, &dev->pio_mask,
2948 &dev->mwdma_mask, &dev->udma_mask);
2952 * ata_dev_set_xfermode - Issue SET FEATURES - XFER MODE command
2953 * @ap: Port associated with device @dev
2954 * @dev: Device to which command will be sent
2956 * Issue SET FEATURES - XFER MODE command to device @dev
2960 * PCI/etc. bus probe sem.
2963 * 0 on success, AC_ERR_* mask otherwise.
2966 static unsigned int ata_dev_set_xfermode(struct ata_port *ap,
2967 struct ata_device *dev)
2969 struct ata_taskfile tf;
2970 unsigned int err_mask;
2972 /* set up set-features taskfile */
2973 DPRINTK("set features - xfer mode\n");
2975 ata_tf_init(ap, &tf, dev->devno);
2976 tf.command = ATA_CMD_SET_FEATURES;
2977 tf.feature = SETFEATURES_XFER;
2978 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
2979 tf.protocol = ATA_PROT_NODATA;
2980 tf.nsect = dev->xfer_mode;
2982 err_mask = ata_exec_internal(ap, dev, &tf, NULL, DMA_NONE, NULL, 0);
2984 DPRINTK("EXIT, err_mask=%x\n", err_mask);
2989 * ata_dev_init_params - Issue INIT DEV PARAMS command
2990 * @ap: Port associated with device @dev
2991 * @dev: Device to which command will be sent
2994 * Kernel thread context (may sleep)
2997 * 0 on success, AC_ERR_* mask otherwise.
3000 static unsigned int ata_dev_init_params(struct ata_port *ap,
3001 struct ata_device *dev,
3005 struct ata_taskfile tf;
3006 unsigned int err_mask;
3008 /* Number of sectors per track 1-255. Number of heads 1-16 */
3009 if (sectors < 1 || sectors > 255 || heads < 1 || heads > 16)
3010 return AC_ERR_INVALID;
3012 /* set up init dev params taskfile */
3013 DPRINTK("init dev params \n");
3015 ata_tf_init(ap, &tf, dev->devno);
3016 tf.command = ATA_CMD_INIT_DEV_PARAMS;
3017 tf.flags |= ATA_TFLAG_ISADDR | ATA_TFLAG_DEVICE;
3018 tf.protocol = ATA_PROT_NODATA;
3020 tf.device |= (heads - 1) & 0x0f; /* max head = num. of heads - 1 */
3022 err_mask = ata_exec_internal(ap, dev, &tf, NULL, DMA_NONE, NULL, 0);
3024 DPRINTK("EXIT, err_mask=%x\n", err_mask);
3029 * ata_sg_clean - Unmap DMA memory associated with command
3030 * @qc: Command containing DMA memory to be released
3032 * Unmap all mapped DMA memory associated with this command.
3035 * spin_lock_irqsave(host_set lock)
3038 static void ata_sg_clean(struct ata_queued_cmd *qc)
3040 struct ata_port *ap = qc->ap;
3041 struct scatterlist *sg = qc->__sg;
3042 int dir = qc->dma_dir;
3043 void *pad_buf = NULL;
3045 WARN_ON(!(qc->flags & ATA_QCFLAG_DMAMAP));
3046 WARN_ON(sg == NULL);
3048 if (qc->flags & ATA_QCFLAG_SINGLE)
3049 WARN_ON(qc->n_elem > 1);
3051 VPRINTK("unmapping %u sg elements\n", qc->n_elem);
3053 /* if we padded the buffer out to 32-bit bound, and data
3054 * xfer direction is from-device, we must copy from the
3055 * pad buffer back into the supplied buffer
3057 if (qc->pad_len && !(qc->tf.flags & ATA_TFLAG_WRITE))
3058 pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3060 if (qc->flags & ATA_QCFLAG_SG) {
3062 dma_unmap_sg(ap->dev, sg, qc->n_elem, dir);
3063 /* restore last sg */
3064 sg[qc->orig_n_elem - 1].length += qc->pad_len;
3066 struct scatterlist *psg = &qc->pad_sgent;
3067 void *addr = kmap_atomic(psg->page, KM_IRQ0);
3068 memcpy(addr + psg->offset, pad_buf, qc->pad_len);
3069 kunmap_atomic(addr, KM_IRQ0);
3073 dma_unmap_single(ap->dev,
3074 sg_dma_address(&sg[0]), sg_dma_len(&sg[0]),
3077 sg->length += qc->pad_len;
3079 memcpy(qc->buf_virt + sg->length - qc->pad_len,
3080 pad_buf, qc->pad_len);
3083 qc->flags &= ~ATA_QCFLAG_DMAMAP;
3088 * ata_fill_sg - Fill PCI IDE PRD table
3089 * @qc: Metadata associated with taskfile to be transferred
3091 * Fill PCI IDE PRD (scatter-gather) table with segments
3092 * associated with the current disk command.
3095 * spin_lock_irqsave(host_set lock)
3098 static void ata_fill_sg(struct ata_queued_cmd *qc)
3100 struct ata_port *ap = qc->ap;
3101 struct scatterlist *sg;
3104 WARN_ON(qc->__sg == NULL);
3105 WARN_ON(qc->n_elem == 0 && qc->pad_len == 0);
3108 ata_for_each_sg(sg, qc) {
3112 /* determine if physical DMA addr spans 64K boundary.
3113 * Note h/w doesn't support 64-bit, so we unconditionally
3114 * truncate dma_addr_t to u32.
3116 addr = (u32) sg_dma_address(sg);
3117 sg_len = sg_dma_len(sg);
3120 offset = addr & 0xffff;
3122 if ((offset + sg_len) > 0x10000)
3123 len = 0x10000 - offset;
3125 ap->prd[idx].addr = cpu_to_le32(addr);
3126 ap->prd[idx].flags_len = cpu_to_le32(len & 0xffff);
3127 VPRINTK("PRD[%u] = (0x%X, 0x%X)\n", idx, addr, len);
3136 ap->prd[idx - 1].flags_len |= cpu_to_le32(ATA_PRD_EOT);
3139 * ata_check_atapi_dma - Check whether ATAPI DMA can be supported
3140 * @qc: Metadata associated with taskfile to check
3142 * Allow low-level driver to filter ATA PACKET commands, returning
3143 * a status indicating whether or not it is OK to use DMA for the
3144 * supplied PACKET command.
3147 * spin_lock_irqsave(host_set lock)
3149 * RETURNS: 0 when ATAPI DMA can be used
3152 int ata_check_atapi_dma(struct ata_queued_cmd *qc)
3154 struct ata_port *ap = qc->ap;
3155 int rc = 0; /* Assume ATAPI DMA is OK by default */
3157 if (ap->ops->check_atapi_dma)
3158 rc = ap->ops->check_atapi_dma(qc);
3163 * ata_qc_prep - Prepare taskfile for submission
3164 * @qc: Metadata associated with taskfile to be prepared
3166 * Prepare ATA taskfile for submission.
3169 * spin_lock_irqsave(host_set lock)
3171 void ata_qc_prep(struct ata_queued_cmd *qc)
3173 if (!(qc->flags & ATA_QCFLAG_DMAMAP))
3179 void ata_noop_qc_prep(struct ata_queued_cmd *qc) { }
3182 * ata_sg_init_one - Associate command with memory buffer
3183 * @qc: Command to be associated
3184 * @buf: Memory buffer
3185 * @buflen: Length of memory buffer, in bytes.
3187 * Initialize the data-related elements of queued_cmd @qc
3188 * to point to a single memory buffer, @buf of byte length @buflen.
3191 * spin_lock_irqsave(host_set lock)
3194 void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
3196 struct scatterlist *sg;
3198 qc->flags |= ATA_QCFLAG_SINGLE;
3200 memset(&qc->sgent, 0, sizeof(qc->sgent));
3201 qc->__sg = &qc->sgent;
3203 qc->orig_n_elem = 1;
3207 sg_init_one(sg, buf, buflen);
3211 * ata_sg_init - Associate command with scatter-gather table.
3212 * @qc: Command to be associated
3213 * @sg: Scatter-gather table.
3214 * @n_elem: Number of elements in s/g table.
3216 * Initialize the data-related elements of queued_cmd @qc
3217 * to point to a scatter-gather table @sg, containing @n_elem
3221 * spin_lock_irqsave(host_set lock)
3224 void ata_sg_init(struct ata_queued_cmd *qc, struct scatterlist *sg,
3225 unsigned int n_elem)
3227 qc->flags |= ATA_QCFLAG_SG;
3229 qc->n_elem = n_elem;
3230 qc->orig_n_elem = n_elem;
3234 * ata_sg_setup_one - DMA-map the memory buffer associated with a command.
3235 * @qc: Command with memory buffer to be mapped.
3237 * DMA-map the memory buffer associated with queued_cmd @qc.
3240 * spin_lock_irqsave(host_set lock)
3243 * Zero on success, negative on error.
3246 static int ata_sg_setup_one(struct ata_queued_cmd *qc)
3248 struct ata_port *ap = qc->ap;
3249 int dir = qc->dma_dir;
3250 struct scatterlist *sg = qc->__sg;
3251 dma_addr_t dma_address;
3254 /* we must lengthen transfers to end on a 32-bit boundary */
3255 qc->pad_len = sg->length & 3;
3257 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3258 struct scatterlist *psg = &qc->pad_sgent;
3260 WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
3262 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
3264 if (qc->tf.flags & ATA_TFLAG_WRITE)
3265 memcpy(pad_buf, qc->buf_virt + sg->length - qc->pad_len,
3268 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
3269 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
3271 sg->length -= qc->pad_len;
3272 if (sg->length == 0)
3275 DPRINTK("padding done, sg->length=%u pad_len=%u\n",
3276 sg->length, qc->pad_len);
3284 dma_address = dma_map_single(ap->dev, qc->buf_virt,
3286 if (dma_mapping_error(dma_address)) {
3288 sg->length += qc->pad_len;
3292 sg_dma_address(sg) = dma_address;
3293 sg_dma_len(sg) = sg->length;
3296 DPRINTK("mapped buffer of %d bytes for %s\n", sg_dma_len(sg),
3297 qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3303 * ata_sg_setup - DMA-map the scatter-gather table associated with a command.
3304 * @qc: Command with scatter-gather table to be mapped.
3306 * DMA-map the scatter-gather table associated with queued_cmd @qc.
3309 * spin_lock_irqsave(host_set lock)
3312 * Zero on success, negative on error.
3316 static int ata_sg_setup(struct ata_queued_cmd *qc)
3318 struct ata_port *ap = qc->ap;
3319 struct scatterlist *sg = qc->__sg;
3320 struct scatterlist *lsg = &sg[qc->n_elem - 1];
3321 int n_elem, pre_n_elem, dir, trim_sg = 0;
3323 VPRINTK("ENTER, ata%u\n", ap->id);
3324 WARN_ON(!(qc->flags & ATA_QCFLAG_SG));
3326 /* we must lengthen transfers to end on a 32-bit boundary */
3327 qc->pad_len = lsg->length & 3;
3329 void *pad_buf = ap->pad + (qc->tag * ATA_DMA_PAD_SZ);
3330 struct scatterlist *psg = &qc->pad_sgent;
3331 unsigned int offset;
3333 WARN_ON(qc->dev->class != ATA_DEV_ATAPI);
3335 memset(pad_buf, 0, ATA_DMA_PAD_SZ);
3338 * psg->page/offset are used to copy to-be-written
3339 * data in this function or read data in ata_sg_clean.
3341 offset = lsg->offset + lsg->length - qc->pad_len;
3342 psg->page = nth_page(lsg->page, offset >> PAGE_SHIFT);
3343 psg->offset = offset_in_page(offset);
3345 if (qc->tf.flags & ATA_TFLAG_WRITE) {
3346 void *addr = kmap_atomic(psg->page, KM_IRQ0);
3347 memcpy(pad_buf, addr + psg->offset, qc->pad_len);
3348 kunmap_atomic(addr, KM_IRQ0);
3351 sg_dma_address(psg) = ap->pad_dma + (qc->tag * ATA_DMA_PAD_SZ);
3352 sg_dma_len(psg) = ATA_DMA_PAD_SZ;
3354 lsg->length -= qc->pad_len;
3355 if (lsg->length == 0)
3358 DPRINTK("padding done, sg[%d].length=%u pad_len=%u\n",
3359 qc->n_elem - 1, lsg->length, qc->pad_len);
3362 pre_n_elem = qc->n_elem;
3363 if (trim_sg && pre_n_elem)
3372 n_elem = dma_map_sg(ap->dev, sg, pre_n_elem, dir);
3374 /* restore last sg */
3375 lsg->length += qc->pad_len;
3379 DPRINTK("%d sg elements mapped\n", n_elem);
3382 qc->n_elem = n_elem;
3388 * ata_poll_qc_complete - turn irq back on and finish qc
3389 * @qc: Command to complete
3390 * @err_mask: ATA status register content
3393 * None. (grabs host lock)
3396 void ata_poll_qc_complete(struct ata_queued_cmd *qc)
3398 struct ata_port *ap = qc->ap;
3399 unsigned long flags;
3401 spin_lock_irqsave(&ap->host_set->lock, flags);
3402 ap->flags &= ~ATA_FLAG_NOINTR;
3404 ata_qc_complete(qc);
3405 spin_unlock_irqrestore(&ap->host_set->lock, flags);
3409 * ata_pio_poll - poll using PIO, depending on current state
3410 * @qc: qc in progress
3413 * None. (executing in kernel thread context)
3416 * timeout value to use
3418 static unsigned long ata_pio_poll(struct ata_queued_cmd *qc)
3420 struct ata_port *ap = qc->ap;
3422 unsigned int poll_state = HSM_ST_UNKNOWN;
3423 unsigned int reg_state = HSM_ST_UNKNOWN;
3425 switch (ap->hsm_task_state) {
3428 poll_state = HSM_ST_POLL;
3432 case HSM_ST_LAST_POLL:
3433 poll_state = HSM_ST_LAST_POLL;
3434 reg_state = HSM_ST_LAST;
3441 status = ata_chk_status(ap);
3442 if (status & ATA_BUSY) {
3443 if (time_after(jiffies, ap->pio_task_timeout)) {
3444 qc->err_mask |= AC_ERR_TIMEOUT;
3445 ap->hsm_task_state = HSM_ST_TMOUT;
3448 ap->hsm_task_state = poll_state;
3449 return ATA_SHORT_PAUSE;
3452 ap->hsm_task_state = reg_state;
3457 * ata_pio_complete - check if drive is busy or idle
3458 * @qc: qc to complete
3461 * None. (executing in kernel thread context)
3464 * Non-zero if qc completed, zero otherwise.
3466 static int ata_pio_complete(struct ata_queued_cmd *qc)
3468 struct ata_port *ap = qc->ap;
3472 * This is purely heuristic. This is a fast path. Sometimes when
3473 * we enter, BSY will be cleared in a chk-status or two. If not,
3474 * the drive is probably seeking or something. Snooze for a couple
3475 * msecs, then chk-status again. If still busy, fall back to
3476 * HSM_ST_POLL state.
3478 drv_stat = ata_busy_wait(ap, ATA_BUSY, 10);
3479 if (drv_stat & ATA_BUSY) {
3481 drv_stat = ata_busy_wait(ap, ATA_BUSY, 10);
3482 if (drv_stat & ATA_BUSY) {
3483 ap->hsm_task_state = HSM_ST_LAST_POLL;
3484 ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
3489 drv_stat = ata_wait_idle(ap);
3490 if (!ata_ok(drv_stat)) {
3491 qc->err_mask |= __ac_err_mask(drv_stat);
3492 ap->hsm_task_state = HSM_ST_ERR;
3496 ap->hsm_task_state = HSM_ST_IDLE;
3498 WARN_ON(qc->err_mask);
3499 ata_poll_qc_complete(qc);
3501 /* another command may start at this point */
3508 * swap_buf_le16 - swap halves of 16-bit words in place
3509 * @buf: Buffer to swap
3510 * @buf_words: Number of 16-bit words in buffer.
3512 * Swap halves of 16-bit words if needed to convert from
3513 * little-endian byte order to native cpu byte order, or
3517 * Inherited from caller.
3519 void swap_buf_le16(u16 *buf, unsigned int buf_words)
3524 for (i = 0; i < buf_words; i++)
3525 buf[i] = le16_to_cpu(buf[i]);
3526 #endif /* __BIG_ENDIAN */
3530 * ata_mmio_data_xfer - Transfer data by MMIO
3531 * @ap: port to read/write
3533 * @buflen: buffer length
3534 * @write_data: read/write
3536 * Transfer data from/to the device data register by MMIO.
3539 * Inherited from caller.
3542 static void ata_mmio_data_xfer(struct ata_port *ap, unsigned char *buf,
3543 unsigned int buflen, int write_data)
3546 unsigned int words = buflen >> 1;
3547 u16 *buf16 = (u16 *) buf;
3548 void __iomem *mmio = (void __iomem *)ap->ioaddr.data_addr;
3550 /* Transfer multiple of 2 bytes */
3552 for (i = 0; i < words; i++)
3553 writew(le16_to_cpu(buf16[i]), mmio);
3555 for (i = 0; i < words; i++)
3556 buf16[i] = cpu_to_le16(readw(mmio));
3559 /* Transfer trailing 1 byte, if any. */
3560 if (unlikely(buflen & 0x01)) {
3561 u16 align_buf[1] = { 0 };
3562 unsigned char *trailing_buf = buf + buflen - 1;
3565 memcpy(align_buf, trailing_buf, 1);
3566 writew(le16_to_cpu(align_buf[0]), mmio);
3568 align_buf[0] = cpu_to_le16(readw(mmio));
3569 memcpy(trailing_buf, align_buf, 1);
3575 * ata_pio_data_xfer - Transfer data by PIO
3576 * @ap: port to read/write
3578 * @buflen: buffer length
3579 * @write_data: read/write
3581 * Transfer data from/to the device data register by PIO.
3584 * Inherited from caller.
3587 static void ata_pio_data_xfer(struct ata_port *ap, unsigned char *buf,
3588 unsigned int buflen, int write_data)
3590 unsigned int words = buflen >> 1;
3592 /* Transfer multiple of 2 bytes */
3594 outsw(ap->ioaddr.data_addr, buf, words);
3596 insw(ap->ioaddr.data_addr, buf, words);
3598 /* Transfer trailing 1 byte, if any. */
3599 if (unlikely(buflen & 0x01)) {
3600 u16 align_buf[1] = { 0 };
3601 unsigned char *trailing_buf = buf + buflen - 1;
3604 memcpy(align_buf, trailing_buf, 1);
3605 outw(le16_to_cpu(align_buf[0]), ap->ioaddr.data_addr);
3607 align_buf[0] = cpu_to_le16(inw(ap->ioaddr.data_addr));
3608 memcpy(trailing_buf, align_buf, 1);
3614 * ata_data_xfer - Transfer data from/to the data register.
3615 * @ap: port to read/write
3617 * @buflen: buffer length
3618 * @do_write: read/write
3620 * Transfer data from/to the device data register.
3623 * Inherited from caller.
3626 static void ata_data_xfer(struct ata_port *ap, unsigned char *buf,
3627 unsigned int buflen, int do_write)
3629 /* Make the crap hardware pay the costs not the good stuff */
3630 if (unlikely(ap->flags & ATA_FLAG_IRQ_MASK)) {
3631 unsigned long flags;
3632 local_irq_save(flags);
3633 if (ap->flags & ATA_FLAG_MMIO)
3634 ata_mmio_data_xfer(ap, buf, buflen, do_write);
3636 ata_pio_data_xfer(ap, buf, buflen, do_write);
3637 local_irq_restore(flags);
3639 if (ap->flags & ATA_FLAG_MMIO)
3640 ata_mmio_data_xfer(ap, buf, buflen, do_write);
3642 ata_pio_data_xfer(ap, buf, buflen, do_write);
3647 * ata_pio_sector - Transfer ATA_SECT_SIZE (512 bytes) of data.
3648 * @qc: Command on going
3650 * Transfer ATA_SECT_SIZE of data from/to the ATA device.
3653 * Inherited from caller.
3656 static void ata_pio_sector(struct ata_queued_cmd *qc)
3658 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
3659 struct scatterlist *sg = qc->__sg;
3660 struct ata_port *ap = qc->ap;
3662 unsigned int offset;
3665 if (qc->cursect == (qc->nsect - 1))
3666 ap->hsm_task_state = HSM_ST_LAST;
3668 page = sg[qc->cursg].page;
3669 offset = sg[qc->cursg].offset + qc->cursg_ofs * ATA_SECT_SIZE;
3671 /* get the current page and offset */
3672 page = nth_page(page, (offset >> PAGE_SHIFT));
3673 offset %= PAGE_SIZE;
3675 buf = kmap(page) + offset;
3680 if ((qc->cursg_ofs * ATA_SECT_SIZE) == (&sg[qc->cursg])->length) {
3685 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3687 /* do the actual data transfer */
3688 do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
3689 ata_data_xfer(ap, buf, ATA_SECT_SIZE, do_write);
3695 * __atapi_pio_bytes - Transfer data from/to the ATAPI device.
3696 * @qc: Command on going
3697 * @bytes: number of bytes
3699 * Transfer Transfer data from/to the ATAPI device.
3702 * Inherited from caller.
3706 static void __atapi_pio_bytes(struct ata_queued_cmd *qc, unsigned int bytes)
3708 int do_write = (qc->tf.flags & ATA_TFLAG_WRITE);
3709 struct scatterlist *sg = qc->__sg;
3710 struct ata_port *ap = qc->ap;
3713 unsigned int offset, count;
3715 if (qc->curbytes + bytes >= qc->nbytes)
3716 ap->hsm_task_state = HSM_ST_LAST;
3719 if (unlikely(qc->cursg >= qc->n_elem)) {
3721 * The end of qc->sg is reached and the device expects
3722 * more data to transfer. In order not to overrun qc->sg
3723 * and fulfill length specified in the byte count register,
3724 * - for read case, discard trailing data from the device
3725 * - for write case, padding zero data to the device
3727 u16 pad_buf[1] = { 0 };
3728 unsigned int words = bytes >> 1;
3731 if (words) /* warning if bytes > 1 */
3732 printk(KERN_WARNING "ata%u: %u bytes trailing data\n",
3735 for (i = 0; i < words; i++)
3736 ata_data_xfer(ap, (unsigned char*)pad_buf, 2, do_write);
3738 ap->hsm_task_state = HSM_ST_LAST;
3742 sg = &qc->__sg[qc->cursg];
3745 offset = sg->offset + qc->cursg_ofs;
3747 /* get the current page and offset */
3748 page = nth_page(page, (offset >> PAGE_SHIFT));
3749 offset %= PAGE_SIZE;
3751 /* don't overrun current sg */
3752 count = min(sg->length - qc->cursg_ofs, bytes);
3754 /* don't cross page boundaries */
3755 count = min(count, (unsigned int)PAGE_SIZE - offset);
3757 buf = kmap(page) + offset;
3760 qc->curbytes += count;
3761 qc->cursg_ofs += count;
3763 if (qc->cursg_ofs == sg->length) {
3768 DPRINTK("data %s\n", qc->tf.flags & ATA_TFLAG_WRITE ? "write" : "read");
3770 /* do the actual data transfer */
3771 ata_data_xfer(ap, buf, count, do_write);
3780 * atapi_pio_bytes - Transfer data from/to the ATAPI device.
3781 * @qc: Command on going
3783 * Transfer Transfer data from/to the ATAPI device.
3786 * Inherited from caller.
3789 static void atapi_pio_bytes(struct ata_queued_cmd *qc)
3791 struct ata_port *ap = qc->ap;
3792 struct ata_device *dev = qc->dev;
3793 unsigned int ireason, bc_lo, bc_hi, bytes;
3794 int i_write, do_write = (qc->tf.flags & ATA_TFLAG_WRITE) ? 1 : 0;
3796 ap->ops->tf_read(ap, &qc->tf);
3797 ireason = qc->tf.nsect;
3798 bc_lo = qc->tf.lbam;
3799 bc_hi = qc->tf.lbah;
3800 bytes = (bc_hi << 8) | bc_lo;
3802 /* shall be cleared to zero, indicating xfer of data */
3803 if (ireason & (1 << 0))
3806 /* make sure transfer direction matches expected */
3807 i_write = ((ireason & (1 << 1)) == 0) ? 1 : 0;
3808 if (do_write != i_write)
3811 __atapi_pio_bytes(qc, bytes);
3816 printk(KERN_INFO "ata%u: dev %u: ATAPI check failed\n",
3817 ap->id, dev->devno);
3818 qc->err_mask |= AC_ERR_HSM;
3819 ap->hsm_task_state = HSM_ST_ERR;
3823 * ata_pio_block - start PIO on a block
3824 * @qc: qc to transfer block for
3827 * None. (executing in kernel thread context)
3829 static void ata_pio_block(struct ata_queued_cmd *qc)
3831 struct ata_port *ap = qc->ap;
3835 * This is purely heuristic. This is a fast path.
3836 * Sometimes when we enter, BSY will be cleared in
3837 * a chk-status or two. If not, the drive is probably seeking
3838 * or something. Snooze for a couple msecs, then
3839 * chk-status again. If still busy, fall back to
3840 * HSM_ST_POLL state.
3842 status = ata_busy_wait(ap, ATA_BUSY, 5);
3843 if (status & ATA_BUSY) {
3845 status = ata_busy_wait(ap, ATA_BUSY, 10);
3846 if (status & ATA_BUSY) {
3847 ap->hsm_task_state = HSM_ST_POLL;
3848 ap->pio_task_timeout = jiffies + ATA_TMOUT_PIO;
3854 if (status & (ATA_ERR | ATA_DF)) {
3855 qc->err_mask |= AC_ERR_DEV;
3856 ap->hsm_task_state = HSM_ST_ERR;
3860 /* transfer data if any */
3861 if (is_atapi_taskfile(&qc->tf)) {
3862 /* DRQ=0 means no more data to transfer */
3863 if ((status & ATA_DRQ) == 0) {
3864 ap->hsm_task_state = HSM_ST_LAST;
3868 atapi_pio_bytes(qc);
3870 /* handle BSY=0, DRQ=0 as error */
3871 if ((status & ATA_DRQ) == 0) {
3872 qc->err_mask |= AC_ERR_HSM;
3873 ap->hsm_task_state = HSM_ST_ERR;
3881 static void ata_pio_error(struct ata_queued_cmd *qc)
3883 struct ata_port *ap = qc->ap;
3885 if (qc->tf.command != ATA_CMD_PACKET)
3886 printk(KERN_WARNING "ata%u: dev %u PIO error\n",
3887 ap->id, qc->dev->devno);
3889 /* make sure qc->err_mask is available to
3890 * know what's wrong and recover
3892 WARN_ON(qc->err_mask == 0);
3894 ap->hsm_task_state = HSM_ST_IDLE;
3896 ata_poll_qc_complete(qc);
3899 static void ata_pio_task(void *_data)
3901 struct ata_queued_cmd *qc = _data;
3902 struct ata_port *ap = qc->ap;
3903 unsigned long timeout;
3910 switch (ap->hsm_task_state) {
3919 qc_completed = ata_pio_complete(qc);
3923 case HSM_ST_LAST_POLL:
3924 timeout = ata_pio_poll(qc);
3934 ata_port_queue_task(ap, ata_pio_task, qc, timeout);
3935 else if (!qc_completed)
3940 * atapi_packet_task - Write CDB bytes to hardware
3941 * @_data: qc in progress
3943 * When device has indicated its readiness to accept
3944 * a CDB, this function is called. Send the CDB.
3945 * If DMA is to be performed, exit immediately.
3946 * Otherwise, we are in polling mode, so poll
3947 * status under operation succeeds or fails.
3950 * Kernel thread context (may sleep)
3952 static void atapi_packet_task(void *_data)
3954 struct ata_queued_cmd *qc = _data;
3955 struct ata_port *ap = qc->ap;
3958 /* sleep-wait for BSY to clear */
3959 DPRINTK("busy wait\n");
3960 if (ata_busy_sleep(ap, ATA_TMOUT_CDB_QUICK, ATA_TMOUT_CDB)) {
3961 qc->err_mask |= AC_ERR_TIMEOUT;
3965 /* make sure DRQ is set */
3966 status = ata_chk_status(ap);
3967 if ((status & (ATA_BUSY | ATA_DRQ)) != ATA_DRQ) {
3968 qc->err_mask |= AC_ERR_HSM;
3973 DPRINTK("send cdb\n");
3974 WARN_ON(qc->dev->cdb_len < 12);
3976 if (qc->tf.protocol == ATA_PROT_ATAPI_DMA ||
3977 qc->tf.protocol == ATA_PROT_ATAPI_NODATA) {
3978 unsigned long flags;
3980 /* Once we're done issuing command and kicking bmdma,
3981 * irq handler takes over. To not lose irq, we need
3982 * to clear NOINTR flag before sending cdb, but
3983 * interrupt handler shouldn't be invoked before we're
3984 * finished. Hence, the following locking.
3986 spin_lock_irqsave(&ap->host_set->lock, flags);
3987 ap->flags &= ~ATA_FLAG_NOINTR;
3988 ata_data_xfer(ap, qc->cdb, qc->dev->cdb_len, 1);
3989 if (qc->tf.protocol == ATA_PROT_ATAPI_DMA)
3990 ap->ops->bmdma_start(qc); /* initiate bmdma */
3991 spin_unlock_irqrestore(&ap->host_set->lock, flags);
3993 ata_data_xfer(ap, qc->cdb, qc->dev->cdb_len, 1);
3995 /* PIO commands are handled by polling */
3996 ap->hsm_task_state = HSM_ST;
3997 ata_port_queue_task(ap, ata_pio_task, qc, 0);
4003 ata_poll_qc_complete(qc);
4007 * ata_qc_new - Request an available ATA command, for queueing
4008 * @ap: Port associated with device @dev
4009 * @dev: Device from whom we request an available command structure
4015 static struct ata_queued_cmd *ata_qc_new(struct ata_port *ap)
4017 struct ata_queued_cmd *qc = NULL;
4020 for (i = 0; i < ATA_MAX_QUEUE; i++)
4021 if (!test_and_set_bit(i, &ap->qactive)) {
4022 qc = ata_qc_from_tag(ap, i);
4033 * ata_qc_new_init - Request an available ATA command, and initialize it
4034 * @ap: Port associated with device @dev
4035 * @dev: Device from whom we request an available command structure
4041 struct ata_queued_cmd *ata_qc_new_init(struct ata_port *ap,
4042 struct ata_device *dev)
4044 struct ata_queued_cmd *qc;
4046 qc = ata_qc_new(ap);
4059 * ata_qc_free - free unused ata_queued_cmd
4060 * @qc: Command to complete
4062 * Designed to free unused ata_queued_cmd object
4063 * in case something prevents using it.
4066 * spin_lock_irqsave(host_set lock)
4068 void ata_qc_free(struct ata_queued_cmd *qc)
4070 struct ata_port *ap = qc->ap;
4073 WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
4077 if (likely(ata_tag_valid(tag))) {
4078 qc->tag = ATA_TAG_POISON;
4079 clear_bit(tag, &ap->qactive);
4083 void __ata_qc_complete(struct ata_queued_cmd *qc)
4085 WARN_ON(qc == NULL); /* ata_qc_from_tag _might_ return NULL */
4086 WARN_ON(!(qc->flags & ATA_QCFLAG_ACTIVE));
4088 if (likely(qc->flags & ATA_QCFLAG_DMAMAP))
4091 /* command should be marked inactive atomically with qc completion */
4092 qc->ap->active_tag = ATA_TAG_POISON;
4094 /* atapi: mark qc as inactive to prevent the interrupt handler
4095 * from completing the command twice later, before the error handler
4096 * is called. (when rc != 0 and atapi request sense is needed)
4098 qc->flags &= ~ATA_QCFLAG_ACTIVE;
4100 /* call completion callback */
4101 qc->complete_fn(qc);
4104 static inline int ata_should_dma_map(struct ata_queued_cmd *qc)
4106 struct ata_port *ap = qc->ap;
4108 switch (qc->tf.protocol) {
4110 case ATA_PROT_ATAPI_DMA:
4113 case ATA_PROT_ATAPI:
4115 if (ap->flags & ATA_FLAG_PIO_DMA)
4128 * ata_qc_issue - issue taskfile to device
4129 * @qc: command to issue to device
4131 * Prepare an ATA command to submission to device.
4132 * This includes mapping the data into a DMA-able
4133 * area, filling in the S/G table, and finally
4134 * writing the taskfile to hardware, starting the command.
4137 * spin_lock_irqsave(host_set lock)
4139 void ata_qc_issue(struct ata_queued_cmd *qc)
4141 struct ata_port *ap = qc->ap;
4143 qc->ap->active_tag = qc->tag;
4144 qc->flags |= ATA_QCFLAG_ACTIVE;
4146 if (ata_should_dma_map(qc)) {
4147 if (qc->flags & ATA_QCFLAG_SG) {
4148 if (ata_sg_setup(qc))
4150 } else if (qc->flags & ATA_QCFLAG_SINGLE) {
4151 if (ata_sg_setup_one(qc))
4155 qc->flags &= ~ATA_QCFLAG_DMAMAP;
4158 ap->ops->qc_prep(qc);
4160 qc->err_mask |= ap->ops->qc_issue(qc);
4161 if (unlikely(qc->err_mask))
4166 qc->flags &= ~ATA_QCFLAG_DMAMAP;
4167 qc->err_mask |= AC_ERR_SYSTEM;
4169 ata_qc_complete(qc);
4173 * ata_qc_issue_prot - issue taskfile to device in proto-dependent manner
4174 * @qc: command to issue to device
4176 * Using various libata functions and hooks, this function
4177 * starts an ATA command. ATA commands are grouped into
4178 * classes called "protocols", and issuing each type of protocol
4179 * is slightly different.
4181 * May be used as the qc_issue() entry in ata_port_operations.
4184 * spin_lock_irqsave(host_set lock)
4187 * Zero on success, AC_ERR_* mask on failure
4190 unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc)
4192 struct ata_port *ap = qc->ap;
4194 ata_dev_select(ap, qc->dev->devno, 1, 0);
4196 switch (qc->tf.protocol) {
4197 case ATA_PROT_NODATA:
4198 ata_tf_to_host(ap, &qc->tf);
4202 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
4203 ap->ops->bmdma_setup(qc); /* set up bmdma */
4204 ap->ops->bmdma_start(qc); /* initiate bmdma */
4207 case ATA_PROT_PIO: /* load tf registers, initiate polling pio */
4208 ata_qc_set_polling(qc);
4209 ata_tf_to_host(ap, &qc->tf);
4210 ap->hsm_task_state = HSM_ST;
4211 ata_port_queue_task(ap, ata_pio_task, qc, 0);
4214 case ATA_PROT_ATAPI:
4215 ata_qc_set_polling(qc);
4216 ata_tf_to_host(ap, &qc->tf);
4217 ata_port_queue_task(ap, atapi_packet_task, qc, 0);
4220 case ATA_PROT_ATAPI_NODATA:
4221 ap->flags |= ATA_FLAG_NOINTR;
4222 ata_tf_to_host(ap, &qc->tf);
4223 ata_port_queue_task(ap, atapi_packet_task, qc, 0);
4226 case ATA_PROT_ATAPI_DMA:
4227 ap->flags |= ATA_FLAG_NOINTR;
4228 ap->ops->tf_load(ap, &qc->tf); /* load tf registers */
4229 ap->ops->bmdma_setup(qc); /* set up bmdma */
4230 ata_port_queue_task(ap, atapi_packet_task, qc, 0);
4235 return AC_ERR_SYSTEM;
4242 * ata_host_intr - Handle host interrupt for given (port, task)
4243 * @ap: Port on which interrupt arrived (possibly...)
4244 * @qc: Taskfile currently active in engine
4246 * Handle host interrupt for given queued command. Currently,
4247 * only DMA interrupts are handled. All other commands are
4248 * handled via polling with interrupts disabled (nIEN bit).
4251 * spin_lock_irqsave(host_set lock)
4254 * One if interrupt was handled, zero if not (shared irq).
4257 inline unsigned int ata_host_intr (struct ata_port *ap,
4258 struct ata_queued_cmd *qc)
4260 u8 status, host_stat;
4262 switch (qc->tf.protocol) {
4265 case ATA_PROT_ATAPI_DMA:
4266 case ATA_PROT_ATAPI:
4267 /* check status of DMA engine */
4268 host_stat = ap->ops->bmdma_status(ap);
4269 VPRINTK("ata%u: host_stat 0x%X\n", ap->id, host_stat);
4271 /* if it's not our irq... */
4272 if (!(host_stat & ATA_DMA_INTR))
4275 /* before we do anything else, clear DMA-Start bit */
4276 ap->ops->bmdma_stop(qc);
4280 case ATA_PROT_ATAPI_NODATA:
4281 case ATA_PROT_NODATA:
4282 /* check altstatus */
4283 status = ata_altstatus(ap);
4284 if (status & ATA_BUSY)
4287 /* check main status, clearing INTRQ */
4288 status = ata_chk_status(ap);
4289 if (unlikely(status & ATA_BUSY))
4291 DPRINTK("ata%u: protocol %d (dev_stat 0x%X)\n",
4292 ap->id, qc->tf.protocol, status);
4294 /* ack bmdma irq events */
4295 ap->ops->irq_clear(ap);
4297 /* complete taskfile transaction */
4298 qc->err_mask |= ac_err_mask(status);
4299 ata_qc_complete(qc);
4306 return 1; /* irq handled */
4309 ap->stats.idle_irq++;
4312 if ((ap->stats.idle_irq % 1000) == 0) {
4313 ata_irq_ack(ap, 0); /* debug trap */
4314 printk(KERN_WARNING "ata%d: irq trap\n", ap->id);
4318 return 0; /* irq not handled */
4322 * ata_interrupt - Default ATA host interrupt handler
4323 * @irq: irq line (unused)
4324 * @dev_instance: pointer to our ata_host_set information structure
4327 * Default interrupt handler for PCI IDE devices. Calls
4328 * ata_host_intr() for each port that is not disabled.
4331 * Obtains host_set lock during operation.
4334 * IRQ_NONE or IRQ_HANDLED.
4337 irqreturn_t ata_interrupt (int irq, void *dev_instance, struct pt_regs *regs)
4339 struct ata_host_set *host_set = dev_instance;
4341 unsigned int handled = 0;
4342 unsigned long flags;
4344 /* TODO: make _irqsave conditional on x86 PCI IDE legacy mode */
4345 spin_lock_irqsave(&host_set->lock, flags);
4347 for (i = 0; i < host_set->n_ports; i++) {
4348 struct ata_port *ap;
4350 ap = host_set->ports[i];
4352 !(ap->flags & (ATA_FLAG_DISABLED | ATA_FLAG_NOINTR))) {
4353 struct ata_queued_cmd *qc;
4355 qc = ata_qc_from_tag(ap, ap->active_tag);
4356 if (qc && (!(qc->tf.ctl & ATA_NIEN)) &&
4357 (qc->flags & ATA_QCFLAG_ACTIVE))
4358 handled |= ata_host_intr(ap, qc);
4362 spin_unlock_irqrestore(&host_set->lock, flags);
4364 return IRQ_RETVAL(handled);
4369 * Execute a 'simple' command, that only consists of the opcode 'cmd' itself,
4370 * without filling any other registers
4372 static int ata_do_simple_cmd(struct ata_port *ap, struct ata_device *dev,
4375 struct ata_taskfile tf;
4378 ata_tf_init(ap, &tf, dev->devno);
4381 tf.flags |= ATA_TFLAG_DEVICE;
4382 tf.protocol = ATA_PROT_NODATA;
4384 err = ata_exec_internal(ap, dev, &tf, NULL, DMA_NONE, NULL, 0);
4386 printk(KERN_ERR "%s: ata command failed: %d\n",
4392 static int ata_flush_cache(struct ata_port *ap, struct ata_device *dev)
4396 if (!ata_try_flush_cache(dev))
4399 if (ata_id_has_flush_ext(dev->id))
4400 cmd = ATA_CMD_FLUSH_EXT;
4402 cmd = ATA_CMD_FLUSH;
4404 return ata_do_simple_cmd(ap, dev, cmd);
4407 static int ata_standby_drive(struct ata_port *ap, struct ata_device *dev)
4409 return ata_do_simple_cmd(ap, dev, ATA_CMD_STANDBYNOW1);
4412 static int ata_start_drive(struct ata_port *ap, struct ata_device *dev)
4414 return ata_do_simple_cmd(ap, dev, ATA_CMD_IDLEIMMEDIATE);
4418 * ata_device_resume - wakeup a previously suspended devices
4419 * @ap: port the device is connected to
4420 * @dev: the device to resume
4422 * Kick the drive back into action, by sending it an idle immediate
4423 * command and making sure its transfer mode matches between drive
4427 int ata_device_resume(struct ata_port *ap, struct ata_device *dev)
4429 if (ap->flags & ATA_FLAG_SUSPENDED) {
4430 struct ata_device *failed_dev;
4431 ap->flags &= ~ATA_FLAG_SUSPENDED;
4432 while (ata_set_mode(ap, &failed_dev))
4433 ata_dev_disable(ap, failed_dev);
4435 if (!ata_dev_enabled(dev))
4437 if (dev->class == ATA_DEV_ATA)
4438 ata_start_drive(ap, dev);
4444 * ata_device_suspend - prepare a device for suspend
4445 * @ap: port the device is connected to
4446 * @dev: the device to suspend
4448 * Flush the cache on the drive, if appropriate, then issue a
4449 * standbynow command.
4451 int ata_device_suspend(struct ata_port *ap, struct ata_device *dev, pm_message_t state)
4453 if (!ata_dev_enabled(dev))
4455 if (dev->class == ATA_DEV_ATA)
4456 ata_flush_cache(ap, dev);
4458 if (state.event != PM_EVENT_FREEZE)
4459 ata_standby_drive(ap, dev);
4460 ap->flags |= ATA_FLAG_SUSPENDED;
4465 * ata_port_start - Set port up for dma.
4466 * @ap: Port to initialize
4468 * Called just after data structures for each port are
4469 * initialized. Allocates space for PRD table.
4471 * May be used as the port_start() entry in ata_port_operations.
4474 * Inherited from caller.
4477 int ata_port_start (struct ata_port *ap)
4479 struct device *dev = ap->dev;
4482 ap->prd = dma_alloc_coherent(dev, ATA_PRD_TBL_SZ, &ap->prd_dma, GFP_KERNEL);
4486 rc = ata_pad_alloc(ap, dev);
4488 dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
4492 DPRINTK("prd alloc, virt %p, dma %llx\n", ap->prd, (unsigned long long) ap->prd_dma);
4499 * ata_port_stop - Undo ata_port_start()
4500 * @ap: Port to shut down
4502 * Frees the PRD table.
4504 * May be used as the port_stop() entry in ata_port_operations.
4507 * Inherited from caller.
4510 void ata_port_stop (struct ata_port *ap)
4512 struct device *dev = ap->dev;
4514 dma_free_coherent(dev, ATA_PRD_TBL_SZ, ap->prd, ap->prd_dma);
4515 ata_pad_free(ap, dev);
4518 void ata_host_stop (struct ata_host_set *host_set)
4520 if (host_set->mmio_base)
4521 iounmap(host_set->mmio_base);
4526 * ata_host_remove - Unregister SCSI host structure with upper layers
4527 * @ap: Port to unregister
4528 * @do_unregister: 1 if we fully unregister, 0 to just stop the port
4531 * Inherited from caller.
4534 static void ata_host_remove(struct ata_port *ap, unsigned int do_unregister)
4536 struct Scsi_Host *sh = ap->host;
4541 scsi_remove_host(sh);
4543 ap->ops->port_stop(ap);
4547 * ata_host_init - Initialize an ata_port structure
4548 * @ap: Structure to initialize
4549 * @host: associated SCSI mid-layer structure
4550 * @host_set: Collection of hosts to which @ap belongs
4551 * @ent: Probe information provided by low-level driver
4552 * @port_no: Port number associated with this ata_port
4554 * Initialize a new ata_port structure, and its associated
4558 * Inherited from caller.
4561 static void ata_host_init(struct ata_port *ap, struct Scsi_Host *host,
4562 struct ata_host_set *host_set,
4563 const struct ata_probe_ent *ent, unsigned int port_no)
4569 host->max_channel = 1;
4570 host->unique_id = ata_unique_id++;
4571 host->max_cmd_len = 12;
4573 ap->flags = ATA_FLAG_DISABLED;
4574 ap->id = host->unique_id;
4576 ap->ctl = ATA_DEVCTL_OBS;
4577 ap->host_set = host_set;
4579 ap->port_no = port_no;
4581 ent->legacy_mode ? ent->hard_port_no : port_no;
4582 ap->pio_mask = ent->pio_mask;
4583 ap->mwdma_mask = ent->mwdma_mask;
4584 ap->udma_mask = ent->udma_mask;
4585 ap->flags |= ent->host_flags;
4586 ap->ops = ent->port_ops;
4587 ap->cbl = ATA_CBL_NONE;
4588 ap->sata_spd_limit = UINT_MAX;
4589 ap->active_tag = ATA_TAG_POISON;
4590 ap->last_ctl = 0xFF;
4592 INIT_WORK(&ap->port_task, NULL, NULL);
4593 INIT_LIST_HEAD(&ap->eh_done_q);
4595 for (i = 0; i < ATA_MAX_DEVICES; i++) {
4596 struct ata_device *dev = &ap->device[i];
4598 dev->pio_mask = UINT_MAX;
4599 dev->mwdma_mask = UINT_MAX;
4600 dev->udma_mask = UINT_MAX;
4604 ap->stats.unhandled_irq = 1;
4605 ap->stats.idle_irq = 1;
4608 memcpy(&ap->ioaddr, &ent->port[port_no], sizeof(struct ata_ioports));
4612 * ata_host_add - Attach low-level ATA driver to system
4613 * @ent: Information provided by low-level driver
4614 * @host_set: Collections of ports to which we add
4615 * @port_no: Port number associated with this host
4617 * Attach low-level ATA driver to system.
4620 * PCI/etc. bus probe sem.
4623 * New ata_port on success, for NULL on error.
4626 static struct ata_port * ata_host_add(const struct ata_probe_ent *ent,
4627 struct ata_host_set *host_set,
4628 unsigned int port_no)
4630 struct Scsi_Host *host;
4631 struct ata_port *ap;
4636 if (!ent->port_ops->probe_reset &&
4637 !(ent->host_flags & (ATA_FLAG_SATA_RESET | ATA_FLAG_SRST))) {
4638 printk(KERN_ERR "ata%u: no reset mechanism available\n",
4643 host = scsi_host_alloc(ent->sht, sizeof(struct ata_port));
4647 host->transportt = &ata_scsi_transport_template;
4649 ap = ata_shost_to_port(host);
4651 ata_host_init(ap, host, host_set, ent, port_no);
4653 rc = ap->ops->port_start(ap);
4660 scsi_host_put(host);
4665 * ata_device_add - Register hardware device with ATA and SCSI layers
4666 * @ent: Probe information describing hardware device to be registered
4668 * This function processes the information provided in the probe
4669 * information struct @ent, allocates the necessary ATA and SCSI
4670 * host information structures, initializes them, and registers
4671 * everything with requisite kernel subsystems.
4673 * This function requests irqs, probes the ATA bus, and probes
4677 * PCI/etc. bus probe sem.
4680 * Number of ports registered. Zero on error (no ports registered).
4683 int ata_device_add(const struct ata_probe_ent *ent)
4685 unsigned int count = 0, i;
4686 struct device *dev = ent->dev;
4687 struct ata_host_set *host_set;
4690 /* alloc a container for our list of ATA ports (buses) */
4691 host_set = kzalloc(sizeof(struct ata_host_set) +
4692 (ent->n_ports * sizeof(void *)), GFP_KERNEL);
4695 spin_lock_init(&host_set->lock);
4697 host_set->dev = dev;
4698 host_set->n_ports = ent->n_ports;
4699 host_set->irq = ent->irq;
4700 host_set->mmio_base = ent->mmio_base;
4701 host_set->private_data = ent->private_data;
4702 host_set->ops = ent->port_ops;
4703 host_set->flags = ent->host_set_flags;
4705 /* register each port bound to this device */
4706 for (i = 0; i < ent->n_ports; i++) {
4707 struct ata_port *ap;
4708 unsigned long xfer_mode_mask;
4710 ap = ata_host_add(ent, host_set, i);
4714 host_set->ports[i] = ap;
4715 xfer_mode_mask =(ap->udma_mask << ATA_SHIFT_UDMA) |
4716 (ap->mwdma_mask << ATA_SHIFT_MWDMA) |
4717 (ap->pio_mask << ATA_SHIFT_PIO);
4719 /* print per-port info to dmesg */
4720 printk(KERN_INFO "ata%u: %cATA max %s cmd 0x%lX ctl 0x%lX "
4721 "bmdma 0x%lX irq %lu\n",
4723 ap->flags & ATA_FLAG_SATA ? 'S' : 'P',
4724 ata_mode_string(xfer_mode_mask),
4725 ap->ioaddr.cmd_addr,
4726 ap->ioaddr.ctl_addr,
4727 ap->ioaddr.bmdma_addr,
4731 host_set->ops->irq_clear(ap);
4738 /* obtain irq, that is shared between channels */
4739 if (request_irq(ent->irq, ent->port_ops->irq_handler, ent->irq_flags,
4740 DRV_NAME, host_set))
4743 /* perform each probe synchronously */
4744 DPRINTK("probe begin\n");
4745 for (i = 0; i < count; i++) {
4746 struct ata_port *ap;
4749 ap = host_set->ports[i];
4751 DPRINTK("ata%u: bus probe begin\n", ap->id);
4752 rc = ata_bus_probe(ap);
4753 DPRINTK("ata%u: bus probe end\n", ap->id);
4756 /* FIXME: do something useful here?
4757 * Current libata behavior will
4758 * tear down everything when
4759 * the module is removed
4760 * or the h/w is unplugged.
4764 rc = scsi_add_host(ap->host, dev);
4766 printk(KERN_ERR "ata%u: scsi_add_host failed\n",
4768 /* FIXME: do something useful here */
4769 /* FIXME: handle unconditional calls to
4770 * scsi_scan_host and ata_host_remove, below,
4776 /* probes are done, now scan each port's disk(s) */
4777 DPRINTK("host probe begin\n");
4778 for (i = 0; i < count; i++) {
4779 struct ata_port *ap = host_set->ports[i];
4781 ata_scsi_scan_host(ap);
4784 dev_set_drvdata(dev, host_set);
4786 VPRINTK("EXIT, returning %u\n", ent->n_ports);
4787 return ent->n_ports; /* success */
4790 for (i = 0; i < count; i++) {
4791 ata_host_remove(host_set->ports[i], 1);
4792 scsi_host_put(host_set->ports[i]->host);
4796 VPRINTK("EXIT, returning 0\n");
4801 * ata_host_set_remove - PCI layer callback for device removal
4802 * @host_set: ATA host set that was removed
4804 * Unregister all objects associated with this host set. Free those
4808 * Inherited from calling layer (may sleep).
4811 void ata_host_set_remove(struct ata_host_set *host_set)
4813 struct ata_port *ap;
4816 for (i = 0; i < host_set->n_ports; i++) {
4817 ap = host_set->ports[i];
4818 scsi_remove_host(ap->host);
4821 free_irq(host_set->irq, host_set);
4823 for (i = 0; i < host_set->n_ports; i++) {
4824 ap = host_set->ports[i];
4826 ata_scsi_release(ap->host);
4828 if ((ap->flags & ATA_FLAG_NO_LEGACY) == 0) {
4829 struct ata_ioports *ioaddr = &ap->ioaddr;
4831 if (ioaddr->cmd_addr == 0x1f0)
4832 release_region(0x1f0, 8);
4833 else if (ioaddr->cmd_addr == 0x170)
4834 release_region(0x170, 8);
4837 scsi_host_put(ap->host);
4840 if (host_set->ops->host_stop)
4841 host_set->ops->host_stop(host_set);
4847 * ata_scsi_release - SCSI layer callback hook for host unload
4848 * @host: libata host to be unloaded
4850 * Performs all duties necessary to shut down a libata port...
4851 * Kill port kthread, disable port, and release resources.
4854 * Inherited from SCSI layer.
4860 int ata_scsi_release(struct Scsi_Host *host)
4862 struct ata_port *ap = ata_shost_to_port(host);
4866 ap->ops->port_disable(ap);
4867 ata_host_remove(ap, 0);
4874 * ata_std_ports - initialize ioaddr with standard port offsets.
4875 * @ioaddr: IO address structure to be initialized
4877 * Utility function which initializes data_addr, error_addr,
4878 * feature_addr, nsect_addr, lbal_addr, lbam_addr, lbah_addr,
4879 * device_addr, status_addr, and command_addr to standard offsets
4880 * relative to cmd_addr.
4882 * Does not set ctl_addr, altstatus_addr, bmdma_addr, or scr_addr.
4885 void ata_std_ports(struct ata_ioports *ioaddr)
4887 ioaddr->data_addr = ioaddr->cmd_addr + ATA_REG_DATA;
4888 ioaddr->error_addr = ioaddr->cmd_addr + ATA_REG_ERR;
4889 ioaddr->feature_addr = ioaddr->cmd_addr + ATA_REG_FEATURE;
4890 ioaddr->nsect_addr = ioaddr->cmd_addr + ATA_REG_NSECT;
4891 ioaddr->lbal_addr = ioaddr->cmd_addr + ATA_REG_LBAL;
4892 ioaddr->lbam_addr = ioaddr->cmd_addr + ATA_REG_LBAM;
4893 ioaddr->lbah_addr = ioaddr->cmd_addr + ATA_REG_LBAH;
4894 ioaddr->device_addr = ioaddr->cmd_addr + ATA_REG_DEVICE;
4895 ioaddr->status_addr = ioaddr->cmd_addr + ATA_REG_STATUS;
4896 ioaddr->command_addr = ioaddr->cmd_addr + ATA_REG_CMD;
4902 void ata_pci_host_stop (struct ata_host_set *host_set)
4904 struct pci_dev *pdev = to_pci_dev(host_set->dev);
4906 pci_iounmap(pdev, host_set->mmio_base);
4910 * ata_pci_remove_one - PCI layer callback for device removal
4911 * @pdev: PCI device that was removed
4913 * PCI layer indicates to libata via this hook that
4914 * hot-unplug or module unload event has occurred.
4915 * Handle this by unregistering all objects associated
4916 * with this PCI device. Free those objects. Then finally
4917 * release PCI resources and disable device.
4920 * Inherited from PCI layer (may sleep).
4923 void ata_pci_remove_one (struct pci_dev *pdev)
4925 struct device *dev = pci_dev_to_dev(pdev);
4926 struct ata_host_set *host_set = dev_get_drvdata(dev);
4928 ata_host_set_remove(host_set);
4929 pci_release_regions(pdev);
4930 pci_disable_device(pdev);
4931 dev_set_drvdata(dev, NULL);
4934 /* move to PCI subsystem */
4935 int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits)
4937 unsigned long tmp = 0;
4939 switch (bits->width) {
4942 pci_read_config_byte(pdev, bits->reg, &tmp8);
4948 pci_read_config_word(pdev, bits->reg, &tmp16);
4954 pci_read_config_dword(pdev, bits->reg, &tmp32);
4965 return (tmp == bits->val) ? 1 : 0;
4968 int ata_pci_device_suspend(struct pci_dev *pdev, pm_message_t state)
4970 pci_save_state(pdev);
4971 pci_disable_device(pdev);
4972 pci_set_power_state(pdev, PCI_D3hot);
4976 int ata_pci_device_resume(struct pci_dev *pdev)
4978 pci_set_power_state(pdev, PCI_D0);
4979 pci_restore_state(pdev);
4980 pci_enable_device(pdev);
4981 pci_set_master(pdev);
4984 #endif /* CONFIG_PCI */
4987 static int __init ata_init(void)
4989 ata_wq = create_workqueue("ata");
4993 printk(KERN_DEBUG "libata version " DRV_VERSION " loaded.\n");
4997 static void __exit ata_exit(void)
4999 destroy_workqueue(ata_wq);
5002 module_init(ata_init);
5003 module_exit(ata_exit);
5005 static unsigned long ratelimit_time;
5006 static spinlock_t ata_ratelimit_lock = SPIN_LOCK_UNLOCKED;
5008 int ata_ratelimit(void)
5011 unsigned long flags;
5013 spin_lock_irqsave(&ata_ratelimit_lock, flags);
5015 if (time_after(jiffies, ratelimit_time)) {
5017 ratelimit_time = jiffies + (HZ/5);
5021 spin_unlock_irqrestore(&ata_ratelimit_lock, flags);
5027 * ata_wait_register - wait until register value changes
5028 * @reg: IO-mapped register
5029 * @mask: Mask to apply to read register value
5030 * @val: Wait condition
5031 * @interval_msec: polling interval in milliseconds
5032 * @timeout_msec: timeout in milliseconds
5034 * Waiting for some bits of register to change is a common
5035 * operation for ATA controllers. This function reads 32bit LE
5036 * IO-mapped register @reg and tests for the following condition.
5038 * (*@reg & mask) != val
5040 * If the condition is met, it returns; otherwise, the process is
5041 * repeated after @interval_msec until timeout.
5044 * Kernel thread context (may sleep)
5047 * The final register value.
5049 u32 ata_wait_register(void __iomem *reg, u32 mask, u32 val,
5050 unsigned long interval_msec,
5051 unsigned long timeout_msec)
5053 unsigned long timeout;
5056 tmp = ioread32(reg);
5058 /* Calculate timeout _after_ the first read to make sure
5059 * preceding writes reach the controller before starting to
5060 * eat away the timeout.
5062 timeout = jiffies + (timeout_msec * HZ) / 1000;
5064 while ((tmp & mask) == val && time_before(jiffies, timeout)) {
5065 msleep(interval_msec);
5066 tmp = ioread32(reg);
5073 * libata is essentially a library of internal helper functions for
5074 * low-level ATA host controller drivers. As such, the API/ABI is
5075 * likely to change as new drivers are added and updated.
5076 * Do not depend on ABI/API stability.
5079 EXPORT_SYMBOL_GPL(ata_std_bios_param);
5080 EXPORT_SYMBOL_GPL(ata_std_ports);
5081 EXPORT_SYMBOL_GPL(ata_device_add);
5082 EXPORT_SYMBOL_GPL(ata_host_set_remove);
5083 EXPORT_SYMBOL_GPL(ata_sg_init);
5084 EXPORT_SYMBOL_GPL(ata_sg_init_one);
5085 EXPORT_SYMBOL_GPL(__ata_qc_complete);
5086 EXPORT_SYMBOL_GPL(ata_qc_issue_prot);
5087 EXPORT_SYMBOL_GPL(ata_tf_load);
5088 EXPORT_SYMBOL_GPL(ata_tf_read);
5089 EXPORT_SYMBOL_GPL(ata_noop_dev_select);
5090 EXPORT_SYMBOL_GPL(ata_std_dev_select);
5091 EXPORT_SYMBOL_GPL(ata_tf_to_fis);
5092 EXPORT_SYMBOL_GPL(ata_tf_from_fis);
5093 EXPORT_SYMBOL_GPL(ata_check_status);
5094 EXPORT_SYMBOL_GPL(ata_altstatus);
5095 EXPORT_SYMBOL_GPL(ata_exec_command);
5096 EXPORT_SYMBOL_GPL(ata_port_start);
5097 EXPORT_SYMBOL_GPL(ata_port_stop);
5098 EXPORT_SYMBOL_GPL(ata_host_stop);
5099 EXPORT_SYMBOL_GPL(ata_interrupt);
5100 EXPORT_SYMBOL_GPL(ata_qc_prep);
5101 EXPORT_SYMBOL_GPL(ata_noop_qc_prep);
5102 EXPORT_SYMBOL_GPL(ata_bmdma_setup);
5103 EXPORT_SYMBOL_GPL(ata_bmdma_start);
5104 EXPORT_SYMBOL_GPL(ata_bmdma_irq_clear);
5105 EXPORT_SYMBOL_GPL(ata_bmdma_status);
5106 EXPORT_SYMBOL_GPL(ata_bmdma_stop);
5107 EXPORT_SYMBOL_GPL(ata_port_probe);
5108 EXPORT_SYMBOL_GPL(sata_set_spd);
5109 EXPORT_SYMBOL_GPL(sata_phy_reset);
5110 EXPORT_SYMBOL_GPL(__sata_phy_reset);
5111 EXPORT_SYMBOL_GPL(ata_bus_reset);
5112 EXPORT_SYMBOL_GPL(ata_std_probeinit);
5113 EXPORT_SYMBOL_GPL(ata_std_softreset);
5114 EXPORT_SYMBOL_GPL(sata_std_hardreset);
5115 EXPORT_SYMBOL_GPL(ata_std_postreset);
5116 EXPORT_SYMBOL_GPL(ata_std_probe_reset);
5117 EXPORT_SYMBOL_GPL(ata_drive_probe_reset);
5118 EXPORT_SYMBOL_GPL(ata_dev_revalidate);
5119 EXPORT_SYMBOL_GPL(ata_dev_classify);
5120 EXPORT_SYMBOL_GPL(ata_dev_pair);
5121 EXPORT_SYMBOL_GPL(ata_port_disable);
5122 EXPORT_SYMBOL_GPL(ata_ratelimit);
5123 EXPORT_SYMBOL_GPL(ata_wait_register);
5124 EXPORT_SYMBOL_GPL(ata_busy_sleep);
5125 EXPORT_SYMBOL_GPL(ata_port_queue_task);
5126 EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
5127 EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
5128 EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
5129 EXPORT_SYMBOL_GPL(ata_scsi_release);
5130 EXPORT_SYMBOL_GPL(ata_host_intr);
5131 EXPORT_SYMBOL_GPL(ata_id_string);
5132 EXPORT_SYMBOL_GPL(ata_id_c_string);
5133 EXPORT_SYMBOL_GPL(ata_scsi_simulate);
5135 EXPORT_SYMBOL_GPL(ata_pio_need_iordy);
5136 EXPORT_SYMBOL_GPL(ata_timing_compute);
5137 EXPORT_SYMBOL_GPL(ata_timing_merge);
5140 EXPORT_SYMBOL_GPL(pci_test_config_bits);
5141 EXPORT_SYMBOL_GPL(ata_pci_host_stop);
5142 EXPORT_SYMBOL_GPL(ata_pci_init_native_mode);
5143 EXPORT_SYMBOL_GPL(ata_pci_init_one);
5144 EXPORT_SYMBOL_GPL(ata_pci_remove_one);
5145 EXPORT_SYMBOL_GPL(ata_pci_device_suspend);
5146 EXPORT_SYMBOL_GPL(ata_pci_device_resume);
5147 EXPORT_SYMBOL_GPL(ata_pci_default_filter);
5148 EXPORT_SYMBOL_GPL(ata_pci_clear_simplex);
5149 #endif /* CONFIG_PCI */
5151 EXPORT_SYMBOL_GPL(ata_device_suspend);
5152 EXPORT_SYMBOL_GPL(ata_device_resume);
5153 EXPORT_SYMBOL_GPL(ata_scsi_device_suspend);
5154 EXPORT_SYMBOL_GPL(ata_scsi_device_resume);
5156 EXPORT_SYMBOL_GPL(ata_eng_timeout);
5157 EXPORT_SYMBOL_GPL(ata_eh_qc_complete);
5158 EXPORT_SYMBOL_GPL(ata_eh_qc_retry);